@carbonenginejs/runtime-resource 0.12.2 → 0.13.0

package/dist/formats/webgl/core/glslBackendBodySet.js

@@ -0,0 +1,243 @@
+import { detailMapTransformFor } from '../../hlsl/core/detailMapFamily.js';
+import { localLightProfileNeutralTransformFor } from '../../hlsl/core/localLightFamily.js';
+
+/**
+ * Reshapes translated GLSL into the backend body set the Carbon container
+ * writer consumes.
+ *
+ * This is the WebGL counterpart of `formats/webgpu/core/effectBackendBodySet.js`
+ * and deliberately emits the same envelope, because `buildCarbonEffectContainer`
+ * is backend-neutral and should stay that way: it wants bodies, passes and
+ * translation units, and does not care what language the programs are in.
+ *
+ * Two facts drive the shape here, and neither is obvious:
+ *
+ * 1. **Body keys must be the permutation graph's, not this package's.** The
+ *    effect walk mints `body_${offset}_${size}` while the graph mints
+ *    `body${N}`. The container writer drives off graph variants, so a package
+ *    key reaching it would silently match nothing. The bridge is the
+ *    permutation index, not string surgery on either spelling.
+ *
+ * 2. **A translation unit is per pass, never per shader.** One DXBC vertex body
+ *    can lower to several different GLSL programs, because `pairVaryings`
+ *    zero-fills the varyings a paired pixel stage reads but the vertex stage
+ *    never writes - and that set differs per pass. Deduplicating programs by
+ *    bytecode would therefore collapse two genuinely different programs into
+ *    one. The unit signature includes the pass key for exactly this reason.
+ */
+
+/**
+ * Carbon's pass identity, matching the WebGPU emitter so both backends key
+ * passes identically.
+ *
+ * @param {string} techniqueName Technique name.
+ * @param {number} passIndex Pass index within the technique.
+ * @returns {string} Pass key.
+ */
+function passKeyFor(techniqueName, passIndex) {
+  return `${techniqueName}.pass${passIndex}`;
+}
+
+/**
+ * Stable signature for one pass translation unit.
+ *
+ * Includes `passKey` because pass-scoped varying pairing can make two units
+ * differ while their source bytecode is identical. Excludes diagnostics
+ * (`emitWarnings`, `hlsl2webgl`) because they describe the build, not the
+ * program, and would split otherwise-identical units.
+ *
+ * @param {object} unit Candidate unit.
+ * @returns {string} Signature.
+ */
+function unitSignature(unit) {
+  return JSON.stringify({
+    passKey: unit.passKey,
+    shaders: unit.shaders,
+    block: unit.block,
+    resourceTransforms: unit.resourceTransforms
+  });
+}
+
+/**
+ * Collect the per-stage data that has no home in Carbon reflection.
+ *
+ * Carbon records the logical resource and its register; these are the lowering
+ * decisions taken on top of that - fused sampler pairs, synthesised data
+ * textures and UBOs, dropped stub registers, and integer attributes lowered to
+ * float. The GLSL text declares them but does not say how to build or bind
+ * them, and reflection does not know they happened.
+ *
+ * Identifiers are kept. An earlier version of this comment claimed `cb{n}`,
+ * `s{n}` and `attr{n}` are functions of the register index alone and so need not
+ * be stored. They are not: the pixel stage remaps constant-buffer slot 0 to
+ * `cb7` (`DxbcGlslEmitter.js`, `pixelConstantBufferRemap`), so an identifier
+ * depends on the register *and* the stage, through a profile table. Deriving it
+ * downstream would re-implement that policy, and a divergence would show up as a
+ * uniform that never binds rather than as an error.
+ * See docs/contracts/constant-buffer-slots.md.
+ *
+ * @param {object} shader Translated shader record.
+ * @returns {object|null} Stage block data, or null when the stage adds nothing.
+ */
+function stageBlockFor(shader) {
+  const block = {};
+  if (Array.isArray(shader.bindings) && shader.bindings.length) {
+    block.bindings = shader.bindings;
+  }
+  if (Array.isArray(shader.stageInputs) && shader.stageInputs.length) {
+    block.stageInputs = shader.stageInputs;
+  }
+  if (shader.computeFragment) {
+    block.computeFragment = shader.computeFragment;
+  }
+  return Object.keys(block).length ? block : null;
+}
+
+/**
+ * Build the backend body set for a translated WebGL effect.
+ *
+ * @param {object} input Translation results.
+ * @param {Array<object>} input.bodies Body records from the effect walk.
+ * @param {Array<object>} input.stages Stage records from the effect walk.
+ * @param {Array<object>} input.shaders Translated shader records.
+ * @param {Array<object>} input.variants Export variants, carrying permutation indices.
+ * @param {object} input.permutationGraph Validated permutation graph.
+ * @returns {object} Backend body set in the container writer's shape.
+ */
+function buildGlslBackendBodySet(input) {
+  const {
+    bodies,
+    stages,
+    shaders,
+    variants,
+    permutationGraph
+  } = input;
+  const shadersByKey = new Map(shaders.map(shader => [shader.key, shader]));
+  const stagesByBody = new Map();
+  for (const stage of stages) {
+    if (!stagesByBody.has(stage.bodyKey)) stagesByBody.set(stage.bodyKey, []);
+    stagesByBody.get(stage.bodyKey).push(stage);
+  }
+
+  // Package body key -> the graph's own key, bridged through the permutation
+  // index rather than by reformatting either spelling.
+  const graphKeyByPackageKey = new Map();
+  const permutationIndexByPackageKey = new Map();
+  for (const variant of variants) {
+    if (graphKeyByPackageKey.has(variant.bodyKey)) continue;
+    const graphVariant = permutationGraph.variants[variant.permutationIndex];
+    if (!graphVariant) continue;
+    graphKeyByPackageKey.set(variant.bodyKey, graphVariant.bodyKey);
+    permutationIndexByPackageKey.set(variant.bodyKey, variant.permutationIndex);
+  }
+  const passUnits = [];
+  const unitKeyBySignature = new Map();
+  const emittedBodies = [];
+  for (const body of bodies) {
+    const graphBodyKey = graphKeyByPackageKey.get(body.key);
+    if (!graphBodyKey) continue;
+    const representativePermutationIndex = permutationIndexByPackageKey.get(body.key) ?? 0;
+    if (body.error) {
+      emittedBodies.push(Object.freeze({
+        bodyKey: graphBodyKey,
+        representativePermutationIndex,
+        status: "unsupported",
+        error: body.error,
+        passes: Object.freeze([])
+      }));
+      continue;
+    }
+    const passes = new Map();
+    for (const stage of stagesByBody.get(body.key) ?? []) {
+      const key = passKeyFor(stage.techniqueName, stage.passIndex);
+      if (!passes.has(key)) {
+        passes.set(key, {
+          passKey: key,
+          shaders: [],
+          block: {},
+          transforms: []
+        });
+      }
+      const shader = shadersByKey.get(stage.shaderKey);
+      // A stage the translator could not lower carries no program. The
+      // body still emits, with reflection intact and an empty slot, so
+      // the offset table stays dense and the failure is visible rather
+      // than absent.
+      if (!shader?.source) continue;
+      const entry = passes.get(key);
+
+      // The merge is a property of the pass, not of one stage: the block's
+      // transform section says how to build the array the GLSL samples.
+      // Built here rather than at translation time because the transform's
+      // identity includes the pass key, which the translator does not know.
+      if (shader.detailMapArray && !entry.hasDetailMapTransform) {
+        entry.hasDetailMapTransform = true;
+        entry.transforms.push(detailMapTransformFor(shader.detailMapArray, key));
+      }
+
+      // Same reasoning, different statement: this one records that the
+      // light profile array was dropped for a constant, so the resource
+      // the description still lists is accounted for rather than missing.
+      if (shader.lightProfileNeutral && !entry.hasLightProfileTransform) {
+        const transform = localLightProfileNeutralTransformFor(shader.lightProfileNeutral, key);
+        if (transform) {
+          entry.hasLightProfileTransform = true;
+          entry.transforms.push(transform);
+        }
+      }
+      entry.shaders.push({
+        key: `${key}.${stage.stageName}`,
+        stageName: stage.stageName,
+        stageType: stage.stageType,
+        code: shader.source
+      });
+      const stageBlock = stageBlockFor(shader);
+      if (stageBlock) entry.block[stage.stageName] = stageBlock;
+    }
+    const bodyPasses = [];
+    let translatedPassCount = 0;
+    for (const pass of passes.values()) {
+      if (!pass.shaders.length) continue;
+      translatedPassCount += 1;
+      const unit = {
+        passKey: pass.passKey,
+        shaders: pass.shaders,
+        block: Object.keys(pass.block).length ? pass.block : null,
+        resourceTransforms: pass.transforms
+      };
+      const signature = unitSignature(unit);
+      let unitKey = unitKeyBySignature.get(signature);
+      if (!unitKey) {
+        unitKey = `unit${passUnits.length}`;
+        unitKeyBySignature.set(signature, unitKey);
+        passUnits.push(Object.freeze({
+          key: unitKey,
+          ...unit
+        }));
+      }
+      bodyPasses.push(Object.freeze({
+        passKey: pass.passKey,
+        unitKey
+      }));
+    }
+    emittedBodies.push(Object.freeze({
+      bodyKey: graphBodyKey,
+      representativePermutationIndex,
+      status: translatedPassCount ? "translated" : "unsupported",
+      error: translatedPassCount ? null : "no pass produced a translated program",
+      passes: Object.freeze(bodyPasses)
+    }));
+  }
+  return Object.freeze({
+    format: "CJS_GLSL_BODY_SET",
+    formatVersion: 1,
+    bodyCount: emittedBodies.length,
+    translatedBodyCount: emittedBodies.filter(body => body.status === "translated").length,
+    passUnitCount: passUnits.length,
+    passUnits: Object.freeze(passUnits),
+    bodies: Object.freeze(emittedBodies)
+  });
+}
+
+export { buildGlslBackendBodySet };
+//# sourceMappingURL=glslBackendBodySet.js.map

