@carbonenginejs/runtime-resource 0.13.0 → 0.15.0

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

@@ -1,7 +1,9 @@
-import { CjsCarbonEffectReader } from '../../../format/carbonEffect/CjsCarbonEffectReader.js';
-import { readGlslBackendBlock } from './glslBackendBlock.js';
-import { hlslShaderStageName, HlslUsageCodeNames } from '../../hlsl/core/tr2/HlslRenderContextEnum.js';
-
+import { CjsCarbonEffectReader } from '../../../format/carbonEffect/CjsCarbonEffectReader.js';
+import { readGlslBackendBlock } from './glslBackendBlock.js';
+import { hlslShaderStageName } from '../../hlsl/core/tr2/HlslRenderContextEnum.js';
+import { runtimeDescriptionFromCarbon } from '../../hlsl/core/carbonDescriptionToRuntime.js';
+import { HlslEffectBindingManifest } from '../../hlsl/core/tr2/shader/HlslEffectBindingManifest.js';
+
 /**
  * Decodes a WebGL effect container into the stage/shader records the
  * completeness rules consume.
@@ -26,102 +28,45 @@ import { hlslShaderStageName, HlslUsageCodeNames } from '../../hlsl/core/tr2/Hls
  * a file on disk does not know why a translation failed months ago. Callers that
  * do know — `buildEffectPackage`, at build time — keep their specific
  * diagnostics by feeding the rules their own records instead.
- */
-
-/** The verdict a stage carrying no stored program gets. */
-const NO_PROGRAM_REASON = "no program was stored";
-
+ */
+
+/** The verdict a stage carrying no stored program gets. */
+const NO_PROGRAM_REASON = "no program was stored";
+
 /**
- * Reshapes one Carbon stage's own reflection into the manifest vocabulary the
- * runtime-ABI rules read.
+ * Derives the per-stage binding manifests for one body through the one
+ * manifest builder the source path uses.
  *
- * The chunk package carried this as a separate META manifest, which is why the
- * old rules cross-checked two chunks against each other. The container needs no
- * such cross-check: `pipelineInputs`, `textures` and `samplers` are Carbon's own
- * per-stage reflection, read straight out of the description. There is only one
- * copy, so there is nothing for a second copy to disagree with — the class of
- * bug those cross-chunk rules existed to catch cannot occur here.
+ * This replaces a hand-built reshape of the wire records into the manifest
+ * vocabulary. That copy had already diverged from the real manifest once —
+ * `isAutoregister` was silently dropped, making every resource look
+ * user-settable — which is the whole argument against a second producer: two
+ * hand-maintained spellings of one reflection drift, and the drift is exactly
+ * the kind of bug that draws, links and renders black without an error. The
+ * record tree now flows through `runtimeDescriptionFromCarbon` — the
+ * corpus-proven adapter the runtime read path uses — and
+ * `HlslEffectBindingManifest`, so the container read and the build-time
+ * package derive their manifests from the same code.
  *
- * `usageName` is derived from the `usage` byte rather than carried, the same way
- * `carbonDescriptionToRuntime.js:261` derives it.
+ * No `bytecodeFor` is supplied: program text lives in the shader records this
+ * reader emits, so the manifest's `shaderBytecode` stays null rather than
+ * duplicating every program into the reflection.
  *
- * @param {object} stage Decoded Carbon stage record.
- * @returns {{pipelineInputs:object[], bindings:object[]}} Manifest-shaped reflection.
- */
-function stageManifest(stage) {
-  return {
-    pipelineInputs: (stage.pipelineInputs ?? []).map(input => ({
-      registerIndex: input.registerIndex,
-      usageName: HlslUsageCodeNames[input.usage] || `USAGE_${input.usage}`,
-      usageIndex: input.usageIndex,
-      usedMask: input.usedMask
-    })),
-    bindings: [
-    // The stage-local constant buffer, carrying the named constants an
-    // engine binds its material parameters to. Register 0 is this
-    // stage's own buffer in per-stage numbering; a consumer maps it to
-    // the slot its backend uses (vertex b0, pixel b7 by the GL
-    // convention).
-    //
-    // This is not optional detail. Without it an engine has no names to
-    // bind parameters to, uploads nothing, and every material value the
-    // shader reads is zero — which draws, links and binds correctly and
-    // renders pure black. It was missing because the completeness rules
-    // this reader was written for only needed inputs, resources and
-    // samplers, so nothing noticed the constants were dropped.
-    {
-      kind: "constantBuffer",
-      registerIndex: 0,
-      carbon: {
-        // Authored defaults live in the stage's blob; its declared
-        // size is what a consumer allocates against.
-        constantValueSize: stage.defaultValues?.size ?? 0,
-        constants: (stage.constants ?? []).map(constant => ({
-          // String refs decode as `{offset, value}` records.
-          name: constant.name?.value ?? constant.name,
-          offset: constant.offset,
-          size: constant.size,
-          type: constant.type,
-          dimension: constant.dimension,
-          elements: constant.elements,
-          isSRGB: constant.isSRGB,
-          isAutoregister: constant.isAutoregister
-        }))
-      }
-    }, ...(stage.textures ?? []).map(texture => ({
-      kind: "resource",
-      registerIndex: texture.registerIndex,
-      // Named so a rule can ask whether a described resource belongs
-      // to a family the packager is known to lower away.
-      name: texture.name.value,
-      // Carbon's own flags, nested like the sampler's, because that
-      // is where the consumer already looks for them.
-      //
-      // `isAutoregister` is not cosmetic: such a resource is bound
-      // automatically from the engine's global variable store rather
-      // than set by a material. Dropping it makes every resource look
-      // user-settable, so a consumer builds an ordinary texture
-      // parameter that nothing ever assigns and the global never
-      // reaches the shader.
-      carbon: {
-        isSRGB: texture.isSRGB === 1,
-        isAutoregister: texture.isAutoregister === 1
-      }
-    })), ...(stage.samplers ?? []).map(sampler => ({
-      kind: "sampler",
-      registerIndex: sampler.registerIndex,
-      // Carbon stores the flag as a byte; the rule compares against
-      // `=== true`, so the conversion has to happen here rather than
-      // letting a truthy 1 pass a strict check by accident.
-      carbon: {
-        sampler: {
-          comparison: sampler.comparison !== 0
-        }
-      }
-    }))]
-  };
-}
-
+ * @param {object} description Decoded Carbon description record tree.
+ * @param {number} version Container data version.
+ * @param {string} source Source name for diagnostics.
+ * @returns {Map<string, object>} Manifest stage records keyed by
+ *     `technique.passN.stageName`.
+ */
+function bodyManifestStages(description, version, source) {
+  const runtime = runtimeDescriptionFromCarbon(description, {
+    effectName: source,
+    version
+  });
+  const manifest = HlslEffectBindingManifest.fromEffectDescription(runtime).toJSON();
+  return new Map(manifest.stages.map(stage => [`${stage.techniqueName}.pass${stage.passIndex}.${stage.stageName}`, stage]));
+}
+
 /**
  * Decodes one pass's backend block, tolerating a pass that has none.
  *
@@ -129,22 +74,22 @@ function stageManifest(stage) {
  * @param {string} passKey Enclosing pass key.
  * @param {string} source Source name for error details.
  * @returns {object} Per-stage backend data, keyed by stage name.
- */
-function backendStages(pass, passKey, source) {
-  if (!pass.backendBlock?.size) return {
-    stages: {},
-    transforms: []
-  };
-  const block = readGlslBackendBlock(pass.backendBlock.bytes, {
-    layoutKey: passKey,
-    source
-  });
-  return {
-    stages: block.stages ?? {},
-    transforms: block.transforms ?? []
-  };
-}
-
+ */
+function backendStages(pass, passKey, source) {
+  if (!pass.backendBlock?.size) return {
+    stages: {},
+    transforms: []
+  };
+  const block = readGlslBackendBlock(pass.backendBlock.bytes, {
+    layoutKey: passKey,
+    source
+  });
+  return {
+    stages: block.stages ?? {},
+    transforms: block.transforms ?? []
+  };
+}
+
 /**
  * Decodes container bytes into stage and shader records.
  *
@@ -157,147 +102,148 @@ function backendStages(pass, passKey, source) {
  * @param {string} [values.source] Source name, for diagnostics.
  * @returns {{stages:object[], shaders:object[], recordCount:number, bodyCount:number}}
  *   Stage graph in the completeness rules' vocabulary.
- */
-function readGlslEffectContainer(input, values = {}) {
-  const source = values.source ?? "memory";
-  const reader = new CjsCarbonEffectReader(input, {
-    source
-  });
-  const stages = [];
-  const shaders = [];
-  const bodyKeyByOffset = new Map();
-
-  // Every permutation index that resolves to each body.
-  //
-  // This is the bridge a caller actually needs, and the only one that is
-  // sound. `bodyKey` here is this reader's own ordinal spelling; the
-  // permutation graph mints `body${N}` for the same body, and the two are not
-  // merely spelled differently — the graph dedupes by content (SHA-256 plus
-  // byte equality) while this reader dedupes by source-record offset. Those
-  // partitions coincide only because the container writer aliases
-  // byte-identical bodies onto one offset, which is a property of the writer
-  // rather than a contract.
-  //
-  // So a consumer must never map between the two by string surgery on either
-  // spelling, and must not assume the two ordinal sequences agree. It holds a
-  // permutation index; this gives it the body directly.
-  const permutationIndicesByOffset = new Map();
-  for (let index = 0; index < reader.records.length; index += 1) {
-    const {
-      offset
-    } = reader.records[index];
-    const seen = permutationIndicesByOffset.get(offset);
-    if (seen) seen.push(index);else permutationIndicesByOffset.set(offset, [index]);
-  }
-
-  // Distinct program texts share one shader record, so `shaders` counts unique
-  // translations the way the chunk package's shader table did. Empty stages are
-  // deliberately *not* pooled: each keeps its own record so a report can name
-  // every pass that is missing a program rather than one shared "absent".
-  //
-  // The pool key is the program text *and* the backend reflection that came
-  // with it, not the text alone. A pooled record carries the bindings and
-  // stage inputs of whichever stage was seen first, and
-  // `validateShaderRuntimeContract` judges the emitted GLSL against them — so
-  // pooling on text alone would let two stages with identical source but
-  // different reflection be checked against the wrong metadata, silently. It
-  // is unlikely that identical GLSL ever carries different reflection, which
-  // is exactly why it would not be noticed.
-  const shaderKeyByIdentity = new Map();
-  for (let index = 0; index < reader.records.length; index += 1) {
-    const {
-      offset
-    } = reader.records[index];
-    if (bodyKeyByOffset.has(offset)) continue;
-    const bodyKey = `body_${bodyKeyByOffset.size}`;
-    bodyKeyByOffset.set(offset, bodyKey);
-    const description = reader.readDescription(index, {
-      backend: true
-    });
-    for (const technique of description.techniques) {
-      const techniqueName = technique.name.value;
-      for (const [passIndex, pass] of technique.passes.entries()) {
-        const passKey = `${techniqueName}.pass${passIndex}`;
-        const {
-          stages: backend,
-          transforms
-        } = backendStages(pass, passKey, source);
-        for (const stage of pass.stages) {
-          const name = hlslShaderStageName(stage.type);
-          const stageKey = `${bodyKey}.${passKey}.${name}`;
-          const stageBackend = backend[name] ?? {};
-          let shaderKey;
-          if (stage.shaderData?.size) {
-            const code = new TextDecoder().decode(stage.shaderData.bytes);
-            const identity = `${JSON.stringify([stageBackend.bindings ?? [], stageBackend.stageInputs ?? [], stageBackend.computeFragment ?? null])} ${code}`;
-            const pooled = shaderKeyByIdentity.get(identity);
-            if (pooled) {
-              shaderKey = pooled;
-            } else {
-              shaderKey = `shader_${shaderKeyByIdentity.size}`;
-              shaderKeyByIdentity.set(identity, shaderKey);
-              shaders.push({
-                key: shaderKey,
-                stageName: name,
-                source: code,
-                hlsl2webgl: {
-                  ok: true
-                },
-                bindings: stageBackend.bindings ?? [],
-                stageInputs: stageBackend.stageInputs ?? [],
-                ...(stageBackend.computeFragment ? {
-                  computeFragment: stageBackend.computeFragment
-                } : {})
-              });
-            }
-          } else {
-            shaderKey = `${stageKey}.absent`;
-            shaders.push({
-              key: shaderKey,
-              stageName: name,
-              source: "",
-              hlsl2webgl: {
-                ok: false,
-                reason: NO_PROGRAM_REASON
-              },
-              bindings: stageBackend.bindings ?? [],
-              stageInputs: stageBackend.stageInputs ?? []
-            });
-          }
-          stages.push({
-            key: stageKey,
-            bodyKey,
-            techniqueName,
-            passIndex,
-            stageName: name,
-            stageType: stage.type,
-            shaderKey,
-            manifest: stageManifest(stage),
-            // The pass's transforms, so a rule can ask whether a
-            // description resource was merged away rather than lost.
-            transforms
-          });
-        }
-      }
-    }
-  }
-
-  // Ordered by first appearance, matching `bodyKey`'s ordinal.
-  const bodies = [];
-  for (const [offset, key] of bodyKeyByOffset) {
-    bodies.push({
-      key,
-      permutationIndices: Object.freeze(permutationIndicesByOffset.get(offset) ?? [])
-    });
-  }
-  return {
-    stages,
-    shaders,
-    bodies,
-    recordCount: reader.records.length,
-    bodyCount: bodyKeyByOffset.size
-  };
-}
-
-export { readGlslEffectContainer };
-//# sourceMappingURL=readGlslEffectContainer.js.map
+ */
+function readGlslEffectContainer(input, values = {}) {
+  const source = values.source ?? "memory";
+  const reader = new CjsCarbonEffectReader(input, {
+    source
+  });
+  const stages = [];
+  const shaders = [];
+  const bodyKeyByOffset = new Map();
+
+  // Every permutation index that resolves to each body.
+  //
+  // This is the bridge a caller actually needs, and the only one that is
+  // sound. `bodyKey` here is this reader's own ordinal spelling; the
+  // permutation graph mints `body${N}` for the same body, and the two are not
+  // merely spelled differently — the graph dedupes by content (SHA-256 plus
+  // byte equality) while this reader dedupes by source-record offset. Those
+  // partitions coincide only because the container writer aliases
+  // byte-identical bodies onto one offset, which is a property of the writer
+  // rather than a contract.
+  //
+  // So a consumer must never map between the two by string surgery on either
+  // spelling, and must not assume the two ordinal sequences agree. It holds a
+  // permutation index; this gives it the body directly.
+  const permutationIndicesByOffset = new Map();
+  for (let index = 0; index < reader.records.length; index += 1) {
+    const {
+      offset
+    } = reader.records[index];
+    const seen = permutationIndicesByOffset.get(offset);
+    if (seen) seen.push(index);else permutationIndicesByOffset.set(offset, [index]);
+  }
+
+  // Distinct program texts share one shader record, so `shaders` counts unique
+  // translations the way the chunk package's shader table did. Empty stages are
+  // deliberately *not* pooled: each keeps its own record so a report can name
+  // every pass that is missing a program rather than one shared "absent".
+  //
+  // The pool key is the program text *and* the backend reflection that came
+  // with it, not the text alone. A pooled record carries the bindings and
+  // stage inputs of whichever stage was seen first, and
+  // `validateShaderRuntimeContract` judges the emitted GLSL against them — so
+  // pooling on text alone would let two stages with identical source but
+  // different reflection be checked against the wrong metadata, silently. It
+  // is unlikely that identical GLSL ever carries different reflection, which
+  // is exactly why it would not be noticed.
+  const shaderKeyByIdentity = new Map();
+  for (let index = 0; index < reader.records.length; index += 1) {
+    const {
+      offset
+    } = reader.records[index];
+    if (bodyKeyByOffset.has(offset)) continue;
+    const bodyKey = `body_${bodyKeyByOffset.size}`;
+    bodyKeyByOffset.set(offset, bodyKey);
+    const description = reader.readDescription(index, {
+      backend: true
+    });
+    const manifestStages = bodyManifestStages(description, reader.version, source);
+    for (const technique of description.techniques) {
+      const techniqueName = technique.name.value;
+      for (const [passIndex, pass] of technique.passes.entries()) {
+        const passKey = `${techniqueName}.pass${passIndex}`;
+        const {
+          stages: backend,
+          transforms
+        } = backendStages(pass, passKey, source);
+        for (const stage of pass.stages) {
+          const name = hlslShaderStageName(stage.type);
+          const stageKey = `${bodyKey}.${passKey}.${name}`;
+          const stageBackend = backend[name] ?? {};
+          let shaderKey;
+          if (stage.shaderData?.size) {
+            const code = new TextDecoder().decode(stage.shaderData.bytes);
+            const identity = `${JSON.stringify([stageBackend.bindings ?? [], stageBackend.stageInputs ?? [], stageBackend.computeFragment ?? null])} ${code}`;
+            const pooled = shaderKeyByIdentity.get(identity);
+            if (pooled) {
+              shaderKey = pooled;
+            } else {
+              shaderKey = `shader_${shaderKeyByIdentity.size}`;
+              shaderKeyByIdentity.set(identity, shaderKey);
+              shaders.push({
+                key: shaderKey,
+                stageName: name,
+                source: code,
+                hlsl2webgl: {
+                  ok: true
+                },
+                bindings: stageBackend.bindings ?? [],
+                stageInputs: stageBackend.stageInputs ?? [],
+                ...(stageBackend.computeFragment ? {
+                  computeFragment: stageBackend.computeFragment
+                } : {})
+              });
+            }
+          } else {
+            shaderKey = `${stageKey}.absent`;
+            shaders.push({
+              key: shaderKey,
+              stageName: name,
+              source: "",
+              hlsl2webgl: {
+                ok: false,
+                reason: NO_PROGRAM_REASON
+              },
+              bindings: stageBackend.bindings ?? [],
+              stageInputs: stageBackend.stageInputs ?? []
+            });
+          }
+          stages.push({
+            key: stageKey,
+            bodyKey,
+            techniqueName,
+            passIndex,
+            stageName: name,
+            stageType: stage.type,
+            shaderKey,
+            manifest: manifestStages.get(`${passKey}.${name}`) ?? null,
+            // The pass's transforms, so a rule can ask whether a
+            // description resource was merged away rather than lost.
+            transforms
+          });
+        }
+      }
+    }
+  }
+
+  // Ordered by first appearance, matching `bodyKey`'s ordinal.
+  const bodies = [];
+  for (const [offset, key] of bodyKeyByOffset) {
+    bodies.push({
+      key,
+      permutationIndices: Object.freeze(permutationIndicesByOffset.get(offset) ?? [])
+    });
+  }
+  return {
+    stages,
+    shaders,
+    bodies,
+    recordCount: reader.records.length,
+    bodyCount: bodyKeyByOffset.size
+  };
+}
+
+export { readGlslEffectContainer };
+//# sourceMappingURL=readGlslEffectContainer.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"readGlslEffectContainer.js","sources":["../../../../../src/formats/webgl/core/readGlslEffectContainer.js"],"sourcesContent":["import { CjsCarbonEffectReader } from \"../../../format/carbonEffect/CjsCarbonEffectReader.js\";\r\nimport { readGlslBackendBlock } from \"./glslBackendBlock.js\";\r\nimport {\r\n    hlslShaderStageName,\r\n    HlslUsageCodeNames\r\n} from \"../../hlsl/core/tr2/HlslRenderContextEnum.js\";\r\n\r\n/**\r\n * Decodes a WebGL effect container into the stage/shader records the\r\n * completeness rules consume.\r\n *\r\n * This exists so the rules run from container bytes alone. The alternative was\r\n * to hand them the in-memory translation, which works inside `buildEffectPackage`\r\n * and nowhere else — the validator reads a finished file and has no translation\r\n * in scope. That would have cost the validator its completeness check while\r\n * still requiring a decoder to produce the programs it compiles in a browser, so\r\n * it was strictly more work for strictly less checking.\r\n *\r\n * The vocabulary is deliberately the one the rules already speak — `stages` with\r\n * pass coordinates, `shaders` with source and a translation verdict. The rules\r\n * are about the translation, not about how it was stored, so retargeting them\r\n * meant changing where the records come from and nothing about what they mean.\r\n *\r\n * **What the wire cannot tell you.** `buildCarbonEffectContainer` stores a body\r\n * the translator could not lower as its full pass tree with zero-length\r\n * programs; the *reason* it failed stays in the in-memory build result and is\r\n * never written. So a shader decoded from bytes reports `ok: false` with\r\n * \"no program was stored\" and nothing more specific. That is the honest answer:\r\n * a file on disk does not know why a translation failed months ago. Callers that\r\n * do know — `buildEffectPackage`, at build time — keep their specific\r\n * diagnostics by feeding the rules their own records instead.\r\n */\r\n\r\n/** The verdict a stage carrying no stored program gets. */\r\nconst NO_PROGRAM_REASON = \"no program was stored\";\r\n\r\n/**\r\n * Reshapes one Carbon stage's own reflection into the manifest vocabulary the\r\n * runtime-ABI rules read.\r\n *\r\n * The chunk package carried this as a separate META manifest, which is why the\r\n * old rules cross-checked two chunks against each other. The container needs no\r\n * such cross-check: `pipelineInputs`, `textures` and `samplers` are Carbon's own\r\n * per-stage reflection, read straight out of the description. There is only one\r\n * copy, so there is nothing for a second copy to disagree with — the class of\r\n * bug those cross-chunk rules existed to catch cannot occur here.\r\n *\r\n * `usageName` is derived from the `usage` byte rather than carried, the same way\r\n * `carbonDescriptionToRuntime.js:261` derives it.\r\n *\r\n * @param {object} stage Decoded Carbon stage record.\r\n * @returns {{pipelineInputs:object[], bindings:object[]}} Manifest-shaped reflection.\r\n */\r\nfunction stageManifest(stage)\r\n{\r\n    return {\r\n        pipelineInputs: (stage.pipelineInputs ?? []).map((input) => ({\r\n            registerIndex: input.registerIndex,\r\n            usageName: HlslUsageCodeNames[input.usage] || `USAGE_${input.usage}`,\r\n            usageIndex: input.usageIndex,\r\n            usedMask: input.usedMask\r\n        })),\r\n        bindings: [\r\n            // The stage-local constant buffer, carrying the named constants an\r\n            // engine binds its material parameters to. Register 0 is this\r\n            // stage's own buffer in per-stage numbering; a consumer maps it to\r\n            // the slot its backend uses (vertex b0, pixel b7 by the GL\r\n            // convention).\r\n            //\r\n            // This is not optional detail. Without it an engine has no names to\r\n            // bind parameters to, uploads nothing, and every material value the\r\n            // shader reads is zero — which draws, links and binds correctly and\r\n            // renders pure black. It was missing because the completeness rules\r\n            // this reader was written for only needed inputs, resources and\r\n            // samplers, so nothing noticed the constants were dropped.\r\n            {\r\n                kind: \"constantBuffer\",\r\n                registerIndex: 0,\r\n                carbon: {\r\n                    // Authored defaults live in the stage's blob; its declared\r\n                    // size is what a consumer allocates against.\r\n                    constantValueSize: stage.defaultValues?.size ?? 0,\r\n                    constants: (stage.constants ?? []).map((constant) => ({\r\n                        // String refs decode as `{offset, value}` records.\r\n                        name: constant.name?.value ?? constant.name,\r\n                        offset: constant.offset,\r\n                        size: constant.size,\r\n                        type: constant.type,\r\n                        dimension: constant.dimension,\r\n                        elements: constant.elements,\r\n                        isSRGB: constant.isSRGB,\r\n                        isAutoregister: constant.isAutoregister\r\n                    }))\r\n                }\r\n            },\r\n            ...(stage.textures ?? []).map((texture) => ({\r\n                kind: \"resource\",\r\n                registerIndex: texture.registerIndex,\r\n                // Named so a rule can ask whether a described resource belongs\r\n                // to a family the packager is known to lower away.\r\n                name: texture.name.value,\r\n                // Carbon's own flags, nested like the sampler's, because that\r\n                // is where the consumer already looks for them.\r\n                //\r\n                // `isAutoregister` is not cosmetic: such a resource is bound\r\n                // automatically from the engine's global variable store rather\r\n                // than set by a material. Dropping it makes every resource look\r\n                // user-settable, so a consumer builds an ordinary texture\r\n                // parameter that nothing ever assigns and the global never\r\n                // reaches the shader.\r\n                carbon: {\r\n                    isSRGB: texture.isSRGB === 1,\r\n                    isAutoregister: texture.isAutoregister === 1\r\n                }\r\n            })),\r\n            ...(stage.samplers ?? []).map((sampler) => ({\r\n                kind: \"sampler\",\r\n                registerIndex: sampler.registerIndex,\r\n                // Carbon stores the flag as a byte; the rule compares against\r\n                // `=== true`, so the conversion has to happen here rather than\r\n                // letting a truthy 1 pass a strict check by accident.\r\n                carbon: { sampler: { comparison: sampler.comparison !== 0 } }\r\n            }))\r\n        ]\r\n    };\r\n}\r\n\r\n/**\r\n * Decodes one pass's backend block, tolerating a pass that has none.\r\n *\r\n * @param {object} pass Decoded pass record.\r\n * @param {string} passKey Enclosing pass key.\r\n * @param {string} source Source name for error details.\r\n * @returns {object} Per-stage backend data, keyed by stage name.\r\n */\r\nfunction backendStages(pass, passKey, source)\r\n{\r\n    if (!pass.backendBlock?.size) return { stages: {}, transforms: [] };\r\n    const block = readGlslBackendBlock(pass.backendBlock.bytes, { layoutKey: passKey, source });\r\n    return { stages: block.stages ?? {}, transforms: block.transforms ?? [] };\r\n}\r\n\r\n/**\r\n * Decodes container bytes into stage and shader records.\r\n *\r\n * Bodies are decoded once each rather than once per permutation row: rows alias\r\n * onto shared bodies, and a rule that saw the same body 4,096 times would report\r\n * 4,096 identical incomplete passes.\r\n *\r\n * @param {Uint8Array|ArrayBuffer|Buffer|DataView} input Container payload.\r\n * @param {object} [values] Read values.\r\n * @param {string} [values.source] Source name, for diagnostics.\r\n * @returns {{stages:object[], shaders:object[], recordCount:number, bodyCount:number}}\r\n *   Stage graph in the completeness rules' vocabulary.\r\n */\r\nexport function readGlslEffectContainer(input, values = {})\r\n{\r\n    const source = values.source ?? \"memory\";\r\n    const reader = new CjsCarbonEffectReader(input, { source });\r\n\r\n    const stages = [];\r\n    const shaders = [];\r\n    const bodyKeyByOffset = new Map();\r\n\r\n    // Every permutation index that resolves to each body.\r\n    //\r\n    // This is the bridge a caller actually needs, and the only one that is\r\n    // sound. `bodyKey` here is this reader's own ordinal spelling; the\r\n    // permutation graph mints `body${N}` for the same body, and the two are not\r\n    // merely spelled differently — the graph dedupes by content (SHA-256 plus\r\n    // byte equality) while this reader dedupes by source-record offset. Those\r\n    // partitions coincide only because the container writer aliases\r\n    // byte-identical bodies onto one offset, which is a property of the writer\r\n    // rather than a contract.\r\n    //\r\n    // So a consumer must never map between the two by string surgery on either\r\n    // spelling, and must not assume the two ordinal sequences agree. It holds a\r\n    // permutation index; this gives it the body directly.\r\n    const permutationIndicesByOffset = new Map();\r\n\r\n    for (let index = 0; index < reader.records.length; index += 1)\r\n    {\r\n        const { offset } = reader.records[index];\r\n        const seen = permutationIndicesByOffset.get(offset);\r\n        if (seen) seen.push(index);\r\n        else permutationIndicesByOffset.set(offset, [ index ]);\r\n    }\r\n\r\n    // Distinct program texts share one shader record, so `shaders` counts unique\r\n    // translations the way the chunk package's shader table did. Empty stages are\r\n    // deliberately *not* pooled: each keeps its own record so a report can name\r\n    // every pass that is missing a program rather than one shared \"absent\".\r\n    //\r\n    // The pool key is the program text *and* the backend reflection that came\r\n    // with it, not the text alone. A pooled record carries the bindings and\r\n    // stage inputs of whichever stage was seen first, and\r\n    // `validateShaderRuntimeContract` judges the emitted GLSL against them — so\r\n    // pooling on text alone would let two stages with identical source but\r\n    // different reflection be checked against the wrong metadata, silently. It\r\n    // is unlikely that identical GLSL ever carries different reflection, which\r\n    // is exactly why it would not be noticed.\r\n    const shaderKeyByIdentity = new Map();\r\n\r\n    for (let index = 0; index < reader.records.length; index += 1)\r\n    {\r\n        const { offset } = reader.records[index];\r\n        if (bodyKeyByOffset.has(offset)) continue;\r\n\r\n        const bodyKey = `body_${bodyKeyByOffset.size}`;\r\n        bodyKeyByOffset.set(offset, bodyKey);\r\n\r\n        const description = reader.readDescription(index, { backend: true });\r\n\r\n        for (const technique of description.techniques)\r\n        {\r\n            const techniqueName = technique.name.value;\r\n            for (const [ passIndex, pass ] of technique.passes.entries())\r\n            {\r\n                const passKey = `${techniqueName}.pass${passIndex}`;\r\n                const { stages: backend, transforms } = backendStages(\r\n                    pass,\r\n                    passKey,\r\n                    source\r\n                );\r\n\r\n                for (const stage of pass.stages)\r\n                {\r\n                    const name = hlslShaderStageName(stage.type);\r\n                    const stageKey = `${bodyKey}.${passKey}.${name}`;\r\n                    const stageBackend = backend[name] ?? {};\r\n\r\n                    let shaderKey;\r\n                    if (stage.shaderData?.size)\r\n                    {\r\n                        const code = new TextDecoder().decode(stage.shaderData.bytes);\r\n                        const identity = `${JSON.stringify([\r\n                            stageBackend.bindings ?? [],\r\n                            stageBackend.stageInputs ?? [],\r\n                            stageBackend.computeFragment ?? null\r\n                        ])} ${code}`;\r\n                        const pooled = shaderKeyByIdentity.get(identity);\r\n                        if (pooled)\r\n                        {\r\n                            shaderKey = pooled;\r\n                        }\r\n                        else\r\n                        {\r\n                            shaderKey = `shader_${shaderKeyByIdentity.size}`;\r\n                            shaderKeyByIdentity.set(identity, shaderKey);\r\n                            shaders.push({\r\n                                key: shaderKey,\r\n                                stageName: name,\r\n                                source: code,\r\n                                hlsl2webgl: { ok: true },\r\n                                bindings: stageBackend.bindings ?? [],\r\n                                stageInputs: stageBackend.stageInputs ?? [],\r\n                                ...(stageBackend.computeFragment\r\n                                    ? { computeFragment: stageBackend.computeFragment }\r\n                                    : {})\r\n                            });\r\n                        }\r\n                    }\r\n                    else\r\n                    {\r\n                        shaderKey = `${stageKey}.absent`;\r\n                        shaders.push({\r\n                            key: shaderKey,\r\n                            stageName: name,\r\n                            source: \"\",\r\n                            hlsl2webgl: { ok: false, reason: NO_PROGRAM_REASON },\r\n                            bindings: stageBackend.bindings ?? [],\r\n                            stageInputs: stageBackend.stageInputs ?? []\r\n                        });\r\n                    }\r\n\r\n                    stages.push({\r\n                        key: stageKey,\r\n                        bodyKey,\r\n                        techniqueName,\r\n                        passIndex,\r\n                        stageName: name,\r\n                        stageType: stage.type,\r\n                        shaderKey,\r\n                        manifest: stageManifest(stage),\r\n                        // The pass's transforms, so a rule can ask whether a\r\n                        // description resource was merged away rather than lost.\r\n                        transforms\r\n                    });\r\n                }\r\n            }\r\n        }\r\n    }\r\n\r\n    // Ordered by first appearance, matching `bodyKey`'s ordinal.\r\n    const bodies = [];\r\n    for (const [ offset, key ] of bodyKeyByOffset)\r\n    {\r\n        bodies.push({\r\n            key,\r\n            permutationIndices: Object.freeze(permutationIndicesByOffset.get(offset) ?? [])\r\n        });\r\n    }\r\n\r\n    return {\r\n        stages,\r\n        shaders,\r\n        bodies,\r\n        recordCount: reader.records.length,\r\n        bodyCount: bodyKeyByOffset.size\r\n    };\r\n}\r\n\r\nexport default readGlslEffectContainer;\r\n"],"names":["NO_PROGRAM_REASON","stageManifest","stage","pipelineInputs","map","input","registerIndex","usageName","HlslUsageCodeNames","usage","usageIndex","usedMask","bindings","kind","carbon","constantValueSize","defaultValues","size","constants","constant","name","value","offset","type","dimension","elements","isSRGB","isAutoregister","textures","texture","samplers","sampler","comparison","backendStages","pass","passKey","source","backendBlock","stages","transforms","block","readGlslBackendBlock","bytes","layoutKey","readGlslEffectContainer","values","reader","CjsCarbonEffectReader","shaders","bodyKeyByOffset","Map","permutationIndicesByOffset","index","records","length","seen","get","push","set","shaderKeyByIdentity","has","bodyKey","description","readDescription","backend","technique","techniques","techniqueName","passIndex","passes","entries","hlslShaderStageName","stageKey","stageBackend","shaderKey","shaderData","code","TextDecoder","decode","identity","JSON","stringify","stageInputs","computeFragment","pooled","key","stageName","hlsl2webgl","ok","reason","stageType","manifest","bodies","permutationIndices","Object","freeze","recordCount","bodyCount"],"mappings":"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"}
+{"version":3,"file":"readGlslEffectContainer.js","sources":["../../../../../src/formats/webgl/core/readGlslEffectContainer.js"],"sourcesContent":["import { CjsCarbonEffectReader } from \"../../../format/carbonEffect/CjsCarbonEffectReader.js\";\r\nimport { readGlslBackendBlock } from \"./glslBackendBlock.js\";\r\nimport { hlslShaderStageName } from \"../../hlsl/core/tr2/HlslRenderContextEnum.js\";\r\nimport { runtimeDescriptionFromCarbon } from \"../../hlsl/core/carbonDescriptionToRuntime.js\";\r\nimport { HlslEffectBindingManifest } from \"../../hlsl/core/tr2/shader/HlslEffectBindingManifest.js\";\r\n\r\n/**\r\n * Decodes a WebGL effect container into the stage/shader records the\r\n * completeness rules consume.\r\n *\r\n * This exists so the rules run from container bytes alone. The alternative was\r\n * to hand them the in-memory translation, which works inside `buildEffectPackage`\r\n * and nowhere else — the validator reads a finished file and has no translation\r\n * in scope. That would have cost the validator its completeness check while\r\n * still requiring a decoder to produce the programs it compiles in a browser, so\r\n * it was strictly more work for strictly less checking.\r\n *\r\n * The vocabulary is deliberately the one the rules already speak — `stages` with\r\n * pass coordinates, `shaders` with source and a translation verdict. The rules\r\n * are about the translation, not about how it was stored, so retargeting them\r\n * meant changing where the records come from and nothing about what they mean.\r\n *\r\n * **What the wire cannot tell you.** `buildCarbonEffectContainer` stores a body\r\n * the translator could not lower as its full pass tree with zero-length\r\n * programs; the *reason* it failed stays in the in-memory build result and is\r\n * never written. So a shader decoded from bytes reports `ok: false` with\r\n * \"no program was stored\" and nothing more specific. That is the honest answer:\r\n * a file on disk does not know why a translation failed months ago. Callers that\r\n * do know — `buildEffectPackage`, at build time — keep their specific\r\n * diagnostics by feeding the rules their own records instead.\r\n */\r\n\r\n/** The verdict a stage carrying no stored program gets. */\r\nconst NO_PROGRAM_REASON = \"no program was stored\";\r\n\r\n/**\r\n * Derives the per-stage binding manifests for one body through the one\r\n * manifest builder the source path uses.\r\n *\r\n * This replaces a hand-built reshape of the wire records into the manifest\r\n * vocabulary. That copy had already diverged from the real manifest once —\r\n * `isAutoregister` was silently dropped, making every resource look\r\n * user-settable — which is the whole argument against a second producer: two\r\n * hand-maintained spellings of one reflection drift, and the drift is exactly\r\n * the kind of bug that draws, links and renders black without an error. The\r\n * record tree now flows through `runtimeDescriptionFromCarbon` — the\r\n * corpus-proven adapter the runtime read path uses — and\r\n * `HlslEffectBindingManifest`, so the container read and the build-time\r\n * package derive their manifests from the same code.\r\n *\r\n * No `bytecodeFor` is supplied: program text lives in the shader records this\r\n * reader emits, so the manifest's `shaderBytecode` stays null rather than\r\n * duplicating every program into the reflection.\r\n *\r\n * @param {object} description Decoded Carbon description record tree.\r\n * @param {number} version Container data version.\r\n * @param {string} source Source name for diagnostics.\r\n * @returns {Map<string, object>} Manifest stage records keyed by\r\n *     `technique.passN.stageName`.\r\n */\r\nfunction bodyManifestStages(description, version, source)\r\n{\r\n    const runtime = runtimeDescriptionFromCarbon(description, {\r\n        effectName: source,\r\n        version\r\n    });\r\n    const manifest = HlslEffectBindingManifest.fromEffectDescription(runtime).toJSON();\r\n    return new Map(manifest.stages.map((stage) => [\r\n        `${stage.techniqueName}.pass${stage.passIndex}.${stage.stageName}`,\r\n        stage\r\n    ]));\r\n}\r\n\r\n/**\r\n * Decodes one pass's backend block, tolerating a pass that has none.\r\n *\r\n * @param {object} pass Decoded pass record.\r\n * @param {string} passKey Enclosing pass key.\r\n * @param {string} source Source name for error details.\r\n * @returns {object} Per-stage backend data, keyed by stage name.\r\n */\r\nfunction backendStages(pass, passKey, source)\r\n{\r\n    if (!pass.backendBlock?.size) return { stages: {}, transforms: [] };\r\n    const block = readGlslBackendBlock(pass.backendBlock.bytes, { layoutKey: passKey, source });\r\n    return { stages: block.stages ?? {}, transforms: block.transforms ?? [] };\r\n}\r\n\r\n/**\r\n * Decodes container bytes into stage and shader records.\r\n *\r\n * Bodies are decoded once each rather than once per permutation row: rows alias\r\n * onto shared bodies, and a rule that saw the same body 4,096 times would report\r\n * 4,096 identical incomplete passes.\r\n *\r\n * @param {Uint8Array|ArrayBuffer|Buffer|DataView} input Container payload.\r\n * @param {object} [values] Read values.\r\n * @param {string} [values.source] Source name, for diagnostics.\r\n * @returns {{stages:object[], shaders:object[], recordCount:number, bodyCount:number}}\r\n *   Stage graph in the completeness rules' vocabulary.\r\n */\r\nexport function readGlslEffectContainer(input, values = {})\r\n{\r\n    const source = values.source ?? \"memory\";\r\n    const reader = new CjsCarbonEffectReader(input, { source });\r\n\r\n    const stages = [];\r\n    const shaders = [];\r\n    const bodyKeyByOffset = new Map();\r\n\r\n    // Every permutation index that resolves to each body.\r\n    //\r\n    // This is the bridge a caller actually needs, and the only one that is\r\n    // sound. `bodyKey` here is this reader's own ordinal spelling; the\r\n    // permutation graph mints `body${N}` for the same body, and the two are not\r\n    // merely spelled differently — the graph dedupes by content (SHA-256 plus\r\n    // byte equality) while this reader dedupes by source-record offset. Those\r\n    // partitions coincide only because the container writer aliases\r\n    // byte-identical bodies onto one offset, which is a property of the writer\r\n    // rather than a contract.\r\n    //\r\n    // So a consumer must never map between the two by string surgery on either\r\n    // spelling, and must not assume the two ordinal sequences agree. It holds a\r\n    // permutation index; this gives it the body directly.\r\n    const permutationIndicesByOffset = new Map();\r\n\r\n    for (let index = 0; index < reader.records.length; index += 1)\r\n    {\r\n        const { offset } = reader.records[index];\r\n        const seen = permutationIndicesByOffset.get(offset);\r\n        if (seen) seen.push(index);\r\n        else permutationIndicesByOffset.set(offset, [ index ]);\r\n    }\r\n\r\n    // Distinct program texts share one shader record, so `shaders` counts unique\r\n    // translations the way the chunk package's shader table did. Empty stages are\r\n    // deliberately *not* pooled: each keeps its own record so a report can name\r\n    // every pass that is missing a program rather than one shared \"absent\".\r\n    //\r\n    // The pool key is the program text *and* the backend reflection that came\r\n    // with it, not the text alone. A pooled record carries the bindings and\r\n    // stage inputs of whichever stage was seen first, and\r\n    // `validateShaderRuntimeContract` judges the emitted GLSL against them — so\r\n    // pooling on text alone would let two stages with identical source but\r\n    // different reflection be checked against the wrong metadata, silently. It\r\n    // is unlikely that identical GLSL ever carries different reflection, which\r\n    // is exactly why it would not be noticed.\r\n    const shaderKeyByIdentity = new Map();\r\n\r\n    for (let index = 0; index < reader.records.length; index += 1)\r\n    {\r\n        const { offset } = reader.records[index];\r\n        if (bodyKeyByOffset.has(offset)) continue;\r\n\r\n        const bodyKey = `body_${bodyKeyByOffset.size}`;\r\n        bodyKeyByOffset.set(offset, bodyKey);\r\n\r\n        const description = reader.readDescription(index, { backend: true });\r\n        const manifestStages = bodyManifestStages(description, reader.version, source);\r\n\r\n        for (const technique of description.techniques)\r\n        {\r\n            const techniqueName = technique.name.value;\r\n            for (const [ passIndex, pass ] of technique.passes.entries())\r\n            {\r\n                const passKey = `${techniqueName}.pass${passIndex}`;\r\n                const { stages: backend, transforms } = backendStages(\r\n                    pass,\r\n                    passKey,\r\n                    source\r\n                );\r\n\r\n                for (const stage of pass.stages)\r\n                {\r\n                    const name = hlslShaderStageName(stage.type);\r\n                    const stageKey = `${bodyKey}.${passKey}.${name}`;\r\n                    const stageBackend = backend[name] ?? {};\r\n\r\n                    let shaderKey;\r\n                    if (stage.shaderData?.size)\r\n                    {\r\n                        const code = new TextDecoder().decode(stage.shaderData.bytes);\r\n                        const identity = `${JSON.stringify([\r\n                            stageBackend.bindings ?? [],\r\n                            stageBackend.stageInputs ?? [],\r\n                            stageBackend.computeFragment ?? null\r\n                        ])} ${code}`;\r\n                        const pooled = shaderKeyByIdentity.get(identity);\r\n                        if (pooled)\r\n                        {\r\n                            shaderKey = pooled;\r\n                        }\r\n                        else\r\n                        {\r\n                            shaderKey = `shader_${shaderKeyByIdentity.size}`;\r\n                            shaderKeyByIdentity.set(identity, shaderKey);\r\n                            shaders.push({\r\n                                key: shaderKey,\r\n                                stageName: name,\r\n                                source: code,\r\n                                hlsl2webgl: { ok: true },\r\n                                bindings: stageBackend.bindings ?? [],\r\n                                stageInputs: stageBackend.stageInputs ?? [],\r\n                                ...(stageBackend.computeFragment\r\n                                    ? { computeFragment: stageBackend.computeFragment }\r\n                                    : {})\r\n                            });\r\n                        }\r\n                    }\r\n                    else\r\n                    {\r\n                        shaderKey = `${stageKey}.absent`;\r\n                        shaders.push({\r\n                            key: shaderKey,\r\n                            stageName: name,\r\n                            source: \"\",\r\n                            hlsl2webgl: { ok: false, reason: NO_PROGRAM_REASON },\r\n                            bindings: stageBackend.bindings ?? [],\r\n                            stageInputs: stageBackend.stageInputs ?? []\r\n                        });\r\n                    }\r\n\r\n                    stages.push({\r\n                        key: stageKey,\r\n                        bodyKey,\r\n                        techniqueName,\r\n                        passIndex,\r\n                        stageName: name,\r\n                        stageType: stage.type,\r\n                        shaderKey,\r\n                        manifest: manifestStages.get(`${passKey}.${name}`) ?? null,\r\n                        // The pass's transforms, so a rule can ask whether a\r\n                        // description resource was merged away rather than lost.\r\n                        transforms\r\n                    });\r\n                }\r\n            }\r\n        }\r\n    }\r\n\r\n    // Ordered by first appearance, matching `bodyKey`'s ordinal.\r\n    const bodies = [];\r\n    for (const [ offset, key ] of bodyKeyByOffset)\r\n    {\r\n        bodies.push({\r\n            key,\r\n            permutationIndices: Object.freeze(permutationIndicesByOffset.get(offset) ?? [])\r\n        });\r\n    }\r\n\r\n    return {\r\n        stages,\r\n        shaders,\r\n        bodies,\r\n        recordCount: reader.records.length,\r\n        bodyCount: bodyKeyByOffset.size\r\n    };\r\n}\r\n\r\nexport default readGlslEffectContainer;\r\n"],"names":["NO_PROGRAM_REASON","bodyManifestStages","description","version","source","runtime","runtimeDescriptionFromCarbon","effectName","manifest","HlslEffectBindingManifest","fromEffectDescription","toJSON","Map","stages","map","stage","techniqueName","passIndex","stageName","backendStages","pass","passKey","backendBlock","size","transforms","block","readGlslBackendBlock","bytes","layoutKey","readGlslEffectContainer","input","values","reader","CjsCarbonEffectReader","shaders","bodyKeyByOffset","permutationIndicesByOffset","index","records","length","offset","seen","get","push","set","shaderKeyByIdentity","has","bodyKey","readDescription","backend","manifestStages","technique","techniques","name","value","passes","entries","hlslShaderStageName","type","stageKey","stageBackend","shaderKey","shaderData","code","TextDecoder","decode","identity","JSON","stringify","bindings","stageInputs","computeFragment","pooled","key","hlsl2webgl","ok","reason","stageType","bodies","permutationIndices","Object","freeze","recordCount","bodyCount"],"mappings":"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"}

package/dist/formats/webgl/index.js

@@ -1,2 +1,2 @@
-export { CjsWebglFormat, CjsWebglFormat as default } from './CjsWebglFormat.js';
-//# sourceMappingURL=index.js.map
+export { CjsWebglFormat, CjsWebglFormat as default } from './CjsWebglFormat.js';
+//# sourceMappingURL=index.js.map