@holoscript/core 8.0.14 → 8.0.16

package/dist/compiler/index.js

@@ -1,89 +1,89 @@
-export { ContextCompileError, ContextCompiler, createContextCompiler } from '../chunk-42Z3SVHQ.js';
-export { LLMCapabilityCompileError, LLMProviderCapabilitiesCompiler, createLLMProviderCapabilitiesCompiler } from '../chunk-LGRKBTPM.js';
-export { GLTF_PIPELINE_TOOLS, registerGLTFTools } from '../chunk-2GKF7JQ6.js';
+export { ContextCompileError, ContextCompiler, createContextCompiler } from '../chunk-X5PMMK7H.js';
+export { LLMCapabilityCompileError, LLMProviderCapabilitiesCompiler, createLLMProviderCapabilitiesCompiler } from '../chunk-OG7RKWWX.js';
+export { GLTF_PIPELINE_TOOLS, registerGLTFTools } from '../chunk-M2GDE3NV.js';
 export { BUSINESS_QUEST_TOOLS, buildVRRCompositionFromDraft, businessVRRDraftSchema, draftToHoloPreview, handleBusinessQuestToolCall, registerBusinessQuestTools, validateBusinessVRRDraft } from '../chunk-NWMJPTVL.js';
 export { NodeToyMapper, mapNodeToyToShader } from '../chunk-TG7O4WBC.js';
 export { createReproducibilityContext, parseReproducibilityFlags } from '../chunk-5GLCTO44.js';
