@holoscript/core 8.0.12 → 8.0.14

package/dist/chunk-ERYKKPHW.cjs

@@ -0,0 +1,1884 @@
+'use strict';
+
+var chunkP65OIMJT_cjs = require('./chunk-P65OIMJT.cjs');
+var chunkSE2Y5BSL_cjs = require('./chunk-SE2Y5BSL.cjs');
+var chunkZHPMP447_cjs = require('./chunk-ZHPMP447.cjs');
+var ans = require('@holoscript/core-types/ans');
+
+// src/compiler/render-modules/geometry-registry.ts
+function resolveGeometry(meshType) {
+  const key = String(meshType ?? "").trim().toLowerCase();
+  const kind = ALIAS[key] ?? "box";
+  return PRIMITIVE[kind];
+}
+var PRIMITIVE, ALIAS;
+var init_geometry_registry = chunkZHPMP447_cjs.__esm({
+  "src/compiler/render-modules/geometry-registry.ts"() {
+    PRIMITIVE = {
+      box: { kind: "box", webgpuVertexFn: "generateCubeVertices(1.0)" },
+      sphere: { kind: "sphere", webgpuVertexFn: "generateSphereVertices(0.5, 16, 16)" },
+      plane: { kind: "plane", webgpuVertexFn: "generatePlaneVertices(1.0, 1.0)" },
+      cylinder: { kind: "cylinder", webgpuVertexFn: "generateCylinderVertices(0.5, 1.0, 16)" },
+      cone: { kind: "cone", webgpuVertexFn: "generateConeVertices(0.5, 1.0, 16)" },
+      torus: { kind: "torus", webgpuVertexFn: "generateTorusVertices(0.5, 0.15, 16, 32)" }
+    };
+    ALIAS = {
+      // box family (panels, rounded boxes read as boxes)
+      cube: "box",
+      box: "box",
+      rounded_panel: "box",
+      rounded_box: "box",
+      panel: "box",
+      card: "box",
+      // sphere family
+      sphere: "sphere",
+      orb: "sphere",
+      ball: "sphere",
+      bubble: "sphere",
+      procedural_upper_body: "sphere",
+      avatar: "sphere",
+      // plane / surface family
+      plane: "plane",
+      quad: "plane",
+      surface: "plane",
+      full_screen_fluid_plane: "plane",
+      fluid_plane: "plane",
+      water: "plane",
+      // cylinder family
+      cylinder: "cylinder",
+      tube: "cylinder",
+      pillar: "cylinder",
+      capsule: "cylinder",
+      // cone family
+      cone: "cone",
+      pyramid: "cone",
+      spike: "cone",
+      crystal: "cone",
+      diamond: "cone",
+      gem: "cone",
+      // torus family
+      torus: "torus",
+      ring: "torus",
+      donut: "torus"
+    };
+  }
+});
+
+// src/compiler/render-modules/skybox-registry.ts
+function hexToRgb(hex) {
+  const h = hex.replace("#", "");
+  return [
+    Number((parseInt(h.substring(0, 2), 16) / 255).toFixed(4)),
+    Number((parseInt(h.substring(2, 4), 16) / 255).toFixed(4)),
+    Number((parseInt(h.substring(4, 6), 16) / 255).toFixed(4))
+  ];
+}
+function resolveSkyboxColor(name) {
+  const key = String(name ?? "").trim().toLowerCase();
+  const hex = SKYBOX_HEX[key];
+  return hex ? hexToRgb(hex) : FALLBACK;
+}
+var SKYBOX_HEX, FALLBACK;
+var init_skybox_registry = chunkZHPMP447_cjs.__esm({
+  "src/compiler/render-modules/skybox-registry.ts"() {
+    SKYBOX_HEX = {
+      // ── deep / space / void ─────────────────────────────────────────────
+      deep_machine_ocean: "#052430",
+      deep_space: "#05060d",
+      space: "#05060d",
+      nebula: "#0b0618",
+      night_sky: "#0b1020",
+      night_overcast: "#14161c",
+      void: "#050507",
+      midnight: "#070a12",
+      // ── water / underwater ──────────────────────────────────────────────
+      ocean: "#063240",
+      underwater: "#062a3a",
+      // ── studio / neutral (light backdrops kept light, just not pure white) ─
+      studio: "#c4c8cf",
+      neutral_studio: "#c4c8cf",
+      studio_soft: "#d2d5da",
+      hdr_studio: "#c9ccd2",
+      gallery: "#20222a",
+      indoor_museum: "#1c1e24",
+      interior_dark: "#14151a",
+      classroom: "#d2cfc6",
+      warehouse: "#3a3c40",
+      asset_pipeline_warehouse: "#3a3c40",
+      // ── sky / daylight ──────────────────────────────────────────────────
+      procedural_sky: "#8fbce6",
+      clear_sky: "#8fbce6",
+      daylight: "#9ec6ea",
+      fantasy_sky: "#2a3a6a",
+      sunset: "#46283a",
+      dusk: "#2e2740",
+      desert_dawn: "#caa079",
+      // ── tech / abstract ─────────────────────────────────────────────────
+      digital_grid: "#0a0f1e",
+      gradient: "#1a2030",
+      // ── environments / scenes ───────────────────────────────────────────
+      industrial: "#2a2d30",
+      urban_courtyard: "#3a3d42",
+      ancient_ruins: "#3a3428",
+      concert_venue: "#0e0a14",
+      lounge: "#1a1220",
+      farm: "#7fae5a",
+      vault_archive: "#1a140a",
+      passthrough: "#0c0c0e",
+      default: "#0a0e14"
+    };
+    FALLBACK = hexToRgb("#0a0e14");
+  }
+});
+
+// src/compiler/render-modules/geometry-purpose.ts
+function coerceBool(v) {
+  if (v === true || v === "true") return true;
+  if (v === false || v === "false") return false;
+  return void 0;
+}
+function resolveGeometryRole(opts) {
+  let purpose = "render";
+  const p = String(opts.purpose ?? "").trim().toLowerCase();
+  if (p && ALL_PURPOSES.has(p)) {
+    purpose = p;
+  } else {
+    for (const t of opts.traitNames ?? []) {
+      const mapped = PURPOSE_TRAITS[String(t).trim().toLowerCase()];
+      if (mapped) {
+        purpose = mapped;
+        break;
+      }
+    }
+  }
+  const explicit = coerceBool(opts.visible);
+  const visible = explicit !== void 0 ? explicit : purpose === "render";
+  return { purpose, visible };
+}
+var INVISIBLE_PURPOSES, PURPOSE_TRAITS, ALL_PURPOSES;
+var init_geometry_purpose = chunkZHPMP447_cjs.__esm({
+  "src/compiler/render-modules/geometry-purpose.ts"() {
+    INVISIBLE_PURPOSES = /* @__PURE__ */ new Set([
+      "collision",
+      "trigger",
+      "vfx_emitter",
+      "sim_domain",
+      "navmesh",
+      "occluder",
+      "audio_zone"
+    ]);
+    PURPOSE_TRAITS = {
+      collider: "collision",
+      collision: "collision",
+      physics_collider: "collision",
+      rigidbody_collider: "collision",
+      trigger: "trigger",
+      trigger_volume: "trigger",
+      interaction_volume: "trigger",
+      emitter: "vfx_emitter",
+      vfx_emitter: "vfx_emitter",
+      particle_emitter: "vfx_emitter",
+      spawn_volume: "vfx_emitter",
+      sim_domain: "sim_domain",
+      sim_volume: "sim_domain",
+      fluid_domain: "sim_domain",
+      field_region: "sim_domain",
+      navmesh: "navmesh",
+      nav_mesh: "navmesh",
+      occluder: "occluder",
+      occlusion: "occluder",
+      audio_zone: "audio_zone",
+      audio_volume: "audio_zone"
+    };
+    ALL_PURPOSES = /* @__PURE__ */ new Set([
+      "render",
+      ...Array.from(INVISIBLE_PURPOSES)
+    ]);
+  }
+});
+
+// src/compiler/WebGPUCompiler.ts
+var WebGPUCompiler_exports = {};
+chunkZHPMP447_cjs.__export(WebGPUCompiler_exports, {
+  WebGPUCompiler: () => exports.WebGPUCompiler
+});
+function isGpuParticleTraitName(name) {
+  return typeof name === "string" && (name === "gpu_particle" || name.startsWith("vfx_particle_"));
+}
+function findGpuParticleTrait(traits) {
+  return traits?.find((t) => isGpuParticleTraitName(t.name));
+}
+exports.WebGPUCompiler = void 0;
+var init_WebGPUCompiler = chunkZHPMP447_cjs.__esm({
+  "src/compiler/WebGPUCompiler.ts"() {
+    chunkSE2Y5BSL_cjs.init_CompilerBase();
+    init_geometry_registry();
+    init_skybox_registry();
+    init_geometry_purpose();
+    chunkP65OIMJT_cjs.init_DomainBlockCompilerMixin();
+    exports.WebGPUCompiler = class extends chunkSE2Y5BSL_cjs.CompilerBase {
+      constructor(options = {}) {
+        super();
+        this.compilerName = "WebGPUCompiler";
+        this.lines = [];
+        this.indentLevel = 0;
+        this.objectIndex = 0;
+        // Resolved once per compile() so findObjProp can fall back to template defaults.
+        this.templatesByName = /* @__PURE__ */ new Map();
+        // True when any object is a water/fluid surface — gates the animated water
+        // pipeline, its WGSL, the tessellated-plane helper, and the shared time uniform.
+        this.hasWater = false;
+        /** World facts collected at emission time, serialized as the HoloScene Manifest. */
+        this.manifestObjects = [];
+        /** Accumulated spatial-group translation for the objects currently being
+         *  emitted — manifest positions are WORLD-space (render applies the same
+         *  offsets via GroupXform; local coords would be a false fact for grouped
+         *  scenes). */
+        this.manifestGroupOffset = [0, 0, 0];
+        // The named channels the water surface's clarity/ripple are bound to (from the
+        // .holo's water_clarity_binding / ripple_intensity_binding props). Host state
+        // (e.g. Brittney receipts) drives these BY NAME via hsSetChannel.
+        this.waterClarityChannel = "environmentWaterClarity";
+        this.waterRippleChannel = "environmentRippleIntensity";
+        this.options = {
+          entryPoint: options.entryPoint || "main",
+          enableCompute: options.enableCompute ?? true,
+          msaa: options.msaa || 4,
+          indent: options.indent || "  ",
+          provenanceHash: options.provenanceHash ?? ""
+        };
+      }
+      getRequiredCapability() {
+        return ans.ANSCapabilityPath.WEBGPU;
+      }
+      compile(composition, agentToken, outputPath) {
+        this.validateCompilerAccess(agentToken, outputPath);
+        this.lines = [];
+        this.indentLevel = 0;
+        this.objectIndex = 0;
+        this.manifestObjects = [];
+        this.manifestGroupOffset = [0, 0, 0];
+        this.templatesByName = new Map(
+          (composition.templates ?? []).map((t) => [t.name, t])
+        );
+        this.hasWater = this.compositionHasWater(composition);
+        if (this.hasWater) this.resolveWaterChannels(composition);
+        this.emit("// Auto-generated by HoloScript WebGPUCompiler");
+        this.emit(
+          `// Source: composition "${this.escapeStringValue(composition.name, "TypeScript")}"`
+        );
+        this.emit("// Do not edit manually \u2014 regenerate from .holo source");
+        if (this.options.provenanceHash) {
+          this.emit(`// Provenance Hash: ${this.options.provenanceHash}`);
+        }
+        this.emit("");
+        this.emitDeviceInit();
+        this.emitGeometryHelpers();
+        this.emitShaderSources();
+        this.emitEnvironment(composition.environment ?? { type: "Environment", properties: [] });
+        this.emitCamera(composition);
+        this.emitSceneLights(composition);
+        if (this.hasWater) {
+          const cc = JSON.stringify(this.waterClarityChannel);
+          const rc = JSON.stringify(this.waterRippleChannel);
+          this.emit(`const hsChannels = { [${cc}]: 1.0, [${rc}]: 0.0 };`);
+          this.emit("let hsWaterAmp = 1.0;");
+          this.emit(
+            "function hsSetChannel(name, value) { if (name in hsChannels) hsChannels[name] = Math.max(0, Math.min(1, value)); return hsChannels[name]; }"
+          );
+          this.emit(
+            `function hsSetWater(o) { if (o) { if (o.clarity !== undefined) hsSetChannel(${cc}, o.clarity); if (o.ripple !== undefined) hsSetChannel(${rc}, o.ripple); if (o.amplitude !== undefined) hsWaterAmp = Math.max(0, o.amplitude); } return { clarity: hsChannels[${cc}], ripple: hsChannels[${rc}], amplitude: hsWaterAmp }; }`
+          );
+          this.emit(
+            'if (typeof window !== "undefined") { window.hsSetChannel = hsSetChannel; window.hsSetWater = hsSetWater; }'
+          );
+          this.emit(
+            `const waterFrameU = createBuffer(device, new Float32Array([0,0,0,0, hsChannels[${cc}], hsChannels[${rc}], hsWaterAmp, 0]), GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST);`
+          );
+          this.emit("");
+        }
+        this.emit("const holoGraphObjects = [];");
+        this.emit("");
+        if (composition.objects) {
+          for (const obj of composition.objects) this.emitObject(obj);
+        }
+        if (composition.spatialGroups) {
+          for (const group of composition.spatialGroups) this.emitGroup(group);
+        }
+        this.emitSceneManifest(composition);
+        if (this.options.enableCompute) this.emitComputeShaders(composition);
+        this.emitWebGPUDomainBlocks(composition);
+        this.emitViewportRuntime();
+        this.emitRenderLoop(composition);
+        return this.lines.join("\n");
+      }
+      emitWebGPUDomainBlocks(composition) {
+        const domainBlocks = composition.domainBlocks ?? [];
+        if (domainBlocks.length === 0) return;
+        this.emit("");
+        this.emit("// === v4.2 Domain Blocks ===");
+        for (let i = 0; i < domainBlocks.length; i++) {
+          const block = domainBlocks[i];
+          const prefix = this.domainBlockVar(block, i);
+          switch (block.domain) {
+            case "material":
+              this.emitMaterialDomainBlock(block, prefix);
+              break;
+            case "dataviz":
+              this.emitMultiline(chunkP65OIMJT_cjs.datavizToWebGPU(chunkP65OIMJT_cjs.compileDataVizBlock(block), prefix));
+              break;
+            case "vfx":
+              this.emitParticleDomainBlock(block, prefix);
+              break;
+            case "postfx":
+              this.emitPostFXDomainBlock(block, prefix);
+              break;
+            case "procedural":
+              this.emitProceduralDomainBlock(block, prefix);
+              break;
+            default:
+              this.emitDomainMetadataBlock(block, prefix);
+              break;
+          }
+          this.emit("");
+        }
+      }
+      emitMaterialDomainBlock(block, prefix) {
+        const mat = chunkP65OIMJT_cjs.compileMaterialBlock(block);
+        this.emitMultiline(chunkP65OIMJT_cjs.materialToWebGPU(mat, prefix));
+        if (Object.keys(mat.textureMaps).length > 0) {
+          this.emit(`const ${prefix}TextureMaps = ${this.json(mat.textureMaps)};`);
+          this.emit(`const ${prefix}Textures = await loadMaterialTextureSet(${prefix}TextureMaps);`);
+          this.emit(
+            `const ${prefix}TextureReceipt = { name: "${this.escapeStringValue(mat.name, "TypeScript")}", maps: Object.keys(${prefix}TextureMaps), loaded: Object.values(${prefix}Textures).filter((t) => t.loaded).length };`
+          );
+        }
+      }
+      emitParticleDomainBlock(block, prefix) {
+        const ps = chunkP65OIMJT_cjs.compileParticleBlock(block);
+        const count = Math.max(
+          1,
+          Math.floor(
+            this.numberProp(block, ["max_particles", "maxParticles", "count", "rate"], 512)
+          )
+        );
+        const seed = this.hashSeed(`${ps.name}:${ps.keyword}:${count}`);
+        this.emit(`// Domain particles: ${this.escapeStringValue(ps.name, "TypeScript")}`);
+        this.emit(`const ${prefix}ParticleConfig = ${this.json({
+          name: ps.name,
+          keyword: ps.keyword,
+          traits: ps.traits,
+          properties: ps.properties,
+          modules: ps.modules
+        })};`);
+        this.emit(`const ${prefix}ParticleCount = ${count};`);
+        this.emit(`const ${prefix}ParticleData = makeParticleCloud(${prefix}ParticleCount, ${seed});`);
+        this.emit(
+          `const ${prefix}ParticleBuf = createBuffer(device, ${prefix}ParticleData, GPUBufferUsage.VERTEX | GPUBufferUsage.STORAGE);`
+        );
+        this.emit(`const ${prefix}ParticlePipeline = device.createRenderPipeline({`);
+        this.indent();
+        this.emit('layout: "auto",');
+        this.emit(
+          'vertex: { module: device.createShaderModule({ code: WGSL_PARTICLE_RENDER }), entryPoint: "vs_particle",'
+        );
+        this.emit(
+          '  buffers: [{ arrayStride: 32, attributes: [{ shaderLocation: 0, offset: 0, format: "float32x3" }, { shaderLocation: 1, offset: 12, format: "float32x3" }, { shaderLocation: 2, offset: 24, format: "float32" }] }] },'
+        );
+        this.emit(
+          'fragment: { module: device.createShaderModule({ code: WGSL_PARTICLE_RENDER }), entryPoint: "fs_particle",'
+        );
+        this.emit(
+          '  targets: [{ format, blend: { color: { srcFactor: "src-alpha", dstFactor: "one", operation: "add" }, alpha: { srcFactor: "zero", dstFactor: "one", operation: "add" } } }] },'
+        );
+        this.emit(
+          'primitive: { topology: "point-list" }, depthStencil: { format: "depth24plus", depthWriteEnabled: false, depthCompare: "less" },'
+        );
+        this.dedent();
+        this.emit("});");
+      }
+      emitPostFXDomainBlock(block, prefix) {
+        const pp = chunkP65OIMJT_cjs.compilePostProcessingBlock(block);
+        this.emit(`// Domain post-processing: ${this.escapeStringValue(pp.name ?? block.name, "TypeScript")}`);
+        this.emit(`const ${prefix}PostFXConfig = ${this.json({
+          name: pp.name,
+          keyword: pp.keyword,
+          effects: pp.effects
+        })};`);
+        this.emit(`const ${prefix}PostFXPipeline = device.createRenderPipeline({`);
+        this.indent();
+        this.emit('layout: "auto",');
+        this.emit(
+          'vertex: { module: device.createShaderModule({ code: WGSL_POSTFX }), entryPoint: "vs_postfx" },'
+        );
+        this.emit(
+          'fragment: { module: device.createShaderModule({ code: WGSL_POSTFX }), entryPoint: "fs_postfx", targets: [{ format, blend: { color: { srcFactor: "src-alpha", dstFactor: "one-minus-src-alpha", operation: "add" }, alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" } } }] },'
+        );
+        this.emit('primitive: { topology: "triangle-list" }, multisample: { count: MSAA_COUNT },');
+        this.dedent();
+        this.emit("});");
+      }
+      emitProceduralDomainBlock(block, prefix) {
+        const proc = chunkP65OIMJT_cjs.compileProceduralBlock(block);
+        this.emit(`// Domain procedural: ${this.escapeStringValue(proc.name, "TypeScript")}`);
+        this.emit(`const ${prefix}ProceduralConfig = ${this.json({
+          name: proc.name,
+          keyword: proc.keyword,
+          genType: proc.genType,
+          seed: proc.seed,
+          density: proc.density,
+          scaleRange: proc.scaleRange,
+          noise: proc.noise,
+          sourceMesh: proc.sourceMesh,
+          traits: proc.traits,
+          properties: proc.properties
+        })};`);
+        this.emit(
+          `const ${prefix}ProceduralUniform = createBuffer(device, new Float32Array([${proc.seed ?? 1}, ${proc.density ?? 1}, ${this.numberProp(block, ["count"], 1)}, 0]), GPUBufferUsage.UNIFORM);`
+        );
+        if (block.keyword === "scatter" || block.keyword === "distribute" || block.properties?.count) {
+          const count = Math.max(1, Math.floor(this.numberProp(block, ["count"], 128)));
+          this.emit(`const ${prefix}ScatterInstanceCount = ${count};`);
+          this.emit(`const ${prefix}ScatterVertices = generateConeVertices(0.08, 0.36, 8);`);
+          this.emit(`const ${prefix}ScatterVBO = createBuffer(device, ${prefix}ScatterVertices, GPUBufferUsage.VERTEX);`);
+          this.emit(`const ${prefix}ScatterVertexCount = ${prefix}ScatterVertices.length / 6;`);
+          this.emit(`const ${prefix}ScatterPipeline = device.createRenderPipeline({`);
+          this.indent();
+          this.emit('layout: "auto",');
+          this.emit(
+            'vertex: { module: device.createShaderModule({ code: WGSL_SCATTER }), entryPoint: "vs_scatter",'
+          );
+          this.emit(
+            '  buffers: [{ arrayStride: 24, attributes: [{ shaderLocation: 0, offset: 0, format: "float32x3" }, { shaderLocation: 1, offset: 12, format: "float32x3" }] }] },'
+          );
+          this.emit(
+            'fragment: { module: device.createShaderModule({ code: WGSL_SCATTER }), entryPoint: "fs_scatter", targets: [{ format }] },'
+          );
+          this.emit(
+            'primitive: { topology: "triangle-list", cullMode: "back" }, depthStencil: { format: "depth24plus", depthWriteEnabled: true, depthCompare: "less" }, multisample: { count: MSAA_COUNT },'
+          );
+          this.dedent();
+          this.emit("});");
+        }
+      }
+      emitDomainMetadataBlock(block, prefix) {
+        this.emit(`const ${prefix}DomainBlock = ${this.json({
+          domain: block.domain,
+          keyword: block.keyword,
+          name: block.name,
+          traits: block.traits,
+          properties: block.properties,
+          childCount: block.children?.length ?? 0
+        })};`);
+      }
+      // ─── Device Init ──────────────────────────────────────────────────────────
+      emitDeviceInit() {
+        this.emit("// === WebGPU Device Initialization ===");
+        this.emit('const canvas = document.querySelector("canvas") as HTMLCanvasElement;');
+        this.emit("const adapter = await navigator.gpu.requestAdapter();");
+        this.emit('if (!adapter) throw new Error("WebGPU not supported");');
+        this.emit("const device = await adapter.requestDevice();");
+        this.emit('document.body.dataset.holoscriptWebgpu = "device-ready";');
+        this.emit('const context = canvas.getContext("webgpu") as GPUCanvasContext;');
+        this.emit("const format = navigator.gpu.getPreferredCanvasFormat();");
+        this.emit('context.configure({ device, format, alphaMode: "premultiplied" });');
+        this.emit(`const MSAA_COUNT = ${this.options.msaa};`);
+        this.emit(
+          "const msaaTexture = device.createTexture({ size: [canvas.width, canvas.height], sampleCount: MSAA_COUNT, format, usage: GPUTextureUsage.RENDER_ATTACHMENT });"
+        );
+        this.emit(
+          'const depthTexture = device.createTexture({ size: [canvas.width, canvas.height], sampleCount: MSAA_COUNT, format: "depth24plus", usage: GPUTextureUsage.RENDER_ATTACHMENT });'
+        );
+        this.emit("");
+        this.emit(
+          "function createBuffer(device: GPUDevice, data: Float32Array, usage: number): GPUBuffer {"
+        );
+        this.indent();
+        this.emit(
+          "const buf = device.createBuffer({ size: data.byteLength, usage: usage | GPUBufferUsage.COPY_DST });"
+        );
+        this.emit("device.queue.writeBuffer(buf, 0, data); return buf;");
+        this.dedent();
+        this.emit("}");
+        this.emit("function createStorageBuffer(device: GPUDevice, size: number): GPUBuffer {");
+        this.indent();
+        this.emit(
+          "return device.createBuffer({ size, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST });"
+        );
+        this.dedent();
+        this.emit("}");
+        this.emit("function createFallbackTexture(device, rgba) {");
+        this.indent();
+        this.emit('const tex = device.createTexture({ size: [1, 1, 1], format: "rgba8unorm", usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST });');
+        this.emit("device.queue.writeTexture({ texture: tex }, new Uint8Array(rgba), { bytesPerRow: 4 }, [1, 1, 1]);");
+        this.emit("return tex;");
+        this.dedent();
+        this.emit("}");
+        this.emit("async function loadTexture2D(src) {");
+        this.indent();
+        this.emit('const sampler = device.createSampler({ magFilter: "linear", minFilter: "linear", mipmapFilter: "linear", addressModeU: "repeat", addressModeV: "repeat" });');
+        this.emit("try {");
+        this.indent();
+        this.emit("const resp = await fetch(src);");
+        this.emit("if (!resp.ok) throw new Error(`texture fetch ${resp.status}`);");
+        this.emit("const bitmap = await createImageBitmap(await resp.blob());");
+        this.emit('const texture = device.createTexture({ size: [bitmap.width, bitmap.height, 1], format: "rgba8unorm", usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT });');
+        this.emit("device.queue.copyExternalImageToTexture({ source: bitmap }, { texture }, [bitmap.width, bitmap.height]);");
+        this.emit("return { src, texture, view: texture.createView(), sampler, loaded: true };");
+        this.dedent();
+        this.emit("} catch {");
+        this.indent();
+        this.emit("const texture = createFallbackTexture(device, [255, 255, 255, 255]);");
+        this.emit("return { src, texture, view: texture.createView(), sampler, loaded: false };");
+        this.dedent();
+        this.emit("}");
+        this.dedent();
+        this.emit("}");
+        this.emit("async function loadMaterialTextureSet(maps) {");
+        this.indent();
+        this.emit("const entries = await Promise.all(Object.entries(maps).map(async ([kind, src]) => [kind, await loadTexture2D(src)]));");
+        this.emit("return Object.fromEntries(entries);");
+        this.dedent();
+        this.emit("}");
+        this.emit("const assetLoader = {");
+        this.indent();
+        this.emit("async load(src) {");
+        this.indent();
+        this.emit('return { src, kind: "external-model", loaded: false };');
+        this.dedent();
+        this.emit("},");
+        this.dedent();
+        this.emit("};");
+        this.emit("function makeParticleCloud(count, seed) {");
+        this.indent();
+        this.emit("let s = seed || 1;");
+        this.emit("const rnd = () => { s = (s * 1664525 + 1013904223) >>> 0; return s / 4294967296; };");
+        this.emit("const data = new Float32Array(count * 8);");
+        this.emit("for (let i = 0; i < count; i++) {");
+        this.indent();
+        this.emit("const o = i * 8;");
+        this.emit("data[o + 0] = rnd() * 1.8 - 0.9; data[o + 1] = rnd() * 1.2 - 0.6; data[o + 2] = rnd() * 1.8 - 0.9;");
+        this.emit("data[o + 3] = 0.0; data[o + 4] = 0.25 + rnd(); data[o + 5] = 0.0; data[o + 6] = rnd(); data[o + 7] = 0.0;");
+        this.dedent();
+        this.emit("}");
+        this.emit("return data;");
+        this.dedent();
+        this.emit("}");
+        this.emit("");
+      }
+      emitGeometryHelpers() {
+        this.emit("// === Geometry Helpers ===");
+        this.emit("function generateCubeVertices(size) {");
+        this.indent();
+        this.emit("const s = size / 2;");
+        this.emit("return new Float32Array([");
+        this.indent();
+        this.emit("-s,-s, s, 0,0,1,  s,-s, s, 0,0,1,  s, s, s, 0,0,1, -s,-s, s, 0,0,1,  s, s, s, 0,0,1, -s, s, s, 0,0,1,");
+        this.emit(" s,-s,-s, 0,0,-1, -s,-s,-s, 0,0,-1, -s, s,-s, 0,0,-1,  s,-s,-s, 0,0,-1, -s, s,-s, 0,0,-1,  s, s,-s, 0,0,-1,");
+        this.emit("-s,-s,-s, -1,0,0, -s,-s, s, -1,0,0, -s, s, s, -1,0,0, -s,-s,-s, -1,0,0, -s, s, s, -1,0,0, -s, s,-s, -1,0,0,");
+        this.emit(" s,-s, s, 1,0,0,  s,-s,-s, 1,0,0,  s, s,-s, 1,0,0,  s,-s, s, 1,0,0,  s, s,-s, 1,0,0,  s, s, s, 1,0,0,");
+        this.emit("-s, s, s, 0,1,0,  s, s, s, 0,1,0,  s, s,-s, 0,1,0, -s, s, s, 0,1,0,  s, s,-s, 0,1,0, -s, s,-s, 0,1,0,");
+        this.emit("-s,-s,-s, 0,-1,0,  s,-s,-s, 0,-1,0,  s,-s, s, 0,-1,0, -s,-s,-s, 0,-1,0,  s,-s, s, 0,-1,0, -s,-s, s, 0,-1,0");
+        this.dedent();
+        this.emit("]);");
+        this.dedent();
+        this.emit("}");
+        this.emit("function generatePlaneVertices(width, depth) {");
+        this.indent();
+        this.emit("const x = width / 2, z = depth / 2;");
+        this.emit("return new Float32Array([-x,0,-z,0,1,0, x,0,-z,0,1,0, x,0,z,0,1,0, -x,0,-z,0,1,0, x,0,z,0,1,0, -x,0,z,0,1,0]);");
+        this.dedent();
+        this.emit("}");
+        if (this.hasWater) {
+          this.emit("function generateWaterPlaneVertices(w, h, n) {");
+          this.indent();
+          this.emit("const out = [], hw = w/2, hh = h/2, N = Math.max(2, n|0);");
+          this.emit("for (let iy=0; iy<N; iy++) { for (let ix=0; ix<N; ix++) {");
+          this.emit("  const x0=-hw+w*ix/N, x1=-hw+w*(ix+1)/N, y0=-hh+h*iy/N, y1=-hh+h*(iy+1)/N;");
+          this.emit("  const a=[x0,y0,0,0,0,1], b=[x1,y0,0,0,0,1], c=[x1,y1,0,0,0,1], d=[x0,y1,0,0,0,1];");
+          this.emit("  out.push(...a,...b,...c, ...a,...c,...d);");
+          this.emit("} } return new Float32Array(out);");
+          this.dedent();
+          this.emit("}");
+        }
+        this.emit("function generateSphereVertices(radius, lat, lon) {");
+        this.indent();
+        this.emit("const rings = Math.max(3, lat | 0), segs = Math.max(3, lon | 0); const out = [];");
+        this.emit("const P = (ri, si) => {");
+        this.emit("  const phi = Math.PI * ri / rings, theta = 2 * Math.PI * si / segs;");
+        this.emit("  const nx = Math.sin(phi) * Math.cos(theta), ny = Math.cos(phi), nz = Math.sin(phi) * Math.sin(theta);");
+        this.emit("  return [nx * radius, ny * radius, nz * radius, nx, ny, nz];");
+        this.emit("};");
+        this.emit("for (let ri = 0; ri < rings; ri++) { for (let si = 0; si < segs; si++) {");
+        this.emit("  const a = P(ri, si), b = P(ri + 1, si), c = P(ri + 1, si + 1), d = P(ri, si + 1);");
+        this.emit("  out.push(...a, ...b, ...c, ...a, ...c, ...d);");
+        this.emit("} } return new Float32Array(out);");
+        this.dedent();
+        this.emit("}");
+        this.emit("function generateCylinderVertices(radius, height, segments) {");
+        this.indent();
+        this.emit("const segs = Math.max(3, segments | 0), hy = height / 2, out = [];");
+        this.emit("for (let i = 0; i < segs; i++) {");
+        this.emit("  const t0 = 2*Math.PI*i/segs, t1 = 2*Math.PI*(i+1)/segs;");
+        this.emit("  const c0 = Math.cos(t0), s0 = Math.sin(t0), c1 = Math.cos(t1), s1 = Math.sin(t1);");
+        this.emit("  const b0 = [radius*c0, -hy, radius*s0, c0, 0, s0], t0v = [radius*c0, hy, radius*s0, c0, 0, s0];");
+        this.emit("  const b1 = [radius*c1, -hy, radius*s1, c1, 0, s1], t1v = [radius*c1, hy, radius*s1, c1, 0, s1];");
+        this.emit("  out.push(...b0, ...b1, ...t1v, ...b0, ...t1v, ...t0v);");
+        this.emit("  out.push(0, hy, 0, 0, 1, 0, radius*c0, hy, radius*s0, 0, 1, 0, radius*c1, hy, radius*s1, 0, 1, 0);");
+        this.emit("  out.push(0, -hy, 0, 0, -1, 0, radius*c1, -hy, radius*s1, 0, -1, 0, radius*c0, -hy, radius*s0, 0, -1, 0);");
+        this.emit("} return new Float32Array(out);");
+        this.dedent();
+        this.emit("}");
+        this.emit("function generateConeVertices(radius, height, segments) {");
+        this.indent();
+        this.emit("const segs = Math.max(3, segments | 0), hy = height / 2, out = [];");
+        this.emit("const ny = radius / Math.hypot(radius, height) || 0, nyx = height / Math.hypot(radius, height) || 1;");
+        this.emit("for (let i = 0; i < segs; i++) {");
+        this.emit("  const t0 = 2*Math.PI*i/segs, t1 = 2*Math.PI*(i+1)/segs;");
+        this.emit("  const c0 = Math.cos(t0), s0 = Math.sin(t0), c1 = Math.cos(t1), s1 = Math.sin(t1);");
+        this.emit("  out.push(0, hy, 0, (c0+c1)*0.5*nyx, ny, (s0+s1)*0.5*nyx);");
+        this.emit("  out.push(radius*c0, -hy, radius*s0, c0*nyx, ny, s0*nyx);");
+        this.emit("  out.push(radius*c1, -hy, radius*s1, c1*nyx, ny, s1*nyx);");
+        this.emit("  out.push(0, -hy, 0, 0, -1, 0, radius*c1, -hy, radius*s1, 0, -1, 0, radius*c0, -hy, radius*s0, 0, -1, 0);");
+        this.emit("} return new Float32Array(out);");
+        this.dedent();
+        this.emit("}");
+        this.emit("function generateTorusVertices(radius, tube, radial, tubular) {");
+        this.indent();
+        this.emit("const R = Math.max(3, radial | 0), T = Math.max(3, tubular | 0), out = [];");
+        this.emit("const P = (ri, ti) => {");
+        this.emit("  const u = 2*Math.PI*ri/R, v = 2*Math.PI*ti/T;");
+        this.emit("  const cu = Math.cos(u), su = Math.sin(u), cv = Math.cos(v), sv = Math.sin(v);");
+        this.emit("  const x = (radius + tube*cv)*cu, y = tube*sv, z = (radius + tube*cv)*su;");
+        this.emit("  return [x, y, z, cv*cu, sv, cv*su];");
+        this.emit("};");
+        this.emit("for (let ri = 0; ri < R; ri++) { for (let ti = 0; ti < T; ti++) {");
+        this.emit("  const a = P(ri, ti), b = P(ri + 1, ti), c = P(ri + 1, ti + 1), d = P(ri, ti + 1);");
+        this.emit("  out.push(...a, ...b, ...c, ...a, ...c, ...d);");
+        this.emit("} } return new Float32Array(out);");
+        this.dedent();
+        this.emit("}");
+        this.emit("");
+      }
+      // ─── Environment ──────────────────────────────────────────────────────────
+      emitEnvironment(env) {
+        this.emit("// === Environment ===");
+        const envData = {};
+        for (const prop of env.properties) envData[prop.key] = prop.value;
+        const bg = envData.background || envData.skybox || "#000000";
+        const bgColor = typeof bg === "string" && bg.startsWith("#") || Array.isArray(bg) ? this.parseColor(bg) : resolveSkyboxColor(bg);
+        this.emit(
+          `const clearColor: GPUColor = { r: ${bgColor[0]}, g: ${bgColor[1]}, b: ${bgColor[2]}, a: 1.0 };`
+        );
+        if (envData.fog && typeof envData.fog === "object") {
+          const fog = envData.fog;
+          const fc = this.parseColor(fog.color || "#cccccc");
+          this.emit(
+            `const fogUniforms = createBuffer(device, new Float32Array([${fc[0]}, ${fc[1]}, ${fc[2]}, 1.0, ${fog.near ?? 10}, ${fog.far ?? 100}, 0.0, 0.0]), GPUBufferUsage.UNIFORM);`
+          );
+        }
+        if (envData.ambient_light !== void 0) {
+          this.emit(
+            `const ambientIntensity = ${typeof envData.ambient_light === "number" ? envData.ambient_light : 0.5};`
+          );
+        }
+        this.emit("");
+      }
+      // ─── Object ───────────────────────────────────────────────────────────────
+      emitObject(obj) {
+        this.objectIndex++;
+        const v = this.sanitizeName(obj.name);
+        const meshType = this.findObjProp(obj, "geometry") || this.findObjProp(obj, "mesh") || this.findObjProp(obj, "type") || "cube";
+        const modelSrc = this.findObjProp(obj, "source") || this.findObjProp(obj, "src") || this.findObjProp(obj, "model");
+        const isModel = meshType === "model" || !!modelSrc;
+        const traits = obj.traits || [];
+        this.emit(`// Object: ${this.escapeStringValue(obj.name, "TypeScript")}`);
+        const role = resolveGeometryRole({
+          purpose: this.findObjProp(obj, "purpose"),
+          visible: this.findObjProp(obj, "visible"),
+          traitNames: traits.map((t) => t.name)
+        });
+        if (!role.visible) {
+          const prim = resolveGeometry(meshType).kind;
+          const pos = this.findObjProp(obj, "position");
+          const [px, py, pz] = Array.isArray(pos) ? pos : [0, 0, 0];
+          this.emit(
+            `// Functional geometry \u2014 purpose="${role.purpose}", not rendered; primitive="${prim}" is shared with physics/vfx/sim consumers.`
+          );
+          this.emit(
+            `holoGraphObjects.push({ id: "${this.escapeStringValue(obj.name, "TypeScript")}", name: "${this.escapeStringValue(obj.name, "TypeScript")}", geometry: "${this.escapeStringValue(meshType, "TypeScript")}", primitive: "${prim}", purpose: "${role.purpose}", visible: false, traits: ${this.json(traits.map((t) => t.name))}, basePosition: [${px},${py},${pz}], position: [${px},${py},${pz}] });`
+          );
+          this.manifestObjects.push({
+            id: String(obj.name ?? ""),
+            geometry: meshType,
+            primitive: prim,
+            purpose: role.purpose,
+            visible: false,
+            traits: traits.map((t) => t.name),
+            affordances: this.extractAffordanceNames(obj),
+            position: [
+              px + this.manifestGroupOffset[0],
+              py + this.manifestGroupOffset[1],
+              pz + this.manifestGroupOffset[2]
+            ]
+          });
+          this.emit("");
+          if (obj.children) {
+            for (const child of obj.children) this.emitObject(child);
+          }
+          return;
+        }
+        const isGaussianSplat = traits.some((t) => t.name === "gaussian_splat");
+        const isPointCloud = traits.some((t) => t.name === "point_cloud");
+        const isGpuParticle = traits.some((t) => isGpuParticleTraitName(t.name));
+        if (isModel && modelSrc) {
+          this.emit(`const ${v}Asset = await assetLoader.load("${modelSrc}");`);
+          this.emit(
+            `// Model asset "${this.escapeStringValue(modelSrc, "TypeScript")}" is tracked in ${v}Asset; fallback mesh keeps the render path defined.`
+          );
+          this.emitMeshObject(v, obj, "cube");
+        } else if (isModel) {
+          this.emit(`// WARNING: geometry "model" without source URL \u2014 placeholder cube`);
+          this.emitMeshObject(v, obj, "cube");
+        } else if (isGaussianSplat) {
+          this.emitGaussianSplatObject(v, obj);
+        } else if (isPointCloud) {
+          this.emitPointCloudObject(v, obj);
+        } else if (isGpuParticle) {
+          this.emitGpuParticleObject(v, obj);
+        } else if (this.isWaterObject(obj)) {
+          this.emitWaterObject(v, obj);
+        } else {
+          this.emitMeshObject(v, obj, meshType);
+        }
+        if (traits.some((t) => t.name === "gpu_physics")) {
+          this.emit(`const ${v}PhysicsBuf = createStorageBuffer(device, 1024 * 16); // gpu_physics`);
+        }
+        if (traits.some((t) => t.name === "compute" || t.name === "gpu_buffer")) {
+          const ct = traits.find((t) => t.name === "compute" || t.name === "gpu_buffer");
+          this.emit(
+            `const ${v}ComputeBuf = createStorageBuffer(device, ${ct?.config?.buffer_size || 4096});`
+          );
+        }
+        this.emit("");
+        if (obj.children) {
+          for (const child of obj.children) this.emitObject(child);
+        }
+      }
+      // ─── Water / fluid surfaces ────────────────────────────────────────────────
+      /**
+       * Resolve which named channels the water surface's clarity/ripple are bound to,
+       * from the first water object's `water_clarity_binding` / `ripple_intensity_binding`
+       * props. These names match the .holo's environment state fields, so host state
+       * (Brittney receipts) driving those fields drives the water by name.
+       */
+      resolveWaterChannels(composition) {
+        const all = [...composition.objects ?? []];
+        for (const g of composition.spatialGroups ?? []) all.push(...g.objects ?? []);
+        const water = all.find((o) => this.isWaterObject(o));
+        if (!water) return;
+        const clarity = this.findObjProp(water, "water_clarity_binding");
+        const ripple = this.findObjProp(water, "ripple_intensity_binding");
+        if (typeof clarity === "string" && clarity.trim()) this.waterClarityChannel = clarity.trim();
+        if (typeof ripple === "string" && ripple.trim()) this.waterRippleChannel = ripple.trim();
+      }
+      /** True if any object (incl. nested groups/children) is a water/fluid surface. */
+      compositionHasWater(composition) {
+        const scan = (objs) => (objs ?? []).some((o) => this.isWaterObject(o) || scan(o.children));
+        if (scan(composition.objects)) return true;
+        const walk = (g) => scan(g.objects) || (g.groups ?? []).some(walk);
+        return (composition.spatialGroups ?? []).some(walk);
+      }
+      /**
+       * A water surface is a fluid-plane mesh (full_screen_fluid_plane / water / ...),
+       * or a water-ish MATERIAL on a plane-like geometry. It is NOT a water material on
+       * a sphere — emitWaterObject always renders a tessellated plane.
+       */
+      isWaterObject(obj) {
+        const mesh = String(this.findObjProp(obj, "mesh") ?? this.findObjProp(obj, "geometry") ?? "").trim().toLowerCase();
+        const material = String(this.findObjProp(obj, "material") ?? "").trim().toLowerCase();
+        const WATER_MESH = ["full_screen_fluid_plane", "fluid_plane", "water", "water_plane", "ocean"];
+        const WATER_MAT = ["liquid_glass", "water", "liquid", "fluid"];
+        if (WATER_MESH.includes(mesh)) return true;
+        return WATER_MAT.includes(material) && resolveGeometry(mesh).kind === "plane";
+      }
+      /**
+       * Emit an animated water surface: a tessellated plane driven by the shared
+       * per-frame time uniform through the WGSL_WATER shader (Gerstner-lite height
+       * waves + analytic normals + texture-free caustics + fresnel). Binding layout
+       * mirrors the mesh path (0=Model, 2=vpUniform) plus 1=WaterStatic, 3=waterFrameU.
+       */
+      emitWaterObject(v, obj) {
+        const pos = this.findObjProp(obj, "position");
+        const scale = this.findObjProp(obj, "scale") || this.findObjProp(obj, "size");
+        const [px, py, pz] = Array.isArray(pos) ? pos : [0, 0, 0];
+        const [sx, sy, sz] = Array.isArray(scale) ? scale : typeof scale === "number" ? [scale, scale, scale] : [1, 1, 1];
+        const deep = this.parseColor(this.findObjProp(obj, "color") ?? "#06131f");
+        const shallow = [
+          Math.min(1, deep[0] * 2.2 + 0.05),
+          Math.min(1, deep[1] * 2.2 + 0.2),
+          Math.min(1, deep[2] * 2 + 0.24)
+        ];
+        const amplitude = 0.18, choppiness = 0.4, clarity = 1, ripple = 0;
+        const L = [0.3714, 0.7428, 0.5571];
+        this.emit(`// Water surface: ${this.escapeStringValue(obj.name, "TypeScript")}`);
+        this.emit(`const ${v}Vertices = generateWaterPlaneVertices(1.0, 1.0, 48);`);
+        this.emit(`const ${v}VBO = createBuffer(device, ${v}Vertices, GPUBufferUsage.VERTEX);`);
+        this.emit(`const ${v}VertexCount = ${v}Vertices.length / 6;`);
+        this.emit(
+          `const ${v}Model = createBuffer(device, new Float32Array([${sx},0,0,0, 0,${sy},0,0, 0,0,${sz},0, ${px},${py},${pz},1]), GPUBufferUsage.UNIFORM);`
+        );
+        this.emit(
+          `const ${v}WaterStatic = createBuffer(device, new Float32Array([${amplitude},${choppiness},${clarity},${ripple}, ${deep[0]},${deep[1]},${deep[2]},0, ${shallow[0]},${shallow[1]},${shallow[2]},0, ${L[0]},${L[1]},${L[2]},0]), GPUBufferUsage.UNIFORM);`
+        );
+        this.emit(`const ${v}WaterPipeline = device.createRenderPipeline({`);
+        this.indent();
+        this.emit('layout: "auto",');
+        this.emit(
+          'vertex: { module: device.createShaderModule({ code: WGSL_WATER }), entryPoint: "vs_water",'
+        );
+        this.emit(
+          '  buffers: [{ arrayStride: 24, attributes: [{ shaderLocation: 0, offset: 0, format: "float32x3" }, { shaderLocation: 1, offset: 12, format: "float32x3" }] }] },'
+        );
+        this.emit(
+          'fragment: { module: device.createShaderModule({ code: WGSL_WATER }), entryPoint: "fs_water", targets: [{ format }] },'
+        );
+        this.emit('primitive: { topology: "triangle-list", cullMode: "none" },');
+        this.emit(
+          `depthStencil: { format: "depth24plus", depthWriteEnabled: true, depthCompare: "less" }, multisample: { count: MSAA_COUNT },`
+        );
+        this.dedent();
+        this.emit("});");
+        this.emit(
+          `const ${v}WaterBind = device.createBindGroup({ layout: ${v}WaterPipeline.getBindGroupLayout(0), entries: [`
+        );
+        this.emit(
+          `  { binding: 0, resource: { buffer: ${v}Model } }, { binding: 1, resource: { buffer: ${v}WaterStatic } }, { binding: 2, resource: { buffer: vpUniform } }, { binding: 3, resource: { buffer: waterFrameU } }] });`
+        );
+      }
+      /** Emit the shared WGSL_WATER module (vs_water + fs_water + noise helpers). */
+      emitWaterShaderSource() {
+        this.emit("const WGSL_WATER = /* wgsl */`");
+        this.emit("struct Model { m: mat4x4<f32> };");
+        this.emit("struct WStatic { p: vec4<f32>, deep: vec4<f32>, shallow: vec4<f32>, lightDir: vec4<f32> };");
+        this.emit("struct Cam { viewProj: mat4x4<f32> };");
+        this.emit("struct WFrame { tc: vec4<f32>, dyn: vec4<f32> };");
+        this.emit("@group(0) @binding(0) var<uniform> model: Model;");
+        this.emit("@group(0) @binding(1) var<uniform> ws: WStatic;");
+        this.emit("@group(0) @binding(2) var<uniform> cam: Cam;");
+        this.emit("@group(0) @binding(3) var<uniform> wf: WFrame;");
+        this.emit("struct VIn { @location(0) pos: vec3<f32>, @location(1) norm: vec3<f32> };");
+        this.emit("struct VOut { @builtin(position) clip: vec4<f32>, @location(0) wNorm: vec3<f32>, @location(1) wPos: vec3<f32> };");
+        this.emit("@vertex fn vs_water(in: VIn) -> VOut {");
+        this.emit("  var o: VOut;");
+        this.emit("  let sx = length(model.m[0].xyz); let sy = length(model.m[1].xyz); let sz = max(length(model.m[2].xyz), 1e-4);");
+        this.emit("  let wp = in.pos.xy * vec2<f32>(sx, sy);");
+        this.emit("  let t = wf.tc.x; let amp = ws.p.x * wf.dyn.z * (0.4 + wf.dyn.y);");
+        this.emit("  var h = 0.0; var dhdx = 0.0; var dhdy = 0.0;");
+        this.emit("  var dx = 0.0; var dy = 0.0; var k = 0.0; var spd = 0.0; var a = 0.0;");
+        this.emit("  for (var i = 0; i < 4; i = i + 1) {");
+        this.emit("    if (i == 0) { dx = 1.0; dy = 0.0; k = 0.7; spd = 0.6; a = 1.0; }");
+        this.emit("    else if (i == 1) { dx = 0.5; dy = 0.86; k = 1.2; spd = 0.9; a = 0.55; }");
+        this.emit("    else if (i == 2) { dx = -0.8; dy = 0.6; k = 1.9; spd = 1.15; a = 0.3; }");
+        this.emit("    else { dx = 0.2; dy = -0.98; k = 2.7; spd = 1.4; a = 0.18; }");
+        this.emit("    let d = normalize(vec2<f32>(dx, dy));");
+        this.emit("    let ph = k * dot(d, wp) + spd * t;");
+        this.emit("    h = h + a * amp * sin(ph);");
+        this.emit("    dhdx = dhdx + a * amp * k * d.x * cos(ph);");
+        this.emit("    dhdy = dhdy + a * amp * k * d.y * cos(ph);");
+        this.emit("  }");
+        this.emit("  var lp = in.pos; lp.z = lp.z + h / sz;");
+        this.emit("  let world = model.m * vec4<f32>(lp, 1.0);");
+        this.emit("  o.wPos = world.xyz;");
+        this.emit("  o.wNorm = normalize(vec3<f32>(-dhdx, -dhdy, 1.0));");
+        this.emit("  o.clip = cam.viewProj * world;");
+        this.emit("  return o;");
+        this.emit("}");
+        this.emit("fn hash21(p: vec2<f32>) -> f32 { let h = dot(p, vec2<f32>(127.1, 311.7)); return fract(sin(h) * 43758.5453); }");
+        this.emit("fn vnoise(p: vec2<f32>) -> f32 {");
+        this.emit("  let i = floor(p); let f = fract(p); let u = f * f * (3.0 - 2.0 * f);");
+        this.emit("  let a = hash21(i); let b = hash21(i + vec2<f32>(1.0, 0.0));");
+        this.emit("  let c = hash21(i + vec2<f32>(0.0, 1.0)); let dd = hash21(i + vec2<f32>(1.0, 1.0));");
+        this.emit("  return mix(mix(a, b, u.x), mix(c, dd, u.x), u.y);");
+        this.emit("}");
+        this.emit("struct FIn { @location(0) wNorm: vec3<f32>, @location(1) wPos: vec3<f32> };");
+        this.emit("@fragment fn fs_water(in: FIn) -> @location(0) vec4<f32> {");
+        this.emit("  let N = normalize(in.wNorm);");
+        this.emit("  let V = normalize(wf.tc.yzw - in.wPos);");
+        this.emit("  let L = normalize(ws.lightDir.xyz);");
+        this.emit("  let t = wf.tc.x;");
+        this.emit("  let ndv = max(dot(N, V), 0.0);");
+        this.emit("  let fres = 0.02 + 0.98 * pow(1.0 - ndv, 5.0);");
+        this.emit("  let tilt = clamp(1.0 - ndv, 0.0, 1.0);");
+        this.emit("  var col = mix(ws.deep.rgb, ws.shallow.rgb, clamp(tilt * 1.3, 0.0, 1.0));");
+        this.emit("  let p = in.wPos.xy;");
+        this.emit("  let n1 = vnoise(p * 0.9 + vec2<f32>(t * 0.15, t * 0.08));");
+        this.emit("  let n2 = vnoise(p * 1.7 - vec2<f32>(t * 0.11, t * 0.19));");
+        this.emit("  let caustic = pow(n1 * n2, 3.0);");
+        this.emit("  col = col + vec3<f32>(0.10, 0.18, 0.20) * caustic * wf.dyn.x;");
+        this.emit("  let H = normalize(L + V);");
+        this.emit("  let spec = pow(max(dot(N, H), 0.0), 200.0);");
+        this.emit("  col = col + vec3<f32>(0.85, 0.92, 1.0) * spec;");
+        this.emit("  let sky = vec3<f32>(0.10, 0.26, 0.36);");
+        this.emit("  col = mix(col, sky, fres * 0.3);");
+        this.emit("  return vec4<f32>(col, 1.0);");
+        this.emit("}`;");
+        this.emit("");
+      }
+      /** Tool-affordance names declared on an object's @tool traits (both trait
+       *  config formats), for the scene manifest — the artifact-level answer to
+       *  "which named actions does this entity offer" that the numeric registry
+       *  cannot express. */
+      extractAffordanceNames(obj) {
+        const names = [];
+        for (const trait of obj.traits ?? []) {
+          const t = trait;
+          if (t.name !== "tool") continue;
+          const config = "config" in t && typeof t.config === "object" && t.config !== null ? t.config : t;
+          if (typeof config["name"] === "string" && config["name"] !== "tool") {
+            names.push(config["name"]);
+          } else {
+            names.push("unnamed_tool");
+          }
+        }
+        return names;
+      }
+      /**
+       * HoloScene Manifest — a machine-readable world-facts block INSIDE the
+       * delivered artifact (g9tk). Collected at EMISSION time (each emitObject/
+       * emitMeshObject records what it actually emitted), so the manifest describes
+       * the artifact, not the input. Strict JSON payload: independent consumers
+       * (perceiver derivations, tooling) JSON.parse it instead of regexing the
+       * imperative holoGraphObjects push literals.
+       */
+      emitSceneManifest(composition) {
+        const manifest = {
+          version: "holo-scene-manifest-v1",
+          source: String(composition.name ?? ""),
+          objects: this.manifestObjects
+        };
+        this.emit("// === HoloScene Manifest (machine-readable world facts; part of the delivered artifact) ===");
+        this.emit(`const holoSceneManifest = ${this.json(manifest)};`);
+        this.emit('if (typeof globalThis !== "undefined") { globalThis.holoSceneManifest = holoSceneManifest; }');
+        this.emit("");
+      }
+      emitMeshObject(v, obj, meshType) {
+        this.emit(`const ${v}Vertices = ${this.geometryVertexDataFn(meshType)};`);
+        this.emit(`const ${v}VBO = createBuffer(device, ${v}Vertices, GPUBufferUsage.VERTEX);`);
+        this.emit(`const ${v}VertexCount = ${v}Vertices.length / 6;`);
+        const pos = this.findObjProp(obj, "position");
+        const scale = this.findObjProp(obj, "scale") || this.findObjProp(obj, "size");
+        const [px, py, pz] = Array.isArray(pos) ? pos : [0, 0, 0];
+        const [sx, sy, sz] = Array.isArray(scale) ? scale : typeof scale === "number" ? [scale, scale, scale] : [1, 1, 1];
+        this.emit(
+          `const ${v}Model = createBuffer(device, new Float32Array([${sx},0,0,0, 0,${sy},0,0, 0,0,${sz},0, ${px},${py},${pz},1]), GPUBufferUsage.UNIFORM);`
+        );
+        const material = this.findObjProp(obj, "material");
+        const color = this.findObjProp(obj, "color");
+        const [cr, cg, cb] = this.extractMaterialColor(material, color);
+        const rough = this.extractMaterialProp(material, "roughness", 0.5);
+        const metal = this.extractMaterialProp(material, "metalness", 0);
+        let [er, eg, eb] = this.extractEmissive(material, obj);
+        let emissiveStrength = this.extractMaterialProp(material, "emissive_intensity", 1);
+        const glow = this.materialGlow(material);
+        if (glow > 0 && er === 0 && eg === 0 && eb === 0) {
+          er = cr;
+          eg = cg;
+          eb = cb;
+          emissiveStrength = glow;
+        }
+        this.emit(
+          `const ${v}Mat = createBuffer(device, new Float32Array([${cr},${cg},${cb},1.0, ${rough},${metal},${emissiveStrength},0, ${er},${eg},${eb},0]), GPUBufferUsage.UNIFORM);`
+        );
+        this.emit(
+          `holoGraphObjects.push({ id: "${this.escapeStringValue(obj.name, "TypeScript")}", name: "${this.escapeStringValue(obj.name, "TypeScript")}", geometry: "${this.escapeStringValue(meshType, "TypeScript")}", traits: ${this.json((obj.traits || []).map((t) => t.name))}, properties: ${this.json(this.extractObjectProperties(obj))}, basePosition: [${px},${py},${pz}], position: [${px},${py},${pz}], baseScale: [${sx},${sy},${sz}], scale: [${sx},${sy},${sz}], baseColor: [${cr},${cg},${cb}], color: [${cr},${cg},${cb}], material: { roughness: ${rough}, metalness: ${metal}, emissiveStrength: ${emissiveStrength}, emissive: [${er},${eg},${eb}] }, modelBuffer: ${v}Model, matBuffer: ${v}Mat, visible: true });`
+        );
+        this.manifestObjects.push({
+          id: String(obj.name ?? ""),
+          geometry: meshType,
+          visible: true,
+          traits: (obj.traits || []).map((t) => t.name),
+          affordances: this.extractAffordanceNames(obj),
+          position: [
+            px + this.manifestGroupOffset[0],
+            py + this.manifestGroupOffset[1],
+            pz + this.manifestGroupOffset[2]
+          ],
+          scale: [sx, sy, sz],
+          color: [cr, cg, cb]
+        });
+        this.emit(`const ${v}Pipeline = device.createRenderPipeline({`);
+        this.indent();
+        this.emit('layout: "auto",');
+        this.emit(
+          'vertex: { module: device.createShaderModule({ code: WGSL_VERTEX }), entryPoint: "vs_main",'
+        );
+        this.emit(
+          '  buffers: [{ arrayStride: 24, attributes: [{ shaderLocation: 0, offset: 0, format: "float32x3" }, { shaderLocation: 1, offset: 12, format: "float32x3" }] }] },'
+        );
+        this.emit(
+          'fragment: { module: device.createShaderModule({ code: WGSL_FRAGMENT }), entryPoint: "fs_main", targets: [{ format }] },'
+        );
+        this.emit('primitive: { topology: "triangle-list", cullMode: "back" },');
+        this.emit(
+          `depthStencil: { format: "depth24plus", depthWriteEnabled: true, depthCompare: "less" }, multisample: { count: MSAA_COUNT },`
+        );
+        this.dedent();
+        this.emit("});");
+        this.emit(
+          `const ${v}Bind = device.createBindGroup({ layout: ${v}Pipeline.getBindGroupLayout(0), entries: [`
+        );
+        this.emit(
+          `  { binding: 0, resource: { buffer: ${v}Model } }, { binding: 1, resource: { buffer: ${v}Mat } }, { binding: 2, resource: { buffer: vpUniform } }, { binding: 3, resource: { buffer: sceneLights } }] });`
+        );
+      }
+      emitGaussianSplatObject(v, obj) {
+        const trait = obj.traits?.find((t) => t.name === "gaussian_splat");
+        const src = trait?.config?.src || "scene.ply";
+        const max = trait?.config?.max_splats || 5e5;
+        const sorted = trait?.config?.sorted !== false;
+        this.emit(`// Gaussian Splat \u2014 source: ${src} (${sorted ? "radix-sorted" : "unsorted"})`);
+        if (sorted) {
+          this.emit(
+            `// === Wait-Free Radix Sort Pipeline (4x 8-bit Blelloch scan, no global atomics) ===`
+          );
+          this.emit(`import { GaussianSplatSorter } from '@holoscript/core/gpu/GaussianSplatSorter';`);
+          this.emit(`const ${v}Sorter = new GaussianSplatSorter(device, {`);
+          this.indent();
+          this.emit(`maxSplats: ${max},`);
+          this.emit(`canvasWidth: canvas.width,`);
+          this.emit(`canvasHeight: canvas.height,`);
+          this.dedent();
+          this.emit(`});`);
+          this.emit(`await ${v}Sorter.initialize();`);
+          this.emit(`const ${v}SplatCount = { value: 0 };`);
+        } else {
+          this.emit(`const ${v}SplatBuf = createStorageBuffer(device, ${max} * 32);`);
+          this.emit(`const ${v}SplatCount = { value: 0 };`);
+          this.emit(`const ${v}SplatPipeline = device.createRenderPipeline({`);
+          this.indent();
+          this.emit('layout: "auto",');
+          this.emit(
+            'vertex: { module: device.createShaderModule({ code: WGSL_SPLAT }), entryPoint: "vs_splat", buffers: [] },'
+          );
+          this.emit(
+            'fragment: { module: device.createShaderModule({ code: WGSL_SPLAT }), entryPoint: "fs_splat",'
+          );
+          this.emit(
+            '  targets: [{ format, blend: { color: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" }, alpha: { srcFactor: "one", dstFactor: "one-minus-src-alpha", operation: "add" } } }] },'
+          );
+          this.emit('primitive: { topology: "triangle-strip" },');
+          this.emit(
+            'depthStencil: { format: "depth24plus", depthWriteEnabled: false, depthCompare: "less" },'
+          );
+          this.dedent();
+          this.emit("});");
+        }
+      }
+      emitPointCloudObject(v, obj) {
+        const trait = obj.traits?.find((t) => t.name === "point_cloud");
+        const max = trait?.config?.max_points || 1e5;
+        this.emit(`// Point Cloud (${max} max points)`);
+        this.emit(`const ${v}PointBuf = createStorageBuffer(device, ${max} * 16);`);
+        this.emit(`const ${v}PointCount = { value: 0 };`);
+        this.emit(`const ${v}PointPipeline = device.createRenderPipeline({`);
+        this.indent();
+        this.emit('layout: "auto",');
+        this.emit(
+          'vertex: { module: device.createShaderModule({ code: WGSL_POINT }), entryPoint: "vs_point",'
+        );
+        this.emit(
+          '  buffers: [{ arrayStride: 16, attributes: [{ shaderLocation: 0, offset: 0, format: "float32x3" }, { shaderLocation: 1, offset: 12, format: "unorm8x4" }] }] },'
+        );
+        this.emit(
+          'fragment: { module: device.createShaderModule({ code: WGSL_POINT }), entryPoint: "fs_point", targets: [{ format }] },'
+        );
+        this.emit(
+          `primitive: { topology: "point-list" }, depthStencil: { format: "depth24plus", depthWriteEnabled: true, depthCompare: "less" }, multisample: { count: MSAA_COUNT },`
+        );
+        this.dedent();
+        this.emit("});");
+      }
+      emitGpuParticleObject(v, obj) {
+        const trait = findGpuParticleTrait(obj.traits);
+        const count = trait?.config?.count || 1e4;
+        this.emit(`// GPU Particles (${count}) from @${trait?.name ?? "gpu_particle"}`);
+        this.emit(`const ${v}ParticleCount = ${count};`);
+        this.emit(`const ${v}ParticleBufA = createStorageBuffer(device, ${v}ParticleCount * 32);`);
+        this.emit(`const ${v}ParticleBufB = createStorageBuffer(device, ${v}ParticleCount * 32);`);
+        this.emit(`const ${v}ParticlePipeline = device.createRenderPipeline({`);
+        this.indent();
+        this.emit('layout: "auto",');
+        this.emit(
+          'vertex: { module: device.createShaderModule({ code: WGSL_PARTICLE_RENDER }), entryPoint: "vs_particle",'
+        );
+        this.emit(
+          '  buffers: [{ arrayStride: 32, attributes: [{ shaderLocation: 0, offset: 0, format: "float32x3" }, { shaderLocation: 1, offset: 12, format: "float32x3" }, { shaderLocation: 2, offset: 24, format: "float32" }] }] },'
+        );
+        this.emit(
+          'fragment: { module: device.createShaderModule({ code: WGSL_PARTICLE_RENDER }), entryPoint: "fs_particle",'
+        );
+        this.emit(
+          '  targets: [{ format, blend: { color: { srcFactor: "src-alpha", dstFactor: "one", operation: "add" }, alpha: { srcFactor: "zero", dstFactor: "one", operation: "add" } } }] },'
+        );
+        this.emit(
+          'primitive: { topology: "point-list" }, depthStencil: { format: "depth24plus", depthWriteEnabled: false, depthCompare: "less" },'
+        );
+        this.dedent();
+        this.emit("});");
+      }
+      // ─── Spatial Group ────────────────────────────────────────────────────────
+      emitGroup(group) {
+        const v = this.sanitizeName(group.name);
+        this.emit(`// Spatial Group: ${this.escapeStringValue(group.name, "TypeScript")}`);
+        const pos = group.properties.find((p) => p.key === "position")?.value;
+        const [px, py, pz] = Array.isArray(pos) ? pos : [0, 0, 0];
+        this.emit(
+          `const ${v}GroupXform = createBuffer(device, new Float32Array([1,0,0,0, 0,1,0,0, 0,0,1,0, ${px},${py},${pz},1]), GPUBufferUsage.UNIFORM);`
+        );
+        const saved = this.manifestGroupOffset;
+        this.manifestGroupOffset = [saved[0] + px, saved[1] + py, saved[2] + pz];
+        for (const obj of group.objects) this.emitObject(obj);
+        if (group.groups) {
+          for (const sub of group.groups) this.emitGroup(sub);
+        }
+        this.manifestGroupOffset = saved;
+        this.emit("");
+      }
+      // ─── Light ────────────────────────────────────────────────────────────────
+      // Aggregate the scene's declared lights into ONE shared uniform buffer that every
+      // mesh binds (binding 3). Shape math — color*intensity, type tag, world position,
+      // travel direction — is resolved here; the fragment shader consumes up to
+      // MAX_LIGHTS. A light-less scene gets a synthesized key light so it stays lit.
+      emitSceneLights(composition) {
+        const MAX_LIGHTS = 4;
+        const typeIndex = {
+          directional: 0,
+          point: 1,
+          spot: 2,
+          hemisphere: 3,
+          ambient: 4,
+          area: 5
+        };
+        const lights = (composition.lights ?? []).slice(0, MAX_LIGHTS).map((light) => {
+          let color = [1, 1, 1], intensity = 1, pos = [0, 10, 0], dir = [0, -1, 0], hasDir = false;
+          for (const prop of light.properties) {
+            if (prop.key === "color") color = this.parseColor(prop.value);
+            else if (prop.key === "intensity") intensity = prop.value;
+            else if (prop.key === "position" && Array.isArray(prop.value)) pos = prop.value;
+            else if (prop.key === "direction" && Array.isArray(prop.value)) {
+              dir = prop.value;
+              hasDir = true;
+            }
+          }
+          const ti = typeIndex[light.lightType] ?? 0;
+          if (ti === 0 && !hasDir && Array.isArray(pos)) dir = [-pos[0], -pos[1], -pos[2]];
+          return { name: String(light.name ?? ""), kind: String(light.lightType ?? ""), color, intensity, pos, dir, ti };
+        });
+        if (lights.length === 0) {
+          lights.push({ name: "(synthesized key light)", kind: "directional", color: [1, 1, 1], intensity: 1, pos: [1, 2, 1.5], dir: [-1, -2, -1.5], ti: 0 });
+        }
+        const segs = [`${lights.length},0,0,0`];
+        for (let i = 0; i < MAX_LIGHTS; i++) {
+          const l = lights[i];
+          if (l) {
+            segs.push(`${l.color[0] * l.intensity},${l.color[1] * l.intensity},${l.color[2] * l.intensity},${l.ti}`);
+            segs.push(`${l.pos[0]},${l.pos[1]},${l.pos[2]},0`);
+            segs.push(`${l.dir[0]},${l.dir[1]},${l.dir[2]},0`);
+          } else {
+            segs.push("0,0,0,0", "0,0,0,0", "0,0,0,0");
+          }
+        }
+        this.emit("// === Scene Lights (shared uniform, bound by every mesh at binding 3) ===");
+        for (let i = 0; i < lights.length; i++) {
+          const safeName = lights[i].name.replace(/[\r\n*]+/g, " ");
+          this.emit(`// Light[${i}]: "${safeName}" (${lights[i].kind}, intensity ${lights[i].intensity})`);
+        }
+        this.emit(
+          `const sceneLights = createBuffer(device, new Float32Array([${segs.join(", ")}]), GPUBufferUsage.UNIFORM);`
+        );
+        this.emit("");
+      }
+      // ─── Camera ───────────────────────────────────────────────────────────────
+      // Compute a bounding sphere (center + radius) over every object's world position,
+      // including spatial-group offsets and per-object scale. Used to auto-frame the
+      // camera when the author declared no explicit position. Returns null for an
+      // object-less scene (nothing to frame → keep the neutral default).
+      sceneBoundsForCamera(composition) {
+        const pts = [];
+        const R_CAP = 3;
+        const addObj = (obj, offset) => {
+          const pos = this.findObjProp(obj, "position");
+          const scale = this.findObjProp(obj, "scale") || this.findObjProp(obj, "size");
+          const [px, py, pz] = Array.isArray(pos) ? pos : [0, 0, 0];
+          const rawR = Array.isArray(scale) ? Math.max(...scale.map((n) => Math.abs(n))) : typeof scale === "number" ? Math.abs(scale) : 1;
+          pts.push({ p: [px + offset[0], py + offset[1], pz + offset[2]], r: Math.min(rawR, R_CAP) });
+        };
+        for (const obj of composition.objects ?? []) addObj(obj, [0, 0, 0]);
+        const walkGroup = (g, parent) => {
+          const gp = g.properties?.find((p) => p.key === "position")?.value;
+          const [gx, gy, gz] = Array.isArray(gp) ? gp : [0, 0, 0];
+          const off = [parent[0] + gx, parent[1] + gy, parent[2] + gz];
+          for (const obj of g.objects ?? []) addObj(obj, off);
+          for (const sub of g.groups ?? []) walkGroup(sub, off);
+        };
+        for (const g of composition.spatialGroups ?? []) walkGroup(g, [0, 0, 0]);
+        if (pts.length === 0) return null;
+        const min = [Infinity, Infinity, Infinity];
+        const max = [-Infinity, -Infinity, -Infinity];
+        for (const { p, r } of pts) {
+          for (let i = 0; i < 3; i++) {
+            min[i] = Math.min(min[i], p[i] - r);
+            max[i] = Math.max(max[i], p[i] + r);
+          }
+        }
+        const center = [(min[0] + max[0]) / 2, (min[1] + max[1]) / 2, (min[2] + max[2]) / 2];
+        let radius = 0;
+        for (const { p, r } of pts) {
+          radius = Math.max(radius, Math.hypot(p[0] - center[0], p[1] - center[1], p[2] - center[2]) + r);
+        }
+        return { center, radius: radius || 1 };
+      }
+      emitCamera(composition) {
+        const cam = composition.camera;
+        this.emit("// === Camera ===");
+        let fov = 60, near = 0.1, far = 1e3, pos = [4, 3, 6], lookAt = [0, 0, 0], hasPos = false;
+        for (const prop of cam?.properties ?? []) {
+          if (prop.key === "fov" || prop.key === "field_of_view") fov = prop.value;
+          else if (prop.key === "near") near = prop.value;
+          else if (prop.key === "far") far = prop.value;
+          else if (prop.key === "position" && Array.isArray(prop.value)) {
+            pos = prop.value;
+            hasPos = true;
+          } else if ((prop.key === "look_at" || prop.key === "lookAt") && Array.isArray(prop.value))
+            lookAt = prop.value;
+        }
+        if (!hasPos) {
+          const b = this.sceneBoundsForCamera(composition);
+          if (b) {
+            const r4 = (n) => Number(n.toFixed(4));
+            const fovRad = fov * Math.PI / 180;
+            const dist = b.radius / Math.sin(fovRad / 2) * 1.1;
+            const dl = Math.hypot(0.35, 0.45, 1);
+            const dir = [0.35 / dl, 0.45 / dl, 1 / dl];
+            pos = [
+              r4(b.center[0] + dir[0] * dist),
+              r4(b.center[1] + dir[1] * dist),
+              r4(b.center[2] + dir[2] * dist)
+            ];
+            lookAt = [r4(b.center[0]), r4(b.center[1]), r4(b.center[2])];
+            far = Math.max(far, r4(dist + b.radius * 2 + 10));
+          }
+        }
+        this.emit(`const cameraFov = ${fov} * Math.PI / 180;`);
+        this.emit(`const cameraNear = ${near}, cameraFar = ${far};`);
+        this.emit(`const cameraPos = new Float32Array([${pos.join(",")}]);`);
+        this.emit(`const cameraTarget = new Float32Array([${lookAt.join(",")}]);`);
+        this.emit("const cameraUp = new Float32Array([0, 1, 0]);");
+        this.emit("const aspect = (canvas.width || 1) / (canvas.height || 1);");
+        this.emit("function mat4Multiply(a: Float32Array, b: Float32Array): Float32Array {");
+        this.indent();
+        this.emit("const o = new Float32Array(16);");
+        this.emit("for (let c = 0; c < 4; c++) { for (let r = 0; r < 4; r++) {");
+        this.emit("  o[c*4+r] = a[0*4+r]*b[c*4+0] + a[1*4+r]*b[c*4+1] + a[2*4+r]*b[c*4+2] + a[3*4+r]*b[c*4+3];");
+        this.emit("} } return o;");
+        this.dedent();
+        this.emit("}");
+        this.emit("function lookAtMatrix(eye: Float32Array, target: Float32Array, up: Float32Array): Float32Array {");
+        this.indent();
+        this.emit("const zx = eye[0]-target[0], zy = eye[1]-target[1], zz = eye[2]-target[2];");
+        this.emit("let zl = Math.hypot(zx, zy, zz) || 1; const fz = [zx/zl, zy/zl, zz/zl];");
+        this.emit("const xx = up[1]*fz[2]-up[2]*fz[1], xy = up[2]*fz[0]-up[0]*fz[2], xz = up[0]*fz[1]-up[1]*fz[0];");
+        this.emit("let xl = Math.hypot(xx, xy, xz) || 1; const rx = [xx/xl, xy/xl, xz/xl];");
+        this.emit("const uy = [fz[1]*rx[2]-fz[2]*rx[1], fz[2]*rx[0]-fz[0]*rx[2], fz[0]*rx[1]-fz[1]*rx[0]];");
+        this.emit("return new Float32Array([");
+        this.emit("  rx[0], uy[0], fz[0], 0,");
+        this.emit("  rx[1], uy[1], fz[1], 0,");
+        this.emit("  rx[2], uy[2], fz[2], 0,");
+        this.emit("  -(rx[0]*eye[0]+rx[1]*eye[1]+rx[2]*eye[2]),");
+        this.emit("  -(uy[0]*eye[0]+uy[1]*eye[1]+uy[2]*eye[2]),");
+        this.emit("  -(fz[0]*eye[0]+fz[1]*eye[1]+fz[2]*eye[2]), 1]);");
+        this.dedent();
+        this.emit("}");
+        this.emit("function buildViewProjection(): Float32Array {");
+        this.indent();
+        this.emit("const f = 1.0 / Math.tan(cameraFov / 2), ri = 1.0 / (cameraNear - cameraFar);");
+        this.emit("const proj = new Float32Array([f/aspect,0,0,0, 0,f,0,0, 0,0,cameraFar*ri,-1, 0,0,cameraNear*cameraFar*ri,0]);");
+        this.emit("const view = lookAtMatrix(cameraPos, cameraTarget, cameraUp);");
+        this.emit("return mat4Multiply(proj, view);");
+        this.dedent();
+        this.emit("}");
+        this.emit(
+          "const vpUniform = createBuffer(device, buildViewProjection(), GPUBufferUsage.UNIFORM);"
+        );
+        this.emit("");
+      }
+      // ─── Compute Pipelines ────────────────────────────────────────────────────
+      emitComputeShaders(composition) {
+        const gpuObjs = (composition.objects || []).filter(
+          (o) => o.traits?.some(
+            (t) => isGpuParticleTraitName(t.name) || t.name === "gpu_physics" || t.name === "compute"
+          )
+        );
+        if (gpuObjs.length === 0) return;
+        this.emit("// === Compute Pipelines ===");
+        for (const obj of gpuObjs) {
+          const v = this.sanitizeName(obj.name);
+          const traits = obj.traits || [];
+          if (traits.some((t) => isGpuParticleTraitName(t.name))) {
+            const count = findGpuParticleTrait(traits)?.config?.count || 1e4;
+            this.emit(
+              `const ${v}ParticleCompute = device.createComputePipeline({ layout: "auto", compute: { module: device.createShaderModule({ code: WGSL_PARTICLE_COMPUTE }), entryPoint: "cs_particle_update" } });`
+            );
+            this.emit(`const ${v}ComputeDispatches = ${Math.ceil(count / 64)};`);
+          }
+          if (traits.some((t) => t.name === "gpu_physics")) {
+            this.emit(
+              `const ${v}PhysicsCompute = device.createComputePipeline({ layout: "auto", compute: { module: device.createShaderModule({ code: WGSL_PHYSICS_COMPUTE }), entryPoint: "cs_physics_step" } });`
+            );
+          }
+          if (traits.some((t) => t.name === "compute")) {
+            const ct = traits.find((t) => t.name === "compute");
+            const entry = ct?.config?.shader || "custom_compute";
+            const wg = ct?.config?.workgroups || [64, 1, 1];
+            this.emit(
+              `const ${v}CustomCompute = device.createComputePipeline({ layout: "auto", compute: { module: device.createShaderModule({ code: WGSL_CUSTOM_${v.toUpperCase()} }), entryPoint: "${entry}" } });`
+            );
+            this.emit(`const ${v}Workgroups = [${wg}];`);
+          }
+        }
+        this.emit("");
+      }
+      // ─── WGSL Shader Sources ──────────────────────────────────────────────────
+      emitShaderSources() {
+        this.emit("// === WGSL Shader Sources ===");
+        this.emit("const WGSL_VERTEX = /* wgsl */`");
+        this.emit("struct Uniforms { model: mat4x4<f32> };");
+        this.emit("struct Camera { viewProj: mat4x4<f32> };");
+        this.emit("@group(0) @binding(0) var<uniform> u: Uniforms;");
+        this.emit("@group(0) @binding(2) var<uniform> cam: Camera;");
+        this.emit("struct VIn { @location(0) pos: vec3<f32>, @location(1) norm: vec3<f32> };");
+        this.emit(
+          "struct VOut { @builtin(position) clip: vec4<f32>, @location(0) wNorm: vec3<f32>, @location(1) wPos: vec3<f32> };"
+        );
+        this.emit("@vertex fn vs_main(i: VIn) -> VOut {");
+        this.emit("  var o: VOut; let w = u.model * vec4<f32>(i.pos, 1.0);");
+        this.emit(
+          "  o.clip = cam.viewProj * w; o.wNorm = normalize((u.model * vec4<f32>(i.norm, 0.0)).xyz); o.wPos = w.xyz; return o; }`;"
+        );
+        this.emit("");
+        this.emit("const WGSL_FRAGMENT = /* wgsl */`");
+        this.emit("struct Mat { color: vec4<f32>, rm: vec4<f32>, emissive: vec4<f32> };");
+        this.emit("struct Light { ct: vec4<f32>, posW: vec4<f32>, dirW: vec4<f32> };");
+        this.emit("struct Lights { count: vec4<f32>, items: array<Light, 4> };");
+        this.emit("@group(0) @binding(1) var<uniform> mat: Mat;");
+        this.emit("@group(0) @binding(3) var<uniform> lights: Lights;");
+        this.emit("struct FIn { @location(0) wNorm: vec3<f32>, @location(1) wPos: vec3<f32> };");
+        this.emit("@fragment fn fs_main(i: FIn) -> @location(0) vec4<f32> {");
+        this.emit("  let N = normalize(i.wNorm);");
+        this.emit("  var acc = vec3<f32>(0.0, 0.0, 0.0);");
+        this.emit("  let n = i32(lights.count.x);");
+        this.emit("  for (var k = 0; k < n; k = k + 1) {");
+        this.emit("    let lt = lights.items[k];");
+        this.emit("    var L = normalize(-lt.dirW.xyz);");
+        this.emit("    if (lt.ct.w > 0.5) { L = normalize(lt.posW.xyz - i.wPos); }");
+        this.emit("    let d = max(dot(N, L), 0.0) * (1.0 - mat.rm[0] * 0.5);");
+        this.emit("    acc = acc + lt.ct.rgb * d;");
+        this.emit("  }");
+        this.emit("  let lit = mat.color.rgb * (0.15 + acc);");
+        this.emit("  let emit = mat.emissive.rgb * mat.rm[2];");
+        this.emit("  return vec4<f32>(lit + emit, mat.color.a); }`;");
+        this.emit("");
+        if (this.hasWater) this.emitWaterShaderSource();
+        this.emit("const WGSL_SPLAT = /* wgsl */`");
+        this.emit(
+          "struct Splat { center: vec3<f32>, opacity: f32, cov: array<f32,6>, sh: vec3<f32> };"
+        );
+        this.emit("@group(0) @binding(0) var<storage, read> splats: array<Splat>;");
+        this.emit(
+          "struct SO { @builtin(position) p: vec4<f32>, @location(0) c: vec4<f32>, @location(1) uv: vec2<f32> };"
+        );
+        this.emit(
+          "@vertex fn vs_splat(@builtin(vertex_index) vi: u32, @builtin(instance_index) ii: u32) -> SO {"
+        );
+        this.emit("  var q = array<vec2<f32>,4>(vec2(-1,-1),vec2(1,-1),vec2(-1,1),vec2(1,1));");
+        this.emit(
+          "  var o: SO; let s = splats[ii]; o.p = vec4<f32>(s.center.xy + q[vi]*0.01, s.center[2], 1.0);"
+        );
+        this.emit("  o.c = vec4<f32>(s.sh, s.opacity); o.uv = q[vi]; return o; }");
+        this.emit("@fragment fn fs_splat(i: SO) -> @location(0) vec4<f32> {");
+        this.emit("  let a = i.c.a * exp(-dot(i.uv, i.uv) * 4.0); if (a < 0.01) { discard; }");
+        this.emit("  return vec4<f32>(i.c.rgb * a, a); }`;");
+        this.emit("");
+        this.emit("const WGSL_POINT = /* wgsl */`");
+        this.emit("struct PO { @builtin(position) p: vec4<f32>, @location(0) c: vec4<f32> };");
+        this.emit(
+          "@vertex fn vs_point(@location(0) pos: vec3<f32>, @location(1) col: vec4<f32>) -> PO { var o: PO; o.p = vec4<f32>(pos, 1.0); o.c = col; return o; }"
+        );
+        this.emit("@fragment fn fs_point(i: PO) -> @location(0) vec4<f32> { return i.c; }`;");
+        this.emit("");
+        this.emit("const WGSL_PARTICLE_RENDER = /* wgsl */`");
+        this.emit("struct PVO { @builtin(position) p: vec4<f32>, @location(0) life: f32 };");
+        this.emit(
+          "@vertex fn vs_particle(@location(0) pos: vec3<f32>, @location(1) vel: vec3<f32>, @location(2) life: f32) -> PVO { var o: PVO; o.p = vec4<f32>(pos, 1.0); o.life = life; return o; }"
+        );
+        this.emit("@fragment fn fs_particle(i: PVO) -> @location(0) vec4<f32> {");
+        this.emit(
+          "  let t = clamp(i.life, 0.0, 1.0); return vec4<f32>(mix(vec3(1.0,0.2,0.0), vec3(1.0,1.0,0.5), t), t*0.8); }`;"
+        );
+        this.emit("");
+        this.emit("const WGSL_SCATTER = /* wgsl */`");
+        this.emit("struct VIn { @location(0) pos: vec3<f32>, @location(1) norm: vec3<f32> };");
+        this.emit("struct VOut { @builtin(position) clip: vec4<f32>, @location(0) shade: f32 };");
+        this.emit("fn hash11(v: f32) -> f32 { return fract(sin(v * 12.9898) * 43758.5453); }");
+        this.emit("@vertex fn vs_scatter(i: VIn, @builtin(instance_index) instance: u32) -> VOut {");
+        this.emit("  let id = f32(instance);");
+        this.emit("  let x = hash11(id + 1.0) * 1.8 - 0.9; let z = hash11(id + 7.0) * 1.8 - 0.9;");
+        this.emit("  let scale = 0.35 + hash11(id + 13.0) * 0.45;");
+        this.emit("  var o: VOut; o.clip = vec4<f32>(i.pos.x * scale + x, i.pos.y * scale - 0.65, i.pos.z * scale + z, 1.0);");
+        this.emit("  o.shade = 0.45 + max(i.norm.y, 0.0) * 0.45; return o; }");
+        this.emit("@fragment fn fs_scatter(i: VOut) -> @location(0) vec4<f32> { return vec4<f32>(0.08 * i.shade, 0.34 * i.shade, 0.12 * i.shade, 1.0); }`;");
+        this.emit("");
+        this.emit("const WGSL_POSTFX = /* wgsl */`");
+        this.emit("struct VO { @builtin(position) pos: vec4<f32> };");
+        this.emit("@vertex fn vs_postfx(@builtin(vertex_index) vi: u32) -> VO {");
+        this.emit("  var p = array<vec2<f32>,3>(vec2(-1.0,-1.0), vec2(3.0,-1.0), vec2(-1.0,3.0));");
+        this.emit("  var o: VO; o.pos = vec4<f32>(p[vi], 0.0, 1.0); return o; }");
+        this.emit("@fragment fn fs_postfx() -> @location(0) vec4<f32> { return vec4<f32>(0.04, 0.08, 0.05, 0.18); }`;");
+        this.emit("");
+        this.emit("const WGSL_PARTICLE_COMPUTE = /* wgsl */`");
+        this.emit("struct P { pos: vec3<f32>, _p0: f32, vel: vec3<f32>, life: f32 };");
+        this.emit("@group(0) @binding(0) var<storage, read> pin: array<P>;");
+        this.emit("@group(0) @binding(1) var<storage, read_write> pout: array<P>;");
+        this.emit("@group(0) @binding(2) var<uniform> dt: f32;");
+        this.emit(
+          "@compute @workgroup_size(64) fn cs_particle_update(@builtin(global_invocation_id) gid: vec3<u32>) {"
+        );
+        this.emit("  let i = gid[0]; if (i >= arrayLength(&pin)) { return; } var p = pin[i];");
+        this.emit("  p.vel[1] -= 9.81 * dt; p.pos += p.vel * dt; p.life -= dt;");
+        this.emit(
+          "  if (p.life <= 0.0) { p.pos = vec3(0.0); p.vel = vec3(0.0, 5.0, 0.0); p.life = 2.0; }"
+        );
+        this.emit("  pout[i] = p; }`;");
+        this.emit("");
+        this.emit("const WGSL_PHYSICS_COMPUTE = /* wgsl */`");
+        this.emit("struct Body { pos: vec3<f32>, mass: f32, vel: vec3<f32>, _p: f32 };");
+        this.emit("@group(0) @binding(0) var<storage, read_write> bodies: array<Body>;");
+        this.emit("@group(0) @binding(1) var<uniform> dt: f32;");
+        this.emit(
+          "@compute @workgroup_size(64) fn cs_physics_step(@builtin(global_invocation_id) gid: vec3<u32>) {"
+        );
+        this.emit("  let i = gid[0]; if (i >= arrayLength(&bodies)) { return; } var b = bodies[i];");
+        this.emit("  b.vel[1] -= 9.81 * dt; b.pos += b.vel * dt;");
+        this.emit(
+          "  if (b.pos[1] < 0.0) { b.pos[1] = 0.0; b.vel[1] = -b.vel[1] * 0.6; } bodies[i] = b; }`;"
+        );
+        this.emit("");
+      }
+      // ─── Render Loop ──────────────────────────────────────────────────────────
+      emitViewportRuntime() {
+        this.emit("// === HoloGraph Viewport Runtime ===");
+        this.emit("const holoGraphInitialCameraPos = new Float32Array(cameraPos);");
+        this.emit("const holoGraphInitialCameraTarget = new Float32Array(cameraTarget);");
+        this.emit(
+          'const holoGraphViewportState = { actionCount: 0, lastAction: null, filter: "all", colorMode: "semantic", structureStyle: "flow", labelPolicy: "none", focusId: null };'
+        );
+        this.emit('document.body.style.position = document.body.style.position || "relative";');
+        this.emit('const holoGraphLabelLayer = document.createElement("div");');
+        this.emit('holoGraphLabelLayer.setAttribute("data-holograph-label-layer", "true");');
+        this.emit('Object.assign(holoGraphLabelLayer.style, { position: "absolute", inset: "0", pointerEvents: "none", overflow: "hidden", fontFamily: "ui-monospace, SFMono-Regular, Consolas, monospace", zIndex: "5" });');
+        this.emit('canvas.insertAdjacentElement("afterend", holoGraphLabelLayer);');
+        this.emit("function hsVec3(v) { return [Number(v[0] || 0), Number(v[1] || 0), Number(v[2] || 0)]; }");
+        this.emit("function hsSub(a, b) { return [a[0] - b[0], a[1] - b[1], a[2] - b[2]]; }");
+        this.emit("function hsAdd(a, b) { return [a[0] + b[0], a[1] + b[1], a[2] + b[2]]; }");
+        this.emit("function hsMul(v, s) { return [v[0] * s, v[1] * s, v[2] * s]; }");
+        this.emit("function hsLen(v) { return Math.hypot(v[0], v[1], v[2]) || 1; }");
+        this.emit("function hsNorm(v) { const l = hsLen(v); return [v[0] / l, v[1] / l, v[2] / l]; }");
+        this.emit(
+          "function hsCross(a, b) { return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]]; }"
+        );
+        this.emit(
+          'function hsHash(text) { let h = 2166136261; const s = String(text || ""); for (let i = 0; i < s.length; i++) { h ^= s.charCodeAt(i); h = Math.imul(h, 16777619); } return h >>> 0; }'
+        );
+        this.emit(
+          "function hsHueRgb(h) { const x = (n) => { const k = (n + h * 6) % 6; return Math.max(0, Math.min(1, Math.min(k, 4 - k, 1))); }; return [x(5), x(3), x(1)]; }"
+        );
+        this.emit(
+          "function hsGraphCenter() { if (!holoGraphObjects.length) return [0, 0, 0]; const sum = holoGraphObjects.reduce((acc, o) => [acc[0] + o.basePosition[0], acc[1] + o.basePosition[1], acc[2] + o.basePosition[2]], [0, 0, 0]); return hsMul(sum, 1 / holoGraphObjects.length); }"
+        );
+        this.emit(
+          "function hsWriteModel(o) { const s = o.visible ? o.scale : [0, 0, 0]; device.queue.writeBuffer(o.modelBuffer, 0, new Float32Array([s[0],0,0,0, 0,s[1],0,0, 0,0,s[2],0, o.position[0],o.position[1],o.position[2],1])); }"
+        );
+        this.emit(
+          "function hsWriteMaterial(o, color) { o.color = [color[0], color[1], color[2]]; const m = o.material; device.queue.writeBuffer(o.matBuffer, 0, new Float32Array([color[0],color[1],color[2],1.0, m.roughness,m.metalness,m.emissiveStrength,0, m.emissive[0],m.emissive[1],m.emissive[2],0])); }"
+        );
+        this.emit("function hsCameraDistance() { return hsLen(hsSub(hsVec3(cameraTarget), hsVec3(cameraPos))); }");
+        this.emit(
+          "function hsSetCamera(pos, target) { cameraPos.set(pos); cameraTarget.set(target); device.queue.writeBuffer(vpUniform, 0, buildViewProjection()); document.body.dataset.holoscriptWebgpuCamera = JSON.stringify({ position: Array.from(cameraPos), target: Array.from(cameraTarget) }); }"
+        );
+        this.emit(
+          "function hsCameraBasis() { const forward = hsNorm(hsSub(hsVec3(cameraTarget), hsVec3(cameraPos))); const worldUp = [0, 1, 0]; const right = hsNorm(hsCross(forward, worldUp)); const up = hsNorm(hsCross(right, forward)); return { forward, right, up }; }"
+        );
+        this.emit(
+          'function hsMatchesFilter(o, filter) { const rawKind = o.properties.symbolType || o.properties.symbol_type || o.properties.kind || o.properties.role || o.properties.type || ""; const symbolType = String(rawKind).toLowerCase(); const traits = (o.traits || []).map((t) => String(t).toLowerCase()); if (filter === "all") return true; if (filter === "call") return symbolType === "function" || symbolType === "method" || symbolType === "call" || traits.includes("function") || traits.includes("method") || traits.includes("call"); if (filter === "import") return symbolType === "module" || symbolType === "namespace" || symbolType === "package" || symbolType === "import" || traits.includes("module") || traits.includes("namespace") || traits.includes("package") || traits.includes("import"); return true; }'
+        );
+        this.emit(
+          'function hsColorForMode(o, mode) { if (mode === "identity_hue") return hsHueRgb((hsHash(o.id) % 10000) / 10000); if (mode === "file_hue") return hsHueRgb((hsHash(o.properties.file || o.properties.path || o.id) % 10000) / 10000); if (mode === "relation_hue") return hsHueRgb((hsHash(o.properties.symbolType || o.properties.symbol_type || o.properties.kind || o.properties.role || (o.traits || []).join(",")) % 10000) / 10000); return o.baseColor; }'
+        );
+        this.emit("function hsRound(n) { return Math.round(Number(n || 0) * 1000) / 1000; }");
+        this.emit("function hsRoundVec(v) { return [hsRound(v?.[0]), hsRound(v?.[1]), hsRound(v?.[2])]; }");
+        this.emit(
+          'function hsHueBucket(o, mode = holoGraphViewportState.colorMode) { if (mode === "identity_hue") return hsHash(o.id) % 10000; if (mode === "file_hue") return hsHash(o.properties.file || o.properties.path || o.id) % 10000; if (mode === "relation_hue") return hsHash(o.properties.symbolType || o.properties.symbol_type || o.properties.kind || o.properties.role || (o.traits || []).join(",")) % 10000; return hsHash(JSON.stringify(o.color || o.baseColor || [])) % 10000; }'
+        );
+        this.emit(
+          'function hsObjectRole(o) { return String(o.properties.symbolType || o.properties.symbol_type || o.properties.kind || o.properties.role || o.properties.type || (o.traits || [])[0] || "object"); }'
+        );
+        this.emit(
+          'function hsCounts(items, keyFn, limit = 12) { const m = new Map(); for (const item of items) { const key = String(keyFn(item) || "unknown"); m.set(key, (m.get(key) || 0) + 1); } return Array.from(m.entries()).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, limit).map(([key, count]) => ({ key, count })); }'
+        );
+        this.emit(
+          'function hsCompactObject(o, index) { return { index, id: o.id, name: o.name, geometry: o.geometry || "mesh", shape: o.geometry || "mesh", role: hsObjectRole(o), traits: o.traits || [], file: o.properties.file || null, path: o.properties.path || null, signature: o.properties.signature || null, language: o.properties.language || null, position: hsRoundVec(o.position), scale: hsRoundVec(o.scale), color: hsRoundVec(o.color || o.baseColor), hueBucket: hsHueBucket(o), visible: o.visible, projection: hsProjectPoint(o.position) }; }'
+        );
+        this.emit(
+          'function hsResolveObject(payload = {}) { const key = payload && (payload.nodeId ?? payload.id ?? payload.target ?? payload.anchorId ?? payload.name); let obj = null; if (typeof payload?.anchorIndex === "number") obj = holoGraphObjects[payload.anchorIndex] || null; if (!obj && typeof key === "number") obj = holoGraphObjects[key] || null; if (!obj && key !== undefined && key !== null) obj = holoGraphObjects.find((o) => o.id === String(key) || o.name === String(key)); if (!obj) obj = holoGraphObjects.find((o) => o.visible) || holoGraphObjects[0] || null; return obj; }'
+        );
+        this.emit(
+          "function hsNearestObjects(obj, limit = 8) { if (!obj) return []; return holoGraphObjects.filter((o) => o.visible && o !== obj).map((o) => ({ object: o, distance: hsLen(hsSub(o.position, obj.position)) })).sort((a, b) => a.distance - b.distance).slice(0, Math.max(0, Math.min(32, Number(limit) || 8))).map((entry) => ({ ...hsCompactObject(entry.object, holoGraphObjects.indexOf(entry.object)), distance: hsRound(entry.distance) })); }"
+        );
+        this.emit(
+          'function hsDescribeScene(payload = {}) { const limit = Math.max(1, Math.min(128, Number(payload.limit || 24))); const visible = holoGraphObjects.filter((o) => o.visible); return { canonicalNames: { graphSurface: "HoloGraph", embeddingTower: "HoloEmbed", visionNavigator: "HoloLlama" }, actionContract: ["pan_left","pan_right","pan_up","pan_down","zoom_in","zoom_out","zoom_to_fit","focus_anchor","focus_node","filter_call","filter_import","filter_all","set_color_mode","set_structure_style","set_label_policy","reset_view"], projectionBridge: "renderer-native", canvas: { width: canvas.width, height: canvas.height, clientWidth: canvas.clientWidth, clientHeight: canvas.clientHeight }, camera: { position: hsRoundVec(cameraPos), target: hsRoundVec(cameraTarget), distance: hsRound(hsCameraDistance()) }, actionCount: holoGraphViewportState.actionCount, lastAction: holoGraphViewportState.lastAction, filter: holoGraphViewportState.filter, colorMode: holoGraphViewportState.colorMode, structureStyle: holoGraphViewportState.structureStyle, labelPolicy: holoGraphViewportState.labelPolicy, objectCount: holoGraphObjects.length, visibleObjects: visible.length, shapes: hsCounts(visible, (o) => o.geometry || "mesh"), roles: hsCounts(visible, hsObjectRole), hueBuckets: hsCounts(visible, (o) => `hue_${hsHueBucket(o)}`, 16), files: hsCounts(visible, (o) => o.properties.file || o.properties.path || "unknown", 16), objects: visible.slice(0, limit).map((o) => hsCompactObject(o, holoGraphObjects.indexOf(o))) }; }'
+        );
+        this.emit(
+          "function hsProjectObject(payload = {}) { const obj = hsResolveObject(payload); if (!obj) return null; return { ...hsCompactObject(obj, holoGraphObjects.indexOf(obj)), cameraDistance: hsRound(hsLen(hsSub(hsVec3(cameraPos), obj.position))) }; }"
+        );
+        this.emit(
+          "function hsInspectObject(payload = {}) { const obj = hsResolveObject(payload); if (!obj) return null; return { ...hsProjectObject(payload), properties: obj.properties, neighbors: hsNearestObjects(obj, payload.limit || 8) }; }"
+        );
+        this.emit('function hsNormalizeLabelPolicy(value) { const policy = String(value || "none").toLowerCase(); return ["none","ids","signatures","details"].includes(policy) ? policy : "none"; }');
+        this.emit(
+          'function hsLabelText(o) { const policy = holoGraphViewportState.labelPolicy; if (policy === "none") return ""; if (policy === "ids") return o.id; if (policy === "signatures") return o.properties.signature || o.id; return `${hsObjectRole(o)}:${o.properties.signature || o.id}`; }'
+        );
+        this.emit(
+          'function hsProjectPoint(p) { const m = buildViewProjection(); const x = Number(p?.[0] || 0), y = Number(p?.[1] || 0), z = Number(p?.[2] || 0); const cx = m[0]*x + m[4]*y + m[8]*z + m[12]; const cy = m[1]*x + m[5]*y + m[9]*z + m[13]; const cz = m[2]*x + m[6]*y + m[10]*z + m[14]; const cw = m[3]*x + m[7]*y + m[11]*z + m[15]; const clip = { x: hsRound(cx), y: hsRound(cy), z: hsRound(cz), w: hsRound(cw) }; if (!Number.isFinite(cw) || Math.abs(cw) < 0.00001) return { source: "renderer-native", valid: false, reason: "invalid-w", inFrame: false, clip }; const ndcX = cx / cw, ndcY = cy / cw, ndcZ = cz / cw; const normalizedX = ndcX * 0.5 + 0.5; const normalizedY = 0.5 - ndcY * 0.5; const width = canvas.clientWidth || canvas.width || 1; const height = canvas.clientHeight || canvas.height || 1; const screenX = normalizedX * width; const screenY = normalizedY * height; const centerDistance = Math.hypot(normalizedX - 0.5, normalizedY - 0.5); return { source: "renderer-native", valid: Number.isFinite(normalizedX) && Number.isFinite(normalizedY), inFrame: ndcX >= -1 && ndcX <= 1 && ndcY >= -1 && ndcY <= 1, ndc: { x: hsRound(ndcX), y: hsRound(ndcY), z: hsRound(ndcZ) }, normalizedX: hsRound(normalizedX), normalizedY: hsRound(normalizedY), screenX: hsRound(screenX), screenY: hsRound(screenY), centerDistance: hsRound(centerDistance), clip }; }'
+        );
+        this.emit(
+          'function hsRenderLabels() { const policy = holoGraphViewportState.labelPolicy; document.body.dataset.holoscriptWebgpuLabels = policy; if (policy === "none") { holoGraphLabelLayer.replaceChildren(); return; } const ranked = holoGraphObjects.filter((o) => o.visible).map((o) => ({ object: o, distance: hsLen(hsSub(o.position, hsVec3(cameraTarget))) })).sort((a, b) => a.distance - b.distance).slice(0, 18); const nodes = []; for (const entry of ranked) { const o = entry.object; const text = hsLabelText(o); const point = hsProjectPoint(o.position); if (!text || !point?.valid || !point.inFrame) continue; const focus = entry.distance <= 0.001 || o.id === holoGraphViewportState.focusId; const el = document.createElement("div"); el.textContent = text.length > 72 ? `${text.slice(0, 69)}...` : text; Object.assign(el.style, { position: "absolute", left: `${point.screenX}px`, top: `${point.screenY}px`, transform: "translate(-50%, -120%)", maxWidth: "280px", padding: focus ? "4px 7px" : "3px 6px", border: focus ? "2px solid rgba(250,204,21,0.98)" : "1px solid rgba(255,255,255,0.68)", borderRadius: "3px", background: focus ? "rgba(15,23,42,0.94)" : "rgba(2,6,23,0.86)", color: focus ? "#fef9c3" : "#f8fafc", fontSize: focus ? "13px" : "12px", fontWeight: focus ? "700" : "600", lineHeight: "1.2", whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis", textShadow: "0 1px 2px #000" }); nodes.push(el); } const focusObj = holoGraphViewportState.focusId ? holoGraphObjects.find((o) => o.id === holoGraphViewportState.focusId && o.visible) : null; if (focusObj) { const panel = document.createElement("div"); Object.assign(panel.style, { position: "absolute", left: "12px", top: "12px", maxWidth: "560px", padding: "8px 10px", border: "2px solid rgba(250,204,21,0.98)", borderRadius: "4px", background: "rgba(15,23,42,0.96)", color: "#fef9c3", fontSize: "13px", fontWeight: "700", lineHeight: "1.35", textShadow: "0 1px 2px #000", boxShadow: "0 10px 30px rgba(0,0,0,0.34)" }); const near = holoGraphObjects.filter((o) => o.visible && o !== focusObj).map((o) => ({ object: o, distance: hsLen(hsSub(o.position, focusObj.position)) })).sort((a, b) => a.distance - b.distance).slice(0, 5); const rows = [{ kind: "target", object: focusObj }, ...near.map((entry) => ({ kind: "near", object: entry.object }))]; for (const row of rows) { const line = document.createElement("div"); const text = `${row.kind} ${hsLabelText(row.object)}`; line.textContent = text.length > 96 ? `${text.slice(0, 93)}...` : text; panel.appendChild(line); } nodes.push(panel); } holoGraphLabelLayer.replaceChildren(...nodes); }'
+        );
+        this.emit("function hsApplyLabelPolicy(policy) { holoGraphViewportState.labelPolicy = hsNormalizeLabelPolicy(policy); hsRenderLabels(); }");
+        this.emit("function hsApplyFilter(filter) { holoGraphViewportState.filter = filter; for (const o of holoGraphObjects) { o.visible = hsMatchesFilter(o, filter); hsWriteModel(o); } }");
+        this.emit("function hsApplyColorMode(mode) { holoGraphViewportState.colorMode = mode; for (const o of holoGraphObjects) hsWriteMaterial(o, hsColorForMode(o, mode)); }");
+        this.emit(
+          'function hsApplyStructureStyle(style) { const center = hsGraphCenter(); const n = Math.max(1, holoGraphObjects.length); const radius = Math.max(20, Math.sqrt(n) * 18); holoGraphViewportState.structureStyle = style; holoGraphObjects.forEach((o, i) => { if (style === "compact") { o.position = hsAdd(center, hsMul(hsSub(o.basePosition, center), 0.45)); } else if (style === "radial") { const a = (i / n) * Math.PI * 2; o.position = [center[0] + Math.cos(a) * radius, center[1] + (o.basePosition[1] - center[1]) * 0.18, center[2] + Math.sin(a) * radius]; } else { o.position = [...o.basePosition]; } hsWriteModel(o); }); }'
+        );
+        this.emit(
+          "function hsFocusObject(payload) { const obj = hsResolveObject(payload); if (!obj) return false; holoGraphViewportState.focusId = obj.id; const target = [...obj.position]; const away = hsNorm(hsSub(hsVec3(cameraPos), hsVec3(cameraTarget))); const distance = Math.max(8, hsCameraDistance() * 0.45); hsSetCamera(hsAdd(target, hsMul(away, distance)), target); return true; }"
+        );
+        this.emit(
+          'function hsViewportSnapshot() { const scene = hsDescribeScene({ limit: 8 }); return { camera: { position: Array.from(cameraPos), target: Array.from(cameraTarget), distance: hsCameraDistance() }, projectionBridge: "renderer-native", canvas: scene.canvas, actionCount: holoGraphViewportState.actionCount, lastAction: holoGraphViewportState.lastAction, filter: holoGraphViewportState.filter, colorMode: holoGraphViewportState.colorMode, structureStyle: holoGraphViewportState.structureStyle, labelPolicy: holoGraphViewportState.labelPolicy, focusId: holoGraphViewportState.focusId, objectCount: scene.objectCount, visibleObjects: scene.visibleObjects, sceneSummary: { shapes: scene.shapes, roles: scene.roles, hueBuckets: scene.hueBuckets, files: scene.files }, sampleObjects: scene.objects }; }'
+        );
+        this.emit("function hsApplyViewportAction(action, payload = {}) {");
+        this.indent();
+        this.emit('const type = typeof action === "string" ? action : String(action?.type || action?.action || "");');
+        this.emit('const data = typeof action === "object" && action !== null ? { ...action, ...payload } : payload || {};');
+        this.emit("const before = hsViewportSnapshot();");
+        this.emit("const basis = hsCameraBasis();");
+        this.emit("const distance = hsCameraDistance();");
+        this.emit("const pan = Math.max(1, distance * 0.08);");
+        this.emit("let ok = true;");
+        this.emit('if (type === "pan_left") hsSetCamera(hsAdd(hsVec3(cameraPos), hsMul(basis.right, -pan)), hsAdd(hsVec3(cameraTarget), hsMul(basis.right, -pan)));');
+        this.emit('else if (type === "pan_right") hsSetCamera(hsAdd(hsVec3(cameraPos), hsMul(basis.right, pan)), hsAdd(hsVec3(cameraTarget), hsMul(basis.right, pan)));');
+        this.emit('else if (type === "pan_up") hsSetCamera(hsAdd(hsVec3(cameraPos), hsMul(basis.up, pan)), hsAdd(hsVec3(cameraTarget), hsMul(basis.up, pan)));');
+        this.emit('else if (type === "pan_down") hsSetCamera(hsAdd(hsVec3(cameraPos), hsMul(basis.up, -pan)), hsAdd(hsVec3(cameraTarget), hsMul(basis.up, -pan)));');
+        this.emit('else if (type === "zoom_in") hsSetCamera(hsAdd(hsVec3(cameraPos), hsMul(basis.forward, distance * 0.22)), hsVec3(cameraTarget));');
+        this.emit('else if (type === "zoom_out") hsSetCamera(hsAdd(hsVec3(cameraPos), hsMul(basis.forward, -distance * 0.25)), hsVec3(cameraTarget));');
+        this.emit('else if (type === "zoom_to_fit" || type === "reset_view") { holoGraphViewportState.focusId = null; hsSetCamera(Array.from(holoGraphInitialCameraPos), Array.from(holoGraphInitialCameraTarget)); }');
+        this.emit('else if (type === "focus_anchor" || type === "focus_node") ok = hsFocusObject(data);');
+        this.emit('else if (type === "filter_call") hsApplyFilter("call");');
+        this.emit('else if (type === "filter_import") hsApplyFilter("import");');
+        this.emit('else if (type === "filter_all") hsApplyFilter("all");');
+        this.emit('else if (type === "set_color_mode") hsApplyColorMode(String(data.mode || data.colorMode || "semantic"));');
+        this.emit('else if (type === "set_structure_style") hsApplyStructureStyle(String(data.style || data.structureStyle || "flow"));');
+        this.emit('else if (type === "set_label_policy") hsApplyLabelPolicy(data.policy || data.labelPolicy || "none");');
+        this.emit("else ok = false;");
+        this.emit("if (!ok) return { ok: false, action: type, before, after: hsViewportSnapshot() };");
+        this.emit("holoGraphViewportState.actionCount++;");
+        this.emit("holoGraphViewportState.lastAction = type;");
+        this.emit("document.body.dataset.holoscriptWebgpuLastAction = type;");
+        this.emit("return { ok: true, action: type, before, after: hsViewportSnapshot() };");
+        this.dedent();
+        this.emit("}");
+        this.emit("globalThis.holoscriptWebgpuViewport = { applyAction: hsApplyViewportAction, getState: hsViewportSnapshot, describeScene: hsDescribeScene, inspectObject: hsInspectObject, projectObject: hsProjectObject, projectPoint: hsProjectPoint };");
+        this.emit("globalThis.HoloGraphViewport = globalThis.holoscriptWebgpuViewport;");
+        this.emit('document.body.dataset.holoscriptWebgpuViewport = "ready";');
+        this.emit('document.body.dataset.holoscriptWebgpuInspector = "ready";');
+        this.emit('document.body.dataset.holoscriptWebgpuLabels = "none";');
+        this.emit("hsSetCamera(Array.from(cameraPos), Array.from(cameraTarget));");
+        this.emit("");
+      }
+      emitRenderLoop(composition) {
+        this.emit("// === Render Loop ===");
+        this.emit("let frameCount = 0;");
+        this.emit("const t0 = performance.now();");
+        this.emit("function frame() {");
+        this.indent();
+        this.emit("frameCount++;");
+        this.emit("const time = (performance.now() - t0) / 1000.0;");
+        this.emit("device.queue.writeBuffer(vpUniform, 0, buildViewProjection());");
+        if (this.hasWater) {
+          this.emit(
+            `device.queue.writeBuffer(waterFrameU, 0, new Float32Array([time, cameraPos[0], cameraPos[1], cameraPos[2], hsChannels[${JSON.stringify(this.waterClarityChannel)}], hsChannels[${JSON.stringify(this.waterRippleChannel)}], hsWaterAmp, 0]));`
+          );
+        }
+        this.emit("hsRenderLabels();");
+        this.emit("const enc = device.createCommandEncoder();");
+        const gpuObjs = (composition.objects || []).filter(
+          (o) => o.traits?.some(
+            (t) => isGpuParticleTraitName(t.name) || t.name === "gpu_physics" || t.name === "compute"
+          )
+        );
+        if (gpuObjs.length > 0 && this.options.enableCompute) {
+          this.emit("const cp = enc.beginComputePass();");
+          for (const obj of gpuObjs) {
+            const v = this.sanitizeName(obj.name);
+            if (obj.traits?.some((t) => isGpuParticleTraitName(t.name))) {
+              this.emit(
+                `cp.setPipeline(${v}ParticleCompute); cp.dispatchWorkgroups(${v}ComputeDispatches);`
+              );
+            }
+            if (obj.traits?.some((t) => t.name === "gpu_physics")) {
+              this.emit(`cp.setPipeline(${v}PhysicsCompute); cp.dispatchWorkgroups(16);`);
+            }
+            if (obj.traits?.some((t) => t.name === "compute")) {
+              this.emit(`cp.setPipeline(${v}CustomCompute); cp.dispatchWorkgroups(...${v}Workgroups);`);
+            }
+          }
+          this.emit("cp.end();");
+        }
+        this.emit("const rp = enc.beginRenderPass({");
+        this.indent();
+        this.emit(
+          'colorAttachments: [{ view: msaaTexture.createView(), resolveTarget: context.getCurrentTexture().createView(), clearValue: clearColor, loadOp: "clear", storeOp: "store" }],'
+        );
+        this.emit(
+          'depthStencilAttachment: { view: depthTexture.createView(), depthClearValue: 1.0, depthLoadOp: "clear", depthStoreOp: "store" },'
+        );
+        this.dedent();
+        this.emit("});");
+        if (composition.objects) {
+          for (const obj of composition.objects) this.emitDrawCall(obj);
+        }
+        if (composition.spatialGroups) {
+          for (const group of composition.spatialGroups) {
+            for (const obj of group.objects) this.emitDrawCall(obj);
+          }
+        }
+        this.emitDomainBlockDrawCalls(composition, false);
+        this.emitDomainBlockDrawCalls(composition, true);
+        this.emit("rp.end();");
+        this.emit("device.queue.submit([enc.finish()]);");
+        this.emit("document.body.dataset.holoscriptWebgpuFrame = String(frameCount);");
+        this.emit("requestAnimationFrame(frame);");
+        this.dedent();
+        this.emit("}");
+        this.emit("requestAnimationFrame(frame);");
+      }
+      emitDrawCall(obj) {
+        const v = this.sanitizeName(obj.name);
+        const traits = obj.traits || [];
+        const role = resolveGeometryRole({
+          purpose: this.findObjProp(obj, "purpose"),
+          visible: this.findObjProp(obj, "visible"),
+          traitNames: traits.map((t) => t.name)
+        });
+        if (!role.visible) {
+          if (obj.children) {
+            for (const child of obj.children) this.emitDrawCall(child);
+          }
+          return;
+        }
+        if (traits.some((t) => t.name === "gaussian_splat")) {
+          this.emit(`rp.setPipeline(${v}SplatPipeline); rp.draw(4, ${v}SplatCount.value);`);
+        } else if (traits.some((t) => t.name === "point_cloud")) {
+          this.emit(`rp.setPipeline(${v}PointPipeline); rp.draw(${v}PointCount.value);`);
+        } else if (traits.some((t) => isGpuParticleTraitName(t.name))) {
+          this.emit(
+            `rp.setPipeline(${v}ParticlePipeline); rp.setVertexBuffer(0, ${v}ParticleBufA); rp.draw(${v}ParticleCount);`
+          );
+        } else if (this.isWaterObject(obj)) {
+          this.emit(
+            `rp.setPipeline(${v}WaterPipeline); rp.setBindGroup(0, ${v}WaterBind); rp.setVertexBuffer(0, ${v}VBO); rp.draw(${v}VertexCount);`
+          );
+        } else {
+          this.emit(
+            `rp.setPipeline(${v}Pipeline); rp.setBindGroup(0, ${v}Bind); rp.setVertexBuffer(0, ${v}VBO); rp.draw(${v}VertexCount);`
+          );
+        }
+        if (obj.children) {
+          for (const child of obj.children) this.emitDrawCall(child);
+        }
+      }
+      emitDomainBlockDrawCalls(composition, postFxOnly) {
+        const blocks = composition.domainBlocks ?? [];
+        for (let i = 0; i < blocks.length; i++) {
+          const block = blocks[i];
+          const prefix = this.domainBlockVar(block, i);
+          if (block.domain === "postfx") {
+            if (postFxOnly) {
+              this.emit(`rp.setPipeline(${prefix}PostFXPipeline); rp.draw(3);`);
+            }
+            continue;
+          }
+          if (postFxOnly) continue;
+          if (block.domain === "vfx") {
+            this.emit(
+              `rp.setPipeline(${prefix}ParticlePipeline); rp.setVertexBuffer(0, ${prefix}ParticleBuf); rp.draw(${prefix}ParticleCount);`
+            );
+          }
+          if (block.domain === "procedural" && (block.keyword === "scatter" || block.keyword === "distribute" || block.properties?.count)) {
+            this.emit(
+              `rp.setPipeline(${prefix}ScatterPipeline); rp.setVertexBuffer(0, ${prefix}ScatterVBO); rp.draw(${prefix}ScatterVertexCount, ${prefix}ScatterInstanceCount);`
+            );
+          }
+        }
+      }
+      // ─── Helpers ──────────────────────────────────────────────────────────────
+      emit(line) {
+        this.lines.push(this.options.indent.repeat(this.indentLevel) + line);
+      }
+      emitMultiline(code) {
+        for (const line of code.split("\n")) this.emit(line);
+      }
+      indent() {
+        this.indentLevel++;
+      }
+      dedent() {
+        this.indentLevel = Math.max(0, this.indentLevel - 1);
+      }
+      sanitizeName(name) {
+        return name.replace(/[^a-zA-Z0-9_]/g, "_");
+      }
+      domainBlockVar(block, index) {
+        const raw = `${block.domain}_${block.keyword}_${block.name || index}`;
+        const safe = this.sanitizeName(raw);
+        return `db${index}_${safe || "domain"}`;
+      }
+      json(value) {
+        return JSON.stringify(value).replace(/</g, "\\u003c");
+      }
+      numberProp(block, keys, fallback) {
+        for (const key of keys) {
+          const value = block.properties?.[key];
+          if (typeof value === "number" && Number.isFinite(value)) return value;
+          if (typeof value === "string" && value.trim() !== "") {
+            const parsed = Number(value);
+            if (Number.isFinite(parsed)) return parsed;
+          }
+        }
+        return fallback;
+      }
+      hashSeed(value) {
+        let h = 2166136261;
+        for (let i = 0; i < value.length; i++) {
+          h ^= value.charCodeAt(i);
+          h = Math.imul(h, 16777619);
+        }
+        return h >>> 0;
+      }
+      findObjProp(obj, key) {
+        const own = obj.properties?.find((p) => p.key === key)?.value;
+        if (own !== void 0) return own;
+        if (obj.template) {
+          const tpl = this.templatesByName.get(obj.template);
+          const fromTemplate = tpl?.properties?.find((p) => p.key === key)?.value;
+          if (fromTemplate !== void 0) return fromTemplate;
+        }
+        return void 0;
+      }
+      extractObjectProperties(obj) {
+        const properties = {};
+        for (const prop of obj.properties ?? []) {
+          if (!prop.key) continue;
+          const value = prop.value;
+          if (typeof value === "string" || typeof value === "number" || typeof value === "boolean" || Array.isArray(value) && value.every(
+            (item) => typeof item === "string" || typeof item === "number" || typeof item === "boolean"
+          )) {
+            properties[prop.key] = value;
+          }
+        }
+        return properties;
+      }
+      parseColor(value) {
+        if (typeof value === "string" && value.startsWith("#")) {
+          const h = value.slice(1);
+          return [
+            parseFloat((parseInt(h.substring(0, 2), 16) / 255).toFixed(4)),
+            parseFloat((parseInt(h.substring(2, 4), 16) / 255).toFixed(4)),
+            parseFloat((parseInt(h.substring(4, 6), 16) / 255).toFixed(4))
+          ];
+        }
+        if (Array.isArray(value) && value.length >= 3) return [value[0], value[1], value[2]];
+        return [1, 1, 1];
+      }
+      extractMaterialColor(material, color) {
+        if (color) return this.parseColor(color);
+        if (material && typeof material === "object" && !Array.isArray(material)) {
+          const m = material;
+          if (m.color) return this.parseColor(m.color);
+        }
+        return [0.8, 0.8, 0.8];
+      }
+      extractMaterialProp(material, key, fallback) {
+        if (material && typeof material === "object" && !Array.isArray(material)) {
+          const m = material;
+          if (m[key] !== void 0) return m[key];
+        }
+        return fallback;
+      }
+      extractEmissive(material, obj) {
+        const objEmissive = this.findObjProp(obj, "emissive");
+        if (objEmissive !== void 0) return this.parseColor(objEmissive);
+        if (material && typeof material === "object" && !Array.isArray(material)) {
+          const m = material;
+          if (m.emissive !== void 0) return this.parseColor(m.emissive);
+        }
+        return [0, 0, 0];
+      }
+      geometryVertexDataFn(meshType) {
+        return resolveGeometry(meshType).webgpuVertexFn;
+      }
+      materialName(material) {
+        if (typeof material === "string") return material;
+        if (material && typeof material === "object") {
+          const m = material;
+          if (typeof m.type === "string") return m.type;
+          if (typeof m.name === "string") return m.name;
+        }
+        return void 0;
+      }
+      // Self-illumination strength for a named material when no explicit emissive is
+      // authored. Holographic/neon/emissive surfaces glow in their own color; glass/gel
+      // gets a soft sheen; everything else stays purely lit (0).
+      materialGlow(material) {
+        const name = this.materialName(material);
+        if (!name) return 0;
+        const n = name.toLowerCase();
+        if (/hologram|holo|liquid_glass|liquid_hologram|neon|glow|emissive|aura|plasma|energy/.test(n)) {
+          return 0.65;
+        }
+        if (/glass|crystal|gel|water/.test(n)) return 0.28;
+        return 0;
+      }
+    };
+  }
+});
+
+exports.WebGPUCompiler_exports = WebGPUCompiler_exports;
+exports.init_WebGPUCompiler = init_WebGPUCompiler;
+exports.init_geometry_purpose = init_geometry_purpose;
+exports.init_geometry_registry = init_geometry_registry;
+exports.init_skybox_registry = init_skybox_registry;
+exports.resolveGeometry = resolveGeometry;
+exports.resolveGeometryRole = resolveGeometryRole;
+exports.resolveSkyboxColor = resolveSkyboxColor;
+//# sourceMappingURL=chunk-ERYKKPHW.cjs.map
+//# sourceMappingURL=chunk-ERYKKPHW.cjs.map