@holoscript/core 8.0.14 → 8.0.15

package/dist/compiler/index.cjs

@@ -1,71 +1,71 @@
 'use strict';
 
-var chunkYM7UUYR5_cjs = require('../chunk-YM7UUYR5.cjs');
-var chunkD44CEFY4_cjs = require('../chunk-D44CEFY4.cjs');
-var chunk7ITJP33Q_cjs = require('../chunk-7ITJP33Q.cjs');
+var chunkXHZYS4QO_cjs = require('../chunk-XHZYS4QO.cjs');
+var chunk2DJIS7TH_cjs = require('../chunk-2DJIS7TH.cjs');
+var chunk4CQ7ULXZ_cjs = require('../chunk-4CQ7ULXZ.cjs');
 var chunkOV46CCA2_cjs = require('../chunk-OV46CCA2.cjs');
 var chunkS6YWHCKV_cjs = require('../chunk-S6YWHCKV.cjs');
 var chunkVJ3L7CHT_cjs = require('../chunk-VJ3L7CHT.cjs');
-var chunkGGH3ZYDB_cjs = require('../chunk-GGH3ZYDB.cjs');
-var chunkCESMPUEZ_cjs = require('../chunk-CESMPUEZ.cjs');
+var chunkIPBSNGAN_cjs = require('../chunk-IPBSNGAN.cjs');
+var chunkPHLNABJD_cjs = require('../chunk-PHLNABJD.cjs');
 var chunkFT6TDR2O_cjs = require('../chunk-FT6TDR2O.cjs');
 require('../chunk-LDYZWNJW.cjs');
-var chunk4CRMVEON_cjs = require('../chunk-4CRMVEON.cjs');
+var chunkF47FEV4X_cjs = require('../chunk-F47FEV4X.cjs');
 require('../chunk-KROXXBK5.cjs');
-var chunkOOP4S3GU_cjs = require('../chunk-OOP4S3GU.cjs');
+var chunkOQVHCYY4_cjs = require('../chunk-OQVHCYY4.cjs');
 var chunkGKFCHGCM_cjs = require('../chunk-GKFCHGCM.cjs');
 var chunkI6XZ5DZF_cjs = require('../chunk-I6XZ5DZF.cjs');
 var chunkXUILI4KB_cjs = require('../chunk-XUILI4KB.cjs');
 var chunkQHSAVOOL_cjs = require('../chunk-QHSAVOOL.cjs');
-var chunkYMI3ED3B_cjs = require('../chunk-YMI3ED3B.cjs');
-var chunkML4V5PVU_cjs = require('../chunk-ML4V5PVU.cjs');
+var chunkCRUIGXF7_cjs = require('../chunk-CRUIGXF7.cjs');
+var chunkX5ZLSPU2_cjs = require('../chunk-X5ZLSPU2.cjs');
 require('../chunk-YKY2JBER.cjs');
-require('../chunk-QQFB4RT2.cjs');
+require('../chunk-BTVHY3UB.cjs');
 var chunkN2ILK7BF_cjs = require('../chunk-N2ILK7BF.cjs');
 require('../chunk-DN6F4DHH.cjs');
 require('../chunk-XHIV6326.cjs');
 require('../chunk-3FOKASKO.cjs');
 require('../chunk-ENZCIQZC.cjs');
 require('../chunk-4PDEPEQW.cjs');
-var chunk5B2AJKA5_cjs = require('../chunk-5B2AJKA5.cjs');
-var chunkKLM6QD6D_cjs = require('../chunk-KLM6QD6D.cjs');
-var chunkSKVBUGMC_cjs = require('../chunk-SKVBUGMC.cjs');
-var chunkVZI7S7P6_cjs = require('../chunk-VZI7S7P6.cjs');
+var chunkFQ4MYZYU_cjs = require('../chunk-FQ4MYZYU.cjs');
+var chunkQ6VW7MGX_cjs = require('../chunk-Q6VW7MGX.cjs');
+var chunkAUMTQV64_cjs = require('../chunk-AUMTQV64.cjs');
+var chunkVSO6HPDZ_cjs = require('../chunk-VSO6HPDZ.cjs');
 require('../chunk-V6GXFSK7.cjs');
-var chunkPZ46WRHX_cjs = require('../chunk-PZ46WRHX.cjs');
+var chunkXRQCTTDC_cjs = require('../chunk-XRQCTTDC.cjs');
 require('../chunk-R75BSDH7.cjs');
-var chunkXZC75AJ4_cjs = require('../chunk-XZC75AJ4.cjs');
-var chunkREN3LHO6_cjs = require('../chunk-REN3LHO6.cjs');
+var chunkFPGYWNNA_cjs = require('../chunk-FPGYWNNA.cjs');
+var chunkQKLEDRHN_cjs = require('../chunk-QKLEDRHN.cjs');
 require('../chunk-CFVK26P4.cjs');
-var chunkGYJLP4BO_cjs = require('../chunk-GYJLP4BO.cjs');
-var chunkFOM36K5I_cjs = require('../chunk-FOM36K5I.cjs');
-var chunkSNMQUWIO_cjs = require('../chunk-SNMQUWIO.cjs');
-var chunkERYKKPHW_cjs = require('../chunk-ERYKKPHW.cjs');
-var chunkOSKGCXAQ_cjs = require('../chunk-OSKGCXAQ.cjs');
-var chunkB6JHTTMR_cjs = require('../chunk-B6JHTTMR.cjs');
+var chunkK53L47NH_cjs = require('../chunk-K53L47NH.cjs');
+var chunkJ74S4ZMF_cjs = require('../chunk-J74S4ZMF.cjs');
+var chunkNTSLNIY7_cjs = require('../chunk-NTSLNIY7.cjs');
+var chunkU6CQOM5Q_cjs = require('../chunk-U6CQOM5Q.cjs');
+var chunkFGTXAVKG_cjs = require('../chunk-FGTXAVKG.cjs');
+var chunkN2BOTBPG_cjs = require('../chunk-N2BOTBPG.cjs');
 require('../chunk-356N4NPM.cjs');
-var chunkVTFLKSJL_cjs = require('../chunk-VTFLKSJL.cjs');
-var chunkVA7THINF_cjs = require('../chunk-VA7THINF.cjs');
-var chunkLQNL3IYV_cjs = require('../chunk-LQNL3IYV.cjs');
-require('../chunk-FHR2AVMA.cjs');
+var chunkZHW6TDZ6_cjs = require('../chunk-ZHW6TDZ6.cjs');
+var chunkZXXC2GXB_cjs = require('../chunk-ZXXC2GXB.cjs');
+var chunkLNJKBQ2B_cjs = require('../chunk-LNJKBQ2B.cjs');
+require('../chunk-LJTM5ONX.cjs');
 var chunkTZCFKZ6Z_cjs = require('../chunk-TZCFKZ6Z.cjs');
-var chunkHCONR4J6_cjs = require('../chunk-HCONR4J6.cjs');
-require('../chunk-P65OIMJT.cjs');
+var chunkAN3ZH7M7_cjs = require('../chunk-AN3ZH7M7.cjs');
+require('../chunk-IYK6LMQ7.cjs');
 var chunkVHORVGCG_cjs = require('../chunk-VHORVGCG.cjs');
-var chunkSE2Y5BSL_cjs = require('../chunk-SE2Y5BSL.cjs');
+var chunkCMEINO5I_cjs = require('../chunk-CMEINO5I.cjs');
 var chunk7FYSSI3C_cjs = require('../chunk-7FYSSI3C.cjs');
 require('../chunk-CI33NINL.cjs');
 require('../chunk-VW5CRJBE.cjs');
 require('../chunk-HCX4SMFK.cjs');
 require('../chunk-3VBO3IYQ.cjs');
 require('../chunk-YP5CHEYU.cjs');
-require('../chunk-EI3J6LTW.cjs');
-require('../chunk-36NPLOI4.cjs');
+require('../chunk-6RDHWSZM.cjs');
+require('../chunk-JERWCCEJ.cjs');
 require('../chunk-AWXFEAQL.cjs');
 require('../chunk-4FIBOJW6.cjs');
 require('../chunk-N74QRJGP.cjs');
 var chunkGJNCFRJU_cjs = require('../chunk-GJNCFRJU.cjs');
-require('../chunk-SJIRCTIS.cjs');
+require('../chunk-HSGJFCVJ.cjs');
 require('../chunk-ILRBGFVD.cjs');
 require('../chunk-ESBXUYOC.cjs');
 var chunkQ47JEE2C_cjs = require('../chunk-Q47JEE2C.cjs');
@@ -74,28 +74,102 @@ var ans = require('@holoscript/core-types/ans');
 var crypto = require('crypto');
 
 // src/compiler/index.ts
-chunkSE2Y5BSL_cjs.init_CompilerBase();
-chunkSE2Y5BSL_cjs.init_CompilerDocumentationGenerator();
+chunkCMEINO5I_cjs.init_CompilerBase();
+chunkCMEINO5I_cjs.init_CompilerDocumentationGenerator();
+
+// src/compiler/SceneIRTsxEmitter.ts
+var GENERATED_HEADER = "// @generated by HoloScript SceneIRTsxEmitter -- DO NOT EDIT";
+function emitSceneIRTsx(root, options = {}) {
+  const componentName = sanitizeComponentName(options.componentName ?? root.id ?? "HoloScene");
+  const sceneConstName = `${componentName}SceneIR`;
+  const imports = [
+    options.includeCanvas ?? true ? "import { Canvas } from '@react-three/fiber';" : "",
+    "import { HoloSceneIRRenderer } from '@holoscript/r3f-renderer';"
+  ].filter(Boolean);
+  const source = options.sourcePath ? `// source: ${options.sourcePath}
+` : "";
+  if (options.includeCanvas === false) {
+    return [
+      GENERATED_HEADER,
+      source.trimEnd(),
+      ...imports,
+      "",
+      `const ${sceneConstName} = ${json(root)};`,
+      "",
+      `export function ${componentName}() {`,
+      `  return <HoloSceneIRRenderer node={${sceneConstName}} />;`,
+      "}",
+      "",
+      `export default ${componentName};`,
+      ""
+    ].filter((line, idx) => line !== "" || idx !== 1).join("\n");
+  }
+  return [
+    GENERATED_HEADER,
+    source.trimEnd(),
+    ...imports,
+    "",
+    `const ${sceneConstName} = ${json(root)};`,
+    "",
+    `export function ${componentName}() {`,
+    "  return (",
+    "    <Canvas>",
+    `      <HoloSceneIRRenderer node={${sceneConstName}} />`,
+    "    </Canvas>",
+    "  );",
+    "}",
+    "",
+    `export default ${componentName};`,
+    ""
+  ].filter((line, idx) => line !== "" || idx !== 1).join("\n");
+}
+function sanitizeComponentName(name) {
+  const words = name.replace(/[^A-Za-z0-9_$]+/g, " ").trim().split(/\s+/).filter(Boolean);
+  const joined = words.map((word) => word[0].toUpperCase() + word.slice(1)).join("");
+  const candidate = joined || "HoloScene";
+  return /^[A-Za-z_$]/.test(candidate) ? candidate : `HoloScene${candidate}`;
+}
+function json(value) {
+  return JSON.stringify(normalizeValue(value), null, 2).replace(/</g, "\\u003c");
+}
+function normalizeValue(value) {
+  if (ArrayBuffer.isView(value) && !(value instanceof DataView)) {
+    return Array.from(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => normalizeValue(entry));
+  }
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) {
+      out[key] = normalizeValue(entry);
+    }
+    return out;
+  }
+  return value;
+}
+
+// src/compiler/index.ts
 chunkVHORVGCG_cjs.init_PerceptualColorPass();
-chunkLQNL3IYV_cjs.init_UnityCompiler();
-chunkHCONR4J6_cjs.init_GodotCompiler();
-chunkVTFLKSJL_cjs.init_OpenXRCompiler();
-chunkVA7THINF_cjs.init_VRChatCompiler();
-chunkFOM36K5I_cjs.init_VisionOSCompiler();
-chunkXZC75AJ4_cjs.init_AndroidCompiler();
-chunkREN3LHO6_cjs.init_AndroidXRCompiler();
-chunkGYJLP4BO_cjs.init_IOSCompiler();
-chunkSNMQUWIO_cjs.init_WASMCompiler();
-chunkERYKKPHW_cjs.init_WebGPUCompiler();
+chunkLNJKBQ2B_cjs.init_UnityCompiler();
+chunkAN3ZH7M7_cjs.init_GodotCompiler();
+chunkZHW6TDZ6_cjs.init_OpenXRCompiler();
+chunkZXXC2GXB_cjs.init_VRChatCompiler();
+chunkJ74S4ZMF_cjs.init_VisionOSCompiler();
+chunkFPGYWNNA_cjs.init_AndroidCompiler();
+chunkQKLEDRHN_cjs.init_AndroidXRCompiler();
+chunkK53L47NH_cjs.init_IOSCompiler();
+chunkNTSLNIY7_cjs.init_WASMCompiler();
+chunkU6CQOM5Q_cjs.init_WebGPUCompiler();
 chunkTZCFKZ6Z_cjs.init_PlatformConditionalCompilerMixin();
-chunkKLM6QD6D_cjs.init_SDFCompiler();
-chunkOSKGCXAQ_cjs.init_DTDLCompiler();
-chunkB6JHTTMR_cjs.init_URDFCompiler();
-chunkSKVBUGMC_cjs.init_StateCompiler();
+chunkQ6VW7MGX_cjs.init_SDFCompiler();
+chunkFGTXAVKG_cjs.init_DTDLCompiler();
+chunkN2BOTBPG_cjs.init_URDFCompiler();
+chunkAUMTQV64_cjs.init_StateCompiler();
 
 // src/compiler/MultiLayerCompiler.ts
