@holoscript/core 8.0.12 → 8.0.14

package/dist/compiler/index.js

@@ -1,25 +1,25 @@
-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-42Z3SVHQ.js';
+export { LLMCapabilityCompileError, LLMProviderCapabilitiesCompiler, createLLMProviderCapabilitiesCompiler } from '../chunk-LGRKBTPM.js';
+export { GLTF_PIPELINE_TOOLS, registerGLTFTools } from '../chunk-2GKF7JQ6.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-TYNRXRHF.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-TYNRXRHF.js';
+export { QuantumCircuitCompiler } from '../chunk-GI5YYZH6.js';
+import { init_NextJSAPICompiler, init_DialectRegistry, DialectRegistry, init_HoloMCPCompiler, init_OmnigentAgentYamlCompiler, init_NodeServiceCompiler, init_SDKCompiler, init_LlamaServerCompiler, init_holoscript_gbnf, init_registerBuiltinDialects, init_PCGGraphCompiler } from '../chunk-EYHPTJ3F.js';
+export { CodeEditorCompiler, CompileTimeAuthorityEffectError, CompilerBridge, ComputePhysicsCompiler, CpuPathTracer, DEFAULT_MATERIAL_KEYWORDS, DEFAULT_OBJECT_KEYWORDS, DEFAULT_PRIMITIVE_SHAPES, DesktopGPUCompiler, DialectRegistry, EdgeCompiler, FMUCompiler, GaussianSplattingCompiler, GaussianTrainCompiler, GaussianTrainConfigError, HOLOSCRIPT_GRAMMAR_PRESETS, HoloMCPCompiler, LlamaServerCompiler, MediaPipelineCompiler, NextJSAPICompiler, NodeServiceCompiler, OmnigentAgentYamlCompiler, PCGGraphCompiler, PCG_GRAPH_SCHEMA, PathTracerCompiler, PhysicsColliderCompiler, REMOTE_TRAIN_EXECUTOR, REQUIRED_SANDBOX_AUTHORITY_EFFECT, SANDBOX_AUTHORITY_TRAIT, SCMCompiler, SDKCompiler, SHARED_SORT_SHADER_PATH, SOVEREIGN_TRAIN_EXECUTOR, SVGCompiler, SpatialAudioCompiler, SpatialPartitionPass, ThreeDTilesCompiler, USDZPipeline, absorbFMU, assertAuthorityEffects, bestCategoryForTraits, checkAuthorityEffects, collectAuthorityEffectNodes, compileAllToNextJSAPI, compilePCGGraphFromBlocks, compilePipelineSource, compilePipelineSourceToNode, compilePipelineSourceToPython, compilePipelineToNode, compilePipelineToPython, compileTo3DTiles, compileToFMU, compileToNextJSAPI, compileToPCGGraph, createGaussianSplattingCompiler, createGaussianTrainCompiler, createOmnigentAgentYamlCompiler, createThreeDTilesCompiler, detectMultiUserSharedSort, ensureDialectsBooted, generateHoloScriptGbnf, isHoloScriptGrammarPreset, pcgGraphToUnrealXml, quickSafetyCheck, registerBuiltinDialects, runSafetyPass, selectModality, selectModalityForAll, spatialPartition, streamWorldTiles } from '../chunk-EYHPTJ3F.js';
 export { generateHullGeometry, generateMembraneGeometry, generateSplineGeometry } from '../chunk-UDE4OZMR.js';
 import '../chunk-3F7ZZWIN.js';
-export { SceneIRCompiler } from '../chunk-QM7FJB5W.js';
+export { SceneIRCompiler } from '../chunk-PSWCJQS4.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-4NEPHK2K.js';
+export { DaimonSeedCompiler, computeExportFidelity, createDaimonSeedCompiler, runHysteresisExp2 } from '../chunk-4NEPHK2K.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-KOGPVAP6.js';
+export { AgentInferenceCompiler, AgentInferenceExportTarget_default as AgentInferenceExportTarget, createAgentInferenceCompiler, createPythonAgentInferenceCompiler } from '../chunk-KOGPVAP6.js';
+import { vrTraitRegistry } from '../chunk-W4AJMMQR.js';
 import '../chunk-6TRX6AR2.js';
 import '../chunk-ZVQMKUGJ.js';
 import { isWebGpuEnvironmentPresent } from '../chunk-K56UVEXV.js';
