@holoscript/core 6.0.3 → 6.1.1

package/dist/{chunk-FEFHPUEM.cjs → chunk-QWNQ523V.cjs}

@@ -1,471 +1,644 @@
 'use strict';
 
-var chunkTSWTWZ42_cjs = require('./chunk-TSWTWZ42.cjs');
-var chunkHHS6FMOU_cjs = require('./chunk-HHS6FMOU.cjs');
-var chunkQHVVVN47_cjs = require('./chunk-QHVVVN47.cjs');
-var chunkEGIZHYJP_cjs = require('./chunk-EGIZHYJP.cjs');
+var chunkBPICAGBV_cjs = require('./chunk-BPICAGBV.cjs');
+var chunk5S7RKFGR_cjs = require('./chunk-5S7RKFGR.cjs');
+var chunkOIQYIIO3_cjs = require('./chunk-OIQYIIO3.cjs');
+var chunkAIA52I7T_cjs = require('./chunk-AIA52I7T.cjs');
+var chunkHGVXZDSK_cjs = require('./chunk-HGVXZDSK.cjs');
+var chunkRMHC2VG7_cjs = require('./chunk-RMHC2VG7.cjs');
+var chunkKKFZ3B6J_cjs = require('./chunk-KKFZ3B6J.cjs');
+var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+var ans = require('@holoscript/core-types/ans');
 