package/dist/formats/webgl/core/glslBackendBodySet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glslBackendBodySet.js","sources":["../../../../../src/formats/webgl/core/glslBackendBodySet.js"],"sourcesContent":["import { detailMapTransformFor } from \"../../hlsl/core/detailMapFamily.js\";\nimport { localLightProfileNeutralTransformFor } from \"../../hlsl/core/localLightFamily.js\";\n\n/**\n * Reshapes translated GLSL into the backend body set the Carbon container\n * writer consumes.\n *\n * This is the WebGL counterpart of `formats/webgpu/core/effectBackendBodySet.js`\n * and deliberately emits the same envelope, because `buildCarbonEffectContainer`\n * is backend-neutral and should stay that way: it wants bodies, passes and\n * translation units, and does not care what language the programs are in.\n *\n * Two facts drive the shape here, and neither is obvious:\n *\n * 1. **Body keys must be the permutation graph's, not this package's.** The\n *    effect walk mints `body_${offset}_${size}` while the graph mints\n *    `body${N}`. The container writer drives off graph variants, so a package\n *    key reaching it would silently match nothing. The bridge is the\n *    permutation index, not string surgery on either spelling.\n *\n * 2. **A translation unit is per pass, never per shader.** One DXBC vertex body\n *    can lower to several different GLSL programs, because `pairVaryings`\n *    zero-fills the varyings a paired pixel stage reads but the vertex stage\n *    never writes - and that set differs per pass. Deduplicating programs by\n *    bytecode would therefore collapse two genuinely different programs into\n *    one. The unit signature includes the pass key for exactly this reason.\n */\n\n/**\n * Carbon's pass identity, matching the WebGPU emitter so both backends key\n * passes identically.\n *\n * @param {string} techniqueName Technique name.\n * @param {number} passIndex Pass index within the technique.\n * @returns {string} Pass key.\n */\nfunction passKeyFor(techniqueName, passIndex)\n{\n    return `${techniqueName}.pass${passIndex}`;\n}\n\n/**\n * Stable signature for one pass translation unit.\n *\n * Includes `passKey` because pass-scoped varying pairing can make two units\n * differ while their source bytecode is identical. Excludes diagnostics\n * (`emitWarnings`, `hlsl2webgl`) because they describe the build, not the\n * program, and would split otherwise-identical units.\n *\n * @param {object} unit Candidate unit.\n * @returns {string} Signature.\n */\nfunction unitSignature(unit)\n{\n    return JSON.stringify({\n        passKey: unit.passKey,\n        shaders: unit.shaders,\n        block: unit.block,\n        resourceTransforms: unit.resourceTransforms\n    });\n}\n\n/**\n * Collect the per-stage data that has no home in Carbon reflection.\n *\n * Carbon records the logical resource and its register; these are the lowering\n * decisions taken on top of that - fused sampler pairs, synthesised data\n * textures and UBOs, dropped stub registers, and integer attributes lowered to\n * float. The GLSL text declares them but does not say how to build or bind\n * them, and reflection does not know they happened.\n *\n * Identifiers are kept. An earlier version of this comment claimed `cb{n}`,\n * `s{n}` and `attr{n}` are functions of the register index alone and so need not\n * be stored. They are not: the pixel stage remaps constant-buffer slot 0 to\n * `cb7` (`DxbcGlslEmitter.js`, `pixelConstantBufferRemap`), so an identifier\n * depends on the register *and* the stage, through a profile table. Deriving it\n * downstream would re-implement that policy, and a divergence would show up as a\n * uniform that never binds rather than as an error.\n * See docs/contracts/constant-buffer-slots.md.\n *\n * @param {object} shader Translated shader record.\n * @returns {object|null} Stage block data, or null when the stage adds nothing.\n */\nfunction stageBlockFor(shader)\n{\n    const block = {};\n\n    if (Array.isArray(shader.bindings) && shader.bindings.length)\n    {\n        block.bindings = shader.bindings;\n    }\n    if (Array.isArray(shader.stageInputs) && shader.stageInputs.length)\n    {\n        block.stageInputs = shader.stageInputs;\n    }\n    if (shader.computeFragment)\n    {\n        block.computeFragment = shader.computeFragment;\n    }\n\n    return Object.keys(block).length ? block : null;\n}\n\n/**\n * Build the backend body set for a translated WebGL effect.\n *\n * @param {object} input Translation results.\n * @param {Array<object>} input.bodies Body records from the effect walk.\n * @param {Array<object>} input.stages Stage records from the effect walk.\n * @param {Array<object>} input.shaders Translated shader records.\n * @param {Array<object>} input.variants Export variants, carrying permutation indices.\n * @param {object} input.permutationGraph Validated permutation graph.\n * @returns {object} Backend body set in the container writer's shape.\n */\nexport function buildGlslBackendBodySet(input)\n{\n    const { bodies, stages, shaders, variants, permutationGraph } = input;\n\n    const shadersByKey = new Map(shaders.map((shader) => [ shader.key, shader ]));\n    const stagesByBody = new Map();\n    for (const stage of stages)\n    {\n        if (!stagesByBody.has(stage.bodyKey)) stagesByBody.set(stage.bodyKey, []);\n        stagesByBody.get(stage.bodyKey).push(stage);\n    }\n\n    // Package body key -> the graph's own key, bridged through the permutation\n    // index rather than by reformatting either spelling.\n    const graphKeyByPackageKey = new Map();\n    const permutationIndexByPackageKey = new Map();\n    for (const variant of variants)\n    {\n        if (graphKeyByPackageKey.has(variant.bodyKey)) continue;\n        const graphVariant = permutationGraph.variants[variant.permutationIndex];\n        if (!graphVariant) continue;\n        graphKeyByPackageKey.set(variant.bodyKey, graphVariant.bodyKey);\n        permutationIndexByPackageKey.set(variant.bodyKey, variant.permutationIndex);\n    }\n\n    const passUnits = [];\n    const unitKeyBySignature = new Map();\n    const emittedBodies = [];\n\n    for (const body of bodies)\n    {\n        const graphBodyKey = graphKeyByPackageKey.get(body.key);\n        if (!graphBodyKey) continue;\n\n        const representativePermutationIndex =\n            permutationIndexByPackageKey.get(body.key) ?? 0;\n\n        if (body.error)\n        {\n            emittedBodies.push(Object.freeze({\n                bodyKey: graphBodyKey,\n                representativePermutationIndex,\n                status: \"unsupported\",\n                error: body.error,\n                passes: Object.freeze([])\n            }));\n            continue;\n        }\n\n        const passes = new Map();\n        for (const stage of stagesByBody.get(body.key) ?? [])\n        {\n            const key = passKeyFor(stage.techniqueName, stage.passIndex);\n            if (!passes.has(key))\n            {\n                passes.set(key, { passKey: key, shaders: [], block: {}, transforms: [] });\n            }\n\n            const shader = shadersByKey.get(stage.shaderKey);\n            // A stage the translator could not lower carries no program. The\n            // body still emits, with reflection intact and an empty slot, so\n            // the offset table stays dense and the failure is visible rather\n            // than absent.\n            if (!shader?.source) continue;\n\n            const entry = passes.get(key);\n\n            // The merge is a property of the pass, not of one stage: the block's\n            // transform section says how to build the array the GLSL samples.\n            // Built here rather than at translation time because the transform's\n            // identity includes the pass key, which the translator does not know.\n            if (shader.detailMapArray && !entry.hasDetailMapTransform)\n            {\n                entry.hasDetailMapTransform = true;\n                entry.transforms.push(detailMapTransformFor(shader.detailMapArray, key));\n            }\n\n            // Same reasoning, different statement: this one records that the\n            // light profile array was dropped for a constant, so the resource\n            // the description still lists is accounted for rather than missing.\n            if (shader.lightProfileNeutral && !entry.hasLightProfileTransform)\n            {\n                const transform = localLightProfileNeutralTransformFor(shader.lightProfileNeutral, key);\n                if (transform)\n                {\n                    entry.hasLightProfileTransform = true;\n                    entry.transforms.push(transform);\n                }\n            }\n\n            entry.shaders.push({\n                key: `${key}.${stage.stageName}`,\n                stageName: stage.stageName,\n                stageType: stage.stageType,\n                code: shader.source\n            });\n\n            const stageBlock = stageBlockFor(shader);\n            if (stageBlock) entry.block[stage.stageName] = stageBlock;\n        }\n\n        const bodyPasses = [];\n        let translatedPassCount = 0;\n\n        for (const pass of passes.values())\n        {\n            if (!pass.shaders.length) continue;\n            translatedPassCount += 1;\n\n            const unit = {\n                passKey: pass.passKey,\n                shaders: pass.shaders,\n                block: Object.keys(pass.block).length ? pass.block : null,\n                resourceTransforms: pass.transforms\n            };\n            const signature = unitSignature(unit);\n            let unitKey = unitKeyBySignature.get(signature);\n\n            if (!unitKey)\n            {\n                unitKey = `unit${passUnits.length}`;\n                unitKeyBySignature.set(signature, unitKey);\n                passUnits.push(Object.freeze({ key: unitKey, ...unit }));\n            }\n\n            bodyPasses.push(Object.freeze({ passKey: pass.passKey, unitKey }));\n        }\n\n        emittedBodies.push(Object.freeze({\n            bodyKey: graphBodyKey,\n            representativePermutationIndex,\n            status: translatedPassCount ? \"translated\" : \"unsupported\",\n            error: translatedPassCount ? null : \"no pass produced a translated program\",\n            passes: Object.freeze(bodyPasses)\n        }));\n    }\n\n    return Object.freeze({\n        format: \"CJS_GLSL_BODY_SET\",\n        formatVersion: 1,\n        bodyCount: emittedBodies.length,\n        translatedBodyCount: emittedBodies.filter((body) => body.status === \"translated\").length,\n        passUnitCount: passUnits.length,\n        passUnits: Object.freeze(passUnits),\n        bodies: Object.freeze(emittedBodies)\n    });\n}\n\nexport default buildGlslBackendBodySet;\n"],"names":["passKeyFor","techniqueName","passIndex","unitSignature","unit","JSON","stringify","passKey","shaders","block","resourceTransforms","stageBlockFor","shader","Array","isArray","bindings","length","stageInputs","computeFragment","Object","keys","buildGlslBackendBodySet","input","bodies","stages","variants","permutationGraph","shadersByKey","Map","map","key","stagesByBody","stage","has","bodyKey","set","get","push","graphKeyByPackageKey","permutationIndexByPackageKey","variant","graphVariant","permutationIndex","passUnits","unitKeyBySignature","emittedBodies","body","graphBodyKey","representativePermutationIndex","error","freeze","status","passes","transforms","shaderKey","source","entry","detailMapArray","hasDetailMapTransform","detailMapTransformFor","lightProfileNeutral","hasLightProfileTransform","transform","localLightProfileNeutralTransformFor","stageName","stageType","code","stageBlock","bodyPasses","translatedPassCount","pass","values","signature","unitKey","format","formatVersion","bodyCount","translatedBodyCount","filter","passUnitCount"],"mappings":"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"}