-chunkSE2Y5BSL_cjs.init_CompilerBase();
-var MultiLayerCompiler = class extends chunkSE2Y5BSL_cjs.CompilerBase {
+chunkCMEINO5I_cjs.init_CompilerBase();
+var MultiLayerCompiler = class extends chunkCMEINO5I_cjs.CompilerBase {
   constructor(_options) {
     super();
     this.compilerName = "MultiLayerCompiler";
@@ -111,12 +185,12 @@ var MultiLayerCompiler = class extends chunkSE2Y5BSL_cjs.CompilerBase {
 };
 
 // src/compiler/NextJSCompiler.ts
-chunkSE2Y5BSL_cjs.init_CompilerBase();
+chunkCMEINO5I_cjs.init_CompilerBase();
 
 // src/compiler/Native2DCompiler.ts
-chunkSE2Y5BSL_cjs.init_CompilerBase();
+chunkCMEINO5I_cjs.init_CompilerBase();
 chunkQ47JEE2C_cjs.init_safeJsonParse();
-var _Native2DCompiler = class _Native2DCompiler extends chunkSE2Y5BSL_cjs.CompilerBase {
+var _Native2DCompiler = class _Native2DCompiler extends chunkCMEINO5I_cjs.CompilerBase {
   constructor() {
     super(...arguments);
     this.compilerName = "Native2DCompiler";
@@ -1810,7 +1884,7 @@ function findTrait(composition, traitName2) {
   const found = traits.find((t) => t.name === traitName2);
   return found?.config || null;
 }
-var NextJSCompiler = class extends chunkSE2Y5BSL_cjs.CompilerBase {
+var NextJSCompiler = class extends chunkCMEINO5I_cjs.CompilerBase {
   constructor(options = {}) {
     super();
     this.options = options;
@@ -1914,12 +1988,12 @@ var NextJSCompiler = class extends chunkSE2Y5BSL_cjs.CompilerBase {
 };
 
 // src/compiler/index.ts
-chunkCESMPUEZ_cjs.init_NextJSAPICompiler();
+chunkPHLNABJD_cjs.init_NextJSAPICompiler();
 
 // src/compiler/MCPConfigCompiler.ts
-chunkSE2Y5BSL_cjs.init_CompilerBase();
-chunkCESMPUEZ_cjs.init_DialectRegistry();
-var MCPConfigCompiler = class extends chunkSE2Y5BSL_cjs.CompilerBase {
+chunkCMEINO5I_cjs.init_CompilerBase();
+chunkPHLNABJD_cjs.init_DialectRegistry();
+var MCPConfigCompiler = class extends chunkCMEINO5I_cjs.CompilerBase {
   constructor(options = {}) {
     super();
     this.compilerName = "MCPConfigCompiler";
@@ -2115,7 +2189,7 @@ var MCPConfigCompiler = class extends chunkSE2Y5BSL_cjs.CompilerBase {
     return void 0;
   }
 };
-chunkCESMPUEZ_cjs.DialectRegistry.register({
+chunkPHLNABJD_cjs.DialectRegistry.register({
   name: "mcp-config",
   domain: "configuration",
   description: "Compiles .holo MCP server connection definitions to IDE-specific client config JSON",
@@ -2126,10 +2200,1310 @@ chunkCESMPUEZ_cjs.DialectRegistry.register({
 });
 
 // src/compiler/index.ts
-chunkCESMPUEZ_cjs.init_HoloMCPCompiler();
-chunkYMI3ED3B_cjs.init_AgentInferenceExportTarget();
-chunkCESMPUEZ_cjs.init_OmnigentAgentYamlCompiler();
-chunkOOP4S3GU_cjs.init_DaimonSeedCompiler();
+chunkPHLNABJD_cjs.init_HoloMCPCompiler();
+chunkCRUIGXF7_cjs.init_AgentInferenceExportTarget();
+chunkPHLNABJD_cjs.init_OmnigentAgentYamlCompiler();
+chunkOQVHCYY4_cjs.init_DaimonSeedCompiler();
+
+// src/compiler/HSIIRCompiler.ts
+chunkCMEINO5I_cjs.init_CompilerBase();
+var HSI_IR_SCHEMA_VERSION = "holoscript.hsi-ir.v0.1.0";
+var HSI_TRACE_SCHEMA_VERSION = "holoscript.hsi-trace.v0.1.0";
+var HSI_LEARNING_GRAPH_SCHEMA_VERSION = "holoscript.learning-graph.v0.1.0";
+var HSI_AUDIT_SCHEMA_VERSION = "holoscript.hsi-audit.v0.1.0";
+var HSIAdmissionError = class extends Error {
+  constructor(code, message) {
+    super(`[${code}] ${message}`);
+    this.name = "HSIAdmissionError";
+    this.code = code;
+  }
+};
+function hsiStableStringify(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value) ?? "null";
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => hsiStableStringify(item)).join(",")}]`;
+  }
+  const record = value;
+  const keys = Object.keys(record).filter((key) => record[key] !== void 0).sort();
+  return `{${keys.map((key) => `${JSON.stringify(key)}:${hsiStableStringify(record[key])}`).join(",")}}`;
+}
+function hsiSha256(value) {
+  return `sha256:${crypto.createHash("sha256").update(hsiStableStringify(value)).digest("hex")}`;
+}
+function hsiSourceTextDigest(source) {
+  return `sha256:${crypto.createHash("sha256").update(source.replace(/\r\n/g, "\n")).digest("hex")}`;
+}
+
+// src/compiler/HSIIRCompiler.ts
+var HSI_OBSERVATION_MEDIATOR_EDGE = "shields";
+var ASSIGN_OPERATORS = /* @__PURE__ */ new Set(["=", "+=", "-=", "*=", "/="]);
+var BINARY_OPERATORS = /* @__PURE__ */ new Set([
+  "+",
+  "-",
+  "*",
+  "/",
+  "%",
+  "===",
+  "!==",
+  "==",
+  "!=",
+  "<",
+  ">",
+  "<=",
+  ">=",
+  "&&",
+  "||"
+]);
+function spanOf(node) {
+  const loc = node?.loc;
+  if (!loc) return void 0;
+  return {
+    line: loc.start.line,
+    column: loc.start.column,
+    endLine: loc.end.line,
+    endColumn: loc.end.column
+  };
+}
+function scalarType(value) {
+  if (value === null) return "null";
+  return typeof value;
+}
+function asScalar(value, where) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  throw new HSIAdmissionError(
+    "unsupported-value",
+    `${where}: HS-Core v0 admits scalar values only, got ${Array.isArray(value) ? "array" : typeof value}`
+  );
+}
+function asTriple(value, where) {
+  let arr;
+  if (Array.isArray(value)) {
+    arr = value;
+  } else if (typeof value === "object" && value !== null && "x" in value) {
+    const vec = value;
+    arr = [vec["x"], vec["y"], vec["z"]];
+  }
+  if (!arr || arr.length !== 3 || !arr.every((n) => typeof n === "number" && Number.isFinite(n))) {
+    throw new HSIAdmissionError("invalid-spatial", `${where}: position/scale must be a finite numeric triple`);
+  }
+  return [arr[0], arr[1], arr[2]];
+}
+function collectSlots(ir, into) {
+  switch (ir.kind) {
+    case "Identifier":
+      into.add(ir.name);
+      return;
+    case "BinaryExpression":
+      collectSlots(ir.left, into);
+      collectSlots(ir.right, into);
+      return;
+    case "UnaryExpression":
+      collectSlots(ir.argument, into);
+      return;
+    case "MemberExpression":
+      collectSlots(ir.object, into);
+      return;
+    case "CallExpression":
+      for (const arg of ir.arguments) collectSlots(arg, into);
+      return;
+    case "Literal":
+      return;
+  }
+}
+function assertSlots(ir, allowed, where) {
+  const used = /* @__PURE__ */ new Set();
+  collectSlots(ir, used);
+  for (const name of used) {
+    if (!allowed.has(name)) {
+      throw new HSIAdmissionError("unknown-slot", `${where}: expression reads undeclared slot "${name}"`);
+    }
+  }
+  return [...used].sort();
+}
+function lowerHoloExpression(expr, where) {
+  switch (expr.type) {
+    case "Literal":
+      return { kind: "Literal", value: expr.value };
+    case "Identifier":
+      return { kind: "Identifier", name: expr.name };
+    case "BinaryExpression": {
+      if (!BINARY_OPERATORS.has(expr.operator)) {
+        throw new HSIAdmissionError("unsupported-operator", `${where}: operator "${expr.operator}"`);
+      }
+      return {
+        kind: "BinaryExpression",
+        operator: expr.operator,
+        left: lowerHoloExpression(expr.left, where),
+        right: lowerHoloExpression(expr.right, where)
+      };
+    }
+    case "UnaryExpression":
+      return {
+        kind: "UnaryExpression",
+        operator: expr.operator,
+        argument: lowerHoloExpression(expr.argument, where)
+      };
+    case "MemberExpression": {
+      if (expr.computed) {
+        throw new HSIAdmissionError("unsupported-expression", `${where}: computed member access`);
+      }
+      return {
+        kind: "MemberExpression",
+        object: lowerHoloExpression(expr.object, where),
+        property: expr.property
+      };
+    }
+    default:
+      throw new HSIAdmissionError("unsupported-expression", `${where}: ${expr.type} is outside HS-Core v0`);
+  }
+}
+function lowerEntities(composition) {
+  const templates = /* @__PURE__ */ new Map();
+  for (const template of composition.templates ?? []) {
+    if (templates.has(template.name)) {
+      throw new HSIAdmissionError("duplicate-template", `template "${template.name}" declared twice`);
+    }
+    templates.set(template.name, template);
+  }
+  const entities = /* @__PURE__ */ new Map();
+  for (const obj of composition.objects ?? []) {
+    if (entities.has(obj.name)) {
+      throw new HSIAdmissionError("duplicate-entity", `entity "${obj.name}" declared twice`);
+    }
+    if ((obj.children ?? []).length > 0) {
+      throw new HSIAdmissionError("unsupported-value", `entity "${obj.name}": nested children are outside HS-Core v0`);
+    }
+    const components = {};
+    const traitNames = /* @__PURE__ */ new Set();
+    let template;
+    if (obj.template !== void 0) {
+      template = templates.get(obj.template);
+      if (!template) {
+        throw new HSIAdmissionError("unknown-archetype", `entity "${obj.name}" uses missing template "${obj.template}"`);
+      }
+      for (const prop of template.properties ?? []) {
+        if (prop.key === "position" || prop.key === "scale") continue;
+        components[prop.key] = asScalar(prop.value, `template "${template.name}".${prop.key}`);
+      }
+      for (const trait of template.traits ?? []) traitNames.add(trait.name);
+    }
+    let position;
+    let scale;
+    for (const prop of obj.properties ?? []) {
+      if (prop.key === "position") {
+        position = asTriple(prop.value, `entity "${obj.name}".position`);
+        continue;
+      }
+      if (prop.key === "scale") {
+        scale = asTriple(prop.value, `entity "${obj.name}".scale`);
+        continue;
+      }
+      components[prop.key] = asScalar(prop.value, `entity "${obj.name}".${prop.key}`);
+    }
+    for (const trait of obj.traits ?? []) traitNames.add(trait.name);
+    const opaqueValue = components["opaque"];
+    const opacity = opaqueValue === void 0 ? "unknown" : opaqueValue === true ? "opaque" : "transparent";
+    delete components["opaque"];
+    const role = typeof components["role"] === "string" ? components["role"] : void 0;
+    const entity = {
+      id: `entity:${obj.name}`,
+      name: obj.name,
+      opacity,
+      components,
+      traits: [...traitNames].sort(),
+      sourceSpan: spanOf(obj)
+    };
+    if (obj.template !== void 0) entity.archetype = obj.template;
+    if (role !== void 0) entity.role = role;
+    if (position === void 0 && obj.position !== void 0) {
+      position = asTriple(obj.position, `entity "${obj.name}".position`);
+    }
+    if (scale === void 0 && obj.scale !== void 0) {
+      scale = asTriple(obj.scale, `entity "${obj.name}".scale`);
+    }
+    if (position !== void 0) entity.position = position;
+    if (scale !== void 0) entity.scale = scale;
+    entities.set(obj.name, entity);
+  }
+  return { templates, entities };
+}
+function lowerRelations(composition, entities) {
+  const relations = [];
+  const connections = composition.connections ?? [];
+  for (const conn of connections) {
+    for (const endpoint of [conn.from, conn.to]) {
+      if (!entities.has(endpoint)) {
+        throw new HSIAdmissionError(
+          "unknown-relation-endpoint",
+          `connection ${conn.from} -> ${conn.to} references undeclared entity "${endpoint}"`
+        );
+      }
+    }
+    const edgeType = conn.edgeType ?? "connects";
+    relations.push({
+      id: `relation:${conn.from}->${conn.to}:${edgeType}`,
+      from: conn.from,
+      to: conn.to,
+      edgeType,
+      sourceSpan: spanOf(conn)
+    });
+  }
+  return relations;
+}
+function lowerState(composition) {
+  const fields = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const prop of composition.state?.properties ?? []) {
+    if (seen.has(prop.key)) {
+      throw new HSIAdmissionError("duplicate-state-key", `state key "${prop.key}" declared twice`);
+    }
+    seen.add(prop.key);
+    const baseline = asScalar(prop.value, `state.${prop.key}`);
+    fields.push({
+      id: `state:world.${prop.key}`,
+      key: prop.key,
+      baseline,
+      valueType: scalarType(baseline),
+      reactive: prop.reactive === true,
+      sourceSpan: spanOf(prop)
+    });
+  }
+  return fields;
+}
+function deriveObservationPolicy(entities, relations) {
+  const rules = [];
+  const observers = [...entities.values()].filter((e) => e.role === "agent");
+  const mediatorsByTarget = /* @__PURE__ */ new Map();
+  for (const rel of relations) {
+    if (rel.edgeType !== HSI_OBSERVATION_MEDIATOR_EDGE) continue;
+    const list = mediatorsByTarget.get(rel.to) ?? [];
+    list.push(entities.get(rel.from));
+    mediatorsByTarget.set(rel.to, list);
+  }
+  for (const observer of observers) {
+    for (const observed of entities.values()) {
+      if (observed.name === observer.name) continue;
+      if (observed.role === "barrier") continue;
+      const mediators = (mediatorsByTarget.get(observed.name) ?? []).slice().sort((a, b) => a.name.localeCompare(b.name));
+      const access = mediators.some((m) => m.opacity === "opaque") ? "blocked" : mediators.some((m) => m.opacity === "unknown") ? "unknown" : "visible";
+      rules.push({
+        id: `obs:${observer.name}->${observed.name}`,
+        observer: observer.name,
+        observed: observed.name,
+        access,
+        mediators: mediators.map((m) => m.name)
+      });
+    }
+  }
+  return rules;
+}
+function lowerStatements(statements, handlerEvent, stateSlots, counter) {
+  const effects = [];
+  for (const stmt of statements) {
+    const ordinal = counter.n++;
+    const id = `effect:${handlerEvent}#${ordinal}`;
+    switch (stmt.type) {
+      case "Assignment": {
+        if (!ASSIGN_OPERATORS.has(stmt.operator)) {
+          throw new HSIAdmissionError("unsupported-operator", `${id}: assignment operator "${stmt.operator}"`);
+        }
+        const target = stmt.target.startsWith("state.") ? stmt.target.slice("state.".length) : stmt.target;
+        if (!stateSlots.has(target)) {
+          throw new HSIAdmissionError("unknown-assignment-target", `${id}: "${stmt.target}" is not a declared state key`);
+        }
+        const value = lowerHoloExpression(stmt.value, id);
+        assertSlots(value, stateSlots, id);
+        effects.push({ kind: "assign", id, target, operator: stmt.operator, value, sourceSpan: spanOf(stmt) });
+        break;
+      }
+      case "EmitStatement": {
+        effects.push({ kind: "emit", id, event: stmt.event, sourceSpan: spanOf(stmt) });
+        break;
+      }
+      case "IfStatement": {
+        const condition = lowerHoloExpression(stmt.condition, id);
+        assertSlots(condition, stateSlots, id);
+        effects.push({
+          kind: "branch",
+          id,
+          condition,
+          then: lowerStatements(stmt.consequent, handlerEvent, stateSlots, counter),
+          else: lowerStatements(stmt.alternate ?? [], handlerEvent, stateSlots, counter),
+          sourceSpan: spanOf(stmt)
+        });
+        break;
+      }
+      default:
+        throw new HSIAdmissionError("unsupported-statement", `${id}: ${stmt.type} is outside HS-Core v0`);
+    }
+  }
+  return effects;
+}
+function lowerEventHandlers(composition, stateSlots) {
+  const logic = composition.logic;
+  const handlers = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const handler of logic?.handlers ?? []) {
+    if (seen.has(handler.event)) {
+      throw new HSIAdmissionError("duplicate-handler", `handler "${handler.event}" declared twice`);
+    }
+    seen.add(handler.event);
+    handlers.push({
+      id: `event:${handler.event}`,
+      event: handler.event,
+      effects: lowerStatements(handler.body, handler.event, stateSlots, { n: 0 }),
+      sourceSpan: spanOf(handler)
+    });
+  }
+  return handlers;
+}
+function lowerMachine(machine) {
+  const stateNames = Object.keys(machine.states ?? {});
+  if (stateNames.length === 0) {
+    throw new HSIAdmissionError("admission-skewed", `state machine "${machine.name}" declares no states`);
+  }
+  if (!stateNames.includes(machine.initialState)) {
+    throw new HSIAdmissionError(
+      "unknown-initial-state",
+      `state machine "${machine.name}": initial state "${machine.initialState}" is not declared`
+    );
+  }
+  const inputs = (machine.inputs ?? []).map((input) => ({
+    id: `input:${machine.name}.${input.name}`,
+    name: input.name,
+    inputType: input.inputType,
+    baseline: input.default !== void 0 ? input.default : input.inputType === "bool" || input.inputType === "trigger" ? false : 0
+  }));
+  const inputSlots = new Set(inputs.map((i) => i.name));
+  const allTransitions = [];
+  for (const t of machine.transitions ?? []) {
+    allTransitions.push({ from: t.from && t.from !== "any" ? t.from : t.from ?? "any", t });
+  }
+  for (const stateName of stateNames) {
+    for (const t of machine.states[stateName]?.transitions ?? []) {
+      allTransitions.push({ from: t.from ?? stateName, t });
+    }
+  }
+  const ordinals = /* @__PURE__ */ new Map();
+  const transitions = allTransitions.map(({ from, t }, declarationOrdinal) => {
+    if (from !== "any" && !stateNames.includes(from)) {
+      throw new HSIAdmissionError(
+        "unknown-transition-endpoint",
+        `state machine "${machine.name}": transition from undeclared state "${from}"`
+      );
+    }
+    if (!stateNames.includes(t.target)) {
+      throw new HSIAdmissionError(
+        "unknown-transition-endpoint",
+        `state machine "${machine.name}": transition to undeclared state "${t.target}"`
+      );
+    }
+    const baseId = `transition:${machine.name}.${from}->${t.target}`;
+    const ordinal = ordinals.get(baseId) ?? 0;
+    ordinals.set(baseId, ordinal + 1);
+    const id = `${baseId}#${ordinal}`;
+    let guard;
+    if (t.condition) {
+      guard = lowerHoloExpression(t.condition, id);
+    } else if ((t.conditions ?? []).length > 0) {
+      for (const cond of t.conditions) {
+        const clause = {
+          kind: "BinaryExpression",
+          operator: cond.operator,
+          left: { kind: "Identifier", name: cond.parameter },
+          right: { kind: "Literal", value: cond.value }
+        };
+        guard = guard ? { kind: "BinaryExpression", operator: cond.chain === "or" ? "||" : "&&", left: guard, right: clause } : clause;
+      }
+    }
+    if (!guard) {
+      throw new HSIAdmissionError("admission-skewed", `${id}: transition has neither guard nor trigger condition`);
+    }
+    const reads = assertSlots(guard, inputSlots, id);
+    const transition = {
+      id,
+      from,
+      target: t.target,
+      priority: declarationOrdinal,
+      guard,
+      reads,
+      sourceSpan: spanOf(t)
+    };
+    if (t.event !== void 0) transition.event = t.event;
+    return transition;
+  });
+  return {
+    id: `machine:${machine.name}`,
+    name: machine.name,
+    initialState: machine.initialState,
+    states: [...stateNames].sort(),
+    inputs,
+    transitions,
+    sourceSpan: spanOf(machine)
+  };
+}
+function lowerPredicates(composition, stateSlots) {
+  const predicates = [];
+  const slotList = [...stateSlots];
+  const lowerClause = (kind, name, expr) => {
+    const id = `${kind}:${name}`;
+    let ir;
+    try {
+      ir = chunkX5ZLSPU2_cjs.parseExpressionToIR(expr, slotList);
+    } catch (error) {
+      if (error instanceof chunkX5ZLSPU2_cjs.ExpressionParseError) {
+        throw new HSIAdmissionError("unparseable-clause", `${id}: ${error.message}`);
+      }
+      throw error;
+    }
+    return { id, name, kind, expression: ir, reads: assertSlots(ir, stateSlots, id), sourceSpan: spanOf(composition.contract) };
+  };
+  for (const clause of composition.contract?.preconditions ?? []) {
+    predicates.push(lowerClause("precondition", clause.name, clause.expr));
+  }
+  for (const clause of composition.contract?.invariants ?? []) {
+    predicates.push(lowerClause("invariant", clause.name, clause.expr));
+  }
+  for (const achievement of composition.achievements ?? []) {
+    const id = `goal:${achievement.name}`;
+    const ir = lowerHoloExpression(achievement.condition, id);
+    predicates.push({
+      id,
+      name: achievement.name,
+      kind: "goal",
+      expression: ir,
+      reads: assertSlots(ir, stateSlots, id),
+      sourceSpan: spanOf(achievement)
+    });
+  }
+  return predicates;
+}
+function lowerCompositionToHSIIR(composition, options = {}) {
+  if (!composition || composition.type !== "Composition" || typeof composition.name !== "string" || composition.name.length === 0) {
+    throw new HSIAdmissionError("empty-world", "input is not a named HoloComposition");
+  }
+  const { entities } = lowerEntities(composition);
+  const stateFields = lowerState(composition);
+  if (entities.size === 0 && stateFields.length === 0) {
+    throw new HSIAdmissionError("empty-world", `composition "${composition.name}" declares no entities and no state`);
+  }
+  const relations = lowerRelations(composition, entities);
+  const observationPolicy = deriveObservationPolicy(entities, relations);
+  const stateSlots = new Set(stateFields.map((f) => f.key));
+  const eventHandlers = lowerEventHandlers(composition, stateSlots);
+  const machines = (composition.stateMachines ?? []).map(lowerMachine);
+  const predicates = lowerPredicates(composition, stateSlots);
+  const sourceDigest = options.sourceText !== void 0 ? hsiSourceTextDigest(options.sourceText) : hsiSha256({ compositionName: composition.name, note: "no-source-text-provided" });
+  const byId = (items) => [...items].sort((a, b) => a.id.localeCompare(b.id));
+  const docWithoutDigest = {
+    schemaVersion: HSI_IR_SCHEMA_VERSION,
+    kind: "HSIIR",
+    world: { name: composition.name, sourceDigest },
+    entities: byId([...entities.values()]),
+    relations: byId(relations),
+    state: byId(stateFields),
+    observationPolicy: byId(observationPolicy),
+    eventHandlers: byId(eventHandlers),
+    machines: byId(machines),
+    predicates: byId(predicates),
+    declaredUnknowns: [
+      "action-capabilities",
+      "action-costs",
+      "beliefs",
+      "first-class-observations",
+      "memory-events",
+      "receipt-shape"
+    ],
+    provenance: { compiler: "HSIIRCompiler" }
+  };
+  const deterministicDigest = hsiSha256(docWithoutDigest);
+  return {
+    ...docWithoutDigest,
+    provenance: { compiler: "HSIIRCompiler", deterministicDigest }
+  };
+}
+var HSIIRCompiler = class extends chunkCMEINO5I_cjs.CompilerBase {
+  constructor(options = {}) {
+    super();
+    this.compilerName = "HSIIRCompiler";
+    this.options = options;
+  }
+  getRequiredCapability() {
+    return ans.ANSCapabilityPath.HSI_IR;
+  }
+  compile(composition, agentToken, outputPath) {
+    this.validateCompilerAccess(agentToken, outputPath);
+    return JSON.stringify(lowerCompositionToHSIIR(composition, this.options), null, 2);
+  }
+  compileToFiles(composition, agentToken = "") {
+    return { [this.defaultOutputFileName()]: this.compile(composition, agentToken) };
+  }
+  defaultOutputFileName() {
+    return "hsi-ir.json";
+  }
+};
+function createHSIIRCompiler(options) {
+  return new HSIIRCompiler(options);
+}
+
+// src/compiler/HSIExactTrace.ts
+function snapshot(world) {
+  const state = {};
+  for (const key of Object.keys(world.state).sort()) state[key] = world.state[key];
+  const machineStates = {};
+  for (const name of [...world.machines.keys()].sort()) {
+    machineStates[name] = world.machines.get(name).current;
+  }
+  return { state, machineStates, stateDigest: hsiSha256({ state, machineStates }) };
+}
+function evaluateGuard(guard, context) {
+  return chunkX5ZLSPU2_cjs.evaluateExpressionIR(guard, context) === true;
+}
+function applyOperator(operator, before, operand, where) {
+  if (operator === "=") {
+    if (operand === null || typeof operand === "string" || typeof operand === "number" || typeof operand === "boolean") {
+      return operand;
+    }
+    throw new HSIAdmissionError("unsupported-value", `${where}: assignment produced a non-scalar value`);
+  }
+  if (typeof before !== "number" || typeof operand !== "number" || !Number.isFinite(operand)) {
+    throw new HSIAdmissionError(
+      "unsupported-value",
+      `${where}: compound assignment requires numeric operands (got ${typeof before} ${operator} ${typeof operand})`
+    );
+  }
+  switch (operator) {
+    case "+=":
+      return before + operand;
+    case "-=":
+      return before - operand;
+    case "*=":
+      return before * operand;
+    case "/=": {
+      if (operand === 0) {
+        throw new HSIAdmissionError("unsupported-value", `${where}: division by zero`);
+      }
+      return before / operand;
+    }
+  }
+}
+function runEffects(effects, world, records, emitted) {
+  for (const effect of effects) {
+    switch (effect.kind) {
+      case "assign": {
+        const before = world.state[effect.target];
+        const operand = chunkX5ZLSPU2_cjs.evaluateExpressionIR(effect.value, world.state);
+        const after = applyOperator(effect.operator, before, operand, effect.id);
+        world.state[effect.target] = after;
+        records.push({ sourceId: effect.id, target: effect.target, before, after });
+        break;
+      }
+      case "emit": {
+        emitted.push(effect.event);
+        break;
+      }
+      case "branch": {
+        const taken = evaluateGuard(effect.condition, world.state);
+        runEffects(taken ? effect.then : effect.else, world, records, emitted);
+        break;
+      }
+    }
+  }
+}
+function evaluateTransitions(world, ir) {
+  const fired = [];
+  for (const machineIR of ir.machines) {
+    const runtime = world.machines.get(machineIR.name);
+    const context = { ...runtime.inputs };
+    for (const trigger of runtime.triggers) context[trigger] = true;
+    const candidates = [...machineIR.transitions].sort((a, b) => a.priority - b.priority);
+    for (const transition of candidates) {
+      if (transition.from !== "any" && transition.from !== runtime.current) continue;
+      if (!transition.guard) continue;
+      if (evaluateGuard(transition.guard, context)) {
+        fired.push({
+          machine: machineIR.name,
+          transitionId: transition.id,
+          from: runtime.current,
+          to: transition.target
+        });
+        runtime.current = transition.target;
+        break;
+      }
+    }
+    runtime.triggers.clear();
+  }
+  return fired;
+}
+function checkInvariants(world, ir) {
+  const violations = [];
+  for (const predicate of ir.predicates) {
+    if (predicate.kind !== "invariant") continue;
+    if (!evaluateGuard(predicate.expression, world.state)) violations.push(predicate.id);
+  }
+  return violations;
+}
+function runExactTrace(ir, scenario) {
+  const world = { state: {}, machines: /* @__PURE__ */ new Map() };
+  for (const field of ir.state) world.state[field.key] = field.baseline;
+  for (const machine of ir.machines) {
+    const inputs = {};
+    for (const input of machine.inputs) {
+      inputs[input.name] = input.inputType === "trigger" ? false : input.baseline;
+    }
+    world.machines.set(machine.name, {
+      name: machine.name,
+      current: machine.initialState,
+      inputs,
+      triggers: /* @__PURE__ */ new Set()
+    });
+  }
+  const preconditionResults = ir.predicates.filter((p) => p.kind === "precondition").map((p) => ({ id: p.id, holds: evaluateGuard(p.expression, world.state) }));
+  const initial = snapshot(world);
+  const steps = [];
+  let valid = preconditionResults.every((r) => r.holds);
+  scenario.forEach((step, ordinal) => {
+    const effects = [];
+    const emitted = [];
+    let transitions = [];
+    switch (step.kind) {
+      case "set-input": {
+        const machine = world.machines.get(step.machine);
+        if (!machine || !(step.input in machine.inputs)) {
+          throw new HSIAdmissionError(
+            "unknown-slot",
+            `scenario step ${ordinal}: unknown machine input ${step.machine}.${step.input}`
+          );
+        }
+        machine.inputs[step.input] = step.value;
+        transitions = evaluateTransitions(world, ir);
+        break;
+      }
+      case "fire-trigger": {
+        const machine = world.machines.get(step.machine);
+        const declared = ir.machines.find((m) => m.name === step.machine)?.inputs.find((i) => i.name === step.input && i.inputType === "trigger");
+        if (!machine || !declared) {
+          throw new HSIAdmissionError(
+            "unknown-slot",
+            `scenario step ${ordinal}: unknown trigger ${step.machine}.${step.input}`
+          );
+        }
+        machine.triggers.add(step.input);
+        transitions = evaluateTransitions(world, ir);
+        break;
+      }
+      case "fire-event": {
+        const handler = ir.eventHandlers.find((h) => h.event === step.event);
+        if (!handler) {
+          throw new HSIAdmissionError(
+            "unknown-slot",
+            `scenario step ${ordinal}: no handler for event "${step.event}"`
+          );
+        }
+        runEffects(handler.effects, world, effects, emitted);
+        break;
+      }
+    }
+    const invariantViolations = checkInvariants(world, ir);
+    if (invariantViolations.length > 0) valid = false;
+    steps.push({
+      ordinal,
+      step,
+      transitions,
+      effects,
+      emitted,
+      invariantViolations,
+      stateDigest: snapshot(world).stateDigest
+    });
+  });
+  const final = snapshot(world);
+  const traceWithoutDigest = {
+    schemaVersion: HSI_TRACE_SCHEMA_VERSION,
+    kind: "HSITrace",
+    worldDigest: ir.provenance.deterministicDigest,
+    preconditionResults,
+    initial,
+    steps,
+    final,
+    valid
+  };
+  return { ...traceWithoutDigest, deterministicDigest: hsiSha256(traceWithoutDigest) };
+}
+function splitFor(nodeId, worldDigest) {
+  const digest = crypto.createHash("sha256").update(`${nodeId}|${worldDigest}`).digest();
+  return digest[0] % 4 === 0 ? "eval" : "train";
+}
+function collectAssignTargets(effects, into, reads) {
+  for (const effect of effects) {
+    if (effect.kind === "assign") {
+      into.add(effect.target);
+      const stack = [effect.value];
+      while (stack.length > 0) {
+        const node = stack.pop();
+        if (node.kind === "Identifier") reads.add(node.name);
+        else if (node.kind === "BinaryExpression") stack.push(node.left, node.right);
+        else if (node.kind === "UnaryExpression") stack.push(node.argument);
+        else if (node.kind === "MemberExpression") stack.push(node.object);
+        else if (node.kind === "CallExpression") stack.push(...node.arguments);
+      }
+    } else if (effect.kind === "branch") {
+      collectAssignTargets(effect.then, into, reads);
+      collectAssignTargets(effect.else, into, reads);
+    }
+  }
+}
+function projectLearningGraph(ir) {
+  const worldDigest = ir.provenance.deterministicDigest;
+  const nodes = [];
+  const edges = [];
+  const addNode = (node) => {
+    nodes.push({ ...node, split: splitFor(node.id, worldDigest) });
+  };
+  const addEdge = (edgeType, from, to, label) => {
+    const edge = { id: `edge:${edgeType}:${from}->${to}`, edgeType, from, to };
+    if (label !== void 0) edge.label = label;
+    edges.push(edge);
+  };
+  const worldId = `entity:${ir.world.name}`;
+  addNode({ id: worldId, nodeType: "entity", baseline: null, unknowns: [] });
+  for (const entity of ir.entities) {
+    addNode({
+      id: entity.id,
+      nodeType: "entity",
+      baseline: null,
+      unknowns: entity.opacity === "unknown" ? ["opacity"] : [],
+      sourceSpan: entity.sourceSpan
+    });
+    addEdge("contains", worldId, entity.id);
+  }
+  for (const field of ir.state) {
+    addNode({
+      id: field.id,
+      nodeType: "state",
+      baseline: field.baseline,
+      unknowns: [],
+      sourceSpan: field.sourceSpan
+    });
+    addEdge("contains", worldId, field.id);
+  }
+  for (const rule of ir.observationPolicy) {
+    addNode({
+      id: rule.id,
+      nodeType: "observation",
+      baseline: null,
+      unknowns: rule.access === "unknown" ? ["access"] : []
+    });
+    addEdge("observes", `entity:${rule.observer}`, rule.id, rule.access);
+    addEdge("refers-to", rule.id, `entity:${rule.observed}`);
+    for (const mediator of rule.mediators) {
+      addEdge("refers-to", rule.id, `entity:${mediator}`, "mediator");
+    }
+  }
+  for (const handler of ir.eventHandlers) {
+    addNode({ id: handler.id, nodeType: "event", baseline: null, unknowns: [], sourceSpan: handler.sourceSpan });
+    const targets = /* @__PURE__ */ new Set();
+    const reads = /* @__PURE__ */ new Set();
+    collectAssignTargets(handler.effects, targets, reads);
+    for (const target of [...targets].sort()) {
+      addEdge("affects", handler.id, `state:world.${target}`);
+    }
+    for (const read of [...reads].sort()) {
+      if (!targets.has(read)) addEdge("requires", handler.id, `state:world.${read}`);
+    }
+  }
+  for (const machine of ir.machines) {
+    for (const transition of machine.transitions) {
+      addNode({
+        id: transition.id,
+        nodeType: "action",
+        baseline: null,
+        unknowns: [],
+        sourceSpan: transition.sourceSpan
+      });
+      for (const read of transition.reads) {
+        addEdge("requires", transition.id, `input:${machine.name}.${read}`);
+      }
+      addEdge("causes", transition.id, `machineState:${machine.name}.${transition.target}`);
+      if (transition.from !== "any") {
+        addEdge("precedes", `machineState:${machine.name}.${transition.from}`, transition.id);
+      }
+    }
+    for (const stateName of machine.states) {
+      addNode({ id: `machineState:${machine.name}.${stateName}`, nodeType: "state", baseline: null, unknowns: [] });
+      addEdge("contains", worldId, `machineState:${machine.name}.${stateName}`);
+    }
+    for (const input of machine.inputs) {
+      addNode({ id: input.id, nodeType: "state", baseline: input.baseline, unknowns: [] });
+      addEdge("contains", worldId, input.id);
+    }
+  }
+  for (const predicate of ir.predicates) {
+    addNode({
+      id: predicate.id,
+      nodeType: "objective",
+      baseline: null,
+      unknowns: [],
+      sourceSpan: predicate.sourceSpan
+    });
+    for (const read of predicate.reads) {
+      addEdge("refers-to", predicate.id, `state:world.${read}`);
+    }
+  }
+  nodes.sort((a, b) => a.id.localeCompare(b.id));
+  edges.sort((a, b) => a.id.localeCompare(b.id));
+  const graphWithoutDigest = {
+    schemaVersion: HSI_LEARNING_GRAPH_SCHEMA_VERSION,
+    kind: "HSILearningGraph",
+    worldDigest,
+    emittedFrom: worldDigest,
+    nodes,
+    edges,
+    interventions: [
+      "intervention:flip-opacity",
+      "intervention:raise-guard-threshold"
+    ]
+  };
+  return { ...graphWithoutDigest, deterministicDigest: hsiSha256(graphWithoutDigest) };
+}
+
+// src/compiler/HSIAuditVerifier.ts
+function renamed(name, map) {
+  return map[name] ?? name;
+}
+function renameExpression(expr, map) {
+  switch (expr.type) {
+    case "Identifier":
+      expr.name = renamed(expr.name, map);
+      return;
+    case "BinaryExpression":
+      renameExpression(expr.left, map);
+      renameExpression(expr.right, map);
+      return;
+    case "UnaryExpression":
+      renameExpression(expr.argument, map);
+      return;
+    case "MemberExpression":
+      renameExpression(expr.object, map);
+      return;
+    case "CallExpression":
+      renameExpression(expr.callee, map);
+      for (const arg of expr.arguments) renameExpression(arg, map);
+      return;
+    default:
+      return;
+  }
+}
+function renameStatements(statements, map) {
+  for (const stmt of statements) {
+    switch (stmt.type) {
+      case "Assignment": {
+        const target = stmt.target.startsWith("state.") ? stmt.target.slice("state.".length) : stmt.target;
+        const prefix = stmt.target.startsWith("state.") ? "state." : "";
+        stmt.target = `${prefix}${renamed(target, map)}`;
+        renameExpression(stmt.value, map);
+        break;
+      }
+      case "IfStatement":
+        renameExpression(stmt.condition, map);
+        renameStatements(stmt.consequent, map);
+        renameStatements(stmt.alternate ?? [], map);
+        break;
+    }
+  }
+}
+function renameRawExpr(expr, map) {
+  return expr.replace(/[A-Za-z_][A-Za-z0-9_]*/g, (token) => renamed(token, map));
+}
+function renameComposition(composition, map) {
+  for (const template of composition.templates ?? []) {
+    template.name = renamed(template.name, map);
+  }
+  for (const obj of composition.objects ?? []) {
+    obj.name = renamed(obj.name, map);
+    if (obj.template !== void 0) obj.template = renamed(obj.template, map);
+  }
+  const connections = composition.connections;
+  for (const conn of connections ?? []) {
+    conn.from = renamed(conn.from, map);
+    conn.to = renamed(conn.to, map);
+  }
+  for (const prop of composition.state?.properties ?? []) {
+    prop.key = renamed(prop.key, map);
+  }
+  const logic = composition.logic;
+  for (const handler of logic?.handlers ?? []) {
+    renameStatements(handler.body, map);
+  }
+  for (const machine of composition.stateMachines ?? []) {
+    machine.name = renamed(machine.name, map);
+    machine.initialState = renamed(machine.initialState, map);
+    const renamedStates = {};
+    for (const [stateName, stateNode] of Object.entries(machine.states ?? {})) {
+      stateNode.name = renamed(stateName, map);
+      renamedStates[renamed(stateName, map)] = stateNode;
+      for (const t of stateNode.transitions ?? []) {
+        if (t.from && t.from !== "any") t.from = renamed(t.from, map);
+        t.target = renamed(t.target, map);
+        if (t.condition) renameExpression(t.condition, map);
+        for (const cond of t.conditions ?? []) cond.parameter = renamed(cond.parameter, map);
+      }
+    }
+    machine.states = renamedStates;
+    for (const input of machine.inputs ?? []) {
+      input.name = renamed(input.name, map);
+    }
+    for (const t of machine.transitions ?? []) {
+      if (t.from && t.from !== "any") t.from = renamed(t.from, map);
+      t.target = renamed(t.target, map);
+      if (t.condition) renameExpression(t.condition, map);
+      for (const cond of t.conditions ?? []) cond.parameter = renamed(cond.parameter, map);
+    }
+  }
+  if (composition.contract) {
+    for (const clause of [...composition.contract.preconditions, ...composition.contract.invariants]) {
+      clause.expr = renameRawExpr(clause.expr, map);
+    }
+  }
+  for (const achievement of composition.achievements ?? []) {
+    renameExpression(achievement.condition, map);
+  }
+}
+var ID_TOKEN_PATTERN = /[A-Za-z_][A-Za-z0-9_]*/g;
+function renameIdString(id, map) {
+  return id.replace(ID_TOKEN_PATTERN, (token) => renamed(token, map));
+}
+function renameTrace(trace, map) {
+  const renameSnapshot = (snap) => {
+    const state = {};
+    for (const [key, value] of Object.entries(snap.state)) state[renamed(key, map)] = value;
+    const machineStates = {};
+    for (const [machine, current] of Object.entries(snap.machineStates)) {
+      machineStates[renamed(machine, map)] = renamed(current, map);
+    }
+    return { state, machineStates, stateDigest: hsiSha256({ state: sortRecord(state), machineStates: sortRecord(machineStates) }) };
+  };
+  const sortRecord = (record) => {
+    const out = {};
+    for (const key of Object.keys(record).sort()) out[key] = record[key];
+    return out;
+  };
+  const stepsRenamed = trace.steps.map((step) => {
+    const scenario = step.step.kind === "fire-event" ? step.step : step.step.kind === "set-input" ? { kind: "set-input", machine: renamed(step.step.machine, map), input: renamed(step.step.input, map), value: step.step.value } : { kind: "fire-trigger", machine: renamed(step.step.machine, map), input: renamed(step.step.input, map) };
+    return {
+      ...step,
+      step: scenario,
+      transitions: step.transitions.map((t) => ({
+        machine: renamed(t.machine, map),
+        transitionId: renameIdString(t.transitionId, map),
+        from: renamed(t.from, map),
+        to: renamed(t.to, map)
+      })),
+      effects: step.effects.map((e) => ({ ...e, target: renamed(e.target, map), sourceId: renameIdString(e.sourceId, map) })),
+      invariantViolations: step.invariantViolations.map((id) => renameIdString(id, map)),
+      stateDigest: ""
+    };
+  });
+  const initial = renameSnapshot(trace.initial);
+  const final = renameSnapshot(trace.final);
+  const traceWithoutDigest = {
+    schemaVersion: trace.schemaVersion,
+    kind: trace.kind,
+    worldDigest: "",
+    preconditionResults: trace.preconditionResults.map((r) => ({ id: renameIdString(r.id, map), holds: r.holds })),
+    initial,
+    steps: stepsRenamed,
+    final,
+    valid: trace.valid
+  };
+  return { ...traceWithoutDigest, deterministicDigest: "" };
+}
+function behavioralProjection(trace) {
+  return {
+    preconditionResults: trace.preconditionResults,
+    initial: { state: trace.initial.state, machineStates: trace.initial.machineStates },
+    steps: trace.steps.map((s) => ({
+      ordinal: s.ordinal,
+      step: s.step,
+      transitions: s.transitions,
+      effects: s.effects,
+      emitted: s.emitted,
+      invariantViolations: s.invariantViolations
+    })),
+    final: { state: trace.final.state, machineStates: trace.final.machineStates },
+    valid: trace.valid
+  };
+}
+function reorderComposition(composition) {
+  composition.templates = [...composition.templates ?? []].reverse();
+  composition.objects = [...composition.objects ?? []].reverse();
+  const holder = composition;
+  if (holder.connections) holder.connections = [...holder.connections].reverse();
+  if (composition.state?.properties) {
+    composition.state.properties = [...composition.state.properties].reverse();
+  }
+  if (composition.contract) {
+    composition.contract.invariants = [...composition.contract.invariants].reverse();
+  }
+}
+function applyIntervention(composition, intervention) {
+  if (intervention.kind === "set-opacity") {
+    const obj = (composition.objects ?? []).find((o) => o.name === intervention.entity);
+    if (!obj) {
+      throw new HSIAdmissionError("admission-skewed", `intervention targets unknown entity "${intervention.entity}"`);
+    }
+    const existing = obj.properties.findIndex((p) => p.key === "opaque");
+    if (existing >= 0) obj.properties.splice(existing, 1);
+    if (intervention.opaque !== void 0) {
+      obj.properties.push({ type: "ObjectProperty", key: "opaque", value: intervention.opaque });
+    } else {
+      const template = (composition.templates ?? []).find((t) => t.name === obj.template);
+      if (template) {
+        template.properties = (template.properties ?? []).filter((p) => p.key !== "opaque");
+      }
+    }
+    return;
+  }
+  const machine = (composition.stateMachines ?? []).find((m) => m.name === intervention.machine);
+  if (!machine) {
+    throw new HSIAdmissionError("admission-skewed", `intervention targets unknown machine "${intervention.machine}"`);
+  }
+  const transitions = [
+    ...machine.transitions ?? [],
+    ...Object.values(machine.states ?? {}).flatMap((s) => s.transitions ?? [])
+  ];
+  const transition = transitions.find(
+    (t) => (t.from ?? "") === intervention.fromState && t.target === intervention.toState
+  );
+  if (!transition) {
+    throw new HSIAdmissionError(
+      "admission-skewed",
+      `intervention targets unknown transition ${intervention.fromState} -> ${intervention.toState}`
+    );
+  }
+  if (transition.condition?.type === "BinaryExpression" && transition.condition.right.type === "Literal") {
+    transition.condition.right.value = intervention.value;
+  }
+  for (const cond of transition.conditions ?? []) {
+    if (typeof cond.value === "number") cond.value = intervention.value;
+  }
+}
+function generateAuditCases(ir) {
+  const cases = [
+    {
+      id: "audit:admission-empty",
+      kind: "admission-empty",
+      description: "An empty composition (no entities, no state) must fail admission.",
+      expectation: "HSIAdmissionError(empty-world)"
+    },
+    {
+      id: "audit:admission-missing-archetype",
+      kind: "admission-skewed",
+      description: "An object using an undeclared template must fail admission.",
+      expectation: "HSIAdmissionError(unknown-archetype)"
+    },
+    {
+      id: "audit:admission-dangling-relation",
+      kind: "admission-skewed",
+      description: "A connection to an undeclared entity must fail admission.",
+      expectation: "HSIAdmissionError(unknown-relation-endpoint)"
+    },
+    {
+      id: "audit:alpha-rename",
+      kind: "alpha-rename",
+      description: "Consistent renaming of declared names preserves behavior (trace modulo names).",
+      expectation: "behavioralProjection(renameTrace(base)) === behavioralProjection(trace(renamed))"
+    },
+    {
+      id: "audit:declaration-reorder",
+      kind: "declaration-reorder",
+      description: "Reordering independent declarations yields a byte-identical IR.",
+      expectation: "deterministicDigest(base) === deterministicDigest(reordered)"
+    },
+    {
+      id: "audit:regenerate-determinism",
+      kind: "regenerate-determinism",
+      description: "Re-lowering and re-tracing from the same source is byte-identical.",
+      expectation: "all artifact digests equal across two independent regenerations"
+    }
+  ];
+  const opaqueMediator = ir.entities.find(
+    (e) => e.opacity === "opaque" && ir.observationPolicy.some((r) => r.mediators.includes(e.name) && r.access === "blocked")
+  );
+  if (opaqueMediator) {
+    cases.push({
+      id: "audit:counterfactual-opacity",
+      kind: "counterfactual-intervention",
+      description: `Making "${opaqueMediator.name}" transparent must change at least one observation access verdict.`,
+      intervention: { kind: "set-opacity", id: "intervention:flip-opacity", entity: opaqueMediator.name, opacity: "transparent" },
+      expectation: "observationPolicy access verdicts differ from base IR"
+    });
+  }
+  const guardedTransition = ir.machines.flatMap((m) => m.transitions.map((t) => ({ machine: m.name, t }))).find(({ t }) => t.guard?.kind === "BinaryExpression" && t.guard.right.kind === "Literal" && typeof t.guard.right.value === "number");
+  if (guardedTransition) {
+    cases.push({
+      id: "audit:counterfactual-guard",
+      kind: "counterfactual-intervention",
+      description: `Raising the numeric guard of ${guardedTransition.t.id} beyond scenario inputs must change the exact trace.`,
+      intervention: {
+        kind: "set-transition-guard-literal",
+        id: "intervention:raise-guard-threshold",
+        machine: guardedTransition.machine,
+        transitionId: guardedTransition.t.id,
+        value: 1e6
+      },
+      expectation: "trace deterministicDigest differs and at least one step fires different transitions"
+    });
+  }
+  return cases;
+}
+function clone(value) {
+  return structuredClone(value);
+}
+function expectAdmissionFailure(fn, expectedCode) {
+  try {
+    fn();
+    return "fail";
+  } catch (error) {
+    return error instanceof HSIAdmissionError && error.code === expectedCode ? "pass" : "fail";
+  }
+}
+function runHSIAudit(input) {
+  const { composition, sourceText, scenario, renameMap } = input;
+  const baseIR = lowerCompositionToHSIIR(clone(composition), { sourceText });
+  const baseTrace = runExactTrace(baseIR, scenario);
+  const cases = generateAuditCases(baseIR);
+  const checks = [];
+  for (const auditCase of cases) {
+    let status = "fail";
+    let detail = auditCase.expectation;
+    try {
+      switch (auditCase.id) {
+        case "audit:admission-empty": {
+          const empty = {
+            ...clone(composition),
+            name: "EmptyWorld",
+            templates: [],
+            objects: [],
+            state: void 0,
+            stateMachines: [],
+            contract: void 0,
+            achievements: []
+          };
+          empty.connections = [];
+          empty.logic = void 0;
+          status = expectAdmissionFailure(() => lowerCompositionToHSIIR(empty), "empty-world");
+          break;
+        }
+        case "audit:admission-missing-archetype": {
+          const skewed = clone(composition);
+          if (skewed.objects.length === 0) throw new Error("fixture has no objects");
+          skewed.objects[0].template = "GhostTemplate";
+          status = expectAdmissionFailure(() => lowerCompositionToHSIIR(skewed), "unknown-archetype");
+          break;
+        }
+        case "audit:admission-dangling-relation": {
+          const skewed = clone(composition);
+          const holder = skewed;
+          holder.connections = [...holder.connections ?? [], { from: "NoSuchEntity", to: "AlsoMissing" }];
+          status = expectAdmissionFailure(() => lowerCompositionToHSIIR(skewed), "unknown-relation-endpoint");
+          break;
+        }
+        case "audit:alpha-rename": {
+          const renamedComposition = clone(composition);
+          renameComposition(renamedComposition, renameMap);
+          const renamedIR = lowerCompositionToHSIIR(renamedComposition);
+          const renamedScenario = scenario.map(
+            (step) => step.kind === "fire-event" ? step : step.kind === "set-input" ? { ...step, machine: renameMap[step.machine] ?? step.machine, input: renameMap[step.input] ?? step.input } : { ...step, machine: renameMap[step.machine] ?? step.machine, input: renameMap[step.input] ?? step.input }
+          );
+          const renamedTrace = runExactTrace(renamedIR, renamedScenario);
+          const expected = hsiStableStringify(behavioralProjection(renameTrace(baseTrace, renameMap)));
+          const actual = hsiStableStringify(behavioralProjection(renamedTrace));
+          status = expected === actual ? "pass" : "fail";
+          if (status === "fail") detail = "renamed trace diverged from rename-projected base trace";
+          break;
+        }
+        case "audit:declaration-reorder": {
+          const reordered = clone(composition);
+          reorderComposition(reordered);
+          const reorderedIR = lowerCompositionToHSIIR(reordered, { sourceText });
+          status = reorderedIR.provenance.deterministicDigest === baseIR.provenance.deterministicDigest ? "pass" : "fail";
+          if (status === "fail") detail = "reordered IR digest differs from base IR digest";
+          break;
+        }
+        case "audit:regenerate-determinism": {
+          const secondIR = lowerCompositionToHSIIR(clone(composition), { sourceText });
+          const secondTrace = runExactTrace(secondIR, scenario);
+          status = secondIR.provenance.deterministicDigest === baseIR.provenance.deterministicDigest && secondTrace.deterministicDigest === baseTrace.deterministicDigest ? "pass" : "fail";
+          if (status === "fail") detail = "regeneration produced different digests";
+          break;
+        }
+        case "audit:counterfactual-opacity": {
+          const intervention = auditCase.intervention;
+          if (intervention.kind !== "set-opacity") throw new Error("case/intervention mismatch");
+          const intervened = clone(composition);
+          applyIntervention(intervened, {
+            id: intervention.id,
+            kind: "set-opacity",
+            entity: intervention.entity,
+            opaque: intervention.opacity === "opaque" ? true : intervention.opacity === "transparent" ? false : void 0
+          });
+          const intervenedIR = lowerCompositionToHSIIR(intervened);
+          const baseAccess = hsiStableStringify(baseIR.observationPolicy);
+          const newAccess = hsiStableStringify(intervenedIR.observationPolicy);
+          status = baseAccess !== newAccess ? "pass" : "fail";
+          if (status === "fail") detail = "opacity intervention did not change any observation verdict";
+          break;
+        }
+        case "audit:counterfactual-guard": {
+          const intervention = auditCase.intervention;
+          if (intervention.kind !== "set-transition-guard-literal") throw new Error("case/intervention mismatch");
+          const parsed = /transition:([^.]+)\.([^-]+)->([^#]+)#/.exec(intervention.transitionId);
+          if (!parsed) throw new Error(`unparseable transition id ${intervention.transitionId}`);
+          const intervened = clone(composition);
+          applyIntervention(intervened, {
+            id: intervention.id,
+            kind: "set-guard-literal",
+            machine: parsed[1],
+            fromState: parsed[2],
+            toState: parsed[3],
+            value: intervention.value
+          });
+          const intervenedIR = lowerCompositionToHSIIR(intervened);
+          const intervenedTrace = runExactTrace(intervenedIR, scenario);
+          const digestDiffers = intervenedTrace.deterministicDigest !== baseTrace.deterministicDigest;
+          const stepDiffers = baseTrace.steps.some(
+            (step, i) => hsiStableStringify(step.transitions) !== hsiStableStringify(intervenedTrace.steps[i]?.transitions)
+          );
+          status = digestDiffers && stepDiffers ? "pass" : "fail";
+          if (status === "fail") detail = "guard intervention did not change the exact trace";
+          break;
+        }
+        default:
+          detail = `unrecognized audit case ${auditCase.id}`;
+      }
+    } catch (error) {
+      status = "fail";
+      detail = `${detail} \u2014 threw: ${error.message}`;
+    }
+    checks.push({ caseId: auditCase.id, status, detail });
+  }
+  const overall = checks.every((c) => c.status === "pass") ? "pass" : "fail";
+  const manifestWithoutDigest = {
+    schemaVersion: HSI_AUDIT_SCHEMA_VERSION,
+    kind: "HSIAuditManifest",
+    worldDigest: baseIR.provenance.deterministicDigest,
+    verifier: "HSIAuditVerifier",
+    checks,
+    overall
+  };
+  return { ...manifestWithoutDigest, deterministicDigest: hsiSha256(manifestWithoutDigest) };
+}
+
+// src/compiler/index.ts
 chunkTZCFKZ6Z_cjs.init_PlatformConditionalCompilerMixin();
 
 // src/compiler/authority/AuthoritySymbolGraph.ts
@@ -3346,13 +4720,13 @@ function byzantineResilientMerge(agentDags, ledger, options = {}) {
 }
 
 // src/compiler/index.ts
-chunkCESMPUEZ_cjs.init_NodeServiceCompiler();
-chunkCESMPUEZ_cjs.init_SDKCompiler();
-chunkCESMPUEZ_cjs.init_LlamaServerCompiler();
-chunkCESMPUEZ_cjs.init_holoscript_gbnf();
-chunkCESMPUEZ_cjs.init_DialectRegistry();
-chunkCESMPUEZ_cjs.init_registerBuiltinDialects();
-chunkCESMPUEZ_cjs.init_PCGGraphCompiler();
+chunkPHLNABJD_cjs.init_NodeServiceCompiler();
+chunkPHLNABJD_cjs.init_SDKCompiler();
+chunkPHLNABJD_cjs.init_LlamaServerCompiler();
+chunkPHLNABJD_cjs.init_holoscript_gbnf();
+chunkPHLNABJD_cjs.init_DialectRegistry();
+chunkPHLNABJD_cjs.init_registerBuiltinDialects();
+chunkPHLNABJD_cjs.init_PCGGraphCompiler();
 
 // src/compiler/dispatch/DispatchPolicy.ts
 var DispatchTier = /* @__PURE__ */ ((DispatchTier2) => {
@@ -3726,7 +5100,7 @@ async function runTier3CpuDirectExecutor(op) {
 }
 async function runTier1BrowserSnn(op) {
   try {
-    const snnWebgpu = await import('../dist-GRMOP2UL.cjs');
+    const snnWebgpu = await import('../dist-YGATNURH.cjs');
     const { GPUContext, LIFSimulator, DEFAULT_LIF_PARAMS } = snnWebgpu;
     const ctx = new GPUContext();
     await ctx.initialize();
@@ -3831,8 +5205,8 @@ async function sha256Hex(input) {
     const digest = await subtle.digest("SHA-256", new TextEncoder().encode(input));
     return bytesToHex(new Uint8Array(digest));
   }
-  const { createHash: createHash2 } = await import('crypto');
-  return createHash2("sha256").update(input).digest("hex");
+  const { createHash: createHash4 } = await import('crypto');
+  return createHash4("sha256").update(input).digest("hex");
 }
 function bytesToHex(bytes) {
   return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
@@ -4179,8 +5553,8 @@ function formatTierCounts(counts) {
 }
 
 // src/compiler/TraitRegistryBridge.ts
-chunkREN3LHO6_cjs.init_AndroidXRTraitMap();
-chunkFOM36K5I_cjs.init_VisionOSTraitMap();
+chunkQKLEDRHN_cjs.init_AndroidXRTraitMap();
+chunkJ74S4ZMF_cjs.init_VisionOSTraitMap();
 chunk7FYSSI3C_cjs.init_traitDocs();
 function normaliseTraitName(name) {
   return name.toLowerCase().replace(/^@/, "").replace(/trait$/i, "").replace(/_/g, "-").trim();
@@ -4188,7 +5562,7 @@ function normaliseTraitName(name) {
 function queryTrait(name, opts = {}) {
   const target = opts.target || "core";
   if (target === "android-xr") {
-    const map = chunkREN3LHO6_cjs.getTraitMapping(name);
+    const map = chunkQKLEDRHN_cjs.getTraitMapping(name);
     if (map) {
       return {
         name,
@@ -4200,7 +5574,7 @@ function queryTrait(name, opts = {}) {
     }
   }
   if (target === "visionos") {
-    const map = chunkFOM36K5I_cjs.getTraitMapping(name);
+    const map = chunkJ74S4ZMF_cjs.getTraitMapping(name);
     if (map) {
       return {
         name,
@@ -4213,8 +5587,8 @@ function queryTrait(name, opts = {}) {
     return { name, exists: false, sourceMap: "VisionOSTraitMap" };
   }
   const normalised = normaliseTraitName(name);
-  if (chunkML4V5PVU_cjs.vrTraitRegistry.has(normalised)) {
-    const handler = chunkML4V5PVU_cjs.vrTraitRegistry.getHandler(normalised);
+  if (chunkX5ZLSPU2_cjs.vrTraitRegistry.has(normalised)) {
+    const handler = chunkX5ZLSPU2_cjs.vrTraitRegistry.getHandler(normalised);
     const doc2 = chunk7FYSSI3C_cjs.getTraitDoc(name);
     return {
       name,
@@ -4245,12 +5619,12 @@ function queryTrait(name, opts = {}) {
 }
 function generateTraitForTarget(name, target, config = {}) {
   if (target === "android-xr" || target === "android") {
-    return chunkREN3LHO6_cjs.getTraitMapping(name)?.generate?.(name, config) ?? [
+    return chunkQKLEDRHN_cjs.getTraitMapping(name)?.generate?.(name, config) ?? [
       `// @${name} not yet mapped for android-xr (see AndroidXRTraitMap)`
     ];
   }
   if (target === "visionos") {
-    return chunkFOM36K5I_cjs.generateTraitCode(name, name, config) ?? [
+    return chunkJ74S4ZMF_cjs.generateTraitCode(name, name, config) ?? [
       `// @${name} not yet mapped for visionos (see VisionOSTraitMap)`
     ];
   }
@@ -4265,15 +5639,15 @@ function generateTraitForTarget(name, target, config = {}) {
 }
 function listTraitsForTarget(target) {
   if (target === "android-xr") {
-    return Object.keys(chunkREN3LHO6_cjs.ANDROIDXR_TRAIT_MAP);
+    return Object.keys(chunkQKLEDRHN_cjs.ANDROIDXR_TRAIT_MAP);
   }
   if (target === "visionos") {
-    return chunkFOM36K5I_cjs.listAllTraits ? chunkFOM36K5I_cjs.listAllTraits() : [];
+    return chunkJ74S4ZMF_cjs.listAllTraits ? chunkJ74S4ZMF_cjs.listAllTraits() : [];
   }
   if (target === "core") {
     const seen = /* @__PURE__ */ new Set();
     const result = [];
-    for (const name of chunkML4V5PVU_cjs.vrTraitRegistry.getRegisteredTraits()) {
+    for (const name of chunkX5ZLSPU2_cjs.vrTraitRegistry.getRegisteredTraits()) {
       const norm = normaliseTraitName(name);
       if (!seen.has(norm)) {
         seen.add(norm);
@@ -4293,17 +5667,17 @@ function listTraitsForTarget(target) {
 }
 function traitExists(name) {
   const normalised = normaliseTraitName(name);
-  if (chunkML4V5PVU_cjs.vrTraitRegistry.has(normalised)) {
+  if (chunkX5ZLSPU2_cjs.vrTraitRegistry.has(normalised)) {
     return true;
   }
   const doc = chunk7FYSSI3C_cjs.getTraitDoc(name);
   if (doc) {
     return true;
   }
-  if (chunkREN3LHO6_cjs.getTraitMapping(name)) {
+  if (chunkQKLEDRHN_cjs.getTraitMapping(name)) {
     return true;
   }
-  if (chunkFOM36K5I_cjs.getTraitMapping(name)) {
+  if (chunkJ74S4ZMF_cjs.getTraitMapping(name)) {
     return true;
   }
   return false;
@@ -4391,7 +5765,7 @@ function getAllManifests() {
 }
 
 // src/compiler/platform/plugins/WebGPUWGSLPlugin.ts
-chunkERYKKPHW_cjs.init_WebGPUCompiler();
+chunkU6CQOM5Q_cjs.init_WebGPUCompiler();
 var WEBGPU_WGSL_METADATA = {
   name: "holoscript-plugin-webgpu-wgsl",
   version: "1.0.0",
@@ -4420,7 +5794,7 @@ var WebGPUWGSLPlugin = class {
     switch (target) {
       case "web": {
         try {
-          const compiler = new chunkERYKKPHW_cjs.WebGPUCompiler({ enableCompute: true });
+          const compiler = new chunkU6CQOM5Q_cjs.WebGPUCompiler({ enableCompute: true });
           const result = compiler.compile(ast, "");
           return { type: "text", data: result };
         } catch (err) {
@@ -4514,7 +5888,7 @@ var WebGPUWGSLPlugin = class {
 platformPluginRegistry.register(new WebGPUWGSLPlugin());
 
 // src/compiler/platform/plugins/AndroidARCorePlugin.ts
-chunkREN3LHO6_cjs.init_AndroidXRCompiler();
+chunkQKLEDRHN_cjs.init_AndroidXRCompiler();
 var ANDROID_ARCORE_METADATA = {
   name: "holoscript-plugin-android-arcore",
   version: "1.0.0",
@@ -4545,7 +5919,7 @@ var AndroidARCorePlugin = class {
       case "android-xr":
       case "android-xr-ar": {
         try {
-          const compiler = new chunkREN3LHO6_cjs.AndroidXRCompiler({
+          const compiler = new chunkQKLEDRHN_cjs.AndroidXRCompiler({
             formFactor: target === "android-xr-ar" ? "glasses" : "headset"
           });
           const result = compiler.compile(ast, "apl-plugin-token");
@@ -4698,6 +6072,8 @@ var BRIDGE_TARGETS = [
   // Meta Quest (Horizon OS / Meta Spatial SDK) — emits a native Kotlin app to Meta's runtime
   "ios",
   "visionos",
+  "r3f",
+  // SceneIR -> generated TSX shell consumed by React Three Fiber; HoloScript owns SceneIR, R3F is the host runtime bridge
   "usd",
   "usdz",
   "fmu",
@@ -4943,35 +6319,35 @@ var SOVEREIGN_ENGINES = [
 
 Object.defineProperty(exports, "ContextCompileError", {
   enumerable: true,
-  get: function () { return chunkYM7UUYR5_cjs.ContextCompileError; }
+  get: function () { return chunkXHZYS4QO_cjs.ContextCompileError; }
 });
 Object.defineProperty(exports, "ContextCompiler", {
   enumerable: true,
-  get: function () { return chunkYM7UUYR5_cjs.ContextCompiler; }
+  get: function () { return chunkXHZYS4QO_cjs.ContextCompiler; }
 });
 Object.defineProperty(exports, "createContextCompiler", {
   enumerable: true,
-  get: function () { return chunkYM7UUYR5_cjs.createContextCompiler; }
+  get: function () { return chunkXHZYS4QO_cjs.createContextCompiler; }
 });
 Object.defineProperty(exports, "LLMCapabilityCompileError", {
   enumerable: true,
-  get: function () { return chunkD44CEFY4_cjs.LLMCapabilityCompileError; }
+  get: function () { return chunk2DJIS7TH_cjs.LLMCapabilityCompileError; }
 });
 Object.defineProperty(exports, "LLMProviderCapabilitiesCompiler", {
   enumerable: true,
-  get: function () { return chunkD44CEFY4_cjs.LLMProviderCapabilitiesCompiler; }
+  get: function () { return chunk2DJIS7TH_cjs.LLMProviderCapabilitiesCompiler; }
 });
 Object.defineProperty(exports, "createLLMProviderCapabilitiesCompiler", {
   enumerable: true,
-  get: function () { return chunkD44CEFY4_cjs.createLLMProviderCapabilitiesCompiler; }
+  get: function () { return chunk2DJIS7TH_cjs.createLLMProviderCapabilitiesCompiler; }
 });
 Object.defineProperty(exports, "GLTF_PIPELINE_TOOLS", {
   enumerable: true,
-  get: function () { return chunk7ITJP33Q_cjs.GLTF_PIPELINE_TOOLS; }
+  get: function () { return chunk4CQ7ULXZ_cjs.GLTF_PIPELINE_TOOLS; }
 });
 Object.defineProperty(exports, "registerGLTFTools", {
   enumerable: true,
-  get: function () { return chunk7ITJP33Q_cjs.registerGLTFTools; }
+  get: function () { return chunk4CQ7ULXZ_cjs.registerGLTFTools; }
 });
 Object.defineProperty(exports, "BUSINESS_QUEST_TOOLS", {
   enumerable: true,
@@ -5019,287 +6395,287 @@ Object.defineProperty(exports, "parseReproducibilityFlags", {
 });
 Object.defineProperty(exports, "QuantumCircuitCompiler", {
   enumerable: true,
-  get: function () { return chunkGGH3ZYDB_cjs.QuantumCircuitCompiler; }
+  get: function () { return chunkIPBSNGAN_cjs.QuantumCircuitCompiler; }
 });
 Object.defineProperty(exports, "CodeEditorCompiler", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.CodeEditorCompiler; }
+  get: function () { return chunkPHLNABJD_cjs.CodeEditorCompiler; }
 });
 Object.defineProperty(exports, "CompileTimeAuthorityEffectError", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.CompileTimeAuthorityEffectError; }
+  get: function () { return chunkPHLNABJD_cjs.CompileTimeAuthorityEffectError; }
 });
 Object.defineProperty(exports, "CompilerBridge", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.CompilerBridge; }
+  get: function () { return chunkPHLNABJD_cjs.CompilerBridge; }
 });
 Object.defineProperty(exports, "ComputePhysicsCompiler", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.ComputePhysicsCompiler; }
+  get: function () { return chunkPHLNABJD_cjs.ComputePhysicsCompiler; }
 });
 Object.defineProperty(exports, "CpuPathTracer", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.CpuPathTracer; }
+  get: function () { return chunkPHLNABJD_cjs.CpuPathTracer; }
 });
 Object.defineProperty(exports, "DEFAULT_MATERIAL_KEYWORDS", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.DEFAULT_MATERIAL_KEYWORDS; }
+  get: function () { return chunkPHLNABJD_cjs.DEFAULT_MATERIAL_KEYWORDS; }
 });
 Object.defineProperty(exports, "DEFAULT_OBJECT_KEYWORDS", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.DEFAULT_OBJECT_KEYWORDS; }
+  get: function () { return chunkPHLNABJD_cjs.DEFAULT_OBJECT_KEYWORDS; }
 });
 Object.defineProperty(exports, "DEFAULT_PRIMITIVE_SHAPES", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.DEFAULT_PRIMITIVE_SHAPES; }
+  get: function () { return chunkPHLNABJD_cjs.DEFAULT_PRIMITIVE_SHAPES; }
 });
 Object.defineProperty(exports, "DesktopGPUCompiler", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.DesktopGPUCompiler; }
+  get: function () { return chunkPHLNABJD_cjs.DesktopGPUCompiler; }
 });
 Object.defineProperty(exports, "DialectRegistry", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.DialectRegistry; }
+  get: function () { return chunkPHLNABJD_cjs.DialectRegistry; }
 });
 Object.defineProperty(exports, "EdgeCompiler", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.EdgeCompiler; }
+  get: function () { return chunkPHLNABJD_cjs.EdgeCompiler; }
 });
 Object.defineProperty(exports, "FMUCompiler", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.FMUCompiler; }
+  get: function () { return chunkPHLNABJD_cjs.FMUCompiler; }
 });
 Object.defineProperty(exports, "GaussianSplattingCompiler", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.GaussianSplattingCompiler; }
+  get: function () { return chunkPHLNABJD_cjs.GaussianSplattingCompiler; }
 });
 Object.defineProperty(exports, "GaussianTrainCompiler", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.GaussianTrainCompiler; }
+  get: function () { return chunkPHLNABJD_cjs.GaussianTrainCompiler; }
 });
 Object.defineProperty(exports, "GaussianTrainConfigError", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.GaussianTrainConfigError; }
+  get: function () { return chunkPHLNABJD_cjs.GaussianTrainConfigError; }
 });
 Object.defineProperty(exports, "HOLOSCRIPT_GRAMMAR_PRESETS", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.HOLOSCRIPT_GRAMMAR_PRESETS; }
+  get: function () { return chunkPHLNABJD_cjs.HOLOSCRIPT_GRAMMAR_PRESETS; }
 });
 Object.defineProperty(exports, "HoloMCPCompiler", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.HoloMCPCompiler; }
+  get: function () { return chunkPHLNABJD_cjs.HoloMCPCompiler; }
 });
 Object.defineProperty(exports, "LlamaServerCompiler", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.LlamaServerCompiler; }
+  get: function () { return chunkPHLNABJD_cjs.LlamaServerCompiler; }
 });
 Object.defineProperty(exports, "MediaPipelineCompiler", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.MediaPipelineCompiler; }
+  get: function () { return chunkPHLNABJD_cjs.MediaPipelineCompiler; }
 });
 Object.defineProperty(exports, "NextJSAPICompiler", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.NextJSAPICompiler; }
+  get: function () { return chunkPHLNABJD_cjs.NextJSAPICompiler; }
 });
 Object.defineProperty(exports, "NodeServiceCompiler", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.NodeServiceCompiler; }
+  get: function () { return chunkPHLNABJD_cjs.NodeServiceCompiler; }
 });
 Object.defineProperty(exports, "OmnigentAgentYamlCompiler", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.OmnigentAgentYamlCompiler; }
+  get: function () { return chunkPHLNABJD_cjs.OmnigentAgentYamlCompiler; }
 });
 Object.defineProperty(exports, "PCGGraphCompiler", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.PCGGraphCompiler; }
+  get: function () { return chunkPHLNABJD_cjs.PCGGraphCompiler; }
 });
 Object.defineProperty(exports, "PCG_GRAPH_SCHEMA", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.PCG_GRAPH_SCHEMA; }
+  get: function () { return chunkPHLNABJD_cjs.PCG_GRAPH_SCHEMA; }
 });
 Object.defineProperty(exports, "PathTracerCompiler", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.PathTracerCompiler; }
+  get: function () { return chunkPHLNABJD_cjs.PathTracerCompiler; }
 });
 Object.defineProperty(exports, "PhysicsColliderCompiler", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.PhysicsColliderCompiler; }
+  get: function () { return chunkPHLNABJD_cjs.PhysicsColliderCompiler; }
 });
 Object.defineProperty(exports, "REMOTE_TRAIN_EXECUTOR", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.REMOTE_TRAIN_EXECUTOR; }
+  get: function () { return chunkPHLNABJD_cjs.REMOTE_TRAIN_EXECUTOR; }
 });
 Object.defineProperty(exports, "REQUIRED_SANDBOX_AUTHORITY_EFFECT", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.REQUIRED_SANDBOX_AUTHORITY_EFFECT; }