-export { QuantumCircuitCompiler } from '../chunk-GI5YYZH6.js';
-import { init_NextJSAPICompiler, init_DialectRegistry, DialectRegistry, init_HoloMCPCompiler, init_OmnigentAgentYamlCompiler, init_NodeServiceCompiler, init_SDKCompiler, init_LlamaServerCompiler, init_holoscript_gbnf, init_registerBuiltinDialects, init_PCGGraphCompiler } from '../chunk-EYHPTJ3F.js';
-export { CodeEditorCompiler, CompileTimeAuthorityEffectError, CompilerBridge, ComputePhysicsCompiler, CpuPathTracer, DEFAULT_MATERIAL_KEYWORDS, DEFAULT_OBJECT_KEYWORDS, DEFAULT_PRIMITIVE_SHAPES, DesktopGPUCompiler, DialectRegistry, EdgeCompiler, FMUCompiler, GaussianSplattingCompiler, GaussianTrainCompiler, GaussianTrainConfigError, HOLOSCRIPT_GRAMMAR_PRESETS, HoloMCPCompiler, LlamaServerCompiler, MediaPipelineCompiler, NextJSAPICompiler, NodeServiceCompiler, OmnigentAgentYamlCompiler, PCGGraphCompiler, PCG_GRAPH_SCHEMA, PathTracerCompiler, PhysicsColliderCompiler, REMOTE_TRAIN_EXECUTOR, REQUIRED_SANDBOX_AUTHORITY_EFFECT, SANDBOX_AUTHORITY_TRAIT, SCMCompiler, SDKCompiler, SHARED_SORT_SHADER_PATH, SOVEREIGN_TRAIN_EXECUTOR, SVGCompiler, SpatialAudioCompiler, SpatialPartitionPass, ThreeDTilesCompiler, USDZPipeline, absorbFMU, assertAuthorityEffects, bestCategoryForTraits, checkAuthorityEffects, collectAuthorityEffectNodes, compileAllToNextJSAPI, compilePCGGraphFromBlocks, compilePipelineSource, compilePipelineSourceToNode, compilePipelineSourceToPython, compilePipelineToNode, compilePipelineToPython, compileTo3DTiles, compileToFMU, compileToNextJSAPI, compileToPCGGraph, createGaussianSplattingCompiler, createGaussianTrainCompiler, createOmnigentAgentYamlCompiler, createThreeDTilesCompiler, detectMultiUserSharedSort, ensureDialectsBooted, generateHoloScriptGbnf, isHoloScriptGrammarPreset, pcgGraphToUnrealXml, quickSafetyCheck, registerBuiltinDialects, runSafetyPass, selectModality, selectModalityForAll, spatialPartition, streamWorldTiles } from '../chunk-EYHPTJ3F.js';
+export { QuantumCircuitCompiler } from '../chunk-E4YS5SIZ.js';
+import { init_NextJSAPICompiler, init_DialectRegistry, DialectRegistry, init_HoloMCPCompiler, init_OmnigentAgentYamlCompiler, init_NodeServiceCompiler, init_SDKCompiler, init_LlamaServerCompiler, init_holoscript_gbnf, init_registerBuiltinDialects, init_PCGGraphCompiler } from '../chunk-PV2OXNP5.js';
+export { CodeEditorCompiler, CompileTimeAuthorityEffectError, CompilerBridge, ComputePhysicsCompiler, CpuPathTracer, DEFAULT_MATERIAL_KEYWORDS, DEFAULT_OBJECT_KEYWORDS, DEFAULT_PRIMITIVE_SHAPES, DesktopGPUCompiler, DialectRegistry, EdgeCompiler, FMUCompiler, GaussianSplattingCompiler, GaussianTrainCompiler, GaussianTrainConfigError, HOLOSCRIPT_GRAMMAR_PRESETS, HoloMCPCompiler, LlamaServerCompiler, MediaPipelineCompiler, NextJSAPICompiler, NodeServiceCompiler, OmnigentAgentYamlCompiler, PCGGraphCompiler, PCG_GRAPH_SCHEMA, PathTracerCompiler, PhysicsColliderCompiler, REMOTE_TRAIN_EXECUTOR, REQUIRED_SANDBOX_AUTHORITY_EFFECT, SANDBOX_AUTHORITY_TRAIT, SCMCompiler, SDKCompiler, SHARED_SORT_SHADER_PATH, SOVEREIGN_TRAIN_EXECUTOR, SVGCompiler, SpatialAudioCompiler, SpatialPartitionPass, ThreeDTilesCompiler, USDZPipeline, absorbFMU, assertAuthorityEffects, bestCategoryForTraits, checkAuthorityEffects, collectAuthorityEffectNodes, compileAllToNextJSAPI, compilePCGGraphFromBlocks, compilePipelineSource, compilePipelineSourceToNode, compilePipelineSourceToPython, compilePipelineToNode, compilePipelineToPython, compileTo3DTiles, compileToFMU, compileToNextJSAPI, compileToPCGGraph, createGaussianSplattingCompiler, createGaussianTrainCompiler, createOmnigentAgentYamlCompiler, createThreeDTilesCompiler, detectMultiUserSharedSort, ensureDialectsBooted, generateHoloScriptGbnf, isHoloScriptGrammarPreset, pcgGraphToUnrealXml, quickSafetyCheck, registerBuiltinDialects, runSafetyPass, selectModality, selectModalityForAll, spatialPartition, streamWorldTiles } from '../chunk-PV2OXNP5.js';
 export { generateHullGeometry, generateMembraneGeometry, generateSplineGeometry } from '../chunk-UDE4OZMR.js';
 import '../chunk-3F7ZZWIN.js';
-export { SceneIRCompiler } from '../chunk-PSWCJQS4.js';
+export { SceneIRCompiler } from '../chunk-X727CQ7X.js';
 import '../chunk-2MQKNDNH.js';
-import { init_DaimonSeedCompiler } from '../chunk-4NEPHK2K.js';
-export { DaimonSeedCompiler, computeExportFidelity, createDaimonSeedCompiler, runHysteresisExp2 } from '../chunk-4NEPHK2K.js';
+import { init_DaimonSeedCompiler } from '../chunk-PMACVMHL.js';
+export { DaimonSeedCompiler, computeExportFidelity, createDaimonSeedCompiler, runHysteresisExp2 } from '../chunk-PMACVMHL.js';
 import { assertHoloMapManifestContract } from '../chunk-IXWGYWH6.js';
 export { COCOExporterImpl as COCOExporter } from '../chunk-Q56TT7IL.js';
 export { RemotionBridgeImpl as RemotionBridge } from '../chunk-YYXH45E2.js';
 export { SemanticSceneGraph } from '../chunk-HHRZ6STP.js';
