@holoscript/core 6.0.4 → 6.1.2

package/dist/compiler/index.js

@@ -1,68 +1,94 @@
 export { createReproducibilityContext, parseReproducibilityFlags } from '../chunk-5GLCTO44.js';
-export { GLTF_PIPELINE_TOOLS, registerGLTFTools } from '../chunk-OFKWH2IP.js';
-export { NodeToyMapper, mapNodeToyToShader } from '../chunk-IHOUYQIA.js';
-import { init_A2AAgentCardCompiler, A2AAgentCardCompiler_exports, init_NIRCompiler, NIRCompiler_exports } from '../chunk-T4NKMBDL.js';
-export { CompilerBridge, USDZPipeline, bestCategoryForTraits, compilePipelineSource, compilePipelineSourceToNode, compilePipelineSourceToPython, compilePipelineToNode, compilePipelineToPython, quickSafetyCheck, runSafetyPass, selectModality, selectModalityForAll } from '../chunk-T4NKMBDL.js';
-export { generateHullGeometry, generateMembraneGeometry, generateSplineGeometry } from '../chunk-HJJLD366.js';
-export { RemotionBridgeImpl as RemotionBridge } from '../chunk-YYXH45E2.js';
+export { ContextCompileError, ContextCompiler, createContextCompiler } from '../chunk-VEXPG4WN.js';
+export { LLMCapabilityCompileError, LLMProviderCapabilitiesCompiler, createLLMProviderCapabilitiesCompiler } from '../chunk-22W6NGYN.js';
+export { GLTF_PIPELINE_TOOLS, registerGLTFTools } from '../chunk-KX76JUQY.js';
+export { BUSINESS_QUEST_TOOLS, buildVRRCompositionFromDraft, businessVRRDraftSchema, draftToHoloPreview, handleBusinessQuestToolCall, registerBusinessQuestTools, validateBusinessVRRDraft } from '../chunk-DMXC24WV.js';
+export { NodeToyMapper, mapNodeToyToShader } from '../chunk-TG7O4WBC.js';
+export { QuantumCircuitCompiler } from '../chunk-EOFNVCM6.js';
+import { init_ThreeJSCompiler, ThreeJSCompiler_exports, init_A2AAgentCardCompiler, A2AAgentCardCompiler_exports, init_NIRCompiler, NIRCompiler_exports } from '../chunk-QCCBXSCE.js';
+export { CompilerBridge, GaussianSplattingCompiler, SHARED_SORT_SHADER_PATH, SpatialPartitionPass, USDZPipeline, bestCategoryForTraits, compilePipelineSource, compilePipelineSourceToNode, compilePipelineSourceToPython, compilePipelineToNode, compilePipelineToPython, createGaussianSplattingCompiler, detectMultiUserSharedSort, quickSafetyCheck, runSafetyPass, selectModality, selectModalityForAll, spatialPartition } from '../chunk-QCCBXSCE.js';
+export { generateHullGeometry, generateMembraneGeometry, generateSplineGeometry } from '../chunk-EKBKLK7P.js';
 export { SemanticSceneGraph } from '../chunk-HYNTS5CP.js';
-import '../chunk-XD6IYDUX.js';
+import '../chunk-GN3KDX4W.js';
+import { assertHoloMapManifestContract } from '../chunk-MBOOR7X4.js';
 export { COCOExporterImpl as COCOExporter } from '../chunk-Q56TT7IL.js';
-import { init_DTDLCompiler, DTDLCompiler_exports } from '../chunk-IWI6J7FX.js';
-export { DTDLCompiler } from '../chunk-IWI6J7FX.js';
-import { init_URDFCompiler, URDFCompiler_exports } from '../chunk-UPJBDCVF.js';
-export { URDFCompiler } from '../chunk-UPJBDCVF.js';
-export { USDPhysicsCompiler } from '../chunk-SDAMZIRE.js';
-import { init_SDFCompiler, SDFCompiler_exports } from '../chunk-UERJ3YJV.js';
-export { SDFCompiler } from '../chunk-UERJ3YJV.js';
-import { init_StateCompiler, StateCompiler_exports } from '../chunk-CDPGV4DN.js';
-export { StateCompiler } from '../chunk-CDPGV4DN.js';
-export { TraitCompositionCompiler } from '../chunk-NOZZ46QU.js';
-export { IncrementalCompiler } from '../chunk-CS2EMTGF.js';
-import { init_R3FCompiler, R3FCompiler_exports } from '../chunk-T36DDXSF.js';
-export { ENVIRONMENT_PRESETS, R3FCompiler } from '../chunk-T36DDXSF.js';
-import '../chunk-H5Z7NASB.js';
-import { init_PlayCanvasCompiler, PlayCanvasCompiler_exports } from '../chunk-S565K7NK.js';
-export { PlayCanvasCompiler } from '../chunk-S565K7NK.js';
-import { init_AndroidCompiler, AndroidCompiler_exports } from '../chunk-QGKNANZ3.js';
-export { AndroidCompiler } from '../chunk-QGKNANZ3.js';
-import { init_AndroidXRCompiler, AndroidXRCompiler_exports } from '../chunk-S2N5TNMA.js';
-export { AndroidXRCompiler } from '../chunk-S2N5TNMA.js';
-import { init_IOSCompiler, IOSCompiler_exports } from '../chunk-BWFJEM5A.js';
-export { IOSCompiler } from '../chunk-BWFJEM5A.js';
-import { init_VisionOSCompiler, VisionOSCompiler_exports } from '../chunk-YCXFCXDS.js';
-export { VisionOSCompiler } from '../chunk-YCXFCXDS.js';
-import { init_WASMCompiler, WASMCompiler_exports } from '../chunk-L4G4RLXX.js';
-export { WASMCompiler } from '../chunk-L4G4RLXX.js';
-import { init_WebGPUCompiler, WebGPUCompiler_exports } from '../chunk-G4VZTCIB.js';
-export { WebGPUCompiler } from '../chunk-G4VZTCIB.js';
-export { MultiLayerCompiler } from '../chunk-FHQVYCH2.js';
-import { init_ARCompiler, ARCompiler_exports } from '../chunk-MEASWI2Y.js';
-export { ARCompiler } from '../chunk-MEASWI2Y.js';
-import { init_OpenXRCompiler, OpenXRCompiler_exports } from '../chunk-XCWFGZAA.js';
-export { OpenXRCompiler } from '../chunk-XCWFGZAA.js';
-import { init_VRChatCompiler, VRChatCompiler_exports } from '../chunk-E3FWRT3Z.js';
-export { VRChatCompiler } from '../chunk-E3FWRT3Z.js';
-import { init_BabylonCompiler, BabylonCompiler_exports } from '../chunk-KED34ILP.js';
-export { BabylonCompiler } from '../chunk-KED34ILP.js';
-import '../chunk-A7PIMZGU.js';
-import '../chunk-DXJQDCFL.js';
-import { init_UnityCompiler, UnityCompiler_exports } from '../chunk-TEWCN33Y.js';
-export { UnityCompiler } from '../chunk-TEWCN33Y.js';
-import { init_UnrealCompiler, UnrealCompiler_exports } from '../chunk-RVYPEYPX.js';
-import { init_GodotCompiler, GodotCompiler_exports } from '../chunk-K6EKD26I.js';
-export { GodotCompiler } from '../chunk-K6EKD26I.js';
-import '../chunk-56IF4NTA.js';
-import { init_constants, CONNECTOR_PACKAGES, CONNECTOR_ENV_REQUIREMENTS, KNOWN_CONNECTORS } from '../chunk-NDQNIJEH.js';
-import '../chunk-IFNQFCTM.js';
-import '../chunk-HPS76H7Q.js';
-import '../chunk-WB4Z63GG.js';
-import '../chunk-XUTX5CBW.js';
-import { init_VRRCompiler, VRRCompiler_exports } from '../chunk-R7MA7QWV.js';
-import '../chunk-YQK5JNFK.js';
-import { init_CompilerBase, CompilerBase, init_identity, ANSCapabilityPath, init_CompilerDocumentationGenerator } from '../chunk-6XSERL6L.js';
-export { CompilerBase, CompilerDocumentationGenerator, UnauthorizedCompilerAccessError, createTestCompilerToken, isCapabilityTokenCredential } from '../chunk-6XSERL6L.js';
-import { __export, __esm, __toCommonJS } from '../chunk-2CWOLHTE.js';
+export { RemotionBridgeImpl as RemotionBridge } from '../chunk-YYXH45E2.js';
+import { vrTraitRegistry } from '../chunk-EOBB6A4B.js';
+import '../chunk-QPOQ7VPI.js';
+import { isWebGpuEnvironmentPresent } from '../chunk-YF2I3MV3.js';
+import '../chunk-TDCNJHWO.js';
+import '../chunk-VECQYRXL.js';
+import '../chunk-YQELFNJV.js';
+import '../chunk-FHP6LXJS.js';
+export { IncrementalCompiler, createIncrementalCompiler } from '../chunk-QAVXL2IH.js';
+import '../chunk-2M2DPHKB.js';
+import '../chunk-4R6SBXDB.js';
+import { init_WASMCompiler, WASMCompiler_exports } from '../chunk-5CKA5SXU.js';
+export { WASMCompiler } from '../chunk-5CKA5SXU.js';
+import { init_WebGPUCompiler, WebGPUCompiler_exports, WebGPUCompiler } from '../chunk-6L4VE27M.js';
+export { WebGPUCompiler } from '../chunk-6L4VE27M.js';
+import { init_DTDLCompiler, DTDLCompiler_exports } from '../chunk-33XCOVE3.js';
+export { DTDLCompiler } from '../chunk-33XCOVE3.js';
+import { init_URDFCompiler, URDFCompiler_exports } from '../chunk-EMMC5CSQ.js';
+export { URDFCompiler, createURDFCompiler } from '../chunk-EMMC5CSQ.js';
+export { USDPhysicsCompiler } from '../chunk-MSMIFMBL.js';
+import { init_SDFCompiler, SDFCompiler_exports } from '../chunk-S5IFXW6E.js';
+export { SDFCompiler } from '../chunk-S5IFXW6E.js';
+import { init_StateCompiler, StateCompiler_exports } from '../chunk-U4NBQJBY.js';
+export { StateCompiler } from '../chunk-U4NBQJBY.js';
+export { TraitCompositionCompiler } from '../chunk-UD3DSHZM.js';
+import { init_UnrealCompiler, UnrealCompiler_exports } from '../chunk-2A7FURVO.js';
+import { init_GodotCompiler, GodotCompiler_exports } from '../chunk-LAOCQJ2M.js';
+export { GodotCompiler } from '../chunk-LAOCQJ2M.js';
+import { init_R3FCompiler, R3FCompiler_exports } from '../chunk-FXKTYFYA.js';
+export { ENVIRONMENT_PRESETS, R3FCompiler } from '../chunk-FXKTYFYA.js';
+import '../chunk-XT6JY5W5.js';
+import { init_PlayCanvasCompiler, PlayCanvasCompiler_exports } from '../chunk-I2O7TW6B.js';
+export { PlayCanvasCompiler } from '../chunk-I2O7TW6B.js';
+import { init_AndroidCompiler, AndroidCompiler_exports } from '../chunk-UDMYRFDZ.js';
+export { AndroidCompiler } from '../chunk-UDMYRFDZ.js';
+import { init_AndroidXRCompiler, init_AndroidXRTraitMap, AndroidXRCompiler_exports, AndroidXRCompiler, getTraitMapping, ANDROIDXR_TRAIT_MAP } from '../chunk-6FGQNDR4.js';
+export { AndroidXRCompiler } from '../chunk-6FGQNDR4.js';
+import '../chunk-FDSGHPAK.js';
+import { init_IOSCompiler, IOSCompiler_exports } from '../chunk-ZXBZVXDW.js';
+export { IOSCompiler } from '../chunk-ZXBZVXDW.js';
+import { init_VisionOSCompiler, init_VisionOSTraitMap, VisionOSCompiler_exports, getTraitMapping as getTraitMapping$1, listAllTraits, generateTraitCode } from '../chunk-4UUKPCY4.js';
+export { VisionOSCompiler } from '../chunk-4UUKPCY4.js';
+export { MultiLayerCompiler } from '../chunk-ER4GATIU.js';
+import { init_VRRCompiler, VRRCompiler_exports } from '../chunk-R3IVNY6P.js';
+export { VRRCompiler } from '../chunk-R3IVNY6P.js';
+import { init_ARCompiler, ARCompiler_exports } from '../chunk-OPZ7XDDI.js';
+export { ARCompiler } from '../chunk-OPZ7XDDI.js';
+import { init_OpenXRCompiler, OpenXRCompiler_exports } from '../chunk-2B7WVIDZ.js';
+export { OpenXRCompiler } from '../chunk-2B7WVIDZ.js';
+import { init_VRChatCompiler, VRChatCompiler_exports } from '../chunk-OEFY723R.js';
+export { VRChatCompiler } from '../chunk-OEFY723R.js';
+import { init_BabylonCompiler, BabylonCompiler_exports } from '../chunk-6ASWLXXN.js';
+export { BabylonCompiler } from '../chunk-6ASWLXXN.js';
+import '../chunk-TJHVSBP2.js';
+import '../chunk-4C57PR42.js';
+import { init_UnityCompiler, UnityCompiler_exports } from '../chunk-P7YIA5LN.js';
+export { UnityCompiler } from '../chunk-P7YIA5LN.js';
+import { init_PlatformConditionalCompilerMixin } from '../chunk-GZG4KA4E.js';
+export { PlatformConditionalCompilerMixin, createPlatformTarget, filterCompositionForPlatform, matchesPlatformConstraint, normalizePlatformName } from '../chunk-GZG4KA4E.js';
+import '../chunk-W55Z7QIX.js';
+import { init_CompilerBase, CompilerBase, init_ANSNamespace, ANSCapabilityPath, init_CompilerDocumentationGenerator } from '../chunk-QTPMJRGS.js';
+export { CompilerBase, CompilerDocumentationGenerator, UnauthorizedCompilerAccessError, createTestCompilerToken, isCapabilityTokenCredential } from '../chunk-QTPMJRGS.js';
+import { init_traitDocs, getTraitDoc, getAllTraitNames } from '../chunk-THCK6ECW.js';
+import '../chunk-N75IH2HY.js';
+import '../chunk-MXFUTKCO.js';
+import '../chunk-J32ZJZJH.js';
+import { init_constants, CONNECTOR_PACKAGES, CONNECTOR_ENV_REQUIREMENTS, KNOWN_CONNECTORS } from '../chunk-2BSMSUCE.js';
+import '../chunk-WRNEH5MO.js';
+import '../chunk-WKX5AMOY.js';
+import '../chunk-SIEXCILW.js';
+import '../chunk-CBJY23VL.js';
+import { ExpressionEvaluator } from '../chunk-XL6INWKT.js';
+import '../chunk-77V4GTCA.js';
+import '../chunk-PHENW4MQ.js';
+import { init_safeJsonParse, readJson } from '../chunk-VVKVQZI6.js';
+import { __export, __esm, __toCommonJS } from '../chunk-OL46QLBJ.js';
+import { ANSCapabilityPath as ANSCapabilityPath$1 } from '@holoscript/core-types/ans';
 
 // src/compiler/Native2DCompiler.ts
 var Native2DCompiler_exports = {};