package/dist/formats/webgl/core/{cewgCompleteness.js → glslEffectCompleteness.js}

@@ -1,81 +1,85 @@
-/**
- * Inspects CEWG stage records for complete WebGL2 raster passes.
- *
- * Geometry and compute stages are not raster-pair members. A raster pass is
- * complete only when both its vertex and pixel records exist and their shared
- * shader records contain successful translated source.
- *
- * @param {object[]} stages CEWG stage records.
- * @param {object[]} shaders CEWG translated shader records.
- * @returns {{ expectedPassCount: number, completePassCount: number, incompletePasses: object[] }}
- */
-function inspectCewgRasterCompleteness(stages, shaders) {
-  const shaderMap = new Map((shaders || []).map(shader => [shader.key, shader]));
-  const usesSharedShaders = Array.isArray(shaders);
-  const groups = new Map();
-  for (const stage of stages || []) {
-    if (stage.stageName !== "vertex" && stage.stageName !== "pixel") continue;
-    const key = [stage.bodyKey || "selected", stage.techniqueName || "Main", Number.isInteger(stage.passIndex) ? stage.passIndex : 0].join(":");
-    let group = groups.get(key);
-    if (!group) {
-      group = {
-        key,
-        bodyKey: stage.bodyKey || "selected",
-        techniqueName: stage.techniqueName || "Main",
-        passIndex: Number.isInteger(stage.passIndex) ? stage.passIndex : 0,
-        vertex: null,
-        pixel: null,
-        duplicateStages: []
-      };
-      groups.set(key, group);
-    }
-    if (group[stage.stageName]) {
-      group.duplicateStages.push(stage.stageName);
-    }
-    group[stage.stageName] = stage;
-  }
-  const incompletePasses = [];
-  let completePassCount = 0;
-  for (const group of groups.values()) {
-    const missingStages = [];
-    const unavailableStages = [];
-    for (const stageName of ["vertex", "pixel"]) {
-      const stage = group[stageName];
-      if (!stage) {
-        missingStages.push(stageName);
-        continue;
-      }
-      const shader = usesSharedShaders ? shaderMap.get(stage.shaderKey) : stage;
-      if (!shader?.hlsl2webgl?.ok || !shader.source) {
-        unavailableStages.push({
-          stageName,
-          stageKey: stage.key,
-          shaderKey: stage.shaderKey,
-          excluded: shader?.excluded || null,
-          reason: shader?.hlsl2webgl?.validationError || shader?.hlsl2webgl?.reason || shader?.hlsl2webgl?.error || shader?.excluded?.reason || "translated source is unavailable"
-        });
-      }
-    }
-    if (!missingStages.length && !unavailableStages.length && !group.duplicateStages.length) {
-      completePassCount += 1;
-      continue;
-    }
-    incompletePasses.push({
-      key: group.key,
-      bodyKey: group.bodyKey,
-      techniqueName: group.techniqueName,
-      passIndex: group.passIndex,
-      missingStages,
-      unavailableStages,
-      duplicateStages: [...new Set(group.duplicateStages)].sort()
-    });
-  }
-  return {
-    expectedPassCount: groups.size,
-    completePassCount,
-    incompletePasses
-  };
-}
-
-export { inspectCewgRasterCompleteness };
-//# sourceMappingURL=cewgCompleteness.js.map
+/**
+ * Inspects Carbon WebGL stage records for complete WebGL2 raster passes.
+ *
+ * Geometry and compute stages are not raster-pair members. A raster pass is
+ * complete only when both its vertex and pixel records exist and their shared
+ * shader records contain successful translated source.
+ *
+ * Stages reference shaders by key. The older shape that inlined the shader into
+ * the stage record has no producer left — both callers pass a shader table, and
+ * the container decoder always builds one — so the branch that supported it is
+ * gone rather than kept as an untested path.
+ *
+ * @param {object[]} stages Stage records.
+ * @param {object[]} shaders Translated shader records.
+ * @returns {{ expectedPassCount: number, completePassCount: number, incompletePasses: object[] }}
+ */
+function inspectRasterCompleteness(stages, shaders) {
+  const shaderMap = new Map((shaders || []).map(shader => [shader.key, shader]));
+  const groups = new Map();
+  for (const stage of stages || []) {
+    if (stage.stageName !== "vertex" && stage.stageName !== "pixel") continue;
+    const key = [stage.bodyKey || "selected", stage.techniqueName || "Main", Number.isInteger(stage.passIndex) ? stage.passIndex : 0].join(":");
+    let group = groups.get(key);
+    if (!group) {
+      group = {
+        key,
+        bodyKey: stage.bodyKey || "selected",
+        techniqueName: stage.techniqueName || "Main",
+        passIndex: Number.isInteger(stage.passIndex) ? stage.passIndex : 0,
+        vertex: null,
+        pixel: null,
+        duplicateStages: []
+      };
+      groups.set(key, group);
+    }
+    if (group[stage.stageName]) {
+      group.duplicateStages.push(stage.stageName);
+    }
+    group[stage.stageName] = stage;
+  }
+  const incompletePasses = [];
+  let completePassCount = 0;
+  for (const group of groups.values()) {
+    const missingStages = [];
+    const unavailableStages = [];
+    for (const stageName of ["vertex", "pixel"]) {
+      const stage = group[stageName];
+      if (!stage) {
+        missingStages.push(stageName);
+        continue;
+      }
+      const shader = shaderMap.get(stage.shaderKey);
+      if (!shader?.hlsl2webgl?.ok || !shader.source) {
+        unavailableStages.push({
+          stageName,
+          stageKey: stage.key,
+          shaderKey: stage.shaderKey,
+          excluded: shader?.excluded || null,
+          reason: shader?.hlsl2webgl?.validationError || shader?.hlsl2webgl?.reason || shader?.hlsl2webgl?.error || shader?.excluded?.reason || "translated source is unavailable"
+        });
+      }
+    }
+    if (!missingStages.length && !unavailableStages.length && !group.duplicateStages.length) {
+      completePassCount += 1;
+      continue;
+    }
+    incompletePasses.push({
+      key: group.key,
+      bodyKey: group.bodyKey,
+      techniqueName: group.techniqueName,
+      passIndex: group.passIndex,
+      missingStages,
+      unavailableStages,
+      duplicateStages: [...new Set(group.duplicateStages)].sort()
+    });
+  }
+  return {
+    expectedPassCount: groups.size,
+    completePassCount,
+    incompletePasses
+  };
+}
+
+export { inspectRasterCompleteness };
+//# sourceMappingURL=glslEffectCompleteness.js.map

