@holoscript/core 8.0.8 → 8.0.10

package/dist/{chunk-3NGDZZR4.js → chunk-KEYG7HGY.js}

@@ -1,6 +1,6 @@
-import { init_DomainBlockCompilerMixin, compileDomainBlocks, compileMaterialBlock, materialToWebGPU } from './chunk-ZA34AN3R.js';
-import { init_CompilerBase, CompilerBase } from './chunk-C7ZBSV2Q.js';
-import { __export, __esm } from './chunk-OL46QLBJ.js';
+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 { ANSCapabilityPath } from '@holoscript/core-types/ans';
 
 // src/compiler/WebGPUCompiler.ts
@@ -52,7 +52,10 @@ var init_WebGPUCompiler = __esm({
         }
         this.emit("");
         this.emitDeviceInit();
+        this.emitGeometryHelpers();
+        this.emitShaderSources();
         if (composition.environment) this.emitEnvironment(composition.environment);
+        this.emitCamera(composition.camera);
         if (composition.objects) {
           for (const obj of composition.objects) this.emitObject(obj);
         }
@@ -62,10 +65,8 @@ var init_WebGPUCompiler = __esm({
         if (composition.lights) {
           for (const light of composition.lights) this.emitLight(light);
         }
-        if (composition.camera) this.emitCamera(composition.camera);
         if (this.options.enableCompute) this.emitComputeShaders(composition);
         this.emitWebGPUDomainBlocks(composition);
-        this.emitShaderSources();
         this.emitRenderLoop(composition);
         return this.lines.join("\n");
       }
@@ -74,23 +75,160 @@ var init_WebGPUCompiler = __esm({
         if (domainBlocks.length === 0) return;
         this.emit("");
         this.emit("// === v4.2 Domain Blocks ===");
-        let blockIdx = 0;
-        const compiled = compileDomainBlocks(
-          domainBlocks,
-          {
-            material: (block) => {
-              const mat = compileMaterialBlock(block);
-              return materialToWebGPU(mat, `db${blockIdx++}`);
-            }
-          },
-          (block) => `// Domain block: ${block.domain}/${block.keyword} "${this.escapeStringValue(block.name, "TypeScript")}"`
-        );
-        for (const line of compiled) {
-          for (const l of line.split("\n")) {
-            this.emit(l);
+        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(datavizToWebGPU(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 = compileMaterialBlock(block);
+        this.emitMultiline(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 = 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 = 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 = 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 ===");
@@ -98,6 +236,7 @@ var init_WebGPUCompiler = __esm({
         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" });');
@@ -126,6 +265,145 @@ var init_WebGPUCompiler = __esm({
         );
         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("}");
+        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 ──────────────────────────────────────────────────────────
@@ -165,12 +443,11 @@ var init_WebGPUCompiler = __esm({
         const isPointCloud = traits.some((t) => t.name === "point_cloud");
         const isGpuParticle = traits.some((t) => isGpuParticleTraitName(t.name));
         if (isModel && modelSrc) {
-          this.emit(`const ${v}Model = await assetLoader.load("${modelSrc}");`);
-          const pos = this.findObjProp(obj, "position");
-          const [px, py, pz] = Array.isArray(pos) ? pos : [0, 0, 0];
+          this.emit(`const ${v}Asset = await assetLoader.load("${modelSrc}");`);
           this.emit(
-            `const ${v}ModelMatrix = createBuffer(device, new Float32Array([1,0,0,0, 0,1,0,0, 0,0,1,0, ${px},${py},${pz},1]), GPUBufferUsage.UNIFORM);`
+            `// 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");
@@ -213,8 +490,10 @@ 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);
         this.emit(
-          `const ${v}Mat = createBuffer(device, new Float32Array([${cr},${cg},${cb},1.0, ${rough},${metal},0,0]), GPUBufferUsage.UNIFORM);`
+          `const ${v}Mat = createBuffer(device, new Float32Array([${cr},${cg},${cb},1.0, ${rough},${metal},${emissiveStrength},0, ${er},${eg},${eb},0]), GPUBufferUsage.UNIFORM);`
         );
         this.emit(`const ${v}Pipeline = device.createRenderPipeline({`);
         this.indent();
@@ -238,7 +517,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: 0, resource: { buffer: ${v}Model } }, { binding: 1, resource: { buffer: ${v}Mat } }, { binding: 2, resource: { buffer: vpUniform } }] });`
         );
       }
       emitGaussianSplatObject(v, obj) {
@@ -373,8 +652,8 @@ var init_WebGPUCompiler = __esm({
       // ─── Camera ───────────────────────────────────────────────────────────────
       emitCamera(cam) {
         this.emit("// === Camera ===");
-        let fov = 60, near = 0.1, far = 1e3, pos = [0, 1, 5], lookAt = [0, 0, 0];
-        for (const prop of cam.properties) {
+        let fov = 60, near = 0.1, far = 1e3, pos = [4, 3, 6], lookAt = [0, 0, 0];
+        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;
@@ -386,13 +665,38 @@ var init_WebGPUCompiler = __esm({
         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 aspect = canvas.width / canvas.height;");
+        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(
-          "return new Float32Array([f/aspect,0,0,0, 0,f,0,0, 0,0,(cameraNear+cameraFar)*ri,-1, 0,0,cameraNear*cameraFar*ri*2,0]);"
-        );
+        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(
@@ -431,7 +735,7 @@ var init_WebGPUCompiler = __esm({
             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: [number, number, number] = [${wg}];`);
+            this.emit(`const ${v}Workgroups = [${wg}];`);
           }
         }
         this.emit("");
@@ -441,7 +745,9 @@ var init_WebGPUCompiler = __esm({
         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> };"
@@ -449,17 +755,19 @@ var init_WebGPUCompiler = __esm({
         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 = w; o.wNorm = (u.model * vec4<f32>(i.norm, 0.0)).xyz; o.wPos = w.xyz; return o; }`;"
+          "  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> };");
+        this.emit("struct Mat { color: vec4<f32>, rm: vec4<f32>, emissive: vec4<f32> };");
         this.emit("@group(0) @binding(1) var<uniform> mat: Mat;");
         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("  return vec4<f32>(mat.color.rgb * (0.15 + d), mat.color.a); }`;");
+        this.emit("  let lit = mat.color.rgb * (0.15 + d);");
+        this.emit("  let emit = mat.emissive.rgb * mat.rm[2];");
+        this.emit("  return vec4<f32>(lit + emit, mat.color.a); }`;");
         this.emit("");
         this.emit("const WGSL_SPLAT = /* wgsl */`");
         this.emit(
@@ -498,6 +806,25 @@ var init_WebGPUCompiler = __esm({
           "  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>;");
@@ -578,8 +905,11 @@ var init_WebGPUCompiler = __esm({
             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("}");
@@ -605,10 +935,37 @@ var init_WebGPUCompiler = __esm({
           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++;
       }
@@ -618,6 +975,33 @@ var init_WebGPUCompiler = __esm({
       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) {
         return obj.properties?.find((p) => p.key === key)?.value;
       }
@@ -648,6 +1032,15 @@ var init_WebGPUCompiler = __esm({
         }
         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) {
         const map = {
           sphere: "generateSphereVertices(0.5, 16, 16)",
@@ -665,5 +1058,5 @@ var init_WebGPUCompiler = __esm({
 });
 
 export { WebGPUCompiler, WebGPUCompiler_exports, init_WebGPUCompiler };
-//# sourceMappingURL=chunk-3NGDZZR4.js.map
-//# sourceMappingURL=chunk-3NGDZZR4.js.map
+//# sourceMappingURL=chunk-KEYG7HGY.js.map
+//# sourceMappingURL=chunk-KEYG7HGY.js.map

package/dist/{chunk-DY72BMU5.js → chunk-KFVNCW4Q.js}

@@ -1,5 +1,5 @@
-import { init_AgentRBAC, init_CompilerBase, getRBAC, UnauthorizedCompilerAccessError } from './chunk-C7ZBSV2Q.js';
-import { __export, __esm } from './chunk-OL46QLBJ.js';
+import { init_AgentRBAC, init_CompilerBase, getRBAC, UnauthorizedCompilerAccessError } from './chunk-DUG3OQAS.js';
+import { __export, __esm } from './chunk-W4GABFCR.js';
 
 // src/compiler/StateCompiler.ts
 var StateCompiler_exports = {};
@@ -109,5 +109,5 @@ var init_StateCompiler = __esm({
 });
 
 export { StateCompiler, StateCompiler_exports, UnauthorizedStateCompilerAccessError, init_StateCompiler };
-//# sourceMappingURL=chunk-DY72BMU5.js.map
-//# sourceMappingURL=chunk-DY72BMU5.js.map
+//# sourceMappingURL=chunk-KFVNCW4Q.js.map
+//# sourceMappingURL=chunk-KFVNCW4Q.js.map