+  get: function () { return chunkPHLNABJD_cjs.REQUIRED_SANDBOX_AUTHORITY_EFFECT; }
 });
 Object.defineProperty(exports, "SANDBOX_AUTHORITY_TRAIT", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.SANDBOX_AUTHORITY_TRAIT; }
+  get: function () { return chunkPHLNABJD_cjs.SANDBOX_AUTHORITY_TRAIT; }
 });
 Object.defineProperty(exports, "SCMCompiler", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.SCMCompiler; }
+  get: function () { return chunkPHLNABJD_cjs.SCMCompiler; }
 });
 Object.defineProperty(exports, "SDKCompiler", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.SDKCompiler; }
+  get: function () { return chunkPHLNABJD_cjs.SDKCompiler; }
 });
 Object.defineProperty(exports, "SHARED_SORT_SHADER_PATH", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.SHARED_SORT_SHADER_PATH; }
+  get: function () { return chunkPHLNABJD_cjs.SHARED_SORT_SHADER_PATH; }
 });
 Object.defineProperty(exports, "SOVEREIGN_TRAIN_EXECUTOR", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.SOVEREIGN_TRAIN_EXECUTOR; }
+  get: function () { return chunkPHLNABJD_cjs.SOVEREIGN_TRAIN_EXECUTOR; }
 });
 Object.defineProperty(exports, "SVGCompiler", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.SVGCompiler; }