-import { init_AgentInferenceExportTarget } from '../chunk-KOGPVAP6.js';
-export { AgentInferenceCompiler, AgentInferenceExportTarget_default as AgentInferenceExportTarget, createAgentInferenceCompiler, createPythonAgentInferenceCompiler } from '../chunk-KOGPVAP6.js';
-import { vrTraitRegistry } from '../chunk-W4AJMMQR.js';
+import { init_AgentInferenceExportTarget } from '../chunk-FT4FGTR6.js';
+export { AgentInferenceCompiler, AgentInferenceExportTarget_default as AgentInferenceExportTarget, createAgentInferenceCompiler, createPythonAgentInferenceCompiler } from '../chunk-FT4FGTR6.js';
+import { vrTraitRegistry, evaluateExpressionIR, parseExpressionToIR, ExpressionParseError } from '../chunk-AUF7HFOO.js';
 import '../chunk-6TRX6AR2.js';
-import '../chunk-ZVQMKUGJ.js';
+import '../chunk-Z5V3KA7L.js';
 import { isWebGpuEnvironmentPresent } from '../chunk-K56UVEXV.js';
 import '../chunk-OG3MBHM3.js';
 import '../chunk-2M2DPHKB.js';
 import '../chunk-TDCNJHWO.js';
 import '../chunk-VKCTYLDN.js';
 import '../chunk-YQELFNJV.js';
-export { USDPhysicsCompiler } from '../chunk-BLCWQ225.js';
-import { init_SDFCompiler } from '../chunk-IXFNA5TT.js';
-export { SDFCompiler } from '../chunk-IXFNA5TT.js';
-import { init_StateCompiler } from '../chunk-62OYZT6Q.js';
-export { StateCompiler } from '../chunk-62OYZT6Q.js';
-export { TraitCompositionCompiler } from '../chunk-UKEK2NZJ.js';
+export { USDPhysicsCompiler } from '../chunk-Z574GVI3.js';
+import { init_SDFCompiler } from '../chunk-YBIHSN55.js';
+export { SDFCompiler } from '../chunk-YBIHSN55.js';
+import { init_StateCompiler } from '../chunk-EKNWUSGW.js';
+export { StateCompiler } from '../chunk-EKNWUSGW.js';
+export { TraitCompositionCompiler } from '../chunk-3MQAOMKD.js';
 import '../chunk-DQRJ5RJG.js';
-export { IncrementalCompiler, createIncrementalCompiler } from '../chunk-VXHB6ZHY.js';
+export { IncrementalCompiler, createIncrementalCompiler } from '../chunk-JTDDLCSP.js';
 import '../chunk-4R6SBXDB.js';
-import { init_AndroidCompiler } from '../chunk-3KHRZTNW.js';
-export { AndroidCompiler } from '../chunk-3KHRZTNW.js';
-import { init_AndroidXRCompiler, init_AndroidXRTraitMap, AndroidXRCompiler, getTraitMapping, ANDROIDXR_TRAIT_MAP } from '../chunk-JCVSCKUH.js';
-export { AndroidXRCompiler } from '../chunk-JCVSCKUH.js';
+import { init_AndroidCompiler } from '../chunk-3AUYBQ5I.js';
+export { AndroidCompiler } from '../chunk-3AUYBQ5I.js';
+import { init_AndroidXRCompiler, init_AndroidXRTraitMap, AndroidXRCompiler, getTraitMapping, ANDROIDXR_TRAIT_MAP } from '../chunk-LJVVOVA6.js';
+export { AndroidXRCompiler } from '../chunk-LJVVOVA6.js';
 import '../chunk-CBSDJF3B.js';
