@holoscript/core 8.0.13 → 8.0.14

package/dist/{chunk-ONPVM4IV.js → chunk-QLPRI3QW.js}

@@ -1,8 +1,200 @@
-import { init_DomainBlockCompilerMixin, datavizToWebGPU, compileDataVizBlock, compileMaterialBlock, materialToWebGPU, compileParticleBlock, compilePostProcessingBlock, compileProceduralBlock } from './chunk-5LVFTGKH.js';
-import { init_CompilerBase, CompilerBase } from './chunk-DUG3OQAS.js';
-import { __export, __esm } from './chunk-W4GABFCR.js';
+import { init_DomainBlockCompilerMixin, datavizToWebGPU, compileDataVizBlock, compileMaterialBlock, materialToWebGPU, compileParticleBlock, compilePostProcessingBlock, compileProceduralBlock } from './chunk-TZQKJOPC.js';
+import { init_CompilerBase, CompilerBase } from './chunk-YDSNDCV3.js';
+import { __esm, __export } from './chunk-W4GABFCR.js';
 import { ANSCapabilityPath } from '@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 = __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 = __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 = __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 = {};
 __export(WebGPUCompiler_exports, {
@@ -18,6 +210,9 @@ var WebGPUCompiler;
 var init_WebGPUCompiler = __esm({
   "src/compiler/WebGPUCompiler.ts"() {
     init_CompilerBase();
+    init_geometry_registry();
+    init_skybox_registry();
+    init_geometry_purpose();
     init_DomainBlockCompilerMixin();
     WebGPUCompiler = class extends CompilerBase {
       constructor(options = {}) {
@@ -26,6 +221,23 @@ var init_WebGPUCompiler = __esm({
         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,
@@ -42,6 +254,13 @@ var init_WebGPUCompiler = __esm({
         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")}"`
@@ -55,7 +274,27 @@ var init_WebGPUCompiler = __esm({
         this.emitGeometryHelpers();
         this.emitShaderSources();
         this.emitEnvironment(composition.environment ?? { type: "Environment", properties: [] });
-        this.emitCamera(composition.camera);
+        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) {
@@ -64,9 +303,7 @@ var init_WebGPUCompiler = __esm({
         if (composition.spatialGroups) {
           for (const group of composition.spatialGroups) this.emitGroup(group);
         }
-        if (composition.lights) {
-          for (const light of composition.lights) this.emitLight(light);
-        }
+        this.emitSceneManifest(composition);
         if (this.options.enableCompute) this.emitComputeShaders(composition);
         this.emitWebGPUDomainBlocks(composition);
         this.emitViewportRuntime();
@@ -350,6 +587,18 @@ var init_WebGPUCompiler = __esm({
         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 = [];");
@@ -415,7 +664,7 @@ var init_WebGPUCompiler = __esm({
         const envData = {};
         for (const prop of env.properties) envData[prop.key] = prop.value;
         const bg = envData.background || envData.skybox || "#000000";
-        const bgColor = this.parseColor(bg);
+        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 };`
         );
@@ -442,6 +691,41 @@ var init_WebGPUCompiler = __esm({
         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));
@@ -460,6 +744,8 @@ var init_WebGPUCompiler = __esm({
           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);
         }
@@ -477,6 +763,203 @@ var init_WebGPUCompiler = __esm({
           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);`);
@@ -493,14 +976,35 @@ var init_WebGPUCompiler = __esm({
         const [cr, cg, cb] = this.extractMaterialColor(material, color);
         const rough = this.extractMaterialProp(material, "roughness", 0.5);
         const metal = this.extractMaterialProp(material, "metalness", 0);
-        const [er, eg, eb] = this.extractEmissive(material, obj);
-        const emissiveStrength = this.extractMaterialProp(material, "emissive_intensity", 1);
+        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",');
@@ -523,7 +1027,7 @@ var init_WebGPUCompiler = __esm({
           `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: 0, resource: { buffer: ${v}Model } }, { binding: 1, resource: { buffer: ${v}Mat } }, { binding: 2, resource: { buffer: vpUniform } }, { binding: 3, resource: { buffer: sceneLights } }] });`
         );
       }
       emitGaussianSplatObject(v, obj) {
@@ -630,43 +1134,140 @@ var init_WebGPUCompiler = __esm({
         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 ────────────────────────────────────────────────────────────────
-      emitLight(light) {
-        const v = this.sanitizeName(light.name);
-        let color = [1, 1, 1], intensity = 1, pos = [0, 10, 0], dir = [0, -1, 0];
-        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;
+      // 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})`);
         }
-        const ti = { directional: 0, point: 1, spot: 2, hemisphere: 3, ambient: 4, area: 5 }[light.lightType] ?? 0;
-        this.emit(
-          `// Light: ${this.escapeStringValue(light.name, "TypeScript")} (${light.lightType})`
-        );
         this.emit(
-          `const ${v}Light = createBuffer(device, new Float32Array([${color[0] * intensity},${color[1] * intensity},${color[2] * intensity},${ti}, ${pos[0]},${pos[1]},${pos[2]},0, ${dir[0]},${dir[1]},${dir[2]},0]), GPUBufferUsage.UNIFORM);`
+          `const sceneLights = createBuffer(device, new Float32Array([${segs.join(", ")}]), GPUBufferUsage.UNIFORM);`
         );
         this.emit("");
       }
       // ─── Camera ───────────────────────────────────────────────────────────────
-      emitCamera(cam) {
+      // 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];
+        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;
-          else if ((prop.key === "look_at" || prop.key === "lookAt") && Array.isArray(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(",")}]);`);
@@ -766,15 +1367,27 @@ var init_WebGPUCompiler = __esm({
         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); let L = normalize(vec3<f32>(1.0, 2.0, 1.5));");
-        this.emit("  let d = max(dot(N, L), 0.0) * (1.0 - mat.rm[0] * 0.5);");
-        this.emit("  let lit = mat.color.rgb * (0.15 + d);");
+        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> };"
@@ -1009,6 +1622,11 @@ var init_WebGPUCompiler = __esm({
         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(
@@ -1065,6 +1683,17 @@ var init_WebGPUCompiler = __esm({
       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")) {
@@ -1073,6 +1702,10 @@ var init_WebGPUCompiler = __esm({
           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);`
@@ -1150,7 +1783,14 @@ var init_WebGPUCompiler = __esm({
         return h >>> 0;
       }
       findObjProp(obj, key) {
-        return obj.properties?.find((p) => p.key === key)?.value;
+        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 = {};
@@ -1202,21 +1842,34 @@ var init_WebGPUCompiler = __esm({
         return [0, 0, 0];
       }
       geometryVertexDataFn(meshType) {
-        const map = {
-          sphere: "generateSphereVertices(0.5, 16, 16)",
-          orb: "generateSphereVertices(0.5, 16, 16)",
-          plane: "generatePlaneVertices(1.0, 1.0)",
-          cylinder: "generateCylinderVertices(0.5, 1.0, 16)",
-          cone: "generateConeVertices(0.5, 1.0, 16)",
-          pyramid: "generateConeVertices(0.5, 1.0, 16)",
-          torus: "generateTorusVertices(0.5, 0.15, 16, 32)"
-        };
-        return map[meshType] || "generateCubeVertices(1.0)";
+        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;
       }
     };
   }
 });
 
-export { WebGPUCompiler, WebGPUCompiler_exports, init_WebGPUCompiler };
-//# sourceMappingURL=chunk-ONPVM4IV.js.map
-//# sourceMappingURL=chunk-ONPVM4IV.js.map
+export { WebGPUCompiler, WebGPUCompiler_exports, init_WebGPUCompiler, init_geometry_purpose, init_geometry_registry, init_skybox_registry, resolveGeometry, resolveGeometryRole, resolveSkyboxColor };
+//# sourceMappingURL=chunk-QLPRI3QW.js.map
+//# sourceMappingURL=chunk-QLPRI3QW.js.map