+  get: function () { return chunkPHLNABJD_cjs.SVGCompiler; }
 });
 Object.defineProperty(exports, "SpatialAudioCompiler", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.SpatialAudioCompiler; }
+  get: function () { return chunkPHLNABJD_cjs.SpatialAudioCompiler; }
 });
 Object.defineProperty(exports, "SpatialPartitionPass", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.SpatialPartitionPass; }
+  get: function () { return chunkPHLNABJD_cjs.SpatialPartitionPass; }
 });
 Object.defineProperty(exports, "ThreeDTilesCompiler", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.ThreeDTilesCompiler; }
+  get: function () { return chunkPHLNABJD_cjs.ThreeDTilesCompiler; }
 });
 Object.defineProperty(exports, "USDZPipeline", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.USDZPipeline; }
+  get: function () { return chunkPHLNABJD_cjs.USDZPipeline; }
 });
 Object.defineProperty(exports, "absorbFMU", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.absorbFMU; }
+  get: function () { return chunkPHLNABJD_cjs.absorbFMU; }
 });
 Object.defineProperty(exports, "assertAuthorityEffects", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.assertAuthorityEffects; }
+  get: function () { return chunkPHLNABJD_cjs.assertAuthorityEffects; }
 });
 Object.defineProperty(exports, "bestCategoryForTraits", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.bestCategoryForTraits; }
