@carbonenginejs/runtime-resource 0.9.2 → 0.11.0

package/dist/formats/webgpu/core/ir/indexableTemps.js

@@ -0,0 +1,137 @@
+const COMPONENTS = "xyzw";
+const DESTINATION_MASK = /^x?y?z?w?$/u;
+function fail(reason) {
+  throw new Error(`Shader IR indexable temp is not supported: ${reason}`);
+}
+function validateComponents(operand, role, componentCount) {
+  const valid = COMPONENTS.slice(0, componentCount);
+  if (role === "destination") {
+    if (typeof operand.mask !== "string" || !operand.mask || !DESTINATION_MASK.test(operand.mask) || Array.from(operand.mask).some(component => !valid.includes(component)) || operand.swizzle || operand.selected) {
+      fail("a destination requires one canonical in-range write mask");
+    }
+    return;
+  }
+  if (operand.mask) {
+    fail("a source indexable temp requires swizzle or select component mode");
+  }
+  if ([operand.swizzle, operand.selected].filter(Boolean).length > 1) {
+    fail("a source requires exactly one component-selection mode");
+  }
+  if (operand.swizzle && (operand.swizzle.length !== 4 || Array.from(operand.swizzle).some(component => !valid.includes(component))) || operand.selected && (operand.selected.length !== 1 || !valid.includes(operand.selected))) {
+    fail("a source selects an invalid or out-of-range component");
+  }
+}
+
+/**
+ * Validates the declaration-backed identity of an indexable-temp operand.
+ * Mutable fixed slots are returned as ordinary SSA register identities.
+ * Reads from an extracted immutable table return null so they bypass register
+ * SSA and lower through the table expression path instead.
+ *
+ * @param {object} program Shader IR program under construction or lowering.
+ * @param {object} operand Indexable-temp operand.
+ * @param {"source"|"destination"} role Operand role.
+ * @returns {{registerIndex:number, slotIndex:number, key:string}|null} Fixed SSA address, or null for a const-table read.
+ */
+function validateIndexableTempOperand(program, operand, role) {
+  if (operand?.typeName !== "indexable_temp") return null;
+  if (!["source", "destination"].includes(role)) throw new TypeError("Invalid indexable-temp operand role");
+  const indices = operand.indices;
+  if (!Array.isArray(indices) || indices.length !== 2) {
+    fail("an operand requires exactly [register][slot] indices");
+  }
+  const registerIndex = indices[0];
+  if (registerIndex?.relative || !Array.isArray(registerIndex?.values) || registerIndex.values.length !== 1 || !Number.isInteger(registerIndex.values[0]) || registerIndex.values[0] < 0) {
+    fail("the register index must be one fixed non-negative integer");
+  }
+  const register = registerIndex.values[0];
+  if (!Number.isInteger(operand.registerIndex) || operand.registerIndex !== register) {
+    fail("the operand register identity does not match its first index");
+  }
+  const declarations = (program.declarations || []).filter(declaration => declaration.opcodeName === "dcl_indexable_temp" && declaration.data?.registerIndex === register);
+  if (declarations.length !== 1) {
+    fail(declarations.length ? `x${register} has duplicate declarations` : `x${register} is undeclared`);
+  }
+  const declaration = declarations[0].data;
+  if (!Number.isInteger(declaration.registerCount) || declaration.registerCount < 1) {
+    fail(`x${register} has no usable slot count`);
+  }
+  if (!Number.isInteger(declaration.componentCount) || declaration.componentCount < 1 || declaration.componentCount > 4) {
+    fail(`x${register} has an invalid component count`);
+  }
+  if (operand.componentCount !== 4) {
+    fail(`x${register} operand is not four-component`);
+  }
+  validateComponents(operand, role, declaration.componentCount);
+  const tables = (program.constTables || []).filter(table => table.registerIndex === register);
+  if (tables.length > 1) fail(`x${register} aliases duplicate immutable constant tables`);
+  if (tables.length && role === "destination") fail(`x${register} aliases an immutable constant table`);
+  const slotIndex = indices[1];
+  if (slotIndex?.relative) {
+    if (!Array.isArray(slotIndex.values) || slotIndex.values.length > 1 || slotIndex.values.length === 1 && (!Number.isInteger(slotIndex.values[0]) || slotIndex.values[0] < 0)) {
+      fail(`x${register} has an invalid relative slot base`);
+    }
+    if (tables.length && role === "source") return null;
+    fail(`x${register} uses relative ${role} addressing`);
+  }
+  if (!Array.isArray(slotIndex?.values) || slotIndex.values.length !== 1 || !Number.isInteger(slotIndex.values[0]) || slotIndex.values[0] < 0) {
+    fail(`x${register} requires one fixed non-negative slot index`);
+  }
+  const slot = slotIndex.values[0];
+  if (slot >= declaration.registerCount) {
+    fail(`x${register}[${slot}] is outside its declared range`);
+  }
+  if (tables.length) return null;
+  if (declaration.componentCount !== 4) {
+    fail(`x${register}[${slot}] is not a four-component mutable operand`);
+  }
+  return {
+    registerIndex: register,
+    slotIndex: slot,
+    key: `indexable_temp[${register},${slot}]`
+  };
+}
+
+/**
+ * Cross-checks a fixed source operand against its canonical SSA read record.
+ *
+ * @param {object} program Frozen shader IR program.
+ * @param {object} operand Indexable-temp source operand.
+ * @param {object} read Register-read or index-read dataflow record.
+ * @param {string[]} expectedComponents Components selected by the current operand metadata.
+ * @returns {{registerIndex:number, slotIndex:number,key:string}} Validated fixed address.
+ */
+function validateIndexableTempRead(program, operand, read, expectedComponents) {
+  if (operand?.typeName !== "indexable_temp") return null;
+  const address = validateIndexableTempOperand(program, operand, "source");
+  if (!address || read?.register !== address.key || !Array.isArray(read.refs) || !read.refs.length || !Array.isArray(expectedComponents) || expectedComponents.length !== read.refs.length || read.refs.some((ref, index) => ref.component !== expectedComponents[index]) || Array.isArray(read.components) && (read.components.length !== expectedComponents.length || read.components.some((component, index) => component !== expectedComponents[index]))) {
+    fail("a fixed source has inconsistent register dataflow");
+  }
+  for (const ref of read.refs) {
+    const value = program.values.find(entry => entry.id === ref.valueId);
+    if (!value || value.register !== address.key) {
+      fail("a fixed source references a value from another register");
+    }
+  }
+  return address;
+}
+
+/**
+ * Cross-checks a fixed destination operand against its canonical SSA write.
+ *
+ * @param {object} program Frozen shader IR program.
+ * @param {object} operand Indexable-temp destination operand.
+ * @param {object} write Register-write dataflow record.
+ * @returns {{registerIndex:number, slotIndex:number,key:string}} Validated fixed address.
+ */
+function validateIndexableTempWrite(program, operand, write) {
+  const address = validateIndexableTempOperand(program, operand, "destination");
+  const value = program.values.find(entry => entry.id === write?.valueId);
+  if (!address || write?.register !== address.key || write.mask !== operand.mask || !value || value.register !== address.key || value.writeMask !== write.mask) {
+    fail("a fixed destination has inconsistent indexable-temp dataflow");
+  }
+  return address;
+}
+
+export { validateIndexableTempOperand, validateIndexableTempRead, validateIndexableTempWrite };
+//# sourceMappingURL=indexableTemps.js.map

