@holoscript/core 6.0.4 → 7.0.0

package/dist/chunk-FSF7EQVA.cjs

@@ -1,1974 +0,0 @@
-'use strict';
-
-var crypto = require('crypto');
-var platform = require('@holoscript/platform');
-
-// src/compiler/TraitDependencyGraph.ts
-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 = JSON.parse(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('./parser.cjs');
-      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 fs = await import('fs/promises');
-      const path = await import('path');
-      const pkgName = "@loro/loro";
-      const { LoroDoc } = await import(
-        /* @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 fs = await import('fs/promises');
-        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);
-  }
-};
-function hashSourceCode(source) {
-  return crypto.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 = JSON.parse(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);
-}
-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;
-    this.traitGraph = traitGraph || globalTraitGraph;
-    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 = platform.getRBAC();
-    const decision = rbac.checkAccess({
-      token: agentToken,
-      resourceType: platform.ResourceType.AST,
-      operation: "read",
-      expectedWorkflowStep: platform.WorkflowStep.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 traitUsages = this.extractTraitUsages(obj.traits || []);
-      this.traitGraph.registerObject({
-        objectName: name,
-        sourceId: newAST.name || "default",
-        traits: traitUsages,
-        template: obj.template
-      });
-      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.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 = JSON.parse(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 = JSON.parse(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 Error {
-  constructor(decision, compilerName) {
-    super(
-      `[${compilerName}] Unauthorized access: ${decision.reason || "Access denied"}
-Agent Role: ${decision.agentRole || "unknown"}
-Required Permission: ${decision.requiredPermission || "unknown"}`
-    );
-    this.decision = decision;
-    this.compilerName = compilerName;
-    this.name = "UnauthorizedIncrementalCompilerAccessError";
-  }
-};
-
-exports.IncrementalCompiler = IncrementalCompiler;
-exports.TraitDependencyGraph = TraitDependencyGraph;
-exports.UnauthorizedIncrementalCompilerAccessError = UnauthorizedIncrementalCompilerAccessError;
-exports.createIncrementalCompiler = createIncrementalCompiler;
-exports.deserializeCache = deserializeCache;
-exports.globalTraitGraph = globalTraitGraph;
-exports.serializeCache = serializeCache;
-//# sourceMappingURL=chunk-FSF7EQVA.cjs.map
-//# sourceMappingURL=chunk-FSF7EQVA.cjs.map