+  get: function () { return chunkPHLNABJD_cjs.bestCategoryForTraits; }
 });
 Object.defineProperty(exports, "checkAuthorityEffects", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.checkAuthorityEffects; }
+  get: function () { return chunkPHLNABJD_cjs.checkAuthorityEffects; }
 });
 Object.defineProperty(exports, "collectAuthorityEffectNodes", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.collectAuthorityEffectNodes; }
+  get: function () { return chunkPHLNABJD_cjs.collectAuthorityEffectNodes; }
 });
 Object.defineProperty(exports, "compileAllToNextJSAPI", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.compileAllToNextJSAPI; }
+  get: function () { return chunkPHLNABJD_cjs.compileAllToNextJSAPI; }
 });
 Object.defineProperty(exports, "compilePCGGraphFromBlocks", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.compilePCGGraphFromBlocks; }
+  get: function () { return chunkPHLNABJD_cjs.compilePCGGraphFromBlocks; }
 });
 Object.defineProperty(exports, "compilePipelineSource", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.compilePipelineSource; }
+  get: function () { return chunkPHLNABJD_cjs.compilePipelineSource; }
 });
 Object.defineProperty(exports, "compilePipelineSourceToNode", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.compilePipelineSourceToNode; }
+  get: function () { return chunkPHLNABJD_cjs.compilePipelineSourceToNode; }
 });
 Object.defineProperty(exports, "compilePipelineSourceToPython", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.compilePipelineSourceToPython; }