package/dist/formats/webgpu/core/ir/indexableTemps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexableTemps.js","sources":["../../../../../../src/formats/webgpu/core/ir/indexableTemps.js"],"sourcesContent":["const COMPONENTS = \"xyzw\";\nconst DESTINATION_MASK = /^x?y?z?w?$/u;\n\nfunction fail(reason)\n{\n    throw new Error(`Shader IR indexable temp is not supported: ${reason}`);\n}\n\nfunction validateComponents(operand, role, componentCount)\n{\n    const valid = COMPONENTS.slice(0, componentCount);\n    if (role === \"destination\")\n    {\n        if (typeof operand.mask !== \"string\" || !operand.mask\n            || !DESTINATION_MASK.test(operand.mask)\n            || Array.from(operand.mask).some((component) => !valid.includes(component))\n            || operand.swizzle || operand.selected)\n        {\n            fail(\"a destination requires one canonical in-range write mask\");\n        }\n        return;\n    }\n    if (operand.mask)\n    {\n        fail(\"a source indexable temp requires swizzle or select component mode\");\n    }\n    if ([ operand.swizzle, operand.selected ].filter(Boolean).length > 1)\n    {\n        fail(\"a source requires exactly one component-selection mode\");\n    }\n    if ((operand.swizzle && (operand.swizzle.length !== 4\n            || Array.from(operand.swizzle).some((component) => !valid.includes(component))))\n        || (operand.selected && (operand.selected.length !== 1 || !valid.includes(operand.selected))))\n    {\n        fail(\"a source selects an invalid or out-of-range component\");\n    }\n}\n\n/**\n * Validates the declaration-backed identity of an indexable-temp operand.\n * Mutable fixed slots are returned as ordinary SSA register identities.\n * Reads from an extracted immutable table return null so they bypass register\n * SSA and lower through the table expression path instead.\n *\n * @param {object} program Shader IR program under construction or lowering.\n * @param {object} operand Indexable-temp operand.\n * @param {\"source\"|\"destination\"} role Operand role.\n * @returns {{registerIndex:number, slotIndex:number, key:string}|null} Fixed SSA address, or null for a const-table read.\n */\nexport function validateIndexableTempOperand(program, operand, role)\n{\n    if (operand?.typeName !== \"indexable_temp\") return null;\n    if (![ \"source\", \"destination\" ].includes(role)) throw new TypeError(\"Invalid indexable-temp operand role\");\n\n    const indices = operand.indices;\n    if (!Array.isArray(indices) || indices.length !== 2)\n    {\n        fail(\"an operand requires exactly [register][slot] indices\");\n    }\n    const registerIndex = indices[0];\n    if (registerIndex?.relative\n        || !Array.isArray(registerIndex?.values)\n        || registerIndex.values.length !== 1\n        || !Number.isInteger(registerIndex.values[0])\n        || registerIndex.values[0] < 0)\n    {\n        fail(\"the register index must be one fixed non-negative integer\");\n    }\n    const register = registerIndex.values[0];\n    if (!Number.isInteger(operand.registerIndex) || operand.registerIndex !== register)\n    {\n        fail(\"the operand register identity does not match its first index\");\n    }\n\n    const declarations = (program.declarations || []).filter((declaration) =>\n        declaration.opcodeName === \"dcl_indexable_temp\"\n        && declaration.data?.registerIndex === register);\n    if (declarations.length !== 1)\n    {\n        fail(declarations.length ? `x${register} has duplicate declarations` : `x${register} is undeclared`);\n    }\n    const declaration = declarations[0].data;\n    if (!Number.isInteger(declaration.registerCount) || declaration.registerCount < 1)\n    {\n        fail(`x${register} has no usable slot count`);\n    }\n    if (!Number.isInteger(declaration.componentCount)\n        || declaration.componentCount < 1 || declaration.componentCount > 4)\n    {\n        fail(`x${register} has an invalid component count`);\n    }\n    if (operand.componentCount !== 4)\n    {\n        fail(`x${register} operand is not four-component`);\n    }\n    validateComponents(operand, role, declaration.componentCount);\n\n    const tables = (program.constTables || []).filter((table) => table.registerIndex === register);\n    if (tables.length > 1) fail(`x${register} aliases duplicate immutable constant tables`);\n    if (tables.length && role === \"destination\") fail(`x${register} aliases an immutable constant table`);\n\n    const slotIndex = indices[1];\n    if (slotIndex?.relative)\n    {\n        if (!Array.isArray(slotIndex.values) || slotIndex.values.length > 1\n            || (slotIndex.values.length === 1\n                && (!Number.isInteger(slotIndex.values[0]) || slotIndex.values[0] < 0)))\n        {\n            fail(`x${register} has an invalid relative slot base`);\n        }\n        if (tables.length && role === \"source\") return null;\n        fail(`x${register} uses relative ${role} addressing`);\n    }\n    if (!Array.isArray(slotIndex?.values)\n        || slotIndex.values.length !== 1\n        || !Number.isInteger(slotIndex.values[0])\n        || slotIndex.values[0] < 0)\n    {\n        fail(`x${register} requires one fixed non-negative slot index`);\n    }\n    const slot = slotIndex.values[0];\n    if (slot >= declaration.registerCount)\n    {\n        fail(`x${register}[${slot}] is outside its declared range`);\n    }\n    if (tables.length) return null;\n    if (declaration.componentCount !== 4)\n    {\n        fail(`x${register}[${slot}] is not a four-component mutable operand`);\n    }\n    return { registerIndex: register, slotIndex: slot, key: `indexable_temp[${register},${slot}]` };\n}\n\n/**\n * Cross-checks a fixed source operand against its canonical SSA read record.\n *\n * @param {object} program Frozen shader IR program.\n * @param {object} operand Indexable-temp source operand.\n * @param {object} read Register-read or index-read dataflow record.\n * @param {string[]} expectedComponents Components selected by the current operand metadata.\n * @returns {{registerIndex:number, slotIndex:number,key:string}} Validated fixed address.\n */\nexport function validateIndexableTempRead(program, operand, read, expectedComponents)\n{\n    if (operand?.typeName !== \"indexable_temp\") return null;\n    const address = validateIndexableTempOperand(program, operand, \"source\");\n    if (!address || read?.register !== address.key || !Array.isArray(read.refs) || !read.refs.length\n        || !Array.isArray(expectedComponents) || expectedComponents.length !== read.refs.length\n        || read.refs.some((ref, index) => ref.component !== expectedComponents[index])\n        || (Array.isArray(read.components)\n            && (read.components.length !== expectedComponents.length\n                || read.components.some((component, index) => component !== expectedComponents[index]))))\n    {\n        fail(\"a fixed source has inconsistent register dataflow\");\n    }\n    for (const ref of read.refs)\n    {\n        const value = program.values.find((entry) => entry.id === ref.valueId);\n        if (!value || value.register !== address.key)\n        {\n            fail(\"a fixed source references a value from another register\");\n        }\n    }\n    return address;\n}\n\n/**\n * Cross-checks a fixed destination operand against its canonical SSA write.\n *\n * @param {object} program Frozen shader IR program.\n * @param {object} operand Indexable-temp destination operand.\n * @param {object} write Register-write dataflow record.\n * @returns {{registerIndex:number, slotIndex:number,key:string}} Validated fixed address.\n */\nexport function validateIndexableTempWrite(program, operand, write)\n{\n    const address = validateIndexableTempOperand(program, operand, \"destination\");\n    const value = program.values.find((entry) => entry.id === write?.valueId);\n    if (!address || write?.register !== address.key || write.mask !== operand.mask\n        || !value || value.register !== address.key || value.writeMask !== write.mask)\n    {\n        fail(\"a fixed destination has inconsistent indexable-temp dataflow\");\n    }\n    return address;\n}\n"],"names":["COMPONENTS","DESTINATION_MASK","fail","reason","Error","validateComponents","operand","role","componentCount","valid","slice","mask","test","Array","from","some","component","includes","swizzle","selected","filter","Boolean","length","validateIndexableTempOperand","program","typeName","TypeError","indices","isArray","registerIndex","relative","values","Number","isInteger","register","declarations","declaration","opcodeName","data","registerCount","tables","constTables","table","slotIndex","slot","key","validateIndexableTempRead","read","expectedComponents","address","refs","ref","index","components","value","find","entry","id","valueId","validateIndexableTempWrite","write","writeMask"],"mappings":"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"}