@@ -28,50 +28,50 @@ 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-BLCWQ225.js';
+import { init_SDFCompiler } from '../chunk-IXFNA5TT.js';
+export { SDFCompiler } from '../chunk-IXFNA5TT.js';
+import { init_StateCompiler } from '../chunk-62OYZT6Q.js';
+export { StateCompiler } from '../chunk-62OYZT6Q.js';
+export { TraitCompositionCompiler } from '../chunk-UKEK2NZJ.js';
 import '../chunk-DQRJ5RJG.js';
-export { IncrementalCompiler, createIncrementalCompiler } from '../chunk-VO52AJD5.js';
+export { IncrementalCompiler, createIncrementalCompiler } from '../chunk-VXHB6ZHY.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-3KHRZTNW.js';
+export { AndroidCompiler } from '../chunk-3KHRZTNW.js';
+import { init_AndroidXRCompiler, init_AndroidXRTraitMap, AndroidXRCompiler, getTraitMapping, ANDROIDXR_TRAIT_MAP } from '../chunk-JCVSCKUH.js';
+export { AndroidXRCompiler } from '../chunk-JCVSCKUH.js';
 import '../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-KEYG7HGY.js';
-export { WebGPUCompiler } from '../chunk-KEYG7HGY.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-73EDVY5D.js';
+export { IOSCompiler } from '../chunk-73EDVY5D.js';
+import { init_VisionOSCompiler, init_VisionOSTraitMap, getTraitMapping as getTraitMapping$1, listAllTraits, generateTraitCode } from '../chunk-VMCR5QVI.js';
+export { VisionOSCompiler } from '../chunk-VMCR5QVI.js';
+import { init_WASMCompiler } from '../chunk-5T6BWIB7.js';
+export { WASMCompiler } from '../chunk-5T6BWIB7.js';
+import { init_WebGPUCompiler, WebGPUCompiler } from '../chunk-QLPRI3QW.js';
+export { WebGPUCompiler } from '../chunk-QLPRI3QW.js';
+import { init_DTDLCompiler } from '../chunk-CHIZSMWD.js';
+export { DTDLCompiler } from '../chunk-CHIZSMWD.js';
+import { init_URDFCompiler } from '../chunk-Q4J2K7FI.js';
+export { URDFCompiler, createURDFCompiler } from '../chunk-Q4J2K7FI.js';
 import '../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-R5VKLUMR.js';
+export { OpenXRCompiler } from '../chunk-R5VKLUMR.js';
+import { init_VRChatCompiler } from '../chunk-6FCNMTL5.js';
+export { VRChatCompiler } from '../chunk-6FCNMTL5.js';
+import { init_UnityCompiler } from '../chunk-KYJD2UMV.js';
+export { UnityCompiler } from '../chunk-KYJD2UMV.js';
+import '../chunk-M7XR3F53.js';
 import { init_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-RVN7OPCP.js';
+export { GodotCompiler } from '../chunk-RVN7OPCP.js';
+import '../chunk-TZQKJOPC.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-YDSNDCV3.js';
+export { CompilerBase, CompilerDocumentationGenerator, UnauthorizedCompilerAccessError, createTestCompilerToken, isCapabilityTokenCredential } from '../chunk-YDSNDCV3.js';
+import { init_traitDocs, getTraitDoc, getAllTraitNames } from '../chunk-IA7FCSRY.js';
 import '../chunk-5CURIYGT.js';
 import '../chunk-33YHE7HX.js';
 import '../chunk-GLEJ2TLS.js';
@@ -89,6 +89,7 @@ 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();
@@ -133,7 +134,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 +147,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 +182,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 +239,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 +272,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 +343,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 +409,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 +435,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 +494,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 +506,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 +518,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 +1041,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 +1061,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 +1074,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 +1106,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 +1664,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 +1778,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) {
@@ -3285,8 +3849,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: createHash2 } = await import('crypto');
+  return createHash2("sha256").update(input).digest("hex");
 }
 function bytesToHex(bytes) {
   return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
@@ -4099,6 +4663,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",
@@ -4320,6 +4896,66 @@ 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."
   }
 ];