+  get: function () { return chunkPHLNABJD_cjs.compilePipelineSourceToPython; }
 });
 Object.defineProperty(exports, "compilePipelineToNode", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.compilePipelineToNode; }
+  get: function () { return chunkPHLNABJD_cjs.compilePipelineToNode; }
 });
 Object.defineProperty(exports, "compilePipelineToPython", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.compilePipelineToPython; }
+  get: function () { return chunkPHLNABJD_cjs.compilePipelineToPython; }
 });
 Object.defineProperty(exports, "compileTo3DTiles", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.compileTo3DTiles; }
+  get: function () { return chunkPHLNABJD_cjs.compileTo3DTiles; }
 });
 Object.defineProperty(exports, "compileToFMU", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.compileToFMU; }
+  get: function () { return chunkPHLNABJD_cjs.compileToFMU; }
 });
 Object.defineProperty(exports, "compileToNextJSAPI", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.compileToNextJSAPI; }
+  get: function () { return chunkPHLNABJD_cjs.compileToNextJSAPI; }
 });
 Object.defineProperty(exports, "compileToPCGGraph", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.compileToPCGGraph; }
+  get: function () { return chunkPHLNABJD_cjs.compileToPCGGraph; }
 });
 Object.defineProperty(exports, "createGaussianSplattingCompiler", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.createGaussianSplattingCompiler; }
