@neuroverseos/governance 0.4.3 → 0.5.1

package/dist/{chunk-GTPV2XGO.js → chunk-GJ6LM4JZ.js}

@@ -1,14 +1,3 @@
-import {
-  buildEngineOptions,
-  trackPlanProgress
-} from "./chunk-5U2MQO5P.js";
-import {
-  evaluateGuard
-} from "./chunk-ZAF6JH23.js";
-import {
-  loadWorld
-} from "./chunk-I4RTIMLX.js";
-
 // src/worlds/mentraos-intent-taxonomy.ts
 var MENTRA_INTENT_TAXONOMY = [
   // ── Camera Domain ───────────────────────────────────────────────────────
@@ -447,430 +436,6 @@ function isAIIntent(intent) {
   return def ? def.domain === "ai_data" || def.domain === "ai_action" : false;
 }
 
-// src/adapters/mentraos.ts
-var DEFAULT_USER_RULES = {
-  aiDataPolicy: "declared_only",
-  aiActionPolicy: "confirm_all",
-  aiPurchasePolicy: "confirm_each",
-  aiMessagingPolicy: "confirm_each",
-  dataRetentionPolicy: "app_declared",
-  maxAIProviders: 5
-};
-function evaluateUserRules(intent, rules, appContext) {
-  const def = getMentraIntent(intent);
-  if (!def) return null;
-  if (def.domain === "ai_data" && intent !== "ai_retain_session_data") {
-    if (rules.aiDataPolicy === "block_all") {
-      return {
-        verdict: {
-          status: "BLOCK",
-          ruleId: "user-rule-ai-data-block",
-          reason: `User rules block all AI data sends. Intent: ${intent}`,
-          evidence: makeEvidence("user-rule-ai-data-block")
-        },
-        reason: "User has blocked all AI data sends"
-      };
-    }
-    if (rules.aiDataPolicy === "confirm_each") {
-      return {
-        verdict: {
-          status: "PAUSE",
-          ruleId: "user-rule-ai-data-confirm",
-          reason: `User rules require confirmation for every AI data send. Intent: ${intent}`,
-          evidence: makeEvidence("user-rule-ai-data-confirm")
-        },
-        reason: "User requires confirmation for each AI data send"
-      };
-    }
-    if (!appContext.aiProviderDeclared) {
-      return {
-        verdict: {
-          status: "BLOCK",
-          ruleId: "user-rule-undeclared-provider",
-          reason: `App "${appContext.appId}" has not declared its AI provider. User rules require declared providers only.`,
-          evidence: makeEvidence("user-rule-undeclared-provider")
-        },
-        reason: "App has not declared its AI provider"
-      };
-    }
-  }
-  if (intent === "ai_retain_session_data") {
-    if (rules.dataRetentionPolicy === "never") {
-      return {
-        verdict: {
-          status: "BLOCK",
-          ruleId: "user-rule-no-retention",
-          reason: `User rules block all data retention. App "${appContext.appId}" cannot retain session data.`,
-          evidence: makeEvidence("user-rule-no-retention")
-        },
-        reason: "User has blocked all data retention"
-      };
-    }
-    if (!appContext.dataRetentionOptedIn) {
-      return {
-        verdict: {
-          status: "BLOCK",
-          ruleId: "user-rule-retention-no-optin",
-          reason: `User has not opted in to data retention for app "${appContext.appId}".`,
-          evidence: makeEvidence("user-rule-retention-no-optin")
-        },
-        reason: "User has not opted in to data retention for this app"
-      };
-    }
-  }
-  if (intent === "ai_auto_purchase") {
-    if (rules.aiPurchasePolicy === "block_all") {
-      return {
-        verdict: {
-          status: "BLOCK",
-          ruleId: "user-rule-no-purchases",
-          reason: "User rules block all AI-initiated purchases.",
-          evidence: makeEvidence("user-rule-no-purchases")
-        },
-        reason: "User has blocked all AI purchases"
-      };
-    }
-    return {
-      verdict: {
-        status: "PAUSE",
-        ruleId: "user-rule-purchase-confirm",
-        reason: `AI wants to make a purchase. User rules require per-transaction confirmation.`,
-        evidence: makeEvidence("user-rule-purchase-confirm")
-      },
-      reason: "User requires per-transaction confirmation for AI purchases"
-    };
-  }
-  if (intent === "ai_auto_respond_message") {
-    if (rules.aiMessagingPolicy === "block_all") {
-      return {
-        verdict: {
-          status: "BLOCK",
-          ruleId: "user-rule-no-messaging",
-          reason: "User rules block all AI-initiated messaging.",
-          evidence: makeEvidence("user-rule-no-messaging")
-        },
-        reason: "User has blocked all AI messaging"
-      };
-    }
-    return {
-      verdict: {
-        status: "PAUSE",
-        ruleId: "user-rule-message-confirm",
-        reason: `AI wants to send a message on your behalf. User rules require per-message confirmation.`,
-        evidence: makeEvidence("user-rule-message-confirm")
-      },
-      reason: "User requires per-message confirmation for AI messaging"
-    };
-  }
-  if (def.domain === "ai_action" && intent !== "ai_auto_purchase" && intent !== "ai_auto_respond_message") {
-    if (rules.aiActionPolicy === "block_all") {
-      return {
-        verdict: {
-          status: "BLOCK",
-          ruleId: "user-rule-no-ai-actions",
-          reason: `User rules block all AI auto-actions. Intent: ${intent}`,
-          evidence: makeEvidence("user-rule-no-ai-actions")
-        },
-        reason: "User has blocked all AI auto-actions"
-      };
-    }
-    if (rules.aiActionPolicy === "confirm_all") {
-      return {
-        verdict: {
-          status: "PAUSE",
-          ruleId: "user-rule-action-confirm",
-          reason: `AI wants to take action: ${intent}. User rules require confirmation.`,
-          evidence: makeEvidence("user-rule-action-confirm")
-        },
-        reason: "User requires confirmation for all AI actions"
-      };
-    }
-    if (def.base_risk === "high" || def.base_risk === "critical") {
-      return {
-        verdict: {
-          status: "PAUSE",
-          ruleId: "user-rule-high-risk-confirm",
-          reason: `AI wants to take high-risk action: ${intent}. User rules require confirmation for high-risk actions.`,
-          evidence: makeEvidence("user-rule-high-risk-confirm")
-        },
-        reason: "User requires confirmation for high-risk AI actions"
-      };
-    }
-  }
-  if (intent === "ai_share_with_third_party") {
-    return {
-      verdict: {
-        status: "PAUSE",
-        ruleId: "user-rule-third-party-confirm",
-        reason: `App wants to share your data with a third party beyond its declared AI provider. Confirmation required.`,
-        evidence: makeEvidence("user-rule-third-party-confirm")
-      },
-      reason: "Third-party data sharing requires user confirmation"
-    };
-  }
-  return null;
-}
-function makeEvidence(ruleId) {
-  return {
-    worldId: "mentraos-user-rules",
-    worldName: "MentraOS User Rules",
-    worldVersion: "1.0.0",
-    evaluatedAt: Date.now(),
-    invariantsSatisfied: 0,
-    invariantsTotal: 0,
-    guardsMatched: [ruleId],
-    rulesMatched: [],
-    enforcementLevel: "strict"
-  };
-}
-var MentraGovernedExecutor = class {
-  world;
-  engineOptions;
-  options;
-  planState;
-  planCallbacks;
-  _userRules;
-  _emergencyOverride = false;
-  _emergencyActivatedAt = null;
-  _spatialSession = null;
-  constructor(world, options = {}, userRules = DEFAULT_USER_RULES) {
-    this.world = world;
-    this.options = options;
-    this._userRules = userRules;
-    this.engineOptions = buildEngineOptions(options, options.plan);
-    this.planState = { activePlan: options.plan, engineOptions: this.engineOptions };
-    this.planCallbacks = {
-      onPlanProgress: options.onPlanProgress,
-      onPlanComplete: options.onPlanComplete
-    };
-  }
-  /** Get the current user rules */
-  get userRules() {
-    return this._userRules;
-  }
-  /** Update user rules at runtime (e.g., user changes preferences in phone app) */
-  updateUserRules(rules) {
-    this._userRules = { ...this._userRules, ...rules };
-  }
-  /**
-   * Activate emergency override — user is king.
-   *
-   * Bypasses all NeuroVerse governance rules (user rules, platform rules).
-   * Does NOT bypass MentraOS platform constraints (hardware capability,
-   * declared permissions, session isolation). You can't override physics.
-   *
-   * Returns the timestamp of activation for audit trail.
-   */
-  activateEmergencyOverride() {
-    this._emergencyOverride = true;
-    this._emergencyActivatedAt = Date.now();
-    this.engineOptions = { ...this.engineOptions, emergencyOverride: true };
-    return this._emergencyActivatedAt;
-  }
-  /**
-   * Deactivate emergency override — governance resumes.
-   * Returns the duration the override was active (ms).
-   */
-  deactivateEmergencyOverride() {
-    if (!this._emergencyOverride || !this._emergencyActivatedAt) {
-      return 0;
-    }
-    const duration = Date.now() - this._emergencyActivatedAt;
-    this._emergencyOverride = false;
-    this._emergencyActivatedAt = null;
-    this.engineOptions = { ...this.engineOptions, emergencyOverride: false };
-    return duration;
-  }
-  /** Whether emergency override is currently active */
-  get isEmergencyOverrideActive() {
-    return this._emergencyOverride;
-  }
-  /** Timestamp when emergency override was activated, or null */
-  get emergencyActivatedAt() {
-    return this._emergencyActivatedAt;
-  }
-  // ── Spatial Governance (optional) ────────────────────────────────────────
-  /**
-   * Attach a spatial session to this executor.
-   *
-   * When attached, intents are evaluated against the spatial context
-   * (zone rules + handshake rules) AFTER user rules but BEFORE
-   * hardware and platform checks. This is Layer 1.5.
-   *
-   * Pass null to detach (e.g., when leaving a zone).
-   */
-  setSpatialSession(session) {
-    this._spatialSession = session;
-  }
-  /** Whether a spatial session is currently active */
-  get hasSpatialSession() {
-    return this._spatialSession !== null;
-  }
-  /** Get the current spatial session description */
-  get spatialDescription() {
-    return this._spatialSession?.description ?? null;
-  }
-  /**
-   * Evaluate an intent against user rules + platform world.
-   *
-   * Three-layer evaluation:
-   *   0. Emergency override — if active, skip governance (layers 1 + 1.5 + 3),
-   *      but STILL enforce platform constraints (layer 2)
-   *   1. User rules check — personal governance override, can BLOCK or PAUSE
-   *   1.5. Spatial governance — zone + handshake rules (optional, temporary)
-   *      ↑ ONLY ACTIVE when a spatial session is attached
-   *   2. Hardware capability check — validates glasses support
-   *      ↑ THIS IS A PLATFORM CONSTRAINT — never overridden
-   *   3. Platform guard engine — full world rule evaluation
-   */
-  evaluate(intent, appContext) {
-    const intentDef = getMentraIntent(intent);
-    const glassesModel = appContext.glassesModel;
-    if (!this._emergencyOverride) {
-      const userRulesResult = evaluateUserRules(intent, this._userRules, appContext);
-      if (userRulesResult) {
-        const allowed2 = false;
-        const requiresConfirmation2 = userRulesResult.verdict.status === "PAUSE";
-        const result2 = {
-          allowed: requiresConfirmation2 ? false : false,
-          requiresConfirmation: requiresConfirmation2,
-          verdict: userRulesResult.verdict,
-          intentDef,
-          userRulesResult: { reason: userRulesResult.reason },
-          appContext,
-          decidingLayer: "user_rules"
-        };
-        if (requiresConfirmation2) {
-          this.options.onPause?.(result2);
-        } else {
-          this.options.onBlock?.(result2);
-        }
-        this.options.onEvaluate?.(result2);
-        return result2;
-      }
-    }
-    if (!this._emergencyOverride && this._spatialSession) {
-      const spatialResult = this._spatialSession.evaluate(intent);
-      if (!spatialResult.allowed && !spatialResult.requiresConfirmation) {
-        const verdict2 = {
-          status: "BLOCK",
-          ruleId: "spatial-zone-rule",
-          reason: spatialResult.reason,
-          evidence: makeEvidence("spatial-zone-rule")
-        };
-        const result2 = {
-          allowed: false,
-          requiresConfirmation: false,
-          verdict: verdict2,
-          intentDef,
-          appContext,
-          decidingLayer: "spatial"
-        };
-        this.options.onBlock?.(result2);
-        this.options.onEvaluate?.(result2);
-        return result2;
-      }
-      if (spatialResult.requiresConfirmation) {
-        const verdict2 = {
-          status: "PAUSE",
-          ruleId: "spatial-zone-rule",
-          reason: spatialResult.reason,
-          evidence: makeEvidence("spatial-zone-rule")
-        };
-        const result2 = {
-          allowed: false,
-          requiresConfirmation: true,
-          verdict: verdict2,
-          intentDef,
-          appContext,
-          decidingLayer: "spatial"
-        };
-        this.options.onPause?.(result2);
-        this.options.onEvaluate?.(result2);
-        return result2;
-      }
-    }
-    if (intentDef && glassesModel && !intentDef.supported_glasses.includes(glassesModel)) {
-      const verdict2 = {
-        status: "BLOCK",
-        ruleId: "hardware-capability",
-        reason: `${intent} not supported on ${glassesModel} \u2014 requires: ${intentDef.supported_glasses.join(", ")}`,
-        evidence: {
-          worldId: this.world.world?.world_id ?? "unknown",
-          worldName: this.world.world?.name ?? "unknown",
-          worldVersion: this.world.world?.version ?? "unknown",
-          evaluatedAt: Date.now(),
-          invariantsSatisfied: 0,
-          invariantsTotal: 0,
-          guardsMatched: ["hardware-capability"],
-          rulesMatched: [],
-          enforcementLevel: "strict"
-        }
-      };
-      const result2 = {
-        allowed: false,
-        requiresConfirmation: false,
-        verdict: verdict2,
-        intentDef,
-        appContext,
-        decidingLayer: "hardware"
-      };
-      this.options.onBlock?.(result2);
-      this.options.onEvaluate?.(result2);
-      return result2;
-    }
-    const event = {
-      intent,
-      tool: intentDef?.sdk_method ?? intent,
-      scope: intentDef?.domain ?? "unknown",
-      actionCategory: intentDef?.action_category,
-      riskLevel: intentDef?.base_risk ?? "medium",
-      irreversible: intentDef ? !intentDef.reversible : false,
-      args: {
-        app_id: appContext.appId,
-        ai_provider_declared: appContext.aiProviderDeclared ? 1 : 0,
-        ai_data_types_sent: appContext.aiDataTypesSent,
-        ai_retention_opted_in: appContext.dataRetentionOptedIn ? 1 : 0,
-        glasses_model: glassesModel ?? "unknown",
-        is_ai_intent: isAIIntent(intent) ? 1 : 0
-      }
-    };
-    const verdict = evaluateGuard(event, this.world, this.engineOptions);
-    const allowed = verdict.status === "ALLOW" || verdict.status === "REWARD";
-    const requiresConfirmation = verdict.status === "PAUSE";
-    if (allowed) {
-      trackPlanProgress(event, this.planState, this.planCallbacks);
-    }
-    const result = {
-      allowed,
-      requiresConfirmation,
-      verdict,
-      intentDef,
-      appContext,
-      decidingLayer: this._emergencyOverride ? "emergency_override" : "platform"
-    };
-    if (!allowed && !requiresConfirmation) {
-      this.options.onBlock?.(result);
-    }
-    if (requiresConfirmation) {
-      this.options.onPause?.(result);
-    }
-    this.options.onEvaluate?.(result);
-    return result;
-  }
-  /** Get all known intents for this adapter */
-  get knownIntents() {
-    return MENTRA_KNOWN_INTENTS;
-  }
-};
-async function createMentraGovernedExecutor(worldPath, options = {}, userRules = DEFAULT_USER_RULES) {
-  const world = await loadWorld(worldPath);
-  return new MentraGovernedExecutor(world, options, userRules);
-}
-function createMentraGovernedExecutorFromWorld(world, options = {}, userRules = DEFAULT_USER_RULES) {
-  return new MentraGovernedExecutor(world, options, userRules);
-}
-
 export {
   MENTRA_INTENT_TAXONOMY,
   MENTRA_KNOWN_INTENTS,
@@ -884,10 +449,5 @@ export {
   getAIDataIntents,
   getAIActionIntents,
   getAIIntents,
-  isAIIntent,
-  DEFAULT_USER_RULES,
-  evaluateUserRules,
-  MentraGovernedExecutor,
-  createMentraGovernedExecutor,
-  createMentraGovernedExecutorFromWorld
+  isAIIntent
 };

package/dist/chunk-H3REGQRI.js

@@ -0,0 +1,107 @@
+// src/cli/sign.ts
+import { createHash, sign } from "crypto";
+import { readFileSync, writeFileSync, readdirSync, statSync } from "fs";
+import { join, relative } from "path";
+import { homedir } from "os";
+var USAGE = `
+neuroverse sign \u2014 Sign a world artifact
+
+Usage:
+  neuroverse sign --world <dir> [--key <path>]
+
+Options:
+  --world <dir>    World directory to sign (required)
+  --key <path>     Private key path (default: ~/.neuroverse/keys/neuroverse.key)
+
+Examples:
+  neuroverse sign --world ./world/
+  neuroverse sign --world ./world/ --key ./keys/production.key
+`.trim();
+function parseArgs(argv) {
+  let worldPath = "";
+  let keyPath = join(homedir(), ".neuroverse", "keys", "neuroverse.key");
+  let help = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--world" && argv[i + 1]) {
+      worldPath = argv[++i];
+    } else if (arg === "--key" && argv[i + 1]) {
+      keyPath = argv[++i];
+    } else if (arg === "--help" || arg === "-h") {
+      help = true;
+    }
+  }
+  return { worldPath, keyPath, help };
+}
+function collectFiles(dir, base) {
+  const root = base ?? dir;
+  const files = [];
+  for (const entry of readdirSync(dir)) {
+    if (entry === ".nv-signature.json") continue;
+    const full = join(dir, entry);
+    const stat = statSync(full);
+    if (stat.isDirectory()) {
+      files.push(...collectFiles(full, root));
+    } else {
+      files.push(relative(root, full));
+    }
+  }
+  return files.sort();
+}
+function buildManifest(worldPath) {
+  const files = collectFiles(worldPath);
+  const manifest = {};
+  for (const file of files) {
+    const content = readFileSync(join(worldPath, file));
+    manifest[file] = createHash("sha256").update(content).digest("hex");
+  }
+  return manifest;
+}
+function canonicalManifest(files) {
+  const sorted = Object.keys(files).sort();
+  return sorted.map((k) => `${k}:${files[k]}`).join("\n");
+}
+async function main(argv = process.argv.slice(2)) {
+  const args = parseArgs(argv);
+  if (args.help) {
+    process.stdout.write(USAGE + "\n");
+    return;
+  }
+  if (!args.worldPath) {
+    process.stderr.write("Error: --world <dir> is required.\n");
+    process.exit(1);
+  }
+  let privateKey;
+  try {
+    privateKey = readFileSync(args.keyPath, "utf-8");
+  } catch {
+    process.stderr.write(`Error: Cannot read private key at ${args.keyPath}
+`);
+    process.stderr.write('Run "neuroverse keygen" to generate a keypair.\n');
+    process.exit(1);
+    return;
+  }
+  const files = buildManifest(args.worldPath);
+  const canonical = canonicalManifest(files);
+  const manifestHash = createHash("sha256").update(canonical).digest("hex");
+  const signature = sign(null, Buffer.from(manifestHash), privateKey).toString("base64");
+  const artifact = {
+    signatureVersion: "1.0",
+    signedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    files,
+    manifestHash,
+    signature
+  };
+  const outPath = join(args.worldPath, ".nv-signature.json");
+  writeFileSync(outPath, JSON.stringify(artifact, null, 2) + "\n", "utf-8");
+  process.stdout.write(`Signed ${Object.keys(files).length} files in ${args.worldPath}
+`);
+  process.stdout.write(`Signature: ${outPath}
+`);
+}
+
+export {
+  buildManifest,
+  canonicalManifest,
+  main
+};

