@holoscript/core 8.0.13 → 8.0.15

package/dist/compiler/index.js

@@ -1,98 +1,173 @@
-export { ContextCompileError, ContextCompiler, createContextCompiler } from '../chunk-UTUD6GJI.js';
-export { LLMCapabilityCompileError, LLMProviderCapabilitiesCompiler, createLLMProviderCapabilitiesCompiler } from '../chunk-RXQNRZ5F.js';
-export { GLTF_PIPELINE_TOOLS, registerGLTFTools } from '../chunk-EM2OGPYE.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-2BYAUHBO.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-DJ5BNRIS.js';
-export { CodeEditorCompiler, CompileTimeAuthorityEffectError, CompilerBridge, DEFAULT_MATERIAL_KEYWORDS, DEFAULT_OBJECT_KEYWORDS, DEFAULT_PRIMITIVE_SHAPES, DialectRegistry, EdgeCompiler, FMUCompiler, GaussianSplattingCompiler, GaussianTrainCompiler, GaussianTrainConfigError, HOLOSCRIPT_GRAMMAR_PRESETS, HoloMCPCompiler, LlamaServerCompiler, NextJSAPICompiler, NodeServiceCompiler, OmnigentAgentYamlCompiler, PCGGraphCompiler, PCG_GRAPH_SCHEMA, REMOTE_TRAIN_EXECUTOR, REQUIRED_SANDBOX_AUTHORITY_EFFECT, SANDBOX_AUTHORITY_TRAIT, SCMCompiler, SDKCompiler, SHARED_SORT_SHADER_PATH, SOVEREIGN_TRAIN_EXECUTOR, SVGCompiler, 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-DJ5BNRIS.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-QM7FJB5W.js';
+export { SceneIRCompiler } from '../chunk-X727CQ7X.js';
 import '../chunk-2MQKNDNH.js';
-import { init_DaimonSeedCompiler } from '../chunk-QBY7LRN2.js';
-export { DaimonSeedCompiler, computeExportFidelity, createDaimonSeedCompiler, runHysteresisExp2 } from '../chunk-QBY7LRN2.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-UGQ3QNV6.js';
-export { AgentInferenceCompiler, AgentInferenceExportTarget_default as AgentInferenceExportTarget, createAgentInferenceCompiler, createPythonAgentInferenceCompiler } from '../chunk-UGQ3QNV6.js';
-import { vrTraitRegistry } from '../chunk-BQJ3YBF3.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-FG6PYGIZ.js';
-import { init_SDFCompiler } from '../chunk-5FYMCVBY.js';
-export { SDFCompiler } from '../chunk-5FYMCVBY.js';
-import { init_StateCompiler } from '../chunk-KFVNCW4Q.js';
-export { StateCompiler } from '../chunk-KFVNCW4Q.js';
-export { TraitCompositionCompiler } from '../chunk-TSTFYGGX.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-RVNXBF2M.js';
+export { IncrementalCompiler, createIncrementalCompiler } from '../chunk-JTDDLCSP.js';
 import '../chunk-4R6SBXDB.js';
-import { init_AndroidCompiler } from '../chunk-HVX7QQYK.js';
-export { AndroidCompiler } from '../chunk-HVX7QQYK.js';
-import { init_AndroidXRCompiler, init_AndroidXRTraitMap, AndroidXRCompiler, getTraitMapping, ANDROIDXR_TRAIT_MAP } from '../chunk-G6KACNMO.js';
-export { AndroidXRCompiler } from '../chunk-G6KACNMO.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-77QI552M.js';
-export { IOSCompiler } from '../chunk-77QI552M.js';
-import { init_VisionOSCompiler, init_VisionOSTraitMap, getTraitMapping as getTraitMapping$1, listAllTraits, generateTraitCode } from '../chunk-Z557DVYN.js';
-export { VisionOSCompiler } from '../chunk-Z557DVYN.js';
-import { init_WASMCompiler } from '../chunk-PJFTTSKE.js';
-export { WASMCompiler } from '../chunk-PJFTTSKE.js';
-import { init_WebGPUCompiler, WebGPUCompiler } from '../chunk-ONPVM4IV.js';
-export { WebGPUCompiler } from '../chunk-ONPVM4IV.js';
-import { init_DTDLCompiler } from '../chunk-SQXAZHDG.js';
-export { DTDLCompiler } from '../chunk-SQXAZHDG.js';
-import { init_URDFCompiler } from '../chunk-AATYYLYK.js';
-export { URDFCompiler, createURDFCompiler } from '../chunk-AATYYLYK.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-WTH23ISI.js';
-export { OpenXRCompiler } from '../chunk-WTH23ISI.js';
-import { init_VRChatCompiler } from '../chunk-BP4KTMLY.js';
-export { VRChatCompiler } from '../chunk-BP4KTMLY.js';
-import { init_UnityCompiler } from '../chunk-CKV5NYAE.js';
-export { UnityCompiler } from '../chunk-CKV5NYAE.js';
-import '../chunk-WWNCM473.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-JEJ7TT54.js';
-export { GodotCompiler } from '../chunk-JEJ7TT54.js';
-import '../chunk-5LVFTGKH.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-DUG3OQAS.js';
-export { CompilerBase, CompilerDocumentationGenerator, UnauthorizedCompilerAccessError, createTestCompilerToken, isCapabilityTokenCredential } from '../chunk-DUG3OQAS.js';
-import { init_traitDocs, getTraitDoc, getAllTraitNames } from '../chunk-B3CWTCK2.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';
 import '../chunk-W4GABFCR.js';
 import { ANSCapabilityPath } from '@holoscript/core-types/ans';
+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();
@@ -133,7 +208,7 @@ init_CompilerBase();
 // src/compiler/Native2DCompiler.ts
 init_CompilerBase();
 init_safeJsonParse();
-var Native2DCompiler = class extends CompilerBase {
+var _Native2DCompiler = class _Native2DCompiler extends CompilerBase {
   constructor() {
     super(...arguments);
     this.compilerName = "Native2DCompiler";
@@ -146,7 +221,22 @@ var Native2DCompiler = class extends CompilerBase {
     this._stateFields = /* @__PURE__ */ new Map();
     this._fetchCalls = [];
     this._hookCalls = [];
+    this._computedBindings = [];
     this._options = {};
+    /** Honest mode (composition-level `@honest`): every data-bound element MUST carry
+     *  `@provenance_bound` or the compiler refuses to emit it (HONEST-UNSOURCED). This is
+     *  the Receipt-Bound Surface constitution — the surface cannot emit an unsourced pixel. */
+    this._honestMode = false;
+    this._verifiedViewMode = false;
+    /** Valid projection roots: composition state keys + @fetch into-slots (pre-scanned). */
+    this._projectionRoots = /* @__PURE__ */ new Set();
+    /**
+     * Verified projections collected during traversal (@verified_view v1): the machine-readable
+     * view contract that co-emits with the surface — a portable, hash-bound receipt of what
+     * every element renders, so an independent consumer can re-derive it from the ARTIFACT
+     * (not the source). Populated by resolveProjection; emitted as `export const holoViewContract`.
+     */
+    this._collectedProjections = [];
   }
   // @ts-expect-error During migration
   compile(composition, agentToken, outputPath, options) {
@@ -166,13 +256,46 @@ var Native2DCompiler = class extends CompilerBase {
     this._stateFields.clear();
     this._fetchCalls = [];
     this._hookCalls = [];
+    this._computedBindings = [];
     this._options = options || {};
+    this._honestMode = (composition?.traits ?? []).some((t) => t?.name === "honest");
+    this._verifiedViewMode = (composition?.traits ?? []).some((t) => t?.name === "verified_view");
     const safeName = name.replace(/[^a-zA-Z0-9]/g, "");
     if (composition?.state?.properties) {
       for (const prop of composition.state.properties) {
         this._stateFields.set(prop.key, prop.value ?? null);
       }
     }
+    this._projectionRoots = new Set(this._stateFields.keys());
+    this._collectedProjections = [];
+    const scanProjectionRoots = (objs) => {
+      for (const o of objs) {
+        for (const t of o.traits ?? []) {
+          if (t?.name === "fetch") {
+            const into = t.config?.into;
+            this._projectionRoots.add(typeof into === "string" && into ? into : "data");
+          }
+          if (t?.name === "each") {
+            const as = t.config?.as;
+            this._projectionRoots.add(typeof as === "string" && as ? as : "item");
+          }
+          if (t?.name === "computed") {
+            const nm = t.config?.name;
+            if (typeof nm === "string" && nm) this._projectionRoots.add(nm);
+          }
+          if (t?.name === "hook") {
+            const returns = t.config?.returns;
+            if (typeof returns === "string") {
+              for (const r of returns.split(",").map((s) => s.trim())) {
+                if (r) this._projectionRoots.add(r);
+              }
+            }
+          }
+        }
+        if (Array.isArray(o.children)) scanProjectionRoots(o.children);
+      }
+    };
+    scanProjectionRoots(objects);
     const jsx = objects.map((obj) => this.generateReactNode(obj)).join("\n        ");
     const imports = [];
     const reactImports = /* @__PURE__ */ new Set();
@@ -190,6 +313,17 @@ var Native2DCompiler = class extends CompilerBase {
     for (const h of this._hookCalls) {
       imports.push(`import { ${h.name} } from '${h.import}';`);
     }
+    const computedImports = /* @__PURE__ */ new Map();
+    for (const b of this._computedBindings) {
+      if (b.from && b.uses.length) {
+        const set = computedImports.get(b.from) || /* @__PURE__ */ new Set();
+        b.uses.forEach((u) => set.add(u));
+        computedImports.set(b.from, set);
+      }
+    }
+    for (const [from, uses] of computedImports) {
+      imports.push(`import { ${[...uses].join(", ")} } from '${from}';`);
+    }
     const stateHooks = [];
     for (const [key, value] of this._stateFields) {
       const capitalKey = key.charAt(0).toUpperCase() + key.slice(1);
@@ -212,25 +346,36 @@ var Native2DCompiler = class extends CompilerBase {
     const hookBindings = [];
     for (const h of this._hookCalls) {
       const members = h.returns.split(",").map((s) => s.trim()).filter((s) => /^[A-Za-z_$][\w$]*$/.test(s));
+      const call = `${h.name}(${h.args ?? ""})`;
       hookBindings.push(
-        members.length > 0 ? `  const { ${members.join(", ")} } = ${h.name}();` : `  ${h.name}();`
+        members.length > 0 ? `  const { ${members.join(", ")} } = ${call};` : `  ${call};`
       );
     }
+    const computedLines = [];
+    for (const b of this._computedBindings) {
+      computedLines.push(`  const ${b.name} = ${b.expr};`);
+    }
+    const viewContract = this.buildViewContract();
+    const rootAttrs = viewContract ? ` data-holo-view-contract="${viewContract.hash}"` : "";
+    const contractExport = viewContract ? `
+
+export const holoViewContract = ${viewContract.json} as const;` : "";
     return `${imports.join("\n")}
 
 // @generated by HoloScript Native2DCompiler \u2014 DO NOT EDIT
 export function ${safeName}Component() {${hookBindings.length > 0 ? "\n" + hookBindings.join("\n") : ""}
 ${stateHooks.join("\n")}
 ${fetchEffects.join("\n")}
+${computedLines.join("\n")}
 
   return (
-    <div className="holoscript-2d-root w-full h-full">
+    <div className="holoscript-2d-root w-full h-full"${rootAttrs}>
       ${jsx}
     </div>
   );
 }
 
-export default ${safeName}Component;
+export default ${safeName}Component;${contractExport}
 `;
   }
   generateReactNode(obj) {
@@ -272,8 +417,39 @@ export default ${safeName}Component;
       if (/['"`\\]/.test(importPath)) {
         throw new Error(`Native2DCompiler @hook: invalid import path ${JSON.stringify(importPath)}`);
       }
+      let hookArgs = "";
+      if (traits.hook.args != null) {
+        hookArgs = String(traits.hook.args);
+        if (!/^[a-zA-Z0-9_$.,(){}\[\]'"/\s*+\-%<>=?:!&|]+$/.test(hookArgs)) {
+          throw new Error(`Native2DCompiler @hook: unsafe args ${JSON.stringify(hookArgs)}`);
+        }
+      }
       if (!this._hookCalls.some((h) => h.name === hookName)) {
-        this._hookCalls.push({ name: hookName, import: importPath, returns: String(traits.hook.returns || "") });
+        this._hookCalls.push({
+          name: hookName,
+          import: importPath,
+          returns: String(traits.hook.returns || ""),
+          args: hookArgs || void 0
+        });
+      }
+    }
+    if (traits.computed?.name && traits.computed?.expr) {
+      const cname = String(traits.computed.name);
+      const expr = String(traits.computed.expr);
+      if (!/^[A-Za-z_$][\w$]*$/.test(cname)) {
+        throw new Error(`Native2DCompiler @computed: invalid name ${JSON.stringify(cname)}`);
+      }
+      if (!/^[a-zA-Z0-9_$.,()\[\]'"/\s*+\-%<>=?:!&|]+$/.test(expr)) {
+        throw new Error(`Native2DCompiler @computed: unsafe expr ${JSON.stringify(expr)}`);
+      }
+      const from = traits.computed.from ? String(traits.computed.from) : "";
+      if (from && /['"`\\]/.test(from)) {
+        throw new Error(`Native2DCompiler @computed: invalid import path ${JSON.stringify(from)}`);
+      }
+      const usesRaw = traits.computed.uses;
+      const uses = (Array.isArray(usesRaw) ? usesRaw : usesRaw ? [usesRaw] : []).map(String).filter((u) => /^[A-Za-z_$][\w$]*$/.test(u));
+      if (!this._computedBindings.some((b) => b.name === cname)) {
+        this._computedBindings.push({ name: cname, expr, from: from || void 0, uses });
       }
     }
     let tag = traits.theme?.tag || traits.panel?.tag || (typeof obj.type === "string" ? obj.type.toLowerCase() : void 0) || "div";
@@ -307,6 +483,10 @@ export default ${safeName}Component;
     const styles = this.buildStyles(traits);
     const classes = this.buildClasses(traits);
     let props = ``;
+    const prov = this.resolveProvenance(traits, obj);
+    if (prov) props += prov.propsStr;
+    const proj = this.resolveProjection(traits, obj);
+    if (proj) props += proj;
     if (traits.theme?.className) {
       classes.push(traits.theme.className);
     }
@@ -329,10 +509,15 @@ export default ${safeName}Component;
       props += ` style={${JSON.stringify(combinedStyles)}}`;
     }
     if (tierExpr) {
-      const staticPrefix = classes.length > 0 ? `${classes.join(" ")} ` : "";
+      const tierFamilies = this.tierColorFamilies(traits);
+      const cleaned = this.stripColorFamilies(
+        this.resolveColorConflicts(classes.join(" ")),
+        tierFamilies
+      );
+      const staticPrefix = cleaned ? `${cleaned} ` : "";
       props += ` className={\`${staticPrefix}\${${tierExpr}}\`}`;
     } else if (classes.length > 0) {
-      props += ` className="${classes.join(" ")}"`;
+      props += ` className="${this.resolveColorConflicts(classes.join(" "))}"`;
     }
     if (traits.theme?.attributes) {
       try {
@@ -383,7 +568,10 @@ export default ${safeName}Component;
       if (stateVar) {
         const setter = `set${stateVar.charAt(0).toUpperCase()}${stateVar.slice(1)}`;
         const valueExpr = subPath ? `${stateVar}.${subPath}` : stateVar;
-        props += ` value={${valueExpr}} onChange={(e) => ${setter}(e.target.value)}`;
+        const inputType = String(traits.input?.type || "").toLowerCase();
+        const numeric = traits.model.cast === "number" || inputType === "range" || inputType === "number";
+        const getter = numeric ? "Number(e.target.value)" : "e.target.value";
+        props += ` value={${valueExpr}} onChange={(e) => ${setter}(${getter})}`;
       }
     }
     if (traits.image?.src) props += ` src="${traits.image.src}"`;
@@ -392,6 +580,9 @@ export default ${safeName}Component;
     if (traits.input?.placeholder) props += ` placeholder="${traits.input.placeholder}"`;
     if (traits.input?.type) props += ` type="${traits.input.type}"`;
     if (traits.input?.required) props += ` required`;
+    if (traits.input?.min != null) props += ` min="${String(traits.input.min)}"`;
+    if (traits.input?.max != null) props += ` max="${String(traits.input.max)}"`;
+    if (traits.input?.step != null) props += ` step="${String(traits.input.step)}"`;
     if (traits.button?.type) props += ` type="${traits.button.type}"`;
     const childrenMarkup = (obj.children || obj.objects || []).map((child) => this.generateReactNode(child)).join("\n");
     const content = traits.text?.content || traits.button?.content || traits.link?.content || traits.icon?.name;
@@ -401,12 +592,23 @@ export default ${safeName}Component;
     } else if (content) {
       safeContent = `{\`${content.replace(/`/g, "\\`").replace(/\$/g, "\\$")}\`}`;
     }
+    if (prov && safeContent && _Native2DCompiler.PROVENANCE_GLYPH[prov.cls]) {
+      safeContent += `<sup className="holo-prov-mark" title=${JSON.stringify(
+        `provenance: ${prov.cls}`
+      )}>${_Native2DCompiler.PROVENANCE_GLYPH[prov.cls]}</sup>`;
+    }
     const each = this.buildEachIterator(traits);
     const keyProp = each ? ` key={i}` : "";
     let element;
     if (tag === "style") {
       const escapedStyle = (content || "").replace(/`/g, "\\`").replace(/\$/g, "\\$");
       element = `<style${keyProp} dangerouslySetInnerHTML={{ __html: \`${escapedStyle}\` }} />`;
+    } else if (traits.sparkline?.state) {
+      element = this.buildSparklineElement(traits, props, keyProp);
+    } else if (traits.chart?.state) {
+      element = this.buildChartElement(traits, props, keyProp);
+    } else if (traits.live_proof?.claim) {
+      element = this.buildLiveProofElement(traits, keyProp);
     } else if (tag === "img" || tag === "input") {
       element = `<${tag}${props}${keyProp} />`;
     } else {
@@ -913,7 +1115,13 @@ export default ${safeName}Component;
    *     : (snap?.fps ?? 0) >= 30 ? "text-amber-400"
    *     : "text-red-400"
    *
-   * Each tier may specify `gte` (>=), `gt` (>), `lte` (<=), and/or `lt` (<).
+   * Each tier may specify `gte` (>=), `gt` (>), `lte` (<=), and/or `lt` (<) for
+   * numeric thresholds, OR `eq`/`neq` for exact-match categories (e.g. a
+   * security audit outcome: `{ eq: "denied", className: "text-red-400" }`).
+   * `eq`/`neq` accept a string or a number; string operands pass the same
+   * injection guard as `@when eq` and are emitted via JSON.stringify. When any
+   * tier compares strings, the bound value is coerced to `''` (not `0`) so the
+   * cascade stays total before state loads without mis-coercing a string to 0.
    * Conditions on one tier are AND-ed. A tier with no bounds is the
    * unconditional fallback (its className is the trailing `:` branch). If no
    * tier is unconditional, an empty-string fallback is appended so the
@@ -927,8 +1135,11 @@ export default ${safeName}Component;
       String(bind.path || ""),
       "@bind tiers"
     );
-    const valueRef = `(${baseExpr} ?? 0)`;
     const tiers = bind.tiers;
+    const usesStringCompare = tiers.some(
+      (t) => typeof t.eq === "string" || typeof t.neq === "string"
+    );
+    const valueRef = usesStringCompare ? `(${baseExpr} ?? '')` : `(${baseExpr} ?? 0)`;
     const branches = [];
     for (const tier of tiers) {
       const className = typeof tier.className === "string" ? tier.className : "";
@@ -937,6 +1148,16 @@ export default ${safeName}Component;
       if (typeof tier.gt === "number") conditions.push(`${valueRef} > ${tier.gt}`);
       if (typeof tier.lte === "number") conditions.push(`${valueRef} <= ${tier.lte}`);
       if (typeof tier.lt === "number") conditions.push(`${valueRef} < ${tier.lt}`);
+      if (typeof tier.eq === "number") conditions.push(`${valueRef} === ${tier.eq}`);
+      else if (typeof tier.eq === "string")
+        conditions.push(
+          `${valueRef} === ${JSON.stringify(this.assertSafeLiteral(tier.eq, "@bind tier eq"))}`
+        );
+      if (typeof tier.neq === "number") conditions.push(`${valueRef} !== ${tier.neq}`);
+      else if (typeof tier.neq === "string")
+        conditions.push(
+          `${valueRef} !== ${JSON.stringify(this.assertSafeLiteral(tier.neq, "@bind tier neq"))}`
+        );
       branches.push({
         condition: conditions.length > 0 ? conditions.join(" && ") : null,
         className
@@ -959,6 +1180,309 @@ export default ${safeName}Component;
       fallback
     );
   }
+  /**
+   * @sparkline: render a bound numeric array as an inline SVG polyline — the
+   * smallest slice of native data-viz (no axes/legend). The points are computed
+   * at render time from the array, normalized into a fixed viewBox
+   * (`width`×`height`, default 100×30) with `preserveAspectRatio="none"` so the
+   * SVG fills its CSS box. `state`(+optional `path`) is the array; `valueKey`
+   * reads a number out of object items (e.g. items `{sizeKb}` → valueKey
+   * "sizeKb"); `stroke` is a themeable line-color class (default
+   * `stroke-studio-accent`). Container styling (`@theme`/`@layout`) rides in on
+   * `props`. Dependency-free, injection-safe: identifiers are validated and the
+   * points expression uses string concatenation (no inner template literals).
+   */
+  buildSparklineElement(traits, props, keyProp) {
+    const sp = traits.sparkline;
+    const state = this.assertSafeDotPath(String(sp.state), "@sparkline state");
+    const path = sp.path ? String(sp.path) : "";
+    if (path) this.assertSafeDotPath(path, "@sparkline path");
+    const arrayRef = this.buildStatePathExpr(state, path, "@sparkline");
+    const W = Number.isInteger(sp.width) && sp.width > 0 ? sp.width : 100;
+    const H = Number.isInteger(sp.height) && sp.height > 0 ? sp.height : 30;
+    let valueExpr = "d";
+    if (sp.valueKey != null) {
+      const vk = String(sp.valueKey);
+      if (!/^[A-Za-z_$][\w$]*$/.test(vk)) {
+        throw new Error(`Native2DCompiler @sparkline: invalid valueKey ${JSON.stringify(vk)}`);
+      }
+      valueExpr = `d?.${vk}`;
+    }
+    const stroke = typeof sp.stroke === "string" ? this.assertSafeLiteral(sp.stroke, "@sparkline stroke") : "stroke-studio-accent";
+    const strokeWidth = /^[0-9]+(\.[0-9]+)?$/.test(String(sp.strokeWidth ?? "")) ? String(sp.strokeWidth) : "1.5";
+    const points = `((__a) => { const __v = (__a ?? []).map((d) => Number(${valueExpr}) || 0); if (!__v.length) return ''; const __mn = Math.min(...__v), __mx = Math.max(...__v), __r = (__mx - __mn) || 1, __sx = __v.length > 1 ? ${W} / (__v.length - 1) : 0; return __v.map((y, i) => (i * __sx).toFixed(2) + ',' + (${H} - ((y - __mn) / __r) * ${H}).toFixed(2)).join(' '); })(${arrayRef})`;
+    return `<svg${props}${keyProp} data-baseline="min" viewBox="0 0 ${W} ${H}" preserveAspectRatio="none">
+      <polyline fill="none" className="${stroke}" strokeWidth="${strokeWidth}" points={${points}} />
+    </svg>`;
+  }
+  /**
+   * @chart: the fuller native data-viz primitive — a bar / line / area chart with
+   * a baseline axis and (bar) crisp category labels. Unlike @sparkline (fill-the-box,
+   * no axes), @chart uses a fixed-aspect viewBox with margins so `<text>` labels stay
+   * undistorted. Geometry is computed at render time from the bound array; a bar chart
+   * emits one `<rect>` per item, line/area emit a `<polyline>`/`<polygon>` over the
+   * plot region. Injection-safe: `state`/`path`/`valueKey`/`labelKey` are validated
+   * identifiers/dot-paths, `stroke`/`fill` pass the literal guard, and the point math
+   * uses string concatenation (no inner template literals).
+   *
+   * `@chart { kind: "bar"|"line"|"area", state, path?, valueKey?, labelKey?,
+   *           width?, height?, stroke?, fill? }`
+   */
+  buildChartElement(traits, props, keyProp) {
+    const ch = traits.chart;
+    const kind = ch.kind === "line" || ch.kind === "area" ? ch.kind : "bar";
+    const state = this.assertSafeDotPath(String(ch.state), "@chart state");
+    const path = ch.path ? String(ch.path) : "";
+    if (path) this.assertSafeDotPath(path, "@chart path");
+    const arrayRef = this.buildStatePathExpr(state, path, "@chart");
+    let valueExpr = "d";
+    if (ch.valueKey != null) {
+      const vk = String(ch.valueKey);
+      if (!/^[A-Za-z_$][\w$]*$/.test(vk)) {
+        throw new Error(`Native2DCompiler @chart: invalid valueKey ${JSON.stringify(vk)}`);
+      }
+      valueExpr = `d?.${vk}`;
+    }
+    let labelKey = "";
+    if (ch.labelKey != null) {
+      labelKey = String(ch.labelKey);
+      if (!/^[A-Za-z_$][\w$]*$/.test(labelKey)) {
+        throw new Error(`Native2DCompiler @chart: invalid labelKey ${JSON.stringify(labelKey)}`);
+      }
+    }
+    let classKey = "";
+    if (ch.classKey != null) {
+      classKey = String(ch.classKey);
+      if (!/^[A-Za-z_$][\w$]*$/.test(classKey)) {
+        throw new Error(`Native2DCompiler @chart: invalid classKey ${JSON.stringify(classKey)}`);
+      }
+    }
+    const W = Number.isInteger(ch.width) && ch.width > 0 ? ch.width : 280;
+    const H = Number.isInteger(ch.height) && ch.height > 0 ? ch.height : 140;
+    const stroke = typeof ch.stroke === "string" ? this.assertSafeLiteral(ch.stroke, "@chart stroke") : "stroke-studio-accent";
+    const fill = typeof ch.fill === "string" ? this.assertSafeLiteral(ch.fill, "@chart fill") : "fill-studio-accent";
+    const PX = 6;
+    const PT = 8;
+    const PB = labelKey && kind === "bar" ? 16 : 6;
+    const plotW = W - 2 * PX;
+    const plotH = H - PT - PB;
+    const baselineY = H - PB;
+    const baseline = `<line x1="${PX}" y1="${baselineY}" x2="${W - PX}" y2="${baselineY}" className="stroke-studio-border" strokeWidth="0.5" />`;
+    const provDefs = classKey ? `<defs><pattern id="holo-hatch" width="4" height="4" patternUnits="userSpaceOnUse" patternTransform="rotate(45)"><line x1="0" y1="0" x2="0" y2="4" className="stroke-studio-accent" strokeWidth="1.2" /></pattern><pattern id="holo-dots" width="3" height="3" patternUnits="userSpaceOnUse"><circle cx="1.5" cy="1.5" r="0.6" className="fill-studio-accent" /></pattern></defs>` : "";
+    let body;
+    if (kind === "bar") {
+      const label = labelKey ? `<text x={__x + __bw / 2} y={${H - 4}} textAnchor="middle" className="fill-studio-muted" fontSize="6">{String(d?.${labelKey} ?? '')}</text>` : "";
+      const provFill = classKey ? ` fill={d?.${classKey} === "inferred" ? "url(#holo-hatch)" : d?.${classKey} === "generative" ? "url(#holo-dots)" : undefined} data-provenance-class={String(d?.${classKey} ?? "")}` : "";
+      body = `{((__a) => { const __d = (__a ?? []); const __v = __d.map((d) => Number(${valueExpr}) || 0); const __max = Math.max(1, ...__v); const __n = __d.length || 1; const __slot = ${plotW} / __n; const __bw = Math.max(1, Math.min(__slot * 0.62, __slot - 1)); return __d.map((d, i) => { const __h = Math.max(0, Number(${valueExpr}) || 0) / __max * ${plotH}; const __x = ${PX} + i * __slot + (__slot - __bw) / 2; const __y = ${baselineY} - __h; return (<g key={i}><rect x={__x} y={__y} width={__bw} height={__h} className="${fill}"${provFill} rx="0.5" />${label}</g>); }); })(${arrayRef})}`;
+    } else {
+      const norm = this._honestMode ? `const __mn = 0, __r = Math.max(1, ...__v), ` : `const __mn = Math.min(...__v), __mx = Math.max(...__v), __r = (__mx - __mn) || 1, `;
+      const yExpr = this._honestMode ? "Math.max(0, y)" : "y";
+      const pts = `((__a) => { const __v = (__a ?? []).map((d) => Number(${valueExpr}) || 0); if (!__v.length) return ''; ` + norm + `__sx = __v.length > 1 ? ${plotW} / (__v.length - 1) : 0; return __v.map((y, i) => (${PX} + i * __sx).toFixed(2) + ',' + (${baselineY} - ((${yExpr} - __mn) / __r) * ${plotH}).toFixed(2)).join(' '); })(${arrayRef})`;
+      const line = `<polyline fill="none" className="${stroke}" strokeWidth="1.5" points={${pts}} />`;
+      if (kind === "area") {
+        const areaPts = `((__p) => __p ? __p + ' ' + ${W - PX} + ',' + ${baselineY} + ' ' + ${PX} + ',' + ${baselineY} : '')(${pts})`;
+        body = `<polygon className="${fill}" fillOpacity="0.25" points={${areaPts}} />
+      ${line}`;
+      } else {
+        body = line;
+      }
+    }
+    const baselineAttr = ` data-baseline="${kind === "bar" || this._honestMode ? "zero" : "min"}"`;
+    const clampedAttr = kind === "bar" || this._honestMode ? ` data-clamped={String(((__a) => (__a ?? []).some((d) => (Number(${valueExpr}) || 0) < 0))(${arrayRef}))}` : "";
+    return `<svg${props}${keyProp}${baselineAttr}${clampedAttr} viewBox="0 0 ${W} ${H}">
+      ${provDefs}
+      ${baseline}
+      ${body}
+    </svg>`;
+  }
+  /**
+   * Receipt-Bound Surface enforcement + emission (@honest / @provenance_bound).
+   *
+   * A "data-bound" element (one that renders a value from state via @bind/@chart/
+   * @sparkline/@model) must, in honest mode, carry `@provenance_bound {source, class}`
+   * — otherwise the compiler THROWS (HONEST-UNSOURCED): the surface cannot emit an
+   * unsourced pixel. When provenance IS present, this returns the inline receipt
+   * attributes (`data-holo-provenance` = a machine-readable {source,class,confidence}
+   * an independent consumer can re-derive against, `data-provenance-class`) plus the
+   * class so the caller can add a visible honesty glyph to text values. An unknown
+   * class is rejected (fail toward lower trust — never silently upgraded to measured).
+   * Returns null when the element is not provenance-bound (no attributes, no glyph).
+   */
+  /**
+   * @verified_view / @projects — the admission gate for agent-authored
+   * surfaces (slice 4 of the Receipt-Bound Surface, honest v0).
+   *
+   * `@projects { node: "stats.sessions" }` is the AUTHOR'S CLAIM of which
+   * world-model node an element renders. This compiler owns the actual data
+   * path (@bind/@chart/@sparkline/@model → state[.path]), so the claim is
+   * verified as compiler-owned DATA-FLOW — the two sides are independently
+   * authored, which is exactly what the shallow "source is non-empty" version
+   * (rejected as theater in the slice-4 warning) lacks. Checks, all fatal
+   * (VIEW-UNGROUNDED):
+   *   1. a declared projection must MATCH the element's actual bound path —
+   *      "the agent says sessions but wired revenue" fails to compile;
+   *   2. a projection must root in a REAL node (composition state or a @fetch
+   *      into-slot) — a hallucinated node fails to compile;
+   *   3. a projection on an element with NO data binding is a lie by
+   *      construction — fails to compile;
+   *   4. under composition-level `@verified_view`, every data-bound element
+   *      MUST declare a projection (mirrors HONEST-UNSOURCED).
+   * Checks 1–3 are always-on (a lying receipt is worse than none); check 4 is
+   * the mode. Verified elements emit `data-holo-projects` so independent
+   * consumers can re-check the claim against the artifact. HONEST SCOPE:
+   * runtime re-derivation against a live graph.holo world model (the full
+   * research-spec `projects:` semantics + SimulationContract co-emission) is
+   * v1+ — this v0 proves what the compiler can prove, statically.
+   */
+  resolveProjection(traits, obj) {
+    const nm = () => String(obj.name ?? "element");
+    const src = traits.bind?.state ? { state: traits.bind.state, path: traits.bind.path } : traits.chart?.state ? { state: traits.chart.state, path: traits.chart.path } : traits.sparkline?.state ? { state: traits.sparkline.state, path: traits.sparkline.path } : traits.model?.state ? { state: traits.model.state, path: traits.model.path } : (
+      // @each renders a LIST from state — the element's provenance is the bound array.
+      traits.each?.state ? { state: traits.each.state, path: traits.each.path } : null
+    );
+    const actualPath = src ? `${String(src.state)}${src.path ? "." + String(src.path) : ""}` : null;
+    const pj = traits.projects;
+    if (!pj) {
+      if (this._verifiedViewMode && actualPath) {
+        throw new Error(
+          `Native2DCompiler @verified_view: VIEW-UNGROUNDED \u2014 "${nm()}" renders data without @projects {node}; an agent-authored surface ships only if every element declares what it renders`
+        );
+      }
+      return null;
+    }
+    const node = this.assertSafeDotPath(String(pj.node ?? ""), "@projects node");
+    if (!actualPath) {
+      throw new Error(
+        `Native2DCompiler @projects: VIEW-UNGROUNDED \u2014 "${nm()}" claims to project "${node}" but has no data binding at all; the claim is a lie by construction`
+      );
+    }
+    if (node !== actualPath) {
+      throw new Error(
+        `Native2DCompiler @projects: VIEW-UNGROUNDED \u2014 "${nm()}" claims to project "${node}" but is actually bound to "${actualPath}"; the surface would lie about its source`
+      );
+    }
+    const root = node.split(".")[0];
+    if (!this._projectionRoots.has(root)) {
+      throw new Error(
+        `Native2DCompiler @projects: VIEW-UNGROUNDED \u2014 "${nm()}" projects "${node}" but no state node "${root}" exists (hallucinated node; declared state keys and @fetch slots: ${[...this._projectionRoots].join(", ") || "none"})`
+      );
+    }
+    const b = traits.bind;
+    const identity = !!b?.state && b.precision === void 0 && b.prefix === void 0 && b.suffix === void 0 && !b.tiers && !traits.chart && !traits.sparkline && !traits.each && !traits.model;
+    let transform;
+    if (b?.state && !traits.chart && !traits.sparkline && !traits.each && !traits.model && (b.precision !== void 0 || b.prefix !== void 0 || b.suffix !== void 0)) {
+      transform = {};
+      if (typeof b.precision === "number") transform.precision = b.precision;
+      if (b.prefix !== void 0) transform.prefix = String(b.prefix);
+      if (b.suffix !== void 0) transform.suffix = String(b.suffix);
+    }
+    let entity;
+    if (pj.entity !== void 0) {
+      const e = String(pj.entity);
+      if (!/^[A-Za-z0-9_.:-]+$/.test(e)) {
+        throw new Error(
+          `Native2DCompiler @projects: invalid entity id ${JSON.stringify(e)} on "${nm()}" (allowed: alphanumerics and . : _ -)`
+        );
+      }
+      entity = e;
+    }
+    this._collectedProjections.push({
+      element: nm(),
+      node,
+      ...entity ? { entity } : {},
+      identity,
+      ...transform ? { transform } : {}
+    });
+    return ` data-holo-projects="${node}"`;
+  }
+  /**
+   * @verified_view v1 — build the co-emitted view contract: a portable, sha256-bound JSON
+   * receipt of every verified projection plus the valid state roots. The contract travels
+   * WITH the compiled artifact (`export const holoViewContract` + a `data-holo-view-contract`
+   * hash on the root), so an independent consumer re-derives the projection set from the
+   * emitted `data-holo-projects` attributes and checks it against this contract — the two
+   * emission paths cannot silently drift, and the surface's honesty becomes one verifiable
+   * receipt instead of N scattered attributes (W.772). Returns null outside @verified_view
+   * mode (un-gated surfaces carry no contract). Canonical: projections sorted by
+   * (element, node) and roots sorted, so the hash is stable across traversal order.
+   *
+   * NOTE (v1 scope): this makes the projection contract portable and independently
+   * re-checkable from the ARTIFACT — the foundation for runtime re-derivation. Verifying the
+   * bound value against a LIVE graph.holo world model at runtime is the deeper v1 still to be
+   * designed.
+   */
+  buildViewContract() {
+    if (!this._verifiedViewMode) return null;
+    const projections = [...this._collectedProjections].sort(
+      (a, b) => a.element === b.element ? a.node.localeCompare(b.node) : a.element.localeCompare(b.element)
+    );
+    const stateRoots = [...this._projectionRoots].sort();
+    const body = { version: _Native2DCompiler.VIEW_CONTRACT_VERSION, projections, stateRoots };
+    const hash = createHash("sha256").update(JSON.stringify(body)).digest("hex");
+    return { json: JSON.stringify({ ...body, contractHash: hash }), hash };
+  }
+  resolveProvenance(traits, obj) {
+    const dataBound = !!(traits.bind?.state || traits.chart?.state && !traits.chart?.classKey || traits.sparkline?.state || traits.model);
+    const pb = traits.provenance_bound;
+    if (this._honestMode && dataBound && !pb) {
+      const nm = String(obj.name ?? "element");
+      throw new Error(
+        `Native2DCompiler @honest: HONEST-UNSOURCED \u2014 "${nm}" renders data without @provenance_bound {source, class}; the surface cannot emit an unsourced pixel`
+      );
+    }
+    if (!pb) return null;
+    const cls = String(pb.class ?? "");
+    if (!_Native2DCompiler.PROVENANCE_CLASSES.has(cls)) {
+      throw new Error(
+        `Native2DCompiler @provenance_bound: invalid class ${JSON.stringify(cls)} \u2014 expected measured|derived|inferred|generative (unknown classes fail toward lower trust, never default to measured)`
+      );
+    }
+    const source = this.assertSafeLiteral(String(pb.source ?? ""), "@provenance_bound source");
+    const receipt = { source, class: cls };
+    if (pb.confidence != null) {
+      const c = Number(pb.confidence);
+      if (Number.isFinite(c) && c >= 0 && c <= 1) receipt.confidence = c;
+    }
+    const propsStr = ` data-holo-provenance='${JSON.stringify(receipt)}' data-provenance-class="${cls}"`;
+    return { propsStr, cls };
+  }
+  /**
+   * @live_proof: the falsifiable surface — the receipt is load-bearing RENDER STATE.
+   *
+   * `@live_proof { claim, label? }` declares a boolean claim over state (a theorem the
+   * element asserts). It compiles to a self-styled verdict badge whose colour + text
+   * FLIP live as the claim breaks: `✓ <label> holds` (green) vs `✗ <label> FALSIFIED`
+   * (red). Because the claim re-evaluates on every render, dragging a bound parameter
+   * (via a sibling @model slider) past the point where the theorem fails flips the
+   * badge in-band — FALSIFIED is a render state, not a console log.
+   *
+   * DISCIPLINE (W.767/W.769): the claim must re-derive from INDEPENDENT state fields
+   * (e.g. `capacity >= load * factor`), never re-read the displayed value — a
+   * self-referential claim proves nothing. The compiler cannot enforce independence,
+   * but the emitted `data-proof-claim` makes the predicate auditable. The claim is
+   * injection-safe (same char-class as @computed; no backticks/semicolons).
+   *
+   * HONESTY LABEL (@verified_view v1 groundwork): the emitted `data-proof-state` re-runs the
+   * SAME `cond` the badge renders from, so today it proves DISPLAY-FAITHFULNESS (the badge
+   * matches its own formula), NOT independently-verified TRUTH of the claim. We refuse to let
+   * that masquerade — `data-proof-independence="self-referential"` marks it so no consumer (or
+   * the moat's own claims) mistakes it for a real proof. A v1 runtime verifier that re-derives
+   * the claim's inputs through a path the render did not author (an external state store or a
+   * solver/StateAuthority oracle) flips this to `"verified"`. Until that oracle exists, honest
+   * labeling is the only non-theatre option (see research/2026-07-10_verified-view-v1-design.md).
+   */
+  buildLiveProofElement(traits, keyProp) {
+    const lp = traits.live_proof;
+    const claim = String(lp.claim ?? "");
+    if (!claim.trim() || !/^[a-zA-Z0-9_$.,()\[\]'"/\s*+\-%<>=?:!&|]+$/.test(claim)) {
+      throw new Error(`Native2DCompiler @live_proof: unsafe or empty claim ${JSON.stringify(claim)}`);
+    }
+    const label = lp.label != null ? this.assertSafeLiteral(String(lp.label), "@live_proof label") : "Claim";
+    const cond = `(${claim})`;
+    return `<div${keyProp} data-proof-claim={${JSON.stringify(claim)}} data-proof-independence="self-referential" data-proof-state={${cond} ? "pass" : "falsified"} className={\`rounded-md p-2 text-xs font-semibold \${${cond} ? "bg-studio-success/10 text-studio-success" : "bg-studio-error/10 text-studio-error"}\`}>
+      {${cond} ? "\u2713 ${label} holds" : "\u2717 ${label} FALSIFIED"}
+    </div>`;
+  }
   buildHTMLBindAttributes(traits, staticClassName) {
     const bind = traits.bind;
     if (!bind?.state) return "";
@@ -1214,6 +1738,78 @@ export default ${safeName}Component;
     }
     return styles;
   }
+  /**
+   * Resolve conflicting Tailwind COLOR utilities in a STATIC class string, keeping the LAST
+   * of each color family. A node's @theme className is appended AFTER the variant defaults
+   * (buildClasses), so this lets an authored token color win over a hardcoded default color
+   * (e.g. @theme `text-studio-muted` overrides the caption default `text-gray-500`) — which
+   * class actually wins otherwise depends on Tailwind's CSS emission order, not the class
+   * attribute, so the default's raw color leaks unpredictably. Only color families are deduped
+   * (text/bg/border/ring/…, incl. variant prefixes like hover:/focus:); sizes, spacing, and
+   * layout are untouched, and text-<size> / border-<width> / ring-<width> are never colors.
+   */
+  /**
+   * The Tailwind COLOR family a token belongs to (incl. variant prefixes like
+   * hover:/focus:), or null for a non-color token. Shared by conflict-resolution
+   * and tier-family stripping. text-<size> / text-<align> / border|ring|divide-<width>
+   * and arbitrary values ([10px], [#fff]) are NOT colors.
+   */
+  colorFamilyKey(t) {
+    const m = t.match(
+      /^((?:[a-z-]+:)*)(text|bg|border|ring|ring-offset|divide|accent|fill|stroke|placeholder|caret|decoration|from|to|via)-(.+)$/
+    );
+    if (!m) return null;
+    const [, variant, prop, rest] = m;
+    if (rest.startsWith("[")) return null;
+    if (prop === "text") {
+      if (_Native2DCompiler.TEXT_SIZE_TOKENS.has(`text-${rest}`)) return null;
+      if (["left", "center", "right", "justify", "start", "end"].includes(rest)) return null;
+    }
+    if (prop === "border" || prop === "divide") {
+      if (/^([xytrbles]|\d+|[xytrbles]-\d+)$/.test(rest)) return null;
+    }
+    if (prop === "ring" && /^(\d+|inset)$/.test(rest)) return null;
+    return `${variant}${prop}`;
+  }
+  resolveColorConflicts(classStr) {
+    const tokens = classStr.split(/\s+/).filter(Boolean);
+    const lastIndex = /* @__PURE__ */ new Map();
+    tokens.forEach((t, i) => {
+      const k = this.colorFamilyKey(t);
+      if (k) lastIndex.set(k, i);
+    });
+    return tokens.filter((t, i) => {
+      const k = this.colorFamilyKey(t);
+      return k === null || lastIndex.get(k) === i;
+    }).join(" ");
+  }
+  /**
+   * The set of color families a @bind's tier classNames assign — so the caller
+   * can strip those families from the static prefix (the dynamic tier cascade
+   * owns them, and the static default would otherwise leak a raw color).
+   */
+  tierColorFamilies(traits) {
+    const families = /* @__PURE__ */ new Set();
+    const tiers = traits?.bind?.tiers;
+    if (!Array.isArray(tiers)) return families;
+    for (const tier of tiers) {
+      const cn = typeof tier?.className === "string" ? tier.className : "";
+      for (const tok of cn.split(/\s+/).filter(Boolean)) {
+        const k = this.colorFamilyKey(tok);
+        if (k) families.add(k);
+      }
+    }
+    return families;
+  }
+  /** Drop every token whose color family is in `families` (removes a static
+   *  default color that a dynamic @bind tier cascade will always override). */
+  stripColorFamilies(classStr, families) {
+    if (families.size === 0) return classStr;
+    return classStr.split(/\s+/).filter(Boolean).filter((t) => {
+      const k = this.colorFamilyKey(t);
+      return k === null || !families.has(k);
+    }).join(" ");
+  }
   buildClasses(traits) {
     const classes = [];
     if (traits.text) {
@@ -1256,6 +1852,48 @@ export default ${safeName}Component;
     return str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
   }
 };
+/** Version tag for the co-emitted `holoViewContract` (@verified_view v1). */
+_Native2DCompiler.VIEW_CONTRACT_VERSION = "holo-view-contract-v1";
+/**
+ * 2D data-value provenance vocabulary, ordered by TRUST (highest → lowest),
+ * aligned to the shipped 3D PointProvenanceClass idiom (observed | interpolated |
+ * nlos-inferred | generative-extended). An UNKNOWN class is REJECTED, never
+ * silently upgraded to `measured` — provenance fails toward lower trust, so a
+ * typo can never make an inferred value read as sensor-attested.
+ */
+_Native2DCompiler.PROVENANCE_CLASSES = /* @__PURE__ */ new Set([
+  "measured",
+  // source-attested: a real sensor reading, DB value, on-chain fact
+  "derived",
+  // computed from measured values by a transparent bounded function
+  "inferred",
+  // model/heuristic estimate (a forecast) — honest that it is a guess
+  "generative"
+  // produced by a generative model (LLM-authored value)
+]);
+/** Visible honesty glyph appended to a non-`measured` text value (measured = trusted, no marker). */
+_Native2DCompiler.PROVENANCE_GLYPH = {
+  measured: "",
+  derived: "\xB0",
+  inferred: "~",
+  generative: "\u2726"
+};
+_Native2DCompiler.TEXT_SIZE_TOKENS = /* @__PURE__ */ new Set([
+  "text-xs",
+  "text-sm",
+  "text-base",
+  "text-lg",
+  "text-xl",
+  "text-2xl",
+  "text-3xl",
+  "text-4xl",
+  "text-5xl",
+  "text-6xl",
+  "text-7xl",
+  "text-8xl",
+  "text-9xl"
+]);
+var Native2DCompiler = _Native2DCompiler;
 
 // src/compiler/NextJSCompiler.ts
 function findTrait(composition, traitName2) {
@@ -1584,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
@@ -3180,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();
@@ -3285,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 } = await import('crypto');
-  return createHash("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("");
@@ -4099,6 +6037,18 @@ platformPluginRegistry.register(new AndroidARCorePlugin());
 var SOVEREIGN_TARGETS = [
   "webgpu",
   // WebGPUCompiler → WGSL compute+render shaders on our own WebGPU device (WebGPURenderer)
+  "audio",
+  // SpatialAudioCompiler → our own Web Audio graph (HRTF PannerNode + Convolver reverb + filters); no third-party audio engine
+  "desktop-gpu",
+  // DesktopGPUCompiler → standalone Rust wgpu project (Vulkan/Metal/DX12), renders the scene offscreen on the machine's own GPU; no browser, no third-party engine. Verified on Jetson Orin/Vulkan.
+  "pathtrace",
+  // PathTracerCompiler → standalone Rust wgpu COMPUTE path tracer (cosine-weighted GI, emissive area lights, multi-sample) → tonemapped PNG; our own tracer, no Cycles/OptiX. Verified on Jetson Orin/Vulkan.
+  "pathtrace-cpu",
+  // CpuPathTracer → the no-GPU fallback: pure-TS CPU path tracer (same algorithm + shared scene extraction) → PNG. Runs offline GI anywhere Node/JS runs (server/CI/old device). The "runs anywhere / no-WebGPU compute fallback" gap.
+  "media",
+  // MediaPipelineCompiler → renders an animated turntable of the scene (CPU) and encodes it to an APNG with our OWN encoder (node:zlib only, no ffmpeg/codec/muxer). The video/media-pipeline gap; a moving picture from a .holo.
+  "physics-sim",
+  // ComputePhysicsCompiler → WGSL COMPUTE rigid-body solver (gravity + sphere/sphere + sphere/AABB collisions, restitution, double-buffered) that steps on the GPU + renders the settled state. Our own solver, no third-party physics engine. Consumes the collider vocabulary; the DYNAMICS layer on top of PhysicsColliderCompiler. Verified on Jetson Orin/Vulkan.
   "character-webgpu",
   // CharacterWebGPUCompiler → authored .holo character → CharacterDrawSpec run by our renderCharacter (sovereign skinned-character path)
   "nir",
@@ -4140,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",
@@ -4320,9 +6272,69 @@ var SOVEREIGN_ENGINES = [
     tests: true,
     promoted: false,
     note: "Signed-distance-field \u2192 raymarch WGSL/GLSL. Native GPU renderer codegen."
+  },
+  {
+    id: "spatial-audio",
+    name: "SpatialAudioCompiler",
+    file: "packages/core/src/compiler/SpatialAudioCompiler.ts",
+    kind: "compiler",
+    maturity: "real",
+    tests: true,
+    promoted: false,
+    note: "The audio peer of WebGPU: emits our OWN Web Audio graph (HRTF PannerNode + Convolver reverb from synthesized rt60 impulses + directivity/occlusion/portal filters) from @audio_source/@audio_listener/@reverb_zone/@audio_material/@audio_occlusion/@audio_portal traits. Sovereign \u2014 no FMOD/Wwise/Resonance. Fills the #1 spatial-computing gap (no audio compiler existed)."
+  },
+  {
+    id: "desktop-gpu",
+    name: "DesktopGPUCompiler",
+    file: "packages/core/src/compiler/DesktopGPUCompiler.ts",
+    kind: "compiler",
+    maturity: "real",
+    tests: true,
+    promoted: false,
+    note: `Sovereign native-desktop GPU: emits a self-contained Rust wgpu project (Vulkan/Metal/DX12) that renders the scene offscreen to a PNG on the machine's OWN GPU \u2014 standalone, no browser, no third-party engine. WebGPU is browser/runtime-bound; this is the "runs standalone at native perf" gap. Matrices computed in the compiler; geometry generators + wgpu host emitted. VERIFIED on real hardware: Jetson Orin (Tegra) via Vulkan rendered a 6-object scene offscreen to PNG (adapter=NVIDIA Tegra Orin, backend=Vulkan). Consumes the same geometry-registry + geometry-purpose vocabulary as render/physics/audio.`
+  },
+  {
+    id: "path-tracer",
+    name: "PathTracerCompiler",
+    file: "packages/core/src/compiler/PathTracerCompiler.ts",
+    kind: "compiler",
+    maturity: "real",
+    tests: true,
+    promoted: false,
+    note: "Sovereign OFFLINE path-traced render \u2014 the film-grade-still gap the rasterizers (WebGPU/desktop-gpu) do not fill. Emits a self-contained Rust wgpu COMPUTE program: our OWN GPU path tracer (no Cycles/OptiX) that traces cosine-weighted diffuse bounces against analytic sphere/box primitives, accumulates many samples, and tonemaps to PNG. Global illumination \u2014 soft shadows, colour bleeding, emissive area lights. VERIFIED on Jetson Orin (Tegra/Vulkan): a Cornell-box scene rendered with visible GI colour-bleed + soft shadows. Fifth consumer of the shared geometry-registry + geometry-purpose vocabulary."
+  },
+  {
+    id: "cpu-path-tracer",
+    name: "CpuPathTracer",
+    file: "packages/core/src/compiler/CpuPathTracer.ts",
+    kind: "runtime",
+    maturity: "real",
+    tests: true,
+    promoted: false,
+    note: 'The sovereign no-GPU FALLBACK: a pure-TypeScript CPU path tracer that RUNS (not emits) the same GI algorithm as PathTracerCompiler, sharing extractRaytraceScene so the two render the same scene. Renders offline global-illumination stills anywhere Node/JS runs \u2014 server, CI, old device, no WebGPU/GPU needed. Ships its own PNG encoder (node:zlib), zero deps. Fills the "runs anywhere / no-WebGPU compute fallback" gap the audit named (compiler-wasm is a parser, not a compute backend).'
+  },
+  {
+    id: "media-pipeline",
+    name: "MediaPipelineCompiler",
+    file: "packages/core/src/compiler/MediaPipelineCompiler.ts",
+    kind: "runtime",
+    maturity: "real",
+    tests: true,
+    promoted: false,
+    note: "The sovereign VIDEO / media-pipeline: renders an animated turntable of the scene (orbiting camera, fast CPU flat projector over the shared raytrace-scene extraction) and encodes the frame sequence to an APNG with our OWN encoder (acTL/fcTL/fdAT via node:zlib) \u2014 no ffmpeg / codec / muxer dependency. A moving picture from a .holo, runs anywhere Node runs. Fills the media-pipeline gap the audit named; browser-native WebCodecs H.264/WebM is the follow-on encode path."
+  },
+  {
+    id: "compute-physics",
+    name: "ComputePhysicsCompiler",
+    file: "packages/core/src/compiler/ComputePhysicsCompiler.ts",
+    kind: "compiler",
+    maturity: "real",
+    tests: true,
+    promoted: false,
+    note: "The sovereign GPU rigid-body SIMULATION \u2014 the dynamics layer PhysicsColliderCompiler was missing. Emits a Rust wgpu program with a WGSL COMPUTE solver: gravity + sphere/sphere + sphere/static-AABB collisions with restitution + friction, double-buffered (gather, race-free), stepped N times on the GPU; then renders the settled state to PNG. Our own solver, no third-party physics engine. One .holo drives BOTH render and sim (Grok + Claude converged design). Dynamic bodies = @rigid_body spheres; statics = scene boxes. VERIFIED on Jetson Orin (Tegra/Vulkan): spheres dropped above a floor fall, collide and settle. Hooks the physics-discovery / provenance goals."
   }
 ];
 
-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