+  get: function () { return chunkPHLNABJD_cjs.createGaussianSplattingCompiler; }
 });
 Object.defineProperty(exports, "createGaussianTrainCompiler", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.createGaussianTrainCompiler; }
+  get: function () { return chunkPHLNABJD_cjs.createGaussianTrainCompiler; }
 });
 Object.defineProperty(exports, "createOmnigentAgentYamlCompiler", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.createOmnigentAgentYamlCompiler; }
+  get: function () { return chunkPHLNABJD_cjs.createOmnigentAgentYamlCompiler; }
 });
 Object.defineProperty(exports, "createThreeDTilesCompiler", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.createThreeDTilesCompiler; }
+  get: function () { return chunkPHLNABJD_cjs.createThreeDTilesCompiler; }
 });
 Object.defineProperty(exports, "detectMultiUserSharedSort", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.detectMultiUserSharedSort; }
+  get: function () { return chunkPHLNABJD_cjs.detectMultiUserSharedSort; }
 });
 Object.defineProperty(exports, "ensureDialectsBooted", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.ensureDialectsBooted; }
+  get: function () { return chunkPHLNABJD_cjs.ensureDialectsBooted; }
 });
 Object.defineProperty(exports, "generateHoloScriptGbnf", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.generateHoloScriptGbnf; }
+  get: function () { return chunkPHLNABJD_cjs.generateHoloScriptGbnf; }
 });
 Object.defineProperty(exports, "isHoloScriptGrammarPreset", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.isHoloScriptGrammarPreset; }
+  get: function () { return chunkPHLNABJD_cjs.isHoloScriptGrammarPreset; }
 });
 Object.defineProperty(exports, "pcgGraphToUnrealXml", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.pcgGraphToUnrealXml; }
+  get: function () { return chunkPHLNABJD_cjs.pcgGraphToUnrealXml; }
 });
 Object.defineProperty(exports, "quickSafetyCheck", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.quickSafetyCheck; }
+  get: function () { return chunkPHLNABJD_cjs.quickSafetyCheck; }
 });
 Object.defineProperty(exports, "registerBuiltinDialects", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.registerBuiltinDialects; }
+  get: function () { return chunkPHLNABJD_cjs.registerBuiltinDialects; }
 });
 Object.defineProperty(exports, "runSafetyPass", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.runSafetyPass; }
+  get: function () { return chunkPHLNABJD_cjs.runSafetyPass; }
 });
 Object.defineProperty(exports, "selectModality", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.selectModality; }
+  get: function () { return chunkPHLNABJD_cjs.selectModality; }
 });
 Object.defineProperty(exports, "selectModalityForAll", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.selectModalityForAll; }
+  get: function () { return chunkPHLNABJD_cjs.selectModalityForAll; }
 });
 Object.defineProperty(exports, "spatialPartition", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.spatialPartition; }