package/dist/formats/webgpu/core/ir/inferValueTypes.js

@@ -0,0 +1,454 @@
+const COMPONENTS = ["x", "y", "z", "w"];
+const COMPONENT_INDEX = new Map(COMPONENTS.map((component, index) => [component, index]));
+const SCALAR_TYPES = Object.freeze(["unknown", "float32", "int32", "uint32", "bool", "bitpattern32"]);
+const FLOAT_OPS = new Set(["add", "deriv_rtx", "deriv_rty", "deriv_rtx_coarse", "deriv_rtx_fine", "deriv_rty_coarse", "deriv_rty_fine", "div", "dp2", "dp3", "dp4", "exp", "frc", "log", "mad", "max", "min", "mul", "rcp", "round_ne", "round_ni", "round_pi", "round_z", "rsq", "sqrt", "sincos"]);
+const FLOAT_COMPARE = new Set(["eq", "ge", "lt", "ne"]);
+const INT_OPS = new Set(["iadd", "imad", "imax", "imin", "imul", "ineg", "ishl", "ishr"]);
+const INT_COMPARE = new Set(["ieq", "ige", "ilt", "ine"]);
+const UINT_OPS = new Set(["countbits", "firstbit_hi", "firstbit_lo", "firstbit_shi", "uaddc", "ubfe", "udiv", "umad", "umax", "umin", "umul", "ushr", "usubb"]);
+const UINT_COMPARE = new Set(["uge", "ult"]);
+const BITWISE_OPS = new Set(["and", "not", "or", "xor"]);
+const CONTROL_MASK_OPS = new Set(["breakc", "continuec", "discard", "if", "retc", "switch"]);
+const SAMPLE_OPS = new Set(["sample", "sample_b", "sample_c", "sample_c_lz", "sample_d", "sample_l"]);
+function bindingResultType(program, instruction, operandTypeName, resourceKind) {
+  const resource = instruction.operands.find(operand => operand.typeName === operandTypeName);
+  const reference = resource?.resourceReference;
+  const binding = program.bindings.find(entry => entry.resourceKind === resourceKind && (reference?.rangeId !== null && reference?.rangeId !== undefined ? entry.range.rangeId === reference.rangeId : entry.registerIndex === resource?.registerIndex));
+  const mapped = (binding?.returnType?.returnTypeNames || []).map(type => ({
+    unorm: "float32",
+    snorm: "float32",
+    float: "float32",
+    sint: "int32",
+    uint: "uint32"
+  })[type] || "unknown");
+  const concrete = mapped.filter(type => type !== "unknown");
+  if (!concrete.length) return null;
+  return new Set(concrete).size === 1 ? concrete[0] : "bitpattern32";
+}
+function sampleResultType(program, instruction) {
+  return bindingResultType(program, instruction, "resource", "sampled-resource");
+}
+function ruleFor(opcodeName, program, instruction) {
+  if (FLOAT_OPS.has(opcodeName)) return {
+    name: "float-arithmetic",
+    destination: "float32",
+    sources: "float32"
+  };
+  if (FLOAT_COMPARE.has(opcodeName)) return {
+    name: "float-comparison-mask",
+    destination: "uint32",
+    sources: "float32"
+  };
+  if (INT_OPS.has(opcodeName)) return {
+    name: "signed-integer",
+    destination: "int32",
+    sources: "int32"
+  };
+  if (INT_COMPARE.has(opcodeName)) return {
+    name: "signed-comparison-mask",
+    destination: "uint32",
+    sources: "int32"
+  };
+  if (UINT_OPS.has(opcodeName)) return {
+    name: "unsigned-integer",
+    destination: "uint32",
+    sources: "uint32"
+  };
+  if (UINT_COMPARE.has(opcodeName)) return {
+    name: "unsigned-comparison-mask",
+    destination: "uint32",
+    sources: "uint32"
+  };
+  if (BITWISE_OPS.has(opcodeName)) return {
+    name: "bitwise",
+    destination: "uint32",
+    sources: "uint32"
+  };
+  if (CONTROL_MASK_OPS.has(opcodeName)) return {
+    name: "control-mask",
+    destination: null,
+    sourceByOperand: {
+      0: "uint32"
+    },
+    conditionProjection: "nonzero"
+  };
+  if (SAMPLE_OPS.has(opcodeName)) {
+    const sourceByOperand = {
+      1: "float32"
+    };
+    if (["sample_b", "sample_c", "sample_l"].includes(opcodeName)) sourceByOperand[4] = "float32";
+    if (opcodeName === "sample_d") Object.assign(sourceByOperand, {
+      4: "float32",
+      5: "float32"
+    });
+    return {
+      name: "sample-resource",
+      destination: sampleResultType(program, instruction),
+      sourceByOperand
+    };
+  }
+  if (opcodeName === "resinfo") {
+    return {
+      name: "resource-info",
+      destination: instruction?.resinfoReturnTypeName === "uint" ? "uint32" : "float32"
+    };
+  }
+  if (opcodeName === "f16tof32") return {
+    name: "half-unpack",
+    destination: "float32",
+    sourceByOperand: {
+      1: "uint32"
+    }
+  };
+  if (opcodeName === "f32tof16") return {
+    name: "half-pack",
+    destination: "uint32",
+    sourceByOperand: {
+      1: "float32"
+    }
+  };
+  if (opcodeName === "ld") {
+    return {
+      name: "texture-load",
+      destination: sampleResultType(program, instruction),
+      sourceByOperand: {
+        1: "uint32"
+      }
+    };
+  }
+  if (opcodeName === "atomic_iadd") {
+    return {
+      name: "atomic-add",
+      destination: null,
+      sourceByOperand: {
+        1: "uint32",
+        2: "uint32"
+      }
+    };
+  }
+  if (opcodeName === "store_uav_typed") {
+    return {
+      name: "typed-uav-store",
+      destination: null,
+      sourceByOperand: {
+        1: "uint32",
+        2: bindingResultType(program, instruction, "uav", "storage-resource")
+      }
+    };
+  }
+  if (opcodeName === "ld_structured") {
+    return {
+      name: "structured-load",
+      destination: null,
+      sourceByOperand: {
+        1: "uint32",
+        2: "uint32"
+      }
+    };
+  }
+  if (opcodeName === "store_structured") {
+    return {
+      name: "structured-store",
+      destination: null,
+      sourceByOperand: {
+        1: "uint32",
+        2: "uint32"
+      }
+    };
+  }
+  const conversions = {
+    ftoi: ["int32", "float32"],
+    ftou: ["uint32", "float32"],
+    itof: ["float32", "int32"],
+    utof: ["float32", "uint32"]
+  };
+  if (conversions[opcodeName]) {
+    const [destination, source] = conversions[opcodeName];
+    return {
+      name: "numeric-conversion",
+      destination,
+      sourceByOperand: {
+        1: source
+      },
+      conversion: {
+        from: source,
+        to: destination
+      }
+    };
+  }
+  if (opcodeName === "mov") return {
+    name: "move",
+    destination: null,
+    equalitySources: [1]
+  };
+  if (opcodeName === "movc") return {
+    name: "conditional-move",
+    destination: null,
+    sourceByOperand: {
+      1: "uint32"
+    },
+    equalitySources: [2, 3]
+  };
+  return {
+    name: "untyped",
+    destination: null
+  };
+}
+function nodeKey(ref) {
+  return `${ref.valueId}.${ref.component}`;
+}
+function valueComponents(value) {
+  return Array.from(value.writeMask || "");
+}
+function signatureType(program, register, component) {
+  if (["output_depth", "output_depth_greater_equal", "output_depth_less_equal"].includes(register)) return "float32";
+  const match = /^(input|output)\[(\d+)/.exec(register);
+  if (!match) return null;
+  const elements = program.signatures?.[match[1]] || [];
+  const componentBit = 1 << COMPONENT_INDEX.get(component);
+  const element = elements.find(entry => entry.registerIndex === Number(match[2]) && entry.mask & componentBit);
+  return element && SCALAR_TYPES.includes(element.componentTypeName) ? element.componentTypeName : null;
+}
+function correspondingRef(refs, index) {
+  if (!refs.length) return null;
+  return refs.length === 1 ? refs[0] : refs[index % refs.length];
+}
+
+/**
+ * Infers component storage types from opcode domains, signatures, moves, and
+ * SSA merges. Conflicting typeless-register uses become `bitpattern32` and
+ * receive explicit per-use reinterpret records.
+ *
+ * @param {object} program Mutable shader IR under construction.
+ * @returns {object} The same program.
+ */
+function inferValueTypes(program) {
+  const parent = new Map();
+  const constraints = new Map();
+  const ensure = ref => {
+    const key = nodeKey(ref);
+    if (!parent.has(key)) {
+      parent.set(key, key);
+      constraints.set(key, new Set());
+    }
+    return key;
+  };
+  const find = key => {
+    let current = key;
+    while (parent.get(current) !== current) current = parent.get(current);
+    while (parent.get(key) !== key) {
+      const next = parent.get(key);
+      parent.set(key, current);
+      key = next;
+    }
+    return current;
+  };
+  const union = (leftRef, rightRef) => {
+    const left = find(ensure(leftRef));
+    const right = find(ensure(rightRef));
+    if (left === right) return;
+    const [root, child] = left.localeCompare(right) <= 0 ? [left, right] : [right, left];
+    parent.set(child, root);
+    for (const type of constraints.get(child)) constraints.get(root).add(type);
+  };
+  const constrain = (ref, type) => {
+    if (!type) return;
+    constraints.get(find(ensure(ref))).add(type);
+  };
+  for (const value of program.values) {
+    for (const component of valueComponents(value)) ensure({
+      valueId: value.id,
+      component
+    });
+    if (value.origin === "control-flow-merge") {
+      const mergeRef = {
+        valueId: value.id,
+        component: value.writeMask
+      };
+      for (const incoming of value.incoming) union(mergeRef, incoming);
+    }
+  }
+  for (const instruction of program.instructions) {
+    const rule = ruleFor(instruction.opcodeName, program, instruction);
+    const writes = instruction.dataflow.writes;
+    for (const sourceOperandIndex of rule.equalitySources || []) {
+      const read = instruction.dataflow.reads.find(entry => entry.operandIndex === sourceOperandIndex && entry.kind !== "index-read");
+      if (!read) continue;
+      for (const write of writes) {
+        Array.from(write.mask).forEach((component, index) => {
+          const sourceRef = correspondingRef(read.refs, index);
+          if (sourceRef) union({
+            valueId: write.valueId,
+            component
+          }, sourceRef);
+        });
+      }
+    }
+  }
+  for (const value of program.values) {
+    for (const component of valueComponents(value)) {
+      const type = signatureType(program, value.register, component);
+      if (type) constrain({
+        valueId: value.id,
+        component
+      }, type);
+    }
+  }
+  for (const instruction of program.instructions) {
+    const rule = ruleFor(instruction.opcodeName, program, instruction);
+    if (rule.destination) {
+      for (const write of instruction.dataflow.writes) {
+        for (const component of write.mask) constrain({
+          valueId: write.valueId,
+          component
+        }, rule.destination);
+      }
+    }
+    for (const read of instruction.dataflow.reads) {
+      if (read.kind === "index-read") continue;
+      const expected = rule.sourceByOperand?.[read.operandIndex] ?? rule.sources ?? null;
+      for (const ref of read.refs) constrain(ref, expected);
+    }
+  }
+
+  // A live value (read by an instruction or feeding a phi) whose type is
+  // otherwise unconstrained — e.g. an immediate `0` that only ever flows
+  // through moves and never reaches a typed use — defaults to raw bitpattern32
+  // bits so it can be emitted. This covers EVERY lane of a live value, not
+  // just the read lane: an emitted multi-lane value needs a type for its dead
+  // lanes too (the vector constructor references all of them). Because moves
+  // union source and destination, the default propagates consistently across
+  // the whole move chain and any phi it feeds. Genuinely dead writes are never
+  // read, keep no constraint (stay `unknown`), and are dropped by the lowerers.
+  const liveValueIds = new Set();
+  for (const instruction of program.instructions) {
+    for (const read of instruction.dataflow.reads) {
+      if (read.kind === "index-read") continue;
+      for (const ref of read.refs) liveValueIds.add(ref.valueId);
+    }
+  }
+  for (const value of program.values) {
+    for (const incoming of value.incoming || []) liveValueIds.add(incoming.valueId);
+  }
+  for (const value of program.values) {
+    if (!liveValueIds.has(value.id)) continue;
+    for (const component of valueComponents(value)) {
+      const ref = {
+        valueId: value.id,
+        component
+      };
+      if (!constraints.get(find(ensure(ref))).size) constrain(ref, "bitpattern32");
+    }
+  }
+  const typeForRef = ref => {
+    const types = Array.from(constraints.get(find(ensure(ref))));
+    if (types.length === 0) return "unknown";
+    return types.length === 1 ? types[0] : "bitpattern32";
+  };
+  for (const value of program.values) {
+    value.componentTypes = {};
+    for (const component of valueComponents(value)) {
+      value.componentTypes[component] = typeForRef({
+        valueId: value.id,
+        component
+      });
+    }
+  }
+  for (const instruction of program.instructions) {
+    const rule = ruleFor(instruction.opcodeName, program, instruction);
+    const writes = instruction.dataflow.writes;
+    const destinationTypes = writes.flatMap(write => Array.from(write.mask).map(component => program.values.find(value => value.id === write.valueId)?.componentTypes[component])).filter(Boolean);
+    const moveType = destinationTypes.length && new Set(destinationTypes).size === 1 ? destinationTypes[0] : null;
+    const operandTypes = instruction.operands.map((operand, operandIndex) => {
+      let expectedType = rule.sourceByOperand?.[operandIndex] ?? null;
+      if (!expectedType && rule.sources && operandIndex > 0) expectedType = rule.sources;
+      if (!expectedType && (rule.equalitySources || []).includes(operandIndex)) expectedType = moveType;
+      if (instruction.dataflow.writes.some(write => write.operandIndex === operandIndex)) expectedType = rule.destination ?? moveType;
+      return {
+        operandIndex,
+        role: instruction.dataflow.writes.some(write => write.operandIndex === operandIndex) ? "destination" : "source",
+        expectedType: expectedType || "unknown",
+        modifier: operand.modifierName || "none",
+        minPrecision: operand.minPrecisionName || "default",
+        immediate: operand.typeName === "immediate32" ? operand.immediateValues.map((value, component) => ({
+          component: COMPONENTS[component],
+          uint32: value.uint32,
+          float32: value.float32
+        })) : null
+      };
+    });
+    const bitcasts = [];
+    for (const read of instruction.dataflow.reads) {
+      if (read.kind === "index-read") continue;
+      let expected = rule.sourceByOperand?.[read.operandIndex] ?? rule.sources ?? null;
+      if (!expected && (rule.equalitySources || []).includes(read.operandIndex)) expected = moveType;
+      if (!expected || expected === "unknown") continue;
+      read.refs.forEach((ref, componentIndex) => {
+        const storage = typeForRef(ref);
+        if (storage !== expected && storage !== "unknown") {
+          bitcasts.push({
+            kind: "read-bitcast",
+            operandIndex: read.operandIndex,
+            componentIndex,
+            valueId: ref.valueId,
+            component: ref.component,
+            from: storage,
+            to: expected
+          });
+        }
+      });
+    }
+    for (const write of writes) {
+      if (!rule.destination) continue;
+      Array.from(write.mask).forEach(component => {
+        const storage = typeForRef({
+          valueId: write.valueId,
+          component
+        });
+        if (storage !== rule.destination && storage !== "unknown") {
+          bitcasts.push({
+            kind: "result-bitcast",
+            operandIndex: write.operandIndex,
+            valueId: write.valueId,
+            component,
+            from: rule.destination,
+            to: storage
+          });
+        }
+      });
+    }
+    for (const operand of operandTypes) {
+      if (!operand.immediate || !["float32", "int32"].includes(operand.expectedType)) continue;
+      for (const immediate of operand.immediate) {
+        bitcasts.push({
+          kind: "immediate-bitcast",
+          operandIndex: operand.operandIndex,
+          component: immediate.component,
+          from: "uint32",
+          to: operand.expectedType,
+          uint32: immediate.uint32
+        });
+      }
+    }
+    instruction.typeInfo = {
+      kind: "instruction-types",
+      rule: rule.name,
+      resultType: rule.destination ?? moveType ?? "unknown",
+      conversion: rule.conversion || null,
+      conditionProjection: rule.conditionProjection || null,
+      operandTypes,
+      bitcasts
+    };
+  }
+  program.typeSystem = {
+    kind: "scalar-type-system",
+    scalarTypes: SCALAR_TYPES.slice(),
+    comparisonResult: "uint32-mask",
+    conditionProjection: "nonzero",
+    registerStorage: "component-granular"
+  };
+  return program;
+}
+
+export { SCALAR_TYPES, inferValueTypes };
+//# sourceMappingURL=inferValueTypes.js.map