@holoscript/core 8.0.8 → 8.0.10

package/dist/{chunk-GH6C2QGW.cjs → chunk-QEDMOGF3.cjs}

@@ -1,11 +1,12 @@
 'use strict';
 
-var chunkLODTHGST_cjs = require('./chunk-LODTHGST.cjs');
-var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+var chunkVHORVGCG_cjs = require('./chunk-VHORVGCG.cjs');
+var chunkZK7KX5CD_cjs = require('./chunk-ZK7KX5CD.cjs');
+var chunkZHPMP447_cjs = require('./chunk-ZHPMP447.cjs');
 
 // src/compiler/DomainBlockCompilerMixin.ts
 function esc(value, target) {
-  return chunkLODTHGST_cjs.escapeStringValue(value, target);
+  return chunkZK7KX5CD_cjs.escapeStringValue(value, target);
 }
 function isPhysicalMaterial(mat) {
   return PHYSICAL_MATERIAL_KEYS.some((k) => mat[k] !== void 0);
@@ -46,6 +47,662 @@ function compileMaterialBlock(block) {
     traits: block.traits || []
   };
 }
+function compileMaterialGraphBlock(block) {
+  const props = block.properties || {};
+  const nodes = [];
+  for (const [key, raw] of Object.entries(props)) {
+    if (key === "connections") continue;
+    const nodeObj = raw && typeof raw === "object" ? raw : {};
+    const { type: nodeType, ...params } = nodeObj;
+    nodes.push({
+      id: key,
+      nodeType: typeof nodeType === "string" ? nodeType : "constant",
+      params
+    });
+  }
+  const rawConns = Array.isArray(props.connections) ? props.connections : [];
+  const edges = [];
+  for (const c of rawConns) {
+    const from = typeof c.from === "string" ? c.from : "";
+    const to = typeof c.to === "string" ? c.to : "";
+    if (!from || !to) continue;
+    const dot = to.indexOf(".");
+    const toNode = dot >= 0 ? to.slice(0, dot) : to;
+    const toPort = dot >= 0 ? to.slice(dot + 1) : "in";
+    edges.push({ from, toNode, toPort });
+  }
+  return {
+    name: block.name || "unnamed",
+    nodes,
+    edges,
+    traits: block.traits || []
+  };
+}
+function sanitizeMgIdent(id) {
+  const s = id.replace(/[^A-Za-z0-9_]/g, "_");
+  return /^[A-Za-z_]/.test(s) ? s : `n_${s}`;
+}
+function mgHexToVec3(value) {
+  const hex = typeof value === "string" ? value : "";
+  const m = /^#?([0-9a-fA-F]{6})$/.exec(hex.trim());
+  if (!m) return "vec3<f32>(0.5, 0.5, 0.5)";
+  const n = parseInt(m[1], 16);
+  const r = (n >> 16 & 255) / 255;
+  const g = (n >> 8 & 255) / 255;
+  const b = (n & 255) / 255;
+  return `vec3<f32>(${r.toFixed(4)}, ${g.toFixed(4)}, ${b.toFixed(4)})`;
+}
+function materialGraphToWGSL(graph) {
+  const safeName = sanitizeMgIdent(graph.name);
+  const fnName = `evalMaterialGraph_${safeName}`;
+  const warnings = [];
+  const nodeById = new Map(graph.nodes.map((n) => [n.id, n]));
+  const inputs = /* @__PURE__ */ new Map();
+  for (const n of graph.nodes) inputs.set(n.id, /* @__PURE__ */ new Map());
+  for (const e of graph.edges) {
+    if (!nodeById.has(e.from)) {
+      warnings.push(`edge from unknown node "${e.from}"`);
+      continue;
+    }
+    if (!inputs.has(e.toNode)) {
+      warnings.push(`edge to unknown node "${e.toNode}"`);
+      continue;
+    }
+    inputs.get(e.toNode).set(e.toPort, e.from);
+  }
+  const indeg = /* @__PURE__ */ new Map();
+  const adj = /* @__PURE__ */ new Map();
+  for (const n of graph.nodes) {
+    indeg.set(n.id, 0);
+    adj.set(n.id, []);
+  }
+  for (const e of graph.edges) {
+    if (!nodeById.has(e.from) || !nodeById.has(e.toNode)) continue;
+    adj.get(e.from).push(e.toNode);
+    indeg.set(e.toNode, (indeg.get(e.toNode) || 0) + 1);
+  }
+  const queue = graph.nodes.filter((n) => (indeg.get(n.id) || 0) === 0).map((n) => n.id);
+  const order = [];
+  while (queue.length) {
+    const id = queue.shift();
+    order.push(id);
+    for (const next of adj.get(id) || []) {
+      indeg.set(next, (indeg.get(next) || 0) - 1);
+      if ((indeg.get(next) || 0) === 0) queue.push(next);
+    }
+  }
+  if (order.length < graph.nodes.length) {
+    warnings.push("material graph has a cycle; emitting nodes in declaration order");
+    for (const n of graph.nodes) if (!order.includes(n.id)) order.push(n.id);
+  }
+  const values = /* @__PURE__ */ new Map();
+  const inPort = (nodeId, port) => {
+    const from = inputs.get(nodeId)?.get(port);
+    return from ? values.get(from) : void 0;
+  };
+  const body = [];
+  let output = null;
+  for (const id of order) {
+    const node = nodeById.get(id);
+    const v = sanitizeMgIdent(id);
+    switch (node.nodeType) {
+      case "constant": {
+        if (typeof node.params.value === "number") {
+          body.push(`  let mg_${v} = ${node.params.value.toFixed(4)}; // constant`);
+          values.set(id, { ref: `mg_${v}`, type: "f32" });
+        } else {
+          body.push(`  let mg_${v} = ${mgHexToVec3(node.params.value)}; // constant`);
+          values.set(id, { ref: `mg_${v}`, type: "vec3" });
+        }
+        break;
+      }
+      case "noise": {
+        const scale = typeof node.params.scale === "number" ? node.params.scale : 1;
+        body.push(`  let mg_${v} = mgNoise(uv * ${scale.toFixed(4)}); // noise`);
+        values.set(id, { ref: `mg_${v}`, type: "f32" });
+        break;
+      }
+      case "fresnel": {
+        const power = typeof node.params.power === "number" ? node.params.power : 5;
+        body.push(
+          `  let mg_${v} = pow(1.0 - max(dot(N, V), 0.0), ${power.toFixed(4)}); // fresnel`
+        );
+        values.set(id, { ref: `mg_${v}`, type: "f32" });
+        break;
+      }
+      case "multiply":
+      case "add": {
+        const a = inPort(id, "a");
+        const b = inPort(id, "b");
+        const op = node.nodeType === "multiply" ? "*" : "+";
+        const asVec = a?.type === "vec3" || b?.type === "vec3";
+        if (asVec) {
+          body.push(`  let mg_${v} = ${mgToVec3(a)} ${op} ${mgToVec3(b)}; // ${node.nodeType}`);
+          values.set(id, { ref: `mg_${v}`, type: "vec3" });
+        } else {
+          body.push(`  let mg_${v} = ${mgToF32(a)} ${op} ${mgToF32(b)}; // ${node.nodeType}`);
+          values.set(id, { ref: `mg_${v}`, type: "f32" });
+        }
+        break;
+      }
+      case "lerp": {
+        const a = inPort(id, "a");
+        const b = inPort(id, "b");
+        const t = inPort(id, "t");
+        body.push(
+          `  let mg_${v} = mix(${mgToVec3(a)}, ${mgToVec3(b)}, vec3<f32>(${mgToF32(t)})); // lerp`
+        );
+        values.set(id, { ref: `mg_${v}`, type: "vec3" });
+        break;
+      }
+      case "output": {
+        output = { id };
+        break;
+      }
+      default: {
+        warnings.push(`unknown node type "${node.nodeType}" (node "${id}") \u2014 treated as black`);
+        body.push(`  let mg_${v} = vec3<f32>(0.0); // unknown:${esc(node.nodeType, "TypeScript")}`);
+        values.set(id, { ref: `mg_${v}`, type: "vec3" });
+      }
+    }
+  }
+  const baseColorIn = output ? inPort(output.id, "base_color") : void 0;
+  const roughnessIn = output ? inPort(output.id, "roughness") : void 0;
+  const metallicIn = output ? inPort(output.id, "metallic") : void 0;
+  const emissiveIn = output ? inPort(output.id, "emissive") : void 0;
+  const baseColor = baseColorIn ? mgToVec3(baseColorIn) : "vec3<f32>(0.8)";
+  const roughness = roughnessIn ? mgToF32(roughnessIn, "0.5") : "0.5";
+  const metallic = metallicIn ? mgToF32(metallicIn, "0.0") : "0.0";
+  const emissive = emissiveIn ? mgToVec3(emissiveIn) : "vec3<f32>(0.0)";
+  const header = [
+    `// Material Graph "${esc(graph.name, "TypeScript")}" \u2014 generated by HoloScript TSLCompiler`,
+    `// Nodes: ${graph.nodes.length} | Edges: ${graph.edges.length} | topo-ordered: [${order.map((o) => esc(o, "TypeScript")).join(" -> ")}]`,
+    ...warnings.map((w) => `// WARNING: ${esc(w, "TypeScript")}`)
+  ];
+  const wgsl = [
+    ...header,
+    "",
+    "struct MaterialGraphSurface {",
+    "  baseColor: vec3<f32>,",
+    "  roughness: f32,",
+    "  metallic: f32,",
+    "  emissive: vec3<f32>,",
+    "};",
+    "",
+    "// Cheap value-noise helper (hash-based); replace with a texture sample for AAA fidelity.",
+    "fn mgNoise(p: vec2<f32>) -> f32 {",
+    "  return fract(sin(dot(p, vec2<f32>(12.9898, 78.233))) * 43758.5453);",
+    "}",
+    "",
+    `fn ${fnName}(uv: vec2<f32>, N: vec3<f32>, V: vec3<f32>, time: f32) -> MaterialGraphSurface {`,
+    ...body,
+    "  var surface: MaterialGraphSurface;",
+    `  surface.baseColor = ${baseColor};`,
+    `  surface.roughness = ${roughness};`,
+    `  surface.metallic = ${metallic};`,
+    `  surface.emissive = ${emissive};`,
+    "  return surface;",
+    "}"
+  ].join("\n");
+  return { fnName, wgsl };
+}
+function compileParticleFieldBlock(block) {
+  const props = block.properties || {};
+  const forces = [];
+  let count = 1e3;
+  let lifetime = 2;
+  for (const [key, raw] of Object.entries(props)) {
+    if (key === "count" && typeof raw === "number") {
+      count = raw;
+      continue;
+    }
+    if (key === "lifetime" && typeof raw === "number") {
+      lifetime = raw;
+      continue;
+    }
+    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+      const { type, ...params } = raw;
+      if (typeof type === "string") forces.push({ id: key, forceType: type, params });
+    }
+  }
+  return { name: block.name || "unnamed", count, lifetime, forces, traits: block.traits || [] };
+}
+function particleFieldToWGSL(field) {
+  const safe = sanitizeMgIdent(field.name);
+  const fnName = `cs_particle_field_${safe}`;
+  const warnings = [];
+  const num = (p, k, d) => typeof p[k] === "number" ? p[k] : d;
+  const forceLines = [];
+  for (const f of field.forces) {
+    const p = f.params;
+    switch (f.forceType) {
+      case "gravity":
+        forceLines.push(
+          `  accel += vec3<f32>(0.0, ${num(p, "strength", -9.81).toFixed(4)}, 0.0); // gravity:${esc(f.id, "TypeScript")}`
+        );
+        break;
+      case "drag":
+        forceLines.push(
+          `  accel -= p.vel * ${num(p, "coefficient", 0.1).toFixed(4)}; // drag:${esc(f.id, "TypeScript")}`
+        );
+        break;
+      case "vortex":
+        forceLines.push(
+          `  accel += normalize(vec3<f32>(-p.pos.z, 0.0, p.pos.x) + vec3<f32>(1e-4)) * ${num(p, "strength", 1).toFixed(4)}; // vortex:${esc(f.id, "TypeScript")}`
+        );
+        break;
+      case "attractor":
+        forceLines.push(
+          `  accel += -normalize(p.pos + vec3<f32>(1e-4)) * ${num(p, "strength", 1).toFixed(4)}; // attractor:${esc(f.id, "TypeScript")}`
+        );
+        break;
+      case "curl_noise":
+      case "turbulence":
+        forceLines.push(
+          `  accel += pfCurl(p.pos * ${num(p, "scale", 1).toFixed(4)}) * ${num(p, "strength", 1).toFixed(4)}; // ${f.forceType}:${esc(f.id, "TypeScript")}`
+        );
+        break;
+      default:
+        warnings.push(`unknown force "${f.forceType}" (node "${f.id}") \u2014 skipped`);
+        forceLines.push(`  // unknown force ${esc(f.forceType, "TypeScript")}:${esc(f.id, "TypeScript")}`);
+    }
+  }
+  if (forceLines.length === 0) forceLines.push("  // no forces declared \u2014 particles drift inertially");
+  const wgsl = [
+    `// Particle Field "${esc(field.name, "TypeScript")}" \u2014 generated by HoloScript TSLCompiler`,
+    `// count: ${field.count} | lifetime: ${field.lifetime} | forces: [${field.forces.map((f) => `${esc(f.forceType, "TypeScript")}:${esc(f.id, "TypeScript")}`).join(", ")}]`,
+    ...warnings.map((w) => `// WARNING: ${esc(w, "TypeScript")}`),
+    "",
+    `struct ParticleField_${safe} {`,
+    "  pos: vec3<f32>,",
+    "  life: f32,",
+    "  vel: vec3<f32>,",
+    "  _pad: f32,",
+    "};",
+    "",
+    "// hash-based value noise \u2192 cheap curl approximation for turbulent forces",
+    "fn pfHash3(p: vec3<f32>) -> f32 {",
+    "  return fract(sin(dot(p, vec3<f32>(12.9898, 78.233, 37.719))) * 43758.5453);",
+    "}",
+    "fn pfCurl(p: vec3<f32>) -> vec3<f32> {",
+    "  let e = 0.1;",
+    "  let dx = pfHash3(p + vec3<f32>(e, 0.0, 0.0)) - pfHash3(p - vec3<f32>(e, 0.0, 0.0));",
+    "  let dy = pfHash3(p + vec3<f32>(0.0, e, 0.0)) - pfHash3(p - vec3<f32>(0.0, e, 0.0));",
+    "  let dz = pfHash3(p + vec3<f32>(0.0, 0.0, e)) - pfHash3(p - vec3<f32>(0.0, 0.0, e));",
+    "  return vec3<f32>(dy - dz, dz - dx, dx - dy);",
+    "}",
+    "",
+    `@group(0) @binding(0) var<storage, read> pfIn_${safe}: array<ParticleField_${safe}>;`,
+    `@group(0) @binding(1) var<storage, read_write> pfOut_${safe}: array<ParticleField_${safe}>;`,
+    `@group(0) @binding(2) var<uniform> pfDt_${safe}: f32;`,
+    "",
+    "@compute @workgroup_size(64)",
+    `fn ${fnName}(@builtin(global_invocation_id) gid: vec3<u32>) {`,
+    `  let i = gid.x;`,
+    `  if (i >= arrayLength(&pfIn_${safe})) { return; }`,
+    `  var p = pfIn_${safe}[i];`,
+    `  let dt = pfDt_${safe};`,
+    "  var accel = vec3<f32>(0.0);",
+    ...forceLines,
+    "  p.vel += accel * dt;",
+    "  p.pos += p.vel * dt;",
+    "  p.life -= dt;",
+    "  if (p.life <= 0.0) {",
+    "    p.pos = vec3<f32>(0.0);",
+    "    p.vel = vec3<f32>(0.0, 1.0, 0.0);",
+    `    p.life = ${field.lifetime.toFixed(4)};`,
+    "  }",
+    `  pfOut_${safe}[i] = p;`,
+    "}"
+  ].join("\n");
+  return { fnName, wgsl };
+}
+function compileLightFieldBlock(block) {
+  const props = block.properties || {};
+  const lights = [];
+  let ambient = "#000000";
+  let bounces = 1;
+  let intensity = 1;
+  for (const [key, raw] of Object.entries(props)) {
+    if (key === "ambient" && typeof raw === "string") {
+      ambient = raw;
+      continue;
+    }
+    if (key === "bounces" && typeof raw === "number") {
+      bounces = raw;
+      continue;
+    }
+    if (key === "intensity" && typeof raw === "number") {
+      intensity = raw;
+      continue;
+    }
+    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+      const { type, ...params } = raw;
+      if (typeof type === "string") lights.push({ id: key, lightType: type, params });
+    }
+  }
+  return { name: block.name || "unnamed", ambient, bounces, intensity, lights, traits: block.traits || [] };
+}
+function lightFieldToWGSL(field) {
+  const safe = sanitizeMgIdent(field.name);
+  const fnName = `evalLightField_${safe}`;
+  const warnings = [];
+  const num = (p, k, d) => typeof p[k] === "number" ? p[k] : d;
+  const lightBlocks = [];
+  for (const l of field.lights) {
+    const p = l.params;
+    const color = mgHexToVec3(p.color);
+    const intensity = num(p, "intensity", 1).toFixed(4);
+    switch (l.lightType) {
+      case "directional":
+      case "sun":
+        lightBlocks.push(
+          [
+            `  { // directional:${esc(l.id, "TypeScript")}`,
+            `    let L = normalize(-vec3<f32>(${num(p, "dir_x", 0).toFixed(4)}, ${num(p, "dir_y", -1).toFixed(4)}, ${num(p, "dir_z", 0).toFixed(4)}));`,
+            `    let NdotL = max(dot(N, L), 0.0);`,
+            `    radiance += albedo * ${color} * ${intensity} * NdotL;`,
+            `  }`
+          ].join("\n")
+        );
+        break;
+      case "point":
+        lightBlocks.push(
+          [
+            `  { // point:${esc(l.id, "TypeScript")}`,
+            `    let d = vec3<f32>(${num(p, "pos_x", 0).toFixed(4)}, ${num(p, "pos_y", 0).toFixed(4)}, ${num(p, "pos_z", 0).toFixed(4)}) - worldPos;`,
+            `    let dist = length(d);`,
+            `    let L = d / max(dist, 1e-4);`,
+            `    let NdotL = max(dot(N, L), 0.0);`,
+            `    let atten = 1.0 / (1.0 + (dist * dist) / (${num(p, "range", 10).toFixed(4)} * ${num(p, "range", 10).toFixed(4)}));`,
+            `    radiance += albedo * ${color} * ${intensity} * NdotL * atten;`,
+            `  }`
+          ].join("\n")
+        );
+        break;
+      case "spot":
+        lightBlocks.push(
+          [
+            `  { // spot:${esc(l.id, "TypeScript")}`,
+            `    let d = vec3<f32>(${num(p, "pos_x", 0).toFixed(4)}, ${num(p, "pos_y", 5).toFixed(4)}, ${num(p, "pos_z", 0).toFixed(4)}) - worldPos;`,
+            `    let dist = length(d);`,
+            `    let L = d / max(dist, 1e-4);`,
+            `    let spotDir = normalize(vec3<f32>(${num(p, "dir_x", 0).toFixed(4)}, ${num(p, "dir_y", -1).toFixed(4)}, ${num(p, "dir_z", 0).toFixed(4)}));`,
+            `    let cone = smoothstep(${Math.cos(num(p, "cone", 30) * Math.PI / 180).toFixed(4)}, 1.0, dot(-L, spotDir));`,
+            `    let NdotL = max(dot(N, L), 0.0);`,
+            `    let atten = 1.0 / (1.0 + (dist * dist) / (${num(p, "range", 10).toFixed(4)} * ${num(p, "range", 10).toFixed(4)}));`,
+            `    radiance += albedo * ${color} * ${intensity} * NdotL * atten * cone;`,
+            `  }`
+          ].join("\n")
+        );
+        break;
+      case "ambient":
+      case "ambient_probe":
+      case "sky":
+        lightBlocks.push(
+          [
+            `  { // ambient:${esc(l.id, "TypeScript")}`,
+            `    radiance += albedo * ${color} * ${intensity};`,
+            `  }`
+          ].join("\n")
+        );
+        break;
+      default:
+        warnings.push(`unknown light "${l.lightType}" (node "${l.id}") \u2014 skipped`);
+        lightBlocks.push(`  // unknown light ${esc(l.lightType, "TypeScript")}:${esc(l.id, "TypeScript")}`);
+    }
+  }
+  const giScale = `(${field.intensity.toFixed(4)} * (1.0 + f32(${Math.round(field.bounces)}) * 0.5))`;
+  const wgsl = [
+    `// Light Field "${esc(field.name, "TypeScript")}" \u2014 generated by HoloScript TSLCompiler`,
+    `// ambient: ${esc(field.ambient, "TypeScript")} | bounces: ${field.bounces} | lights: [${field.lights.map((l) => `${esc(l.lightType, "TypeScript")}:${esc(l.id, "TypeScript")}`).join(", ")}]`,
+    ...warnings.map((w) => `// WARNING: ${esc(w, "TypeScript")}`),
+    "",
+    `fn ${fnName}(worldPos: vec3<f32>, N: vec3<f32>, V: vec3<f32>, albedo: vec3<f32>, roughness: f32, metallic: f32) -> vec3<f32> {`,
+    "  var radiance = vec3<f32>(0.0);",
+    "  // ambient / GI base \u2014 bounces approximated as an indirect ambient lift",
+    `  radiance += albedo * ${mgHexToVec3(field.ambient)} * ${giScale};`,
+    ...lightBlocks,
+    "  return radiance;",
+    "}"
+  ].join("\n");
+  return { fnName, wgsl };
+}
+function compileNavFieldBlock(block) {
+  const props = block.properties || {};
+  const behaviors = [];
+  let agents = 256;
+  let maxSpeed = 2;
+  for (const [key, raw] of Object.entries(props)) {
+    if (key === "agents" && typeof raw === "number") {
+      agents = raw;
+      continue;
+    }
+    if ((key === "max_speed" || key === "maxSpeed") && typeof raw === "number") {
+      maxSpeed = raw;
+      continue;
+    }
+    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+      const { type, ...params } = raw;
+      if (typeof type === "string") behaviors.push({ id: key, behaviorType: type, params });
+    }
+  }
+  return { name: block.name || "unnamed", agents, maxSpeed, behaviors, traits: block.traits || [] };
+}
+function navFieldToWGSL(field) {
+  const safe = sanitizeMgIdent(field.name);
+  const fnName = `cs_nav_field_${safe}`;
+  const ms = field.maxSpeed.toFixed(4);
+  const warnings = [];
+  const num = (p, k, d) => typeof p[k] === "number" ? p[k] : d;
+  const steerLines = [];
+  for (const b of field.behaviors) {
+    const p = b.params;
+    const w = num(p, "weight", 1).toFixed(4);
+    const target = `vec3<f32>(${num(p, "target_x", 0).toFixed(4)}, ${num(p, "target_y", 0).toFixed(4)}, ${num(p, "target_z", 0).toFixed(4)})`;
+    switch (b.behaviorType) {
+      case "seek":
+        steerLines.push(
+          `  { let desired = normalize(${target} - a.pos + vec3<f32>(1e-4)) * ${ms}; steer += (desired - a.vel) * ${w}; } // seek:${esc(b.id, "TypeScript")}`
+        );
+        break;
+      case "flee":
+        steerLines.push(
+          `  { let desired = normalize(a.pos - ${target} + vec3<f32>(1e-4)) * ${ms}; steer += (desired - a.vel) * ${w}; } // flee:${esc(b.id, "TypeScript")}`
+        );
+        break;
+      case "flow":
+        steerLines.push(
+          `  { let desired = normalize(vec3<f32>(${num(p, "dir_x", 1).toFixed(4)}, ${num(p, "dir_y", 0).toFixed(4)}, ${num(p, "dir_z", 0).toFixed(4)}) + vec3<f32>(1e-4)) * ${ms}; steer += (desired - a.vel) * ${w}; } // flow:${esc(b.id, "TypeScript")}`
+        );
+        break;
+      case "arrive":
+        steerLines.push(
+          [
+            `  { // arrive:${esc(b.id, "TypeScript")}`,
+            `    let to = ${target} - a.pos;`,
+            `    let dist = length(to);`,
+            `    let speed = ${ms} * clamp(dist / ${num(p, "slow_radius", 3).toFixed(4)}, 0.0, 1.0);`,
+            `    let desired = normalize(to + vec3<f32>(1e-4)) * speed;`,
+            `    steer += (desired - a.vel) * ${w};`,
+            `  }`
+          ].join("\n")
+        );
+        break;
+      default:
+        warnings.push(`unknown behavior "${b.behaviorType}" (node "${b.id}") \u2014 skipped`);
+        steerLines.push(`  // unknown behavior ${esc(b.behaviorType, "TypeScript")}:${esc(b.id, "TypeScript")}`);
+    }
+  }
+  if (steerLines.length === 0) steerLines.push("  // no behaviors declared \u2014 agents coast");
+  const wgsl = [
+    `// Nav Field "${esc(field.name, "TypeScript")}" \u2014 generated by HoloScript TSLCompiler`,
+    `// agents: ${field.agents} | max_speed: ${field.maxSpeed} | behaviors: [${field.behaviors.map((b) => `${esc(b.behaviorType, "TypeScript")}:${esc(b.id, "TypeScript")}`).join(", ")}]`,
+    ...warnings.map((w) => `// WARNING: ${esc(w, "TypeScript")}`),
+    "",
+    `struct NavAgent_${safe} {`,
+    "  pos: vec3<f32>,",
+    "  _pad0: f32,",
+    "  vel: vec3<f32>,",
+    "  _pad1: f32,",
+    "};",
+    "",
+    `@group(0) @binding(0) var<storage, read> navIn_${safe}: array<NavAgent_${safe}>;`,
+    `@group(0) @binding(1) var<storage, read_write> navOut_${safe}: array<NavAgent_${safe}>;`,
+    `@group(0) @binding(2) var<uniform> navDt_${safe}: f32;`,
+    "",
+    "@compute @workgroup_size(64)",
+    `fn ${fnName}(@builtin(global_invocation_id) gid: vec3<u32>) {`,
+    `  let i = gid.x;`,
+    `  if (i >= arrayLength(&navIn_${safe})) { return; }`,
+    `  var a = navIn_${safe}[i];`,
+    `  let dt = navDt_${safe};`,
+    "  var steer = vec3<f32>(0.0);",
+    ...steerLines,
+    "  a.vel += steer * dt;",
+    `  let sp = length(a.vel);`,
+    `  if (sp > ${ms}) { a.vel = a.vel / sp * ${ms}; }`,
+    "  a.pos += a.vel * dt;",
+    `  navOut_${safe}[i] = a;`,
+    "}"
+  ].join("\n");
+  return { fnName, wgsl };
+}
+function compilePhysicsContractBlock(block) {
+  const props = block.properties || {};
+  const bodies = [];
+  const constraints = [];
+  const gravity = [0, -9.81, 0];
+  let substeps = 1;
+  const numOf = (v, d) => typeof v === "number" ? v : d;
+  for (const [key, raw] of Object.entries(props)) {
+    if (key === "gravity" && Array.isArray(raw)) {
+      gravity[0] = numOf(raw[0], gravity[0]);
+      gravity[1] = numOf(raw[1], gravity[1]);
+      gravity[2] = numOf(raw[2], gravity[2]);
+      continue;
+    }
+    if (key === "gravity_x" && typeof raw === "number") {
+      gravity[0] = raw;
+      continue;
+    }
+    if (key === "gravity_y" && typeof raw === "number") {
+      gravity[1] = raw;
+      continue;
+    }
+    if (key === "gravity_z" && typeof raw === "number") {
+      gravity[2] = raw;
+      continue;
+    }
+    if (key === "substeps" && typeof raw === "number") {
+      substeps = Math.max(1, Math.floor(raw));
+      continue;
+    }
+    if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+      const sub = raw;
+      const kind = sub.kind;
+      if (kind === "body") {
+        bodies.push({
+          id: key,
+          mass: numOf(sub.mass, 1),
+          shape: typeof sub.shape === "string" ? sub.shape : "box",
+          pos: [numOf(sub.pos_x, 0), numOf(sub.pos_y, 0), numOf(sub.pos_z, 0)]
+        });
+      } else if (kind === "constraint") {
+        const { kind: _k, type, body_a, body_b, ...params } = sub;
+        constraints.push({
+          id: key,
+          constraintType: typeof type === "string" ? type : "distance",
+          bodyA: typeof body_a === "string" ? body_a : "",
+          bodyB: typeof body_b === "string" ? body_b : "",
+          params
+        });
+      }
+    }
+  }
+  return { name: block.name || "unnamed", gravity, substeps, bodies, constraints, traits: block.traits || [] };
+}
+function physicsContractToWGSL(field) {
+  const safe = sanitizeMgIdent(field.name);
+  const fnName = `cs_physics_contract_${safe}`;
+  const warnings = [];
+  const idx = new Map(field.bodies.map((b, i) => [b.id, i]));
+  const num = (p, k, d) => typeof p[k] === "number" ? p[k] : d;
+  const g = `vec3<f32>(${field.gravity[0].toFixed(4)}, ${field.gravity[1].toFixed(4)}, ${field.gravity[2].toFixed(4)})`;
+  const substeps = Math.max(1, field.substeps);
+  const constraintLines = [];
+  for (const c of field.constraints) {
+    const aIdx = idx.get(c.bodyA);
+    const bIdx = idx.get(c.bodyB);
+    if (aIdx === void 0 || bIdx === void 0) {
+      warnings.push(`constraint "${c.id}" (${c.constraintType}) references unknown body \u2014 skipped`);
+      constraintLines.push(`      // ${esc(c.constraintType, "TypeScript")}:${esc(c.id, "TypeScript")} \u2014 unresolved body ref, skipped`);
+      continue;
+    }
+    const a = `${aIdx}u`;
+    const b = `${bIdx}u`;
+    const p = c.params;
+    if (c.constraintType === "distance" || c.constraintType === "hinge") {
+      const rest = (c.constraintType === "hinge" ? num(p, "rest", 0) : num(p, "rest", 1)).toFixed(4);
+      const stiff = num(p, "stiffness", 1).toFixed(4);
+      const axisNote = c.constraintType === "hinge" ? ` axis (${num(p, "axis_x", 0).toFixed(2)},${num(p, "axis_y", 1).toFixed(2)},${num(p, "axis_z", 0).toFixed(2)}) \u2014 angular limit deferred` : "";
+      constraintLines.push(
+        [
+          `      // ${c.constraintType}:${esc(c.id, "TypeScript")}${axisNote}`,
+          `      if (i == ${a}) { let o = physIn_${safe}[${b}]; let d = p.pos - o.pos; let dist = length(d) + 1e-6; let n = d / dist; let C = dist - ${rest}; let w = p.invMass + o.invMass + 1e-6; p.pos -= n * (C * (p.invMass / w) * ${stiff}); }`,
+          `      if (i == ${b}) { let o = physIn_${safe}[${a}]; let d = p.pos - o.pos; let dist = length(d) + 1e-6; let n = d / dist; let C = dist - ${rest}; let w = p.invMass + o.invMass + 1e-6; p.pos -= n * (C * (p.invMass / w) * ${stiff}); }`
+        ].join("\n")
+      );
+    } else if (c.constraintType === "fixed") {
+      const off = `vec3<f32>(${num(p, "rest_x", 0).toFixed(4)}, ${num(p, "rest_y", 0).toFixed(4)}, ${num(p, "rest_z", 0).toFixed(4)})`;
+      constraintLines.push(
+        [
+          `      // fixed:${esc(c.id, "TypeScript")} \u2014 3-DoF weld (rotational lock deferred)`,
+          `      if (i == ${a}) { let o = physIn_${safe}[${b}]; let e = (o.pos - p.pos) - ${off}; let w = p.invMass + o.invMass + 1e-6; p.pos += e * (p.invMass / w); }`,
+          `      if (i == ${b}) { let o = physIn_${safe}[${a}]; let e = (p.pos - o.pos) - ${off}; let w = p.invMass + o.invMass + 1e-6; p.pos -= e * (p.invMass / w); }`
+        ].join("\n")
+      );
+    } else {
+      warnings.push(`unknown constraint "${c.constraintType}" (node "${c.id}") \u2014 skipped`);
+      constraintLines.push(`      // unknown constraint ${esc(c.constraintType, "TypeScript")}:${esc(c.id, "TypeScript")} \u2014 skipped`);
+    }
+  }
+  if (constraintLines.length === 0) constraintLines.push("      // no constraints declared \u2014 free integration only");
+  const wgsl = [
+    `// Physics Contract "${esc(field.name, "TypeScript")}" \u2014 generated by HoloScript TSLCompiler`,
+    `// bodies: ${field.bodies.length} | constraints: ${field.constraints.length} | gravity: [${field.gravity.join(", ")}] | substeps: ${substeps}`,
+    `// Upload: physIn[i] = { pos, invMass (= mass>0 ? 1/mass : 0), vel, _pad } from the authored body stack.`,
+    ...warnings.map((w) => `// WARNING: ${esc(w, "TypeScript")}`),
+    "",
+    `struct PhysBody_${safe} {`,
+    "  pos: vec3<f32>,",
+    "  invMass: f32,",
+    "  vel: vec3<f32>,",
+    "  _pad: f32,",
+    "};",
+    "",
+    `@group(0) @binding(0) var<storage, read> physIn_${safe}: array<PhysBody_${safe}>;`,
+    `@group(0) @binding(1) var<storage, read_write> physOut_${safe}: array<PhysBody_${safe}>;`,
+    `@group(0) @binding(2) var<uniform> physDt_${safe}: f32;`,
+    "",
+    "@compute @workgroup_size(64)",
+    `fn ${fnName}(@builtin(global_invocation_id) gid: vec3<u32>) {`,
+    `  let i = gid.x;`,
+    `  if (i >= arrayLength(&physIn_${safe})) { return; }`,
+    `  var p = physIn_${safe}[i];`,
+    `  let subDt = physDt_${safe} / ${substeps}.0;`,
+    `  for (var s = 0u; s < ${substeps}u; s = s + 1u) {`,
+    "    if (p.invMass > 0.0) {",
+    `      p.vel += ${g} * subDt;`,
+    "      p.pos += p.vel * subDt;",
+    "    }",
+    ...constraintLines,
+    "  }",
+    `  physOut_${safe}[i] = p;`,
+    "}"
+  ].join("\n");
+  return { fnName, wgsl };
+}
 function compilePhysicsBlock(block) {
   const colliders = [];
   const forceFields = [];
@@ -2727,6 +3384,102 @@ function iotToUSDA(iot) {
   lines.push("}");
   return lines.join("\n");
 }
+function stringProperty(props, keys) {
+  for (const key of keys) {
+    const value = props[key];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return void 0;
+}
+function numberProperty(props, keys) {
+  for (const key of keys) {
+    const value = props[key];
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+  }
+  return void 0;
+}
+function booleanProperty(props, keys) {
+  for (const key of keys) {
+    const value = props[key];
+    if (typeof value === "boolean") return value;
+  }
+  return void 0;
+}
+function stringArrayProperty(props, keys) {
+  for (const key of keys) {
+    const value = props[key];
+    if (Array.isArray(value) && value.every((entry) => typeof entry === "string")) {
+      return [...value];
+    }
+  }
+  return void 0;
+}
+function gradientStopsProperty(props, keys) {
+  for (const key of keys) {
+    const value = props[key];
+    if (!Array.isArray(value)) continue;
+    const stops = [];
+    for (const entry of value) {
+      if (entry && typeof entry === "object" && typeof entry.t === "number" && typeof entry.color === "string") {
+        const stop = entry;
+        stops.push({ t: stop.t, color: stop.color });
+      }
+    }
+    if (stops.length > 0) return stops;
+  }
+  return void 0;
+}
+function sampledStopsFromColors(colors) {
+  if (colors.length === 0) return [];
+  if (colors.length === 1) return [{ t: 0, color: colors[0] }];
+  return colors.map((color, index) => ({
+    t: index / (colors.length - 1),
+    color
+  }));
+}
+function buildPerceptualColorMetadata(props, traits, fallbackColorMap = "viridis") {
+  const colorMap = stringProperty(props, ["color_map", "colormap", "colorMap"]);
+  const palette = stringArrayProperty(props, ["palette", "colors"]);
+  const gradient = gradientStopsProperty(props, ["gradient", "color_gradient", "colorGradient"]) ?? stringArrayProperty(props, ["gradient", "color_gradient", "colorGradient"]);
+  const enabled = traits.includes("perceptual_color") || booleanProperty(props, ["perceptual_color", "perceptualColor", "scientific"]) === true || colorMap !== void 0 || palette !== void 0 || gradient !== void 0;
+  if (!enabled) return void 0;
+  const input = {
+    colorMap: colorMap ?? (palette || gradient ? void 0 : fallbackColorMap),
+    palette,
+    gradient,
+    steps: numberProperty(props, ["steps", "color_steps", "colorSteps"]),
+    dampening: numberProperty(props, ["dampening", "perceptual_dampening", "perceptualDampening"]),
+    targetDeltaE: numberProperty(props, ["target_delta_e", "targetDeltaE"]),
+    neutralAxis: booleanProperty(props, ["neutral_axis", "neutralAxis"]),
+    scientific: true
+  };
+  const pass = chunkVHORVGCG_cjs.applyPerceptualColorPass(input);
+  const source = pass.colorMap ?? pass.gradient ?? pass.palette;
+  const colors = source?.colors ?? [];
+  const stops = pass.colorMap?.stops ?? pass.gradient?.stops ?? sampledStopsFromColors(colors);
+  return {
+    mapName: pass.colorMap?.name ?? colorMap ?? (palette ? "palette" : gradient ? "gradient" : fallbackColorMap),
+    colors,
+    stops,
+    minDeltaE: source?.minDeltaE ?? 0,
+    maxDeltaE: source?.maxDeltaE ?? 0,
+    meanDeltaE: source?.meanDeltaE ?? 0,
+    warnings: pass.warnings,
+    pass
+  };
+}
+function perceptualColorRampFloat32(metadata) {
+  return metadata.colors.map((color) => {
+    const [r, g, b] = hexToRGBTuple(color);
+    return `${r}, ${g}, ${b}, 1.0`;
+  }).join(", ");
+}
+function perceptualColorRampLinearColors(metadata) {
+  return metadata.colors.map((color) => {
+    const [r, g, b] = hexToRGBTuple(color);
+    return `FLinearColor(${r}f, ${g}f, ${b}f, 1.0f)`;
+  }).join(", ");
+}
 function compileDataVizBlock(block) {
   const props = block.properties || {};
   let axes;
@@ -2740,6 +3493,9 @@ function compileDataVizBlock(block) {
   if (props.width != null || props.height != null) {
     dimensions = { width: props.width ?? 400, height: props.height ?? 300 };
   }
+  const traits = block.traits || [];
+  const colorMap = stringProperty(props, ["color_map", "colormap", "colorMap"]);
+  const perceptualColorPass = buildPerceptualColorMetadata(props, traits, colorMap ?? "viridis");
   return {
     name: block.name || "unnamed",
     keyword: block.keyword,
@@ -2749,11 +3505,14 @@ function compileDataVizBlock(block) {
     aggregation: props.aggregation,
     refreshInterval: props.refresh_interval,
     dimensions,
-    traits: block.traits || [],
+    colorMap: colorMap ?? perceptualColorPass?.mapName,
+    perceptualColorPass,
+    traits,
     properties: props
   };
 }
 function datavizToR3F(dv) {
+  const perceptual = dv.perceptualColorPass;
   const safeName = dv.name.replace(/[^a-zA-Z0-9_]/g, "_");
   const lines = [];
   lines.push(`// DataViz: ${dv.name} (${dv.keyword})`);
@@ -2767,10 +3526,15 @@ function datavizToR3F(dv) {
   if (dv.refreshInterval) lines.push(`  refreshInterval: ${dv.refreshInterval},`);
   if (dv.dimensions)
     lines.push(`  dimensions: { width: ${dv.dimensions.width}, height: ${dv.dimensions.height} },`);
+  if (dv.colorMap)
+    lines.push(`  colorMap: ${JSON.stringify(dv.colorMap)},`);
+  if (perceptual)
+    lines.push(`  perceptualColorPass: ${JSON.stringify(perceptual)},`);
   lines.push("};");
   return lines.join("\n");
 }
 function datavizToUnity(dv) {
+  const perceptual = dv.perceptualColorPass;
   const safeName = dv.name.replace(/[^a-zA-Z0-9_]/g, "_");
   const lines = [];
   lines.push(`// DataViz: ${dv.name}`);
@@ -2784,9 +3548,58 @@ function datavizToUnity(dv) {
     lines.push(`    public float width = ${dv.dimensions.width}f;`);
     lines.push(`    public float height = ${dv.dimensions.height}f;`);
   }
+  if (dv.colorMap)
+    lines.push(`    public string colorMap = "${esc(dv.colorMap, "CSharp")}";`);
+  if (perceptual) {
+    lines.push(
+      `    public string[] perceptualColorRamp = new string[] { ${perceptual.colors.map((color) => `"${color}"`).join(", ")} };`
+    );
+    lines.push(`    public float perceptualMinDeltaE = ${perceptual.minDeltaE.toFixed(3)}f;`);
+    lines.push(`    public float perceptualMeanDeltaE = ${perceptual.meanDeltaE.toFixed(3)}f;`);
+  }
   lines.push("}");
   return lines.join("\n");
 }
+function datavizToUnreal(dv, varPrefix) {
+  const perceptual = dv.perceptualColorPass;
+  const lines = [];
+  lines.push(`// DataViz: ${dv.name}`);
+  lines.push(`FString ${varPrefix}DataVizType = TEXT("${esc(dv.keyword, "CSharp")}");`);
+  if (dv.chartType) lines.push(`FString ${varPrefix}ChartType = TEXT("${esc(dv.chartType, "CSharp")}");`);
+  if (dv.dataSource) lines.push(`FString ${varPrefix}DataSource = TEXT("${esc(dv.dataSource, "CSharp")}");`);
+  if (perceptual) {
+    lines.push(`// PerceptualColorPass: ${perceptual.mapName}, ${perceptual.colors.length} stops`);
+    lines.push(`TArray<FLinearColor> ${varPrefix}PerceptualColorRamp = { ${perceptualColorRampLinearColors(perceptual)} };`);
+    lines.push(`float ${varPrefix}PerceptualMinDeltaE = ${perceptual.minDeltaE.toFixed(3)}f;`);
+  }
+  return lines.join("\n");
+}
+function datavizToWebGPU(dv, varPrefix) {
+  const perceptual = dv.perceptualColorPass;
+  const lines = [];
+  lines.push(`// DataViz: ${dv.name}`);
+  lines.push(`const ${varPrefix}DataVizConfig = ${JSON.stringify({
+    name: dv.name,
+    type: dv.keyword,
+    chartType: dv.chartType,
+    dataSource: dv.dataSource,
+    axes: dv.axes,
+    aggregation: dv.aggregation,
+    refreshInterval: dv.refreshInterval,
+    dimensions: dv.dimensions,
+    colorMap: dv.colorMap
+  })};`);
+  if (perceptual) {
+    lines.push(`const ${varPrefix}PerceptualColorRamp = new Float32Array([${perceptualColorRampFloat32(perceptual)}]);`);
+    lines.push(`const ${varPrefix}PerceptualColorStats = ${JSON.stringify({
+      minDeltaE: perceptual.minDeltaE,
+      maxDeltaE: perceptual.maxDeltaE,
+      meanDeltaE: perceptual.meanDeltaE,
+      warnings: perceptual.warnings
+    })};`);
+  }
+  return lines.join("\n");
+}
 function datavizToGodot(dv) {
   const lines = [];
   lines.push(`# DataViz: ${dv.name}`);
@@ -3734,13 +4547,19 @@ function compileSimulationBlock(block) {
     const c = child;
     if (c.traits?.includes("scalar_field_overlay") || c.keyword === "scalar_field_overlay") {
       const p = c.properties || {};
+      const colormap = p.colormap ?? "turbo";
       overlays.push({
         source: p.source ?? "",
-        colormap: p.colormap ?? "turbo",
+        colormap,
         range: p.range ?? [0, 1],
         opacity: p.opacity ?? 0.7,
         visible: p.visible ?? true,
-        label: p.label ?? ""
+        label: p.label ?? "",
+        perceptualColorPass: buildPerceptualColorMetadata(
+          { ...p, colormap },
+          c.traits || [],
+          colormap
+        )
       });
     }
   }
@@ -3776,9 +4595,16 @@ function simulationEnvironmentToR3FChunks(env) {
 function simulationToR3F(sim) {
   const configExpr = JSON.stringify(sim.config);
   const { visualLines, userDataExpr } = simulationEnvironmentToR3FChunks(sim.environment);
-  const overlayJSX = sim.overlays.map(
-    (o) => `<ScalarFieldOverlay colormap="${o.colormap}" range={[${o.range.join(", ")}]} opacity={${o.opacity}} visible={${o.visible}} label="${o.label}" />`
-  ).join("\n        ");
+  const overlayJSX = sim.overlays.map((o) => {
+    const perceptualComment = o.perceptualColorPass ? `{/* PerceptualColorPass ${JSON.stringify({
+      mapName: o.perceptualColorPass.mapName,
+      colors: o.perceptualColorPass.colors,
+      minDeltaE: o.perceptualColorPass.minDeltaE,
+      meanDeltaE: o.perceptualColorPass.meanDeltaE
+    })} */}
+        ` : "";
+    return `${perceptualComment}<ScalarFieldOverlay colormap="${o.colormap}" range={[${o.range.join(", ")}]} opacity={${o.opacity}} visible={${o.visible}} label="${o.label}" />`;
+  }).join("\n        ");
   const envVisual = visualLines.length > 0 ? `${visualLines.join("\n      ")}
       ` : "";
   const wrapWithGroup = (body) => userDataExpr ? `<group userData={${userDataExpr}}>
@@ -3821,13 +4647,14 @@ function hexToRGBA(hex, alpha) {
   ];
 }
 function getRequiredCapability() {
-  return chunkLODTHGST_cjs.ANSCapabilityPath.DOMAIN_BLOCK;
+  return chunkZK7KX5CD_cjs.ANSCapabilityPath.DOMAIN_BLOCK;
 }
-var PHYSICAL_MATERIAL_KEYS; exports.DOMAIN_BLOCK_COMPILER_MIXIN_CAPABILITY = void 0;
-var init_DomainBlockCompilerMixin = chunkHCCQLAA4_cjs.__esm({
+var PHYSICAL_MATERIAL_KEYS, mgToVec3, mgToF32; exports.DOMAIN_BLOCK_COMPILER_MIXIN_CAPABILITY = void 0;
+var init_DomainBlockCompilerMixin = chunkZHPMP447_cjs.__esm({
   "src/compiler/DomainBlockCompilerMixin.ts"() {
-    chunkLODTHGST_cjs.init_CompilerBase();
-    chunkLODTHGST_cjs.init_ANSNamespace();
+    chunkZK7KX5CD_cjs.init_CompilerBase();
+    chunkZK7KX5CD_cjs.init_ANSNamespace();
+    chunkVHORVGCG_cjs.init_PerceptualColorPass();
     PHYSICAL_MATERIAL_KEYS = [
       "clearcoat",
       "clearcoatRoughness",
@@ -3841,6 +4668,8 @@ var init_DomainBlockCompilerMixin = chunkHCCQLAA4_cjs.__esm({
       "attenuationColor",
       "attenuationDistance"
     ];
+    mgToVec3 = (v) => !v ? "vec3<f32>(0.0)" : v.type === "vec3" ? v.ref : `vec3<f32>(${v.ref})`;
+    mgToF32 = (v, fallback = "0.0") => !v ? fallback : v.type === "f32" ? v.ref : `(${v.ref}).x`;
     exports.DOMAIN_BLOCK_COMPILER_MIXIN_CAPABILITY = "/compile/mixin/domain-block";
   }
 });
@@ -3867,13 +4696,18 @@ exports.compileEducationBlock = compileEducationBlock;
 exports.compileHealthcareBlock = compileHealthcareBlock;
 exports.compileInputBlock = compileInputBlock;
 exports.compileIoTBlock = compileIoTBlock;
+exports.compileLightFieldBlock = compileLightFieldBlock;
 exports.compileMaterialBlock = compileMaterialBlock;
+exports.compileMaterialGraphBlock = compileMaterialGraphBlock;
 exports.compileMusicBlock = compileMusicBlock;
 exports.compileNarrativeBlock = compileNarrativeBlock;
+exports.compileNavFieldBlock = compileNavFieldBlock;
 exports.compileNavigationBlock = compileNavigationBlock;
 exports.compileParticleBlock = compileParticleBlock;
+exports.compileParticleFieldBlock = compileParticleFieldBlock;
 exports.compilePaymentBlock = compilePaymentBlock;
 exports.compilePhysicsBlock = compilePhysicsBlock;
+exports.compilePhysicsContractBlock = compilePhysicsContractBlock;
 exports.compilePostProcessingBlock = compilePostProcessingBlock;
 exports.compileProceduralBlock = compileProceduralBlock;
 exports.compileRenderingBlock = compileRenderingBlock;
@@ -3885,7 +4719,9 @@ exports.datavizToGodot = datavizToGodot;
 exports.datavizToR3F = datavizToR3F;
 exports.datavizToUSDA = datavizToUSDA;
 exports.datavizToUnity = datavizToUnity;
+exports.datavizToUnreal = datavizToUnreal;
 exports.datavizToVRChat = datavizToVRChat;
+exports.datavizToWebGPU = datavizToWebGPU;
 exports.educationToGodot = educationToGodot;
 exports.educationToR3F = educationToR3F;
 exports.educationToUSDA = educationToUSDA;
@@ -3909,6 +4745,8 @@ exports.iotToUSDA = iotToUSDA;
 exports.iotToUnity = iotToUnity;
 exports.iotToVRChat = iotToVRChat;
 exports.isPhysicalMaterial = isPhysicalMaterial;
+exports.lightFieldToWGSL = lightFieldToWGSL;
+exports.materialGraphToWGSL = materialGraphToWGSL;
 exports.materialToAndroidXR = materialToAndroidXR;
 exports.materialToBabylon = materialToBabylon;
 exports.materialToGLTF = materialToGLTF;
@@ -3932,11 +4770,13 @@ exports.narrativeToR3F = narrativeToR3F;
 exports.narrativeToUSDA = narrativeToUSDA;
 exports.narrativeToUnity = narrativeToUnity;
 exports.narrativeToVRChat = narrativeToVRChat;
+exports.navFieldToWGSL = navFieldToWGSL;
 exports.navigationToGodot = navigationToGodot;
 exports.navigationToR3F = navigationToR3F;
 exports.navigationToUSDA = navigationToUSDA;
 exports.navigationToUnity = navigationToUnity;
 exports.navigationToVRChat = navigationToVRChat;
+exports.particleFieldToWGSL = particleFieldToWGSL;
 exports.particlesToAndroidXR = particlesToAndroidXR;
 exports.particlesToBabylon = particlesToBabylon;
 exports.particlesToGodot = particlesToGodot;
@@ -3951,6 +4791,7 @@ exports.paymentToR3F = paymentToR3F;
 exports.paymentToUSDA = paymentToUSDA;
 exports.paymentToUnity = paymentToUnity;
 exports.paymentToVRChat = paymentToVRChat;
+exports.physicsContractToWGSL = physicsContractToWGSL;
 exports.physicsToAndroidXR = physicsToAndroidXR;
 exports.physicsToBabylon = physicsToBabylon;
 exports.physicsToGodot = physicsToGodot;
@@ -3994,5 +4835,5 @@ exports.web3ToR3F = web3ToR3F;
 exports.web3ToUSDA = web3ToUSDA;
 exports.web3ToUnity = web3ToUnity;
 exports.web3ToVRChat = web3ToVRChat;
-//# sourceMappingURL=chunk-GH6C2QGW.cjs.map
-//# sourceMappingURL=chunk-GH6C2QGW.cjs.map
+//# sourceMappingURL=chunk-QEDMOGF3.cjs.map
+//# sourceMappingURL=chunk-QEDMOGF3.cjs.map