-import { init_IOSCompiler } from '../chunk-73EDVY5D.js';
-export { IOSCompiler } from '../chunk-73EDVY5D.js';
-import { init_VisionOSCompiler, init_VisionOSTraitMap, getTraitMapping as getTraitMapping$1, listAllTraits, generateTraitCode } from '../chunk-VMCR5QVI.js';
-export { VisionOSCompiler } from '../chunk-VMCR5QVI.js';
-import { init_WASMCompiler } from '../chunk-5T6BWIB7.js';
-export { WASMCompiler } from '../chunk-5T6BWIB7.js';
-import { init_WebGPUCompiler, WebGPUCompiler } from '../chunk-QLPRI3QW.js';
-export { WebGPUCompiler } from '../chunk-QLPRI3QW.js';
-import { init_DTDLCompiler } from '../chunk-CHIZSMWD.js';
-export { DTDLCompiler } from '../chunk-CHIZSMWD.js';
-import { init_URDFCompiler } from '../chunk-Q4J2K7FI.js';
-export { URDFCompiler, createURDFCompiler } from '../chunk-Q4J2K7FI.js';
+import { init_IOSCompiler } from '../chunk-7AY66PZP.js';
+export { IOSCompiler } from '../chunk-7AY66PZP.js';
+import { init_VisionOSCompiler, init_VisionOSTraitMap, getTraitMapping as getTraitMapping$1, listAllTraits, generateTraitCode } from '../chunk-ULT2QAV5.js';
+export { VisionOSCompiler } from '../chunk-ULT2QAV5.js';
+import { init_WASMCompiler } from '../chunk-PFZ5WLIP.js';
+export { WASMCompiler } from '../chunk-PFZ5WLIP.js';
+import { init_WebGPUCompiler, WebGPUCompiler } from '../chunk-WQJMSSJT.js';
+export { WebGPUCompiler } from '../chunk-WQJMSSJT.js';
+import { init_DTDLCompiler } from '../chunk-PLK3DLTF.js';
+export { DTDLCompiler } from '../chunk-PLK3DLTF.js';
+import { init_URDFCompiler } from '../chunk-TZM6DKSJ.js';
+export { URDFCompiler, createURDFCompiler } from '../chunk-TZM6DKSJ.js';
 import '../chunk-JBQXZIWB.js';
-import { init_OpenXRCompiler } from '../chunk-R5VKLUMR.js';
-export { OpenXRCompiler } from '../chunk-R5VKLUMR.js';
-import { init_VRChatCompiler } from '../chunk-6FCNMTL5.js';
-export { VRChatCompiler } from '../chunk-6FCNMTL5.js';
-import { init_UnityCompiler } from '../chunk-KYJD2UMV.js';
-export { UnityCompiler } from '../chunk-KYJD2UMV.js';
-import '../chunk-M7XR3F53.js';
+import { init_OpenXRCompiler } from '../chunk-AAUQTR7I.js';
+export { OpenXRCompiler } from '../chunk-AAUQTR7I.js';
+import { init_VRChatCompiler } from '../chunk-7HDRN5BW.js';
+export { VRChatCompiler } from '../chunk-7HDRN5BW.js';
+import { init_UnityCompiler } from '../chunk-ZPHCTPR6.js';
+export { UnityCompiler } from '../chunk-ZPHCTPR6.js';
+import '../chunk-2UP2J3OK.js';
 import { init_PlatformConditionalCompilerMixin } from '../chunk-DJNH4HFW.js';
 export { PlatformConditionalCompilerMixin, createPlatformTarget, filterCompositionForPlatform, matchesPlatformConstraint, normalizePlatformName } from '../chunk-DJNH4HFW.js';