@@ -73,6 +99,7 @@ var Native2DCompiler;
 var init_Native2DCompiler = __esm({
   "src/compiler/Native2DCompiler.ts"() {
     init_CompilerBase();
+    init_safeJsonParse();
     Native2DCompiler = class extends CompilerBase {
       constructor() {
         super(...arguments);
@@ -93,24 +120,11 @@ var init_Native2DCompiler = __esm({
         const isReact = options?.format === "react";
         const elements = composition.ui?.elements || composition.objects || [];
         if (isReact) {
-          const code = this.generateReactComponent(composition.name, elements, composition, options);
-          if (options?.generateDocs) {
-            return {
-              output: code,
-              documentation: this.generateDocumentation(composition, code, options.docsOptions)
-            };
-          }
-          return code;
-        } else {
-          const code = this.generateHTMLPage(composition.name, elements, composition);
-          if (options?.generateDocs) {
-            return {
-              output: code,
-              documentation: this.generateDocumentation(composition, code, options.docsOptions)
-            };
-          }
-          return code;
+          const code2 = this.generateReactComponent(composition.name, elements, composition, options);
+          return this.withTripleOutputIfRequested(composition, code2, options);
         }
+        const code = this.generateHTMLPage(composition.name, elements, composition);
+        return this.withTripleOutputIfRequested(composition, code, options);
       }
       generateReactComponent(name, objects, composition, options) {
         this._slotImports.clear();
@@ -250,7 +264,7 @@ export default ${safeName}Component;
         }
         if (traits.theme?.attributes) {
           try {
-            const parsedAttrs = JSON.parse(traits.theme.attributes);
+            const parsedAttrs = readJson(traits.theme.attributes);
             for (const [key, value] of Object.entries(parsedAttrs)) {
               props += ` ${key}="${value}"`;
             }
@@ -391,7 +405,7 @@ export default ${safeName}Component;
         }
         if (traits.theme?.attributes) {
           try {
-            const parsedAttrs = JSON.parse(traits.theme.attributes);
+            const parsedAttrs = readJson(traits.theme.attributes);
             for (const [key, value] of Object.entries(parsedAttrs)) {
               props += ` ${key}="${value}"`;
             }
@@ -560,6 +574,19 @@ function buildPropMap(obj) {
   }
   return map;
 }
+function toStringArray(val) {
+  if (val === void 0 || val === null) return void 0;
+  if (!Array.isArray(val)) return void 0;
+  const out = [];
+  for (const item of val) {
+    if (typeof item === "string") out.push(item);
+  }
+  return out.length ? out : void 0;
+}
+function parseResponseMode(raw) {
+  if (raw === "echo" || raw === "message") return raw;
+  return void 0;
+}
 function toApiRouteSegment(name, override) {
   if (override) {
     return override.replace(/^\/+api\/+/, "").replace(/^\/+/, "").replace(/\/+$/, "");
@@ -580,7 +607,9 @@ function extractHandlers(composition) {
       byMethod.set(method, {
         method,
         statusCode: Number(toScalar(rootHttp["statusCode"]) ?? toScalar(rootHttp["status"]) ?? 200),
-        description: String(toScalar(rootHttp["description"]) ?? "")
+        description: String(toScalar(rootHttp["description"]) ?? ""),
+        requiredBodyKeys: toStringArray(rootHttp["requiredBodyKeys"]),
+        responseMode: parseResponseMode(String(toScalar(rootHttp["responseMode"]) ?? "")) ?? (rootHttp["echoBody"] === true ? "echo" : void 0)
       });
     }
   }
@@ -594,21 +623,28 @@ function extractHandlers(composition) {
     if (!method) continue;
     const traitStatus = toScalar(traitConfig["statusCode"] ?? traitConfig["status"]);
     const propStatus = props.get("statusCode") ?? props.get("status");
+    const objRequired = toStringArray(traitConfig["requiredBodyKeys"]);
+    const mode = parseResponseMode(String(toScalar(traitConfig["responseMode"]) ?? "")) ?? (traitConfig["echoBody"] === true ? "echo" : void 0);
     byMethod.set(method, {
       method,
       statusCode: Number(traitStatus ?? propStatus ?? 200),
       description: String(
         props.get("description") ?? toScalar(traitConfig["description"]) ?? obj.name ?? ""
-      )
+      ),
+      requiredBodyKeys: objRequired,
+      responseMode: mode
     });
   }
   return [...byMethod.values()];
 }
-function emitHandler(handler) {
-  const { method, statusCode, description } = handler;
+function emitHandler(handler, meta, opts) {
+  const { method, statusCode, description, requiredBodyKeys = [], responseMode } = handler;
   const lines = [];
   const hasBody = BODY_METHODS.has(method);
   const isPassthrough = PASSTHROUGH_METHODS.has(method);
+  const mode = responseMode ?? (requiredBodyKeys.length > 0 ? "message" : "echo");
+  const keysJson = JSON.stringify(requiredBodyKeys);
+  const useEcho = mode === "echo";
   if (description) {
     lines.push(`/** ${description} */`);
   }
@@ -624,18 +660,48 @@ function emitHandler(handler) {
     lines.push(`  try {`);
     lines.push(`    body = await _request.json();`);
     lines.push(`  } catch {`);
-    lines.push(`    return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 });`);
+    lines.push(`    return NextResponse.json({ ok: false, error: 'Invalid JSON body' }, { status: 400 });`);
     lines.push(`  }`);
-    lines.push(``);
-    lines.push(`  void body; // TODO: validate and process body`);
-    lines.push(``);
-    lines.push(`  return NextResponse.json(`);
-    lines.push(`    { /* TODO: return response data */ },`);
-    lines.push(`    { status: ${statusCode} }`);
-    lines.push(`  );`);
+    lines.push(`  const record = typeof body === 'object' && body !== null ? (body as Record<string, unknown>) : null;`);
+    lines.push(`  if (!record) {`);
+    lines.push(
+      `    return NextResponse.json({ ok: false, error: 'JSON body must be an object' }, { status: 400 });`
+    );
+    lines.push(`  }`);
+    if (opts.includeValidation) {
+      lines.push(`  const spatialValidation = validateSpatialRequestBody(record);`);
+      lines.push(`  if (!spatialValidation.valid) {`);
+      lines.push(
+        `    return NextResponse.json({ ok: false, error: spatialValidation.error, field: spatialValidation.field }, { status: 400 });`
+      );
+      lines.push(`  }`);
+    }
+    lines.push(`  const requiredKeys = ${keysJson} as const;`);
+    lines.push(`  for (const key of requiredKeys) {`);
+    lines.push(`    if (!(key in record)) {`);
+    lines.push(
+      `      return NextResponse.json({ ok: false, error: 'Missing required field', field: key }, { status: 400 });`
+    );
+    lines.push(`    }`);
+    lines.push(`  }`);
+    if (useEcho) {
+      lines.push(`  return NextResponse.json(`);
+      lines.push(`    { ok: true, route: ${JSON.stringify(meta.routeSegment)}, data: record },`);
+      lines.push(`    { status: ${statusCode} }`);
+      lines.push(`  );`);
+    } else {
+      lines.push(`  return NextResponse.json(`);
+      lines.push(
+        `    { ok: true, route: ${JSON.stringify(meta.routeSegment)}, composition: ${JSON.stringify(meta.compositionName)}, message: ${JSON.stringify(description || "Accepted")}, receivedKeys: Object.keys(record) },`
+      );
+      lines.push(`    { status: ${statusCode} }`);
+      lines.push(`  );`);
+    }
   } else {
     lines.push(`  return NextResponse.json(`);
-    lines.push(`    { /* TODO: return response data */ },`);
+    lines.push(
+      `    { ok: true, route: ${JSON.stringify(meta.routeSegment)}, composition: ${JSON.stringify(meta.compositionName)}, message: ${JSON.stringify(description || "OK")} },`
+    );
     lines.push(`    { status: ${statusCode} }`);
     lines.push(`  );`);
   }
@@ -656,6 +722,9 @@ function compileToNextJSAPI(composition, options = {}) {
   const routeSegment = toApiRouteSegment(composition.name, options.apiRoute);
   const outputBase = options.outputDir ? options.outputDir.replace(/\/$/, "") : "api";
   const filePath = `${outputBase}/${routeSegment}/route.ts`;
+  const meta = { routeSegment, compositionName: composition.name };
+  const includeValidation = options.includeValidation !== false;
+  const hasBodyHandlers = handlers.some((h) => BODY_METHODS.has(h.method));
   const lines = [];
   if (options.includeJsDoc !== false) {
     lines.push(`// @generated by HoloScript NextJSAPICompiler \u2014 DO NOT EDIT`);
@@ -670,8 +739,40 @@ function compileToNextJSAPI(composition, options = {}) {
     lines.push(`import { NextResponse } from 'next/server';`);
   }
   lines.push(``);
+  if (includeValidation && hasBodyHandlers) {
+    lines.push(`function isTuple3(value: unknown): value is [number, number, number] {`);
+    lines.push(`  return Array.isArray(value) && value.length === 3 && value.every((n) => typeof n === 'number');`);
+    lines.push(`}`);
+    lines.push(``);
+    lines.push(`function isTuple4(value: unknown): value is [number, number, number, number] {`);
+    lines.push(`  return Array.isArray(value) && value.length === 4 && value.every((n) => typeof n === 'number');`);
+    lines.push(`}`);
+    lines.push(``);
+    lines.push(
+      `function validateSpatialRequestBody(record: Record<string, unknown>): { valid: true } | { valid: false; error: string; field: string } {`
+    );
+    lines.push(`  if ('position' in record && !isTuple3(record.position)) {`);
+    lines.push(`    return { valid: false, error: 'position must be [x, y, z] numeric tuple', field: 'position' };`);
+    lines.push(`  }`);
+    lines.push(`  if ('scale' in record && !isTuple3(record.scale)) {`);
+    lines.push(`    return { valid: false, error: 'scale must be [x, y, z] numeric tuple', field: 'scale' };`);
+    lines.push(`  }`);
+    lines.push(`  if ('rotation' in record) {`);
+    lines.push(`    const rotation = record.rotation;`);
+    lines.push(`    const isEuler = isTuple3(rotation);`);
+    lines.push(`    const isQuat = isTuple4(rotation);`);
+    lines.push(`    if (!isEuler && !isQuat) {`);
+    lines.push(
+      `      return { valid: false, error: 'rotation must be [x, y, z] or [x, y, z, w] numeric tuple', field: 'rotation' };`
+    );
+    lines.push(`    }`);
+    lines.push(`  }`);
+    lines.push(`  return { valid: true };`);
+    lines.push(`}`);
+    lines.push(``);
+  }
   for (let i = 0; i < handlers.length; i++) {
-    lines.push(...emitHandler(handlers[i]));
+    lines.push(...emitHandler(handlers[i], meta, { includeValidation }));
     if (i < handlers.length - 1) {
       lines.push(``);
     }
@@ -703,26 +804,33 @@ var init_NextJSAPICompiler = __esm({
       constructor(options = {}) {
         super();
         this.options = options;
+        this.compilerName = "NextJSAPICompiler";
       }
-      get name() {
-        return "nextjs-api";
-      }
-      compile(composition, agentToken) {
-        const comp = composition;
-        const result = compileAllToNextJSAPI(comp);
-        return {
-          code: result.map((r) => r.code).join("\n\n"),
-          files: result.map((r) => ({ path: r.routePath, content: r.code }))
-        };
+      compile(composition, agentToken, outputPath, _sceneGraph) {
+        this.validateCompilerAccess(agentToken, outputPath);
+        const result = compileToNextJSAPI(composition, this.options);
+        return { [result.path]: result.code };
       }
-      compileSingle(composition, agentToken) {
-        const comp = composition;
-        return compileToNextJSAPI(comp);
+      /** Multi-composition helper (not used by CompilerBase). */
+      compileAll(compositions, agentToken, outputPath) {
+        this.validateCompilerAccess(agentToken, outputPath);
+        const files = {};
+        for (const row of compileAllToNextJSAPI(compositions, this.options)) {
+          files[row.path] = row.code;
+        }
+        return files;
       }
     };
   }
 });
 
+// src/compiler/identity/index.ts
+var init_identity = __esm({
+  "src/compiler/identity/index.ts"() {
+    init_ANSNamespace();
+  }
+});
+
 // src/compiler/NodeServiceCompiler.ts
 var NodeServiceCompiler_exports = {};
 __export(NodeServiceCompiler_exports, {
@@ -753,7 +861,6 @@ var init_NodeServiceCompiler = __esm({
         return ANSCapabilityPath.NODE_SERVICE;
       }
       compile(composition, agentToken, outputPath) {
-        console.log("DEBUG: Composition:", JSON.stringify(composition, null, 2));
         this.validateCompilerAccess(agentToken, outputPath);
         this.services = [];
         this.extractServices(composition);
@@ -820,7 +927,16 @@ var init_NodeServiceCompiler = __esm({
       }
       hasServiceTraits(obj) {
         if (!obj.traits) return false;
-        const serviceTraits = ["service", "endpoint", "http", "handler", "route", "connector", "env", "deploy"];
+        const serviceTraits = [
+          "service",
+          "endpoint",
+          "http",
+          "handler",
+          "route",
+          "connector",
+          "env",
+          "deploy"
+        ];
         return obj.traits.some((t) => serviceTraits.includes(t.name));
       }
       parseServiceBlock(block) {
@@ -860,7 +976,10 @@ var init_NodeServiceCompiler = __esm({
         if (obj.traits) {
           const traitNames = obj.traits.map((t) => t.name);
           service.middleware = this.extractMiddlewareFromTraits(traitNames);
-          service.connectors = this.extractConnectors(traitNames, this.objectPropsToMap(obj.properties));
+          service.connectors = this.extractConnectors(
+            traitNames,
+            this.objectPropsToMap(obj.properties)
+          );
           service.envVars = this.extractEnvVars(traitNames, this.objectPropsToMap(obj.properties));
           service.deploy = this.extractDeploy(traitNames, this.objectPropsToMap(obj.properties));
         }
@@ -870,16 +989,20 @@ var init_NodeServiceCompiler = __esm({
       }
       extractRoute(obj, serviceName) {
         const propMap = this.objectPropsToMap(obj.properties);
-        const traits = (obj.traits || []).map((t) => t.name);
+        const traitObjects = obj.traits || [];
+        const traits = traitObjects.map((t) => t.name);
+        const handlerTrait = this.findTrait(traitObjects, "handler");
         const method = this.resolveString(propMap.get("method"))?.toUpperCase() || "GET";
         const path = this.resolveString(propMap.get("path")) || `/${this.toKebab(obj.name)}`;
-        const handlerName = this.resolveString(propMap.get("handler")) || this.toCamelCase(obj.name);
+        const handlerName = this.resolveString(propMap.get("handler")) || this.resolveString(this.readTraitConfig(handlerTrait, "name", "handler")) || this.resolveString(this.readTraitConfig(handlerTrait, "_arg0")) || this.toCamelCase(obj.name);
         const hasHttpInfo = propMap.has("method") || propMap.has("path") || traits.includes("http") || traits.includes("route");
         if (!hasHttpInfo) return null;
         return {
           method,
           path,
           handlerName,
+          handlerBody: this.extractRouteHandlerBody(obj, propMap, handlerName),
+          handlerState: this.extractRouteState(obj),
           middleware: this.extractMiddlewareFromTraits(traits),
           serviceName
         };
@@ -887,14 +1010,111 @@ var init_NodeServiceCompiler = __esm({
       extractInlineRoute(block) {
         const props = block.properties;
         if (!props["method"] && !props["path"]) return null;
+        const handlerName = this.resolveString(props["handler"]) || this.toCamelCase(block.name);
         return {
           method: this.resolveString(props["method"])?.toUpperCase() || "GET",
           path: this.resolveString(props["path"]) || `/${this.toKebab(block.name)}`,
-          handlerName: this.resolveString(props["handler"]) || this.toCamelCase(block.name),
+          handlerName,
+          handlerBody: this.extractBlockHandlerBody(block, handlerName),
           middleware: [],
           serviceName: block.name
         };
       }
+      extractRouteHandlerBody(obj, propMap, handlerName) {
+        const directBody = this.handlerBodyFromValue(
+          this.readMapValue(propMap, "handlerBody", "handler_body", "body")
+        );
+        if (directBody) return directBody;
+        const handlerTrait = this.findTrait(obj.traits || [], "handler");
+        const traitBody = this.handlerBodyFromValue(
+          this.readTraitConfig(handlerTrait, "body", "code", "implementation")
+        );
+        if (traitBody) return traitBody;
+        for (const directive of obj.directives ?? []) {
+          const body = this.handlerBodyFromDirective(directive, handlerName);
+          if (body) return body;
+        }
+        return this.handlerBodyFromEventHandlers(
+          obj.eventHandlers,
+          handlerName
+        );
+      }
+      extractBlockHandlerBody(block, handlerName) {
+        const directBody = this.handlerBodyFromValue(
+          this.readRecordValue(block.properties, "handlerBody", "handler_body", "body")
+        );
+        if (directBody) return directBody;
+        return this.handlerBodyFromEventHandlers(block.eventHandlers, handlerName);
+      }
+      handlerBodyFromDirective(directive, handlerName) {
+        if (!directive || typeof directive !== "object") return void 0;
+        const record = directive;
+        const name = String(record["name"] ?? record["handlerName"] ?? "");
+        const type = String(record["type"] ?? "");
+        if (type === "method" && name === handlerName) {
+          return this.handlerBodyFromValue(record["body"]);
+        }
+        if (type === "trait" && name === "handler") {
+          return this.handlerBodyFromValue(
+            this.readRecordValue(record["config"] ?? {}, "body", "code")
+          );
+        }
+        return void 0;
+      }
+      handlerBodyFromEventHandlers(handlers, handlerName) {
+        for (const handler of handlers ?? []) {
+          if (handler.event === handlerName || handler.name === handlerName) {
+            const body = this.handlerBodyFromValue(handler.body);
+            if (body) return body;
+          }
+        }
+        return void 0;
+      }
+      handlerBodyFromValue(value) {
+        if (value === void 0 || value === null) return void 0;
+        if (typeof value === "string") {
+          const trimmed = value.trim();
+          return trimmed.length > 0 ? trimmed : void 0;
+        }
+        if (Array.isArray(value)) {
+          const lines = value.map((statement) => this.emitHoloStatement(statement)).filter((line) => Boolean(line));
+          return lines.length > 0 ? lines.join("\n") : void 0;
+        }
+        if (typeof value === "object") {
+          const record = value;
+          return this.handlerBodyFromValue(
+            record["body"] ?? record["code"] ?? record["implementation"] ?? record["value"]
+          );
+        }
+        return void 0;
+      }
+      extractRouteState(obj) {
+        if (!obj.state?.properties?.length) return void 0;
+        const state = {};
+        for (const prop of obj.state.properties) {
+          state[prop.key] = prop.value;
+        }
+        return state;
+      }
+      findTrait(traits, name) {
+        return traits.find((trait) => trait.name.replace(/^@/, "") === name);
+      }
+      readTraitConfig(trait, ...keys) {
+        if (!trait?.config) return void 0;
+        return this.readRecordValue(trait.config, ...keys);
+      }
+      readMapValue(map, ...keys) {
+        for (const key of keys) {
+          if (map.has(key)) return map.get(key);
+        }
+        return void 0;
+      }
+      readRecordValue(record, ...keys) {
+        for (const key of keys) {
+          if (Object.prototype.hasOwnProperty.call(record, key)) return record[key];
+        }
+        return void 0;
+      }
       extractMiddlewareFromTraits(traits) {
         const mw = [];
         for (const t of traits) {
@@ -1065,10 +1285,7 @@ var init_NodeServiceCompiler = __esm({
                 `router.${methodLower}('${this.escapeStringValue(route.path, "TypeScript")}', ${mwArgs}(req, res) => {`
               );
             }
-            lines.push(`  // TODO: Implement ${route.handlerName}`);
-            lines.push(
-              `  res.json({ message: '${this.escapeStringValue(route.handlerName, "TypeScript")} not implemented' });`
-            );
+            lines.push(...this.emitExpressRouteBody(route));
             lines.push(`});`);
             lines.push("");
           }
@@ -1096,10 +1313,7 @@ var init_NodeServiceCompiler = __esm({
             lines.push(
               `  app.${methodLower}('${this.escapeStringValue(route.path, "TypeScript")}', async (request, reply) => {`
             );
-            lines.push(`    // TODO: Implement ${route.handlerName}`);
-            lines.push(
-              `    return { message: '${this.escapeStringValue(route.handlerName, "TypeScript")} not implemented' };`
-            );
+            lines.push(...this.emitFastifyRouteBody(route));
             lines.push(`  });`);
             lines.push("");
           }
@@ -1116,6 +1330,90 @@ var init_NodeServiceCompiler = __esm({
         }
         return lines.join("\n");
       }
+      emitExpressRouteBody(route) {
+        if (route.handlerBody) {
+          return [
+            `  // Handler: ${route.handlerName}`,
+            ...this.emitHandlerState(route, "  "),
+            ...this.indentHandlerBody(route.handlerBody, "  ")
+          ];
+        }
+        return [
+          `  // Placeholder \u2014 replace with ${route.handlerName} logic`,
+          `  res.status(501).json({ error: 'not_implemented', handler: '${this.escapeStringValue(route.handlerName, "TypeScript")}' });`
+        ];
+      }
+      emitFastifyRouteBody(route) {
+        if (route.handlerBody) {
+          return [
+            `    // Handler: ${route.handlerName}`,
+            ...this.emitHandlerState(route, "    "),
+            ...this.indentHandlerBody(route.handlerBody, "    ")
+          ];
+        }
+        return [
+          `    // Placeholder \u2014 replace with ${route.handlerName} logic`,
+          `    return reply.code(501).send({ error: 'not_implemented', handler: '${this.escapeStringValue(route.handlerName, "TypeScript")}' });`
+        ];
+      }
+      indentHandlerBody(body, indent) {
+        return body.split(/\r?\n/).map((line) => line.trimEnd()).filter((line) => line.length > 0).map((line) => `${indent}${line}`);
+      }
+      emitHandlerState(route, indent) {
+        if (!route.handlerState || Object.keys(route.handlerState).length === 0) return [];
+        return [
+          `${indent}const state = ${JSON.stringify(route.handlerState, null, 2).replace(/\n/g, `
+${indent}`)};`
+        ];
+      }
+      emitHoloStatement(statement) {
+        switch (statement.type) {
+          case "Assignment":
+            return `${statement.target} ${statement.operator} ${this.emitHoloExpression(statement.value)};`;
+          case "VariableDeclaration":
+            return `${statement.kind} ${statement.name}${statement.value ? ` = ${this.emitHoloExpression(statement.value)}` : ""};`;
+          case "ReturnStatement":
+            return `return ${statement.value ? this.emitHoloExpression(statement.value) : ""};`;
+          case "EmitStatement":
+            return `emit(${JSON.stringify(statement.event)}, ${statement.data ? this.emitHoloExpression(statement.data) : "undefined"});`;
+          case "ExpressionStatement":
+            return `${this.emitHoloExpression(statement.expression)};`;
+          case "MethodCall": {
+            const target = statement.object ? `${statement.object}.` : "";
+            return `${target}${statement.method}(${statement.arguments.map((arg) => this.emitHoloExpression(arg)).join(", ")});`;
+          }
+          default:
+            return `// Unsupported handler statement: ${statement.type}`;
+        }
+      }
+      emitHoloExpression(expression) {
+        switch (expression.type) {
+          case "Literal":
+            return JSON.stringify(expression.value);
+          case "Identifier":
+            return expression.name;
+          case "BinaryExpression":
+            return `(${this.emitHoloExpression(expression.left)} ${expression.operator} ${this.emitHoloExpression(expression.right)})`;
+          case "UnaryExpression":
+            return `(${expression.operator}${this.emitHoloExpression(expression.argument)})`;
+          case "MemberExpression":
+            return expression.computed ? `${this.emitHoloExpression(expression.object)}[${JSON.stringify(expression.property)}]` : `${this.emitHoloExpression(expression.object)}.${expression.property}`;
+          case "CallExpression":
+            return `${this.emitHoloExpression(expression.callee)}(${expression.arguments.map((arg) => this.emitHoloExpression(arg)).join(", ")})`;
+          case "ArrayExpression":
+            return `[${expression.elements.map((element) => this.emitHoloExpression(element)).join(", ")}]`;
+          case "ObjectExpression":
+            return `{ ${expression.properties.map((prop) => `${JSON.stringify(prop.key)}: ${this.emitHoloExpression(prop.value)}`).join(", ")} }`;
+          case "ConditionalExpression":
+            return `(${this.emitHoloExpression(expression.test)} ? ${this.emitHoloExpression(expression.consequent)} : ${this.emitHoloExpression(expression.alternate)})`;
+          case "UpdateExpression":
+            return expression.prefix ? `${expression.operator}${this.emitHoloExpression(expression.argument)}` : `${this.emitHoloExpression(expression.argument)}${expression.operator}`;
+          case "BindExpression":
+            return expression.source;
+          default:
+            return "undefined";
+        }
+      }
       emitMiddlewareIndex(middleware) {
         const lines = [];
         lines.push(`/**`);
@@ -1129,7 +1427,7 @@ var init_NodeServiceCompiler = __esm({
           for (const mw of middleware) {
             const fnName = this.toCamelCase(mw) + "Middleware";
             lines.push(`export function ${fnName}(req: Request, _res: Response, next: NextFunction) {`);
-            lines.push(`  // TODO: Implement ${mw} middleware`);
+            lines.push(`  // Pass-through placeholder for ${mw} \u2014 add auth/limits here`);
             lines.push(`  next();`);
             lines.push(`}`);
             lines.push("");
@@ -1144,7 +1442,7 @@ var init_NodeServiceCompiler = __esm({
             lines.push(
               `export function ${fnName}(request: FastifyRequest, _reply: FastifyReply, done: HookHandlerDoneFunction) {`
             );
-            lines.push(`  // TODO: Implement ${mw} middleware`);
+            lines.push(`  // Pass-through placeholder for ${mw} \u2014 add auth/limits here`);
             lines.push(`  done();`);
             lines.push(`}`);
             lines.push("");
@@ -1392,7 +1690,9 @@ var init_NodeServiceCompiler = __esm({
         const envMap = new Map(envVars.map((ev) => [ev.name, ev]));
         for (const conn of connectors) {
           if (!KNOWN_CONNECTORS.includes(conn.name)) {
-            console.warn(`[NodeServiceCompiler] Warning: Unknown connector '${conn.name}'. Package dependency will not be added.`);
+            console.warn(
+              `[NodeServiceCompiler] Warning: Unknown connector '${conn.name}'. Package dependency will not be added.`
+            );
           } else {
             const requirements = CONNECTOR_ENV_REQUIREMENTS[conn.name] || [];
             for (const req of requirements) {
@@ -1586,6 +1886,28 @@ function registerBuiltinDialects() {
       },
       outputExtensions: [".js"]
     },
+    {
+      name: "threejs",
+      domain: "web3d",
+      description: "Compiles to vanilla Three.js TypeScript (bypasses R3F for bundle-critical deployments)",
+      supportedTraits: [
+        "physics",
+        "collidable",
+        "grabbable",
+        "hoverable",
+        "audio",
+        "animation",
+        "particles",
+        "material",
+        "shadow"
+      ],
+      riskTier: "standard",
+      factory: (opts) => {
+        const { ThreeJSCompiler } = (init_ThreeJSCompiler(), __toCommonJS(ThreeJSCompiler_exports));
+        return new ThreeJSCompiler(opts);
+      },
+      outputExtensions: [".ts"]
+    },
     // ── VR/XR ─────────────────────────────────────────────────────────────
     {
       name: "openxr",
@@ -1609,7 +1931,7 @@ function registerBuiltinDialects() {
     {
       name: "vrchat",
       domain: "social-vr",
-      description: "Compiles to VRChat UdonSharp scripts",
+      description: "Compiles to VRChat SDK3. Current implementation emits legacy UdonSharp C#; Byte/Udon output is gated on the artifact contract.",
       supportedTraits: [
         "physics",
         "collidable",
@@ -1801,8 +2123,8 @@ function registerBuiltinDialects() {
       supportedTraits: ["physics", "material", "lod", "rendering"],
       riskTier: "standard",
       factory: (opts) => {
-        const { VRRCompiler } = (init_VRRCompiler(), __toCommonJS(VRRCompiler_exports));
-        return new VRRCompiler(opts);
+        const { VRRCompiler: VRRCompiler2 } = (init_VRRCompiler(), __toCommonJS(VRRCompiler_exports));
+        return new VRRCompiler2(opts);
       },
       outputExtensions: [".ts"]
     },
@@ -1825,11 +2147,9 @@ function registerBuiltinDialects() {
       description: "Compiles @http traits to Next.js App Router API route handlers (route.ts)",
       supportedTraits: ["http", "handler", "middleware", "auth", "rate_limit", "cors"],
       riskTier: "standard",
-      factory: () => {
-        const { compileToNextJSAPI: compileToNextJSAPI2 } = (init_NextJSAPICompiler(), __toCommonJS(NextJSAPICompiler_exports));
-        return {
-          compile: (composition, _token) => compileToNextJSAPI2(composition)
-        };
+      factory: (opts) => {
+        const { NextJSAPICompiler: NextJSAPICompiler2 } = (init_NextJSAPICompiler(), __toCommonJS(NextJSAPICompiler_exports));
+        return new NextJSAPICompiler2(opts);
       },
       outputExtensions: [".ts"],
       experimental: true
@@ -2044,12 +2364,14 @@ init_PlayCanvasCompiler();
 init_ARCompiler();
 init_OpenXRCompiler();
 init_VRChatCompiler();
+init_VRRCompiler();
 init_VisionOSCompiler();
 init_AndroidCompiler();
 init_AndroidXRCompiler();
 init_IOSCompiler();
 init_WASMCompiler();
 init_WebGPUCompiler();
+init_PlatformConditionalCompilerMixin();
 init_SDFCompiler();
 init_DTDLCompiler();
 init_URDFCompiler();
@@ -2209,7 +2531,7 @@ var MCPConfigCompiler = class extends CompilerBase {
   extractServersFromBlock(block) {
     if (!block.children) return;
     for (const child of block.children) {
-      if ("type" in child && child.type === "ObjectDecl") {
+      if ("type" in child && child.type === "Object") {
         const obj = child;
         this.servers.push(this.extractServerFromObject(obj));
       }
@@ -2256,6 +2578,11 @@ var MCPConfigCompiler = class extends CompilerBase {
     }
     const config = {
       _generated: "HoloScript MCPConfigCompiler",
+      _configKind: "mcp-client-connection-config",
+      _limitations: [
+        "emits IDE client mcpServers connection entries only",
+        "does not emit MCP server manifests, tools, input schemas, or resources"
+      ],
       _target: this.options.target,
       _updated: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
       mcpServers
@@ -2365,19 +2692,2834 @@ var MCPConfigCompiler = class extends CompilerBase {
 DialectRegistry.register({
   name: "mcp-config",
   domain: "configuration",
-  description: "Compiles .holo server definitions to IDE-specific MCP config JSON",
+  description: "Compiles .holo MCP server connection definitions to IDE-specific client config JSON",
   supportedTraits: ["connector", "env"],
+  riskTier: "standard",
   factory: (options) => new MCPConfigCompiler(options),
-  inputFormats: [".holo"],
-  outputFormat: ".json"
+  outputExtensions: [".json"]
 });
 
 // src/compiler/index.ts
+init_PlatformConditionalCompilerMixin();
 init_Native2DCompiler();
+
+// src/compiler/SCMCompiler.ts
+init_CompilerBase();
+var SCMCompiler = class extends CompilerBase {
+  constructor(options = {}) {
+    super();
+    this.compilerName = "SCMCompiler";
+    this.nodes = [];
+    this.edges = [];
+    this.options = {
+      modelName: options.modelName || "HoloScript_SCM_DAG",
+      affectiveContext: options.affectiveContext || {
+        valence: 0,
+        arousal: 0,
+        dominantEmotion: "calm"
+      },
+      privacyMask: options.privacyMask || false
+    };
+  }
+  getRequiredCapability() {
+    return ANSCapabilityPath$1.SCM;
+  }
+  // Helper to extract traits consistently
+  getTraitName(trait) {
+    return typeof trait === "string" ? trait : trait.name;
+  }
+  hasTrait(obj, traitName) {
+    return obj.traits?.some((t) => this.getTraitName(t) === traitName) ?? false;
+  }
+  compile(composition, agentToken, outputPath) {
+    this.validateCompilerAccess(agentToken, outputPath);
+    this.nodes = [];
+    this.edges = [];
+    this.extractNodes(composition);
+    this.extractEdges(composition);
+    this.applyAffectivePruning();
+    this.applyPrivacyMask();
+    const dag = {
+      metadata: {
+        model_name: this.options.modelName,
+        generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+        affective_context: this.options.affectiveContext
+      },
+      nodes: this.nodes,
+      edges: this.edges
+    };
+    return JSON.stringify(dag, null, 2);
+  }
+  applyAffectivePruning() {
+    const state = this.options.affectiveContext;
+    if (state.dominantEmotion === "frustrated" || state.dominantEmotion === "anxious") {
+      this.nodes = this.nodes.filter(
+        (n) => n.do_capable || n.properties.context_group === "global"
+      );
+      this.edges = this.edges.filter((e) => {
+        const targetNode = this.nodes.find((n) => n.id === e.target);
+        return targetNode && (targetNode.do_capable === true || e.weight > 1);
+      });
+    }
+    if (state.dominantEmotion === "engaged") {
+      this.edges = this.edges.map((e) => ({
+        ...e,
+        weight: e.weight * 1.5
+        // Engaged awareness strengthens correlations
+      }));
+    }
+  }
+  applyPrivacyMask() {
+    if (!this.options.privacyMask) return;
+    const idMap = /* @__PURE__ */ new Map();
+    let counter = 0;
+    for (const node of this.nodes) {
+      if (!idMap.has(node.id)) {
+        idMap.set(node.id, `NODE_${counter++}`);
+      }
+      node.id = idMap.get(node.id);
+      node.properties = {};
+    }
+    for (const edge of this.edges) {
+      edge.source = idMap.get(edge.source) || `UNKNOWN_${counter++}`;
+      edge.target = idMap.get(edge.target) || `UNKNOWN_${counter++}`;
+    }
+  }
+  extractNodes(composition) {
+    if (composition.objects) {
+      for (const obj of composition.objects) {
+        this.processNode(obj, "global");
+      }
+    }
+    if (composition.spatialGroups) {
+      for (const group of composition.spatialGroups) {
+        if (group.objects) {
+          for (const obj of group.objects) {
+            this.processNode(obj, group.name);
+          }
+        }
+      }
+    }
+  }
+  processNode(obj, contextGroup) {
+    const isInterventionCapable = this.hasTrait(obj, "ai_agent") || this.hasTrait(obj, "interactive") || this.hasTrait(obj, "causal");
+    const node = {
+      id: obj.name,
+      type: isInterventionCapable ? "mechanism_variable" : "static_variable",
+      do_capable: isInterventionCapable,
+      properties: {
+        context_group: contextGroup
+      }
+    };
+    for (const prop of obj.properties) {
+      if (typeof prop.value === "number" || typeof prop.value === "string" || typeof prop.value === "boolean") {
+        node.properties[prop.key] = prop.value;
+      }
+    }
+    this.nodes.push(node);
+  }
+  extractEdges(composition) {
+    if (composition.spatialGroups) {
+      for (const group of composition.spatialGroups) {
+        if (group.objects) {
+          for (const childObj of group.objects) {
+            this.edges.push({
+              source: group.name,
+              target: childObj.name,
+              relation: "dictates_context",
+              weight: 1
+            });
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/compiler/social-causality.ts
+var DEFAULT_THRESHOLD = 0.5;
+var EDGE_KEY = (e) => `${e.source}\0${e.target}\0${e.relation}`;
+function mergeSocialCausalModels(agentDags, options = {}) {
+  const threshold = options.consensusThreshold ?? DEFAULT_THRESHOLD;
+  if (threshold <= 0 || threshold > 1) {
+    throw new RangeError(
+      `consensusThreshold must be in (0, 1]; got ${threshold}`
+    );
+  }
+  const agentCount = agentDags.length;
+  const minObservers = Math.min(
+    agentCount,
+    Math.floor(threshold * agentCount) + 1
+  );
+  if (agentCount === 0) {
+    return {
+      dag: emptyDag(options.modelName),
+      report: {
+        agents: 0,
+        threshold,
+        nodes: { kept: 0, dropped: 0 },
+        edges: { kept: 0, dropped: 0, smoothed: 0 }
+      }
+    };
+  }
+  const nodeObservers = /* @__PURE__ */ new Map();
+  const nodeRepresentative = /* @__PURE__ */ new Map();
+  for (const dag of agentDags) {
+    const seenInThisAgent = /* @__PURE__ */ new Set();
+    for (const node of dag.nodes) {
+      if (seenInThisAgent.has(node.id)) continue;
+      seenInThisAgent.add(node.id);
+      nodeObservers.set(node.id, (nodeObservers.get(node.id) ?? 0) + 1);
+      if (!nodeRepresentative.has(node.id)) {
+        nodeRepresentative.set(node.id, node);
+      }
+    }
+  }
+  const consensusNodes = [];
+  let nodesDropped = 0;
+  for (const [id, count] of nodeObservers) {
+    if (count >= minObservers) {
+      consensusNodes.push(cloneNode(nodeRepresentative.get(id)));
+    } else {
+      nodesDropped += 1;
+    }
+  }
+  const consensusNodeIds = new Set(consensusNodes.map((n) => n.id));
+  const edgeAccumulators = /* @__PURE__ */ new Map();
+  for (const dag of agentDags) {
+    const seenInThisAgent = /* @__PURE__ */ new Set();
+    for (const edge of dag.edges) {
+      const key = EDGE_KEY(edge);
+      if (seenInThisAgent.has(key)) continue;
+      seenInThisAgent.add(key);
+      let acc = edgeAccumulators.get(key);
+      if (!acc) {
+        acc = {
+          template: edge,
+          weights: [],
+          observers: 0,
+          distinctWeights: /* @__PURE__ */ new Set()
+        };
+        edgeAccumulators.set(key, acc);
+      }
+      acc.weights.push(edge.weight);
+      acc.distinctWeights.add(edge.weight);
+      acc.observers += 1;
+    }
+  }
+  const consensusEdges = [];
+  let edgesDropped = 0;
+  let edgesSmoothed = 0;
+  for (const [, acc] of edgeAccumulators) {
+    if (acc.observers < minObservers) {
+      edgesDropped += 1;
+      continue;
+    }
+    if (!consensusNodeIds.has(acc.template.source) || !consensusNodeIds.has(acc.template.target)) {
+      edgesDropped += 1;
+      continue;
+    }
+    const smoothed = acc.distinctWeights.size > 1;
+    if (smoothed) edgesSmoothed += 1;
+    consensusEdges.push({
+      source: acc.template.source,
+      target: acc.template.target,
+      relation: acc.template.relation,
+      weight: average(acc.weights)
+    });
+  }
+  return {
+    dag: {
+      metadata: {
+        model_name: options.modelName ?? "Social_Consensus_DAG",
+        generated_at: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      nodes: consensusNodes,
+      edges: consensusEdges
+    },
+    report: {
+      agents: agentCount,
+      threshold,
+      nodes: { kept: consensusNodes.length, dropped: nodesDropped },
+      edges: {
+        kept: consensusEdges.length,
+        dropped: edgesDropped,
+        smoothed: edgesSmoothed
+      }
+    }
+  };
+}
+function average(xs) {
+  let sum = 0;
+  for (const x of xs) sum += x;
+  return sum / xs.length;
+}
+function cloneNode(node) {
+  return {
+    id: node.id,
+    type: node.type,
+    do_capable: node.do_capable,
+    properties: { ...node.properties }
+  };
+}
+function emptyDag(modelName) {
+  return {
+    metadata: {
+      model_name: modelName ?? "Social_Consensus_DAG",
+      generated_at: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    nodes: [],
+    edges: []
+  };
+}
+
+// src/compiler/social-causality-byzantine.ts
+var DEFAULT_OUTLIER_SIGMA = 1.5;
+var DEFAULT_DECAY = 0.1;
+var DEFAULT_DROP_THRESHOLD = 0.3;
+var DEFAULT_MIN_CLUSTER = 3;
+var EDGE_KEY2 = (e) => `${e.source} ${e.target} ${e.relation}`;
+var AgentTrustLedger = class {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Get a snapshot of an agent's trust state. Returns undefined if the
+   * agent has never been observed.
+   */
+  get(agentId) {
+    const e = this.entries.get(agentId);
+    return e ? { ...e } : void 0;
+  }
+  /**
+   * Get a snapshot of every agent's trust state. Mutating the returned
+   * object does NOT mutate the ledger.
+   */
+  snapshot() {
+    const out = {};
+    for (const [id, e] of this.entries) out[id] = { ...e };
+    return out;
+  }
+  /**
+   * Forget an agent's history entirely. Use to pardon an agent that was
+   * dropped — see "Recovery semantics" in the file header.
+   */
+  reset(agentId) {
+    this.entries.delete(agentId);
+  }
+  /** Forget every agent. */
+  resetAll() {
+    this.entries.clear();
+  }
+  /** @internal — used by {@link byzantineResilientMerge}. */
+  observe(agentId, hostileThisEpoch, decay) {
+    let e = this.entries.get(agentId);
+    if (!e) {
+      e = { score: 1, epochs: 0, hostileEpochs: 0 };
+      this.entries.set(agentId, e);
+    }
+    e.epochs += 1;
+    if (hostileThisEpoch) {
+      e.hostileEpochs += 1;
+      e.score = Math.max(0, e.score - decay);
+    }
+  }
+  /** @internal — used by {@link byzantineResilientMerge}. */
+  isTrusted(agentId, threshold) {
+    const e = this.entries.get(agentId);
+    if (!e) return true;
+    return e.score >= threshold;
+  }
+};
+function byzantineResilientMerge(agentDags, ledger, options = {}) {
+  const sigma = options.outlierSigma ?? DEFAULT_OUTLIER_SIGMA;
+  const decay = options.decayPerEpoch ?? DEFAULT_DECAY;
+  const dropThreshold = options.dropThreshold ?? DEFAULT_DROP_THRESHOLD;
+  const minCluster = options.minClusterAgents ?? DEFAULT_MIN_CLUSTER;
+  if (sigma <= 0) {
+    throw new RangeError(`outlierSigma must be > 0; got ${sigma}`);
+  }
+  if (decay < 0 || decay > 1) {
+    throw new RangeError(`decayPerEpoch must be in [0, 1]; got ${decay}`);
+  }
+  if (dropThreshold < 0 || dropThreshold > 1) {
+    throw new RangeError(
+      `dropThreshold must be in [0, 1]; got ${dropThreshold}`
+    );
+  }
+  if (minCluster < 2 || !Number.isInteger(minCluster)) {
+    throw new RangeError(
+      `minClusterAgents must be an integer >= 2; got ${minCluster}`
+    );
+  }
+  const agentIds = /* @__PURE__ */ new Map();
+  const seenIds = /* @__PURE__ */ new Set();
+  agentDags.forEach((dag, idx) => {
+    let id = dag.metadata.model_name?.trim();
+    if (!id || seenIds.has(id)) {
+      id = `agent#${idx}`;
+    }
+    seenIds.add(id);
+    agentIds.set(dag, id);
+  });
+  const edgeObservations = /* @__PURE__ */ new Map();
+  for (const dag of agentDags) {
+    const agentId = agentIds.get(dag);
+    const seenInThisAgent = /* @__PURE__ */ new Set();
+    for (const edge of dag.edges) {
+      const key = EDGE_KEY2(edge);
+      if (seenInThisAgent.has(key)) continue;
+      seenInThisAgent.add(key);
+      const obs = edgeObservations.get(key) ?? [];
+      obs.push({ agentId, weight: edge.weight });
+      edgeObservations.set(key, obs);
+    }
+  }
+  const outliersByEdge = {};
+  const hostileThisEpoch = /* @__PURE__ */ new Set();
+  for (const [edgeKey, obs] of edgeObservations) {
+    if (obs.length < minCluster) continue;
+    const mean2 = obs.reduce((s, o) => s + o.weight, 0) / obs.length;
+    const variance = obs.reduce((s, o) => s + (o.weight - mean2) ** 2, 0) / obs.length;
+    const std = Math.sqrt(variance);
+    if (std === 0) continue;
+    const cutoff = sigma * std;
+    const outliers = [];
+    for (const o of obs) {
+      if (Math.abs(o.weight - mean2) > cutoff) {
+        outliers.push(o.agentId);
+        hostileThisEpoch.add(o.agentId);
+      }
+    }
+    if (outliers.length > 0) outliersByEdge[edgeKey] = outliers;
+  }
+  const seenThisEpoch = /* @__PURE__ */ new Set();
+  for (const dag of agentDags) {
+    const agentId = agentIds.get(dag);
+    if (seenThisEpoch.has(agentId)) continue;
+    seenThisEpoch.add(agentId);
+    ledger.observe(agentId, hostileThisEpoch.has(agentId), decay);
+  }
+  const dropped = [];
+  const survivors = [];
+  for (const dag of agentDags) {
+    const agentId = agentIds.get(dag);
+    if (ledger.isTrusted(agentId, dropThreshold)) {
+      survivors.push(dag);
+    } else {
+      dropped.push(agentId);
+    }
+  }
+  const merged = mergeSocialCausalModels(survivors, options);
+  return {
+    dag: merged.dag,
+    report: {
+      ledger: ledger.snapshot(),
+      dropped: Array.from(new Set(dropped)),
+      flaggedThisEpoch: Array.from(hostileThisEpoch),
+      outliersByEdge,
+      consensus: merged.report
+    }
+  };
+}
+
+// src/compiler/index.ts
 init_NodeServiceCompiler();
 init_DialectRegistry();
 init_registerBuiltinDialects();
 
-export { DialectRegistry, MCPConfigCompiler, Native2DCompiler, NextJSCompiler, NodeServiceCompiler, compileAllToNextJSAPI, compileToNextJSAPI, ensureDialectsBooted, registerBuiltinDialects };
+// src/compiler/FlatSemanticCompiler.ts
+init_CompilerBase();
+function isFlatSemanticCompilerOptions(value) {
+  if (!value || typeof value !== "object") return false;
+  return "format" in value || "generateDocs" in value || "docsOptions" in value || "provenanceHash" in value;
+}
+var FlatSemanticCompiler = class extends CompilerBase {
+  constructor() {
+    super(...arguments);
+    this.compilerName = "FlatSemanticCompiler";
+  }
+  compile(composition, agentToken, outputPath, sceneGraphOrOptions, options) {
+    this.validateCompilerAccess(agentToken, outputPath);
+    const compileOptions = options ?? (isFlatSemanticCompilerOptions(sceneGraphOrOptions) ? sceneGraphOrOptions : void 0);
+    const elements = composition.ui?.elements || composition.objects || [];
+    const traits = this.extractTraits(composition);
+    const canvasConfig = traits["2d_canvas"] || {};
+    const code = this.generateReactComponent(composition.name, elements, canvasConfig);
+    if (compileOptions?.generateDocs) {
+      return {
+        output: code,
+        documentation: this.generateDocumentation(composition, code, compileOptions.docsOptions)
+      };
+    }
+    return code;
+  }
+  extractTraits(obj) {
+    const map = {};
+    if (!obj.traits) return map;
+    for (const t of obj.traits) {
+      map[t.name] = t.config || {};
+    }
+    return map;
+  }
+  // ============================================================================
+  // CODE GENERATION
+  // ============================================================================
+  generateReactComponent(name, objects, _canvasConfig) {
+    const safeName = name.replace(/[^a-zA-Z0-9]/g, "");
+    const semanticNodes = objects.map((obj) => this.generateSemanticNode(obj)).join("\n            ");
+    return `import React, { useRef, useState, useEffect } from 'react';
+import { Canvas, useFrame } from '@react-three/fiber';
+import { Html, Float, Sparkles, MeshDistortMaterial } from '@react-three/drei';
+
+/**
+ * HoloScript V6 2D UI Revolution
+ * Flat-Semantic Projection of: ${name}
+ * 
+ * Auto-generated by FlatSemanticCompiler
+ */
+
+// Procedural Field Background Component
+function ProceduralField({ turbulence = 0.3, intensity = 1.0 }) {
+  const meshRef = useRef<any>(null);
+  useFrame((state) => {
+    if (meshRef.current) {
+      meshRef.current.rotation.x = state.clock.getElapsedTime() * 0.1 * turbulence;
+      meshRef.current.rotation.y = state.clock.getElapsedTime() * 0.15 * turbulence;
+    }
+  });
+
+  return (
+    <mesh ref={meshRef} scale={[15, 15, 1]} position={[0, 0, -5]}>
+      <planeGeometry args={[2, 2, 32, 32]} />
+      <MeshDistortMaterial 
+        color="#1a0b2e" 
+        emissive="#0a0515"
+        distort={turbulence} 
+        speed={intensity * 2} 
+        roughness={0.2}
+      />
+      <Sparkles count={100} scale={20} size={2} color="#8b5cf6" speed={0.4} opacity={0.5} />
+    </mesh>
+  );
+}
+
+export function ${safeName}Component() {
+  const [bountyPools, setBountyPools] = useState<Record<string, number>>({});
+
+  return (
+    <div className="holoscript-v6-root w-full h-screen bg-[#050505] overflow-hidden text-white font-sans">
+      <Canvas orthographic camera={{ zoom: 100, position: [0, 0, 100] }}>
+        <ambientLight intensity={0.5} />
+        <directionalLight position={[10, 10, 5]} intensity={1} />
+        
+        {/* Simulation Layer */}
+        <ProceduralField turbulence={0.3} intensity={1.0} />
+
+        {/* Semantic 2D Projection Layer */}
+        <Html fullscreen zIndexRange={[100, 0]} className="pointer-events-none">
+          <div className="w-full h-full relative pointer-events-auto overflow-y-auto">
+            ${semanticNodes}
+          </div>
+        </Html>
+      </Canvas>
+    </div>
+  );
+}
+
+export default ${safeName}Component;
+`;
+  }
+  generateSemanticNode(obj) {
+    const traits = this.extractTraits(obj);
+    !!traits["semantic_entity"];
+    const type = traits["semantic_entity"]?.type || "generic";
+    let classes = "relative ";
+    if (traits.tailwind?.classes) classes += traits.tailwind.classes + " ";
+    const layout = traits["semantic_layout"];
+    if (layout) {
+      const flow = layout.flow || "semantic";
+      if (flow === "cluster") classes += "flex flex-wrap gap-4 justify-center items-center ";
+      else if (flow === "priority") classes += "flex flex-col gap-3 ";
+      else if (flow === "radial")
+        classes += "grid place-items-center gap-4 p-8 rounded-full border border-white/10 ";
+      else classes += "flex flex-row gap-4 items-start ";
+      const spacing = layout.spacing || 12;
+      classes += `p-[${spacing}px] `;
+    }
+    const hasSwarm = !!traits["agent_attention"];
+    let rawChildren = obj.children || obj.objects || [];
+    if (rawChildren.length === 0 && traits["semantic_entity"]?.children) {
+      rawChildren = traits["semantic_entity"].children;
+    }
+    const childrenMarkup = rawChildren.map((child) => this.generateSemanticNode(child)).join("\n");
+    let content = traits.text?.content || "";
+    if (content)
+      content = "{`" + content.replace(new RegExp("`", "g"), "\\`").replace(/\\$/g, "\\\\$") + "`}";
+    if (type === "data-cluster" || type === "section") {
+      return '<section className="' + classes + '">\n' + content + "\n" + childrenMarkup + "\n</section>";
+    }
+    if (type === "metric-card") {
+      return '<div className="lift-card p-6 bg-white/5 border border-white/10 rounded-xl hover:bg-white/10 transition-all ' + classes + '">\n' + content + "\n" + childrenMarkup + "\n</div>";
+    }
+    let interactionProps = "";
+    if (traits["agent_attention"] && traits["agent_attention"].bounty_threshold) {
+      interactionProps = " onClick={() => alert('Bounty Negotiated: " + traits["agent_attention"].bounty_threshold + " credits')} ";
+    } else if (traits["intent_driven"]) {
+      interactionProps = " onClick={() => console.log('Intent Emitted: " + (traits["intent_driven"].intents?.[0] || "action") + "')} ";
+    }
+    if (traits.link || type === "link") {
+      return '<a href="' + (traits.link?.href || "#") + '" className="' + classes + '"' + interactionProps + ">\n" + content + "\n" + childrenMarkup + "\n</a>";
+    }
+    if (traits.image) {
+      return '<img src="' + traits.image.src + '" className="' + classes + '" alt="' + (traits.image.alt || "") + '" />';
+    }
+    const swarmHtml = hasSwarm ? '<div className="text-xs text-purple-400 mt-2 font-mono flex items-center gap-2"><span className="w-2 h-2 rounded-full bg-purple-500 animate-pulse"></span> Agent Swarm Active</div>' : "";
+    return '<div className="' + classes + '"' + interactionProps + ">\n" + content + "\n" + swarmHtml + "\n" + childrenMarkup + "\n</div>";
+  }
+};
+
+// src/compiler/dispatch/DispatchPolicy.ts
+var DispatchTier = /* @__PURE__ */ ((DispatchTier2) => {
+  DispatchTier2["TIER_1_NEUROMORPHIC"] = "tier-1-neuromorphic";
+  DispatchTier2["TIER_1_BROWSER"] = "tier-1-browser";
+  DispatchTier2["TIER_1_WASM"] = "tier-1-wasm";
+  DispatchTier2["TIER_2_SPECULATIVE"] = "tier-2-speculative";
+  DispatchTier2["TIER_3_CPU_DIRECT"] = "tier-3-cpu-direct";
+  return DispatchTier2;
+})(DispatchTier || {});
+var AlphaTracker = class {
+  constructor(size = 50) {
+    this.window = [];
+    this.size = size;
+  }
+  recordAttempt(success) {
+    this.window.push(success);
+    if (this.window.length > this.size) {
+      this.window.shift();
+    }
+  }
+  getAlpha() {
+    if (this.window.length === 0) return 0;
+    const successes = this.window.filter((s) => s).length;
+    return successes / this.window.length;
+  }
+  get windowLength() {
+    return this.window.length;
+  }
+};
+var DispatchPolicy = class {
+  constructor(config = {}) {
+    this.config = {
+      tier1BrowserEnabled: false,
+      tier1WasmEnabled: false,
+      tier1NeuromorphicEnabled: false,
+      tier2Enabled: false,
+      tier2AlphaThreshold: 0.85,
+      alphaWindowSize: 50,
+      ...config
+    };
+    this.alphaTracker = new AlphaTracker(this.config.alphaWindowSize);
+  }
+  /**
+   * Route an operation to the highest viable tier, falling back as needed.
+   */
+  async route(op) {
+    const start = performance.now();
+    let lastRejectionReason;
+    let lastRejectionMetrics;
+    if (this.config.tier1NeuromorphicEnabled) {
+      const decision2 = await this.tryTier1Neuromorphic(op);
+      if (decision2.accepted) {
+        decision2.metrics.latencyEstimateMs = performance.now() - start;
+        return decision2;
+      }
+      lastRejectionReason = decision2.metrics.fallbackReason;
+      lastRejectionMetrics = {
+        neuromorphicProbe: decision2.metrics.neuromorphicProbe
+      };
+    }
+    if (this.config.tier1BrowserEnabled) {
+      const decision2 = await this.tryTier1Browser(op);
+      if (decision2.accepted) {
+        decision2.metrics.latencyEstimateMs = performance.now() - start;
+        return decision2;
+      }
+      lastRejectionReason = decision2.metrics.fallbackReason;
+      lastRejectionMetrics = void 0;
+    }
+    if (this.config.tier1WasmEnabled) {
+      const decision2 = await this.tryTier1Wasm(op);
+      if (decision2.accepted) {
+        decision2.metrics.latencyEstimateMs = performance.now() - start;
+        return decision2;
+      }
+      lastRejectionReason = decision2.metrics.fallbackReason;
+      lastRejectionMetrics = {
+        wasmProbe: decision2.metrics.wasmProbe,
+        wasmEmulator: decision2.metrics.wasmEmulator
+      };
+    }
+    if (this.config.tier2Enabled) {
+      const decision2 = await this.tryTier2(op);
+      if (decision2.accepted) {
+        decision2.metrics.latencyEstimateMs = performance.now() - start;
+        return decision2;
+      }
+      lastRejectionReason = decision2.metrics.fallbackReason;
+      lastRejectionMetrics = {
+        alpha: decision2.metrics.alpha,
+        verifierPassed: decision2.metrics.verifierPassed,
+        traitEquivalence: decision2.metrics.traitEquivalence
+      };
+    }
+    const decision = await this.fallbackTier3(
+      op,
+      lastRejectionReason ?? "No higher tier accepted or enabled",
+      lastRejectionMetrics
+    );
+    decision.metrics.latencyEstimateMs = performance.now() - start;
+    return decision;
+  }
+  /** Current speculative-decoding alpha (Tier-2 acceptance rate). */
+  getAlpha() {
+    return this.alphaTracker.getAlpha();
+  }
+  // ---------------------------------------------------------------------------
+  // TIER ATTEMPTERS
+  // ---------------------------------------------------------------------------
+  async tryTier1Neuromorphic(op) {
+    const probe = await this.probeNeuromorphicRuntime();
+    const deviceMatches = probe.available && (!this.config.tier1NeuromorphicDevice || probe.device === this.config.tier1NeuromorphicDevice);
+    const traitCompatible = this.isTraitSnnCompatible(op.trait);
+    const accepted = deviceMatches && traitCompatible;
+    const reason = accepted ? void 0 : this.describeNeuromorphicRejection(probe, traitCompatible);
+    return this.buildDecision("tier-1-neuromorphic" /* TIER_1_NEUROMORPHIC */, accepted, op, reason, void 0, {
+      neuromorphicProbe: probe
+    });
+  }
+  async tryTier1Browser(op) {
+    const available = isWebGpuEnvironmentPresent();
+    const traitCompatible = this.isTraitSnnCompatible(op.trait);
+    if (!available || !traitCompatible) {
+      const reason = !available ? "WebGPU not available" : "Trait is not mapped to the SNN/WebGPU hot path";
+      return this.buildDecision("tier-1-browser" /* TIER_1_BROWSER */, false, op, reason);
+    }
+    const executor = this.config.tier1BrowserExecutor ?? runTier1BrowserSnn;
+    try {
+      const result = await executor(op);
+      const reason = result.accepted ? void 0 : result.reason ?? "Tier-1 browser executor rejected dispatch";
+      return this.buildDecision(
+        "tier-1-browser" /* TIER_1_BROWSER */,
+        result.accepted,
+        op,
+        reason,
+        void 0,
+        { browserExecutor: result }
+      );
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return this.buildDecision("tier-1-browser" /* TIER_1_BROWSER */, false, op, message, void 0, {
+        browserExecutor: { accepted: false, source: "tier-1-browser-error", reason: message }
+      });
+    }
+  }
+  async tryTier1Wasm(op) {
+    const runtime = await this.probeWasmRuntime();
+    const traitCompatible = this.isTraitSnnCompatible(op.trait);
+    if (!runtime.available || !traitCompatible) {
+      const reason2 = this.describeWasmRejection(runtime, traitCompatible);
+      return this.buildDecision("tier-1-wasm" /* TIER_1_WASM */, false, op, reason2, void 0, {
+        wasmProbe: runtime
+      });
+    }
+    const emulator = await this.runTier1WasmEmulator(op, runtime);
+    const reason = emulator.accepted ? void 0 : emulator.reason ?? "compiler-wasm SNN emulator rejected dispatch";
+    return this.buildDecision(
+      "tier-1-wasm" /* TIER_1_WASM */,
+      emulator.accepted,
+      op,
+      reason,
+      void 0,
+      {
+        wasmProbe: runtime,
+        wasmEmulator: emulator
+      }
+    );
+  }
+  async tryTier2(op) {
+    const provider = this.config.llmProposalProvider;
+    const proposal = provider ? await provider(op) ?? null : null;
+    if (!proposal) {
+      this.alphaTracker.recordAttempt(false);
+      const alpha2 = this.alphaTracker.getAlpha();
+      return this.buildDecision(
+        "tier-2-speculative" /* TIER_2_SPECULATIVE */,
+        false,
+        op,
+        `LLM proposal failed; alpha ${alpha2.toFixed(2)} < threshold ${this.config.tier2AlphaThreshold}`,
+        alpha2,
+        {
+          verifierPassed: false,
+          traitEquivalence: {
+            equivalent: false,
+            source: "dispatch-policy",
+            reason: "LLM proposal provider returned no output",
+            score: 0
+          }
+        }
+      );
+    }
+    const verifierPassed = await this.runCpuVerifier(op, proposal);
+    const tier3Output = await this.runTier3CpuDirect(op);
+    const traitEquivalence = await this.evaluateTraitEquivalence(op, proposal, tier3Output);
+    this.alphaTracker.recordAttempt(traitEquivalence.equivalent);
+    const alpha = this.alphaTracker.getAlpha();
+    const accepted = verifierPassed && traitEquivalence.equivalent && alpha >= this.config.tier2AlphaThreshold;
+    const reason = accepted ? void 0 : this.describeTier2Rejection(verifierPassed, traitEquivalence, alpha);
+    return this.buildDecision("tier-2-speculative" /* TIER_2_SPECULATIVE */, accepted, op, reason, alpha, {
+      verifierPassed,
+      traitEquivalence
+    });
+  }
+  async fallbackTier3(op, reason, extraMetrics = {}) {
+    return this.buildDecision(
+      "tier-3-cpu-direct" /* TIER_3_CPU_DIRECT */,
+      true,
+      op,
+      reason,
+      void 0,
+      extraMetrics
+    );
+  }
+  // ---------------------------------------------------------------------------
+  // VERIFIERS & HELPERS
+  // ---------------------------------------------------------------------------
+  async probeNeuromorphicRuntime() {
+    const probe = this.config.neuromorphicRuntimeProbe ?? detectNeuromorphicRuntime;
+    return probe(this.config.tier1NeuromorphicDevice);
+  }
+  async probeWasmRuntime() {
+    const probe = this.config.tier1WasmRuntimeProbe ?? detectWasmRuntime;
+    return probe();
+  }
+  async runTier1WasmEmulator(op, runtime) {
+    const executor = this.config.tier1WasmExecutor ?? runCompilerWasmSnnEmulator;
+    try {
+      return await executor(op, runtime);
+    } catch (error) {
+      return {
+        accepted: false,
+        source: "compiler-wasm-snn-emulator",
+        runtime,
+        reason: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  describeNeuromorphicRejection(probe, traitCompatible) {
+    if (!probe.available) {
+      return probe.reason ?? "Neuromorphic runtime device not discovered";
+    }
+    if (this.config.tier1NeuromorphicDevice && probe.device !== this.config.tier1NeuromorphicDevice) {
+      return `NIR runtime discovered ${probe.device ?? "unknown"} but requires ${this.config.tier1NeuromorphicDevice}`;
+    }
+    if (!traitCompatible) {
+      return "Trait is not mapped to the SNN/NIR hot path";
+    }
+    return "Neuromorphic runtime probe did not accept dispatch";
+  }
+  describeWasmRejection(runtime, traitCompatible) {
+    if (!runtime.available) {
+      return runtime.reason ?? "WebAssembly runtime unavailable for Tier-1 WASM fallback";
+    }
+    if (!traitCompatible) {
+      return "Trait is not mapped to the SNN/WASM hot path";
+    }
+    return "compiler-wasm SNN emulator did not accept dispatch";
+  }
+  isTraitSnnCompatible(trait) {
+    const snnTraits = /* @__PURE__ */ new Set(["grabbable", "hoverable", "clickable", "draggable", "throwable"]);
+    return snnTraits.has(trait);
+  }
+  async runCpuVerifier(op, _proposal) {
+    let anyVerifierWired = false;
+    if (this.config.effectVerifier) {
+      anyVerifierWired = true;
+      const effectResult = await this.config.effectVerifier([op.trait]);
+      if (!effectResult || !effectResult.passed) return false;
+    }
+    if (op.manifest && this.config.simulationContractVerifier) {
+      anyVerifierWired = true;
+      const scPassed = await this.config.simulationContractVerifier(op.manifest);
+      if (!scPassed) return false;
+    } else if (op.manifest) {
+      anyVerifierWired = true;
+      try {
+        assertHoloMapManifestContract(op.manifest);
+      } catch {
+        return false;
+      }
+    }
+    return anyVerifierWired;
+  }
+  async runTier3CpuDirect(op) {
+    const executor = this.config.tier3CpuExecutor ?? runTier3CpuDirectExecutor;
+    return executor(op);
+  }
+  async evaluateTraitEquivalence(op, proposal, tier3Output) {
+    const oracle = this.config.traitEquivalenceOracle ?? defaultTraitEquivalenceOracle;
+    try {
+      return await oracle({ operation: op, proposal, tier3Output });
+    } catch (error) {
+      return {
+        equivalent: false,
+        source: "trait-equivalence-oracle",
+        reason: error instanceof Error ? error.message : String(error),
+        score: 0
+      };
+    }
+  }
+  describeTier2Rejection(verifierPassed, equivalence, alpha) {
+    const parts = [
+      `Verifier ${verifierPassed ? "passed" : "rejected"}`,
+      `equivalence ${equivalence.equivalent ? "passed" : "failed"}`,
+      `alpha ${alpha.toFixed(2)} < threshold ${this.config.tier2AlphaThreshold}`
+    ];
+    if (equivalence.reason) {
+      parts.push(equivalence.reason);
+    }
+    return parts.join("; ");
+  }
+  // ---------------------------------------------------------------------------
+  // PROVENANCE BUILDER
+  // ---------------------------------------------------------------------------
+  async buildDecision(tier, accepted, op, fallbackReason, alpha, extraMetrics = {}) {
+    const metrics = {
+      tierAttempted: tier,
+      tierAccepted: accepted,
+      fallbackReason,
+      latencyEstimateMs: 0,
+      alpha,
+      ...extraMetrics
+    };
+    const provenanceContext = op.provenanceContext ?? {
+      authorityLevel: 50,
+      // AGENT default
+      sourceType: "system"
+    };
+    const provenance = {
+      value: { tier, accepted, nodeId: op.nodeId, trait: op.trait },
+      source: "dispatch-policy",
+      context: provenanceContext
+    };
+    const replayFingerprint = await this.hashDecision(provenance);
+    return {
+      tier,
+      accepted,
+      provenance,
+      metrics,
+      replayFingerprint
+    };
+  }
+  async hashDecision(provenance) {
+    const value = provenance.value;
+    const canonical = stableStringify(value);
+    return `sha256:${await sha256Hex(canonical)}`;
+  }
+};
+function createTier3CpuDirectOutput(op) {
+  return {
+    trait: op.trait,
+    nodeId: op.nodeId,
+    config: op.config ?? {}
+  };
+}
+async function runTier3CpuDirectExecutor(op) {
+  const evaluator = new ExpressionEvaluator(op.config ?? {});
+  const evaluatedConfig = {};
+  for (const [key, value] of Object.entries(op.config ?? {})) {
+    if (typeof value === "string") {
+      evaluatedConfig[key] = evaluator.evaluate(value);
+    } else {
+      evaluatedConfig[key] = value;
+    }
+  }
+  return {
+    trait: op.trait,
+    nodeId: op.nodeId,
+    config: evaluatedConfig
+  };
+}
+async function runTier1BrowserSnn(op) {
+  try {
+    const snnWebgpu = await import('@holoscript/snn-webgpu');
+    const { GPUContext, LIFSimulator, DEFAULT_LIF_PARAMS } = snnWebgpu;
+    const ctx = new GPUContext();
+    await ctx.initialize();
+    const simulator = new LIFSimulator(ctx, 1, DEFAULT_LIF_PARAMS);
+    await simulator.initialize();
+    const input = stableStringify({ trait: op.trait, nodeId: op.nodeId, config: op.config });
+    const steps = Math.max(1, Math.min(64, input.length));
+    await simulator.stepN(steps);
+    return { accepted: true, source: "snn-webgpu", steps };
+  } catch (error) {
+    return {
+      accepted: false,
+      source: "snn-webgpu",
+      reason: normalizeTier1BrowserReason(error)
+    };
+  }
+}
+function normalizeTier1BrowserReason(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (message.includes("@holoscript/snn-webgpu") && message.includes("Cannot find package")) {
+    return `WebGPU SNN runtime unavailable: ${message}`;
+  }
+  return message;
+}
+function detectWasmRuntime() {
+  const runtime = globalThis;
+  const validate = runtime.WebAssembly?.validate;
+  if (typeof validate !== "function") {
+    return {
+      available: false,
+      source: "global-webassembly",
+      reason: "WebAssembly.validate is unavailable"
+    };
+  }
+  const moduleValidated = validate(MINIMAL_WASM_MODULE);
+  return {
+    available: moduleValidated,
+    source: "global-webassembly",
+    moduleValidated,
+    reason: moduleValidated ? void 0 : "Minimal WebAssembly module failed validation"
+  };
+}
+function runCompilerWasmSnnEmulator(op, runtime) {
+  if (!runtime.available) {
+    return {
+      accepted: false,
+      source: "compiler-wasm-snn-emulator",
+      runtime,
+      reason: runtime.reason ?? "WebAssembly runtime unavailable"
+    };
+  }
+  const input = stableStringify({
+    trait: op.trait,
+    nodeId: op.nodeId,
+    config: op.config ?? {}
+  });
+  const steps = Math.max(1, Math.min(64, input.length));
+  const state = emulateLifSteps(input, steps);
+  return {
+    accepted: true,
+    source: "compiler-wasm-snn-emulator",
+    runtime,
+    steps,
+    spikeCount: state.spikeCount,
+    membranePotential: state.membranePotential,
+    inputChecksum: state.inputChecksum
+  };
+}
+async function defaultTraitEquivalenceOracle(input) {
+  const proposalCanonical = stableStringify(input.proposal);
+  const tier3Canonical = stableStringify(input.tier3Output);
+  const equivalent = proposalCanonical === tier3Canonical;
+  return {
+    equivalent,
+    source: "canonical-json",
+    reason: equivalent ? "canonical outputs match" : "canonical outputs differ",
+    score: equivalent ? 1 : 0,
+    proposalFingerprint: `sha256:${await sha256Hex(proposalCanonical)}`,
+    tier3Fingerprint: `sha256:${await sha256Hex(tier3Canonical)}`
+  };
+}
+function stableStringify(value) {
+  return JSON.stringify(canonicalize(value)) ?? "undefined";
+}
+function canonicalize(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => canonicalize(entry));
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  const record = value;
+  const sorted = {};
+  for (const key of Object.keys(record).sort()) {
+    sorted[key] = canonicalize(record[key]);
+  }
+  return sorted;
+}
+async function sha256Hex(input) {
+  const subtle = globalThis.crypto?.subtle;
+  if (subtle) {
+    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");
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+var MINIMAL_WASM_MODULE = new Uint8Array([
+  0,
+  97,
+  115,
+  109,
+  1,
+  0,
+  0,
+  0
+]);
+function emulateLifSteps(input, steps) {
+  const vRest = -65;
+  const vReset = -65;
+  const vThreshold = -50;
+  const tau = 12;
+  let membranePotential = vRest;
+  let spikeCount = 0;
+  let inputChecksum = 2166136261;
+  for (let i = 0; i < steps; i += 1) {
+    const code = input.charCodeAt(i % input.length);
+    inputChecksum ^= code;
+    inputChecksum = Math.imul(inputChecksum, 16777619) >>> 0;
+    const inputCurrent = 12 + code % 17;
+    membranePotential += (vRest - membranePotential + inputCurrent) / tau;
+    if (membranePotential >= vThreshold) {
+      spikeCount += 1;
+      membranePotential = vReset;
+    }
+  }
+  return {
+    spikeCount,
+    membranePotential: Number(membranePotential.toFixed(6)),
+    inputChecksum
+  };
+}
+function detectNeuromorphicRuntime(preferredDevice) {
+  const globalDevices = readGlobalNeuromorphicDevices();
+  const envDevices = readEnvNeuromorphicDevices();
+  const devices = [...globalDevices, ...envDevices].filter((device) => device.available !== false).sort((a, b) => deviceRank(a.target) - deviceRank(b.target));
+  const selected = preferredDevice ? devices.find((device) => device.target === preferredDevice) : devices[0];
+  if (selected) {
+    return {
+      available: true,
+      device: selected.target,
+      source: selected.source ?? "runtime",
+      devices
+    };
+  }
+  return {
+    available: false,
+    source: devices.length ? "runtime" : "none",
+    reason: preferredDevice ? `No ${preferredDevice} NIR runtime device discovered` : "No NIR runtime device discovered",
+    devices
+  };
+}
+function readGlobalNeuromorphicDevices() {
+  const runtime = globalThis;
+  return parseNeuromorphicDevices(runtime.__HOLOSCRIPT_NIR_DEVICES__, "global");
+}
+function readEnvNeuromorphicDevices() {
+  const env = typeof process !== "undefined" ? process.env : void 0;
+  if (!env) return [];
+  const configured = parseNeuromorphicDevices(env.HOLOSCRIPT_NIR_DEVICE ?? env.NIR_DEVICE, "env");
+  const detected = [...configured];
+  if (env.LOIHI2_HOST) {
+    detected.push({ target: "loihi", id: env.LOIHI2_HOST, available: true, source: "env" });
+  }
+  if (env.SPINNAKER_BOARD) {
+    detected.push({ target: "spinnaker", id: env.SPINNAKER_BOARD, available: true, source: "env" });
+  }
+  if (env.SYNSENSE_DEVICE) {
+    detected.push({ target: "synsense", id: env.SYNSENSE_DEVICE, available: true, source: "env" });
+  }
+  if (env.AKIDA_DEVICE) {
+    detected.push({ target: "akida", id: env.AKIDA_DEVICE, available: true, source: "env" });
+  }
+  return detected;
+}
+function parseNeuromorphicDevices(value, source) {
+  if (!value) return [];
+  if (typeof value === "string") {
+    return value.split(",").map((entry) => toNeuromorphicDevice(entry.trim(), source)).filter((device) => Boolean(device));
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => toNeuromorphicDevice(entry, source)).filter((device) => Boolean(device));
+  }
+  return [];
+}
+function toNeuromorphicDevice(value, source) {
+  if (typeof value === "string") {
+    const target2 = normalizeNeuromorphicTarget(value);
+    return target2 ? { target: target2, available: true, source } : null;
+  }
+  if (!value || typeof value !== "object") return null;
+  const record = value;
+  const target = normalizeNeuromorphicTarget(record.target ?? record.device ?? record.kind);
+  if (!target) return null;
+  return {
+    target,
+    id: typeof record.id === "string" ? record.id : void 0,
+    available: record.available === false ? false : true,
+    source: typeof record.source === "string" ? record.source : source
+  };
+}
+function normalizeNeuromorphicTarget(value) {
+  if (typeof value !== "string") return null;
+  const normalized = value.toLowerCase().replace(/[\s_-]+/g, "");
+  if (normalized === "loihi" || normalized === "loihi2") return "loihi";
+  if (normalized === "spinnaker" || normalized === "spinnaker2") return "spinnaker";
+  if (normalized === "synsense" || normalized === "synsensespeck" || normalized === "synsensexylo") {
+    return "synsense";
+  }
+  if (normalized === "akida") return "akida";
+  return null;
+}
+function deviceRank(device) {
+  return ["loihi", "spinnaker", "synsense", "akida"].indexOf(device);
+}
+
+// src/compiler/dispatch/DispatchPolicyBenchmark.ts
+var DEFAULT_ITERATIONS = 100;
+var DEFAULT_WARMUP_ITERATIONS = 10;
+var DEFAULT_DISPATCH_LATENCY_OPERATION = {
+  trait: "grabbable",
+  nodeId: "dispatch-policy-latency-benchmark"
+};
+function createDefaultDispatchLatencyScenarios(options = {}) {
+  const alphaWindowSize = (options.iterations ?? DEFAULT_ITERATIONS) + (options.warmupIterations ?? DEFAULT_WARMUP_ITERATIONS);
+  return [
+    {
+      id: "tier-1-neuromorphic-synsense",
+      tier: "tier-1-neuromorphic" /* TIER_1_NEUROMORPHIC */,
+      config: {
+        tier1NeuromorphicEnabled: true,
+        tier1NeuromorphicDevice: "synsense",
+        neuromorphicRuntimeProbe: async () => ({
+          available: true,
+          device: "synsense",
+          source: "dispatch-latency-benchmark",
+          devices: [{ target: "synsense", id: "benchmark-synsense", source: "benchmark" }]
+        })
+      }
+    },
+    {
+      id: "tier-1-browser-webgpu",
+      tier: "tier-1-browser" /* TIER_1_BROWSER */,
+      config: {
+        tier1BrowserEnabled: true
+      }
+    },
+    {
+      id: "tier-1-wasm-fallback",
+      tier: "tier-1-wasm" /* TIER_1_WASM */,
+      config: {
+        tier1WasmEnabled: true
+      }
+    },
+    {
+      id: "tier-2-speculative",
+      tier: "tier-2-speculative" /* TIER_2_SPECULATIVE */,
+      config: {
+        tier2Enabled: true,
+        llmProposalProvider: (op) => createTier3CpuDirectOutput(op),
+        tier2AlphaThreshold: 0,
+        alphaWindowSize,
+        effectVerifier: async () => ({ passed: true })
+      }
+    },
+    {
+      id: "tier-3-cpu-direct",
+      tier: "tier-3-cpu-direct" /* TIER_3_CPU_DIRECT */,
+      config: {
+        tier1BrowserEnabled: false,
+        tier1NeuromorphicEnabled: false,
+        tier2Enabled: false
+      }
+    }
+  ];
+}
+async function runDispatchPolicyLatencyBenchmark(options = {}) {
+  const iterations = options.iterations ?? DEFAULT_ITERATIONS;
+  const warmupIterations = options.warmupIterations ?? DEFAULT_WARMUP_ITERATIONS;
+  const operation = options.operation ?? DEFAULT_DISPATCH_LATENCY_OPERATION;
+  const scenarios = options.scenarios ?? createDefaultDispatchLatencyScenarios({ iterations, warmupIterations });
+  const summaries = [];
+  for (const scenario of scenarios) {
+    const policy = new DispatchPolicy(scenario.config);
+    const scenarioOperation = scenario.operation ?? operation;
+    for (let i = 0; i < warmupIterations; i += 1) {
+      await policy.route(scenarioOperation);
+    }
+    const samples = [];
+    for (let i = 0; i < iterations; i += 1) {
+      samples.push(await measureDispatchSample(policy, scenario, scenarioOperation, i, options.now));
+    }
+    summaries.push(summarizeDispatchSamples(scenario, samples));
+  }
+  return {
+    operationTrait: operation.trait,
+    iterations,
+    warmupIterations,
+    summaries,
+    recommendation: recommendDispatchPolicyDefaults(summaries)
+  };
+}
+function recommendDispatchPolicyDefaults(summaries) {
+  const tier2 = summaries.find((summary) => summary.requestedTier === "tier-2-speculative" /* TIER_2_SPECULATIVE */);
+  const tier3 = summaries.find((summary) => summary.requestedTier === "tier-3-cpu-direct" /* TIER_3_CPU_DIRECT */);
+  if (!tier2) {
+    return {
+      tier2DefaultEnabled: false,
+      reason: "Tier 2 benchmark summary missing; keep speculative dispatch disabled by default."
+    };
+  }
+  if (!tier3) {
+    return {
+      tier2DefaultEnabled: false,
+      reason: "Tier 3 CPU-direct baseline missing; keep speculative dispatch disabled by default."
+    };
+  }
+  const tier2Comparable = tier2.acceptedSamples > 0;
+  const tier3Comparable = tier3.acceptedSamples > 0;
+  if (!tier2Comparable || !tier3Comparable) {
+    return {
+      tier2DefaultEnabled: false,
+      reason: "Tier 2 or Tier 3 did not accept benchmark samples; keep speculative dispatch disabled by default.",
+      tier2MeanLatencyMs: tier2.meanLatencyMs,
+      tier3MeanLatencyMs: tier3.meanLatencyMs,
+      tier2P95LatencyMs: tier2.p95LatencyMs,
+      tier3P95LatencyMs: tier3.p95LatencyMs
+    };
+  }
+  const tier2Faster = tier2.meanLatencyMs < tier3.meanLatencyMs && tier2.p95LatencyMs < tier3.p95LatencyMs;
+  if (!tier2Faster) {
+    return {
+      tier2DefaultEnabled: false,
+      reason: "Tier 2 speculative dispatch is not faster than Tier 3 CPU direct on mean and p95 latency; keep Tier 2 disabled by default.",
+      tier2MeanLatencyMs: tier2.meanLatencyMs,
+      tier3MeanLatencyMs: tier3.meanLatencyMs,
+      tier2P95LatencyMs: tier2.p95LatencyMs,
+      tier3P95LatencyMs: tier3.p95LatencyMs
+    };
+  }
+  return {
+    tier2DefaultEnabled: true,
+    reason: "Tier 2 speculative dispatch beat Tier 3 CPU direct on mean and p95 latency.",
+    tier2MeanLatencyMs: tier2.meanLatencyMs,
+    tier3MeanLatencyMs: tier3.meanLatencyMs,
+    tier2P95LatencyMs: tier2.p95LatencyMs,
+    tier3P95LatencyMs: tier3.p95LatencyMs
+  };
+}
+function formatDispatchLatencyBenchmarkReport(report) {
+  const lines = [
+    `DispatchPolicy @${report.operationTrait} latency benchmark`,
+    `iterations=${report.iterations} warmup=${report.warmupIterations}`,
+    "",
+    "requested tier | accepted samples | mean ms | p50 ms | p95 ms | max ms | accepted tiers"
+  ];
+  for (const summary of report.summaries) {
+    lines.push(
+      [
+        summary.requestedTier,
+        `${summary.acceptedSamples}/${summary.samples}`,
+        formatMs(summary.meanLatencyMs),
+        formatMs(summary.p50LatencyMs),
+        formatMs(summary.p95LatencyMs),
+        formatMs(summary.maxLatencyMs),
+        formatTierCounts(summary.acceptedTierCounts)
+      ].join(" | ")
+    );
+  }
+  lines.push("");
+  lines.push(
+    `Tier 2 default: ${report.recommendation.tier2DefaultEnabled ? "enabled" : "disabled"}`
+  );
+  lines.push(report.recommendation.reason);
+  return lines.join("\n");
+}
+async function measureDispatchSample(policy, scenario, operation, iteration, now) {
+  const clock = now ?? (() => performance.now());
+  const started = clock();
+  const decision = await policy.route(operation);
+  const latencyMs = Math.max(0, clock() - started);
+  return toLatencySample(iteration, scenario.tier, decision, latencyMs);
+}
+function toLatencySample(iteration, requestedTier, decision, latencyMs) {
+  return {
+    iteration,
+    requestedTier,
+    acceptedTier: decision.tier,
+    accepted: decision.accepted,
+    latencyMs,
+    decisionLatencyMs: decision.metrics.latencyEstimateMs,
+    fallbackReason: decision.metrics.fallbackReason,
+    alpha: decision.metrics.alpha,
+    replayFingerprint: decision.replayFingerprint
+  };
+}
+function summarizeDispatchSamples(scenario, samples) {
+  const latencies = samples.map((sample) => sample.latencyMs).sort((a, b) => a - b);
+  const acceptedTierCounts = {};
+  const fallbackReasons = {};
+  let acceptedSamples = 0;
+  for (const sample of samples) {
+    acceptedTierCounts[sample.acceptedTier] = (acceptedTierCounts[sample.acceptedTier] ?? 0) + 1;
+    if (sample.accepted) acceptedSamples += 1;
+    if (sample.fallbackReason) {
+      fallbackReasons[sample.fallbackReason] = (fallbackReasons[sample.fallbackReason] ?? 0) + 1;
+    }
+  }
+  return {
+    id: scenario.id,
+    requestedTier: scenario.tier,
+    samples: samples.length,
+    acceptedSamples,
+    acceptedTierCounts,
+    fallbackReasons,
+    minLatencyMs: latencies[0] ?? 0,
+    meanLatencyMs: mean(latencies),
+    p50LatencyMs: percentile(latencies, 0.5),
+    p95LatencyMs: percentile(latencies, 0.95),
+    maxLatencyMs: latencies[latencies.length - 1] ?? 0
+  };
+}
+function mean(values) {
+  if (values.length === 0) return 0;
+  return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+function percentile(sortedValues, percentileValue) {
+  if (sortedValues.length === 0) return 0;
+  const index = Math.min(
+    sortedValues.length - 1,
+    Math.max(0, Math.ceil(sortedValues.length * percentileValue) - 1)
+  );
+  return sortedValues[index] ?? 0;
+}
+function formatMs(value) {
+  return value.toFixed(3);
+}
+function formatTierCounts(counts) {
+  return Object.entries(counts).map(([tier, count]) => `${tier}:${count}`).join(",");
+}
+
+// src/compiler/MatterpakCompiler.ts
+init_CompilerBase();
+function parseOBJExtended(text) {
+  const allVertices = [];
+  const allNormals = [];
+  const allUVs = [];
+  const groups = [];
+  let currentGroup = null;
+  let currentMaterial;
+  function flushGroup() {
+    if (currentGroup && (currentGroup.triangles.length > 0 || currentGroup.vertices.length > 0)) {
+      groups.push(currentGroup);
+    }
+  }
+  function startGroup(name) {
+    flushGroup();
+    currentGroup = {
+      name,
+      vertices: new Float64Array(0),
+      normals: new Float64Array(0),
+      uvs: new Float64Array(0),
+      triangles: new Uint32Array(0),
+      materialName: currentMaterial
+    };
+  }
+  const lines = text.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line.length === 0 || line.startsWith("#")) continue;
+    const parts = line.split(/\s+/);
+    const cmd = parts[0];
+    if (cmd === "v" && parts.length >= 4) {
+      allVertices.push(
+        parseFloat(parts[1]),
+        parseFloat(parts[2]),
+        parseFloat(parts[3])
+      );
+    } else if (cmd === "vn" && parts.length >= 4) {
+      allNormals.push(
+        parseFloat(parts[1]),
+        parseFloat(parts[2]),
+        parseFloat(parts[3])
+      );
+    } else if (cmd === "vt" && parts.length >= 3) {
+      allUVs.push(
+        parseFloat(parts[1]),
+        parseFloat(parts[2])
+      );
+    } else if (cmd === "g" || cmd === "o") {
+      const name = parts.slice(1).join(" ") || `group_${groups.length}`;
+      startGroup(name);
+    } else if (cmd === "usemtl" && parts.length >= 2) {
+      currentMaterial = parts[1];
+      const grp = currentGroup;
+      if (grp !== null) {
+        grp.materialName = currentMaterial;
+      }
+    } else if (cmd === "f" && parts.length >= 4) {
+      if (!currentGroup) {
+        startGroup("default");
+      }
+      const indices = parts.slice(1).map((p) => {
+        const vStr = p.split("/")[0];
+        const vIdx = parseInt(vStr, 10);
+        return vIdx > 0 ? vIdx - 1 : allVertices.length / 3 + vIdx;
+      });
+      for (let t = 1; t < indices.length - 1; t++) {
+        currentGroup.triangles = appendTri(currentGroup.triangles, indices[0], indices[t], indices[t + 1]);
+      }
+    }
+  }
+  flushGroup();
+  for (const g of groups) {
+    const usedVerts = /* @__PURE__ */ new Set();
+    for (let i = 0; i < g.triangles.length; i++) {
+      usedVerts.add(g.triangles[i]);
+    }
+    const remap = /* @__PURE__ */ new Map();
+    let next = 0;
+    const verts = [];
+    for (const idx of usedVerts) {
+      remap.set(idx, next++);
+      verts.push(
+        allVertices[idx * 3],
+        allVertices[idx * 3 + 1],
+        allVertices[idx * 3 + 2]
+      );
+    }
+    g.vertices = new Float64Array(verts);
+    for (let i = 0; i < g.triangles.length; i++) {
+      g.triangles[i] = remap.get(g.triangles[i]);
+    }
+  }
+  return groups.length > 0 ? groups : [{
+    name: "default",
+    vertices: new Float64Array(allVertices),
+    normals: new Float64Array(allNormals),
+    uvs: new Float64Array(allUVs),
+    triangles: new Uint32Array(0),
+    materialName: currentMaterial
+  }];
+}
+function appendTri(arr, a, b, c) {
+  const next = new Uint32Array(arr.length + 3);
+  next.set(arr);
+  next[arr.length] = a;
+  next[arr.length + 1] = b;
+  next[arr.length + 2] = c;
+  return next;
+}
+function parseMTL(text) {
+  const materials = /* @__PURE__ */ new Map();
+  let current = null;
+  const lines = text.split("\n");
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (line.length === 0 || line.startsWith("#")) continue;
+    const parts = line.split(/\s+/);
+    const cmd = parts[0];
+    if (cmd === "newmtl" && parts.length >= 2) {
+      current = parts[1];
+      materials.set(current, {
+        baseColor: [0.8, 0.8, 0.8],
+        metallic: 0,
+        roughness: 0.5
+      });
+    } else if (current) {
+      const mat = materials.get(current);
+      if (cmd === "Kd" && parts.length >= 4) {
+        mat.baseColor = [
+          parseFloat(parts[1]),
+          parseFloat(parts[2]),
+          parseFloat(parts[3])
+        ];
+      } else if (cmd === "map_Kd" && parts.length >= 2) {
+        mat.textureMap = parts.slice(1).join(" ");
+      } else if (cmd === "map_Bump" && parts.length >= 2) {
+        mat.normalMap = parts.slice(1).join(" ");
+      }
+      if (cmd === "Ns" && parts.length >= 2) {
+        const ns = parseFloat(parts[1]);
+        mat.roughness = Math.max(0, 1 - ns / 1e3);
+      }
+    }
+  }
+  return { materials };
+}
+function parseXYZ(text) {
+  const points = [];
+  const colors = [];
+  let hasColor = true;
+  const lines = text.split("\n");
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (line.length === 0 || line.startsWith("#")) continue;
+    const parts = line.split(/\s+/);
+    if (parts.length < 3) continue;
+    points.push(
+      parseFloat(parts[0]),
+      parseFloat(parts[1]),
+      parseFloat(parts[2])
+    );
+    if (parts.length >= 6) {
+      colors.push(
+        parseInt(parts[3], 10),
+        parseInt(parts[4], 10),
+        parseInt(parts[5], 10)
+      );
+    } else {
+      hasColor = false;
+    }
+  }
+  return {
+    points: new Float64Array(points),
+    colors: hasColor ? new Uint8Array(colors) : void 0,
+    count: points.length / 3
+  };
+}
+function parseE57(buffer) {
+  const view = new DataView(buffer);
+  const bytes = new Uint8Array(buffer);
+  const text = new TextDecoder().decode(bytes.slice(0, Math.min(1024, buffer.byteLength)));
+  if (!text.includes("e57")) {
+    return { points: new Float64Array(0), count: 0 };
+  }
+  const points = [];
+  const len = Math.min(buffer.byteLength, 5e7);
+  for (let off = 0; off <= len - 24; off += 8) {
+    const x = view.getFloat64(off, true);
+    const y = view.getFloat64(off + 8, true);
+    const z = view.getFloat64(off + 16, true);
+    if (isFinite(x) && isFinite(y) && isFinite(z) && Math.abs(x) < 1e6 && Math.abs(y) < 1e6 && Math.abs(z) < 1e6 && (x !== 0 || y !== 0 || z !== 0)) {
+      points.push(x, y, z);
+      off += 16;
+    }
+  }
+  return {
+    points: new Float64Array(points),
+    count: points.length / 3
+  };
+}
+var MatterpakCompiler = class extends CompilerBase {
+  constructor(options = {}) {
+    super();
+    this.compilerName = "matterpak";
+    this.version = "1.0.0";
+    this.options = {
+      scale: 1,
+      rotationY: 0,
+      centerOrigin: true,
+      groupAsRooms: true,
+      pointCloudAsParticles: true,
+      maxPointsPerSystem: 1e5,
+      downsampleLargeClouds: true,
+      ...options
+    };
+  }
+  /**
+   * Satisfy CompilerBase abstract method — MatterpakCompiler is a format-ingest
+   * compiler (bundle → HoloComposition) rather than a target compiler
+   * (HoloComposition → output). Use compileBundle() for ingestion.
+   */
+  compile(..._args) {
+    throw new Error(
+      "MatterpakCompiler.compile() is not supported. Use compileBundle(bundle: MatterpakBundle) to ingest a Matterpak bundle into a HoloComposition AST."
+    );
+  }
+  /**
+   * Compile a Matterpak bundle into a HoloComposition AST.
+   */
+  compileBundle(bundle) {
+    const warnings = [];
+    const errors = [];
+    const stats = {
+      meshGroups: 0,
+      vertices: 0,
+      triangles: 0,
+      pointCount: 0,
+      materials: 0,
+      rooms: 0
+    };
+    const objGroups = parseOBJExtended(bundle.obj);
+    stats.meshGroups = objGroups.length;
+    stats.vertices = objGroups.reduce((sum, g) => sum + g.vertices.length / 3, 0);
+    stats.triangles = objGroups.reduce((sum, g) => sum + g.triangles.length / 3, 0);
+    const mtl = bundle.mtl ? parseMTL(bundle.mtl) : { materials: /* @__PURE__ */ new Map() };
+    stats.materials = mtl.materials.size;
+    let xyzCloud;
+    let e57Cloud;
+    if (bundle.xyz) {
+      xyzCloud = parseXYZ(bundle.xyz);
+      stats.pointCount += xyzCloud.count;
+    }
+    if (bundle.e57) {
+      e57Cloud = parseE57(bundle.e57);
+      if (e57Cloud.count > 0) {
+        stats.pointCount += e57Cloud.count;
+      } else {
+        warnings.push("E57 parsing produced zero points (header-only or unsupported format variant)");
+      }
+    }
+    const objects = [];
+    const spatialGroups = [];
+    const lights = [];
+    let minX = Infinity, minY = Infinity, minZ = Infinity;
+    let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+    for (const g of objGroups) {
+      for (let i = 0; i < g.vertices.length; i += 3) {
+        const x = g.vertices[i];
+        const y = g.vertices[i + 1];
+        const z = g.vertices[i + 2];
+        if (x < minX) minX = x;
+        if (x > maxX) maxX = x;
+        if (y < minY) minY = y;
+        if (y > maxY) maxY = y;
+        if (z < minZ) minZ = z;
+        if (z > maxZ) maxZ = z;
+      }
+    }
+    const cx = (minX + maxX) / 2;
+    const cy = minY;
+    const cz = (minZ + maxZ) / 2;
+    const scale = this.options.scale ?? 1;
+    const rotY = this.options.rotationY ?? 0;
+    if (this.options.groupAsRooms) {
+      for (const g of objGroups) {
+        const traits = [];
+        const matName = g.materialName;
+        if (matName && mtl.materials.has(matName)) {
+          const mat = mtl.materials.get(matName);
+          const matConfig = {
+            baseColor: mat.baseColor,
+            metallic: mat.metallic,
+            roughness: mat.roughness
+          };
+          if (mat.textureMap !== void 0) matConfig.textureMap = mat.textureMap;
+          if (mat.normalMap !== void 0) matConfig.normalMap = mat.normalMap;
+          traits.push({
+            type: "ObjectTrait",
+            name: "material",
+            config: matConfig
+          });
+        }
+        traits.push({
+          type: "ObjectTrait",
+          name: "geometry",
+          config: {
+            primitive: "mesh",
+            vertices: Array.from(g.vertices),
+            indices: Array.from(g.triangles)
+          }
+        });
+        let gx = 0, gy = 0, gz = 0;
+        for (let i = 0; i < g.vertices.length; i += 3) {
+          gx += g.vertices[i];
+          gy += g.vertices[i + 1];
+          gz += g.vertices[i + 2];
+        }
+        const vc = g.vertices.length / 3;
+        gx /= vc;
+        gy /= vc;
+        gz /= vc;
+        const obj = {
+          type: "ObjectDecl",
+          id: `obj_${g.name}`,
+          name: g.name,
+          properties: [],
+          position: {
+            x: (gx - cx) * scale,
+            y: (gy - cy) * scale,
+            z: (gz - cz) * scale
+          },
+          scale: { x: scale, y: scale, z: scale },
+          rotation: { x: 0, y: rotY, z: 0 },
+          traits
+        };
+        objects.push(obj);
+        spatialGroups.push({
+          type: "SpatialGroup",
+          id: `room_${g.name}`,
+          name: g.name,
+          properties: [],
+          objects: [obj]
+        });
+      }
+      stats.rooms = spatialGroups.length;
+    } else {
+      for (const g of objGroups) {
+        const traits = [{
+          type: "ObjectTrait",
+          name: "geometry",
+          config: {
+            primitive: "mesh",
+            vertices: Array.from(g.vertices),
+            indices: Array.from(g.triangles)
+          }
+        }];
+        const matName = g.materialName;
+        if (matName && mtl.materials.has(matName)) {
+          const mat = mtl.materials.get(matName);
+          const matConfig = {
+            baseColor: mat.baseColor,
+            metallic: mat.metallic,
+            roughness: mat.roughness
+          };
+          if (mat.textureMap !== void 0) matConfig.textureMap = mat.textureMap;
+          if (mat.normalMap !== void 0) matConfig.normalMap = mat.normalMap;
+          traits.push({
+            type: "ObjectTrait",
+            name: "material",
+            config: matConfig
+          });
+        }
+        objects.push({
+          type: "ObjectDecl",
+          id: `obj_${g.name}`,
+          name: g.name,
+          properties: [],
+          position: { x: 0, y: 0, z: 0 },
+          scale: { x: scale, y: scale, z: scale },
+          rotation: { x: 0, y: rotY, z: 0 },
+          traits
+        });
+      }
+      spatialGroups.push({
+        type: "SpatialGroup",
+        id: "room_all",
+        name: "Full Property",
+        properties: [],
+        objects: [...objects]
+      });
+      stats.rooms = 1;
+    }
+    const pointClouds = [];
+    if (xyzCloud && xyzCloud.count > 0) pointClouds.push(xyzCloud);
+    if (e57Cloud && e57Cloud.count > 0) pointClouds.push(e57Cloud);
+    if (this.options.pointCloudAsParticles && pointClouds.length > 0) {
+      let systemIndex = 0;
+      for (const pc of pointClouds) {
+        const maxPts = this.options.maxPointsPerSystem ?? 1e5;
+        let stride = 1;
+        if (this.options.downsampleLargeClouds && pc.count > maxPts) {
+          stride = Math.ceil(pc.count / maxPts);
+        }
+        const particles = [];
+        const particleColors = [];
+        for (let i = 0; i < pc.count; i += stride) {
+          const x = pc.points[i * 3];
+          const y = pc.points[i * 3 + 1];
+          const z = pc.points[i * 3 + 2];
+          particles.push(
+            (x - cx) * scale,
+            (y - cy) * scale,
+            (z - cz) * scale
+          );
+          if (pc.colors) {
+            particleColors.push(
+              pc.colors[i * 3] / 255,
+              pc.colors[i * 3 + 1] / 255,
+              pc.colors[i * 3 + 2] / 255
+            );
+          }
+        }
+        objects.push({
+          type: "ObjectDecl",
+          id: `pointcloud_${systemIndex}`,
+          name: `Point Cloud ${systemIndex}`,
+          properties: [],
+          position: { x: 0, y: 0, z: 0 },
+          scale: { x: 1, y: 1, z: 1 },
+          rotation: { x: 0, y: 0, z: 0 },
+          traits: [{
+            type: "ObjectTrait",
+            name: "particleSystem",
+            config: {
+              count: particles.length / 3,
+              positions: particles,
+              ...particleColors.length > 0 ? { colors: particleColors } : {},
+              size: 0.02 * scale,
+              billboard: true
+            }
+          }]
+        });
+        systemIndex++;
+      }
+    }
+    const camera = {
+      type: "Camera",
+      cameraType: "perspective",
+      properties: [],
+      position: { x: 0, y: 1.6 * scale, z: 3 * scale },
+      target: { x: 0, y: 0.5 * scale, z: 0 },
+      fov: 70,
+      near: 0.01,
+      far: 1e3
+    };
+    lights.push({
+      type: "Light",
+      id: "ambient_main",
+      name: "ambient_main",
+      lightType: "ambient",
+      properties: [
+        { type: "LightProperty", key: "color", value: "#ffffff" },
+        { type: "LightProperty", key: "intensity", value: 0.6 }
+      ]
+    });
+    lights.push({
+      type: "Light",
+      id: "directional_main",
+      name: "directional_main",
+      lightType: "directional",
+      properties: [
+        { type: "LightProperty", key: "color", value: "#ffffff" },
+        { type: "LightProperty", key: "intensity", value: 0.8 },
+        { type: "LightProperty", key: "position", value: [5 * scale, 10 * scale, 5 * scale] }
+      ]
+    });
+    const composition = {
+      type: "Composition",
+      name: "Matterpak Import",
+      environment: {
+        type: "Environment",
+        properties: [
+          { type: "EnvironmentProperty", key: "background", value: "#202020" },
+          { type: "EnvironmentProperty", key: "fogColor", value: "#202020" },
+          { type: "EnvironmentProperty", key: "fogNear", value: 10 * scale },
+          { type: "EnvironmentProperty", key: "fogFar", value: 50 * scale }
+        ]
+      },
+      templates: [],
+      objects,
+      spatialGroups,
+      lights,
+      camera,
+      effects: {
+        type: "Effects",
+        effects: [
+          { type: "Effect", effectType: "shadows", properties: { enabled: true } },
+          { type: "Effect", effectType: "ambientOcclusion", properties: { enabled: true } }
+        ]
+      },
+      imports: [],
+      timelines: [],
+      audio: [],
+      zones: [],
+      worlds: [{
+        type: "World",
+        id: "property_world",
+        name: "Imported Property",
+        properties: [
+          { type: "WorldProperty", key: "gravityX", value: 0 },
+          { type: "WorldProperty", key: "gravityY", value: -9.81 },
+          { type: "WorldProperty", key: "gravityZ", value: 0 },
+          { type: "WorldProperty", key: "boundsMinX", value: (minX - cx) * scale },
+          { type: "WorldProperty", key: "boundsMinY", value: (minY - cy) * scale },
+          { type: "WorldProperty", key: "boundsMinZ", value: (minZ - cz) * scale },
+          { type: "WorldProperty", key: "boundsMaxX", value: (maxX - cx) * scale },
+          { type: "WorldProperty", key: "boundsMaxY", value: (maxY - cy) * scale },
+          { type: "WorldProperty", key: "boundsMaxZ", value: (maxZ - cz) * scale }
+        ]
+      }],
+      ui: {
+        type: "UI",
+        elements: []
+      },
+      transitions: [],
+      conditionals: [],
+      iterators: [],
+      npcs: [],
+      quests: [],
+      abilities: [],
+      dialogues: [],
+      stateMachines: [],
+      achievements: [],
+      talentTrees: [],
+      shapes: []
+    };
+    return {
+      success: errors.length === 0,
+      composition,
+      stats,
+      warnings,
+      errors
+    };
+  }
+};
+function createMatterpakCompiler(options) {
+  return new MatterpakCompiler(options);
+}
+
+// src/compiler/HoloGramMLSCompiler.ts
+init_CompilerBase();
+function groupPhotosByRoom(photos) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const p of photos) {
+    const room = p.room?.trim() || "Uncategorized";
+    if (!groups.has(room)) groups.set(room, []);
+    groups.get(room).push(p);
+  }
+  return groups;
+}
+function computeRoomGrid(rooms, spacing) {
+  const positions = /* @__PURE__ */ new Map();
+  const cols = Math.ceil(Math.sqrt(rooms.length));
+  const offsetX = (cols - 1) * spacing / 2;
+  const offsetZ = (Math.ceil(rooms.length / cols) - 1) * spacing / 2;
+  for (let i = 0; i < rooms.length; i++) {
+    const col = i % cols;
+    const row = Math.floor(i / cols);
+    positions.set(rooms[i], {
+      x: col * spacing - offsetX,
+      z: row * spacing - offsetZ
+    });
+  }
+  return positions;
+}
+function aspectScale(photo) {
+  const w = photo.width ?? 1024;
+  const h = photo.height ?? 768;
+  const base = 2;
+  if (w >= h) {
+    return { x: base, y: base * h / w };
+  }
+  return { x: base * w / h, y: base };
+}
+function placePhotosInRoom(photos, roomSize) {
+  const placements = [];
+  const half = roomSize / 2 - 0.5;
+  const wallHeight = 1.6;
+  if (photos.length === 1) {
+    placements.push({
+      photo: photos[0],
+      position: { x: 0, y: wallHeight, z: -half },
+      rotation: { x: 0, y: 0, z: 0 }
+    });
+  } else if (photos.length === 2) {
+    placements.push({
+      photo: photos[0],
+      position: { x: -half, y: wallHeight, z: 0 },
+      rotation: { x: 0, y: 90, z: 0 }
+    });
+    placements.push({
+      photo: photos[1],
+      position: { x: half, y: wallHeight, z: 0 },
+      rotation: { x: 0, y: -90, z: 0 }
+    });
+  } else {
+    const wallOrder = [
+      { x: 0, z: -half, ry: 0 },
+      { x: -half, z: 0, ry: 90 },
+      { x: half, z: 0, ry: -90 },
+      { x: 0, z: half, ry: 180 }
+    ];
+    for (let i = 0; i < photos.length; i++) {
+      const wall = wallOrder[i % wallOrder.length];
+      const offsetIndex = Math.floor(i / wallOrder.length);
+      const offset = (offsetIndex % 2 === 0 ? -1 : 1) * (0.6 + offsetIndex * 0.3);
+      placements.push({
+        photo: photos[i],
+        position: {
+          x: wall.x === 0 ? offset : wall.x,
+          y: wallHeight + offsetIndex * 0.3,
+          z: wall.z === 0 ? offset : wall.z
+        },
+        rotation: { x: 0, y: wall.ry, z: 0 }
+      });
+    }
+  }
+  return placements;
+}
+var HoloGramMLSCompiler = class extends CompilerBase {
+  constructor(options = {}) {
+    super();
+    this.compilerName = "hologram_mls";
+    this.version = "1.0.0";
+    this.options = {
+      photoScale: 1,
+      roomSpacing: 8,
+      depthModel: "depth-anything-v2-small",
+      depthBackend: "webgpu",
+      displacementScale: 0.3,
+      displacementSegments: 128,
+      walkable: true,
+      ambientLight: 0.4,
+      spotLighting: true,
+      floorColor: "#1a1a2e",
+      environment: "night",
+      ...options
+    };
+  }
+  /**
+   * Satisfy CompilerBase abstract method — HoloGramMLSCompiler is a format-ingest
+   * compiler (bundle → HoloComposition). Use compileBundle() for ingestion.
+   */
+  compile(..._args) {
+    throw new Error(
+      "HoloGramMLSCompiler.compile() is not supported. Use compileBundle(bundle: HoloGramMLSBundle) to ingest an MLS bundle."
+    );
+  }
+  compileBundle(bundle) {
+    const warnings = [];
+    const errors = [];
+    const stats = { photos: 0, rooms: 0, waypoints: 0, lights: 0 };
+    if (!bundle.photos || bundle.photos.length === 0) {
+      warnings.push("No photos provided; returning empty gallery");
+      return {
+        success: true,
+        composition: this.buildEmptyComposition(),
+        stats,
+        warnings,
+        errors
+      };
+    }
+    const roomGroups = groupPhotosByRoom(bundle.photos);
+    const roomNames = Array.from(roomGroups.keys());
+    stats.photos = bundle.photos.length;
+    stats.rooms = roomNames.length;
+    const roomPositions = computeRoomGrid(roomNames, this.options.roomSpacing);
+    const objects = [];
+    const spatialGroups = [];
+    const lights = [];
+    const waypoints = [];
+    const wpPoints = [];
+    for (const roomName of roomNames) {
+      const photos = roomGroups.get(roomName);
+      const pos = roomPositions.get(roomName);
+      const roomSize = Math.min(this.options.roomSpacing * 0.8, 6);
+      objects.push({
+        type: "ObjectDecl",
+        id: `floor_${roomName.replace(/\s+/g, "_")}`,
+        name: `${roomName} Floor`,
+        position: { x: pos.x, y: 0, z: pos.z },
+        scale: { x: roomSize, y: 1, z: roomSize },
+        rotation: { x: -90, y: 0, z: 0 },
+        properties: [],
+        traits: [
+          { type: "ObjectTrait", name: "collidable", config: {}, params: {} },
+          { type: "ObjectTrait", name: "static", config: {}, params: {} },
+          {
+            type: "ObjectTrait",
+            name: "geometry",
+            config: {},
+            params: { primitive: "plane" }
+          },
+          {
+            type: "ObjectTrait",
+            name: "material",
+            config: {},
+            params: {
+              color: this.options.floorColor,
+              roughness: 0.1,
+              metalness: 0.6
+            }
+          }
+        ]
+      });
+      const placements = placePhotosInRoom(photos, roomSize);
+      for (const placement of placements) {
+        const scale = aspectScale(placement.photo);
+        const traits = [
+          {
+            type: "ObjectTrait",
+            name: "image",
+            config: {},
+            params: { src: placement.photo.url }
+          },
+          {
+            type: "ObjectTrait",
+            name: "depth_estimation",
+            config: {},
+            params: {
+              model: this.options.depthModel,
+              backend: this.options.depthBackend
+            }
+          },
+          {
+            type: "ObjectTrait",
+            name: "displacement",
+            config: {},
+            params: {
+              scale: this.options.displacementScale,
+              segments: this.options.displacementSegments
+            }
+          },
+          {
+            type: "ObjectTrait",
+            name: "depth_to_normal",
+            config: {},
+            params: {}
+          },
+          {
+            type: "ObjectTrait",
+            name: "geometry",
+            config: {},
+            params: { primitive: "plane" }
+          }
+        ];
+        if (placement.photo.caption) {
+          traits.push({
+            type: "ObjectTrait",
+            name: "billboard",
+            config: {},
+            params: { label: placement.photo.caption }
+          });
+        }
+        objects.push({
+          type: "ObjectDecl",
+          id: `photo_${objects.length}`,
+          name: placement.photo.caption || `Photo ${objects.length}`,
+          position: {
+            x: pos.x + placement.position.x,
+            y: placement.position.y,
+            z: pos.z + placement.position.z
+          },
+          scale: {
+            x: scale.x * this.options.photoScale,
+            y: scale.y * this.options.photoScale,
+            z: 1
+          },
+          rotation: placement.rotation,
+          properties: [],
+          traits
+        });
+      }
+      objects.push({
+        type: "ObjectDecl",
+        id: `label_${roomName.replace(/\s+/g, "_")}`,
+        name: `${roomName} Label`,
+        position: { x: pos.x, y: 2.8, z: pos.z },
+        scale: { x: 2, y: 0.4, z: 0.01 },
+        rotation: { x: 0, y: 0, z: 0 },
+        properties: [],
+        traits: [
+          { type: "ObjectTrait", name: "billboard", config: {}, params: {} },
+          {
+            type: "ObjectTrait",
+            name: "material",
+            config: {},
+            params: { color: "#0a0a20", emissive: "#4422cc", emissiveIntensity: 1.2 }
+          }
+        ]
+      });
+      if (this.options.spotLighting) {
+        lights.push({
+          type: "Light",
+          id: `spot_${roomName.replace(/\s+/g, "_")}`,
+          lightType: "spot",
+          name: `${roomName} Spot`,
+          properties: [
+            { type: "LightProperty", key: "position", value: [pos.x, 4, pos.z] },
+            { type: "LightProperty", key: "target", value: [pos.x, 0, pos.z] },
+            { type: "LightProperty", key: "color", value: "#ffffff" },
+            { type: "LightProperty", key: "intensity", value: 1.2 },
+            { type: "LightProperty", key: "angle", value: Math.PI / 3 },
+            { type: "LightProperty", key: "penumbra", value: 0.3 }
+          ]
+        });
+        stats.lights++;
+      }
+      spatialGroups.push({
+        type: "SpatialGroup",
+        id: `room_${roomName.replace(/\s+/g, "_")}`,
+        name: roomName,
+        objects: objects.filter((o) => o.id?.startsWith(`floor_${roomName.replace(/\s+/g, "_")}`) || o.id?.startsWith(`label_${roomName.replace(/\s+/g, "_")}`) || o.traits?.some((t) => t.name === "image") && Math.abs((o.position?.x ?? 0) - pos.x) < roomSize && Math.abs((o.position?.z ?? 0) - pos.z) < roomSize),
+        properties: []
+      });
+      wpPoints.push([pos.x, 0.1, pos.z]);
+    }
+    if (this.options.walkable && wpPoints.length > 1) {
+      waypoints.push({
+        type: "Waypoints",
+        name: "room_navigation",
+        points: wpPoints
+      });
+      stats.waypoints = wpPoints.length;
+    }
+    lights.push({
+      type: "Light",
+      id: "ambient_main",
+      lightType: "ambient",
+      name: "Ambient",
+      properties: [
+        { type: "LightProperty", key: "color", value: "#ffffff" },
+        { type: "LightProperty", key: "intensity", value: this.options.ambientLight }
+      ]
+    });
+    stats.lights++;
+    lights.push({
+      type: "Light",
+      id: "directional_main",
+      lightType: "directional",
+      name: "Directional",
+      properties: [
+        { type: "LightProperty", key: "color", value: "#ffffff" },
+        { type: "LightProperty", key: "intensity", value: 0.8 },
+        { type: "LightProperty", key: "position", value: [5, 10, 5] }
+      ]
+    });
+    stats.lights++;
+    const firstRoom = roomPositions.get(roomNames[0]);
+    const camera = {
+      type: "Camera",
+      cameraType: "perspective",
+      position: { x: firstRoom.x, y: 1.6, z: firstRoom.z + this.options.roomSpacing * 0.4 },
+      target: { x: firstRoom.x, y: 1.2, z: firstRoom.z },
+      fov: 70,
+      near: 0.01,
+      far: 1e3,
+      properties: []
+    };
+    const composition = {
+      type: "Composition",
+      name: "HoloGram MLS Gallery",
+      objects,
+      spatialGroups,
+      lights,
+      camera,
+      waypointSets: waypoints,
+      worlds: [{
+        type: "World",
+        name: "gallery_world",
+        bounds: {
+          minX: -this.options.roomSpacing * 2,
+          minY: 0,
+          minZ: -this.options.roomSpacing * 2,
+          maxX: this.options.roomSpacing * 2,
+          maxY: 10,
+          maxZ: this.options.roomSpacing * 2
+        }
+      }],
+      templates: [],
+      imports: [],
+      transitions: [],
+      conditionals: [],
+      iterators: [],
+      timelines: [],
+      audio: [],
+      zones: [],
+      npcs: [],
+      quests: [],
+      abilities: [],
+      dialogues: [],
+      stateMachines: [],
+      achievements: [],
+      talentTrees: [],
+      shapes: [],
+      metadata: {
+        ...bundle.propertyMetadata,
+        compiler: "hologram_mls",
+        version: "1.0.0"
+      }
+    };
+    return {
+      success: true,
+      composition,
+      stats,
+      warnings,
+      errors
+    };
+  }
+  buildEmptyComposition() {
+    return {
+      type: "Composition",
+      name: "HoloGram MLS Gallery (Empty)",
+      objects: [],
+      spatialGroups: [],
+      lights: [],
+      templates: [],
+      imports: [],
+      transitions: [],
+      conditionals: [],
+      iterators: [],
+      timelines: [],
+      audio: [],
+      zones: [],
+      npcs: [],
+      quests: [],
+      abilities: [],
+      dialogues: [],
+      stateMachines: [],
+      achievements: [],
+      talentTrees: [],
+      shapes: []
+    };
+  }
+};
+function createHoloGramMLSCompiler(options) {
+  return new HoloGramMLSCompiler(options);
+}
+
+// src/compiler/TraitRegistryBridge.ts
+init_AndroidXRTraitMap();
+init_VisionOSTraitMap();
+init_traitDocs();
+function normaliseTraitName(name) {
+  return name.toLowerCase().replace(/^@/, "").replace(/trait$/i, "").replace(/_/g, "-").trim();
+}
+function queryTrait(name, opts = {}) {
+  const target = opts.target || "core";
+  if (target === "android-xr") {
+    const map = getTraitMapping(name);
+    if (map) {
+      return {
+        name,
+        exists: true,
+        level: map.level,
+        codegen: opts.includeCodegen ? map.generate?.(name, {}) : void 0,
+        sourceMap: "AndroidXRTraitMap"
+      };
+    }
+  }
+  if (target === "visionos") {
+    const map = getTraitMapping$1(name);
+    if (map) {
+      return {
+        name,
+        exists: true,
+        level: map.level,
+        codegen: opts.includeCodegen ? map.generate?.(name, {}) : void 0,
+        sourceMap: "VisionOSTraitMap"
+      };
+    }
+    return { name, exists: false, sourceMap: "VisionOSTraitMap" };
+  }
+  const normalised = normaliseTraitName(name);
+  if (vrTraitRegistry.has(normalised)) {
+    const handler = vrTraitRegistry.getHandler(normalised);
+    const doc2 = getTraitDoc(name);
+    return {
+      name,
+      exists: true,
+      sourceMap: "VRTraitRegistry",
+      level: handler?.defaultConfig ? String(handler.defaultConfig.level ?? "core") : "core",
+      description: doc2?.description,
+      category: doc2?.category,
+      annotation: doc2?.annotation
+    };
+  }
+  const doc = getTraitDoc(name);
+  if (doc) {
+    return {
+      name,
+      exists: true,
+      sourceMap: "traitDocs",
+      description: doc.description,
+      category: doc.category,
+      annotation: doc.annotation
+    };
+  }
+  return {
+    name,
+    exists: false,
+    sourceMap: "core-traits (not found in any registry)"
+  };
+}
+function generateTraitForTarget(name, target, config = {}) {
+  if (target === "android-xr" || target === "android") {
+    return getTraitMapping(name)?.generate?.(name, config) ?? [
+      `// @${name} not yet mapped for android-xr (see AndroidXRTraitMap)`
+    ];
+  }
+  if (target === "visionos") {
+    return generateTraitCode(name, name, config) ?? [
+      `// @${name} not yet mapped for visionos (see VisionOSTraitMap)`
+    ];
+  }
+  const info = queryTrait(name, { target: "core" });
+  if (info.exists) {
+    return [
+      `// @${name} \u2014 core trait (registered in ${info.sourceMap}), no platform-specific codegen for "${target}"`,
+      `// trait level: ${info.level ?? "unknown"}, category: ${info.category ?? "unknown"}`
+    ];
+  }
+  return [`// @${name} \u2014 no codegen path registered for target "${target}" yet`];
+}
+function listTraitsForTarget(target) {
+  if (target === "android-xr") {
+    return Object.keys(ANDROIDXR_TRAIT_MAP);
+  }
+  if (target === "visionos") {
+    return listAllTraits ? listAllTraits() : [];
+  }
+  if (target === "core") {
+    const seen = /* @__PURE__ */ new Set();
+    const result = [];
+    for (const name of vrTraitRegistry.getRegisteredTraits()) {
+      const norm = normaliseTraitName(name);
+      if (!seen.has(norm)) {
+        seen.add(norm);
+        result.push(name);
+      }
+    }
+    for (const annotation of getAllTraitNames()) {
+      const norm = normaliseTraitName(annotation);
+      if (!seen.has(norm)) {
+        seen.add(norm);
+        result.push(annotation);
+      }
+    }
+    return result;
+  }
+  return [];
+}
+function traitExists(name) {
+  const normalised = normaliseTraitName(name);
+  if (vrTraitRegistry.has(normalised)) {
+    return true;
+  }
+  const doc = getTraitDoc(name);
+  if (doc) {
+    return true;
+  }
+  if (getTraitMapping(name)) {
+    return true;
+  }
+  if (getTraitMapping$1(name)) {
+    return true;
+  }
+  return false;
+}
+function getTraitInfo(name) {
+  const info = queryTrait(name, { target: "core" });
+  if (!info.exists) return void 0;
+  return info;
+}
+
+// src/compiler/platform/PlatformCompilerPlugin.ts
+var PlatformPluginRegistry = class {
+  constructor() {
+    this.plugins = /* @__PURE__ */ new Map();
+    this.targetIndex = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a plugin. Indexes by name and by each target.
+   * Overwrites any existing plugin with the same name.
+   */
+  register(plugin) {
+    const { name } = plugin.metadata;
+    const existing = this.plugins.get(name);
+    if (existing) {
+      for (const target of existing.metadata.targets) {
+        this.targetIndex.delete(target);
+      }
+    }
+    this.plugins.set(name, plugin);
+    for (const target of plugin.metadata.targets) {
+      this.targetIndex.set(target, plugin);
+    }
+  }
+  /** Get a plugin by its unique name */
+  getByName(name) {
+    return this.plugins.get(name);
+  }
+  /** Get the plugin that handles a given target */
+  getPluginForTarget(target) {
+    return this.targetIndex.get(target);
+  }
+  /** List all registered plugin names */
+  listPluginNames() {
+    return [...this.plugins.keys()];
+  }
+  /** Get all registered plugins */
+  listPlugins() {
+    return [...this.plugins.values()];
+  }
+  /** Get all supported targets across all plugins */
+  listAllTargets() {
+    return [...this.targetIndex.keys()];
+  }
+  /** Unregister a plugin by name, cleaning up target index */
+  unregister(name) {
+    const plugin = this.plugins.get(name);
+    if (plugin) {
+      for (const target of plugin.metadata.targets) {
+        this.targetIndex.delete(target);
+      }
+      this.plugins.delete(name);
+    }
+  }
+  /** Unregister all plugins */
+  clear() {
+    this.plugins.clear();
+    this.targetIndex.clear();
+  }
+};
+var platformPluginRegistry = new PlatformPluginRegistry();
+function manifestFromPlugin(plugin) {
+  const { name, version, targets, sizeKB, integrity } = plugin.metadata;
+  const shortName = name.replace(/^holoscript-plugin-/, "");
+  return {
+    name,
+    version,
+    targets,
+    wasmUrl: `plugins/holoscript-plugin-${shortName}.component.wasm`,
+    sizeKB,
+    integrity
+  };
+}
+function getAllManifests() {
+  return platformPluginRegistry.listPlugins().map(manifestFromPlugin);
+}
+
+// src/compiler/platform/plugins/WebGPUWGSLPlugin.ts
+init_WebGPUCompiler();
+var WEBGPU_WGSL_METADATA = {
+  name: "holoscript-plugin-webgpu-wgsl",
+  version: "1.0.0",
+  targets: ["web"],
+  // webgpu-wgsl maps to 'web' in PlatformTarget
+  sizeKB: 220,
+  minCoreVersion: "6.0.0"
+};
+var WebGPUWGSLPlugin = class {
+  constructor() {
+    this.metadata = WEBGPU_WGSL_METADATA;
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Core compilation
+  // ─────────────────────────────────────────────────────────────────────
+  compile(astJson, target) {
+    let ast;
+    try {
+      ast = JSON.parse(astJson);
+    } catch {
+      return {
+        type: "error",
+        diagnostics: [{ severity: "error", message: "WebGPU plugin: invalid AST JSON input" }]
+      };
+    }
+    switch (target) {
+      case "web": {
+        try {
+          const compiler = new WebGPUCompiler({ enableCompute: true });
+          const result = compiler.compile(ast, "");
+          return { type: "text", data: result };
+        } catch (err) {
+          return {
+            type: "error",
+            diagnostics: [
+              {
+                severity: "error",
+                message: `WebGPU compilation failed: ${err instanceof Error ? err.message : String(err)}`
+              }
+            ]
+          };
+        }
+      }
+      default:
+        return {
+          type: "error",
+          diagnostics: [
+            {
+              severity: "error",
+              message: `WebGPU plugin: unsupported target '${target}'. Supported: web`
+            }
+          ]
+        };
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Trait evaluation (delegates to TraitRegistryBridge)
+  // ─────────────────────────────────────────────────────────────────────
+  traitExists(name) {
+    return traitExists(name);
+  }
+  traitQuery(name, opts) {
+    return queryTrait(name, { target: "webgpu", ...opts });
+  }
+  traitList() {
+    return listTraitsForTarget("core");
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Trait codegen (WGSL-specific)
+  // ─────────────────────────────────────────────────────────────────────
+  traitCodegen(traitName, context) {
+    const { target, config, format } = context;
+    if (!this.traitExists(traitName)) {
+      return {
+        code: [`// @${traitName} \u2014 trait not found in any registry`],
+        language: "wgsl",
+        fidelity: "stub",
+        sourceMap: "WebGPUWGSLPlugin"
+      };
+    }
+    const webgpuCode = generateTraitForTarget(traitName, "webgpu-wgsl", config);
+    if (webgpuCode.length > 0 && !webgpuCode[0].startsWith("//")) {
+      return {
+        code: webgpuCode,
+        language: "wgsl",
+        fidelity: "full",
+        sourceMap: "TraitRegistryBridge/webgpu-wgsl",
+        ...context.includeProvenance && {
+          provenance: {
+            pluginName: this.metadata.name,
+            pluginVersion: this.metadata.version,
+            traitName,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        }
+      };
+    }
+    const coreCode = generateTraitForTarget(traitName, "core", config);
+    return {
+      code: coreCode,
+      language: "wgsl",
+      fidelity: coreCode[0]?.startsWith("//") ? "stub" : "partial",
+      sourceMap: "TraitRegistryBridge/core",
+      ...context.includeProvenance && {
+        provenance: {
+          pluginName: this.metadata.name,
+          pluginVersion: this.metadata.version,
+          traitName,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      }
+    };
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Lifecycle
+  // ─────────────────────────────────────────────────────────────────────
+  unload() {
+  }
+};
+platformPluginRegistry.register(new WebGPUWGSLPlugin());
+
+// src/compiler/platform/plugins/AndroidARCorePlugin.ts
+init_AndroidXRCompiler();
+var ANDROID_ARCORE_METADATA = {
+  name: "holoscript-plugin-android-arcore",
+  version: "1.0.0",
+  targets: ["android-xr", "android-xr-ar"],
+  sizeKB: 300,
+  minCoreVersion: "6.0.0"
+};
+var AndroidARCorePlugin = class {
+  constructor() {
+    this.metadata = ANDROID_ARCORE_METADATA;
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Core compilation
+  // ─────────────────────────────────────────────────────────────────────
+  compile(astJson, target) {
+    let ast;
+    try {
+      ast = JSON.parse(astJson);
+    } catch {
+      return {
+        type: "error",
+        diagnostics: [
+          { severity: "error", message: "Android/ARCore plugin: invalid AST JSON input" }
+        ]
+      };
+    }
+    switch (target) {
+      case "android-xr":
+      case "android-xr-ar": {
+        try {
+          const compiler = new AndroidXRCompiler({
+            formFactor: target === "android-xr-ar" ? "glasses" : "headset"
+          });
+          const result = compiler.compile(ast, "apl-plugin-token");
+          const output = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+          return { type: "text", data: output };
+        } catch (err) {
+          return {
+            type: "error",
+            diagnostics: [
+              {
+                severity: "error",
+                message: `Android/ARCore compilation failed: ${err instanceof Error ? err.message : String(err)}`
+              }
+            ]
+          };
+        }
+      }
+      default:
+        return {
+          type: "error",
+          diagnostics: [
+            {
+              severity: "error",
+              message: `Android/ARCore plugin: unsupported target '${target}'. Supported: android-xr, android-xr-ar`
+            }
+          ]
+        };
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Trait evaluation (delegates to TraitRegistryBridge)
+  // ─────────────────────────────────────────────────────────────────────
+  traitExists(name) {
+    return traitExists(name);
+  }
+  traitQuery(name, opts) {
+    return queryTrait(name, { target: "android-xr", ...opts });
+  }
+  traitList() {
+    return listTraitsForTarget("android-xr");
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Trait codegen (Kotlin/ARCore-specific)
+  // ─────────────────────────────────────────────────────────────────────
+  traitCodegen(traitName, context) {
+    const { target, config, format } = context;
+    if (!this.traitExists(traitName)) {
+      return {
+        code: [`// @${traitName} \u2014 trait not found in any registry`],
+        language: "kotlin",
+        fidelity: "stub",
+        sourceMap: "AndroidARCorePlugin"
+      };
+    }
+    const androidCode = generateTraitForTarget(traitName, "android-xr", config);
+    if (androidCode.length > 0 && !androidCode[0].startsWith("//")) {
+      return {
+        code: androidCode,
+        language: "kotlin",
+        fidelity: "full",
+        sourceMap: "AndroidXRTraitMap",
+        ...context.includeProvenance && {
+          provenance: {
+            pluginName: this.metadata.name,
+            pluginVersion: this.metadata.version,
+            traitName,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        }
+      };
+    }
+    const coreCode = generateTraitForTarget(traitName, "core", config);
+    return {
+      code: coreCode,
+      language: "kotlin",
+      fidelity: coreCode[0]?.startsWith("//") ? "stub" : "partial",
+      sourceMap: "TraitRegistryBridge/core",
+      ...context.includeProvenance && {
+        provenance: {
+          pluginName: this.metadata.name,
+          pluginVersion: this.metadata.version,
+          traitName,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      }
+    };
+  }
+  // ─────────────────────────────────────────────────────────────────────
+  // Lifecycle
+  // ─────────────────────────────────────────────────────────────────────
+  unload() {
+  }
+};
+platformPluginRegistry.register(new AndroidARCorePlugin());
+
+export { AgentTrustLedger, AlphaTracker, AndroidARCorePlugin, DEFAULT_DISPATCH_LATENCY_OPERATION, DialectRegistry, DispatchPolicy, DispatchTier, FlatSemanticCompiler, HoloGramMLSCompiler, MCPConfigCompiler, MatterpakCompiler, Native2DCompiler, NextJSAPICompiler, NextJSCompiler, NodeServiceCompiler, SCMCompiler, WebGPUWGSLPlugin, byzantineResilientMerge, compileAllToNextJSAPI, compileToNextJSAPI, createDefaultDispatchLatencyScenarios, createHoloGramMLSCompiler, createMatterpakCompiler, createTier3CpuDirectOutput, detectWasmRuntime, ensureDialectsBooted, formatDispatchLatencyBenchmarkReport, generateTraitForTarget, getAllManifests, getTraitInfo, listTraitsForTarget, manifestFromPlugin, mergeSocialCausalModels, platformPluginRegistry, queryTrait, recommendDispatchPolicyDefaults, registerBuiltinDialects, runCompilerWasmSnnEmulator, runDispatchPolicyLatencyBenchmark, traitExists };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map