package/dist/{chunk-J2IZBHXJ.js → chunk-LAKUB76X.js}

@@ -2,12 +2,12 @@ import {
   describeActiveWorld,
   resolveWorldPath
 } from "./chunk-AKW5YVCE.js";
+import {
+  loadWorld
+} from "./chunk-EQUAWNXW.js";
 import {
   evaluateGuard
 } from "./chunk-ZAF6JH23.js";
-import {
-  loadWorld
-} from "./chunk-I4RTIMLX.js";
 import {
   advancePlan,
   evaluatePlan,

package/dist/{chunk-FVOGUCB6.js → chunk-R23T5SZG.js}

@@ -5,12 +5,12 @@ import {
   extractScope,
   trackPlanProgress
 } from "./chunk-5U2MQO5P.js";
+import {
+  loadWorld
+} from "./chunk-EQUAWNXW.js";
 import {
   evaluateGuard
 } from "./chunk-ZAF6JH23.js";
-import {
-  loadWorld
-} from "./chunk-I4RTIMLX.js";
 
 // src/adapters/openai.ts
 var GovernanceBlockedError2 = class extends GovernanceBlockedError {

package/dist/{chunk-A7SHG75T.js → chunk-RF2L5SYG.js}

@@ -4,12 +4,12 @@ import {
   extractScope,
   trackPlanProgress
 } from "./chunk-5U2MQO5P.js";
+import {
+  loadWorld
+} from "./chunk-EQUAWNXW.js";
 import {
   evaluateGuard
 } from "./chunk-ZAF6JH23.js";
-import {
-  loadWorld
-} from "./chunk-I4RTIMLX.js";
 
 // src/adapters/openclaw.ts
 var GovernanceBlockedError2 = class extends GovernanceBlockedError {

package/dist/{chunk-QMVQ6KPL.js → chunk-TL4DLMMW.js}

@@ -1,9 +1,9 @@
+import {
+  loadWorldFromDirectory
+} from "./chunk-EQUAWNXW.js";
 import {
   evaluateGuard
 } from "./chunk-ZAF6JH23.js";
-import {
-  loadWorldFromDirectory
-} from "./chunk-I4RTIMLX.js";
 
 // src/adapters/autoresearch.ts
 var AutoresearchGovernor = class {

package/dist/{chunk-AV7XJJWK.js → chunk-TZBERHFM.js}

@@ -1,9 +1,9 @@
+import {
+  loadWorld
+} from "./chunk-EQUAWNXW.js";
 import {
   evaluateGuard
 } from "./chunk-ZAF6JH23.js";
-import {
-  loadWorld
-} from "./chunk-I4RTIMLX.js";
 
 // src/runtime/govern.ts
 function actionToGuardEvent(action) {

package/dist/{chunk-3AYKQHYI.js → chunk-UZBW44KD.js}

@@ -4,12 +4,12 @@ import {
   extractScope,
   trackPlanProgress
 } from "./chunk-5U2MQO5P.js";
+import {
+  loadWorld
+} from "./chunk-EQUAWNXW.js";
 import {
   evaluateGuard
 } from "./chunk-ZAF6JH23.js";
-import {
-  loadWorld
-} from "./chunk-I4RTIMLX.js";
 
 // src/adapters/langchain.ts
 var GovernanceBlockedError2 = class extends GovernanceBlockedError {

package/dist/{chunk-FS2UUJJO.js → chunk-XPMZB46F.js}

@@ -35,7 +35,7 @@ async function addGuard(worldDir, input) {
   };
   config.guards.push(guard);
   await writeFile(guardsPath, JSON.stringify(config, null, 2) + "\n");
-  const { loadWorldFromDirectory } = await import("./world-loader-YTYFOP7D.js");
+  const { loadWorldFromDirectory } = await import("./world-loader-J47PCPDZ.js");
   const world = await loadWorldFromDirectory(worldDir);
   const report = validateWorld(world);
   return {
@@ -83,7 +83,7 @@ async function addRule(worldDir, input) {
   };
   const rulePath = join(rulesDir, `rule-${ruleNum}.json`);
   await writeFile(rulePath, JSON.stringify(rule, null, 2) + "\n");
-  const { loadWorldFromDirectory } = await import("./world-loader-YTYFOP7D.js");
+  const { loadWorldFromDirectory } = await import("./world-loader-J47PCPDZ.js");
   const world = await loadWorldFromDirectory(worldDir);
   const report = validateWorld(world);
   return {
@@ -118,7 +118,7 @@ async function addInvariant(worldDir, input) {
   };
   config.invariants.push(invariant);
   await writeFile(invariantsPath, JSON.stringify(config, null, 2) + "\n");
-  const { loadWorldFromDirectory } = await import("./world-loader-YTYFOP7D.js");
+  const { loadWorldFromDirectory } = await import("./world-loader-J47PCPDZ.js");
   const world = await loadWorldFromDirectory(worldDir);
   const report = validateWorld(world);
   return {