package/dist/formats/webgl/core/glslEffectCompleteness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glslEffectCompleteness.js","sources":["../../../../../src/formats/webgl/core/glslEffectCompleteness.js"],"sourcesContent":["import { LOCAL_LIGHT_RESOURCE_NAMES } from \"../../hlsl/core/localLightFamily.js\";\n\n/**\n * Light-record fields naming the Carbon registers a lowering replaced.\n *\n * A lowered family declares one synthesised uniform, so its own `registerIndex`\n * covers only one of the sources; the record carries the rest.\n */\n/** Transform stage names, in the shared codec's vocabulary, as WebGL names them. */\nconst TRANSFORM_STAGE_NAMES = Object.freeze({\n  vertex: \"vertex\",\n  fragment: \"pixel\",\n  compute: \"compute\"\n});\n\nconst LOCAL_LIGHT_RECORD_REGISTERS = Object.freeze([\n  \"lightIndexRegister\",\n  \"lightDataRegister\",\n  \"lightProfileRegister\"\n]);\n\n/**\n * Inspects Carbon WebGL stage records for complete WebGL2 raster passes.\n *\n * Geometry and compute stages are not raster-pair members. A raster pass is\n * complete only when both its vertex and pixel records exist and their shared\n * shader records contain successful translated source.\n *\n * Stages reference shaders by key. The older shape that inlined the shader into\n * the stage record has no producer left — both callers pass a shader table, and\n * the container decoder always builds one — so the branch that supported it is\n * gone rather than kept as an untested path.\n *\n * @param {object[]} stages Stage records.\n * @param {object[]} shaders Translated shader records.\n * @returns {{ expectedPassCount: number, completePassCount: number, incompletePasses: object[] }}\n */\nexport function inspectRasterCompleteness(stages, shaders)\n{\n    const shaderMap = new Map((shaders || []).map((shader) => [ shader.key, shader ]));\n    const groups = new Map();\n\n    for (const stage of stages || [])\n    {\n        if (stage.stageName !== \"vertex\" && stage.stageName !== \"pixel\") continue;\n\n        const key = [\n            stage.bodyKey || \"selected\",\n            stage.techniqueName || \"Main\",\n            Number.isInteger(stage.passIndex) ? stage.passIndex : 0\n        ].join(\":\");\n        let group = groups.get(key);\n        if (!group)\n        {\n            group = {\n                key,\n                bodyKey: stage.bodyKey || \"selected\",\n                techniqueName: stage.techniqueName || \"Main\",\n                passIndex: Number.isInteger(stage.passIndex) ? stage.passIndex : 0,\n                vertex: null,\n                pixel: null,\n                duplicateStages: []\n            };\n            groups.set(key, group);\n        }\n        if (group[stage.stageName])\n        {\n            group.duplicateStages.push(stage.stageName);\n        }\n        group[stage.stageName] = stage;\n    }\n\n    const incompletePasses = [];\n    let completePassCount = 0;\n\n    for (const group of groups.values())\n    {\n        const missingStages = [];\n        const unavailableStages = [];\n\n        for (const stageName of [ \"vertex\", \"pixel\" ])\n        {\n            const stage = group[stageName];\n            if (!stage)\n            {\n                missingStages.push(stageName);\n                continue;\n            }\n\n            const shader = shaderMap.get(stage.shaderKey);\n            if (!shader?.hlsl2webgl?.ok || !shader.source)\n            {\n                unavailableStages.push({\n                    stageName,\n                    stageKey: stage.key,\n                    shaderKey: stage.shaderKey,\n                    excluded: shader?.excluded || null,\n                    reason: shader?.hlsl2webgl?.validationError\n            || shader?.hlsl2webgl?.reason\n            || shader?.hlsl2webgl?.error\n            || shader?.excluded?.reason\n            || \"translated source is unavailable\"\n                });\n            }\n        }\n\n        if (!missingStages.length && !unavailableStages.length && !group.duplicateStages.length)\n        {\n            completePassCount += 1;\n            continue;\n        }\n\n        incompletePasses.push({\n            key: group.key,\n            bodyKey: group.bodyKey,\n            techniqueName: group.techniqueName,\n            passIndex: group.passIndex,\n            missingStages,\n            unavailableStages,\n            duplicateStages: [ ...new Set(group.duplicateStages) ].sort()\n        });\n    }\n\n    return {\n        expectedPassCount: groups.size,\n        completePassCount,\n        incompletePasses\n    };\n}\n\n/**\n * Checks the host-side routing contract emitted for compute-as-fragment\n * programs. A boolean marker is insufficient: the runtime needs the original\n * dispatch shape, dispatch-origin uniform, and every UAV render-target route.\n */\nexport function isComputeFragmentContract(value)\n{\n    if (!value || typeof value !== \"object\" || Array.isArray(value)) return false;\n    if (!Array.isArray(value.threadGroup)\n    || value.threadGroup.length !== 3\n    || value.threadGroup.some((item) => !Number.isSafeInteger(item) || item < 1))\n    {\n        return false;\n    }\n    if (value.dispatchOriginUniform !== null\n    && (typeof value.dispatchOriginUniform !== \"string\" || !value.dispatchOriginUniform)) return false;\n    if (!Array.isArray(value.uavOutputs) || !value.uavOutputs.length) return false;\n\n    const locations = new Set();\n    const names = new Set();\n    const routes = new Set();\n    for (const output of value.uavOutputs)\n    {\n        if (!output || typeof output !== \"object\") return false;\n        if (!Number.isSafeInteger(output.register) || output.register < 0) return false;\n        if (output.slice !== null && (!Number.isSafeInteger(output.slice) || output.slice < 0)) return false;\n        if (!Number.isSafeInteger(output.location) || output.location < 0 || locations.has(output.location)) return false;\n        if (typeof output.glslName !== \"string\" || !output.glslName || names.has(output.glslName)) return false;\n        const route = `${output.register}:${output.slice === null ? \"dynamic\" : output.slice}`;\n        if (routes.has(route)) return false;\n        locations.add(output.location);\n        names.add(output.glslName);\n        routes.add(route);\n    }\n    return true;\n}\n\n/**\n * Checks a declared resource transform against the bindings it claims to have\n * rewritten.\n *\n * A transform says N described resources became one array binding. That claim is\n * only meaningful if the shader agrees: the carrier - layer 0's register, whose\n * slot the array occupies - must be declared, and every merged-away input must\n * not be. A transform naming registers the shader still binds separately has not\n * happened; a carrier the shader never declares cannot be bound.\n *\n * engine-webgpu makes equivalent checks when it realizes a package, and they are\n * mostly about the emitted artefacts rather than the device. WebGL has no engine\n * to make them, so a container can currently ship a transform nothing agrees\n * with. Checking here covers both, and covers WebGL at the only point that\n * exists.\n *\n * @param {object} stage Decoded stage record.\n * @param {object} shader Decoded shader record.\n * @param {object[]} errors Collected integrity errors.\n */\nfunction checkResourceTransforms(stage, shader, errors)\n{\n    const all = Array.isArray(stage.transforms) ? stage.transforms : [];\n    // A transform belongs to a pass but rewrites one stage. The record names that\n    // stage in WGSL's vocabulary, where WebGL's is \"pixel\" - the block codec is\n    // shared between the backends and restores the field from one set of\n    // defaults. Checking a vertex stage against a fragment transform reports\n    // every pass twice and says nothing: measured on a shipped effect, that was\n    // 48 carrier-undeclared reports on a container with nothing wrong with it.\n    const transforms = all.filter(\n        (transform) => TRANSFORM_STAGE_NAMES[transform?.stage] === stage.stageName\n    );\n    if (!transforms.length) return;\n\n    const declared = new Set(\n        (Array.isArray(shader.bindings) ? shader.bindings : [])\n            .filter((binding) => Number.isSafeInteger(binding?.registerIndex))\n            .map((binding) => binding.registerIndex)\n    );\n\n    for (const transform of transforms)\n    {\n        const inputs = Array.isArray(transform?.inputs) ? transform.inputs : [];\n\n        // Not every transform is a merge. `local-light-profile-neutral` records\n        // one resource replaced by a constant, so it has exactly one input and\n        // no carrier - the checks below would read that as an underfilled merge\n        // whose carrier went missing, which is the opposite of what happened.\n        if (transform?.family === \"local-light-profile-neutral\")\n        {\n            if (inputs.length !== 1)\n            {\n                addIntegrityError(\n                    errors,\n                    \"resource_transform_neutral_arity\",\n                    `Stage ${stage.key} transform ${transform?.id || \"<missing>\"} neutralises ${inputs.length} resource(s); exactly one is expected`,\n                    { stageKey: stage.key, transformId: transform?.id || null }\n                );\n                continue;\n            }\n\n            const [ neutralised ] = inputs;\n            if (Number.isSafeInteger(neutralised.registerIndex)\n                && declared.has(neutralised.registerIndex))\n            {\n                addIntegrityError(\n                    errors,\n                    \"resource_transform_neutral_still_bound\",\n                    `Stage ${stage.key} transform ${transform.id} neutralised register ${neutralised.registerIndex}, but the shader still declares it`,\n                    {\n                        stageKey: stage.key,\n                        transformId: transform.id,\n                        register: neutralised.registerIndex\n                    }\n                );\n            }\n            continue;\n        }\n\n        if (inputs.length < 2)\n        {\n            addIntegrityError(\n                errors,\n                \"resource_transform_underfilled\",\n                `Stage ${stage.key} declares transform ${transform?.id || \"<missing>\"} with ${inputs.length} input(s); a merge needs at least two`,\n                { stageKey: stage.key, transformId: transform?.id || null }\n            );\n            continue;\n        }\n\n        // Layers address array slices, so they must be the whole range 0..n-1.\n        const layers = inputs.map((input) => input.layer);\n        if (layers.some((layer, index) => layer !== index))\n        {\n            addIntegrityError(\n                errors,\n                \"resource_transform_layer_gap\",\n                `Stage ${stage.key} transform ${transform.id} has layers ${layers.join(\", \")} rather than a contiguous range`,\n                { stageKey: stage.key, transformId: transform.id, layers }\n            );\n            continue;\n        }\n\n        const [ carrier, ...merged ] = inputs;\n        if (Number.isSafeInteger(carrier.registerIndex)\n            && !declared.has(carrier.registerIndex))\n        {\n            addIntegrityError(\n                errors,\n                \"resource_transform_carrier_undeclared\",\n                `Stage ${stage.key} transform ${transform.id} names carrier register ${carrier.registerIndex}, which the shader does not declare`,\n                {\n                    stageKey: stage.key,\n                    transformId: transform.id,\n                    register: carrier.registerIndex\n                }\n            );\n        }\n\n        for (const input of merged)\n        {\n            if (!Number.isSafeInteger(input.registerIndex)) continue;\n            if (!declared.has(input.registerIndex)) continue;\n\n            addIntegrityError(\n                errors,\n                \"resource_transform_input_still_bound\",\n                `Stage ${stage.key} transform ${transform.id} merged register ${input.registerIndex} away, but the shader still declares it`,\n                {\n                    stageKey: stage.key,\n                    transformId: transform.id,\n                    register: input.registerIndex\n                }\n            );\n        }\n    }\n}\n\n/**\n * Reports a local-light family that the shipped GLSL neither binds nor explains.\n *\n * The container deliberately says two things at once. The Carbon description\n * records are the authored name and register authority and are never rewritten\n * by a lowering; the GLSL declares whatever the lowering actually produced; and\n * the per-pass backend block is the delta that ties one to the other. That only\n * holds while the delta is complete.\n *\n * This cannot be a general \"every described resource is declared\" rule. Carbon\n * describes resources a shader may simply not use, and the emitter only declares\n * what it samples, so an undeclared resource is ordinary. Measured on a shipped\n * effect, the general form reported 96 such resources on a perfectly good build.\n *\n * What is checkable is a family the packager is known to rewrite. Local lights\n * are two structured buffers plus an optional profile texture; WebGL2 has no\n * structured buffers, so the shader either lowers them - leaving a light record\n * naming the source registers - or it cannot bind lights at all. A described\n * family with no declaration and no record is the one case that is definitely\n * wrong rather than merely unused.\n *\n * `localLights: \"drop\"` produces exactly that: the emitter removes the\n * declarations *and* their binding records, so nothing reaches the block while\n * the description still lists all three. That mode is a diagnostic aid, not a\n * shipping mode, and this is what says so instead of writing a container that\n * quietly disagrees with itself.\n *\n * @param {object} stage Decoded stage record.\n * @param {object} shader Decoded shader record.\n * @param {object[]} errors Collected integrity errors.\n */\nfunction checkLocalLightFamilyAccounted(stage, shader, errors)\n{\n    const manifestBindings = Array.isArray(stage.manifest?.bindings)\n        ? stage.manifest.bindings\n        : [];\n    const family = manifestBindings.filter((entry) => entry?.kind === \"resource\"\n        && LOCAL_LIGHT_RESOURCE_NAMES.includes(entry.name));\n    if (family.length < 2) return;\n\n    const bindings = Array.isArray(shader.bindings) ? shader.bindings : [];\n    const accounted = new Set();\n    for (const binding of bindings)\n    {\n        if (Number.isSafeInteger(binding?.registerIndex))\n        {\n            accounted.add(binding.registerIndex);\n        }\n        for (const key of LOCAL_LIGHT_RECORD_REGISTERS)\n        {\n            if (Number.isSafeInteger(binding?.[key])) accounted.add(binding[key]);\n        }\n    }\n\n    // A resource transform accounts for a register just as a binding record\n    // does. `local-light-profile-neutral` names a resource replaced by a\n    // constant: nothing is bound, so no binding can carry it, and the transform\n    // is the only place the decision is written down.\n    for (const transform of Array.isArray(stage.transforms) ? stage.transforms : [])\n    {\n        if (transform?.family !== \"local-light-profile-neutral\") continue;\n        for (const input of Array.isArray(transform.inputs) ? transform.inputs : [])\n        {\n            if (Number.isSafeInteger(input?.registerIndex)) accounted.add(input.registerIndex);\n        }\n    }\n\n    // Any orphan is a fault, not only a wholly missing family. A lowering that\n    // declares its synthesised uniform but forgets to record the other source\n    // registers loses them just as completely, and only the record can say where\n    // they went.\n    const orphans = family\n        .filter((entry) => Number.isSafeInteger(entry.registerIndex)\n            && !accounted.has(entry.registerIndex))\n        .map((entry) => entry.registerIndex);\n    if (!orphans.length) return;\n\n    addIntegrityError(\n        errors,\n        \"unlowered_local_light_family\",\n        `Stage ${stage.key} describes a local-light family at registers ${orphans.join(\", \")} that the shader neither declares nor lowers`,\n        {\n            stageKey: stage.key,\n            shaderKey: stage.shaderKey || null,\n            registers: orphans\n        }\n    );\n}\n\n/**\n * Inspects a decoded effect container for the contracts a WebGL 2 runtime needs.\n *\n * This replaces `inspectGlslContainerIntegrity`, which took the chunk package's\n * INFO, META and GLSL records. Most of that function was bookkeeping about the\n * chunk format rather than about the effect, and it is not carried across:\n *\n * - **Envelope and kind checks** (`invalid_package_envelope`,\n *   `unsupported_package_kind`) asserted the magic strings `Carbon WebGL` /\n *   `CARBON_WEBGL_GLSL_SET` and a `packageKind` naming the chunk layout. They described\n *   the container they were written in, and that container is gone.\n * - **Declared-count checks** (`invalid_declared_count`, `declared_count_mismatch`,\n *   `declared_partial_package` — twelve fields) compared a header counter against\n *   the graph it summarised. A header can lie about the body; that is why the\n *   check existed. Nothing here declares a count, so there is nothing to lie.\n * - **Cross-copy reconciliation** (`package_mode_mismatch`,\n *   `package_selection_mismatch`, `variant_metadata_mismatch`,\n *   `failed_metadata_body`, `missing_metadata_*`, `orphan_metadata_*`) checked\n *   that META and GLSL agreed. Two independently-encoded copies of one fact can\n *   drift. The container stores one copy, so the bug class is gone rather than\n *   unchecked.\n * - **`missing_glsl_set` / `missing_metadata` / `invalid_core_chunk_cardinality`**\n *   asked whether a chunk was present exactly once. The reader now refuses to\n *   construct at all on a malformed container, which is strictly stronger.\n * - **`orphan_shader` / `duplicate_shader_key`** are unreachable by construction:\n *   the decoder pools shaders by program text and emits a key per pool, so a\n *   shader exists only because a stage referenced it.\n *\n * What survives is everything that describes the translation: which stages a\n * pass may contain, whether a declared stage carries a program, whether a\n * compute stage was adapted to the fragment host, and whether the emitted GLSL\n * actually declares the inputs and samplers the reflection promises. Those are\n * properties of the shader, not of the file it arrived in.\n *\n * @param {{stages:object[], shaders:object[]}} decoded Decoded container graph.\n * @returns {{ok:boolean, errors:object[]}} Integrity report.\n */\nexport function inspectGlslContainerIntegrity(decoded)\n{\n    const errors = [];\n    const stages = decoded?.stages;\n    const shaders = decoded?.shaders;\n\n    if (!Array.isArray(stages) || !Array.isArray(shaders))\n    {\n        addIntegrityError(\n            errors,\n            \"missing_container_graph\",\n            \"Container integrity requires decoded stage and shader arrays\"\n        );\n        return { ok: false, errors };\n    }\n\n    const shaderMap = new Map(shaders.map((shader) => [ shader.key, shader ]));\n    const passGroups = new Map();\n\n    for (const stage of stages)\n    {\n        const passKey = `${stage.bodyKey}.${stage.techniqueName}.pass${stage.passIndex}`;\n        if (!passGroups.has(passKey)) passGroups.set(passKey, []);\n        passGroups.get(passKey).push(stage);\n\n        const shader = shaderMap.get(stage.shaderKey);\n\n        if (![ \"vertex\", \"pixel\", \"compute\" ].includes(stage.stageName))\n        {\n            addIntegrityError(\n                errors,\n                \"unsupported_stage\",\n                `Stage ${stage.key} uses unsupported WebGL2 stage ${stage.stageName}`,\n                { stageKey: stage.key, stageName: stage.stageName || null }\n            );\n            continue;\n        }\n\n        if (!shader?.hlsl2webgl?.ok || !shader.source)\n        {\n            addIntegrityError(\n                errors,\n                \"unavailable_stage_shader\",\n                `Stage ${stage.key} has no successful translated source`,\n                { stageKey: stage.key, shaderKey: stage.shaderKey || null }\n            );\n            continue;\n        }\n\n        if (stage.stageName === \"compute\")\n        {\n            const computeIssue = computeFragmentShaderIssue(shader);\n            if (computeIssue)\n            {\n                addIntegrityError(\n                    errors,\n                    \"unadapted_compute_stage\",\n                    `Compute stage ${stage.key} ${computeIssue}`,\n                    { stageKey: stage.key, shaderKey: stage.shaderKey || null }\n                );\n            }\n        }\n\n        if (stage.manifest) validateShaderRuntimeContract(shader, stage, stage.manifest, errors);\n    }\n\n    for (const [ passKey, passStages ] of passGroups)\n    {\n        const counts = { vertex: 0, pixel: 0, compute: 0, other: 0 };\n        for (const stage of passStages)\n        {\n            if (stage.stageName in counts && stage.stageName !== \"other\") counts[stage.stageName] += 1;\n            else counts.other += 1;\n        }\n        const raster = counts.vertex === 1 && counts.pixel === 1 && counts.compute === 0 && counts.other === 0;\n        const compute = counts.vertex === 0 && counts.pixel === 0 && counts.compute === 1 && counts.other === 0;\n        if (!raster && !compute)\n        {\n            const duplicate = Object.values(counts).some((count) => count > 1);\n            const mixed = counts.compute > 0 && (counts.vertex > 0 || counts.pixel > 0);\n            const code = duplicate || mixed\n                ? \"invalid_pass_stage_family\"\n                : counts.other > 0\n                    ? \"unsupported_pass_stage_family\"\n                    : \"incomplete_pass_stage_family\";\n            addIntegrityError(\n                errors,\n                code,\n                `Pass ${passKey} must contain exactly one vertex/pixel pair or one compute stage`,\n                { passKey, counts }\n            );\n        }\n    }\n\n    return { ok: errors.length === 0, errors };\n}\n\nfunction computeFragmentShaderIssue(shader)\n{\n    const contract = shader?.computeFragment;\n    if (!isComputeFragmentContract(contract)) return \"has no valid compute-fragment host contract\";\n    if (!Array.isArray(shader.bindings)) return \"has no binding metadata for its compute-fragment host contract\";\n\n    const bindings = shader.bindings.filter((binding) => binding?.kind === \"uavTexture\");\n    if (bindings.length !== contract.uavOutputs.length)\n    {\n        return \"compute-fragment UAV routes do not match its binding metadata\";\n    }\n    for (const output of contract.uavOutputs)\n    {\n        if (!bindings.some((binding) => binding.registerIndex === output.register\n      && binding.slice === output.slice\n      && binding.location === output.location\n      && binding.name === output.glslName))\n        {\n            return `compute-fragment route ${output.glslName} does not match its binding metadata`;\n        }\n        const declaration = new RegExp(\n            `layout\\\\s*\\\\(\\\\s*location\\\\s*=\\\\s*${output.location}\\\\s*\\\\)\\\\s*out\\\\b[^;]*\\\\b${escapeRegExp(output.glslName)}\\\\s*;`\n        );\n        if (!declaration.test(shader.source))\n        {\n            return `compute-fragment route ${output.glslName} is not declared at output location ${output.location}`;\n        }\n    }\n\n    const dispatchBindings = shader.bindings.filter((binding) => binding?.kind === \"dispatchUniform\");\n    if (contract.dispatchOriginUniform === null)\n    {\n        if (dispatchBindings.length) return \"declares unexpected dispatch-origin binding metadata\";\n    }\n    else\n    {\n        if (dispatchBindings.length !== 1 || dispatchBindings[0].name !== contract.dispatchOriginUniform)\n        {\n            return \"dispatch-origin uniform does not match its binding metadata\";\n        }\n        const declaration = new RegExp(`uniform\\\\s+ivec3\\\\s+${escapeRegExp(contract.dispatchOriginUniform)}\\\\s*;`);\n        if (!declaration.test(shader.source)) return \"dispatch-origin uniform is not declared in translated source\";\n    }\n    return null;\n}\n\nfunction validateShaderRuntimeContract(shader, stage, manifestStage, errors)\n{\n    if (stage.stageName === \"vertex\" && Array.isArray(shader.stageInputs))\n    {\n        const registers = new Set();\n        const names = new Set();\n        const expectedInputs = (manifestStage.pipelineInputs || []).filter((input) => Number(input?.usedMask || 0) !== 0);\n        for (const input of shader.stageInputs)\n        {\n            if (!Number.isSafeInteger(input?.register)\n        || input.register < 0\n        || registers.has(input.register)\n        || typeof input.name !== \"string\"\n        || !input.name\n        || names.has(input.name))\n            {\n                addIntegrityError(\n                    errors,\n                    \"invalid_vertex_input_contract\",\n                    `Vertex shader ${shader.key} has an invalid or duplicate emitted input`,\n                    { stageKey: stage.key, shaderKey: shader.key }\n                );\n                continue;\n            }\n            registers.add(input.register);\n            names.add(input.name);\n            if (!expectedInputs.some((entry) => entry.registerIndex === input.register\n        && normalizeSemanticName(entry.usageName) === normalizeSemanticName(input.semanticName)\n        && entry.usageIndex === input.semanticIndex))\n            {\n                addIntegrityError(\n                    errors,\n                    \"vertex_input_contract_mismatch\",\n                    `Vertex shader ${shader.key} input ${input.name} is not present in its manifest pipeline inputs`,\n                    { stageKey: stage.key, shaderKey: shader.key, register: input.register }\n                );\n            }\n            const declaration = new RegExp(`\\\\bin\\\\b[^;]*\\\\b${escapeRegExp(input.name)}\\\\s*;`);\n            if (!declaration.test(shader.source))\n            {\n                addIntegrityError(\n                    errors,\n                    \"vertex_input_declaration_mismatch\",\n                    `Vertex shader ${shader.key} input ${input.name} is not declared in translated source`,\n                    { stageKey: stage.key, shaderKey: shader.key, inputName: input.name }\n                );\n            }\n        }\n    }\n\n    checkLocalLightFamilyAccounted(stage, shader, errors);\n    checkResourceTransforms(stage, shader, errors);\n\n    if (!Array.isArray(shader.bindings)) return;\n    const manifestBindings = Array.isArray(manifestStage.bindings) ? manifestStage.bindings : [];\n    for (const binding of shader.bindings)\n    {\n        if (typeof binding?.samplerType !== \"string\" || !binding.samplerType) continue;\n        const uniform = new RegExp(\n            `uniform\\\\s+(?:(?:lowp|mediump|highp)\\\\s+)?${escapeRegExp(binding.samplerType)}\\\\s+${escapeRegExp(binding.name)}\\\\s*;`\n        );\n        if (!uniform.test(shader.source))\n        {\n            addIntegrityError(\n                errors,\n                \"sampler_binding_declaration_mismatch\",\n                `Shader ${shader.key} sampler ${binding.name || \"<missing>\"} is not declared as ${binding.samplerType}`,\n                { stageKey: stage.key, shaderKey: shader.key, bindingName: binding.name || null }\n            );\n        }\n        if (!Number.isSafeInteger(binding.registerIndex)\n      || binding.registerIndex < 0\n      || !manifestBindings.some((entry) => entry?.kind === \"resource\" && entry.registerIndex === binding.registerIndex))\n        {\n            addIntegrityError(\n                errors,\n                \"sampler_resource_contract_mismatch\",\n                `Shader ${shader.key} sampler ${binding.name || \"<missing>\"} has no matching manifest resource register`,\n                { stageKey: stage.key, shaderKey: shader.key, register: binding.registerIndex }\n            );\n        }\n\n        const comparison = binding.samplerType.endsWith(\"Shadow\");\n        if ((binding.comparison === true) !== comparison)\n        {\n            addIntegrityError(\n                errors,\n                \"comparison_sampler_contract_mismatch\",\n                `Shader ${shader.key} sampler ${binding.name || \"<missing>\"} comparison metadata disagrees with ${binding.samplerType}`,\n                { stageKey: stage.key, shaderKey: shader.key, bindingName: binding.name || null }\n            );\n        }\n        if (comparison)\n        {\n            const samplerRegisters = binding.samplerRegisterIndices;\n            if (!Array.isArray(samplerRegisters)\n        || !samplerRegisters.length\n        || new Set(samplerRegisters).size !== samplerRegisters.length\n        || samplerRegisters.some((register) => !Number.isSafeInteger(register)\n          || register < 0\n          || !manifestBindings.some((entry) => entry?.kind === \"sampler\"\n            && entry.registerIndex === register\n            && entry.carbon?.sampler?.comparison === true)))\n            {\n                addIntegrityError(\n                    errors,\n                    \"comparison_sampler_contract_mismatch\",\n                    `Shader ${shader.key} comparison sampler ${binding.name || \"<missing>\"} has invalid manifest sampler pairing`,\n                    { stageKey: stage.key, shaderKey: shader.key, bindingName: binding.name || null }\n                );\n            }\n        }\n    }\n}\n\nfunction normalizeSemanticName(value)\n{\n    const name = String(value || \"\").toUpperCase();\n    if (name === \"BITANGENT\") return \"BINORMAL\";\n    if (name === \"BLENDWEIGHTS\") return \"BLENDWEIGHT\";\n    return name;\n}\n\nfunction escapeRegExp(value)\n{\n    return String(value).replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\n\nfunction addIntegrityError(errors, code, message, details = {})\n{\n    errors.push({ code, message, ...details });\n}\n"],"names":["inspectRasterCompleteness","stages","shaders","shaderMap","Map","map","shader","key","groups","stage","stageName","bodyKey","techniqueName","Number","isInteger","passIndex","join","group","get","vertex","pixel","duplicateStages","set","push","incompletePasses","completePassCount","values","missingStages","unavailableStages","shaderKey","hlsl2webgl","ok","source","stageKey","excluded","reason","validationError","error","length","Set","sort","expectedPassCount","size"],"mappings":"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"}