-// src/compiler/Native2DCompiler.ts
-var Native2DCompiler_exports = {};
-chunkEGIZHYJP_cjs.__export(Native2DCompiler_exports, {
-  Native2DCompiler: () => exports.Native2DCompiler
+// src/compiler/ThreeJSCompiler.ts
+var ThreeJSCompiler_exports = {};
+chunkHCCQLAA4_cjs.__export(ThreeJSCompiler_exports, {
+  ThreeJSCompiler: () => exports.ThreeJSCompiler
 });
-exports.Native2DCompiler = void 0;
-var init_Native2DCompiler = chunkEGIZHYJP_cjs.__esm({
-  "src/compiler/Native2DCompiler.ts"() {
-    chunkQHVVVN47_cjs.init_CompilerBase();
-    exports.Native2DCompiler = class extends chunkQHVVVN47_cjs.CompilerBase {
-      constructor() {
-        super(...arguments);
-        this.compilerName = "Native2DCompiler";
-        // ============================================================================
-        // REACT GENERATION
-        // ============================================================================
-        /** Collected during node traversal — used to generate imports and hooks */
-        this._slotImports = /* @__PURE__ */ new Map();
-        this._uiImports = /* @__PURE__ */ new Set();
-        this._stateFields = /* @__PURE__ */ new Map();
-        this._fetchCalls = [];
-        this._options = {};
-      }
-      // @ts-expect-error During migration
-      compile(composition, agentToken, outputPath, options) {
+var SHAPE_TO_THREE_GEOMETRY; exports.ThreeJSCompiler = void 0;
+var init_ThreeJSCompiler = chunkHCCQLAA4_cjs.__esm({
+  "src/compiler/ThreeJSCompiler.ts"() {
+    chunkOIQYIIO3_cjs.init_TraitCompositor();
+    chunk5S7RKFGR_cjs.init_ProvenanceSemiring();
+    chunkRMHC2VG7_cjs.init_CompilerBase();
+    SHAPE_TO_THREE_GEOMETRY = {
+      sphere: "SphereGeometry",
+      orb: "SphereGeometry",
+      cube: "BoxGeometry",
+      box: "BoxGeometry",
+      cylinder: "CylinderGeometry",
+      cone: "ConeGeometry",
+      pyramid: "ConeGeometry",
+      plane: "PlaneGeometry",
+      ground: "PlaneGeometry",
+      torus: "TorusGeometry",
+      ring: "TorusGeometry",
+      capsule: "CapsuleGeometry"
+    };
+    exports.ThreeJSCompiler = class extends chunkRMHC2VG7_cjs.CompilerBase {
+      constructor(options = {}) {
+        super();
+        this.compilerName = "ThreeJSCompiler";
+        this.lines = [];
+        this.indentLevel = 0;
+        this.options = {
+          className: options.className ?? "GeneratedScene",
+          enableShadows: options.enableShadows ?? true,
+          enablePostProcessing: options.enablePostProcessing ?? false,
+          indent: options.indent ?? "  ",
+          provenanceHash: options.provenanceHash ?? ""
+        };
+      }
+      getRequiredCapability() {
+        return ans.ANSCapabilityPath.R3F;
+      }
+      compile(composition, agentToken, outputPath) {
         this.validateCompilerAccess(agentToken, outputPath);
-        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;
-        }
-      }
-      generateReactComponent(name, objects, composition, options) {
-        this._slotImports.clear();
-        this._uiImports.clear();
-        this._stateFields.clear();
-        this._fetchCalls = [];
-        this._options = options || {};
-        const safeName = name.replace(/[^a-zA-Z0-9]/g, "");
-        if (composition?.state?.properties) {
-          for (const prop of composition.state.properties) {
-            this._stateFields.set(prop.key, prop.value ?? null);
-          }
+        this.lines = [];
+        this.indentLevel = 0;
+        this.emit("// Auto-generated by HoloScript ThreeJSCompiler");
+        this.emit(
+          `// Source: composition "${this.escapeStringValue(composition.name, "TypeScript")}"`
+        );
+        if (this.options.provenanceHash) {
+          this.emit(`// Provenance Hash: ${this.options.provenanceHash}`);
         }
-        const jsx = objects.map((obj) => this.generateReactNode(obj)).join("\n        ");
-        const imports = [];
-        const reactImports = /* @__PURE__ */ new Set();
-        if (this._stateFields.size > 0) reactImports.add("useState");
-        if (this._fetchCalls.length > 0) reactImports.add("useEffect");
-        imports.push(
-          reactImports.size > 0 ? `import React, { ${[...reactImports].join(", ")} } from 'react';` : `import React from 'react';`
+        this.emit("");
+        this.emitImports(composition);
+        this.emit("");
+        this.emit(`export class ${this.options.className} {`);
+        this.indent();
+        this.emit("private scene: THREE.Scene;");
+        this.emit("private renderer: THREE.WebGLRenderer;");
+        this.emit("private camera: THREE.PerspectiveCamera;");
+        this.emit("private canvas: HTMLCanvasElement;");
+        this.emit("private frameId: number = 0;");
+        this.emit("");
+        this.emit("constructor(canvas: HTMLCanvasElement) {");
+        this.indent();
+        this.emit("this.canvas = canvas;");
+        this.emit("this.scene = new THREE.Scene();");
+        this.emit(
+          "this.renderer = new THREE.WebGLRenderer({ canvas, antialias: true, alpha: false });"
         );
-        if (this._uiImports.size > 0) {
-          imports.push(`import { ${[...this._uiImports].join(", ")} } from '@holoscript/ui';`);
-        }
-        for (const [, slot] of this._slotImports) {
-          imports.push(`import { ${slot.component} } from '${slot.importPath}';`);
-        }
-        const stateHooks = [];
-        for (const [key, value] of this._stateFields) {
-          const capitalKey = key.charAt(0).toUpperCase() + key.slice(1);
-          const initValue = JSON.stringify(value);
-          stateHooks.push(`  const [${key}, set${capitalKey}] = useState(${initValue === void 0 ? "null" : initValue});`);
-        }
-        const fetchEffects = [];
-        for (const f of this._fetchCalls) {
-          fetchEffects.push(`  useEffect(() => {
-    fetch(\`${f.endpoint}\`${f.method !== "GET" ? `, { method: '${f.method}' }` : ""})
-      .then(r => r.json())
-      .then(set${f.name.charAt(0).toUpperCase() + f.name.slice(1)})
-      .catch(console.error);
-  }, []);`);
-        }
-        return `${imports.join("\n")}
-
-// @generated by HoloScript Native2DCompiler \u2014 DO NOT EDIT
-export function ${safeName}Component() {
-${stateHooks.join("\n")}
-${fetchEffects.join("\n")}
-
-  return (
-    <div className="holoscript-2d-root w-full h-full">
-      ${jsx}
-    </div>
-  );
-}
-
-export default ${safeName}Component;
-`;
-      }
-      generateReactNode(obj) {
-        const traits = this.extractTraits(obj);
-        if (traits.slot) {
-          const slotName = traits.slot.name || obj.name || "Slot";
-          const configuredSlot = this._options.slots?.[String(slotName)];
-          const component = traits.slot.component || configuredSlot?.component || slotName;
-          const importPath = traits.slot.import || configuredSlot?.importPath || `@/components/${component}`;
-          this._slotImports.set(slotName, { component, importPath });
-          const propsStr = traits.slot.props ? ` {...${JSON.stringify(traits.slot.props)}}` : "";
-          return `<div data-holo-slot="${slotName}">
-        <${component}${propsStr} />
-      </div>`;
-        }
-        if (traits.fetch) {
-          const name = traits.fetch.into || "data";
-          const endpoint = traits.fetch.endpoint || "/api/data";
-          const method = traits.fetch.method || "GET";
-          this._fetchCalls.push({ name, endpoint, method });
-          if (!this._stateFields.has(name)) {
-            this._stateFields.set(name, null);
-          }
+        this.emit("this.renderer.setPixelRatio(window.devicePixelRatio);");
+        this.emit("this.renderer.setSize(canvas.clientWidth, canvas.clientHeight);");
+        if (this.options.enableShadows) {
+          this.emit("this.renderer.shadowMap.enabled = true;");
+          this.emit("this.renderer.shadowMap.type = THREE.PCFSoftShadowMap;");
         }
-        let tag = traits.theme?.tag || traits.panel?.tag || (typeof obj.type === "string" ? obj.type.toLowerCase() : void 0) || "div";
-        if ([
-          "nav",
-          "section",
-          "main",
-          "footer",
-          "form",
-          "style",
-          "a",
-          "header",
-          "h1",
-          "h2",
-          "h3"
-        ].includes(tag)) ; else if (tag === "container") {
-          tag = "div";
-        } else if (traits.link || tag === "link") {
-          tag = "a";
-        } else if (traits.button || tag === "button") {
-          tag = "button";
-        } else if (traits.image || tag === "image") {
-          tag = "img";
-        } else if (traits.input || tag === "input") {
-          tag = "input";
-        } else if (traits.text || tag === "text") {
-          tag = this.mapTextVariantToTag(traits.text?.variant || "body");
+        this.emit(
+          "this.camera = new THREE.PerspectiveCamera(75, canvas.clientWidth / canvas.clientHeight, 0.1, 1000);"
+        );
+        this.emit("this.camera.position.set(0, 2, 10);");
+        this.dedent();
+        this.emit("}");
+        this.emit("");
+        this.emit("async build(): Promise<void> {");
+        this.indent();
+        if (composition.environment) this.emitEnvironment(composition.environment);
+        if (composition.lights?.length) {
+          for (const light of composition.lights) this.emitLight(light);
         } else {
-          tag = "div";
-        }
-        const styles = this.buildStyles(traits);
-        const classes = this.buildClasses(traits);
-        let props = ``;
-        if (traits.theme?.className) {
-          classes.push(traits.theme.className);
-        }
-        if (traits.theme?.id) {
-          props += ` id="${traits.theme.id}"`;
-        }
-        const combinedStyles = { ...styles };
-        if (traits.theme?.style) {
-          traits.theme.style.split(";").forEach((rule) => {
-            const [key, ...valueParts] = rule.split(":");
-            const value = valueParts.join(":");
-            if (key && value) {
-              const camelKey = key.trim().replace(/-([a-z])/g, (g) => g[1].toUpperCase());
-              combinedStyles[camelKey] = value.trim();
-            }
-          });
+          this.emit("// Default lighting");
+          this.emit("const ambientLight = new THREE.AmbientLight(0xffffff, 0.6);");
+          this.emit("this.scene.add(ambientLight);");
+          this.emit("const dirLight = new THREE.DirectionalLight(0xffffff, 0.8);");
+          this.emit("dirLight.position.set(5, 10, 5);");
+          if (this.options.enableShadows) {
+            this.emit("dirLight.castShadow = true;");
+            this.emit("dirLight.shadow.mapSize.set(2048, 2048);");
+          }
+          this.emit("this.scene.add(dirLight);");
+          this.emit("");
         }
-        if (Object.keys(combinedStyles).length > 0) {
-          props += ` style={${JSON.stringify(combinedStyles)}}`;
+        if (composition.camera) this.emitCamera(composition.camera);
+        if (composition.objects?.length) {
+          for (const obj of composition.objects) this.emitObject(obj);
         }
-        if (classes.length > 0) {
-          props += ` className="${classes.join(" ")}"`;
+        if (composition.spatialGroups?.length) {
+          for (const g of composition.spatialGroups) this.emitGroup(g);
         }
-        if (traits.theme?.attributes) {
-          try {
-            const parsedAttrs = JSON.parse(traits.theme.attributes);
-            for (const [key, value] of Object.entries(parsedAttrs)) {
-              props += ` ${key}="${value}"`;
-            }
-          } catch (e) {
-          }
+        if (composition.zones?.length) {
+          for (const z of composition.zones) this.emitZone(z);
+        }
+        if (composition.audio?.length) {
+          for (const a of composition.audio) this.emitAudio(a);
         }
-        if (traits.button?.onClick || traits.form?.onSubmit) {
-          const action = traits.button?.onClick || traits.form?.onSubmit;
-          if (action) {
-            const cleanAction = action.replace(/["']/g, "'");
-            if (cleanAction.includes("navigate")) {
-              props += ` onClick={() => ${cleanAction}}`;
-            } else if (cleanAction.includes("submit")) {
-              props += ` onSubmit={${cleanAction}}`;
-            } else if (cleanAction.includes("window.open")) {
-              props += ` onClick={() => ${cleanAction}}`;
+        this.emitRenderLoop();
+        this.dedent();
+        this.emit("}");
+        this.emit("");
+        this.emit("dispose(): void {");
+        this.indent();
+        this.emit("cancelAnimationFrame(this.frameId);");
+        this.emit("this.renderer.dispose();");
+        this.emit("this.scene.clear();");
+        this.dedent();
+        this.emit("}");
+        this.dedent();
+        this.emit("}");
+        return this.lines.join("\n");
+      }
+      // --- Imports ---
+      emitImports(_composition) {
+        this.emit('import * as THREE from "three";');
+        if (this.options.enablePostProcessing) {
+          this.emit('import { EffectComposer } from "three/addons/postprocessing/EffectComposer.js";');
+          this.emit(
+            'import { RenderPass } from "three/addons/postprocessing/RenderPass.js";'
+          );
+          this.emit(
+            'import { UnrealBloomPass } from "three/addons/postprocessing/UnrealBloomPass.js";'
+          );
+        }
+      }
+      // --- Environment ---
+      emitEnvironment(env) {
+        for (const prop of env.properties) {
+          if (prop.key === "background" || prop.key === "skybox" || prop.key === "preset") {
+            if (typeof prop.value === "string" && prop.value.startsWith("#")) {
+              this.emit(`this.scene.background = new THREE.Color(${this.toThreeColorHex(prop.value)});`);
             } else {
-              props += ` onClick={() => console.log('${cleanAction}')}`;
+              this.emit(`// skybox: "${prop.value}" \u2014 load via THREE.CubeTextureLoader`);
             }
+          } else if (prop.key === "fog" && typeof prop.value === "object") {
+            const fog = prop.value;
+            const near = fog.near ?? 10;
+            const far = fog.far ?? 100;
+            const color = this.toThreeColorHex(fog.color ?? "#cccccc");
+            this.emit(`this.scene.fog = new THREE.Fog(${color}, ${near}, ${far});`);
+          } else if (prop.key === "ambient_light") {
+            this.emit(
+              `this.scene.add(new THREE.AmbientLight(0xffffff, ${prop.value ?? 0.5}));`
+            );
+          } else if (prop.key === "ground") {
+            this.emit(
+              `const groundGeom = new THREE.PlaneGeometry(100, 100);`
+            );
+            this.emit(
+              `const groundMat = new THREE.MeshStandardMaterial({ color: 0x888888, roughness: 0.8 });`
+            );
+            this.emit(`const ground = new THREE.Mesh(groundGeom, groundMat);`);
+            this.emit(`ground.rotation.x = -Math.PI / 2;`);
+            if (this.options.enableShadows) {
+              this.emit(`ground.receiveShadow = true;`);
+            }
+            this.emit(`this.scene.add(ground);`);
           }
         }
-        if (traits.image?.src) props += ` src="${traits.image.src}"`;
-        if (traits.image?.alt) props += ` alt="${traits.image.alt}"`;
-        if (traits.link?.href) props += ` href="${traits.link.href}"`;
-        if (traits.input?.placeholder) props += ` placeholder="${traits.input.placeholder}"`;
-        if (traits.input?.type) props += ` type="${traits.input.type}"`;
-        if (traits.input?.required) props += ` required`;
-        if (traits.button?.type) props += ` type="${traits.button.type}"`;
-        const childrenMarkup = (obj.children || obj.objects || []).map((child) => this.generateReactNode(child)).join("\n");
-        const content = traits.text?.content || traits.button?.content || traits.link?.content || traits.icon?.name;
-        let safeContent = "";
-        if (content) {
-          safeContent = `{\`${content.replace(/`/g, "\\`").replace(/\$/g, "\\$")}\`}`;
-        }
-        if (tag === "style") {
-          const escapedStyle = (content || "").replace(/`/g, "\\`").replace(/\$/g, "\\$");
-          return `<style dangerouslySetInnerHTML={{ __html: \`${escapedStyle}\` }} />`;
-        }
-        if (tag === "img" || tag === "input") {
-          return `<${tag}${props} />`;
-        }
-        return `<${tag}${props}>
-      ${safeContent}
-      ${childrenMarkup}
-    </${tag}>`;
-      }
-      // ============================================================================
-      // HTML GENERATION
-      // ============================================================================
-      generateHTMLPage(name, objects, composition) {
-        const content = objects.map((obj) => this.generateHTMLNode(obj)).join("\n      ");
-        let bgColor = "#ffffff";
-        let color = "#000000";
-        if (composition.environment?.properties) {
-          const themeProp = composition.environment.properties.find((p) => p.key === "theme");
-          const bgProp = composition.environment.properties.find((p) => p.key === "backgroundColor");
-          if (themeProp?.value === "dark" || composition.traits?.some((t) => t.name === "theme" && t.config?.dark)) {
-            bgColor = bgProp?.value || "#050510";
-            color = "#ffffff";
+        this.emit("");
+      }
+      // --- Objects ---
+      emitObject(obj, parentVar) {
+        const v = this.sanitizeName(obj.name);
+        let geom = "cube";
+        let modelSrc;
+        let textContent;
+        let position;
+        let rotation;
+        let scale;
+        let size;
+        const mat = {};
+        for (const p of obj.properties) {
+          switch (p.key) {
+            case "geometry":
+            case "mesh":
+            case "type":
+              if (typeof p.value === "string") geom = p.value;
+              break;
+            case "position":
+              if (Array.isArray(p.value)) position = p.value;
+              break;
+            case "rotation":
+              if (Array.isArray(p.value)) rotation = p.value;
+              break;
+            case "scale":
+              scale = p.value;
+              break;
+            case "size":
+              size = p.value;
+              break;
+            case "color":
+              mat.color = p.value;
+              break;
+            case "roughness":
+              mat.roughness = p.value;
+              break;
+            case "metalness":
+            case "metallic":
+              mat.metalness = p.value;
+              break;
+            case "opacity":
+              mat.opacity = p.value;
+              break;
+            case "emissive":
+              mat.emissive = p.value;
+              break;
+            case "emissive_intensity":
+            case "emissiveIntensity":
+              mat.emissiveIntensity = p.value;
+              break;
+            case "material":
+              if (typeof p.value === "object" && p.value !== null)
+                Object.assign(mat, p.value);
+              break;
+            case "model":
+            case "src":
+            case "source":
+              if (typeof p.value === "string") modelSrc = p.value;
+              break;
+            case "text":
+              if (typeof p.value === "string") textContent = p.value;
+              break;
           }
         }
-        return `<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>${name}</title>
-    <script src="https://cdn.tailwindcss.com"></script>
-    <style>
-      body { margin: 0; padding: 0; background-color: ${bgColor}; color: ${color}; font-family: system-ui, -apple-system, sans-serif; }
-      /* Basic resets and custom trait animations to mirror React Framer variants */
-      .glow-btn:hover { box-shadow: 0 0 15px rgba(255,255,255,0.5); }
-      .lift-card { transition: transform 0.2s ease, box-shadow 0.2s ease; }
-      .lift-card:hover { transform: translateY(-4px); box-shadow: 0 10px 20px rgba(0,0,0,0.2); }
-    </style>
-</head>
-<body>
-    <div id="holoscript-native-root">
-      ${content}
-    </div>
-    <script>
-      function navigate(path) { window.location.href = path; }
-      function submitNewsletter(e) { e.preventDefault(); alert('Subscribed!'); }
-    </script>
-</body>
-</html>`;
-      }
-      generateHTMLNode(obj) {
-        const node = obj;
-        const traits = this.extractTraits(obj);
-        const nodeType = typeof node.type === "string" ? node.type.toLowerCase() : void 0;
-        let tag = traits.theme?.tag || traits.panel?.tag || nodeType || "div";
-        if ([
-          "nav",
-          "section",
-          "main",
-          "footer",
-          "form",
-          "style",
-          "a",
-          "header",
-          "h1",
-          "h2",
-          "h3"
-        ].includes(tag)) ; else if (tag === "container") {
-          tag = "div";
-        } else if (traits.link || tag === "link") {
-          tag = "a";
-        } else if (traits.button || tag === "button") {
-          tag = "button";
-        } else if (traits.image || tag === "image") {
-          tag = "img";
-        } else if (traits.input || tag === "input") {
-          tag = "input";
-        } else if (traits.text || tag === "text") {
-          tag = this.mapTextVariantToTag(traits.text?.variant || "body");
+        this.emit(`// Object: ${this.escapeStringValue(obj.name, "TypeScript")}`);
+        if (modelSrc) {
+          this.emit(`// GLTFLoader required for model: "${modelSrc}"`);
+          this.emit(`// import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";`);
+          this.emit(`const ${v}Loader = new GLTFLoader();`);
+          this.emit(
+            `const ${v}Gltf = await new Promise<THREE.Group>((resolve, reject) => { ${v}Loader.load("${modelSrc}", (g) => resolve(g.scene), undefined, reject); });`
+          );
+          this.emit(`const ${v} = ${v}Gltf;`);
+          this.emit(`this.scene.add(${v});`);
+        } else if (geom === "text" || textContent) {
+          this.emit(`// Text geometry requires THREE.FontLoader / troika-three-text`);
+          this.emit(`const ${v}Geom = new THREE.PlaneGeometry(2, 0.5);`);
+          this.emit(
+            `const ${v}Mat = new THREE.MeshBasicMaterial({ color: 0xffffff, transparent: true });`
+          );
+          this.emit(`const ${v} = new THREE.Mesh(${v}Geom, ${v}Mat);`);
+          this.emit(`// Text content: "${textContent || ""}"`);
+          this.emit(`this.scene.add(${v});`);
         } else {
-          tag = "div";
+          const geomArgs = this.geometryArgs(geom, size);
+          const geomClass = SHAPE_TO_THREE_GEOMETRY[geom] ?? "BoxGeometry";
+          this.emit(`const ${v}Geom = new THREE.${geomClass}(${geomArgs});`);
+          const matProps = this.buildMaterialProps(mat);
+          this.emit(`const ${v}Mat = new THREE.MeshStandardMaterial({ ${matProps} });`);
+          this.emit(`const ${v} = new THREE.Mesh(${v}Geom, ${v}Mat);`);
+          this.emit(`this.scene.add(${v});`);
         }
-        const styles = this.buildStyles(traits);
-        const classes = this.buildClasses(traits);
-        let props = ``;
-        if (traits.theme?.className) {
-          classes.push(traits.theme.className);
+        if (position)
+          this.emit(`${v}.position.set(${position[0]}, ${position[1]}, ${position[2]});`);
+        if (rotation)
+          this.emit(`${v}.rotation.set(${rotation[0]}, ${rotation[1]}, ${rotation[2]});`);
+        if (scale) {
+          if (Array.isArray(scale)) {
+            this.emit(`${v}.scale.set(${scale[0]}, ${scale[1]}, ${scale[2]});`);
+          } else {
+            this.emit(`${v}.scale.setScalar(${scale});`);
+          }
         }
-        if (traits.theme?.id) {
-          props += ` id="${traits.theme.id}"`;
+        if (parentVar) this.emit(`${parentVar}.add(${v});`);
+        const physicsTraits = (obj.traits || []).filter(
+          (t) => t.name === "physics" || t.name === "collidable"
+        );
+        if (physicsTraits.length > 0) {
+          const semiring = new chunk5S7RKFGR_cjs.ProvenanceSemiring();
+          const applications = physicsTraits.map((t) => ({
+            name: t.name,
+            config: t.config || {},
+            context: obj.provenance?.context
+          }));
+          const { config: physicsConfig } = semiring.add(applications);
+          const isStatic = (physicsConfig.type || "dynamic") === "static";
+          this.emit(
+            `// @physics \u2014 mass: ${physicsConfig.mass ?? 1}, type: ${isStatic ? "static" : "dynamic"}`
+          );
+          this.emit(
+            `// Use a physics library (cannon-es, rapier, ammo.js) to attach a rigid body to ${v}`
+          );
         }
-        if (Object.keys(styles).length > 0 || traits.theme?.style) {
-          let styleStr = Object.entries(styles).map(([k, v]) => `${this.camelToKebab(k)}: ${v}`).join("; ");
-          if (traits.theme?.style) {
-            styleStr += (styleStr ? "; " : "") + traits.theme.style;
+        for (const trait of obj.traits || []) {
+          if (trait.name === "physics" || trait.name === "collidable") {
+            continue;
+          } else if (trait.name === "shadow") {
+            if (this.options.enableShadows) {
+              this.emit(`${v}.castShadow = true;`);
+              this.emit(`${v}.receiveShadow = true;`);
+            }
+          } else if (trait.name === "grabbable") {
+            this.emit(`// @grabbable \u2014 attach raycaster pointer-down handler to ${v}`);
+          } else if (trait.name === "hoverable") {
+            this.emit(`// @hoverable \u2014 attach raycaster pointer-move handler to ${v}`);
+          } else if (trait.name === "gaussian_splat") {
+            this.emit(
+              `// @gaussian_splat \u2014 use @mkkellogg/gaussian-splats-3d or three-splat for ${v}`
+            );
+          } else if (trait.name === "object_tracking") {
+            this.emit(`// @object_tracking \u2014 WebXR hit-test for ${v}`);
+          } else if (trait.name === "eye_tracked") {
+            this.emit(`// @eye_tracked \u2014 WebXR eye tracking for ${v}`);
+          } else if (trait.name === "controlnet") {
+            this.emit(
+              `// @controlnet(model: "${trait.config?.model || "canny"}") \u2014 route to inference API for ${v}`
+            );
+          } else {
+            this.emit(
+              `// @${this.escapeStringValue(trait.name, "TypeScript")}: ${JSON.stringify(trait.config || {})}`
+            );
           }
-          props += ` style="${styleStr}"`;
         }
-        if (classes.length > 0) {
-          props += ` class="${classes.join(" ")}"`;
-        }
-        if (traits.theme?.attributes) {
-          try {
-            const parsedAttrs = JSON.parse(traits.theme.attributes);
-            for (const [key, value] of Object.entries(parsedAttrs)) {
-              props += ` ${key}="${value}"`;
+        if (obj.traits && obj.traits.length > 0) {
+          const traitNames = obj.traits.map((t) => t.name);
+          const compositor = new chunkOIQYIIO3_cjs.TraitCompositor();
+          const composed = compositor.compose(traitNames);
+          if (Object.keys(composed).length > 0) {
+            this.emit(`// TraitCompositor: composed ${traitNames.join(" + ")}`);
+            const composedProps = this.buildMaterialProps(composed);
+            if (composedProps) {
+              this.emit(
+                `Object.assign((${v}.material as THREE.MeshStandardMaterial), { ${composedProps} });`
+              );
             }
-          } catch (e) {
           }
         }
-        if (traits.button?.onClick) props += ` onclick="${traits.button.onClick}"`;
-        if (traits.form?.onSubmit) props += ` onsubmit="${traits.form.onSubmit}"`;
-        if (traits.image?.src) props += ` src="${traits.image.src}"`;
-        if (traits.image?.alt) props += ` alt="${traits.image.alt}"`;
-        if (traits.link?.href) props += ` href="${traits.link.href}"`;
-        if (traits.input?.placeholder) props += ` placeholder="${traits.input.placeholder}"`;
-        if (traits.input?.type) props += ` type="${traits.input.type}"`;
-        if (traits.input?.required) props += ` required`;
-        const children = node.children || node.objects || [];
-        const childrenMarkup = children.map((child) => this.generateHTMLNode(child)).join("\n");
-        const content = traits.text?.content || traits.button?.content || traits.link?.content || traits.icon?.name;
-        if (tag === "img" || tag === "input") {
-          return `<${tag}${props}>`;
-        }
-        return `<${tag}${props}>
-      ${content ? content : ""}
-      ${childrenMarkup}
-    </${tag}>`;
-      }
-      // ============================================================================
-      // UTILITIES
-      // ============================================================================
-      extractTraits(obj) {
-        const map = {};
-        const node = obj;
-        if (!node.traits) return map;
-        for (const t of node.traits) {
-          map[t.name] = t.config || {};
-          if (t.name === "tailwind" && typeof t.config === "string") {
-            map[t.name] = { classes: t.config };
+        if (obj.children?.length) {
+          for (const child of obj.children) this.emitObject(child, v);
+        }
+        this.emit("");
+      }
+      // --- Groups ---
+      emitGroup(group, parentVar) {
+        const v = this.sanitizeName(group.name);
+        this.emit(
+          `const ${v} = new THREE.Group(); // "${this.escapeStringValue(group.name, "TypeScript")}"`
+        );
+        for (const p of group.properties) {
+          if (p.key === "position" && Array.isArray(p.value))
+            this.emit(`${v}.position.set(${p.value[0]}, ${p.value[1]}, ${p.value[2]});`);
+          else if (p.key === "rotation" && Array.isArray(p.value))
+            this.emit(`${v}.rotation.set(${p.value[0]}, ${p.value[1]}, ${p.value[2]});`);
+          else if (p.key === "scale") {
+            if (Array.isArray(p.value)) {
+              this.emit(`${v}.scale.set(${p.value[0]}, ${p.value[1]}, ${p.value[2]});`);
+            } else {
+              this.emit(`${v}.scale.setScalar(${p.value});`);
+            }
           }
         }
-        return map;
-      }
-      mapTextVariantToTag(variant) {
-        switch (variant) {
-          case "h1":
-            return "h1";
-          case "h2":
-            return "h2";
-          case "h3":
-            return "h3";
-          case "subtitle":
-            return "h4";
-          case "caption":
-            return "span";
-          case "emoji":
-            return "span";
-          default:
-            return "p";
+        const addTarget = parentVar ? parentVar : "this.scene";
+        this.emit(`${addTarget}.add(${v});`);
+        for (const obj of group.objects) this.emitObject(obj, v);
+        if (group.groups) {
+          for (const sub of group.groups) this.emitGroup(sub, v);
         }
+        this.emit("");
       }
-      buildStyles(traits) {
-        const styles = {};
-        const layout = traits.layout;
-        const theme = traits.theme;
-        if (layout) {
-          if (layout.flex) {
-            styles.display = "flex";
-            styles.flexDirection = layout.flex === "row" ? "row" : "column";
+      // --- Lights ---
+      emitLight(light) {
+        const v = this.sanitizeName(light.name);
+        let position;
+        let color;
+        let intensity;
+        let direction;
+        let castShadow = false;
+        let angle;
+        let distance;
+        let penumbra;
+        for (const p of light.properties) {
+          if (p.key === "position" && Array.isArray(p.value)) position = p.value;
+          else if (p.key === "color") color = p.value;
+          else if (p.key === "intensity") intensity = p.value;
+          else if (p.key === "direction" && Array.isArray(p.value)) direction = p.value;
+          else if (p.key === "cast_shadow" || p.key === "castShadow") castShadow = !!p.value;
+          else if (p.key === "angle") angle = p.value;
+          else if (p.key === "distance") distance = p.value;
+          else if (p.key === "penumbra") penumbra = p.value;
+        }
+        const colorHex = this.toThreeColorHex(color ?? "#ffffff");
+        const intStr = intensity !== void 0 ? String(intensity) : "1.0";
+        switch (light.lightType) {
+          case "hemisphere":
+          case "ambient":
+            this.emit(`const ${v} = new THREE.AmbientLight(${colorHex}, ${intStr});`);
+            this.emit(`this.scene.add(${v});`);
+            break;
+          case "directional": {
+            this.emit(`const ${v} = new THREE.DirectionalLight(${colorHex}, ${intStr});`);
+            const pos = position ?? direction ?? [5, 10, 5];
+            this.emit(`${v}.position.set(${pos[0]}, ${pos[1]}, ${pos[2]});`);
+            if (castShadow && this.options.enableShadows) {
+              this.emit(`${v}.castShadow = true;`);
+              this.emit(`${v}.shadow.mapSize.set(2048, 2048);`);
+              this.emit(`${v}.shadow.camera.near = 0.1;`);
+              this.emit(`${v}.shadow.camera.far = 500;`);
+            }
+            this.emit(`this.scene.add(${v});`);
+            break;
           }
-          if (layout.grid) {
-            styles.display = "grid";
-            styles.gridTemplateColumns = `repeat(${layout.columns || 1}, minmax(0, 1fr))`;
+          case "point": {
+            const distStr = distance !== void 0 ? String(distance) : "0";
+            this.emit(
+              `const ${v} = new THREE.PointLight(${colorHex}, ${intStr}, ${distStr});`
+            );
+            if (position) this.emit(`${v}.position.set(${position[0]}, ${position[1]}, ${position[2]});`);
+            if (castShadow && this.options.enableShadows) this.emit(`${v}.castShadow = true;`);
+            this.emit(`this.scene.add(${v});`);
+            break;
+          }
+          case "spot": {
+            const angleRad = angle !== void 0 ? `${angle} * Math.PI / 180` : "Math.PI / 6";
+            const pen = penumbra ?? 0.1;
+            this.emit(
+              `const ${v} = new THREE.SpotLight(${colorHex}, ${intStr}, ${distance ?? 0}, ${angleRad}, ${pen});`
+            );
+            if (position) this.emit(`${v}.position.set(${position[0]}, ${position[1]}, ${position[2]});`);
+            if (castShadow && this.options.enableShadows) this.emit(`${v}.castShadow = true;`);
+            this.emit(`this.scene.add(${v});`);
+            break;
           }
-          if (layout.justify) styles.justifyContent = layout.justify;
-          if (layout.align) styles.alignItems = layout.align;
-          if (layout.gap) styles.gap = typeof layout.gap === "number" ? `${layout.gap}px` : layout.gap;
-          if (layout.padding)
-            styles.padding = typeof layout.padding === "number" ? `${layout.padding}px` : layout.padding;
-        }
-        if (theme) {
-          if (theme.backgroundColor) styles.backgroundColor = theme.backgroundColor;
-          if (theme.color) styles.color = theme.color;
-          if (theme.padding)
-            styles.padding = typeof theme.padding === "number" ? `${theme.padding}px` : theme.padding;
-          if (theme.borderRadius)
-            styles.borderRadius = typeof theme.borderRadius === "number" ? `${theme.borderRadius}px` : theme.borderRadius;
-          if (theme.border) styles.border = theme.border;
-          if (theme.borderTop) styles.borderTop = theme.borderTop;
-        }
-        if (traits.text) {
-          if (traits.text.align) styles.textAlign = traits.text.align;
-          if (traits.text.maxWidth)
-            styles.maxWidth = typeof traits.text.maxWidth === "number" ? `${traits.text.maxWidth}px` : traits.text.maxWidth;
-          if (traits.text.weight) styles.fontWeight = traits.text.weight;
-        }
-        return styles;
-      }
-      buildClasses(traits) {
-        const classes = [];
-        if (traits.text) {
-          if (traits.text.variant === "h1") classes.push("text-5xl font-bold tracking-tight");
-          if (traits.text.variant === "h2") classes.push("text-3xl font-bold");
-          if (traits.text.variant === "h3") classes.push("text-xl font-semibold");
-          if (traits.text.variant === "subtitle") classes.push("text-xl text-gray-400");
-          if (traits.text.variant === "caption") classes.push("text-sm text-gray-500");
-          if (traits.text.variant === "emoji") classes.push("text-2xl");
-        }
-        if (traits.button) {
-          classes.push("px-4 py-2 rounded-lg font-medium transition-all");
-          if (traits.button.variant === "primary")
-            classes.push("bg-blue-600 hover:bg-blue-700 text-white");
-          if (traits.button.variant === "outline")
-            classes.push("border border-gray-600 hover:bg-gray-800 text-white");
-          if (traits.button.variant === "ghost")
-            classes.push("hover:bg-gray-800 text-gray-300 hover:text-white");
-          if (traits.button.variant === "glow")
-            classes.push("bg-indigo-600 text-white glow-btn hover:bg-indigo-500");
-          if (traits.button.size === "lg") classes.push("px-6 py-3 text-lg");
-          if (traits.button.size === "sm") classes.push("px-3 py-1 text-sm");
-        }
-        if (traits.card) {
-          if (traits.card.shadow === "md") classes.push("shadow-md");
-          if (traits.card.shadow === "lg") classes.push("shadow-lg");
-          if (traits.card.hover === "glow") classes.push("lift-card");
-        }
-        if (traits.input) {
-          classes.push(
-            "px-4 py-2 rounded-lg border border-gray-700 bg-gray-900 text-white focus:ring-2 focus:ring-indigo-500 outline-none"
+          default:
+            this.emit(`// Light "${light.lightType}" not mapped \u2014 using AmbientLight fallback`);
+            this.emit(`const ${v} = new THREE.AmbientLight(${colorHex}, ${intStr});`);
+            this.emit(`this.scene.add(${v});`);
+        }
+        this.emit("");
+      }
+      // --- Camera ---
+      emitCamera(camera) {
+        let position;
+        let target;
+        let fov;
+        let near;
+        let far;
+        for (const p of camera.properties) {
+          if (p.key === "position" && Array.isArray(p.value)) position = p.value;
+          else if (p.key === "target" && Array.isArray(p.value)) target = p.value;
+          else if (p.key === "fov") fov = p.value;
+          else if (p.key === "near") near = p.value;
+          else if (p.key === "far") far = p.value;
+        }
+        if (fov !== void 0) this.emit(`this.camera.fov = ${fov};`);
+        if (near !== void 0) this.emit(`this.camera.near = ${near};`);
+        if (far !== void 0) this.emit(`this.camera.far = ${far};`);
+        if (position)
+          this.emit(
+            `this.camera.position.set(${position[0]}, ${position[1]}, ${position[2]});`
+          );
+        if (target) {
+          this.emit(
+            `this.camera.lookAt(new THREE.Vector3(${target[0]}, ${target[1]}, ${target[2]}));`
+          );
+        }
+        this.emit(`this.camera.updateProjectionMatrix();`);
+        this.emit("");
+      }
+      // --- Audio ---
+      emitAudio(audio) {
+        const v = this.sanitizeName(audio.name);
+        let src = "";
+        let loop = false;
+        let volume = 1;
+        let spatial = false;
+        for (const p of audio.properties) {
+          if (p.key === "src" || p.key === "source") src = String(p.value);
+          else if (p.key === "loop") loop = !!p.value;
+          else if (p.key === "volume") volume = p.value;
+          else if (p.key === "spatial") spatial = !!p.value;
+        }
+        if (spatial) {
+          this.emit(`const ${v}Listener = new THREE.AudioListener();`);
+          this.emit(`this.camera.add(${v}Listener);`);
+          this.emit(`const ${v} = new THREE.PositionalAudio(${v}Listener);`);
+        } else {
+          this.emit(`const ${v}Listener = new THREE.AudioListener();`);
+          this.emit(`this.camera.add(${v}Listener);`);
+          this.emit(`const ${v} = new THREE.Audio(${v}Listener);`);
+        }
+        this.emit(`const ${v}Loader = new THREE.AudioLoader();`);
+        this.emit(
+          `${v}Loader.load("${src}", (buffer) => { ${v}.setBuffer(buffer); ${v}.setLoop(${loop}); ${v}.setVolume(${volume}); ${v}.play(); });`
+        );
+        this.emit("");
+      }
+      // --- Zones ---
+      emitZone(zone) {
+        const v = this.sanitizeName(zone.name);
+        let shape = "box";
+        let position;
+        let size;
+        let radius;
+        for (const p of zone.properties) {
+          if (p.key === "shape") shape = String(p.value);
+          else if (p.key === "position" && Array.isArray(p.value)) position = p.value;
+          else if (p.key === "size") size = p.value;
+          else if (p.key === "radius") radius = p.value;
+        }
+        if (shape === "sphere") {
+          this.emit(
+            `const ${v}Geom = new THREE.SphereGeometry(${radius ?? 5}, 16, 16);`
           );
+        } else {
+          const s = Array.isArray(size) ? size : [size ?? 5, size ?? 5, size ?? 5];
+          this.emit(`const ${v}Geom = new THREE.BoxGeometry(${s[0]}, ${s[1]}, ${s[2]});`);
+        }
+        this.emit(
+          `const ${v}Mat = new THREE.MeshBasicMaterial({ color: 0x00ff00, wireframe: true, visible: false });`
+        );
+        this.emit(`const ${v} = new THREE.Mesh(${v}Geom, ${v}Mat);`);
+        if (position) this.emit(`${v}.position.set(${position[0]}, ${position[1]}, ${position[2]});`);
+        this.emit(`this.scene.add(${v}); // trigger zone (invisible)`);
+        if (zone.handlers?.length) {
+          this.emit(
+            `// Zone handlers: attach raycaster intersection checks for ${v}`
+          );
+          for (const h of zone.handlers) {
+            this.emit(
+              `// on ${this.escapeStringValue(h.event, "TypeScript")}: implement via raycaster.intersectObject(${v})`
+            );
+          }
         }
-        if (traits.tailwind?.classes) {
-          classes.push(traits.tailwind.classes);
+        this.emit("");
+      }
+      // --- Render Loop ---
+      emitRenderLoop() {
+        this.emit("// Render loop");
+        this.emit("const animate = (): void => {");
+        this.indent();
+        this.emit("this.frameId = requestAnimationFrame(animate);");
+        this.emit("this.renderer.render(this.scene, this.camera);");
+        this.dedent();
+        this.emit("};");
+        this.emit("animate();");
+        this.emit("");
+        this.emit("// Resize handler");
+        this.emit('window.addEventListener("resize", () => {');
+        this.indent();
+        this.emit("const w = this.canvas.clientWidth, h = this.canvas.clientHeight;");
+        this.emit("this.renderer.setSize(w, h);");
+        this.emit("this.camera.aspect = w / h;");
+        this.emit("this.camera.updateProjectionMatrix();");
+        this.dedent();
+        this.emit("});");
+      }
+      // --- Value Helpers ---
+      toThreeColorHex(value) {
+        if (typeof value === "string" && value.startsWith("#")) {
+          return `0x${value.slice(1)}`;
         }
-        return classes;
+        if (typeof value === "number") return `0x${value.toString(16).padStart(6, "0")}`;
+        return "0xffffff";
       }
-      camelToKebab(str) {
-        return str.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+      buildMaterialProps(mat) {
+        const parts = [];
+        if (mat.color !== void 0) {
+          parts.push(`color: ${this.toThreeColorHex(mat.color)}`);
+        }
+        if (mat.roughness !== void 0) parts.push(`roughness: ${mat.roughness}`);
+        if (mat.metalness !== void 0) parts.push(`metalness: ${mat.metalness}`);
+        if (mat.opacity !== void 0 && mat.opacity < 1) {
+          parts.push(`opacity: ${mat.opacity}`, "transparent: true");
+        }
+        if (mat.emissive !== void 0) {
+          parts.push(`emissive: ${this.toThreeColorHex(mat.emissive)}`);
+        }
+        if (mat.emissiveIntensity !== void 0) {
+          parts.push(`emissiveIntensity: ${mat.emissiveIntensity}`);
+        }
+        return parts.join(", ");
+      }
+      geometryArgs(type, size) {
+        const s = typeof size === "number" ? size : 1;
+        switch (type) {
+          case "sphere":
+          case "orb":
+            return `${s * 0.5}, 32, 32`;
+          case "cube":
+          case "box":
+            return `${s}, ${s}, ${s}`;
+          case "cylinder":
+            return `${s * 0.5}, ${s * 0.5}, ${s * 2}, 32`;
+          case "cone":
+          case "pyramid":
+            return `${s * 0.5}, ${s * 2}, ${type === "pyramid" ? 4 : 32}`;
+          case "plane":
+          case "ground":
+            return `${s}, ${s}`;
+          case "torus":
+          case "ring":
+            return `${s * 0.5}, ${s * 0.15}, 16, 64`;
+          case "capsule":
+            return `${s * 0.3}, ${s * 0.6}, 4, 16`;
+          default:
+            return `${s}, ${s}, ${s}`;
+        }
+      }
+      // --- Emit Helpers ---
+      emit(line) {
+        this.lines.push(this.options.indent.repeat(this.indentLevel) + line);
+      }
+      indent() {
+        this.indentLevel++;
+      }
+      dedent() {
+        this.indentLevel = Math.max(0, this.indentLevel - 1);
+      }
+      sanitizeName(name) {
+        return name.replace(/[^a-zA-Z0-9_]/g, "_");
       }
     };
   }
@@ -473,16 +646,15 @@ export default ${safeName}Component;
 
 // src/compiler/A2AAgentCardCompiler.ts
 var A2AAgentCardCompiler_exports = {};
-chunkEGIZHYJP_cjs.__export(A2AAgentCardCompiler_exports, {
+chunkHCCQLAA4_cjs.__export(A2AAgentCardCompiler_exports, {
   A2AAgentCardCompiler: () => exports.A2AAgentCardCompiler,
   default: () => A2AAgentCardCompiler_default
 });
 exports.A2AAgentCardCompiler = void 0; var A2AAgentCardCompiler_default;
-var init_A2AAgentCardCompiler = chunkEGIZHYJP_cjs.__esm({
+var init_A2AAgentCardCompiler = chunkHCCQLAA4_cjs.__esm({
   "src/compiler/A2AAgentCardCompiler.ts"() {
-    chunkQHVVVN47_cjs.init_CompilerBase();
-    chunkQHVVVN47_cjs.init_ANSNamespace();
-    exports.A2AAgentCardCompiler = class extends chunkQHVVVN47_cjs.CompilerBase {
+    chunkRMHC2VG7_cjs.init_CompilerBase();
+    exports.A2AAgentCardCompiler = class extends chunkRMHC2VG7_cjs.CompilerBase {
       constructor(options = {}) {
         super();
         this.compilerName = "A2AAgentCardCompiler";
@@ -507,7 +679,7 @@ var init_A2AAgentCardCompiler = chunkEGIZHYJP_cjs.__esm({
         };
       }
       getRequiredCapability() {
-        return chunkQHVVVN47_cjs.ANSCapabilityPath.A2A_AGENT_CARD;
+        return ans.ANSCapabilityPath.A2A_AGENT_CARD;
       }
       /**
        * Compile a HoloComposition AST into an A2A Agent Card JSON string.
@@ -635,9 +807,7 @@ var init_A2AAgentCardCompiler = chunkEGIZHYJP_cjs.__esm({
           }
         }
         if (examples.length === 0) {
-          examples.push(
-            `Create a ${this.escapeStringValue(template.name, "JSON")} instance`
-          );
+          examples.push(`Create a ${this.escapeStringValue(template.name, "JSON")} instance`);
         }
         return {
           id: this.sanitizeId(template.name),
@@ -665,9 +835,7 @@ var init_A2AAgentCardCompiler = chunkEGIZHYJP_cjs.__esm({
         }
         const examples = [];
         if (objTraitNames.includes("sensor")) {
-          examples.push(
-            `Read sensor data from ${this.escapeStringValue(obj.name, "JSON")}`
-          );
+          examples.push(`Read sensor data from ${this.escapeStringValue(obj.name, "JSON")}`);
         }
         if (objTraitNames.includes("networked")) {
           examples.push(
@@ -758,26 +926,10 @@ var init_A2AAgentCardCompiler = chunkEGIZHYJP_cjs.__esm({
        * Compile a domain-specific block into a specialized skill.
        */
       compileDomainBlockSkill(block) {
-        const domainTags = {
-          iot: ["iot", "sensor", "telemetry", "digital-twin"],
-          robotics: ["robotics", "control", "actuator", "simulation"],
-          dataviz: ["data-visualization", "analytics", "dashboard"],
-          education: ["education", "learning", "curriculum"],
-          healthcare: ["healthcare", "medical", "monitoring"],
-          music: ["music", "audio", "composition"],
-          architecture: ["architecture", "building", "design"],
-          web3: ["web3", "blockchain", "smart-contract"],
-          physics: ["physics", "simulation", "collision"],
-          material: ["material", "rendering", "pbr"],
-          vfx: ["vfx", "particles", "visual-effects"],
-          weather: ["weather", "atmosphere", "environmental"],
-          navigation: ["navigation", "pathfinding", "ai"],
-          procedural: ["procedural", "generation", "algorithms"]
-        };
         const tags = [
           block.domain,
           block.keyword,
-          ...domainTags[block.domain] || [block.domain],
+          ...block.domainTags?.length ? block.domainTags : [],
           ...block.traits
         ];
         return {
@@ -945,9 +1097,7 @@ var init_A2AAgentCardCompiler = chunkEGIZHYJP_cjs.__esm({
        */
       generateDescription(composition) {
         const parts = [];
-        parts.push(
-          `HoloScript agent "${this.escapeStringValue(composition.name, "JSON")}"`
-        );
+        parts.push(`HoloScript agent "${this.escapeStringValue(composition.name, "JSON")}"`);
         const features = [];
         if (composition.templates?.length) {
           features.push(`${composition.templates.length} template(s)`);
@@ -1044,7 +1194,7 @@ function validateNIRGraph(graph) {
   return { valid: errors.length === 0, errors };
 }
 var NEURON_TRAIT_MAP, SYNAPSE_TRAIT_MAP, ENCODING_TRAIT_MAP, TOPOLOGY_TRAIT_MAP, NIR_TRAIT_MAP;
-var init_NIRTraitMap = chunkEGIZHYJP_cjs.__esm({
+var init_NIRTraitMap = chunkHCCQLAA4_cjs.__esm({
   "src/compiler/NIRTraitMap.ts"() {
     NEURON_TRAIT_MAP = {
       lif_neuron: {
@@ -1558,17 +1708,16 @@ var init_NIRTraitMap = chunkEGIZHYJP_cjs.__esm({
 
 // src/compiler/NIRCompiler.ts
 var NIRCompiler_exports = {};
-chunkEGIZHYJP_cjs.__export(NIRCompiler_exports, {
+chunkHCCQLAA4_cjs.__export(NIRCompiler_exports, {
   NIRCompiler: () => exports.NIRCompiler,
   default: () => NIRCompiler_default
 });
 exports.NIRCompiler = void 0; var NIRCompiler_default;
-var init_NIRCompiler = chunkEGIZHYJP_cjs.__esm({
+var init_NIRCompiler = chunkHCCQLAA4_cjs.__esm({
   "src/compiler/NIRCompiler.ts"() {
-    chunkQHVVVN47_cjs.init_CompilerBase();
-    chunkQHVVVN47_cjs.init_ANSNamespace();
+    chunkRMHC2VG7_cjs.init_CompilerBase();
     init_NIRTraitMap();
-    exports.NIRCompiler = class extends chunkQHVVVN47_cjs.CompilerBase {
+    exports.NIRCompiler = class extends chunkRMHC2VG7_cjs.CompilerBase {
       constructor(options = {}) {
         super();
         this.compilerName = "NIRCompiler";
@@ -1589,7 +1738,7 @@ var init_NIRCompiler = chunkEGIZHYJP_cjs.__esm({
         };
       }
       getRequiredCapability() {
-        return chunkQHVVVN47_cjs.ANSCapabilityPath.NIR;
+        return ans.ANSCapabilityPath.NIR;
       }
       /**
        * Compile a HoloScript composition to NIR graph JSON.
@@ -1913,691 +2062,21 @@ var init_NIRCompiler = chunkEGIZHYJP_cjs.__esm({
   }
 });
 
-// src/parser/PipelineParser.ts
-function stripComments(source) {
-  const lines = source.split("\n");
-  return lines.map((line) => {
-    let inString = null;
-    for (let i = 0; i < line.length; i++) {
-      const ch = line[i];
-      if (inString) {
-        if (ch === inString && line[i - 1] !== "\\") inString = null;
-      } else if (ch === '"' || ch === "'") {
-        inString = ch;
-      } else if (ch === "/" && line[i + 1] === "/") {
-        return line.substring(0, i);
-      }
-    }
-    return line;
-  }).join("\n");
-}
-function parseDuration(value) {
-  const match = value.match(/^(\d+)(s|m|h|d)$/);
-  if (!match) return void 0;
-  return { value: parseInt(match[1], 10), unit: match[2] };
-}
-function extractBlock(source, keyword, name) {
-  const results = [];
-  const namePattern = "(\\w+)";
-  const regex = new RegExp(`${keyword}\\s+${namePattern}\\s*\\{`, "g");
-  let match;
-  while ((match = regex.exec(source)) !== null) {
-    const blockName = match[1];
-    const startLine = source.substring(0, match.index).split("\n").length;
-    const startIdx = source.indexOf("{", match.index);
-    let depth = 1;
-    let i = startIdx + 1;
-    while (i < source.length && depth > 0) {
-      if (source[i] === "{") depth++;
-      if (source[i] === "}") depth--;
-      i++;
-    }
-    results.push({
-      content: source.substring(startIdx + 1, i - 1),
-      name: blockName,
-      startLine
-    });
-  }
-  return results;
-}
-function parseProperties(content) {
-  const props = {};
-  const lines = content.split("\n");
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("//")) continue;
-    const kvMatch = trimmed.match(/^(\w+)\s*:\s+(.+)$/);
-    if (kvMatch) {
-      const key = kvMatch[1];
-      let val = kvMatch[2].trim();
-      if (typeof val === "string" && val.endsWith(",")) {
-        val = val.slice(0, -1).trim();
-      }
-      if (typeof val === "string") {
-        const strVal = val;
-        if (strVal.startsWith('"') && strVal.endsWith('"')) {
-          val = strVal.slice(1, -1);
-        } else if (strVal.startsWith("'") && strVal.endsWith("'")) {
-          val = strVal.slice(1, -1);
-        } else if (strVal === "true") {
-          val = true;
-        } else if (strVal === "false") {
-          val = false;
-        } else if (/^\d+$/.test(strVal)) {
-          val = parseInt(strVal, 10);
-        } else if (/^\d+\.\d+$/.test(strVal)) {
-          val = parseFloat(strVal);
-        }
-      }
-      props[key] = val;
-    }
-  }
-  return props;
-}
-function parseNestedBlock(content, keyword) {
-  const blocks = extractBlock(content, keyword);
-  if (blocks.length === 0) return void 0;
-  return parseProperties(blocks[0].content);
-}
-function parseFieldMappings(content) {
-  const mappings = [];
-  const lines = content.split("\n");
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("//")) continue;
-    const mapMatch = trimmed.match(/^(\w+)\s*->\s*(\w+)(?:\s*:\s*(.+))?$/);
-    if (mapMatch) {
-      const transforms = mapMatch[3] ? mapMatch[3].split(":").map((t) => t.trim()).filter(Boolean) : [];
-      mappings.push({
-        from: mapMatch[1],
-        to: mapMatch[2],
-        transforms
-      });
-    }
-  }
-  return mappings;
-}
-function parseValidateFields(content) {
-  const fields = [];
-  const lines = content.split("\n");
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("//")) continue;
-    const vMatch = trimmed.match(/^(\w+)\s*:\s*(.+)$/);
-    if (vMatch) {
-      const rules = vMatch[2].split(",").map((r) => r.trim()).filter(Boolean);
-      fields.push({ field: vMatch[1], rules });
-    }
-  }
-  return fields;
-}
-function parseBranchRoutes(content) {
-  const routes = [];
-  const lines = content.split("\n");
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("//")) continue;
-    const whenMatch = trimmed.match(/^when\s+(.+?)\s*->\s*sink\s+(\w+)$/);
-    if (whenMatch) {
-      routes.push({ condition: whenMatch[1], sinkName: whenMatch[2] });
-      continue;
-    }
-    const defaultMatch = trimmed.match(/^default\s*->\s*sink\s+(\w+)$/);
-    if (defaultMatch) {
-      routes.push({ condition: "default", sinkName: defaultMatch[1] });
-    }
-  }
-  return routes;
-}
-function parseStringArray(content) {
-  const match = content.match(/\[([\s\S]*?)\]/);
-  if (!match) return [];
-  return match[1].split(",").map((s) => s.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
-}
-function parsePipeline(source) {
-  const errors = [];
-  const clean = stripComments(source);
-  const pipelineBlocks = extractBlock(clean, "pipeline");
-  if (pipelineBlocks.length === 0) {
-    const quotedMatch = clean.match(/pipeline\s+["']([^"']+)["']\s*\{/);
-    if (!quotedMatch) {
-      return { success: false, errors: [{ message: "No pipeline block found" }] };
-    }
-    const startIdx = clean.indexOf("{", quotedMatch.index);
-    let depth = 1;
-    let i = startIdx + 1;
-    while (i < clean.length && depth > 0) {
-      if (clean[i] === "{") depth++;
-      if (clean[i] === "}") depth--;
-      i++;
-    }
-    const pipelineContent = clean.substring(startIdx + 1, i - 1);
-    return parsePipelineContent(quotedMatch[1], pipelineContent, errors);
-  }
-  return parsePipelineContent(pipelineBlocks[0].name, pipelineBlocks[0].content, errors);
-}
-function parsePipelineContent(name, content, errors) {
-  const invalidKeywords = [
-    "environment",
-    "spatial_group",
-    "template",
-    "object",
-    "orb",
-    "theme",
-    "light",
-    "camera",
-    "audio",
-    "zone",
-    "timeline",
-    "particle_system",
-    "effects",
-    "ui",
-    "npc",
-    "quest",
-    "dialogue",
-    "ability",
-    "achievement",
-    "talent_tree",
-    "behavior",
-    "state_machine",
-    "shape",
-    "terrain",
-    "waypoints",
-    "spawn_group",
-    "composition",
-    "constraint",
-    "sub_orb",
-    "norm",
-    "metanorm"
-  ];
-  for (const keyword of invalidKeywords) {
-    if (new RegExp(`\\b${keyword}\\b`).test(content)) {
-      errors.push({
-        message: `SyntaxError: '${keyword}' is not valid in a pipeline context. Use .holo for spatial compositions or .hsplus for behaviors.`
-      });
-    }
-  }
-  const props = parseProperties(content);
-  const schedule = typeof props.schedule === "string" ? props.schedule : void 0;
-  const timeout = typeof props.timeout === "string" ? parseDuration(props.timeout) : void 0;
-  let retry;
-  const retryBlock = parseNestedBlock(content, "retry");
-  if (retryBlock) {
-    retry = {
-      max: typeof retryBlock.max === "number" ? retryBlock.max : 3,
-      backoff: retryBlock.backoff || "exponential"
-    };
-  }
-  const sources = [];
-  for (const block of extractBlock(content, "source")) {
-    const p = parseProperties(block.content);
-    sources.push({
-      kind: "source",
-      name: block.name,
-      type: p.type || "rest",
-      endpoint: p.endpoint,
-      path: p.path,
-      pattern: p.pattern,
-      since: p.since,
-      method: p.method,
-      auth: parseNestedBlock(block.content, "auth"),
-      pagination: parseNestedBlock(block.content, "pagination"),
-      properties: p
-    });
-  }
-  const transforms = [];
-  for (const block of extractBlock(content, "transform")) {
-    const p = parseProperties(block.content);
-    const mappings = parseFieldMappings(block.content);
-    const hasType = p.type !== void 0;
-    transforms.push({
-      kind: "transform",
-      name: block.name,
-      type: hasType ? p.type : mappings.length > 0 ? "field_mapping" : void 0,
-      mappings: mappings.length > 0 ? mappings : void 0,
-      model: p.model,
-      prompt: p.prompt,
-      input: p.input,
-      output: p.output,
-      server: p.server,
-      tool: p.tool,
-      method: p.method,
-      url: p.url,
-      timeout: typeof p.timeout === "string" ? parseDuration(p.timeout) : void 0,
-      where: p.where,
-      properties: p
-    });
-  }
-  const filters = [];
-  for (const block of extractBlock(content, "filter")) {
-    const p = parseProperties(block.content);
-    if (!p.where) {
-      errors.push({ message: `Filter "${block.name}" missing 'where' clause`, line: block.startLine, block: block.name });
-    }
-    filters.push({
-      kind: "filter",
-      name: block.name,
-      where: p.where || ""
-    });
-  }
-  const validates = [];
-  for (const block of extractBlock(content, "validate")) {
-    validates.push({
-      kind: "validate",
-      name: block.name,
-      fields: parseValidateFields(block.content)
-    });
-  }
-  const merges = [];
-  for (const block of extractBlock(content, "merge")) {
-    const p = parseProperties(block.content);
-    const fromArr = typeof p.from === "string" ? parseStringArray(p.from) : [];
-    merges.push({
-      kind: "merge",
-      name: block.name,
-      from: fromArr,
-      dedup: parseNestedBlock(block.content, "dedup"),
-      strategy: p.strategy
-    });
-  }
-  const branches = [];
-  for (const block of extractBlock(content, "branch")) {
-    branches.push({
-      kind: "branch",
-      name: block.name,
-      routes: parseBranchRoutes(block.content)
-    });
-  }
-  const sinks = [];
-  for (const block of extractBlock(content, "sink")) {
-    const p = parseProperties(block.content);
-    sinks.push({
-      kind: "sink",
-      name: block.name,
-      type: p.type || "rest",
-      endpoint: p.endpoint,
-      path: p.path,
-      method: p.method,
-      auth: parseNestedBlock(block.content, "auth"),
-      batch: parseNestedBlock(block.content, "batch"),
-      onError: parseNestedBlock(block.content, "on_error"),
-      format: p.format,
-      append: p.append,
-      server: p.server,
-      tool: p.tool,
-      properties: p
-    });
-  }
-  const steps = [
-    ...sources,
-    ...merges,
-    ...transforms,
-    ...filters,
-    ...validates,
-    ...branches,
-    ...sinks
-  ];
-  if (sources.length === 0) {
-    errors.push({ message: "Pipeline has no sources" });
-  }
-  if (sinks.length === 0) {
-    errors.push({ message: "Pipeline has no sinks" });
-  }
-  const pipeline = {
-    name,
-    schedule,
-    timeout,
-    retry,
-    steps,
-    sources,
-    transforms,
-    filters,
-    validates,
-    merges,
-    branches,
-    sinks
-  };
-  return { success: errors.length === 0, pipeline, errors };
-}
-function isPipelineSource(source) {
-  return /pipeline\s+["']?\w/.test(source);
-}
-
-// src/compiler/platform/PlatformConditional.ts
-var PLATFORM_CATEGORIES = {
-  vr: ["quest3", "pcvr", "visionos", "android-xr"],
-  ar: ["visionos-ar", "android-xr-ar", "webxr"],
-  mobile: ["ios", "android"],
-  desktop: ["windows", "macos", "linux", "web"],
-  automotive: ["android-auto", "carplay"],
-  wearable: ["watchos", "wearos"]
-};
-var ALL_PLATFORMS = Object.values(
-  PLATFORM_CATEGORIES
-).flat();
-function platformCategory(target) {
-  for (const [cat, platforms] of Object.entries(PLATFORM_CATEGORIES)) {
-    if (platforms.includes(target)) return cat;
-  }
-  return "desktop";
-}
-var PLATFORM_CAPABILITIES = {
-  quest3: {
-    spatialTracking: true,
-    handTracking: true,
-    eyeTracking: true,
-    haptics: true,
-    spatialAudio: true,
-    gpu3D: true,
-    arCamera: true,
-    gps: false,
-    npu: true,
-    webxrSupport: true,
-    frameBudgetMs: 11.1,
-    agentBudgetMs: 5,
-    computeModel: "edge-first"
-  },
-  pcvr: {
-    spatialTracking: true,
-    handTracking: true,
-    eyeTracking: true,
-    haptics: true,
-    spatialAudio: true,
-    gpu3D: true,
-    arCamera: false,
-    gps: false,
-    npu: false,
-    webxrSupport: true,
-    frameBudgetMs: 11.1,
-    agentBudgetMs: 5,
-    computeModel: "edge-first"
-  },
-  visionos: {
-    spatialTracking: true,
-    handTracking: true,
-    eyeTracking: true,
-    haptics: false,
-    spatialAudio: true,
-    gpu3D: true,
-    arCamera: true,
-    gps: false,
-    npu: true,
-    webxrSupport: false,
-    frameBudgetMs: 11.1,
-    agentBudgetMs: 5,
-    computeModel: "edge-first"
-  },
-  "android-xr": {
-    spatialTracking: true,
-    handTracking: true,
-    eyeTracking: true,
-    haptics: true,
-    spatialAudio: true,
-    gpu3D: true,
-    arCamera: true,
-    gps: true,
-    npu: true,
-    webxrSupport: true,
-    frameBudgetMs: 11.1,
-    agentBudgetMs: 5,
-    computeModel: "edge-first"
-  },
-  "visionos-ar": {
-    spatialTracking: true,
-    handTracking: true,
-    eyeTracking: true,
-    haptics: false,
-    spatialAudio: true,
-    gpu3D: true,
-    arCamera: true,
-    gps: true,
-    npu: true,
-    webxrSupport: false,
-    frameBudgetMs: 16.6,
-    agentBudgetMs: 10,
-    computeModel: "edge-first"
-  },
-  "android-xr-ar": {
-    spatialTracking: true,
-    handTracking: true,
-    eyeTracking: false,
-    haptics: true,
-    spatialAudio: true,
-    gpu3D: true,
-    arCamera: true,
-    gps: true,
-    npu: true,
-    webxrSupport: true,
-    frameBudgetMs: 16.6,
-    agentBudgetMs: 10,
-    computeModel: "edge-first"
-  },
-  webxr: {
-    spatialTracking: true,
-    handTracking: false,
-    eyeTracking: false,
-    haptics: false,
-    spatialAudio: false,
-    gpu3D: true,
-    arCamera: true,
-    gps: false,
-    npu: false,
-    webxrSupport: true,
-    frameBudgetMs: 16.6,
-    agentBudgetMs: 15,
-    computeModel: "cloud-first"
-  },
-  ios: {
-    spatialTracking: false,
-    handTracking: false,
-    eyeTracking: false,
-    haptics: true,
-    spatialAudio: false,
-    gpu3D: true,
-    arCamera: true,
-    gps: true,
-    npu: true,
-    webxrSupport: false,
-    frameBudgetMs: 16.6,
-    agentBudgetMs: 100,
-    computeModel: "cloud-first"
-  },
-  android: {
-    spatialTracking: false,
-    handTracking: false,
-    eyeTracking: false,
-    haptics: true,
-    spatialAudio: false,
-    gpu3D: true,
-    arCamera: true,
-    gps: true,
-    npu: true,
-    webxrSupport: true,
-    frameBudgetMs: 16.6,
-    agentBudgetMs: 100,
-    computeModel: "cloud-first"
-  },
-  windows: {
-    spatialTracking: false,
-    handTracking: false,
-    eyeTracking: false,
-    haptics: false,
-    spatialAudio: false,
-    gpu3D: true,
-    arCamera: false,
-    gps: false,
-    npu: false,
-    webxrSupport: true,
-    frameBudgetMs: 16.6,
-    agentBudgetMs: 200,
-    computeModel: "cloud-first"
-  },
-  macos: {
-    spatialTracking: false,
-    handTracking: false,
-    eyeTracking: false,
-    haptics: false,
-    spatialAudio: false,
-    gpu3D: true,
-    arCamera: false,
-    gps: false,
-    npu: true,
-    webxrSupport: true,
-    frameBudgetMs: 16.6,
-    agentBudgetMs: 200,
-    computeModel: "cloud-first"
-  },
-  linux: {
-    spatialTracking: false,
-    handTracking: false,
-    eyeTracking: false,
-    haptics: false,
-    spatialAudio: false,
-    gpu3D: true,
-    arCamera: false,
-    gps: false,
-    npu: false,
-    webxrSupport: true,
-    frameBudgetMs: 16.6,
-    agentBudgetMs: 200,
-    computeModel: "cloud-first"
-  },
-  web: {
-    spatialTracking: false,
-    handTracking: false,
-    eyeTracking: false,
-    haptics: false,
-    spatialAudio: false,
-    gpu3D: true,
-    arCamera: false,
-    gps: false,
-    npu: false,
-    webxrSupport: true,
-    frameBudgetMs: 16.6,
-    agentBudgetMs: 200,
-    computeModel: "cloud-first"
-  },
-  "android-auto": {
-    spatialTracking: false,
-    handTracking: false,
-    eyeTracking: false,
-    haptics: false,
-    spatialAudio: true,
-    gpu3D: false,
-    arCamera: false,
-    gps: true,
-    npu: false,
-    webxrSupport: false,
-    frameBudgetMs: 30,
-    agentBudgetMs: 15,
-    computeModel: "safety-critical"
-  },
-  carplay: {
-    spatialTracking: false,
-    handTracking: false,
-    eyeTracking: false,
-    haptics: false,
-    spatialAudio: true,
-    gpu3D: false,
-    arCamera: false,
-    gps: true,
-    npu: false,
-    webxrSupport: false,
-    frameBudgetMs: 30,
-    agentBudgetMs: 15,
-    computeModel: "safety-critical"
-  },
-  watchos: {
-    spatialTracking: false,
-    handTracking: false,
-    eyeTracking: false,
-    haptics: true,
-    spatialAudio: false,
-    gpu3D: false,
-    arCamera: false,
-    gps: true,
-    npu: true,
-    webxrSupport: false,
-    frameBudgetMs: 33.3,
-    agentBudgetMs: 50,
-    computeModel: "cloud-first"
-  },
-  wearos: {
-    spatialTracking: false,
-    handTracking: false,
-    eyeTracking: false,
-    haptics: true,
-    spatialAudio: false,
-    gpu3D: false,
-    arCamera: false,
-    gps: true,
-    npu: false,
-    webxrSupport: false,
-    frameBudgetMs: 33.3,
-    agentBudgetMs: 50,
-    computeModel: "cloud-first"
-  }
-};
-var DEFAULT_EMBODIMENT = {
-  vr: "Avatar3D",
-  ar: "SpatialPersona",
-  mobile: "UI2D",
-  desktop: "FullGUI",
-  automotive: "VoiceHUD",
-  wearable: "UI2D"
-};
-function resolvePlatforms(condition) {
-  let platforms = /* @__PURE__ */ new Set();
-  if (condition.include) {
-    for (const p of condition.include) platforms.add(p);
-  }
-  if (condition.includeCategories) {
-    for (const cat of condition.includeCategories) {
-      for (const p of PLATFORM_CATEGORIES[cat]) platforms.add(p);
-    }
-  }
-  if (!condition.include && !condition.includeCategories) {
-    for (const p of ALL_PLATFORMS) platforms.add(p);
-  }
-  if (condition.exclude) {
-    for (const p of condition.exclude) platforms.delete(p);
-  }
-  if (condition.requireCapabilities) {
-    platforms = new Set(
-      [...platforms].filter((p) => {
-        const caps = PLATFORM_CAPABILITIES[p];
-        return condition.requireCapabilities.every((cap) => {
-          const val = caps[cap];
-          return typeof val === "boolean" ? val : Number(val) > 0;
-        });
-      })
-    );
-  }
-  return [...platforms];
-}
-function matchesPlatform(target, condition) {
-  return resolvePlatforms(condition).includes(target);
-}
-function selectBlock(target, blocks) {
-  for (const block of blocks) {
-    if (matchesPlatform(target, block.condition)) return block.body;
-  }
-  return void 0;
-}
-function embodimentFor(target) {
-  return DEFAULT_EMBODIMENT[platformCategory(target)];
+// src/compiler/USDZPipeline.ts
+chunkHGVXZDSK_cjs.init_DomainBlockCompilerMixin();
+chunkBPICAGBV_cjs.init_R3FCompiler();
+function presetString(p, k) {
+  const v = p[k];
+  return typeof v === "string" ? v : void 0;
 }
-function agentBudgetFor(target) {
-  return PLATFORM_CAPABILITIES[target].agentBudgetMs;
+function presetNumber(p, k) {
+  const v = p[k];
+  return typeof v === "number" && Number.isFinite(v) ? v : void 0;
 }
-function hasCapability(target, cap) {
-  const val = PLATFORM_CAPABILITIES[target][cap];
-  return typeof val === "boolean" ? val : Number(val) > 0;
+function presetBoolean(p, k) {
+  const v = p[k];
+  return typeof v === "boolean" ? v : void 0;
 }
-
-// src/compiler/USDZPipeline.ts
-chunkHHS6FMOU_cjs.init_DomainBlockCompilerMixin();
-chunkTSWTWZ42_cjs.init_R3FCompiler();
 var _USDZPipeline = class _USDZPipeline {
   constructor(options = {}) {
     this.materials = /* @__PURE__ */ new Map();
@@ -2816,33 +2295,49 @@ ${domainBlocksOutput}` : materials,
       const matName = `Material_${this.sanitizeName(obj.name)}`;
       const mat = { name: matName };
       const presetName = typeof material === "string" ? material : typeof materialPreset === "string" ? materialPreset : void 0;
-      if (presetName && chunkTSWTWZ42_cjs.MATERIAL_PRESETS[presetName]) {
-        const preset = chunkTSWTWZ42_cjs.MATERIAL_PRESETS[presetName];
-        if (preset.color) mat.baseColor = this.hexToRGB(preset.color);
-        if (preset.metalness !== void 0) mat.metallic = preset.metalness;
-        if (preset.roughness !== void 0) mat.roughness = preset.roughness;
-        if (preset.opacity !== void 0) mat.opacity = preset.opacity;
-        if (preset.emissive) mat.emissiveColor = this.hexToRGB(preset.emissive);
-        if (preset.emissiveIntensity !== void 0)
-          mat.emissiveIntensity = preset.emissiveIntensity;
-        if (preset.transmission !== void 0) mat.transmission = preset.transmission;
-        if (preset.ior !== void 0) mat.ior = preset.ior;
-        if (preset.thickness !== void 0) mat.thickness = preset.thickness;
-        if (preset.clearcoat !== void 0) mat.clearcoat = preset.clearcoat;
-        if (preset.clearcoatRoughness !== void 0)
-          mat.clearcoatRoughness = preset.clearcoatRoughness;
-        if (preset.sheen !== void 0) mat.sheen = preset.sheen;
-        if (preset.sheenRoughness !== void 0) mat.sheenRoughness = preset.sheenRoughness;
-        if (preset.sheenColor) mat.sheenColor = this.hexToRGB(preset.sheenColor);
-        if (preset.iridescence !== void 0) mat.iridescence = preset.iridescence;
-        if (preset.iridescenceIOR !== void 0) mat.iridescenceIOR = preset.iridescenceIOR;
-        if (preset.anisotropy !== void 0) mat.anisotropy = preset.anisotropy;
-        if (preset.anisotropyRotation !== void 0)
-          mat.anisotropyRotation = preset.anisotropyRotation;
-        if (preset.attenuationColor) mat.attenuationColor = this.hexToRGB(preset.attenuationColor);
-        if (preset.attenuationDistance !== void 0)
-          mat.attenuationDistance = preset.attenuationDistance;
-        if (preset.transparent && mat.opacity === void 0) mat.opacity = 0.99;
+      if (presetName && chunkBPICAGBV_cjs.MATERIAL_PRESETS[presetName]) {
+        const preset = chunkBPICAGBV_cjs.MATERIAL_PRESETS[presetName];
+        const colorStr = presetString(preset, "color");
+        if (colorStr) mat.baseColor = this.hexToRGB(colorStr);
+        const metal = presetNumber(preset, "metalness");
+        if (metal !== void 0) mat.metallic = metal;
+        const rough = presetNumber(preset, "roughness");
+        if (rough !== void 0) mat.roughness = rough;
+        const op = presetNumber(preset, "opacity");
+        if (op !== void 0) mat.opacity = op;
+        const emissiveStr = presetString(preset, "emissive");
+        if (emissiveStr) mat.emissiveColor = this.hexToRGB(emissiveStr);
+        const emissiveInt = presetNumber(preset, "emissiveIntensity");
+        if (emissiveInt !== void 0) mat.emissiveIntensity = emissiveInt;
+        const trans = presetNumber(preset, "transmission");
+        if (trans !== void 0) mat.transmission = trans;
+        const ior = presetNumber(preset, "ior");
+        if (ior !== void 0) mat.ior = ior;
+        const thick = presetNumber(preset, "thickness");
+        if (thick !== void 0) mat.thickness = thick;
+        const cc = presetNumber(preset, "clearcoat");
+        if (cc !== void 0) mat.clearcoat = cc;
+        const ccr = presetNumber(preset, "clearcoatRoughness");
+        if (ccr !== void 0) mat.clearcoatRoughness = ccr;
+        const sheen = presetNumber(preset, "sheen");
+        if (sheen !== void 0) mat.sheen = sheen;
+        const sheenR = presetNumber(preset, "sheenRoughness");
+        if (sheenR !== void 0) mat.sheenRoughness = sheenR;
+        const sheenColorStr = presetString(preset, "sheenColor");
+        if (sheenColorStr) mat.sheenColor = this.hexToRGB(sheenColorStr);
+        const irid = presetNumber(preset, "iridescence");
+        if (irid !== void 0) mat.iridescence = irid;
+        const iridIor = presetNumber(preset, "iridescenceIOR");
+        if (iridIor !== void 0) mat.iridescenceIOR = iridIor;
+        const aniso = presetNumber(preset, "anisotropy");
+        if (aniso !== void 0) mat.anisotropy = aniso;
+        const anisoRot = presetNumber(preset, "anisotropyRotation");
+        if (anisoRot !== void 0) mat.anisotropyRotation = anisoRot;
+        const attColorStr = presetString(preset, "attenuationColor");
+        if (attColorStr) mat.attenuationColor = this.hexToRGB(attColorStr);
+        const attDist = presetNumber(preset, "attenuationDistance");
+        if (attDist !== void 0) mat.attenuationDistance = attDist;
+        if (presetBoolean(preset, "transparent") && mat.opacity === void 0) mat.opacity = 0.99;
       }
       if (typeof color === "string") {
         mat.baseColor = this.hexToRGB(color);
@@ -3302,59 +2797,59 @@ ${domainBlocksOutput}` : materials,
   generateDomainBlocks(composition) {
     const domainBlocks = composition.domainBlocks ?? [];
     if (domainBlocks.length === 0) return "";
-    const compiled = chunkHHS6FMOU_cjs.compileDomainBlocks(
+    const compiled = chunkHGVXZDSK_cjs.compileDomainBlocks(
       domainBlocks,
       {
         material: (block) => {
-          const mat = chunkHHS6FMOU_cjs.compileMaterialBlock(block);
-          return chunkHHS6FMOU_cjs.materialToUSD(mat);
+          const mat = chunkHGVXZDSK_cjs.compileMaterialBlock(block);
+          return chunkHGVXZDSK_cjs.materialToUSD(mat);
         },
         physics: (block) => {
-          const phys = chunkHHS6FMOU_cjs.compilePhysicsBlock(block);
+          const phys = chunkHGVXZDSK_cjs.compilePhysicsBlock(block);
           return `# Physics: ${phys.keyword} "${phys.name || ""}" \u2014 ${JSON.stringify(phys.properties)}`;
         },
         vfx: (block) => {
-          const ps = chunkHHS6FMOU_cjs.compileParticleBlock(block);
-          return chunkHHS6FMOU_cjs.particlesToUSD(ps);
+          const ps = chunkHGVXZDSK_cjs.compileParticleBlock(block);
+          return chunkHGVXZDSK_cjs.particlesToUSD(ps);
         },
         postfx: (block) => {
-          const pp = chunkHHS6FMOU_cjs.compilePostProcessingBlock(block);
-          return chunkHHS6FMOU_cjs.postProcessingToUSD(pp);
+          const pp = chunkHGVXZDSK_cjs.compilePostProcessingBlock(block);
+          return chunkHGVXZDSK_cjs.postProcessingToUSD(pp);
         },
         audio: (block) => {
-          const audio = chunkHHS6FMOU_cjs.compileAudioSourceBlock(block);
-          return chunkHHS6FMOU_cjs.audioSourceToUSD(audio);
+          const audio = chunkHGVXZDSK_cjs.compileAudioSourceBlock(block);
+          return chunkHGVXZDSK_cjs.audioSourceToUSD(audio);
         },
         weather: (block) => {
-          const weather = chunkHHS6FMOU_cjs.compileWeatherBlock(block);
-          return chunkHHS6FMOU_cjs.weatherToUSD(weather);
+          const weather = chunkHGVXZDSK_cjs.compileWeatherBlock(block);
+          return chunkHGVXZDSK_cjs.weatherToUSD(weather);
         },
         narrative: (block) => {
-          const narr = chunkHHS6FMOU_cjs.compileNarrativeBlock(block);
-          return chunkHHS6FMOU_cjs.narrativeToUSDA(narr);
+          const narr = chunkHGVXZDSK_cjs.compileNarrativeBlock(block);
+          return chunkHGVXZDSK_cjs.narrativeToUSDA(narr);
         },
         payment: (block) => {
-          const pay = chunkHHS6FMOU_cjs.compilePaymentBlock(block);
-          return chunkHHS6FMOU_cjs.paymentToUSDA(pay);
+          const pay = chunkHGVXZDSK_cjs.compilePaymentBlock(block);
+          return chunkHGVXZDSK_cjs.paymentToUSDA(pay);
         },
         healthcare: (block) => {
-          const h = chunkHHS6FMOU_cjs.compileHealthcareBlock(block);
-          return chunkHHS6FMOU_cjs.healthcareToUSDA(h);
+          const h = chunkHGVXZDSK_cjs.compileHealthcareBlock(block);
+          return chunkHGVXZDSK_cjs.healthcareToUSDA(h);
         },
         robotics: (block) => {
-          const r = chunkHHS6FMOU_cjs.compileRoboticsBlock(block);
-          return chunkHHS6FMOU_cjs.roboticsToUSDA(r);
+          const r = chunkHGVXZDSK_cjs.compileRoboticsBlock(block);
+          return chunkHGVXZDSK_cjs.roboticsToUSDA(r);
         },
-        iot: (block) => chunkHHS6FMOU_cjs.iotToUSDA(chunkHHS6FMOU_cjs.compileIoTBlock(block)),
-        dataviz: (block) => chunkHHS6FMOU_cjs.datavizToUSDA(chunkHHS6FMOU_cjs.compileDataVizBlock(block)),
-        education: (block) => chunkHHS6FMOU_cjs.educationToUSDA(chunkHHS6FMOU_cjs.compileEducationBlock(block)),
-        music: (block) => chunkHHS6FMOU_cjs.musicToUSDA(chunkHHS6FMOU_cjs.compileMusicBlock(block)),
-        architecture: (block) => chunkHHS6FMOU_cjs.architectureToUSDA(chunkHHS6FMOU_cjs.compileArchitectureBlock(block)),
-        web3: (block) => chunkHHS6FMOU_cjs.web3ToUSDA(chunkHHS6FMOU_cjs.compileWeb3Block(block)),
-        procedural: (block) => chunkHHS6FMOU_cjs.proceduralToUSDA(chunkHHS6FMOU_cjs.compileProceduralBlock(block)),
-        rendering: (block) => chunkHHS6FMOU_cjs.renderingToUSDA(chunkHHS6FMOU_cjs.compileRenderingBlock(block)),
-        navigation: (block) => chunkHHS6FMOU_cjs.navigationToUSDA(chunkHHS6FMOU_cjs.compileNavigationBlock(block)),
-        input: (block) => chunkHHS6FMOU_cjs.inputToUSDA(chunkHHS6FMOU_cjs.compileInputBlock(block))
+        iot: (block) => chunkHGVXZDSK_cjs.iotToUSDA(chunkHGVXZDSK_cjs.compileIoTBlock(block)),
+        dataviz: (block) => chunkHGVXZDSK_cjs.datavizToUSDA(chunkHGVXZDSK_cjs.compileDataVizBlock(block)),
+        education: (block) => chunkHGVXZDSK_cjs.educationToUSDA(chunkHGVXZDSK_cjs.compileEducationBlock(block)),
+        music: (block) => chunkHGVXZDSK_cjs.musicToUSDA(chunkHGVXZDSK_cjs.compileMusicBlock(block)),
+        architecture: (block) => chunkHGVXZDSK_cjs.architectureToUSDA(chunkHGVXZDSK_cjs.compileArchitectureBlock(block)),
+        web3: (block) => chunkHGVXZDSK_cjs.web3ToUSDA(chunkHGVXZDSK_cjs.compileWeb3Block(block)),
+        procedural: (block) => chunkHGVXZDSK_cjs.proceduralToUSDA(chunkHGVXZDSK_cjs.compileProceduralBlock(block)),
+        rendering: (block) => chunkHGVXZDSK_cjs.renderingToUSDA(chunkHGVXZDSK_cjs.compileRenderingBlock(block)),
+        navigation: (block) => chunkHGVXZDSK_cjs.navigationToUSDA(chunkHGVXZDSK_cjs.compileNavigationBlock(block)),
+        input: (block) => chunkHGVXZDSK_cjs.inputToUSDA(chunkHGVXZDSK_cjs.compileInputBlock(block))
       },
       (block) => `# Domain block: ${block.domain}/${block.keyword} "${block.name}"`
     );
@@ -3384,6 +2879,864 @@ _USDZPipeline.TEXTURE_CHANNEL_MAP = {
 };
 var USDZPipeline = _USDZPipeline;
 
+// src/compiler/GaussianSplattingCompiler.ts
+chunkRMHC2VG7_cjs.init_CompilerBase();
+var GAUSSIAN_SPLAT_TRAIT_NAME = "gaussian_splat";
+var MULTIPLAYER_TRAIT_NAME = "multiplayer";
+function detectMultiUserSharedSort(composition) {
+  const objects = composition.objects ?? [];
+  for (const obj of objects) {
+    if (objectHasBothTraits(obj)) return true;
+  }
+  return false;
+}
+function objectHasBothTraits(obj) {
+  const traits = obj.traits ?? [];
+  let hasSplat = false;
+  let hasMultiplayer = false;
+  for (const t of traits) {
+    if (t.name === GAUSSIAN_SPLAT_TRAIT_NAME) hasSplat = true;
+    else if (t.name === MULTIPLAYER_TRAIT_NAME) hasMultiplayer = true;
+    if (hasSplat && hasMultiplayer) return true;
+  }
+  const childrenLike = obj.children ?? obj.objects ?? [];
+  for (const child of childrenLike) {
+    if (objectHasBothTraits(child)) return true;
+  }
+  return false;
+}
+var SHARED_SORT_SHADER_PATH = "packages/engine/src/gpu/shaders/splat-shared-sort.wgsl";
+var GaussianSplattingCompiler = class extends chunkRMHC2VG7_cjs.CompilerBase {
+  constructor(options = {}) {
+    super();
+    this.compilerName = "GaussianSplattingCompiler";
+    this.options = {
+      format: options.format ?? "glb",
+      colorSpace: options.colorSpace ?? "srgb_rec709_display",
+      generator: options.generator ?? "HoloScript GaussianSplattingCompiler v1.0.0",
+      copyright: options.copyright ?? "",
+      shDegree: options.shDegree ?? 0
+    };
+  }
+  getRequiredCapability() {
+    return ans.ANSCapabilityPath.GLTF;
+  }
+  compile(composition, agentToken, outputPath) {
+    this.validateCompilerAccess(agentToken, outputPath);
+    const { data, warnings } = this.extractGaussianData(composition);
+    const result = this.buildGLTF(data);
+    if (warnings && warnings.length > 0) {
+      result.warnings = warnings;
+    }
+    return result;
+  }
+  /**
+   * Extended compile that runs the standard glTF export AND reports
+   * compile-time WebGPU emit flags derived from trait co-occurrence.
+   *
+   * The standard `compile()` API is left unchanged so existing call sites
+   * (MCP `compile_to_3dgs`, ExportManager) keep their contract. Callers that
+   * need the shared-sort flag opt in via this method.
+   *
+   * @see detectMultiUserSharedSort (the detection rule)
+   * @see SHARED_SORT_SHADER_PATH (the kernel artifact path)
+   */
+  compileExtended(composition, agentToken, outputPath) {
+    const gltf = this.compile(composition, agentToken, outputPath);
+    const multiUserSharedSort = detectMultiUserSharedSort(composition);
+    return {
+      gltf,
+      multiUserSharedSort,
+      sharedSortShaderPath: multiUserSharedSort ? SHARED_SORT_SHADER_PATH : void 0
+    };
+  }
+  /**
+   * Instance accessor for the multi-user shared-sort detector. Mirrors the
+   * standalone `detectMultiUserSharedSort()` export — provided so callers
+   * holding a compiler instance can run the check without a second import.
+   */
+  detectMultiUserSharedSort(composition) {
+    return detectMultiUserSharedSort(composition);
+  }
+  // ─── Data extraction ────────────────────────────────────────────────────────
+  extractGaussianData(composition) {
+    for (const obj of composition.objects ?? []) {
+      const trait = obj.traits?.find((t) => t.name === "gaussian_splat");
+      if (trait && trait.config) {
+        const p = trait.config;
+        const positions = this.parseFloatArray(p.positions);
+        const scales = this.parseFloatArray(p.scales);
+        const rotations = this.parseFloatArray(p.rotations);
+        let colors = this.parseFloatArray(p.colors);
+        const opacities = this.parseFloatArray(p.opacities);
+        if (positions && scales && rotations && colors && opacities) {
+          const count = positions.length / 3;
+          if (scales.length === count * 3 && rotations.length === count * 4 && (colors.length === count * 4 || colors.length === count * 3) && opacities.length === count) {
+            if (colors.length === count * 3) {
+              colors = this.expandRgbToRgba(colors, count);
+            }
+            return {
+              data: {
+                positions,
+                scales,
+                rotations,
+                colors,
+                opacities,
+                shCoefficients: this.parseFloatArray(p.shCoefficients),
+                count
+              }
+            };
+          }
+        }
+        if (positions && colors) {
+          const count = positions.length / 3;
+          if (colors.length === count * 3 || colors.length === count * 4) {
+            return { data: this.computeCovarianceFromPointCloud(positions, colors) };
+          }
+        }
+      }
+    }
+    return {
+      data: this.generateDemoGrid(),
+      warnings: ["No valid @gaussian_splat trait data found; falling back to demo grid"]
+    };
+  }
+  expandRgbToRgba(rgb, count) {
+    const rgba = new Float32Array(count * 4);
+    for (let i = 0; i < count; i++) {
+      rgba[i * 4] = rgb[i * 3];
+      rgba[i * 4 + 1] = rgb[i * 3 + 1];
+      rgba[i * 4 + 2] = rgb[i * 3 + 2];
+      rgba[i * 4 + 3] = 1;
+    }
+    return rgba;
+  }
+  parseFloatArray(value) {
+    if (value instanceof Float32Array) return value;
+    if (Array.isArray(value)) {
+      const nums = value.map((v) => typeof v === "number" ? v : Number(v));
+      return new Float32Array(nums);
+    }
+    return void 0;
+  }
+  // ─── Covariance from point cloud (HoloMap raw output) ───────────────────────
+  /**
+   * Compute per-point Gaussian parameters from a raw point cloud.
+   *
+   * For each point we find k nearest neighbours, compute the 3x3 covariance
+   * matrix of that neighbourhood, eigen-decompose it via Jacobi rotations,
+   * and derive:
+   *   - scales   = sqrt(eigenvalues)  (isotropic minimum clamp)
+   *   - rotation = quaternion from eigenvector basis
+   *   - opacity  = 1.0 (uniform)
+   *   - colors   = passed through (RGB expanded to RGBA if needed)
+   */
+  computeCovarianceFromPointCloud(positions, colors) {
+    const n = Math.floor(positions.length / 3);
+    const k = Math.min(12, Math.max(4, n - 1));
+    const scales = new Float32Array(n * 3);
+    const rotations = new Float32Array(n * 4);
+    const opacities = new Float32Array(n);
+    let rgbaColors;
+    if (colors.length === n * 3) {
+      rgbaColors = this.expandRgbToRgba(colors, n);
+    } else {
+      rgbaColors = colors;
+    }
+    const grid = this.buildSpatialGrid(positions, n);
+    for (let i = 0; i < n; i++) {
+      const px = positions[i * 3];
+      const py = positions[i * 3 + 1];
+      const pz = positions[i * 3 + 2];
+      const neighbours = this.findKNearestNeighbours(grid, positions, n, px, py, pz, k, i);
+      let meanX = 0, meanY = 0, meanZ = 0;
+      for (const idx of neighbours) {
+        meanX += positions[idx * 3];
+        meanY += positions[idx * 3 + 1];
+        meanZ += positions[idx * 3 + 2];
+      }
+      const invM = 1 / neighbours.length;
+      meanX *= invM;
+      meanY *= invM;
+      meanZ *= invM;
+      let c00 = 0, c01 = 0, c02 = 0, c11 = 0, c12 = 0, c22 = 0;
+      for (const idx of neighbours) {
+        const dx = positions[idx * 3] - meanX;
+        const dy = positions[idx * 3 + 1] - meanY;
+        const dz = positions[idx * 3 + 2] - meanZ;
+        c00 += dx * dx;
+        c01 += dx * dy;
+        c02 += dx * dz;
+        c11 += dy * dy;
+        c12 += dy * dz;
+        c22 += dz * dz;
+      }
+      const invLen = 1 / (neighbours.length - 1 || 1);
+      c00 *= invLen;
+      c01 *= invLen;
+      c02 *= invLen;
+      c11 *= invLen;
+      c12 *= invLen;
+      c22 *= invLen;
+      const ev = this.jacobiEigenvalues3([
+        c00,
+        c01,
+        c02,
+        c01,
+        c11,
+        c12,
+        c02,
+        c12,
+        c22
+      ]);
+      const minScale = 1e-3;
+      scales[i * 3] = Math.max(minScale, Math.sqrt(Math.abs(ev.values[0])));
+      scales[i * 3 + 1] = Math.max(minScale, Math.sqrt(Math.abs(ev.values[1])));
+      scales[i * 3 + 2] = Math.max(minScale, Math.sqrt(Math.abs(ev.values[2])));
+      const q = this.rotationMatrixToQuaternion(ev.vectors);
+      rotations[i * 4] = q[0];
+      rotations[i * 4 + 1] = q[1];
+      rotations[i * 4 + 2] = q[2];
+      rotations[i * 4 + 3] = q[3];
+      opacities[i] = 1;
+    }
+    return {
+      positions,
+      scales,
+      rotations,
+      colors: rgbaColors,
+      opacities,
+      count: n
+    };
+  }
+  /** Simple uniform-grid spatial hash for k-NN acceleration. */
+  buildSpatialGrid(positions, n) {
+    let minX = Infinity, minY = Infinity, minZ = Infinity;
+    let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+    for (let i = 0; i < n; i++) {
+      const x = positions[i * 3];
+      const y = positions[i * 3 + 1];
+      const z = positions[i * 3 + 2];
+      if (x < minX) minX = x;
+      if (y < minY) minY = y;
+      if (z < minZ) minZ = z;
+      if (x > maxX) maxX = x;
+      if (y > maxY) maxY = y;
+      if (z > maxZ) maxZ = z;
+    }
+    const extent = Math.max(maxX - minX, maxY - minY, maxZ - minZ, 1e-6);
+    const cellsPerAxis = Math.max(1, Math.round(Math.pow(n / 8, 1 / 3)));
+    const cellSize = extent / cellsPerAxis;
+    const grid = /* @__PURE__ */ new Map();
+    for (let i = 0; i < n; i++) {
+      const cx = Math.floor((positions[i * 3] - minX) / cellSize);
+      const cy = Math.floor((positions[i * 3 + 1] - minY) / cellSize);
+      const cz = Math.floor((positions[i * 3 + 2] - minZ) / cellSize);
+      const key = `${cx},${cy},${cz}`;
+      const arr = grid.get(key);
+      if (arr) {
+        arr.push(i);
+      } else {
+        grid.set(key, [i]);
+      }
+    }
+    return grid;
+  }
+  findKNearestNeighbours(grid, positions, n, px, py, pz, k, selfIdx) {
+    if (n <= 2048) {
+      const dists = [];
+      for (let i = 0; i < n; i++) {
+        const dx = positions[i * 3] - px;
+        const dy = positions[i * 3 + 1] - py;
+        const dz = positions[i * 3 + 2] - pz;
+        dists.push({ idx: i, d2: dx * dx + dy * dy + dz * dz });
+      }
+      dists.sort((a, b) => a.d2 - b.d2);
+      return dists.slice(0, k + 1).map((d) => d.idx);
+    }
+    const radius = this.estimateSearchRadius(positions, n);
+    const radius2 = radius * radius;
+    const candidates = [];
+    for (let i = 0; i < n; i++) {
+      const dx = positions[i * 3] - px;
+      const dy = positions[i * 3 + 1] - py;
+      const dz = positions[i * 3 + 2] - pz;
+      const d2 = dx * dx + dy * dy + dz * dz;
+      if (d2 <= radius2) {
+        candidates.push({ idx: i, d2 });
+      }
+    }
+    candidates.sort((a, b) => a.d2 - b.d2);
+    return candidates.slice(0, k + 1).map((c) => c.idx);
+  }
+  estimateSearchRadius(positions, n) {
+    const sampleCount = Math.min(256, n);
+    let totalDist = 0;
+    let counted = 0;
+    const step = Math.max(1, Math.floor(n / sampleCount));
+    for (let i = 0; i < n; i += step) {
+      let minD2 = Infinity;
+      const px = positions[i * 3];
+      const py = positions[i * 3 + 1];
+      const pz = positions[i * 3 + 2];
+      for (let j = 0; j < n; j++) {
+        if (i === j) continue;
+        const dx = positions[j * 3] - px;
+        const dy = positions[j * 3 + 1] - py;
+        const dz = positions[j * 3 + 2] - pz;
+        const d2 = dx * dx + dy * dy + dz * dz;
+        if (d2 < minD2) minD2 = d2;
+      }
+      if (minD2 < Infinity) {
+        totalDist += Math.sqrt(minD2);
+        counted++;
+      }
+    }
+    const avg = counted > 0 ? totalDist / counted : 0.1;
+    return avg * 3;
+  }
+  /** Jacobi eigenvalue decomposition for a 3x3 symmetric matrix.
+   *  Returns eigenvalues (descending) and eigenvectors as column-major 3x3.
+   */
+  jacobiEigenvalues3(a) {
+    let m = [
+      [a[0], a[1], a[2]],
+      [a[3], a[4], a[5]],
+      [a[6], a[7], a[8]]
+    ];
+    let v = [
+      [1, 0, 0],
+      [0, 1, 0],
+      [0, 0, 1]
+    ];
+    const eps = 1e-10;
+    const maxSweeps = 50;
+    for (let sweep = 0; sweep < maxSweeps; sweep++) {
+      let offDiagSum = 0;
+      for (let p = 0; p < 3; p++) {
+        for (let q = p + 1; q < 3; q++) {
+          offDiagSum += Math.abs(m[p][q]);
+          if (Math.abs(m[p][q]) < eps) continue;
+          const tau = (m[q][q] - m[p][p]) / (2 * m[p][q]);
+          let t;
+          if (tau >= 0) {
+            t = 1 / (tau + Math.sqrt(1 + tau * tau));
+          } else {
+            t = 1 / (tau - Math.sqrt(1 + tau * tau));
+          }
+          const c = 1 / Math.sqrt(1 + t * t);
+          const s = t * c;
+          const mpp = m[p][p];
+          const mqq = m[q][q];
+          const mpq = m[p][q];
+          m[p][p] = c * c * mpp - 2 * s * c * mpq + s * s * mqq;
+          m[q][q] = s * s * mpp + 2 * s * c * mpq + c * c * mqq;
+          m[p][q] = 0;
+          m[q][p] = 0;
+          for (let r = 0; r < 3; r++) {
+            if (r !== p && r !== q) {
+              const mr_p = m[r][p];
+              const mr_q = m[r][q];
+              m[r][p] = c * mr_p - s * mr_q;
+              m[p][r] = m[r][p];
+              m[r][q] = s * mr_p + c * mr_q;
+              m[q][r] = m[r][q];
+            }
+          }
+          for (let r = 0; r < 3; r++) {
+            const vr_p = v[r][p];
+            const vr_q = v[r][q];
+            v[r][p] = c * vr_p - s * vr_q;
+            v[r][q] = s * vr_p + c * vr_q;
+          }
+        }
+      }
+      if (offDiagSum < eps) break;
+    }
+    const vals = [m[0][0], m[1][1], m[2][2]];
+    const cols = [
+      [v[0][0], v[1][0], v[2][0]],
+      [v[0][1], v[1][1], v[2][1]],
+      [v[0][2], v[1][2], v[2][2]]
+    ];
+    const order = [0, 1, 2].sort((i, j) => vals[j] - vals[i]);
+    return {
+      values: [vals[order[0]], vals[order[1]], vals[order[2]]],
+      vectors: [
+        cols[order[0]][0],
+        cols[order[1]][0],
+        cols[order[2]][0],
+        cols[order[0]][1],
+        cols[order[1]][1],
+        cols[order[2]][1],
+        cols[order[0]][2],
+        cols[order[1]][2],
+        cols[order[2]][2]
+      ]
+    };
+  }
+  rotationMatrixToQuaternion(m) {
+    const trace = m[0] + m[4] + m[8];
+    let qw, qx, qy, qz;
+    if (trace > 0) {
+      const s = 0.5 / Math.sqrt(trace + 1);
+      qw = 0.25 / s;
+      qx = (m[5] - m[7]) * s;
+      qy = (m[6] - m[2]) * s;
+      qz = (m[1] - m[3]) * s;
+    } else if (m[0] > m[4] && m[0] > m[8]) {
+      const s = 2 * Math.sqrt(1 + m[0] - m[4] - m[8]);
+      qw = (m[5] - m[7]) / s;
+      qx = 0.25 * s;
+      qy = (m[3] + m[1]) / s;
+      qz = (m[6] + m[2]) / s;
+    } else if (m[4] > m[8]) {
+      const s = 2 * Math.sqrt(1 + m[4] - m[0] - m[8]);
+      qw = (m[6] - m[2]) / s;
+      qx = (m[3] + m[1]) / s;
+      qy = 0.25 * s;
+      qz = (m[7] + m[5]) / s;
+    } else {
+      const s = 2 * Math.sqrt(1 + m[8] - m[0] - m[4]);
+      qw = (m[1] - m[3]) / s;
+      qx = (m[6] + m[2]) / s;
+      qy = (m[7] + m[5]) / s;
+      qz = 0.25 * s;
+    }
+    const norm = Math.sqrt(qx * qx + qy * qy + qz * qz + qw * qw) || 1;
+    return [qx / norm, qy / norm, qz / norm, qw / norm];
+  }
+  generateDemoGrid() {
+    const count = 8;
+    const positions = new Float32Array(count * 3);
+    const scales = new Float32Array(count * 3);
+    const rotations = new Float32Array(count * 4);
+    const colors = new Float32Array(count * 4);
+    const opacities = new Float32Array(count);
+    let i = 0;
+    for (let x = 0; x < 2; x++) {
+      for (let y = 0; y < 2; y++) {
+        for (let z = 0; z < 2; z++) {
+          positions[i * 3] = x * 0.5;
+          positions[i * 3 + 1] = y * 0.5;
+          positions[i * 3 + 2] = z * 0.5;
+          scales[i * 3] = 0.1;
+          scales[i * 3 + 1] = 0.1;
+          scales[i * 3 + 2] = 0.1;
+          rotations[i * 4] = 0;
+          rotations[i * 4 + 1] = 0;
+          rotations[i * 4 + 2] = 0;
+          rotations[i * 4 + 3] = 1;
+          colors[i * 4] = 0.8;
+          colors[i * 4 + 1] = 0.3;
+          colors[i * 4 + 2] = 0.3;
+          colors[i * 4 + 3] = 1;
+          opacities[i] = 1;
+          i++;
+        }
+      }
+    }
+    return { positions, scales, rotations, colors, opacities, count };
+  }
+  // ─── glTF builder ─────────────────────────────────────────────────────────
+  buildGLTF(data) {
+    const N = data.count;
+    const bufferData = this.buildBuffer(data);
+    const bufferViews = this.buildBufferViews(N);
+    const accessors = this.buildAccessors(N);
+    const primitive = {
+      attributes: {
+        POSITION: 0,
+        _ROTATION: 1,
+        _SCALE: 2,
+        _OPACITY: 3,
+        COLOR_0: 4
+      },
+      mode: 0,
+      // POINTS
+      extensions: {
+        KHR_gaussian_splatting: {
+          colorSpace: this.options.colorSpace
+        }
+      }
+    };
+    const mesh = {
+      name: "GaussianSplatMesh",
+      primitives: [primitive]
+    };
+    const node = {
+      name: "GaussianSplatNode",
+      mesh: 0
+    };
+    const gltf = {
+      asset: {
+        version: "2.0",
+        generator: this.options.generator,
+        ...this.options.copyright ? { copyright: this.options.copyright } : {}
+      },
+      scene: 0,
+      scenes: [{ name: "Scene", nodes: [0] }],
+      nodes: [node],
+      meshes: [mesh],
+      accessors,
+      bufferViews,
+      buffers: [{ byteLength: bufferData.byteLength }],
+      extensionsUsed: ["KHR_gaussian_splatting"]
+    };
+    const stats = {
+      nodeCount: 1,
+      meshCount: 1,
+      materialCount: 0,
+      textureCount: 0,
+      animationCount: 0,
+      totalVertices: N,
+      totalTriangles: 0,
+      fileSizeBytes: 0
+    };
+    if (this.options.format === "glb") {
+      const binary = this.createGLB(gltf, bufferData);
+      stats.fileSizeBytes = binary.byteLength;
+      return { binary, stats };
+    }
+    stats.fileSizeBytes = JSON.stringify(gltf).length + bufferData.byteLength;
+    return { json: gltf, buffer: bufferData, stats };
+  }
+  // ─── Binary layout ──────────────────────────────────────────────────────────
+  buildBuffer(data) {
+    const N = data.count;
+    const logScales = new Float32Array(N * 3);
+    for (let i = 0; i < N * 3; i++) {
+      logScales[i] = Math.log(Math.max(data.scales[i], 1e-8));
+    }
+    const size = N * 3 * 4 + N * 4 * 4 + N * 3 * 4 + N * 4 + N * 4 * 4;
+    const buf = new Uint8Array(size);
+    let off = 0;
+    const write = (arr) => {
+      const view = new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+      buf.set(view, off);
+      off += arr.byteLength;
+    };
+    write(data.positions);
+    write(data.rotations);
+    write(logScales);
+    write(data.opacities);
+    write(data.colors);
+    return buf;
+  }
+  buildBufferViews(N) {
+    let off = 0;
+    const views = [];
+    const add = (len) => {
+      views.push({ buffer: 0, byteOffset: off, byteLength: len });
+      off += len;
+      return views.length - 1;
+    };
+    add(N * 3 * 4);
+    add(N * 4 * 4);
+    add(N * 3 * 4);
+    add(N * 4);
+    add(N * 4 * 4);
+    return views;
+  }
+  buildAccessors(N) {
+    let bv = 0;
+    const accs = [];
+    const add = (type, compType, count) => {
+      accs.push({ bufferView: bv++, componentType: compType, count, type });
+    };
+    add("VEC3", 5126, N);
+    add("VEC4", 5126, N);
+    add("VEC3", 5126, N);
+    add("SCALAR", 5126, N);
+    add("VEC4", 5126, N);
+    return accs;
+  }
+  // ─── GLB assembler (mirrors GLTFPipeline) ─────────────────────────────────
+  createGLB(gltf, buffer) {
+    const jsonString = JSON.stringify(gltf);
+    const jsonBuffer = new TextEncoder().encode(jsonString);
+    const jsonPadding = (4 - jsonBuffer.byteLength % 4) % 4;
+    const paddedJsonLength = jsonBuffer.byteLength + jsonPadding;
+    const binPadding = (4 - buffer.byteLength % 4) % 4;
+    const paddedBinLength = buffer.byteLength + binPadding;
+    const totalSize = 12 + 8 + paddedJsonLength + 8 + paddedBinLength;
+    const output = new ArrayBuffer(totalSize);
+    const view = new DataView(output);
+    const bytes = new Uint8Array(output);
+    let offset = 0;
+    view.setUint32(offset, 1179937895, true);
+    offset += 4;
+    view.setUint32(offset, 2, true);
+    offset += 4;
+    view.setUint32(offset, totalSize, true);
+    offset += 4;
+    view.setUint32(offset, paddedJsonLength, true);
+    offset += 4;
+    view.setUint32(offset, 1313821514, true);
+    offset += 4;
+    bytes.set(jsonBuffer, offset);
+    offset += jsonBuffer.byteLength;
+    for (let i = 0; i < jsonPadding; i++) bytes[offset++] = 32;
+    view.setUint32(offset, paddedBinLength, true);
+    offset += 4;
+    view.setUint32(offset, 5130562, true);
+    offset += 4;
+    bytes.set(buffer, offset);
+    offset += buffer.byteLength;
+    for (let i = 0; i < binPadding; i++) bytes[offset++] = 0;
+    return new Uint8Array(output);
+  }
+};
+function createGaussianSplattingCompiler(options) {
+  return new GaussianSplattingCompiler(options);
+}
+
+// src/compiler/SpatialPartitionPass.ts
+var MAX_DEPTH = 8;
+var SCALE_PER_SPLAT_UNIT = 1e-6;
+var MIN_SCALE = 1e-9;
+var SpatialPartitionPass = class {
+  constructor(options = {}) {
+    this.maxDepth = options.maxDepth ?? MAX_DEPTH;
+    this.scalePerSplatUnit = options.scalePerSplatUnit ?? SCALE_PER_SPLAT_UNIT;
+    this.includeUnpositioned = options.includeUnpositioned ?? true;
+  }
+  /**
+   * Run the pass over a HoloComposition and return the serializable result.
+   */
+  run(composition) {
+    const rawSources = [];
+    this.collectFromComposition(composition, rawSources);
+    if (rawSources.length === 0) {
+      return this.emptyResult(composition.name);
+    }
+    const maxScaleInScene = Math.max(
+      ...rawSources.map((s) => Math.max(s.maxSplats * this.scalePerSplatUnit, MIN_SCALE))
+    );
+    const anchors = [];
+    const lodDist = {};
+    let objectsWalked = 0;
+    for (const src of rawSources) {
+      objectsWalked++;
+      if (!this.includeUnpositioned && !src.hasPosition) continue;
+      const scale = Math.max(src.maxSplats * this.scalePerSplatUnit, MIN_SCALE);
+      const lodLevel = this.computeLODLevel(scale, maxScaleInScene);
+      const provenanceHash = src.sourceFile ? deterministicHash(`file:${src.sourceFile}:${src.maxSplats}`) : deterministicHash(`${src.objectName}:${lodLevel}:${src.maxSplats}`);
+      const anchor = {
+        id: `spa_${sanitiseId(src.objectName)}_l${lodLevel}`,
+        position: src.position,
+        scale,
+        lodLevel,
+        gaussianCount: src.maxSplats,
+        importance: src.importance,
+        provenanceHash,
+        ...src.sourceFile ? { sourceFile: src.sourceFile } : {}
+      };
+      anchors.push(anchor);
+      lodDist[lodLevel] = (lodDist[lodLevel] ?? 0) + 1;
+    }
+    anchors.sort((a, b) => a.lodLevel - b.lodLevel);
+    const bounds = computeBounds(anchors);
+    const merkleRoot = computeMerkleRoot(anchors);
+    const totalGaussians = anchors.reduce((s, a) => s + a.gaussianCount, 0);
+    const maxLodLevel = anchors.length > 0 ? Math.max(...anchors.map((a) => a.lodLevel)) : 0;
+    return {
+      schema: "spatial-partition/v1",
+      compositionName: composition.name,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      anchors,
+      bounds,
+      merkleRoot,
+      totalGaussians,
+      stats: {
+        objectsWalked,
+        anchorsEmitted: anchors.length,
+        lodLevelDistribution: lodDist,
+        maxLodLevel,
+        maxScaleInScene
+      }
+    };
+  }
+  // ── LOD level computation (same algorithm as OctreeLODSystem.computeLODLevelFromScale) ──
+  computeLODLevel(scale, maxScaleInScene) {
+    if (scale <= 0 || maxScaleInScene <= 0) return this.maxDepth - 1;
+    if (scale >= maxScaleInScene) return 0;
+    const ratio = maxScaleInScene / scale;
+    const level = Math.floor(Math.log2(ratio));
+    return Math.min(Math.max(0, level), this.maxDepth - 1);
+  }
+  // ── AST Walk (mirrors GaussianBudgetAnalyzer.collectGaussianSources) ─────────
+  collectFromComposition(composition, out) {
+    if (composition.objects) {
+      for (const obj of composition.objects) {
+        this.collectFromObject(obj, out);
+      }
+    }
+    if (composition.spatialGroups) {
+      for (const group of composition.spatialGroups) {
+        this.collectFromGroup(group, out);
+      }
+    }
+    if (composition.conditionals) {
+      for (const cond of composition.conditionals) {
+        if (cond.objects) {
+          for (const obj of cond.objects) this.collectFromObject(obj, out);
+        }
+        if (cond.elseObjects) {
+          for (const obj of cond.elseObjects) this.collectFromObject(obj, out);
+        }
+      }
+    }
+    if (composition.iterators) {
+      for (const iter of composition.iterators) {
+        if (iter.objects) {
+          for (const obj of iter.objects) this.collectFromObject(obj, out);
+        }
+      }
+    }
+  }
+  collectFromObject(obj, out) {
+    if (obj.traits) {
+      for (const trait of obj.traits) {
+        if (trait.name === "gaussian_splat") {
+          const src = this.extractSource(obj, trait);
+          if (src) out.push(src);
+        }
+      }
+    }
+    if (obj.children) {
+      for (const child of obj.children) {
+        this.collectFromObject(child, out);
+      }
+    }
+  }
+  collectFromGroup(group, out) {
+    if (group.objects) {
+      for (const obj of group.objects) this.collectFromObject(obj, out);
+    }
+    if (group.groups) {
+      for (const sub of group.groups) this.collectFromGroup(sub, out);
+    }
+  }
+  extractSource(obj, trait) {
+    const config = trait.config ?? {};
+    const maxSplats = typeof config.max_splats === "number" ? config.max_splats : 5e4;
+    const sourceFile = typeof config.src === "string" ? config.src : typeof config.source === "string" ? config.source : void 0;
+    const importance = typeof config.importance === "number" ? Math.max(0, Math.min(1, config.importance)) : 0.5;
+    let posArr = null;
+    if (obj.position && typeof obj.position.x === "number") {
+      posArr = [obj.position.x, obj.position.y, obj.position.z];
+    } else {
+      const posProp = obj.properties?.find((p) => p.key === "position")?.value;
+      if (Array.isArray(posProp) && posProp.length >= 3) {
+        posArr = [Number(posProp[0]), Number(posProp[1]), Number(posProp[2])];
+      } else if (posProp !== null && typeof posProp === "object" && !Array.isArray(posProp) && typeof posProp["x"] === "number") {
+        const pobj = posProp;
+        posArr = [pobj.x, pobj.y, pobj.z];
+      }
+    }
+    return {
+      objectName: obj.name ?? `unnamed_${Math.random().toString(36).slice(2, 7)}`,
+      position: posArr ?? [0, 0, 0],
+      hasPosition: posArr !== null,
+      maxSplats,
+      sourceFile,
+      importance
+    };
+  }
+  // ── Empty-composition fast path ─────────────────────────────────────────────
+  emptyResult(compositionName) {
+    return {
+      schema: "spatial-partition/v1",
+      compositionName,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      anchors: [],
+      bounds: {
+        min: { x: 0, y: 0, z: 0 },
+        max: { x: 0, y: 0, z: 0 },
+        center: { x: 0, y: 0, z: 0 },
+        halfSize: 0
+      },
+      merkleRoot: "0".repeat(64),
+      totalGaussians: 0,
+      stats: {
+        objectsWalked: 0,
+        anchorsEmitted: 0,
+        lodLevelDistribution: {},
+        maxLodLevel: 0,
+        maxScaleInScene: 0
+      }
+    };
+  }
+};
+function deterministicHash(input) {
+  let h0 = 2166136261;
+  let h1 = 3521423859;
+  for (let i = 0; i < input.length; i++) {
+    const c = input.charCodeAt(i);
+    h0 = Math.imul(h0 ^ c, 16777619) >>> 0;
+    h1 = Math.imul(h1 ^ c, 16777619) >>> 0;
+  }
+  const hex0 = h0.toString(16).padStart(8, "0");
+  const hex1 = h1.toString(16).padStart(8, "0");
+  const base = (hex0 + hex1).repeat(4).slice(0, 64);
+  return base;
+}
+function computeMerkleRoot(anchors) {
+  if (anchors.length === 0) return "0".repeat(64);
+  const sorted = [...anchors].sort((a, b) => a.id.localeCompare(b.id));
+  const bytes = new Uint8Array(32);
+  for (const anchor of sorted) {
+    const hash = anchor.provenanceHash.slice(0, 64).padEnd(64, "0");
+    for (let i = 0; i < 32; i++) {
+      const byteHex = hash.slice(i * 2, i * 2 + 2);
+      bytes[i] ^= parseInt(byteHex, 16) || 0;
+    }
+  }
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function computeBounds(anchors) {
+  if (anchors.length === 0) {
+    return {
+      min: { x: 0, y: 0, z: 0 },
+      max: { x: 0, y: 0, z: 0 },
+      center: { x: 0, y: 0, z: 0 },
+      halfSize: 0
+    };
+  }
+  let minX = Infinity, minY = Infinity, minZ = Infinity;
+  let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+  for (const a of anchors) {
+    const r = a.scale;
+    minX = Math.min(minX, a.position[0] - r);
+    minY = Math.min(minY, a.position[1] - r);
+    minZ = Math.min(minZ, a.position[2] - r);
+    maxX = Math.max(maxX, a.position[0] + r);
+    maxY = Math.max(maxY, a.position[1] + r);
+    maxZ = Math.max(maxZ, a.position[2] + r);
+  }
+  const cx = (minX + maxX) / 2;
+  const cy = (minY + maxY) / 2;
+  const cz = (minZ + maxZ) / 2;
+  const halfSize = Math.max(
+    (maxX - minX) / 2,
+    (maxY - minY) / 2,
+    (maxZ - minZ) / 2
+  );
+  return {
+    min: { x: minX, y: minY, z: minZ },
+    max: { x: maxX, y: maxY, z: maxZ },
+    center: { x: cx, y: cy, z: cz },
+    halfSize
+  };
+}
+function sanitiseId(s) {
+  return s.replace(/[^a-zA-Z0-9_]/g, "_").slice(0, 32);
+}
+function spatialPartition(composition, options) {
+  return new SpatialPartitionPass(options).run(composition);
+}
+
 // src/types/effects.ts
 function effectCategory(effect) {
   return effect.split(":")[0];
@@ -3548,6 +3901,7 @@ var TRAIT_EFFECTS = {
   // Audio traits
   "@audio": ["audio:play"],
   "@spatial_audio": ["audio:spatial"],
+  "@gem_resonance": ["audio:spatial", "state:read"],
   "@reverb": ["audio:reverb"],
   "@music": ["audio:play", "audio:global"],
   // State traits
@@ -3758,6 +4112,7 @@ var TRAIT_EFFECTS = {
   "@mitosis": [],
   "@mock": [],
   "@model_load": [],
+  "@modbus": ["io:network"],
   "@motion_reduced": ["io:read", "io:write"],
   "@mqtt_pub": ["io:network"],
   "@mqtt_sink": ["io:network"],
@@ -3775,6 +4130,7 @@ var TRAIT_EFFECTS = {
   "@object_tracking": ["state:read"],
   "@occlusion": ["io:read", "io:write"],
   "@openxr_hal": [],
+  "@opc_ua": ["io:network"],
   "@orbital": [],
   "@package_signing": ["authority:own"],
   "@pagerduty": [],
@@ -3967,7 +4323,9 @@ function inferFromTraits(traitNames) {
         sources.set(e, existing);
       }
     } else {
-      warnings.push(`Unknown trait '${normalized}': cannot infer effects. Assuming pure.`);
+      warnings.push(
+        `Unknown trait '${normalized}': cannot infer effects, so the safety checker assumes pure. Register the trait in TRAIT_EFFECTS or add an explicit @effect declaration before relying on this inference.`
+      );
     }
   }
   return { row: new EffectRow(allEffects), sources, warnings };
@@ -4258,6 +4616,7 @@ var TRAIT_RESOURCE_COSTS = {
   // ── Audio ──
   "@audio": { audioSources: 1 },
   "@spatial_audio": { audioSources: 1 },
+  "@gem_resonance": { audioSources: 1 },
   "@environmental_audio": { audioSources: 4, memoryMB: 2 },
   "@voice_mesh": { audioSources: 1, networkMsgs: 10 },
   "@voice_input": { audioSources: 1, memoryMB: 1 },
@@ -4270,6 +4629,8 @@ var TRAIT_RESOURCE_COSTS = {
   "@lobby": { networkMsgs: 5, memoryMB: 2 },
   "@mqtt_sink": { networkMsgs: 5 },
   "@mqtt_source": { networkMsgs: 5 },
+  "@modbus": { networkMsgs: 5 },
+  "@opc_ua": { networkMsgs: 5 },
   "@sync_tier": { networkMsgs: 2 },
   "@crdt_room": { networkMsgs: 10, memoryMB: 4 },
   "@shareplay": { networkMsgs: 5, memoryMB: 2 },
@@ -4983,6 +5344,7 @@ function quickSafetyCheck(traits, calls, options = {}) {
 }
 
 // src/compiler/platform/CrossRealityTraitRegistry.ts
+chunkAIA52I7T_cjs.init_PlatformConditional();
 var CATEGORY_DEFAULT_EMBODIMENT = {
   vr: "FullAvatar",
   ar: "FloatingAgent",
@@ -5083,7 +5445,7 @@ var CrossRealityTraitRegistry = class {
     if (trait.applicablePlatforms.length === 0 && trait.applicableCategories.length === 0)
       return true;
     if (trait.applicablePlatforms.includes(platform)) return true;
-    const category = platformCategory(platform);
+    const category = chunkAIA52I7T_cjs.platformCategory(platform);
     return trait.applicableCategories.includes(category);
   }
   /** Resolve the default embodiment for a platform */
@@ -5091,13 +5453,13 @@ var CrossRealityTraitRegistry = class {
     if (platform in PLATFORM_EMBODIMENT_OVERRIDES) {
       return PLATFORM_EMBODIMENT_OVERRIDES[platform];
     }
-    const category = platformCategory(platform);
+    const category = chunkAIA52I7T_cjs.platformCategory(platform);
     return CATEGORY_DEFAULT_EMBODIMENT[category];
   }
   /** Validate a handoff path at compile time */
   validateHandoffPath(from, to) {
-    const fromCat = platformCategory(from);
-    const toCat = platformCategory(to);
+    const fromCat = chunkAIA52I7T_cjs.platformCategory(from);
+    const toCat = chunkAIA52I7T_cjs.platformCategory(to);
     if (fromCat === toCat) return { allowed: true, latencyBudgetMs: 100 };
     const rule = HANDOFF_PATH_RULES.find((r) => r.from === fromCat && r.to === toCat);
     if (!rule) return { allowed: true, latencyBudgetMs: 500 };
@@ -5110,7 +5472,7 @@ var CrossRealityTraitRegistry = class {
   }
   /** Get MVC budget for a target platform */
   getMVCBudget(platform) {
-    const category = platformCategory(platform);
+    const category = chunkAIA52I7T_cjs.platformCategory(platform);
     return MVC_BUDGET_CONSTRAINTS.find((b) => b.category === category) ?? MVC_BUDGET_CONSTRAINTS[0];
   }
   /** Get total registered trait count */
@@ -5270,6 +5632,7 @@ function createCrossRealityTraitRegistry() {
 }
 
 // src/compiler/platform/ModalitySelector.ts
+chunkAIA52I7T_cjs.init_PlatformConditional();
 var EMBODIMENT_TO_TARGET = {
   FullAvatar: { primary: "openxr", fallback: "r3f" },
   FloatingAgent: { primary: "visionos", fallback: "r3f" },
@@ -5301,22 +5664,18 @@ var PLATFORM_TARGET_OVERRIDES = {
 };
 function selectModality(platform, options = {}) {
   const reasoning = [];
-  const capabilities = PLATFORM_CAPABILITIES[platform];
-  const category = platformCategory(platform);
+  const capabilities = chunkAIA52I7T_cjs.PLATFORM_CAPABILITIES[platform];
+  const category = chunkAIA52I7T_cjs.platformCategory(platform);
   let embodiment;
   if (options.forceEmbodiment) {
     embodiment = options.forceEmbodiment;
     reasoning.push(`Embodiment forced to ${embodiment} by caller`);
   } else if (platform in PLATFORM_EMBODIMENT_OVERRIDES) {
     embodiment = PLATFORM_EMBODIMENT_OVERRIDES[platform];
-    reasoning.push(
-      `Embodiment ${embodiment} from platform-specific override for ${platform}`
-    );
+    reasoning.push(`Embodiment ${embodiment} from platform-specific override for ${platform}`);
   } else {
     embodiment = CATEGORY_DEFAULT_EMBODIMENT[category];
-    reasoning.push(
-      `Embodiment ${embodiment} from category default for ${category}`
-    );
+    reasoning.push(`Embodiment ${embodiment} from category default for ${category}`);
   }
   let exportTarget;
   let fallbackTarget;
@@ -5327,16 +5686,12 @@ function selectModality(platform, options = {}) {
   } else if (platform in PLATFORM_TARGET_OVERRIDES) {
     exportTarget = PLATFORM_TARGET_OVERRIDES[platform];
     fallbackTarget = EMBODIMENT_TO_TARGET[embodiment]?.fallback ?? null;
-    reasoning.push(
-      `ExportTarget ${exportTarget} from platform-specific override for ${platform}`
-    );
+    reasoning.push(`ExportTarget ${exportTarget} from platform-specific override for ${platform}`);
   } else {
     const mapping = EMBODIMENT_TO_TARGET[embodiment];
     exportTarget = mapping.primary;
     fallbackTarget = mapping.fallback;
-    reasoning.push(
-      `ExportTarget ${exportTarget} from embodiment mapping for ${embodiment}`
-    );
+    reasoning.push(`ExportTarget ${exportTarget} from embodiment mapping for ${embodiment}`);
   }
   const canRenderSpatial = capabilities.gpu3D && capabilities.frameBudgetMs <= 16.6;
   reasoning.push(
@@ -5367,19 +5722,21 @@ function selectModality(platform, options = {}) {
 }
 function selectModalityForAll(options = {}) {
   const results = /* @__PURE__ */ new Map();
-  for (const platform of Object.keys(PLATFORM_CAPABILITIES)) {
+  for (const platform of Object.keys(chunkAIA52I7T_cjs.PLATFORM_CAPABILITIES)) {
     results.set(platform, selectModality(platform, options));
   }
   return results;
 }
 function bestCategoryForTraits(requiredCapabilities) {
   const categories = [];
-  for (const [cat, platforms] of Object.entries(PLATFORM_CATEGORIES)) {
+  for (const [cat, platforms] of Object.entries(chunkAIA52I7T_cjs.PLATFORM_CATEGORIES)) {
     const canSupport = platforms.some((platform) => {
-      const caps = PLATFORM_CAPABILITIES[platform];
+      const caps = chunkAIA52I7T_cjs.PLATFORM_CAPABILITIES[platform];
       return Object.entries(requiredCapabilities).every(([key, required]) => {
-        if (typeof required === "boolean") return !required || caps[key] === true;
-        if (typeof required === "number") return caps[key] <= required;
+        if (typeof required === "boolean")
+          return !required || caps[key] === true;
+        if (typeof required === "number")
+          return caps[key] <= required;
         return true;
       });
     });
@@ -5401,7 +5758,7 @@ var CompilerBridge = class {
     if (this.initialized) return;
     try {
       const [parserModule, compilerModule] = await Promise.all([
-        import('./parser.cjs'),
+        import('./HoloScriptPlusParser-WKHRIH6T.cjs'),
         import('./compiler/r3f.cjs')
       ]);
       this.modules = {
@@ -5530,6 +5887,16 @@ function getCompilerBridge() {
 function json(value) {
   return JSON.stringify(value, null, 2);
 }
+function unsupportedPipelineStep(kind, type, name) {
+  const typeLabel = type || "unknown";
+  return `[PipelineNodeCompiler] Unsupported pipeline ${kind} type "${typeLabel}" (step: ${name}). PipelineNodeCompiler does not yet emit code for this type.`;
+}
+function unsupportedNodeThrow(kind, type, name) {
+  return `(() => { throw new Error(${json(unsupportedPipelineStep(kind, type, name))}); })()`;
+}
+function unsupportedPythonRaise(kind, type, name) {
+  return `raise NotImplementedError(${json(unsupportedPipelineStep(kind, type, name))})`;
+}
 function emitSource(source) {
   switch (source.type) {
     case "rest":
@@ -5540,15 +5907,29 @@ function emitSource(source) {
     case "list":
       return json(source.items || []);
     default:
-      return "[]";
+      return unsupportedNodeThrow("source", source.type, source.name);
   }
 }
 function emitFieldMappingTransform(t) {
   const mappings = t.mappings || [];
-  const mapExpr = mappings.map((m) => `${json(m.to)}: applyTransforms(item[${json(m.from)}], ${json(m.transforms || [])})`).join(",\n      ");
-  return `data = data.map((item) => ({
+  const unwrapMappings = mappings.filter((m) => m.from.endsWith("[]"));
+  const valueMappings = mappings.filter((m) => !m.from.endsWith("[]"));
+  const lines = [];
+  for (const mapping of unwrapMappings) {
+    lines.push(
+      `data = data.flatMap((item) => unwrapPathValues(item, ${json(mapping.from)}).map((value) => ({ ...item, ${json(mapping.to)}: applyTransforms(value, ${json(mapping.transforms || [])}) })));`
+    );
+  }
+  if (valueMappings.length === 0) {
+    return lines.join("\n");
+  }
+  const mapExpr = valueMappings.map(
+    (m) => `${json(m.to)}: applyTransforms(getPathValue(item, ${json(m.from)}), ${json(m.transforms || [])})`
+  ).join(",\n      ");
+  lines.push(`data = data.map((item) => ({
       ${mapExpr}
-    }));`;
+    }));`);
+  return lines.join("\n");
 }
 function emitTransform(t) {
   if ((t.type === "field_mapping" || !t.type) && t.mappings && t.mappings.length > 0) {
@@ -5580,11 +5961,11 @@ function emitSink(sink) {
       return `await writeOutput(${json(sink.path || "./pipeline-output.jsonl")}, data, ${json(sink.format || "jsonl")}, ${json(Boolean(sink.append))});`;
     case "rest":
     case "webhook":
-      return `await fetch(${json(sink.endpoint || "")}, { method: ${json(sink.method || "POST")}, headers: { 'content-type': 'application/json' }, body: JSON.stringify(data) });`;
+      return `await postJSON(${json(sink.endpoint || "")}, data, { method: ${json(sink.method || "POST")} });`;
     case "mcp":
       return `console.warn(${json(`[${sink.name}] mcp sink requires host integration: ${sink.server || ""}/${sink.tool || ""}`)});`;
     default:
-      return `// sink ${sink.name} (${sink.type}) not implemented`;
+      return `${unsupportedNodeThrow("sink", sink.type, sink.name)};`;
   }
 }
 function emitPythonSource(source) {
@@ -5597,12 +5978,14 @@ function emitPythonSource(source) {
     case "list":
       return `datasets[${json(source.name)}] = ${json(source.items || [])}`;
     default:
-      return `datasets[${json(source.name)}] = []`;
+      return unsupportedPythonRaise("source", source.type, source.name);
   }
 }
 function emitPythonFieldMappingTransform(t) {
   const mappings = t.mappings || [];
-  const mappingLines = mappings.map((m) => `${json(m.to)}: apply_transforms(item.get(${json(m.from)}), ${json(m.transforms || [])}),`).join("\n                ");
+  const mappingLines = mappings.map(
+    (m) => `${json(m.to)}: apply_transforms(item.get(${json(m.from)}), ${json(m.transforms || [])}),`
+  ).join("\n                ");
   return `data = [
         {
             ${mappingLines}
@@ -5644,7 +6027,7 @@ function emitPythonSink(sink) {
     case "mcp":
       return `print(${json(`[${sink.name}] mcp sink requires host integration: ${sink.server || ""}/${sink.tool || ""}`)})`;
     default:
-      return `# sink ${sink.name} (${sink.type}) not implemented`;
+      return unsupportedPythonRaise("sink", sink.type, sink.name);
   }
 }
 function compilePipelineToNode(pipeline, options = {}) {
@@ -5661,18 +6044,55 @@ function compilePipelineToNode(pipeline, options = {}) {
  */
 
 import fs from 'node:fs/promises';
+import path from 'node:path';
+
+const RUN_DATE = new Date().toISOString().slice(0, 10);
+
+function resolveTemplate(value, context = {}) {
+  if (typeof value !== 'string') return value;
+  return value
+    .replace(/\\$\\{date\\}/g, RUN_DATE)
+    .replace(/\\$\\{env\\.([A-Za-z_][A-Za-z0-9_]*)\\}/g, (_match, name) => process.env[name] ?? '')
+    .replace(/\\$\\{([A-Za-z_][A-Za-z0-9_.]*)\\}/g, (_match, key) => {
+      const found = key.split('.').reduce((acc, part) => (acc && typeof acc === 'object' ? acc[part] : undefined), context);
+      return found === undefined || found === null ? '' : String(found);
+    });
+}
+
+function normalizeOutputPath(rawPath, format) {
+  const resolved = resolveTemplate(rawPath);
+  if (!resolved) return format === 'json' ? './pipeline-output.json' : './pipeline-output.jsonl';
+  if (path.extname(resolved)) return resolved;
+  return path.join(resolved, format === 'json' ? 'pipeline-output.json' : 'pipeline-output.jsonl');
+}
 
 async function fetchJSON(url, init) {
-  if (!url) return [];
-  const res = await fetch(url, init);
+  const resolvedUrl = resolveTemplate(url);
+  if (!resolvedUrl) return [];
+  const res = await fetch(resolvedUrl, init);
   if (!res.ok) throw new Error(\`Request failed: \${res.status} \${res.statusText}\`);
   const body = await res.json();
   return Array.isArray(body) ? body : [body];
 }
 
+async function postJSON(url, data, init) {
+  const resolvedUrl = resolveTemplate(url, { data });
+  if (!resolvedUrl) {
+    console.warn('[PipelineNodeCompiler] skipping empty webhook/rest sink endpoint');
+    return;
+  }
+  const res = await fetch(resolvedUrl, {
+    ...init,
+    headers: { 'content-type': 'application/json', ...(init?.headers || {}) },
+    body: JSON.stringify(data),
+  });
+  if (!res.ok) throw new Error(\`Request failed: \${res.status} \${res.statusText}\`);
+}
+
 async function readJSONArray(filePath) {
-  if (!filePath) return [];
-  const raw = await fs.readFile(filePath, 'utf8');
+  const resolvedPath = resolveTemplate(filePath);
+  if (!resolvedPath) return [];
+  const raw = await fs.readFile(resolvedPath, 'utf8');
   const parsed = JSON.parse(raw);
   return Array.isArray(parsed) ? parsed : [parsed];
 }
@@ -5690,6 +6110,22 @@ function applyTransforms(value, transforms) {
   return v;
 }
 
+function getPathValue(item, pathExpr) {
+  const cleanPath = String(pathExpr || '').replace(/\\[\\]$/, '');
+  if (!cleanPath) return item;
+  return cleanPath.split('.').reduce((acc, part) => {
+    if (acc == null || typeof acc !== 'object') return undefined;
+    return acc[part];
+  }, item);
+}
+
+function unwrapPathValues(item, pathExpr) {
+  const value = getPathValue(item, pathExpr);
+  if (Array.isArray(value)) return value;
+  if (value == null) return [];
+  return [value];
+}
+
 function evalCondition(item, condition) {
   try {
     const fn = new Function('item', \`with (item) { return (\${condition}); }\`);
@@ -5710,17 +6146,20 @@ function validateItem(item, fields) {
   return true;
 }
 
-async function writeOutput(path, data, format, append) {
+async function writeOutput(rawPath, data, format, append) {
+  const outputPath = normalizeOutputPath(rawPath, format);
+  await fs.mkdir(path.dirname(outputPath), { recursive: true });
+
   if (format === 'json') {
     const text = JSON.stringify(data, null, 2);
-    if (append) await fs.appendFile(path, text + '\\n');
-    else await fs.writeFile(path, text);
+    if (append) await fs.appendFile(outputPath, text + '\\n');
+    else await fs.writeFile(outputPath, text);
     return;
   }
 
   const lines = data.map((d) => JSON.stringify(d)).join('\\n') + '\\n';
-  if (append) await fs.appendFile(path, lines);
-  else await fs.writeFile(path, lines);
+  if (append) await fs.appendFile(outputPath, lines);
+  else await fs.writeFile(outputPath, lines);
 }
 
 export async function runPipeline() {
@@ -5909,7 +6348,7 @@ if __name__ == '__main__':
 `;
 }
 function compilePipelineSourceToNode(source, options = {}) {
-  const parsed = parsePipeline(source);
+  const parsed = chunkKKFZ3B6J_cjs.parsePipeline(source);
   if (!parsed.success || !parsed.pipeline) {
     return {
       success: false,
@@ -5922,7 +6361,7 @@ function compilePipelineSourceToNode(source, options = {}) {
   };
 }
 function compilePipelineSourceToPython(source, options = {}) {
-  const parsed = parsePipeline(source);
+  const parsed = chunkKKFZ3B6J_cjs.parsePipeline(source);
   if (!parsed.success || !parsed.pipeline) {
     return {
       success: false,
@@ -5942,144 +6381,32 @@ function compilePipelineSource(source, options = {}) {
   return compilePipelineSourceToNode(source, options.node);
 }
 
-// src/compiler/NextJSCompiler.ts
-chunkQHVVVN47_cjs.init_CompilerBase();
-init_Native2DCompiler();
-function findTrait(composition, traitName) {
-  const traits = composition.traits;
-  if (!traits) return null;
-  const found = traits.find((t) => t.name === traitName);
-  return found?.config || null;
-}
-var NextJSCompiler = class extends chunkQHVVVN47_cjs.CompilerBase {
-  constructor(options = {}) {
-    super();
-    this.options = options;
-    this.compilerName = "NextJSCompiler";
-  }
-  /**
-   * Compile HoloComposition AST to Next.js App Router Code
-   *
-   * @param composition - HoloScript AST
-   * @param agentToken - JWT or UCAN token proving agent identity
-   * @param outputPath - Optional output file path for scope validation
-   * @param sceneGraph - Optional pre-computed SSG
-   */
-  async compile(composition, agentToken, outputPath, _sceneGraph) {
-    this.validateCompilerAccess(agentToken, outputPath);
-    return this.buildNextRoute(composition);
-  }
-  validateCompilerAccess(agentToken, outputPath) {
-    if (typeof agentToken === "object" && agentToken !== null) {
-      this.validateCapabilityAccess(agentToken, outputPath);
-    } else {
-      this.validateASTAccess(agentToken);
-      this.validateCodeGeneration(agentToken);
-      if (outputPath) {
-        this.validateOutputPath(agentToken, outputPath);
-      }
-      this.validateSpatialZoneAccess(agentToken);
-    }
-  }
-  buildNextRoute(composition) {
-    const compiler = new exports.Native2DCompiler();
-    const pageTrait = findTrait(composition, "page");
-    const metaTrait = findTrait(composition, "metadata");
-    const route = pageTrait?.route || `/${composition.name.toLowerCase().replace(/\s+/g, "-")}`;
-    const isClient = pageTrait?.client !== false;
-    const slotMap = this.options.slots || {};
-    if (pageTrait?.redirect) {
-      const redirectUrl = pageTrait.redirect;
-      const lines2 = [
-        `// @generated by HoloScript NextJSCompiler \u2014 DO NOT EDIT`,
-        `import { redirect } from 'next/navigation';`,
-        ``,
-        `export default function RedirectPage() {`,
-        `  redirect(${JSON.stringify(redirectUrl)});`,
-        `}`
-      ];
-      if (metaTrait) {
-        const metaEntries = [];
-        if (metaTrait.title) metaEntries.push(`  title: ${JSON.stringify(metaTrait.title)},`);
-        if (metaTrait.description) metaEntries.push(`  description: ${JSON.stringify(metaTrait.description)},`);
-        lines2.push("");
-        lines2.push(`export const metadata = {`);
-        lines2.push(metaEntries.join("\n"));
-        lines2.push(`};`);
-      }
-      const routePath2 = route.replace(/^\//, "") || "index";
-      return {
-        path: `${routePath2}/page.tsx`,
-        code: lines2.join("\n")
-      };
-    }
-    const compilerOptions = {
-      format: "react",
-      useUIComponents: true,
-      slots: slotMap
-    };
-    const elements = composition.ui?.elements || composition.objects || [];
-    const componentCode = compiler.generateReactComponent(
-      composition.name,
-      elements,
-      composition,
-      compilerOptions
-    );
-    const pageSafeComponentCode = componentCode.replace(
-      /export\s+function\s+([A-Za-z0-9_]+)\s*\(/,
-      "function $1("
-    );
-    const lines = [];
-    if (isClient) {
-      lines.push("'use client';");
-      lines.push("");
-    }
-    lines.push(pageSafeComponentCode);
-    if (metaTrait && !isClient) {
-      const metaEntries = [];
-      if (metaTrait.title) metaEntries.push(`  title: ${JSON.stringify(metaTrait.title)},`);
-      if (metaTrait.description) metaEntries.push(`  description: ${JSON.stringify(metaTrait.description)},`);
-      lines.push("");
-      lines.push(`export const metadata = {`);
-      lines.push(metaEntries.join("\n"));
-      lines.push(`};`);
-    }
-    const routePath = route.replace(/^\//, "") || "index";
-    return {
-      path: `${routePath}/page.tsx`,
-      code: lines.join("\n")
-    };
-  }
-};
-
 exports.A2AAgentCardCompiler_exports = A2AAgentCardCompiler_exports;
-exports.ALL_PLATFORMS = ALL_PLATFORMS;
 exports.BUILTIN_RESOURCES = BUILTIN_RESOURCES;
 exports.CAPABILITY_HIERARCHY = CAPABILITY_HIERARCHY;
 exports.CATEGORY_DEFAULT_EMBODIMENT = CATEGORY_DEFAULT_EMBODIMENT;
 exports.CompilerBridge = CompilerBridge;
 exports.CrossRealityTraitRegistry = CrossRealityTraitRegistry;
-exports.DEFAULT_EMBODIMENT = DEFAULT_EMBODIMENT;
+exports.EFFECTS_BY_CATEGORY = EFFECTS_BY_CATEGORY;
 exports.EFFECT_TO_CAPABILITY = EFFECT_TO_CAPABILITY;
 exports.EffectChecker = EffectChecker;
 exports.EffectRow = EffectRow;
+exports.GaussianSplattingCompiler = GaussianSplattingCompiler;
 exports.HANDOFF_PATH_RULES = HANDOFF_PATH_RULES;
 exports.LinearTypeChecker = LinearTypeChecker;
 exports.MVC_BUDGET_CONSTRAINTS = MVC_BUDGET_CONSTRAINTS;
 exports.NIRCompiler_exports = NIRCompiler_exports;
-exports.Native2DCompiler_exports = Native2DCompiler_exports;
-exports.NextJSCompiler = NextJSCompiler;
 exports.PLATFORM_BUDGETS = PLATFORM_BUDGETS;
-exports.PLATFORM_CAPABILITIES = PLATFORM_CAPABILITIES;
-exports.PLATFORM_CATEGORIES = PLATFORM_CATEGORIES;
 exports.PLATFORM_EMBODIMENT_OVERRIDES = PLATFORM_EMBODIMENT_OVERRIDES;
 exports.ResourceBudgetAnalyzer = ResourceBudgetAnalyzer;
+exports.SHARED_SORT_SHADER_PATH = SHARED_SORT_SHADER_PATH;
+exports.SpatialPartitionPass = SpatialPartitionPass;
 exports.TRAIT_EFFECTS = TRAIT_EFFECTS;
 exports.TRAIT_RESOURCE_COSTS = TRAIT_RESOURCE_COSTS;
 exports.TRAIT_RESOURCE_MAP = TRAIT_RESOURCE_MAP;
 exports.TRUST_LEVEL_CAPABILITIES = TRUST_LEVEL_CAPABILITIES;
+exports.ThreeJSCompiler_exports = ThreeJSCompiler_exports;
 exports.USDZPipeline = USDZPipeline;
-exports.agentBudgetFor = agentBudgetFor;
 exports.bestCategoryForTraits = bestCategoryForTraits;
 exports.buildSafetyReport = buildSafetyReport;
 exports.checkCapabilities = checkCapabilities;
@@ -6090,33 +6417,29 @@ exports.compilePipelineToNode = compilePipelineToNode;
 exports.compilePipelineToPython = compilePipelineToPython;
 exports.createCrossRealityTraitRegistry = createCrossRealityTraitRegistry;
 exports.createEffectChecker = createEffectChecker;
+exports.createGaussianSplattingCompiler = createGaussianSplattingCompiler;
 exports.dangerLevel = dangerLevel;
 exports.deriveRequirements = deriveRequirements;
-exports.embodimentFor = embodimentFor;
+exports.detectMultiUserSharedSort = detectMultiUserSharedSort;
+exports.effectCategory = effectCategory;
 exports.expandCapabilities = expandCapabilities;
 exports.formatReport = formatReport;
 exports.generateCertificate = generateCertificate;
 exports.getCompilerBridge = getCompilerBridge;
 exports.getCrossRealityTraitRegistry = getCrossRealityTraitRegistry;
-exports.hasCapability = hasCapability;
 exports.inferFromBuiltins = inferFromBuiltins;
 exports.inferFromTraits = inferFromTraits;
 exports.init_A2AAgentCardCompiler = init_A2AAgentCardCompiler;
 exports.init_NIRCompiler = init_NIRCompiler;
-exports.init_Native2DCompiler = init_Native2DCompiler;
-exports.isPipelineSource = isPipelineSource;
+exports.init_ThreeJSCompiler = init_ThreeJSCompiler;
 exports.isSafeTraitSet = isSafeTraitSet;
 exports.knownBuiltins = knownBuiltins;
 exports.knownTraits = knownTraits;
-exports.matchesPlatform = matchesPlatform;
-exports.parsePipeline = parsePipeline;
-exports.platformCategory = platformCategory;
 exports.quickSafetyCheck = quickSafetyCheck;
 exports.resetCrossRealityTraitRegistry = resetCrossRealityTraitRegistry;
-exports.resolvePlatforms = resolvePlatforms;
 exports.runSafetyPass = runSafetyPass;
-exports.selectBlock = selectBlock;
 exports.selectModality = selectModality;
 exports.selectModalityForAll = selectModalityForAll;
-//# sourceMappingURL=chunk-FEFHPUEM.cjs.map
-//# sourceMappingURL=chunk-FEFHPUEM.cjs.map
+exports.spatialPartition = spatialPartition;
+//# sourceMappingURL=chunk-QWNQ523V.cjs.map
+//# sourceMappingURL=chunk-QWNQ523V.cjs.map