-import { init_GodotCompiler } from '../chunk-RVN7OPCP.js';
-export { GodotCompiler } from '../chunk-RVN7OPCP.js';
-import '../chunk-TZQKJOPC.js';
+import { init_GodotCompiler } from '../chunk-ETIJOUIO.js';
+export { GodotCompiler } from '../chunk-ETIJOUIO.js';
+import '../chunk-TW2AH2ZS.js';
 import { init_PerceptualColorPass } from '../chunk-UCVZXQ63.js';
 export { SCIENTIFIC_COLOR_MAPS, analyzePerceptualColor, applyPerceptualColorPass, buildPerceptualGradient, buildPerceptualPalette, hexToSrgb, normalizeHexColor, srgbToHex } from '../chunk-UCVZXQ63.js';
-import { init_CompilerBase, init_CompilerDocumentationGenerator, CompilerBase } from '../chunk-YDSNDCV3.js';
-export { CompilerBase, CompilerDocumentationGenerator, UnauthorizedCompilerAccessError, createTestCompilerToken, isCapabilityTokenCredential } from '../chunk-YDSNDCV3.js';
+import { init_CompilerBase, init_CompilerDocumentationGenerator, CompilerBase } from '../chunk-QC3CAVFN.js';
+export { CompilerBase, CompilerDocumentationGenerator, UnauthorizedCompilerAccessError, createTestCompilerToken, isCapabilityTokenCredential } from '../chunk-QC3CAVFN.js';
 import { init_traitDocs, getTraitDoc, getAllTraitNames } from '../chunk-IA7FCSRY.js';
 import '../chunk-5CURIYGT.js';
 import '../chunk-33YHE7HX.js';
 import '../chunk-GLEJ2TLS.js';
 import '../chunk-SYTRBGDS.js';
 import '../chunk-UNMVGZVW.js';
-import '../chunk-2EGGAZT3.js';
-import '../chunk-YW3I2FQL.js';
+import '../chunk-QS27OYBU.js';
+import '../chunk-ANMME7XT.js';
 import '../chunk-7I74JWPW.js';
 import '../chunk-2I3XAGMF.js';
 import '../chunk-MD4IVS42.js';
 import { ExpressionEvaluator } from '../chunk-XL6INWKT.js';
-import '../chunk-IK6Z2HNC.js';
+import '../chunk-6OQHLNTT.js';
 import '../chunk-PHENW4MQ.js';
 import '../chunk-ZVFHPMC5.js';
 import { init_safeJsonParse, readJson } from '../chunk-RAN3ECAS.js';
@@ -94,6 +94,80 @@ import { createHash } from 'crypto';
 // src/compiler/index.ts
 init_CompilerBase();
 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
 init_PerceptualColorPass();
 init_UnityCompiler();
 init_GodotCompiler();
@@ -2148,6 +2222,1306 @@ init_HoloMCPCompiler();
 init_AgentInferenceExportTarget();
 init_OmnigentAgentYamlCompiler();
 init_DaimonSeedCompiler();
