entry : fxRelations.entrySet()) {
+ UUID targetId = parseUUID(entry.getKey());
+ if (targetId == null) continue;
+
+ RelationType type = switch (entry.getValue().toLowerCase()) {
+ case "ally" -> RelationType.ALLY;
+ case "enemy" -> RelationType.ENEMY;
+ default -> RelationType.NEUTRAL;
+ };
+
+ if (type != RelationType.NEUTRAL) {
+ relations.put(targetId, FactionRelation.create(targetId, type));
+ }
+ }
+
+ return relations;
+ }
+
+ /**
+ * Converts FactionsX per-role permissions (Build, Claim, Interact, Invite, Kick)
+ * to HyperFactions territory permission flags.
+ *
+ * FactionsX permissions control what each role can do within faction territory.
+ * We map "Build" to Break+Place, "Interact" to Interact, and leave other flags as defaults.
+ * The outsider/ally equivalent permissions are not stored in FactionsX, so we use defaults.
+ */
+ @Nullable
+ private FactionPermissions convertPermissions(
+ @Nullable Map> fxPermissions) {
+ if (fxPermissions == null || fxPermissions.isEmpty()) {
+ return null; // Use default permissions
+ }
+
+ Map flags = new HashMap<>();
+
+ // Map MEMBER role permissions
+ Map memberPerms = fxPermissions.getOrDefault("MEMBER", Map.of());
+ boolean memberBuild = memberPerms.getOrDefault("Build", true);
+ boolean memberInteract = memberPerms.getOrDefault("Interact", true);
+ flags.put(FactionPermissions.MEMBER_BREAK, memberBuild);
+ flags.put(FactionPermissions.MEMBER_PLACE, memberBuild);
+ flags.put(FactionPermissions.MEMBER_INTERACT, memberInteract);
+
+ // Map OFFICER role permissions (FactionsX OFFICER maps to HyperFactions officer level)
+ Map officerPerms = fxPermissions.getOrDefault("OFFICER", Map.of());
+ boolean officerBuild = officerPerms.getOrDefault("Build", true);
+ boolean officerInteract = officerPerms.getOrDefault("Interact", true);
+ flags.put(FactionPermissions.OFFICER_BREAK, officerBuild);
+ flags.put(FactionPermissions.OFFICER_PLACE, officerBuild);
+ flags.put(FactionPermissions.OFFICER_INTERACT, officerInteract);
+
+ // Officers can edit permissions if they have Kick permission
+ boolean officersCanEdit = officerPerms.getOrDefault("Kick", false);
+ flags.put(FactionPermissions.OFFICERS_CAN_EDIT, officersCanEdit);
+
+ // Constructor fills in remaining flags from defaults
+ return new FactionPermissions(flags);
+ }
+
+ /**
+ * Distributes power using individual player power values from FactionsX player files,
+ * rather than even-splitting a faction total.
+ */
+ private void distributePlayerPower(Faction faction, ImportResult.Builder result) {
+ int membersWithPower = 0;
+
+ for (UUID memberUuid : faction.members().keySet()) {
+ int power = powerCache.getOrDefault(memberUuid, 0);
+ int maxPower = maxPowerCache.getOrDefault(memberUuid, 0);
+
+ if (power <= 0 && maxPower <= 0) continue;
+
+ double maxAllowed = ConfigManager.get().getMaxPlayerPower();
+ double effectivePower = Math.min(power, maxAllowed);
+ double effectiveMax = Math.min(maxPower, maxAllowed);
+
+ if (!dryRun) {
+ PlayerPower playerPower = PlayerPower.create(memberUuid, effectivePower, effectiveMax);
+ // PowerManager will handle this via its API
+ }
+ membersWithPower++;
+ }
+
+ if (membersWithPower > 0) {
+ progress(" - Set power for %d members from individual FactionsX data", membersWithPower);
+ result.addPlayersWithPower(membersWithPower);
+ }
+ }
+
+ /**
+ * Handles players who are already in existing HyperFactions factions.
+ * Removes them from their current faction, and disbands the faction if it becomes empty.
+ */
+ private int handleExistingMemberships(Faction importedFaction, ImportResult.Builder result) {
+ int playersRemoved = 0;
+ Set factionsToCheck = new HashSet<>();
+
+ for (UUID memberUuid : importedFaction.members().keySet()) {
+ Faction existingFaction = factionManager.getPlayerFaction(memberUuid);
+
+ if (existingFaction == null || existingFaction.id().equals(importedFaction.id())) {
+ continue;
+ }
+
+ FactionMember existingMember = existingFaction.getMember(memberUuid);
+ String playerName = existingMember != null ? existingMember.username() : "Unknown";
+
+ progress(" - Player %s is already in faction '%s', removing...",
+ playerName, existingFaction.name());
+
+ if (!dryRun) {
+ Faction updatedExisting = existingFaction.withoutMember(memberUuid)
+ .withLog(FactionLog.create(
+ FactionLog.LogType.MEMBER_LEAVE,
+ playerName + " left (imported to another faction)",
+ null
+ ));
+
+ factionManager.removePlayerFromIndex(memberUuid);
+
+ if (updatedExisting.getMemberCount() == 0) {
+ progress(" - Faction '%s' is now empty, will be disbanded...", existingFaction.name());
+ factionsToCheck.add(existingFaction.id());
+ factionManager.updateFaction(updatedExisting);
+ } else {
+ if (existingMember != null && existingMember.isLeader()) {
+ FactionMember successor = updatedExisting.findSuccessor();
+ if (successor != null) {
+ FactionMember promoted = successor.withRole(FactionRole.LEADER);
+ updatedExisting = updatedExisting.withMember(promoted)
+ .withLog(FactionLog.create(
+ FactionLog.LogType.LEADER_TRANSFER,
+ promoted.username() + " became leader (previous leader imported to another faction)",
+ null
+ ));
+ progress(" - %s promoted to leader of '%s'",
+ promoted.username(), existingFaction.name());
+ }
+ }
+ factionManager.updateFaction(updatedExisting);
+ }
+ }
+
+ playersRemoved++;
+ result.warning(String.format("Player %s removed from faction '%s' (imported to another faction)",
+ playerName, existingFaction.name()));
+ }
+
+ if (!dryRun) {
+ for (UUID factionId : factionsToCheck) {
+ Faction faction = factionManager.getFaction(factionId);
+ if (faction != null && faction.getMemberCount() == 0) {
+ disbandEmptyFaction(faction, result);
+ }
+ }
+ }
+
+ return playersRemoved;
+ }
+
+ private void disbandEmptyFaction(Faction faction, ImportResult.Builder result) {
+ progress(" - Disbanding empty faction '%s'", faction.name());
+
+ FactionManager.FactionResult disbandResult = factionManager.forceDisband(
+ faction.id(),
+ "All members imported to other factions"
+ );
+
+ if (disbandResult == FactionManager.FactionResult.SUCCESS) {
+ result.warning(String.format("Faction '%s' disbanded (all members imported elsewhere)", faction.name()));
+ } else {
+ result.warning(String.format("Failed to disband faction '%s': %s", faction.name(), disbandResult));
+ }
+ }
+
+ // === Zone Processing ===
+
+ private void processZones(List chunks, ZoneType type, String namePrefix,
+ ImportResult.Builder result) {
+ if (chunks.isEmpty()) {
+ return;
+ }
+
+ Map> byDimension = chunks.stream()
+ .collect(Collectors.groupingBy(FxZoneChunk::dimension));
+
+ int zoneCount = 0;
+ List> futures = new ArrayList<>();
+
+ for (Map.Entry> entry : byDimension.entrySet()) {
+ String dimension = entry.getKey();
+ List dimChunks = entry.getValue();
+
+ List> clusters = clusterChunks(dimension, dimChunks);
+
+ for (Set cluster : clusters) {
+ zoneCount++;
+ String zoneName = namePrefix + "-" + zoneCount;
+
+ progress(" Creating %s with %d chunks in %s", zoneName, cluster.size(), dimension);
+
+ if (!dryRun) {
+ Map defaultFlags = ZoneFlags.getDefaultFlags(type);
+ CompletableFuture future = zoneManager.createZoneWithChunks(
+ zoneName, type, dimension, UUID.randomUUID(), cluster, defaultFlags
+ ).thenApply(zoneResult -> {
+ if (zoneResult == ZoneManager.ZoneResult.SUCCESS) {
+ result.incrementZonesCreated();
+ } else {
+ result.warning(String.format("Failed to create zone %s: %s", zoneName, zoneResult));
+ }
+ return zoneResult;
+ });
+ futures.add(future);
+ } else {
+ result.incrementZonesCreated();
+ }
+ }
+ }
+
+ if (!dryRun && !futures.isEmpty()) {
+ try {
+ CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
+ progress(" All %d zones created successfully", futures.size());
+ } catch (Exception e) {
+ result.warning("Error waiting for zone creation: " + e.getMessage());
+ }
+ }
+ }
+
+ /**
+ * Clusters adjacent chunks into connected groups using BFS flood-fill.
+ */
+ private List> clusterChunks(String dimension, List chunks) {
+ Set remaining = chunks.stream()
+ .map(c -> new ChunkKey(dimension, c.chunkX(), c.chunkZ()))
+ .collect(Collectors.toSet());
+
+ List> clusters = new ArrayList<>();
+
+ while (!remaining.isEmpty()) {
+ ChunkKey start = remaining.iterator().next();
+ Set cluster = new HashSet<>();
+ Queue queue = new LinkedList<>();
+
+ queue.add(start);
+ remaining.remove(start);
+
+ while (!queue.isEmpty()) {
+ ChunkKey current = queue.poll();
+ cluster.add(current);
+
+ for (ChunkKey adjacent : getAdjacent(current)) {
+ if (remaining.contains(adjacent)) {
+ remaining.remove(adjacent);
+ queue.add(adjacent);
+ }
+ }
+ }
+
+ clusters.add(cluster);
+ }
+
+ return clusters;
+ }
+
+ private List getAdjacent(ChunkKey key) {
+ return List.of(
+ new ChunkKey(key.world(), key.chunkX() + 1, key.chunkZ()),
+ new ChunkKey(key.world(), key.chunkX() - 1, key.chunkZ()),
+ new ChunkKey(key.world(), key.chunkX(), key.chunkZ() + 1),
+ new ChunkKey(key.world(), key.chunkX(), key.chunkZ() - 1)
+ );
+ }
+
+ // === Utility Methods ===
+
+ /**
+ * Converts an RGB integer color to a hex string.
+ */
+ private String convertColor(int rgb) {
+ return String.format("#%02X%02X%02X", (rgb >> 16) & 0xFF, (rgb >> 8) & 0xFF, rgb & 0xFF);
+ }
+
+ @NotNull
+ private String getRandomColor() {
+ // Exclude black (0) and white (f) as they're hard to see
+ String[] colors = {"#0000AA", "#00AA00", "#00AAAA", "#AA0000", "#AA00AA",
+ "#FFAA00", "#5555FF", "#55FF55", "#55FFFF", "#FF5555", "#FF55FF", "#FFFF55"};
+ return colors[new Random().nextInt(colors.length)];
+ }
+
+ @Nullable
+ private UUID parseUUID(@Nullable String uuidStr) {
+ if (uuidStr == null || uuidStr.isEmpty()) {
+ return null;
+ }
+ try {
+ return UUID.fromString(uuidStr);
+ } catch (IllegalArgumentException e) {
+ return null;
+ }
+ }
+
+ private void progress(String format, Object... args) {
+ String message = String.format(format, args);
+ Logger.info("[FactionsXImport] " + message);
+ if (progressCallback != null) {
+ progressCallback.accept(message);
+ }
+ }
+}
diff --git a/src/main/java/com/hyperfactions/importer/HyFactionsImporter.java b/src/main/java/com/hyperfactions/importer/HyFactionsImporter.java
index c514871..cabe607 100644
--- a/src/main/java/com/hyperfactions/importer/HyFactionsImporter.java
+++ b/src/main/java/com/hyperfactions/importer/HyFactionsImporter.java
@@ -522,6 +522,16 @@ private List loadWarZonesForValidation(File configDir, Impor
public ImportResult importFrom(@NotNull Path sourcePath) {
ImportResult.Builder result = ImportResult.builder().dryRun(dryRun);
+ // Check other importers aren't running
+ if (ElbaphFactionsImporter.isImportInProgress()) {
+ result.error("An ElbaphFactions import is already in progress. Please wait for it to complete.");
+ return result.build();
+ }
+ if (FactionsXImporter.isImportInProgress()) {
+ result.error("A FactionsX import is already in progress. Please wait for it to complete.");
+ return result.build();
+ }
+
// Thread safety: prevent concurrent imports
if (!importLock.tryLock()) {
result.error("Another import is already in progress. Please wait for it to complete.");
diff --git a/src/main/java/com/hyperfactions/importer/factionsx/FxChunkInfo.java b/src/main/java/com/hyperfactions/importer/factionsx/FxChunkInfo.java
new file mode 100644
index 0000000..3fc562f
--- /dev/null
+++ b/src/main/java/com/hyperfactions/importer/factionsx/FxChunkInfo.java
@@ -0,0 +1,22 @@
+package com.hyperfactions.importer.factionsx;
+
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Gson-mapped record for a chunk claim entry in FactionsX Claims.json.
+ *
+ * Note: FactionsX stores the Z coordinate under the key "ChunkY" — this is a naming
+ * bug inherited from HyFactions. Use {@link #getChunkZ()} for the actual Z coordinate.
+ */
+public record FxChunkInfo(
+ @Nullable String UUID,
+ int ChunkX,
+ int ChunkY,
+ @Nullable FxTracker CreatedTracker
+) {
+
+ /** Returns the actual chunk Z coordinate (stored as ChunkY in FactionsX data). */
+ public int getChunkZ() {
+ return ChunkY;
+ }
+}
diff --git a/src/main/java/com/hyperfactions/importer/factionsx/FxClaims.java b/src/main/java/com/hyperfactions/importer/factionsx/FxClaims.java
new file mode 100644
index 0000000..fe4468a
--- /dev/null
+++ b/src/main/java/com/hyperfactions/importer/factionsx/FxClaims.java
@@ -0,0 +1,11 @@
+package com.hyperfactions.importer.factionsx;
+
+import java.util.List;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Gson-mapped record for FactionsX Claims.json root object.
+ */
+public record FxClaims(
+ @Nullable List Dimensions
+) {}
diff --git a/src/main/java/com/hyperfactions/importer/factionsx/FxDimension.java b/src/main/java/com/hyperfactions/importer/factionsx/FxDimension.java
new file mode 100644
index 0000000..002c4ba
--- /dev/null
+++ b/src/main/java/com/hyperfactions/importer/factionsx/FxDimension.java
@@ -0,0 +1,12 @@
+package com.hyperfactions.importer.factionsx;
+
+import java.util.List;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Gson-mapped record for a dimension entry within FactionsX Claims.json.
+ */
+public record FxDimension(
+ @Nullable String Dimension,
+ @Nullable List ChunkInfo
+) {}
diff --git a/src/main/java/com/hyperfactions/importer/factionsx/FxFaction.java b/src/main/java/com/hyperfactions/importer/factionsx/FxFaction.java
new file mode 100644
index 0000000..f70dac5
--- /dev/null
+++ b/src/main/java/com/hyperfactions/importer/factionsx/FxFaction.java
@@ -0,0 +1,47 @@
+package com.hyperfactions.importer.factionsx;
+
+import java.util.Map;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Gson-mapped record for FactionsX per-faction JSON files ({@code config/factions/{UUID}.json}).
+ *
+ * Key quirk: the {@code Members} map does NOT include the faction owner.
+ * The owner is always LEADER and stored separately in the {@code Owner} field.
+ */
+public record FxFaction(
+ @Nullable String Id,
+ @Nullable String Owner,
+ @Nullable String Name,
+ int Color,
+ @Nullable String Description,
+ @Nullable FxTracker CreatedTracker,
+ @Nullable FxTracker ModifiedTracker,
+ @Nullable String HomeDimension,
+ double HomeX,
+ double HomeY,
+ double HomeZ,
+ float HomeYaw,
+ float HomePitch,
+ @Nullable Map Members,
+ @Nullable Map Relations,
+ @Nullable Map> Permissions
+) {
+
+ /** Returns true if the faction has a home set. */
+ public boolean hasHome() {
+ return HomeDimension != null && !HomeDimension.isEmpty();
+ }
+
+ /**
+ * Returns the total member count including the owner.
+ * The owner is NOT in the Members map, so we add 1 if Owner is present.
+ */
+ public int getMemberCount() {
+ int count = Members != null ? Members.size() : 0;
+ if (Owner != null && !Owner.isEmpty()) {
+ count++;
+ }
+ return count;
+ }
+}
diff --git a/src/main/java/com/hyperfactions/importer/factionsx/FxPlayer.java b/src/main/java/com/hyperfactions/importer/factionsx/FxPlayer.java
new file mode 100644
index 0000000..1080512
--- /dev/null
+++ b/src/main/java/com/hyperfactions/importer/factionsx/FxPlayer.java
@@ -0,0 +1,18 @@
+package com.hyperfactions.importer.factionsx;
+
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Gson-mapped record for FactionsX per-player JSON files ({@code config/players/{UUID}.json}).
+ *
+ * Power is per-player (not per-faction). FactionId/FactionRole may be null if the player
+ * is not in a faction.
+ */
+public record FxPlayer(
+ @Nullable String Uuid,
+ @Nullable String LastKnownName,
+ @Nullable String FactionId,
+ @Nullable String FactionRole,
+ int Power,
+ int MaxPower
+) {}
diff --git a/src/main/java/com/hyperfactions/importer/factionsx/FxTracker.java b/src/main/java/com/hyperfactions/importer/factionsx/FxTracker.java
new file mode 100644
index 0000000..4b67071
--- /dev/null
+++ b/src/main/java/com/hyperfactions/importer/factionsx/FxTracker.java
@@ -0,0 +1,42 @@
+package com.hyperfactions.importer.factionsx;
+
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeParseException;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Gson-mapped record for FactionsX tracker objects (CreatedTracker / ModifiedTracker).
+ * Date is a LocalDateTime ISO-8601 string (e.g. "2026-01-22T22:17:02.563322051").
+ */
+public record FxTracker(
+ @Nullable String UserUUID,
+ @Nullable String UserName,
+ @Nullable String Date
+) {
+
+ /**
+ * Parses the ISO-8601 date string to epoch milliseconds.
+ * Falls back to current time if parsing fails.
+ */
+ public long toEpochMillis() {
+ if (Date == null || Date.isEmpty()) {
+ return System.currentTimeMillis();
+ }
+
+ try {
+ // FactionsX uses LocalDateTime.now().toString() which produces ISO-8601 without zone
+ LocalDateTime ldt = LocalDateTime.parse(Date, DateTimeFormatter.ISO_LOCAL_DATE_TIME);
+ return ldt.toInstant(ZoneOffset.UTC).toEpochMilli();
+ } catch (DateTimeParseException e) {
+ // Try ISO instant format as fallback
+ try {
+ return Instant.parse(Date).toEpochMilli();
+ } catch (DateTimeParseException e2) {
+ return System.currentTimeMillis();
+ }
+ }
+ }
+}
diff --git a/src/main/java/com/hyperfactions/importer/factionsx/FxZoneChunk.java b/src/main/java/com/hyperfactions/importer/factionsx/FxZoneChunk.java
new file mode 100644
index 0000000..2e92313
--- /dev/null
+++ b/src/main/java/com/hyperfactions/importer/factionsx/FxZoneChunk.java
@@ -0,0 +1,13 @@
+package com.hyperfactions.importer.factionsx;
+
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Parsed zone chunk record (not a direct JSON mapping).
+ * Created by splitting the {@code "chunkX:chunkZ"} strings from FactionsX Zones.json.
+ */
+public record FxZoneChunk(
+ @NotNull String dimension,
+ int chunkX,
+ int chunkZ
+) {}
diff --git a/src/main/java/com/hyperfactions/importer/factionsx/FxZones.java b/src/main/java/com/hyperfactions/importer/factionsx/FxZones.java
new file mode 100644
index 0000000..902fea0
--- /dev/null
+++ b/src/main/java/com/hyperfactions/importer/factionsx/FxZones.java
@@ -0,0 +1,16 @@
+package com.hyperfactions.importer.factionsx;
+
+import java.util.List;
+import java.util.Map;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Gson-mapped record for FactionsX Zones.json root object.
+ *
+ *
Zone chunks are stored as {@code "chunkX:chunkZ"} strings grouped by dimension name.
+ * Keys are "Safezone" and "Warzone" (singular, matching FactionsX source).
+ */
+public record FxZones(
+ @Nullable Map> Safezone,
+ @Nullable Map> Warzone
+) {}