@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-GYZE55MO.js

@@ -0,0 +1,2007 @@
+import { computeContentHash } from './chunk-4R6SBXDB.js';
+import { init_AgentRBAC, init_CompilerBase, getRBAC, UnauthorizedCompilerAccessError } from './chunk-QPSKHBJP.js';
+import { init_safeJsonParse, readJson } from './chunk-VVKVQZI6.js';
+import { createHash } from 'crypto';
+
+// src/compiler/TraitDependencyGraph.ts
+init_safeJsonParse();
+function hashConfig(config) {
+  const keys = Object.keys(config).sort();
+  const parts = [];
+  for (const key of keys) {
+    const value = config[key];
+    parts.push(`${key}:${JSON.stringify(value)}`);
+  }
+  const str = parts.join("|");
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) + hash ^ str.charCodeAt(i);
+  }
+  return (hash >>> 0).toString(36);
+}
+var TraitDependencyGraph = class _TraitDependencyGraph {
+  constructor() {
+    /** Trait → required traits (what this trait depends on) */
+    this.traitDependencies = /* @__PURE__ */ new Map();
+    /** Trait → conflicting traits */
+    this.traitConflicts = /* @__PURE__ */ new Map();
+    /** Object → trait info (current state) */
+    this.objectTraits = /* @__PURE__ */ new Map();
+    /** Trait → objects using this trait */
+    this.traitToObjects = /* @__PURE__ */ new Map();
+    /** Source → objects defined in this source */
+    this.sourceToObjects = /* @__PURE__ */ new Map();
+    /** Template → objects extending this template */
+    this.templateToObjects = /* @__PURE__ */ new Map();
+    /** Previous state for diff comparison */
+    this.previousObjectTraits = /* @__PURE__ */ new Map();
+    // ---------------------------------------------------------------------------
+    // IMPORT GRAPH — cross-file dependency edges
+    // ---------------------------------------------------------------------------
+    /**
+     * File → set of files it directly imports.
+     * Edge: `importer → importee`
+     * e.g., 'a.hs' → { 'b.hs', 'c.hs' }
+     */
+    this.importEdges = /* @__PURE__ */ new Map();
+    /**
+     * Reverse map: file → set of files that import it.
+     * Edge: `importee → importers`
+     * e.g., 'b.hs' → { 'a.hs', 'd.hs' }
+     */
+    this.reverseImportEdges = /* @__PURE__ */ new Map();
+  }
+  // ===========================================================================
+  // TRAIT REGISTRATION
+  // ===========================================================================
+  /**
+   * Register a trait definition with its dependencies and conflicts
+   */
+  registerTrait(definition) {
+    const { name, requires, conflicts } = definition;
+    if (!this.traitDependencies.has(name)) {
+      this.traitDependencies.set(name, /* @__PURE__ */ new Set());
+    }
+    for (const req of requires) {
+      this.traitDependencies.get(name).add(req);
+    }
+    if (!this.traitConflicts.has(name)) {
+      this.traitConflicts.set(name, /* @__PURE__ */ new Set());
+    }
+    for (const conflict of conflicts) {
+      this.traitConflicts.get(name).add(conflict);
+    }
+  }
+  /**
+   * Register common VR trait dependencies
+   */
+  registerBuiltinTraits() {
+    this.registerTrait({
+      name: "physics",
+      requires: [],
+      conflicts: ["static"]
+    });
+    this.registerTrait({
+      name: "static",
+      requires: [],
+      conflicts: ["physics", "kinematic"]
+    });
+    this.registerTrait({
+      name: "kinematic",
+      requires: [],
+      conflicts: ["static"]
+    });
+    this.registerTrait({
+      name: "collidable",
+      requires: [],
+      conflicts: []
+    });
+    this.registerTrait({
+      name: "grabbable",
+      requires: ["collidable"],
+      conflicts: []
+    });
+    this.registerTrait({
+      name: "throwable",
+      requires: ["grabbable"],
+      conflicts: []
+    });
+    this.registerTrait({
+      name: "draggable",
+      requires: ["collidable"],
+      conflicts: []
+    });
+    this.registerTrait({
+      name: "visible",
+      requires: [],
+      conflicts: ["invisible"]
+    });
+    this.registerTrait({
+      name: "invisible",
+      requires: [],
+      conflicts: ["visible"]
+    });
+    this.registerTrait({
+      name: "audio",
+      requires: [],
+      conflicts: []
+    });
+    this.registerTrait({
+      name: "spatial_audio",
+      requires: ["audio"],
+      conflicts: []
+    });
+    this.registerTrait({
+      name: "networked",
+      requires: [],
+      conflicts: []
+    });
+    this.registerTrait({
+      name: "lobby",
+      requires: [],
+      conflicts: []
+    });
+    this.registerTrait({
+      name: "crdt-room",
+      requires: [],
+      conflicts: ["lobby"]
+      // crdt-room replaces lobby-based room management
+    });
+    this.registerTrait({
+      name: "crdt-room.entity",
+      requires: ["crdt-room"],
+      conflicts: []
+    });
+    this.registerTrait({
+      name: "cultural_profile",
+      requires: [],
+      conflicts: []
+    });
+    this.registerTrait({
+      name: "norm_compliant",
+      requires: ["cultural_profile"],
+      conflicts: []
+    });
+    this.registerTrait({
+      name: "cultural_memory",
+      requires: ["cultural_profile"],
+      conflicts: []
+    });
+    this.registerTrait({
+      name: "cultural_trace",
+      requires: [],
+      conflicts: []
+    });
+    this.registerV6Traits();
+  }
+  /**
+   * Register v6 universal service/data/pipeline/container/resilience traits
+   */
+  registerV6Traits() {
+    this.registerTrait({ name: "service", requires: [], conflicts: [] });
+    this.registerTrait({ name: "endpoint", requires: ["service"], conflicts: [] });
+    this.registerTrait({ name: "handler", requires: ["http"], conflicts: [] });
+    this.registerTrait({ name: "middleware", requires: ["service"], conflicts: [] });
+    this.registerTrait({ name: "http", requires: [], conflicts: [] });
+    this.registerTrait({ name: "gateway", requires: [], conflicts: ["proxy"] });
+    this.registerTrait({ name: "proxy", requires: [], conflicts: ["gateway"] });
+    this.registerTrait({ name: "db", requires: [], conflicts: [] });
+    this.registerTrait({ name: "data_model", requires: ["db"], conflicts: [] });
+    this.registerTrait({ name: "migration", requires: ["db"], conflicts: [] });
+    this.registerTrait({ name: "query", requires: ["db"], conflicts: [] });
+    this.registerTrait({ name: "cache", requires: [], conflicts: [] });
+    this.registerTrait({ name: "pipeline", requires: [], conflicts: [] });
+    this.registerTrait({ name: "stream", requires: ["pipeline"], conflicts: [] });
+    this.registerTrait({ name: "queue", requires: [], conflicts: [] });
+    this.registerTrait({ name: "worker", requires: ["pipeline"], conflicts: ["scheduler"] });
+    this.registerTrait({ name: "scheduler", requires: [], conflicts: ["worker"] });
+    this.registerTrait({ name: "container", requires: [], conflicts: ["serverless"] });
+    this.registerTrait({ name: "serverless", requires: [], conflicts: ["container"] });
+    this.registerTrait({ name: "deployment", requires: [], conflicts: [] });
+    this.registerTrait({ name: "metric", requires: [], conflicts: [] });
+    this.registerTrait({ name: "trace", requires: ["service"], conflicts: [] });
+    this.registerTrait({ name: "health_check", requires: ["service"], conflicts: [] });
+    this.registerTrait({ name: "log", requires: [], conflicts: [] });
+    this.registerTrait({ name: "circuit_breaker", requires: ["service"], conflicts: [] });
+    this.registerTrait({ name: "retry", requires: ["service"], conflicts: [] });
+    this.registerTrait({ name: "timeout", requires: ["service"], conflicts: [] });
+    this.registerTrait({ name: "fallback", requires: [], conflicts: [] });
+    this.registerTrait({ name: "bulkhead", requires: ["service"], conflicts: [] });
+    this.registerTrait({ name: "schema", requires: [], conflicts: [] });
+    this.registerTrait({ name: "validator", requires: ["schema"], conflicts: [] });
+    this.registerTrait({ name: "serializer", requires: ["schema"], conflicts: [] });
+    this.registerTrait({ name: "contract", requires: [], conflicts: [] });
+  }
+  // ===========================================================================
+  // IMPORT EDGE TRACKING (@import cross-file dependencies)
+  // ===========================================================================
+  /**
+   * Register a cross-file @import relationship.
+   *
+   * Call this once per `@import` directive after parsing.
+   * Idempotent — registering the same edge twice is safe.
+   *
+   * @param importingFile  Canonical path of the file that contains `@import`
+   * @param importedFile   Canonical path of the file being imported
+   */
+  registerImport(importingFile, importedFile) {
+    if (!this.importEdges.has(importingFile)) {
+      this.importEdges.set(importingFile, /* @__PURE__ */ new Set());
+    }
+    this.importEdges.get(importingFile).add(importedFile);
+    if (!this.reverseImportEdges.has(importedFile)) {
+      this.reverseImportEdges.set(importedFile, /* @__PURE__ */ new Set());
+    }
+    this.reverseImportEdges.get(importedFile).add(importingFile);
+  }
+  /**
+   * Remove all import edges for a file (call before re-registering after a parse).
+   * Cleans both the forward edge and the corresponding reverse entries.
+   */
+  clearImportsForFile(importingFile) {
+    const imported = this.importEdges.get(importingFile);
+    if (!imported) return;
+    for (const dep of imported) {
+      this.reverseImportEdges.get(dep)?.delete(importingFile);
+    }
+    this.importEdges.delete(importingFile);
+  }
+  /**
+   * Return the set of files that `sourceFile` directly imports.
+   */
+  getImportedFiles(sourceFile) {
+    return new Set(this.importEdges.get(sourceFile) ?? []);
+  }
+  /**
+   * Return the set of files that directly import `sourceFile`.
+   */
+  getFilesThatImport(sourceFile) {
+    return new Set(this.reverseImportEdges.get(sourceFile) ?? []);
+  }
+  /**
+   * Walk the reverse-import graph (BFS) to compute the full set of files that
+   * need to be recompiled when `changedFiles` are modified.
+   *
+   * Includes the changed files themselves and all direct/transitive importers.
+   *
+   * @param changedFiles Canonical paths of the files that changed on disk
+   * @returns Set of canonical paths that need recompilation
+   */
+  getFilesAffectedByChange(changedFiles) {
+    const affected = new Set(changedFiles);
+    const queue = [...changedFiles];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      const importers = this.reverseImportEdges.get(current);
+      if (!importers) continue;
+      for (const importer of importers) {
+        if (!affected.has(importer)) {
+          affected.add(importer);
+          queue.push(importer);
+        }
+      }
+    }
+    return affected;
+  }
+  // ===========================================================================
+  // OBJECT TRACKING
+  // ===========================================================================
+  /**
+   * Register an object and its trait usage
+   */
+  registerObject(info) {
+    const { objectName, sourceId, traits, template } = info;
+    const traitsWithHashes = traits.map((t) => ({
+      ...t,
+      configHash: t.configHash || hashConfig(t.config)
+    }));
+    const fullInfo = {
+      ...info,
+      traits: traitsWithHashes
+    };
+    this.objectTraits.set(objectName, fullInfo);
+    for (const trait of traitsWithHashes) {
+      if (!this.traitToObjects.has(trait.name)) {
+        this.traitToObjects.set(trait.name, /* @__PURE__ */ new Set());
+      }
+      this.traitToObjects.get(trait.name).add(objectName);
+    }
+    if (!this.sourceToObjects.has(sourceId)) {
+      this.sourceToObjects.set(sourceId, /* @__PURE__ */ new Set());
+    }
+    this.sourceToObjects.get(sourceId).add(objectName);
+    if (template) {
+      if (!this.templateToObjects.has(template)) {
+        this.templateToObjects.set(template, /* @__PURE__ */ new Set());
+      }
+      this.templateToObjects.get(template).add(objectName);
+    }
+  }
+  /**
+   * Remove an object from tracking
+   */
+  unregisterObject(objectName) {
+    const info = this.objectTraits.get(objectName);
+    if (!info) return;
+    for (const trait of info.traits) {
+      this.traitToObjects.get(trait.name)?.delete(objectName);
+    }
+    this.sourceToObjects.get(info.sourceId)?.delete(objectName);
+    if (info.template) {
+      this.templateToObjects.get(info.template)?.delete(objectName);
+    }
+    this.objectTraits.delete(objectName);
+  }
+  // ===========================================================================
+  // CHANGE DETECTION
+  // ===========================================================================
+  /**
+   * Save current state for comparison
+   */
+  saveSnapshot() {
+    this.previousObjectTraits = new Map(
+      Array.from(this.objectTraits.entries()).map(([k, v]) => [
+        k,
+        {
+          ...v,
+          traits: [...v.traits]
+        }
+      ])
+    );
+  }
+  /**
+   * Detect trait changes for an object
+   */
+  detectTraitChanges(objectName, newTraits) {
+    const changes = [];
+    const oldInfo = this.previousObjectTraits.get(objectName);
+    const newTraitsWithHashes = newTraits.map((t) => ({
+      ...t,
+      configHash: t.configHash || hashConfig(t.config)
+    }));
+    const oldTraitMap = /* @__PURE__ */ new Map();
+    const newTraitMap = /* @__PURE__ */ new Map();
+    if (oldInfo) {
+      for (const t of oldInfo.traits) {
+        oldTraitMap.set(t.name, t);
+      }
+    }
+    for (const t of newTraitsWithHashes) {
+      newTraitMap.set(t.name, t);
+    }
+    for (const [name, newTrait] of newTraitMap) {
+      if (!oldTraitMap.has(name)) {
+        changes.push({
+          traitName: name,
+          changeType: "added",
+          newConfigHash: newTrait.configHash
+        });
+      }
+    }
+    for (const [name, oldTrait] of oldTraitMap) {
+      if (!newTraitMap.has(name)) {
+        changes.push({
+          traitName: name,
+          changeType: "removed",
+          oldConfigHash: oldTrait.configHash
+        });
+      }
+    }
+    for (const [name, newTrait] of newTraitMap) {
+      const oldTrait = oldTraitMap.get(name);
+      if (oldTrait && oldTrait.configHash !== newTrait.configHash) {
+        changes.push({
+          traitName: name,
+          changeType: "config_changed",
+          oldConfigHash: oldTrait.configHash,
+          newConfigHash: newTrait.configHash
+        });
+      }
+    }
+    return changes;
+  }
+  // ===========================================================================
+  // AFFECTED SET CALCULATION
+  // ===========================================================================
+  /**
+   * Get all objects using a specific trait
+   */
+  getObjectsUsingTrait(traitName) {
+    return new Set(this.traitToObjects.get(traitName) || []);
+  }
+  /**
+   * Get all traits that depend on a given trait
+   */
+  getDependentTraits(traitName) {
+    const dependents = /* @__PURE__ */ new Set();
+    for (const [trait, deps] of this.traitDependencies) {
+      if (deps.has(traitName)) {
+        dependents.add(trait);
+      }
+    }
+    return dependents;
+  }
+  /**
+   * Calculate the affected set when traits change
+   */
+  calculateAffectedSet(changes) {
+    const objects = /* @__PURE__ */ new Set();
+    const sources = /* @__PURE__ */ new Set();
+    const reasons = /* @__PURE__ */ new Map();
+    for (const change of changes) {
+      const { traitName, changeType } = change;
+      const directUsers = this.getObjectsUsingTrait(traitName);
+      for (const obj of directUsers) {
+        objects.add(obj);
+        reasons.set(obj, `Uses trait @${traitName} (${changeType})`);
+        const info = this.objectTraits.get(obj);
+        if (info) {
+          sources.add(info.sourceId);
+        }
+      }
+      const dependentTraits = this.getDependentTraits(traitName);
+      for (const depTrait of dependentTraits) {
+        const depUsers = this.getObjectsUsingTrait(depTrait);
+        for (const obj of depUsers) {
+          if (!objects.has(obj)) {
+            objects.add(obj);
+            reasons.set(obj, `Uses trait @${depTrait} which depends on @${traitName}`);
+            const info = this.objectTraits.get(obj);
+            if (info) {
+              sources.add(info.sourceId);
+            }
+          }
+        }
+      }
+    }
+    return { objects, sources, reasons };
+  }
+  /**
+   * Calculate minimal recompilation set for changed objects
+   * Considers trait dependencies and template inheritance
+   */
+  calculateRecompilationSet(changedObjects) {
+    const toRecompile = new Set(changedObjects);
+    const queue = [...changedObjects];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      const info = this.objectTraits.get(current);
+      if (!info) continue;
+      const extending = this.templateToObjects.get(current);
+      if (extending) {
+        for (const obj of extending) {
+          if (!toRecompile.has(obj)) {
+            toRecompile.add(obj);
+            queue.push(obj);
+          }
+        }
+      }
+    }
+    return toRecompile;
+  }
+  // ===========================================================================
+  // SERIALIZATION (for cache persistence)
+  // ===========================================================================
+  /**
+   * Serialize the graph for persistence
+   */
+  serialize() {
+    const data = {
+      version: 2,
+      traitDependencies: Array.from(this.traitDependencies.entries()).map(([k, v]) => [
+        k,
+        Array.from(v)
+      ]),
+      traitConflicts: Array.from(this.traitConflicts.entries()).map(([k, v]) => [k, Array.from(v)]),
+      objectTraits: Array.from(this.objectTraits.entries()),
+      importEdges: Array.from(this.importEdges.entries()).map(([k, v]) => [k, Array.from(v)]),
+      timestamp: Date.now()
+    };
+    return JSON.stringify(data);
+  }
+  /**
+   * Deserialize the graph from persisted data
+   */
+  static deserialize(json) {
+    const graph = new _TraitDependencyGraph();
+    const data = readJson(json);
+    if (data.version !== 1 && data.version !== 2) {
+      throw new Error(`Unsupported trait graph version: ${data.version}`);
+    }
+    for (const [trait, deps] of data.traitDependencies) {
+      graph.traitDependencies.set(trait, new Set(deps));
+    }
+    for (const [trait, conflicts] of data.traitConflicts) {
+      graph.traitConflicts.set(trait, new Set(conflicts));
+    }
+    for (const [_name, info] of data.objectTraits) {
+      graph.registerObject(info);
+    }
+    if (data.importEdges) {
+      for (const [importer, imported] of data.importEdges) {
+        for (const dep of imported) {
+          graph.registerImport(importer, dep);
+        }
+      }
+    }
+    return graph;
+  }
+  // ===========================================================================
+  // STATS & DEBUGGING
+  // ===========================================================================
+  /**
+   * Get graph statistics
+   */
+  getStats() {
+    let dependencyEdges = 0;
+    for (const deps of this.traitDependencies.values()) {
+      dependencyEdges += deps.size;
+    }
+    let importEdges = 0;
+    for (const deps of this.importEdges.values()) {
+      importEdges += deps.size;
+    }
+    return {
+      traitCount: this.traitDependencies.size,
+      objectCount: this.objectTraits.size,
+      sourceCount: this.sourceToObjects.size,
+      dependencyEdges,
+      importEdges
+    };
+  }
+  /**
+   * Clear all data
+   */
+  clear() {
+    this.traitDependencies.clear();
+    this.traitConflicts.clear();
+    this.objectTraits.clear();
+    this.traitToObjects.clear();
+    this.sourceToObjects.clear();
+    this.templateToObjects.clear();
+    this.previousObjectTraits.clear();
+    this.importEdges.clear();
+    this.reverseImportEdges.clear();
+  }
+};
+var globalTraitGraph = new TraitDependencyGraph();
+globalTraitGraph.registerBuiltinTraits();
+
+// src/parser/ImportResolver.ts
+function resolveImportPath(importPath, baseDir) {
+  importPath = importPath.replace(/\\/g, "/");
+  baseDir = baseDir.replace(/\\/g, "/");
+  if (importPath.startsWith("/") || /^[A-Za-z]:/.test(importPath)) {
+    return importPath;
+  }
+  const baseResolved = normalizePath(baseDir);
+  const base = baseResolved.replace(/\/$/, "");
+  const combined = base + "/" + importPath;
+  return normalizePath(combined);
+}
+function normalizePath(p) {
+  const isAbsolute = p.startsWith("/");
+  const parts = p.split("/");
+  const resolved = [];
+  for (const part of parts) {
+    if (part === "" || part === ".") {
+      if (resolved.length === 0 && part === "" && isAbsolute) {
+        resolved.push("");
+      }
+      continue;
+    }
+    if (part === "..") {
+      if (resolved.length > (isAbsolute ? 1 : 0)) {
+        resolved.pop();
+      }
+    } else {
+      resolved.push(part);
+    }
+  }
+  let result = resolved.join("/");
+  if (isAbsolute && !result.startsWith("/")) result = "/" + result;
+  return result || "/";
+}
+var REGISTRY_IMPORT_RE = /^@[a-zA-Z0-9_-]+\/[a-zA-Z0-9_.-]+$/;
+function isRegistryImport(importPath) {
+  return REGISTRY_IMPORT_RE.test(importPath);
+}
+function isCrdtImport(importPath) {
+  return importPath.startsWith("crdt://");
+}
+function parseRegistryImport(importPath) {
+  if (!isRegistryImport(importPath)) return null;
+  const parts = importPath.slice(1).split("/");
+  return { username: parts[0], name: parts[1] };
+}
+var ImportResolver = class {
+  constructor() {
+    /** Already-resolved modules keyed by canonical path */
+    this.cache = /* @__PURE__ */ new Map();
+    /** Paths currently being resolved (DFS cycle detection) */
+    this.inProgress = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Resolve all @import directives from a parsed result and return a merged scope.
+   *
+   * @param result - The top-level parse result (from HoloScriptPlusParser.parse)
+   * @param sourceFile - Canonical path of the file that produced `result`
+   * @param options - Resolution options
+   */
+  async resolve(result, sourceFile, options) {
+    if (options.disabled) {
+      return { scope: /* @__PURE__ */ new Map(), modules: /* @__PURE__ */ new Map(), errors: [] };
+    }
+    const scope = /* @__PURE__ */ new Map();
+    const modules = /* @__PURE__ */ new Map();
+    const errors = [];
+    const imports = result.ast?.imports ?? [];
+    if (imports.length === 0) {
+      return { scope, modules, errors };
+    }
+    const baseDir = options.baseDir.replace(/\\/g, "/");
+    for (const imp of imports) {
+      const canonicalPath = isRegistryImport(imp.path) || isCrdtImport(imp.path) ? imp.path : resolveImportPath(imp.path, baseDir);
+      let mod;
+      try {
+        mod = await this._resolveModule(canonicalPath, sourceFile, options, 0, errors);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        errors.push({
+          importPath: imp.path,
+          message: msg,
+          code: msg.startsWith("Circular") ? "cycle" : msg.startsWith("Max depth") ? "max_depth" : msg.startsWith("Parse error") ? "parse_error" : msg.startsWith("Registry") ? "registry_unavailable" : "not_found",
+          ...msg.startsWith("Circular") ? { cycle: [canonicalPath] } : {}
+        });
+        continue;
+      }
+      modules.set(canonicalPath, mod);
+      if (imp.namedImports && imp.namedImports.length > 0) {
+        for (const named of imp.namedImports) {
+          const node = mod.exports.get(named);
+          if (!node) {
+            errors.push({
+              importPath: imp.path,
+              message: `'${named}' is not exported from '${imp.path}'`,
+              code: "named_not_exported"
+            });
+          } else {
+            scope.set(named, node);
+          }
+        }
+      } else if (imp.isWildcard) {
+        for (const [exportName, node] of mod.exports) {
+          scope.set(`${imp.alias}.${exportName}`, node);
+        }
+      } else {
+        for (const [exportName, node] of mod.exports) {
+          scope.set(`${imp.alias}.${exportName}`, node);
+        }
+      }
+    }
+    return { scope, modules, errors };
+  }
+  /**
+   * Recursively resolve a single module file.
+   * Cycle detection: if `canonicalPath` is already in `inProgress`, throws.
+   * Transitive errors (cycles, missing, max depth) are pushed to `errors` array.
+   */
+  async _resolveModule(canonicalPath, importedBy, options, depth, errors) {
+    const maxDepth = options.maxDepth ?? 32;
+    if (depth > maxDepth) {
+      throw new Error(`Max depth (${maxDepth}) exceeded resolving '${canonicalPath}'`);
+    }
+    if (this.inProgress.has(canonicalPath)) {
+      const chain = [...this.inProgress, canonicalPath];
+      throw new Error(`Circular import detected: ${chain.join(" \u2192 ")}`);
+    }
+    if (this.cache.has(canonicalPath)) {
+      return this.cache.get(canonicalPath);
+    }
+    this.inProgress.add(canonicalPath);
+    try {
+      let source;
+      if (isRegistryImport(canonicalPath) && options.registryBaseUrl) {
+        try {
+          source = await this._fetchRegistrySource(canonicalPath, options.registryBaseUrl);
+        } catch {
+          throw new Error(
+            `Registry unavailable for '${canonicalPath}' (imported from '${importedBy}')`
+          );
+        }
+      } else if (isCrdtImport(canonicalPath)) {
+        try {
+          source = await this._fetchCrdtSource(canonicalPath);
+        } catch (err) {
+          throw new Error(
+            `CRDT feed unavailable for '${canonicalPath}' (imported from '${importedBy}'): ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      } else {
+        try {
+          const reader = options.readFile ?? this._defaultReader();
+          source = await reader(canonicalPath);
+        } catch {
+          throw new Error(`File not found: '${canonicalPath}' (imported from '${importedBy}')`);
+        }
+      }
+      const { HoloScriptPlusParser } = await import('./HoloScriptPlusParser-F2Z56FJR.js');
+      const parser = new HoloScriptPlusParser({ enableTypeScriptImports: true });
+      const result = parser.parse(source);
+      if (!result.success && result.errors.length > 0) {
+        throw new Error(
+          `Parse error in '${canonicalPath}': ${result.errors[0]?.message ?? "unknown error"}`
+        );
+      }
+      const exports$1 = this._extractExports(result);
+      const transitiveDeps = [];
+      const subImports = result.ast?.imports ?? [];
+      const baseDir = canonicalPath.replace(/\/[^/]+$/, "");
+      for (const subImp of subImports) {
+        const subPath = isRegistryImport(subImp.path) || isCrdtImport(subImp.path) ? subImp.path : resolveImportPath(subImp.path, baseDir);
+        transitiveDeps.push(subPath);
+        if (!this.cache.has(subPath)) {
+          try {
+            const subMod = await this._resolveModule(
+              subPath,
+              canonicalPath,
+              options,
+              depth + 1,
+              errors
+            );
+            for (const [k, v] of subMod.exports) {
+              if (!exports$1.has(k)) exports$1.set(k, v);
+            }
+          } catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            errors.push({
+              importPath: subImp.path,
+              message: msg,
+              code: msg.startsWith("Circular") ? "cycle" : msg.startsWith("Max depth") ? "max_depth" : msg.startsWith("Parse error") ? "parse_error" : msg.startsWith("Registry") ? "registry_unavailable" : "not_found",
+              ...msg.startsWith("Circular") ? { cycle: [subPath] } : {}
+            });
+          }
+        }
+      }
+      const mod = {
+        canonicalPath,
+        result,
+        exports: exports$1,
+        dependencies: transitiveDeps
+      };
+      this.cache.set(canonicalPath, mod);
+      return mod;
+    } finally {
+      this.inProgress.delete(canonicalPath);
+    }
+  }
+  /**
+   * Fetch native string sources from the local LoroText Holographic CRDT.
+   * This bridges the compiler directly into the decentralized HoloMesh feed.
+   */
+  async _fetchCrdtSource(importPath) {
+    if (importPath !== "crdt://holomesh/feed") {
+      throw new Error(`Unknown CRDT namespace. Only crdt://holomesh/feed is supported.`);
+    }
+    try {
+      const fsModule = "fs/promises";
+      const pathModule = "path";
+      const fs = await import(
+        /* webpackIgnore: true */
+        /* @vite-ignore */
+        fsModule
+      );
+      const path = await import(
+        /* webpackIgnore: true */
+        /* @vite-ignore */
+        pathModule
+      );
+      const pkgName = "@loro/loro";
+      const { LoroDoc } = await import(
+        /* webpackIgnore: true */
+        /* @vite-ignore */
+        pkgName
+      );
+      const crdtPath = path.resolve(process.cwd(), ".holomesh/worldstate.crdt");
+      const bytes = await fs.readFile(crdtPath);
+      const doc = new LoroDoc();
+      doc.import(bytes);
+      const feed = doc.getText("feed");
+      return feed.toString();
+    } catch (e) {
+      throw new Error(`CRDT Sync Error: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  /**
+   * Fetch source code from the community registry for @username/name imports.
+   * Calls GET {registryBaseUrl}/api/scene/{name} and returns the scene code.
+   */
+  async _fetchRegistrySource(importPath, registryBaseUrl) {
+    const parsed = parseRegistryImport(importPath);
+    if (!parsed) {
+      throw new Error(`Invalid registry import path: '${importPath}'`);
+    }
+    const url = `${registryBaseUrl.replace(/\/$/, "")}/api/registry/${encodeURIComponent(parsed.username)}/${encodeURIComponent(parsed.name)}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Registry returned ${response.status} for '${importPath}'`);
+    }
+    const data = await response.json();
+    if (!data.code || typeof data.code !== "string") {
+      throw new Error(`Registry returned no code for '${importPath}'`);
+    }
+    return data.code;
+  }
+  /**
+   * Extract @exported nodes from a parse result.
+   *
+   * Handles two AST shapes that HoloScriptPlusParser can produce:
+   * 1. Single node file: result.ast.root IS the node; its directives contain @export
+   * 2. Fragment file: result.ast.root.children[] are nodes, each may have @export directives
+   */
+  _extractExports(result) {
+    const exports$1 = /* @__PURE__ */ new Map();
+    const ast = result.ast;
+    if (!ast) return exports$1;
+    const root = ast.root;
+    if (!root) return exports$1;
+    const seen = /* @__PURE__ */ new Set();
+    const nodesToCheck = [];
+    const addNode = (n) => {
+      if (!n || typeof n !== "object") return;
+      const node = n;
+      if (!seen.has(node)) {
+        seen.add(node);
+        nodesToCheck.push(node);
+      }
+    };
+    addNode(root);
+    if (Array.isArray(root.children)) {
+      for (const child of root.children) addNode(child);
+    }
+    if (Array.isArray(ast.body)) {
+      for (const n of ast.body) addNode(n);
+    }
+    if (Array.isArray(ast.children)) {
+      for (const n of ast.children) addNode(n);
+    }
+    for (const node of nodesToCheck) {
+      const nodeRec = node;
+      const directives = nodeRec.directives ?? [];
+      const exportDir = directives.find((d) => d?.type === "export");
+      if (exportDir) {
+        const exportName = exportDir.exportName ?? nodeRec.id ?? nodeRec.name ?? nodeRec.type;
+        exports$1.set(exportName, node);
+      }
+    }
+    return exports$1;
+  }
+  /**
+   * Default Node.js file reader. Only used on server-side / CLI.
+   * Throws in environments without the 'fs' module (browser, XR).
+   */
+  _defaultReader() {
+    return async (filePath) => {
+      try {
+        const fsModule = "fs/promises";
+        const fs = await import(
+          /* webpackIgnore: true */
+          /* @vite-ignore */
+          fsModule
+        );
+        return await fs.readFile(filePath, "utf-8");
+      } catch {
+        throw new Error(
+          `Cannot read '${filePath}': no readFile option provided and fs is unavailable`
+        );
+      }
+    };
+  }
+  /** Clear the module cache (useful between test runs) */
+  clearCache() {
+    this.cache.clear();
+    this.inProgress.clear();
+  }
+  /** Return the set of canonical paths currently cached */
+  getCachedPaths() {
+    return [...this.cache.keys()];
+  }
+  /** Return a resolved module from cache, or undefined */
+  getCached(canonicalPath) {
+    return this.cache.get(canonicalPath);
+  }
+};
+
+// src/compiler/SemanticCache.ts
+init_safeJsonParse();
+function hashSourceCode(source) {
+  return createHash("sha256").update(source, "utf8").digest("hex");
+}
+function generateCacheKey(contentHash, type, prefix) {
+  return `${prefix}:${type}:${contentHash}`;
+}
+function serializeASTNode(node) {
+  return JSON.stringify(node, null, 0);
+}
+function hashASTSubtree(node) {
+  const serialized = serializeASTNode(node);
+  return hashSourceCode(serialized);
+}
+var SemanticCache = class {
+  constructor(options = {}) {
+    this.redis = null;
+    this.memoryCache = /* @__PURE__ */ new Map();
+    this.stats = {
+      hits: 0,
+      misses: 0,
+      totalLatencyMs: 0,
+      lookupCount: 0
+    };
+    this.redisConnected = false;
+    this.initialized = false;
+    this.options = {
+      redisUrl: options.redisUrl ?? "redis://localhost:6379",
+      keyPrefix: options.keyPrefix ?? "holoscript:semantic",
+      ttl: options.ttl ?? 7 * 24 * 60 * 60,
+      // 7 days in seconds
+      version: options.version ?? "1.0.0",
+      debug: options.debug ?? false,
+      connectionTimeout: options.connectionTimeout ?? 5e3,
+      maxRetries: options.maxRetries ?? 3
+    };
+  }
+  /**
+   * Initialize the cache (connect to Redis if available)
+   */
+  async initialize() {
+    if (this.initialized) return;
+    try {
+      const Redis = await this.loadRedisClient();
+      if (Redis) {
+        this.redis = new Redis(this.options.redisUrl, {
+          connectTimeout: this.options.connectionTimeout,
+          maxRetriesPerRequest: this.options.maxRetries,
+          lazyConnect: true,
+          enableOfflineQueue: false
+        });
+        this.redis.on("connect", () => {
+          this.redisConnected = true;
+          this.log("Redis connected");
+        });
+        this.redis.on("error", (error) => {
+          this.log(`Redis error: ${error.message}`);
+          this.redisConnected = false;
+        });
+        this.redis.on("close", () => {
+          this.redisConnected = false;
+          this.log("Redis disconnected");
+        });
+        await this.redis.ping();
+        this.redisConnected = true;
+        this.log("Redis cache initialized");
+      }
+    } catch (error) {
+      this.log(`Redis initialization failed: ${error}. Falling back to in-memory cache.`);
+      this.redis = null;
+      this.redisConnected = false;
+    }
+    this.initialized = true;
+    this.log(`Semantic cache initialized (backend: ${this.getBackend()})`);
+  }
+  /**
+   * Load Redis client dynamically (optional dependency)
+   */
+  async loadRedisClient() {
+    try {
+      const ioredis = await import('ioredis');
+      return ioredis.default;
+    } catch (error) {
+      this.log("ioredis not installed, using in-memory cache");
+      return null;
+    }
+  }
+  /**
+   * Get cache entry
+   */
+  async get(contentHash, type) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    const startTime = Date.now();
+    const key = generateCacheKey(contentHash, type, this.options.keyPrefix);
+    try {
+      let entry = null;
+      if (this.redis && this.redisConnected) {
+        const raw = await this.redis.get(key);
+        if (raw) {
+          entry = readJson(raw);
+        }
+      } else {
+        const memEntry = this.memoryCache.get(key);
+        if (memEntry) {
+          entry = memEntry;
+        }
+      }
+      const latencyMs = Date.now() - startTime;
+      this.stats.totalLatencyMs += latencyMs;
+      this.stats.lookupCount++;
+      if (!entry) {
+        this.stats.misses++;
+        return {
+          hit: false,
+          reason: "not_found",
+          latencyMs
+        };
+      }
+      if (entry.version !== this.options.version) {
+        this.stats.misses++;
+        await this.delete(contentHash, type);
+        return {
+          hit: false,
+          reason: "version_mismatch",
+          latencyMs
+        };
+      }
+      if (!this.redis) {
+        const age = Date.now() - entry.createdAt;
+        const ttlMs = this.options.ttl * 1e3;
+        if (age > ttlMs) {
+          this.stats.misses++;
+          this.memoryCache.delete(key);
+          return {
+            hit: false,
+            reason: "expired",
+            latencyMs
+          };
+        }
+      }
+      entry.accessedAt = Date.now();
+      entry.accessCount++;
+      if (this.redis && this.redisConnected) {
+        await this.redis.set(key, JSON.stringify(entry), "EX", this.options.ttl);
+      } else {
+        this.memoryCache.set(key, entry);
+      }
+      this.stats.hits++;
+      this.log(`Cache HIT: ${type} (${contentHash.slice(0, 8)}...) [${latencyMs}ms]`);
+      return {
+        hit: true,
+        entry,
+        latencyMs
+      };
+    } catch (error) {
+      this.stats.misses++;
+      this.log(`Cache lookup error: ${error}`);
+      return {
+        hit: false,
+        reason: "redis_error",
+        latencyMs: Date.now() - startTime
+      };
+    }
+  }
+  /**
+   * Set cache entry
+   */
+  async set(contentHash, type, data, options) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    const key = generateCacheKey(contentHash, type, this.options.keyPrefix);
+    const serialized = JSON.stringify(data);
+    const entry = {
+      contentHash,
+      type,
+      data,
+      sourcePath: options?.sourcePath,
+      dependencies: options?.dependencies,
+      createdAt: Date.now(),
+      accessedAt: Date.now(),
+      accessCount: 0,
+      size: serialized.length,
+      version: this.options.version
+    };
+    try {
+      if (this.redis && this.redisConnected) {
+        await this.redis.set(key, JSON.stringify(entry), "EX", this.options.ttl);
+      } else {
+        this.memoryCache.set(key, entry);
+      }
+      this.log(`Cache SET: ${type} (${contentHash.slice(0, 8)}...) [${entry.size} bytes]`);
+    } catch (error) {
+      this.log(`Cache set error: ${error}`);
+    }
+  }
+  /**
+   * Delete cache entry
+   */
+  async delete(contentHash, type) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    const key = generateCacheKey(contentHash, type, this.options.keyPrefix);
+    try {
+      if (this.redis && this.redisConnected) {
+        await this.redis.del(key);
+      } else {
+        this.memoryCache.delete(key);
+      }
+      this.log(`Cache DELETE: ${type} (${contentHash.slice(0, 8)}...)`);
+    } catch (error) {
+      this.log(`Cache delete error: ${error}`);
+    }
+  }
+  /**
+   * Invalidate all cache entries for a type
+   */
+  async invalidateType(type) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    let count = 0;
+    try {
+      if (this.redis && this.redisConnected) {
+        const pattern = `${this.options.keyPrefix}:${type}:*`;
+        const keys = await this.redis.keys(pattern);
+        for (const key of keys) {
+          await this.redis.del(key);
+          count++;
+        }
+      } else {
+        for (const [key, entry] of this.memoryCache.entries()) {
+          if (entry.type === type) {
+            this.memoryCache.delete(key);
+            count++;
+          }
+        }
+      }
+      this.log(`Invalidated ${count} entries of type: ${type}`);
+    } catch (error) {
+      this.log(`Cache invalidation error: ${error}`);
+    }
+    return count;
+  }
+  /**
+   * Clear all cache entries
+   */
+  async clear() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    try {
+      if (this.redis && this.redisConnected) {
+        const pattern = `${this.options.keyPrefix}:*`;
+        const keys = await this.redis.keys(pattern);
+        for (const key of keys) {
+          await this.redis.del(key);
+        }
+      } else {
+        this.memoryCache.clear();
+      }
+      this.stats.hits = 0;
+      this.stats.misses = 0;
+      this.stats.totalLatencyMs = 0;
+      this.stats.lookupCount = 0;
+      this.log("Cache cleared");
+    } catch (error) {
+      this.log(`Cache clear error: ${error}`);
+    }
+  }
+  /**
+   * Get cache statistics
+   */
+  async getStats() {
+    const totalRequests = this.stats.hits + this.stats.misses;
+    const hitRate = totalRequests > 0 ? this.stats.hits / totalRequests : 0;
+    const avgLatencyMs = this.stats.lookupCount > 0 ? this.stats.totalLatencyMs / this.stats.lookupCount : 0;
+    let totalEntries = 0;
+    const entriesByType = {
+      "ast-subtree": 0,
+      "compiled-module": 0,
+      "compiled-object": 0,
+      "trait-composition": 0,
+      "import-resolution": 0
+    };
+    try {
+      if (this.redis && this.redisConnected) {
+        const pattern = `${this.options.keyPrefix}:*`;
+        const keys = await this.redis.keys(pattern);
+        totalEntries = keys.length;
+        for (const key of keys) {
+          const parts = key.split(":");
+          const type = parts[2];
+          if (type in entriesByType) {
+            entriesByType[type]++;
+          }
+        }
+      } else {
+        totalEntries = this.memoryCache.size;
+        for (const entry of this.memoryCache.values()) {
+          entriesByType[entry.type]++;
+        }
+      }
+    } catch (error) {
+      this.log(`Stats error: ${error}`);
+    }
+    return {
+      hits: this.stats.hits,
+      misses: this.stats.misses,
+      hitRate,
+      avgLatencyMs,
+      totalEntries,
+      backend: this.getBackend(),
+      redisConnected: this.redisConnected,
+      entriesByType
+    };
+  }
+  /**
+   * Get cache backend type
+   */
+  getBackend() {
+    return this.redis && this.redisConnected ? "redis" : "memory";
+  }
+  /**
+   * Close Redis connection
+   */
+  async close() {
+    if (this.redis) {
+      try {
+        await this.redis.quit();
+        this.log("Redis connection closed");
+      } catch (error) {
+        this.log(`Error closing Redis: ${error}`);
+      }
+    }
+  }
+  /**
+   * Debug logging
+   */
+  log(message) {
+    if (this.options.debug) {
+      console.log(`[SemanticCache] ${message}`);
+    }
+  }
+};
+function createSemanticCache(options) {
+  return new SemanticCache(options);
+}
+
+// src/compiler/IncrementalCompiler.ts
+init_AgentRBAC();
+init_CompilerBase();
+init_safeJsonParse();
+function hashContent(content) {
+  let hash = 0;
+  for (let i = 0; i < content.length; i++) {
+    const char = content.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return hash.toString(36);
+}
+function hashConfig2(config) {
+  const keys = Object.keys(config).sort();
+  const parts = [];
+  for (const key of keys) {
+    const value = config[key];
+    parts.push(`${key}:${JSON.stringify(value)}`);
+  }
+  const str = parts.join("|");
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) + hash ^ str.charCodeAt(i);
+  }
+  return (hash >>> 0).toString(36);
+}
+function serializeObject(obj) {
+  return JSON.stringify({
+    name: obj.name,
+    properties: obj.properties,
+    traits: obj.traits,
+    children: obj.children?.map(serializeObject),
+    logic: obj.logic
+    // logic might not be directly on HoloObjectDecl but used in diff
+  });
+}
+function serializeProperty(prop) {
+  return JSON.stringify({ key: prop.key, value: prop.value });
+}
+var IncrementalCompiler = class _IncrementalCompiler {
+  constructor(traitGraph, options) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.previousAST = null;
+    this.stateSnapshot = null;
+    this.dependencyGraph = /* @__PURE__ */ new Map();
+    this.semanticCache = null;
+    /** Persistent disk cache keyed by provenance content-hash (paper-10). */
+    this.buildCache = null;
+    this.traitGraph = traitGraph || globalTraitGraph;
+    this.buildCache = options?.buildCache ?? null;
+    if (options?.enableSemanticCache) {
+      this.semanticCache = createSemanticCache({
+        redisUrl: options.redisUrl,
+        ttl: options.cacheTTL,
+        debug: false
+      });
+      this.semanticCache.initialize().catch((err) => {
+        console.warn(`Semantic cache initialization failed: ${err}`);
+        this.semanticCache = null;
+      });
+    }
+  }
+  /**
+   * Diff two ASTs and return the changes
+   */
+  diff(oldAST, newAST) {
+    const changes = [];
+    const addedObjects = [];
+    const removedObjects = [];
+    const modifiedObjects = [];
+    const unchangedObjects = [];
+    if (!oldAST) {
+      const allObjects = this.collectObjectNames(newAST);
+      return {
+        hasChanges: true,
+        changes: allObjects.map((name) => ({
+          type: "added",
+          path: [name],
+          nodeName: name,
+          nodeType: "object",
+          newValue: this.findObject(newAST, name)
+        })),
+        addedObjects: allObjects,
+        removedObjects: [],
+        modifiedObjects: [],
+        unchangedObjects: []
+      };
+    }
+    const oldObjects = /* @__PURE__ */ new Map();
+    const newObjects = /* @__PURE__ */ new Map();
+    this.collectObjects(oldAST, oldObjects);
+    this.collectObjects(newAST, newObjects);
+    for (const [name, obj] of newObjects) {
+      if (!oldObjects.has(name)) {
+        addedObjects.push(name);
+        changes.push({
+          type: "added",
+          path: [name],
+          nodeName: name,
+          nodeType: "object",
+          newValue: obj
+        });
+      }
+    }
+    for (const [name, obj] of oldObjects) {
+      if (!newObjects.has(name)) {
+        removedObjects.push(name);
+        changes.push({
+          type: "removed",
+          path: [name],
+          nodeName: name,
+          nodeType: "object",
+          oldValue: obj
+        });
+      }
+    }
+    for (const [name, newObj] of newObjects) {
+      if (oldObjects.has(name)) {
+        const oldObj = oldObjects.get(name);
+        const objectChanges = this.diffObject(oldObj, newObj, [name]);
+        if (objectChanges.length > 0) {
+          modifiedObjects.push(name);
+          changes.push(...objectChanges);
+        } else {
+          unchangedObjects.push(name);
+        }
+      }
+    }
+    return {
+      hasChanges: changes.length > 0,
+      changes,
+      addedObjects,
+      removedObjects,
+      modifiedObjects,
+      unchangedObjects
+    };
+  }
+  /**
+   * Diff two objects and return property-level changes
+   */
+  diffObject(oldObj, newObj, path) {
+    const changes = [];
+    const oldProps = new Map(oldObj.properties?.map((p) => [p.key, p]) || []);
+    const newProps = new Map(newObj.properties?.map((p) => [p.key, p]) || []);
+    for (const [key, newProp] of newProps) {
+      if (!oldProps.has(key)) {
+        changes.push({
+          type: "added",
+          path: [...path, key],
+          nodeName: key,
+          nodeType: "property",
+          newValue: newProp.value
+        });
+      } else {
+        const oldProp = oldProps.get(key);
+        if (serializeProperty(oldProp) !== serializeProperty(newProp)) {
+          changes.push({
+            type: "modified",
+            path: [...path, key],
+            nodeName: key,
+            nodeType: "property",
+            oldValue: oldProp.value,
+            newValue: newProp.value
+          });
+        }
+      }
+    }
+    for (const key of oldProps.keys()) {
+      if (!newProps.has(key)) {
+        changes.push({
+          type: "removed",
+          path: [...path, key],
+          nodeName: key,
+          nodeType: "property",
+          oldValue: oldProps.get(key).value
+        });
+      }
+    }
+    const oldTraitUsages = this.extractTraitUsages(oldObj.traits || []);
+    const newTraitUsages = this.extractTraitUsages(newObj.traits || []);
+    const oldTraitMap = new Map(oldTraitUsages.map((t) => [t.name, t]));
+    const newTraitMap = new Map(newTraitUsages.map((t) => [t.name, t]));
+    for (const [name, newTrait] of newTraitMap) {
+      if (!oldTraitMap.has(name)) {
+        changes.push({
+          type: "added",
+          path: [...path, "@" + name],
+          nodeName: name,
+          nodeType: "trait",
+          newValue: newTrait
+        });
+      }
+    }
+    for (const [name, oldTrait] of oldTraitMap) {
+      if (!newTraitMap.has(name)) {
+        changes.push({
+          type: "removed",
+          path: [...path, "@" + name],
+          nodeName: name,
+          nodeType: "trait",
+          oldValue: oldTrait
+        });
+      }
+    }
+    for (const [name, newTrait] of newTraitMap) {
+      const oldTrait = oldTraitMap.get(name);
+      if (oldTrait && oldTrait.configHash !== newTrait.configHash) {
+        changes.push({
+          type: "modified",
+          path: [...path, "@" + name],
+          nodeName: name,
+          nodeType: "trait",
+          oldValue: oldTrait,
+          newValue: newTrait
+        });
+      }
+    }
+    if (JSON.stringify(oldObj.logic) !== JSON.stringify(newObj.logic)) {
+      changes.push({
+        type: "modified",
+        path: [...path, "logic"],
+        nodeName: "logic",
+        nodeType: "logic",
+        oldValue: oldObj.logic,
+        newValue: newObj.logic
+      });
+    }
+    const oldChildren = new Map((oldObj.children || []).map((c) => [c.name, c]));
+    const newChildren = new Map((newObj.children || []).map((c) => [c.name, c]));
+    for (const [name, newChild] of newChildren) {
+      if (!oldChildren.has(name)) {
+        changes.push({
+          type: "added",
+          path: [...path, name],
+          nodeName: name,
+          nodeType: "object",
+          newValue: newChild
+        });
+      } else {
+        const childChanges = this.diffObject(oldChildren.get(name), newChild, [...path, name]);
+        changes.push(...childChanges);
+      }
+    }
+    for (const name of oldChildren.keys()) {
+      if (!newChildren.has(name)) {
+        changes.push({
+          type: "removed",
+          path: [...path, name],
+          nodeName: name,
+          nodeType: "object",
+          oldValue: oldChildren.get(name)
+        });
+      }
+    }
+    return changes;
+  }
+  /**
+   * Extract trait usages with config hashes from trait array
+   * Handles both string traits and trait objects with config
+   */
+  extractTraitUsages(traits) {
+    return traits.map((t) => {
+      if (typeof t === "string") {
+        return {
+          name: t,
+          config: {},
+          configHash: hashConfig2({})
+        };
+      }
+      if (t && typeof t === "object") {
+        const traitObj = t;
+        if ("name" in traitObj) {
+          const name = String(traitObj.name);
+          const config = {};
+          for (const [key, value] of Object.entries(traitObj)) {
+            if (key !== "name") {
+              config[key] = value;
+            }
+          }
+          return {
+            name,
+            config,
+            configHash: hashConfig2(config)
+          };
+        }
+        const keys = Object.keys(traitObj);
+        if (keys.length === 1) {
+          const name = keys[0];
+          const config = traitObj[name] || {};
+          return {
+            name,
+            config: typeof config === "object" ? config : {},
+            configHash: hashConfig2(typeof config === "object" ? config : {})
+          };
+        }
+      }
+      return {
+        name: String(t),
+        config: {},
+        configHash: hashConfig2({})
+      };
+    });
+  }
+  /**
+   * Collect all object names from a composition
+   */
+  collectObjectNames(composition) {
+    const names = [];
+    const collectFromObject = (obj) => {
+      names.push(obj.name);
+      obj.children?.forEach(collectFromObject);
+    };
+    composition.objects?.forEach(collectFromObject);
+    composition.spatialGroups?.forEach((group) => {
+      names.push(group.name);
+      group.objects?.forEach(collectFromObject);
+    });
+    return names;
+  }
+  /**
+   * Collect all objects into a map
+   */
+  collectObjects(composition, map) {
+    const collectFromObject = (obj) => {
+      map.set(obj.name, obj);
+      obj.children?.forEach(collectFromObject);
+    };
+    composition.objects?.forEach(collectFromObject);
+    composition.spatialGroups?.forEach((group) => {
+      group.objects?.forEach(collectFromObject);
+    });
+  }
+  /**
+   * Find an object by name in a composition
+   */
+  findObject(composition, name) {
+    const searchInObject = (obj) => {
+      if (obj.name === name) return obj;
+      for (const child of obj.children || []) {
+        const found = searchInObject(child);
+        if (found) return found;
+      }
+      return void 0;
+    };
+    for (const obj of composition.objects || []) {
+      const found = searchInObject(obj);
+      if (found) return found;
+    }
+    for (const group of composition.spatialGroups || []) {
+      for (const obj of group.objects || []) {
+        const found = searchInObject(obj);
+        if (found) return found;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Get cached compilation for an object if still valid
+   */
+  getCached(objectName, currentHash) {
+    const entry = this.cache.get(objectName);
+    if (entry && entry.hash === currentHash) {
+      return entry;
+    }
+    return null;
+  }
+  /**
+   * Store compilation result in cache
+   */
+  setCached(objectName, hash, compiledCode, dependencies) {
+    this.cache.set(objectName, {
+      hash,
+      compiledCode,
+      dependencies,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Save current state for hot reload
+   */
+  saveState(states) {
+    this.stateSnapshot = {
+      objectStates: new Map(states),
+      timestamp: Date.now()
+    };
+  }
+  /**
+   * Restore state after hot reload
+   */
+  restoreState() {
+    return this.stateSnapshot;
+  }
+  /**
+   * Clear state snapshot
+   */
+  clearState() {
+    this.stateSnapshot = null;
+  }
+  /**
+   * Update dependency graph
+   */
+  updateDependencies(objectName, dependencies) {
+    this.dependencyGraph.set(objectName, new Set(dependencies));
+  }
+  /**
+   * Get objects that depend on a given object
+   */
+  getDependents(objectName) {
+    const dependents = [];
+    for (const [name, deps] of this.dependencyGraph) {
+      if (deps.has(objectName)) {
+        dependents.push(name);
+      }
+    }
+    return dependents;
+  }
+  /**
+   * Get all objects that need recompilation due to a change
+   * Enhanced with trait-aware dependency tracking
+   */
+  getRecompilationSet(changedObjects) {
+    const toRecompile = new Set(changedObjects);
+    const queue = [...changedObjects];
+    while (queue.length > 0) {
+      const current = queue.shift();
+      const dependents = this.getDependents(current);
+      for (const dep of dependents) {
+        if (!toRecompile.has(dep)) {
+          toRecompile.add(dep);
+          queue.push(dep);
+        }
+      }
+    }
+    const traitRecompileSet = this.traitGraph.calculateRecompilationSet(changedObjects);
+    for (const obj of traitRecompileSet) {
+      toRecompile.add(obj);
+    }
+    return toRecompile;
+  }
+  /**
+   * Get trait changes for specific objects
+   * Used for fine-grained trait config change detection
+   */
+  getTraitChanges(objectName, newTraits) {
+    return this.traitGraph.detectTraitChanges(objectName, newTraits);
+  }
+  /**
+   * Get the trait dependency graph for external access
+   */
+  getTraitGraph() {
+    return this.traitGraph;
+  }
+  // ===========================================================================
+  // IMPORT RESOLUTION (Asset Pipeline)
+  // ===========================================================================
+  /**
+   * Resolve all `@import` directives in a `HSPlusCompileResult`, merge the
+   * imported exports into a scope, and register cross-file edges in the
+   * `TraitDependencyGraph` for incremental recompilation.
+   *
+   * This method is **async** because it may read files from disk (or any
+   * injected async reader).
+   *
+   * ### Typical usage
+   * ```ts
+   * const parser = new HoloScriptPlusParser({ enableTypeScriptImports: true });
+   * const result = parser.parse(source);
+   *
+   * const compiler = new IncrementalCompiler();
+   * const { importScope, importErrors } = await compiler.resolveImports(
+   *   result,
+   *   { baseDir: '/project', sourceFile: '/project/scene.hs' }
+   * );
+   * ```
+   *
+   * @param result     Parse result that may contain `ast.imports`
+   * @param options    Must include `baseDir` (and optionally `sourceFile`, `readFile`)
+   * @returns          `{ scope, modules, errors }` from `ImportResolver.resolve()`
+   */
+  async resolveImports(result, options) {
+    const baseDir = options.baseDir ?? "/";
+    const sourceFile = options.sourceFile ?? `${baseDir}/unknown.hs`;
+    const resolver = new ImportResolver();
+    const resolution = await resolver.resolve(result, sourceFile, {
+      baseDir,
+      readFile: options.readFile
+    });
+    const imports = result.ast?.imports ?? [];
+    this.traitGraph.clearImportsForFile(sourceFile);
+    for (const imp of imports) {
+      const canonicalPath = resolveImportPath(imp.path, baseDir);
+      this.traitGraph.registerImport(sourceFile, canonicalPath);
+    }
+    return resolution;
+  }
+  // ===========================================================================
+  // RBAC ENFORCEMENT
+  // ===========================================================================
+  /**
+   * Validate agent has permission for incremental compilation.
+   * Skips validation when no token is provided (backwards compatibility / testing).
+   */
+  validateAccess(agentToken) {
+    if (!agentToken) return;
+    const rbac = getRBAC();
+    const decision = rbac.checkAccess({
+      token: agentToken,
+      resourceType: "ast" /* AST */,
+      operation: "read",
+      expectedWorkflowStep: "generate_assembly" /* GENERATE_ASSEMBLY */
+    });
+    if (!decision.allowed) {
+      throw new UnauthorizedIncrementalCompilerAccessError(decision, "IncrementalCompiler");
+    }
+  }
+  /**
+   * Perform incremental compilation
+   */
+  async compile(newAST, compileObject, options = {}) {
+    const { preserveState = true, forceRecompile = [], skipUnchanged = true, agentToken } = options;
+    this.validateAccess(agentToken);
+    const diffResult = this.diff(this.previousAST, newAST);
+    const changedObjects = [
+      ...diffResult.addedObjects,
+      ...diffResult.modifiedObjects,
+      ...forceRecompile
+    ];
+    const recompileSet = this.getRecompilationSet(changedObjects);
+    for (const removed of diffResult.removedObjects) {
+      const dependents = this.getDependents(removed);
+      for (const dep of dependents) {
+        recompileSet.add(dep);
+      }
+    }
+    const recompiledObjects = [];
+    const cachedObjects = [];
+    const compiledParts = [];
+    const allObjects = /* @__PURE__ */ new Map();
+    this.collectObjects(newAST, allObjects);
+    for (const [name, obj] of allObjects) {
+      const hash = hashContent(serializeObject(obj));
+      const provenanceHash = computeContentHash(serializeObject(obj));
+      const traitUsages = this.extractTraitUsages(obj.traits || []);
+      this.traitGraph.registerObject({
+        objectName: name,
+        sourceId: newAST.name || "default",
+        traits: traitUsages,
+        template: obj.template
+      });
+      if (this.buildCache) {
+        const provResult = await this.buildCache.getByProvenanceHash(
+          provenanceHash,
+          "compiled"
+        );
+        if (provResult.hit) {
+          cachedObjects.push(name);
+          compiledParts.push(provResult.entry.data);
+          continue;
+        }
+      }
+      if (skipUnchanged && !recompileSet.has(name)) {
+        if (this.semanticCache) {
+          const astHash = hashASTSubtree(obj);
+          const semanticResult = await this.semanticCache.get(astHash, "compiled-object");
+          if (semanticResult.hit) {
+            cachedObjects.push(name);
+            compiledParts.push(semanticResult.entry.data);
+            continue;
+          }
+        }
+        const cached = this.getCached(name, hash);
+        if (cached) {
+          cachedObjects.push(name);
+          compiledParts.push(cached.compiledCode);
+          continue;
+        }
+      }
+      const compiled = compileObject(obj);
+      recompiledObjects.push(name);
+      compiledParts.push(compiled);
+      this.setCached(name, hash, compiled, []);
+      if (this.buildCache) {
+        await this.buildCache.setByProvenanceHash(provenanceHash, "compiled", compiled, {
+          tags: ["incremental-compiler", newAST.name || "unknown"]
+        });
+      }
+      if (this.semanticCache) {
+        const astHash = hashASTSubtree(obj);
+        await this.semanticCache.set(astHash, "compiled-object", compiled, {
+          sourcePath: newAST.name,
+          dependencies: []
+        });
+      }
+    }
+    this.previousAST = newAST;
+    return {
+      fullRecompile: cachedObjects.length === 0,
+      recompiledObjects,
+      cachedObjects,
+      statePreserved: preserveState && this.stateSnapshot !== null,
+      compiledCode: compiledParts.join("\n\n"),
+      changes: diffResult
+    };
+  }
+  /**
+   * Reset compiler state
+   */
+  reset() {
+    this.cache.clear();
+    this.previousAST = null;
+    this.stateSnapshot = null;
+    this.dependencyGraph.clear();
+  }
+  /**
+   * Get cache statistics including trait graph info
+   */
+  async getStats() {
+    let dependencyEdges = 0;
+    for (const deps of this.dependencyGraph.values()) {
+      dependencyEdges += deps.size;
+    }
+    const stats = {
+      cacheSize: this.cache.size,
+      objectsCached: Array.from(this.cache.keys()),
+      dependencyEdges,
+      traitGraphStats: this.traitGraph.getStats()
+    };
+    if (this.semanticCache) {
+      const semanticStats = await this.semanticCache.getStats();
+      return {
+        ...stats,
+        semanticCache: semanticStats
+      };
+    }
+    return stats;
+  }
+  /**
+   * Get semantic cache statistics
+   */
+  async getSemanticCacheStats() {
+    if (!this.semanticCache) {
+      return null;
+    }
+    return this.semanticCache.getStats();
+  }
+  /**
+   * Clear semantic cache
+   */
+  async clearSemanticCache() {
+    if (this.semanticCache) {
+      await this.semanticCache.clear();
+    }
+  }
+  /**
+   * Close semantic cache connection
+   */
+  async closeSemanticCache() {
+    if (this.semanticCache) {
+      await this.semanticCache.close();
+    }
+  }
+  /**
+   * Serialize compiler state for persistence
+   * Includes cache, dependency graph, and trait graph
+   */
+  serialize() {
+    const data = {
+      version: 1,
+      entries: Array.from(this.cache.entries()).map(([name, entry]) => ({
+        name,
+        entry
+      })),
+      dependencies: Array.from(this.dependencyGraph.entries()).map(([name, deps]) => ({
+        name,
+        deps: Array.from(deps)
+      })),
+      traitGraph: this.traitGraph.serialize(),
+      timestamp: Date.now()
+    };
+    return JSON.stringify(data);
+  }
+  /**
+   * Restore compiler state from serialized data
+   */
+  static deserialize(json) {
+    const data = readJson(json);
+    if (data.version !== 1) {
+      throw new Error(`Unsupported cache version: ${data.version}`);
+    }
+    const traitGraph = TraitDependencyGraph.deserialize(data.traitGraph);
+    const compiler = new _IncrementalCompiler(traitGraph);
+    for (const { name, entry } of data.entries) {
+      compiler.cache.set(name, entry);
+    }
+    for (const { name, deps } of data.dependencies) {
+      compiler.dependencyGraph.set(name, new Set(deps));
+    }
+    return compiler;
+  }
+};
+function createIncrementalCompiler() {
+  return new IncrementalCompiler();
+}
+function serializeCache(compiler) {
+  compiler.getStats();
+  const data = {
+    version: 1,
+    entries: [],
+    dependencies: [],
+    traitGraph: compiler.getTraitGraph().serialize(),
+    timestamp: Date.now()
+  };
+  return JSON.stringify(data);
+}
+function deserializeCache(json) {
+  const data = readJson(json);
+  if (data.version !== 1) {
+    throw new Error(`Unsupported cache version: ${data.version}`);
+  }
+  const traitGraph = TraitDependencyGraph.deserialize(data.traitGraph);
+  const compiler = new IncrementalCompiler(traitGraph);
+  for (const { name, entry } of data.entries) {
+    compiler.setCached(name, entry.hash, entry.compiledCode, entry.dependencies);
+  }
+  for (const { name, deps } of data.dependencies) {
+    compiler.updateDependencies(name, deps);
+  }
+  return compiler;
+}
+var UnauthorizedIncrementalCompilerAccessError = class extends UnauthorizedCompilerAccessError {
+  constructor(decision, compilerName) {
+    super(decision, "incremental compilation", compilerName);
+    this.name = "UnauthorizedIncrementalCompilerAccessError";
+  }
+};
+
+export { IncrementalCompiler, TraitDependencyGraph, UnauthorizedIncrementalCompilerAccessError, createIncrementalCompiler, deserializeCache, globalTraitGraph, serializeCache };
+//# sourceMappingURL=chunk-GYZE55MO.js.map
+//# sourceMappingURL=chunk-GYZE55MO.js.map