+
+// src/compiler/HSIIRCompiler.ts
+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:${createHash("sha256").update(hsiStableStringify(value)).digest("hex")}`;
+}
+function hsiSourceTextDigest(source) {
+  return `sha256:${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 = parseExpressionToIR(expr, slotList);
+    } catch (error) {
+      if (error instanceof 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 CompilerBase {
+  constructor(options = {}) {
+    super();
+    this.compilerName = "HSIIRCompiler";
+    this.options = options;
+  }
+  getRequiredCapability() {
+    return 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 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 = 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 = 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
 init_PlatformConditionalCompilerMixin();
 
 // src/compiler/authority/AuthoritySymbolGraph.ts
@@ -3744,7 +5118,7 @@ async function runTier3CpuDirectExecutor(op) {
 }
 async function runTier1BrowserSnn(op) {
   try {
-    const snnWebgpu = await import('../dist-ZBUKU2JG.js');
+    const snnWebgpu = await import('../dist-ZEZXRCBG.js');
     const { GPUContext, LIFSimulator, DEFAULT_LIF_PARAMS } = snnWebgpu;
     const ctx = new GPUContext();
     await ctx.initialize();
@@ -3849,8 +5223,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("");
@@ -4716,6 +6090,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",
@@ -4959,6 +6335,6 @@ var SOVEREIGN_ENGINES = [
   }
 ];
 
-export { AgentTrustLedger, AlphaTracker, AndroidARCorePlugin, AuthoritySymbolGraph, BRIDGE_TARGETS, COLYSEUS_CONSTANT_TIERS, COLYSEUS_EMIT_FILE, COLYSEUS_SCHEMA_FIELD_TIERS, DEFAULT_DISPATCH_LATENCY_OPERATION, DispatchPolicy, DispatchTier, MCPConfigCompiler, MultiLayerCompiler, NATIVE_COMPILE_MODES, NextJSCompiler, ProvenanceBoundsChecker, SOVEREIGN_ENGINES, SOVEREIGN_TARGETS, Vector2DCompiler, WebGPUWGSLPlugin, buildColyseusAuthorityGraph, buildColyseusCrossFileContext, byzantineResilientMerge, createAuthoritySymbolGraph, createDefaultDispatchLatencyScenarios, createProvenanceBoundsChecker, createTier3CpuDirectOutput, detectWasmRuntime, formatDispatchLatencyBenchmarkReport, generateTraitForTarget, getAllManifests, getTraitInfo, isBridgeTarget, isSovereignTarget, listTraitsForTarget, manifestFromPlugin, mergeSocialCausalModels, mostRestrictiveTier, platformPluginRegistry, queryTrait, recommendDispatchPolicyDefaults, runCompilerWasmSnnEmulator, runDispatchPolicyLatencyBenchmark, splitServerAuthority, targetSovereignty, traitExists };
+export { AgentTrustLedger, AlphaTracker, AndroidARCorePlugin, AuthoritySymbolGraph, BRIDGE_TARGETS, COLYSEUS_CONSTANT_TIERS, COLYSEUS_EMIT_FILE, COLYSEUS_SCHEMA_FIELD_TIERS, DEFAULT_DISPATCH_LATENCY_OPERATION, DispatchPolicy, DispatchTier, HSIAdmissionError, HSIIRCompiler, HSI_AUDIT_SCHEMA_VERSION, HSI_IR_SCHEMA_VERSION, HSI_LEARNING_GRAPH_SCHEMA_VERSION, HSI_OBSERVATION_MEDIATOR_EDGE, HSI_TRACE_SCHEMA_VERSION, MCPConfigCompiler, MultiLayerCompiler, NATIVE_COMPILE_MODES, NextJSCompiler, ProvenanceBoundsChecker, SOVEREIGN_ENGINES, SOVEREIGN_TARGETS, Vector2DCompiler, WebGPUWGSLPlugin, applyIntervention, behavioralProjection, buildColyseusAuthorityGraph, buildColyseusCrossFileContext, byzantineResilientMerge, createAuthoritySymbolGraph, createDefaultDispatchLatencyScenarios, createHSIIRCompiler, createProvenanceBoundsChecker, createTier3CpuDirectOutput, detectWasmRuntime, emitSceneIRTsx, formatDispatchLatencyBenchmarkReport, generateAuditCases, generateTraitForTarget, getAllManifests, getTraitInfo, hsiSha256, hsiSourceTextDigest, hsiStableStringify, isBridgeTarget, isSovereignTarget, listTraitsForTarget, lowerCompositionToHSIIR, lowerHoloExpression, manifestFromPlugin, mergeSocialCausalModels, mostRestrictiveTier, platformPluginRegistry, projectLearningGraph, queryTrait, recommendDispatchPolicyDefaults, renameComposition, renameTrace, reorderComposition, runCompilerWasmSnnEmulator, runDispatchPolicyLatencyBenchmark, runExactTrace, runHSIAudit, splitServerAuthority, targetSovereignty, traitExists };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map