+  get: function () { return chunkPHLNABJD_cjs.spatialPartition; }
 });
 Object.defineProperty(exports, "streamWorldTiles", {
   enumerable: true,
-  get: function () { return chunkCESMPUEZ_cjs.streamWorldTiles; }
+  get: function () { return chunkPHLNABJD_cjs.streamWorldTiles; }
 });
 Object.defineProperty(exports, "generateHullGeometry", {
   enumerable: true,
@@ -5315,23 +6691,23 @@ Object.defineProperty(exports, "generateSplineGeometry", {
 });
 Object.defineProperty(exports, "SceneIRCompiler", {
   enumerable: true,
-  get: function () { return chunk4CRMVEON_cjs.SceneIRCompiler; }
+  get: function () { return chunkF47FEV4X_cjs.SceneIRCompiler; }
 });
 Object.defineProperty(exports, "DaimonSeedCompiler", {
   enumerable: true,
-  get: function () { return chunkOOP4S3GU_cjs.DaimonSeedCompiler; }
+  get: function () { return chunkOQVHCYY4_cjs.DaimonSeedCompiler; }
 });
 Object.defineProperty(exports, "computeExportFidelity", {
   enumerable: true,
-  get: function () { return chunkOOP4S3GU_cjs.computeExportFidelity; }
+  get: function () { return chunkOQVHCYY4_cjs.computeExportFidelity; }
 });
 Object.defineProperty(exports, "createDaimonSeedCompiler", {
   enumerable: true,
-  get: function () { return chunkOOP4S3GU_cjs.createDaimonSeedCompiler; }
+  get: function () { return chunkOQVHCYY4_cjs.createDaimonSeedCompiler; }
 });
 Object.defineProperty(exports, "runHysteresisExp2", {
   enumerable: true,
-  get: function () { return chunkOOP4S3GU_cjs.runHysteresisExp2; }
+  get: function () { return chunkOQVHCYY4_cjs.runHysteresisExp2; }
 });
 Object.defineProperty(exports, "COCOExporter", {
   enumerable: true,
@@ -5347,91 +6723,91 @@ Object.defineProperty(exports, "SemanticSceneGraph", {
 });
 Object.defineProperty(exports, "AgentInferenceCompiler", {
   enumerable: true,
-  get: function () { return chunkYMI3ED3B_cjs.AgentInferenceCompiler; }
+  get: function () { return chunkCRUIGXF7_cjs.AgentInferenceCompiler; }
 });
 Object.defineProperty(exports, "AgentInferenceExportTarget", {
   enumerable: true,
-  get: function () { return chunkYMI3ED3B_cjs.AgentInferenceExportTarget_default; }
+  get: function () { return chunkCRUIGXF7_cjs.AgentInferenceExportTarget_default; }
 });
 Object.defineProperty(exports, "createAgentInferenceCompiler", {
   enumerable: true,
-  get: function () { return chunkYMI3ED3B_cjs.createAgentInferenceCompiler; }
+  get: function () { return chunkCRUIGXF7_cjs.createAgentInferenceCompiler; }
 });
 Object.defineProperty(exports, "createPythonAgentInferenceCompiler", {
   enumerable: true,
-  get: function () { return chunkYMI3ED3B_cjs.createPythonAgentInferenceCompiler; }
+  get: function () { return chunkCRUIGXF7_cjs.createPythonAgentInferenceCompiler; }
 });
 Object.defineProperty(exports, "USDPhysicsCompiler", {
   enumerable: true,
-  get: function () { return chunk5B2AJKA5_cjs.USDPhysicsCompiler; }
+  get: function () { return chunkFQ4MYZYU_cjs.USDPhysicsCompiler; }
 });
 Object.defineProperty(exports, "SDFCompiler", {
   enumerable: true,
-  get: function () { return chunkKLM6QD6D_cjs.SDFCompiler; }
+  get: function () { return chunkQ6VW7MGX_cjs.SDFCompiler; }
 });
 Object.defineProperty(exports, "StateCompiler", {
   enumerable: true,
-  get: function () { return chunkSKVBUGMC_cjs.StateCompiler; }
+  get: function () { return chunkAUMTQV64_cjs.StateCompiler; }
 });
 Object.defineProperty(exports, "TraitCompositionCompiler", {
   enumerable: true,
-  get: function () { return chunkVZI7S7P6_cjs.TraitCompositionCompiler; }
+  get: function () { return chunkVSO6HPDZ_cjs.TraitCompositionCompiler; }
 });
 Object.defineProperty(exports, "IncrementalCompiler", {
   enumerable: true,
-  get: function () { return chunkPZ46WRHX_cjs.IncrementalCompiler; }
+  get: function () { return chunkXRQCTTDC_cjs.IncrementalCompiler; }
 });
 Object.defineProperty(exports, "createIncrementalCompiler", {
   enumerable: true,
-  get: function () { return chunkPZ46WRHX_cjs.createIncrementalCompiler; }
+  get: function () { return chunkXRQCTTDC_cjs.createIncrementalCompiler; }
 });
 Object.defineProperty(exports, "AndroidCompiler", {
   enumerable: true,
-  get: function () { return chunkXZC75AJ4_cjs.AndroidCompiler; }
+  get: function () { return chunkFPGYWNNA_cjs.AndroidCompiler; }
 });
 Object.defineProperty(exports, "AndroidXRCompiler", {
   enumerable: true,
-  get: function () { return chunkREN3LHO6_cjs.AndroidXRCompiler; }
+  get: function () { return chunkQKLEDRHN_cjs.AndroidXRCompiler; }
 });
 Object.defineProperty(exports, "IOSCompiler", {
   enumerable: true,
-  get: function () { return chunkGYJLP4BO_cjs.IOSCompiler; }
+  get: function () { return chunkK53L47NH_cjs.IOSCompiler; }
 });
 Object.defineProperty(exports, "VisionOSCompiler", {
   enumerable: true,
-  get: function () { return chunkFOM36K5I_cjs.VisionOSCompiler; }
+  get: function () { return chunkJ74S4ZMF_cjs.VisionOSCompiler; }
 });
 Object.defineProperty(exports, "WASMCompiler", {
   enumerable: true,
-  get: function () { return chunkSNMQUWIO_cjs.WASMCompiler; }
+  get: function () { return chunkNTSLNIY7_cjs.WASMCompiler; }
 });
 Object.defineProperty(exports, "WebGPUCompiler", {
   enumerable: true,
-  get: function () { return chunkERYKKPHW_cjs.WebGPUCompiler; }
+  get: function () { return chunkU6CQOM5Q_cjs.WebGPUCompiler; }
 });
 Object.defineProperty(exports, "DTDLCompiler", {
   enumerable: true,
-  get: function () { return chunkOSKGCXAQ_cjs.DTDLCompiler; }
+  get: function () { return chunkFGTXAVKG_cjs.DTDLCompiler; }
 });
 Object.defineProperty(exports, "URDFCompiler", {
   enumerable: true,
-  get: function () { return chunkB6JHTTMR_cjs.URDFCompiler; }
+  get: function () { return chunkN2BOTBPG_cjs.URDFCompiler; }
 });
 Object.defineProperty(exports, "createURDFCompiler", {
   enumerable: true,
-  get: function () { return chunkB6JHTTMR_cjs.createURDFCompiler; }
+  get: function () { return chunkN2BOTBPG_cjs.createURDFCompiler; }
 });
 Object.defineProperty(exports, "OpenXRCompiler", {
   enumerable: true,
-  get: function () { return chunkVTFLKSJL_cjs.OpenXRCompiler; }
+  get: function () { return chunkZHW6TDZ6_cjs.OpenXRCompiler; }
 });
 Object.defineProperty(exports, "VRChatCompiler", {
   enumerable: true,
-  get: function () { return chunkVA7THINF_cjs.VRChatCompiler; }
+  get: function () { return chunkZXXC2GXB_cjs.VRChatCompiler; }
 });
 Object.defineProperty(exports, "UnityCompiler", {
   enumerable: true,
-  get: function () { return chunkLQNL3IYV_cjs.UnityCompiler; }
+  get: function () { return chunkLNJKBQ2B_cjs.UnityCompiler; }
 });
 Object.defineProperty(exports, "PlatformConditionalCompilerMixin", {
   enumerable: true,
@@ -5455,7 +6831,7 @@ Object.defineProperty(exports, "normalizePlatformName", {
 });
 Object.defineProperty(exports, "GodotCompiler", {
   enumerable: true,
-  get: function () { return chunkHCONR4J6_cjs.GodotCompiler; }
+  get: function () { return chunkAN3ZH7M7_cjs.GodotCompiler; }
 });
 Object.defineProperty(exports, "SCIENTIFIC_COLOR_MAPS", {
   enumerable: true,
@@ -5491,23 +6867,23 @@ Object.defineProperty(exports, "srgbToHex", {
 });
 Object.defineProperty(exports, "CompilerBase", {
   enumerable: true,
-  get: function () { return chunkSE2Y5BSL_cjs.CompilerBase; }
+  get: function () { return chunkCMEINO5I_cjs.CompilerBase; }
 });
 Object.defineProperty(exports, "CompilerDocumentationGenerator", {
   enumerable: true,
-  get: function () { return chunkSE2Y5BSL_cjs.CompilerDocumentationGenerator; }
+  get: function () { return chunkCMEINO5I_cjs.CompilerDocumentationGenerator; }
 });
 Object.defineProperty(exports, "UnauthorizedCompilerAccessError", {
   enumerable: true,
-  get: function () { return chunkSE2Y5BSL_cjs.UnauthorizedCompilerAccessError; }
+  get: function () { return chunkCMEINO5I_cjs.UnauthorizedCompilerAccessError; }
 });
 Object.defineProperty(exports, "createTestCompilerToken", {
   enumerable: true,
-  get: function () { return chunkSE2Y5BSL_cjs.createTestCompilerToken; }
+  get: function () { return chunkCMEINO5I_cjs.createTestCompilerToken; }
 });
 Object.defineProperty(exports, "isCapabilityTokenCredential", {
   enumerable: true,
-  get: function () { return chunkSE2Y5BSL_cjs.isCapabilityTokenCredential; }
+  get: function () { return chunkCMEINO5I_cjs.isCapabilityTokenCredential; }
 });
 exports.AgentTrustLedger = AgentTrustLedger;
 exports.AlphaTracker = AlphaTracker;
@@ -5520,6 +6896,13 @@ exports.COLYSEUS_SCHEMA_FIELD_TIERS = COLYSEUS_SCHEMA_FIELD_TIERS;
 exports.DEFAULT_DISPATCH_LATENCY_OPERATION = DEFAULT_DISPATCH_LATENCY_OPERATION;
 exports.DispatchPolicy = DispatchPolicy;
 exports.DispatchTier = DispatchTier;
+exports.HSIAdmissionError = HSIAdmissionError;
+exports.HSIIRCompiler = HSIIRCompiler;
+exports.HSI_AUDIT_SCHEMA_VERSION = HSI_AUDIT_SCHEMA_VERSION;
+exports.HSI_IR_SCHEMA_VERSION = HSI_IR_SCHEMA_VERSION;
+exports.HSI_LEARNING_GRAPH_SCHEMA_VERSION = HSI_LEARNING_GRAPH_SCHEMA_VERSION;
+exports.HSI_OBSERVATION_MEDIATOR_EDGE = HSI_OBSERVATION_MEDIATOR_EDGE;
+exports.HSI_TRACE_SCHEMA_VERSION = HSI_TRACE_SCHEMA_VERSION;
 exports.MCPConfigCompiler = MCPConfigCompiler;
 exports.MultiLayerCompiler = MultiLayerCompiler;
 exports.NATIVE_COMPILE_MODES = NATIVE_COMPILE_MODES;
@@ -5529,29 +6912,45 @@ exports.SOVEREIGN_ENGINES = SOVEREIGN_ENGINES;
 exports.SOVEREIGN_TARGETS = SOVEREIGN_TARGETS;
 exports.Vector2DCompiler = Vector2DCompiler;
 exports.WebGPUWGSLPlugin = WebGPUWGSLPlugin;
+exports.applyIntervention = applyIntervention;
+exports.behavioralProjection = behavioralProjection;
 exports.buildColyseusAuthorityGraph = buildColyseusAuthorityGraph;
 exports.buildColyseusCrossFileContext = buildColyseusCrossFileContext;
 exports.byzantineResilientMerge = byzantineResilientMerge;
 exports.createAuthoritySymbolGraph = createAuthoritySymbolGraph;
 exports.createDefaultDispatchLatencyScenarios = createDefaultDispatchLatencyScenarios;
+exports.createHSIIRCompiler = createHSIIRCompiler;
 exports.createProvenanceBoundsChecker = createProvenanceBoundsChecker;
 exports.createTier3CpuDirectOutput = createTier3CpuDirectOutput;
 exports.detectWasmRuntime = detectWasmRuntime;
+exports.emitSceneIRTsx = emitSceneIRTsx;
 exports.formatDispatchLatencyBenchmarkReport = formatDispatchLatencyBenchmarkReport;
+exports.generateAuditCases = generateAuditCases;
 exports.generateTraitForTarget = generateTraitForTarget;
 exports.getAllManifests = getAllManifests;
 exports.getTraitInfo = getTraitInfo;
+exports.hsiSha256 = hsiSha256;
+exports.hsiSourceTextDigest = hsiSourceTextDigest;
+exports.hsiStableStringify = hsiStableStringify;
 exports.isBridgeTarget = isBridgeTarget;
 exports.isSovereignTarget = isSovereignTarget;
 exports.listTraitsForTarget = listTraitsForTarget;
+exports.lowerCompositionToHSIIR = lowerCompositionToHSIIR;
+exports.lowerHoloExpression = lowerHoloExpression;
 exports.manifestFromPlugin = manifestFromPlugin;
 exports.mergeSocialCausalModels = mergeSocialCausalModels;
 exports.mostRestrictiveTier = mostRestrictiveTier;
 exports.platformPluginRegistry = platformPluginRegistry;
+exports.projectLearningGraph = projectLearningGraph;
 exports.queryTrait = queryTrait;
 exports.recommendDispatchPolicyDefaults = recommendDispatchPolicyDefaults;
+exports.renameComposition = renameComposition;
+exports.renameTrace = renameTrace;
+exports.reorderComposition = reorderComposition;
 exports.runCompilerWasmSnnEmulator = runCompilerWasmSnnEmulator;
 exports.runDispatchPolicyLatencyBenchmark = runDispatchPolicyLatencyBenchmark;
+exports.runExactTrace = runExactTrace;
+exports.runHSIAudit = runHSIAudit;
 exports.splitServerAuthority = splitServerAuthority;
 exports.targetSovereignty = targetSovereignty;
 exports.traitExists = traitExists;