@carbonenginejs/runtime-resource 0.12.0 → 0.12.1

package/dist/formats/webgpu/core/cewgpu/containerViews.js

@@ -0,0 +1,355 @@
+import { HlslEffectBindingManifest } from '../../../hlsl/core/tr2/shader/HlslEffectBindingManifest.js';
+import { HlslShaderBytecode } from '../../../hlsl/core/HlslShaderBytecode.js';
+import { hlslShaderStageName } from '../../../hlsl/core/tr2/HlslRenderContextEnum.js';
+import { runtimeDescriptionFromCarbon } from '../../../hlsl/core/carbonDescriptionToRuntime.js';
+import { buildEffectAnalysis } from '../helpers.js';
+import { WGSL_SET_VERSION } from '../wgsl/buildWgslSet.js';
+import { sha256Utf8 } from '../../../../format/effect/sha256.js';
+
+/**
+ * Derived compatibility views over a container.
+ *
+ * The chunk package stored `ANLS` and `WGSL` as documents beside the reflection
+ * they were computed from, and carried digests to detect the two disagreeing.
+ * The container stores one document, so these are **views**: functions of the
+ * records, computed on read. The class of bug the digests guarded cannot occur,
+ * because there is no second copy to drift.
+ *
+ * The analysis view is deliberately not a reimplementation. It runs
+ * `buildEffectAnalysis` — the same function the packager runs on source — over a
+ * description rebuilt by `runtimeDescriptionFromCarbon`. That is what keeps the
+ * view honest: if it were rewritten to emit the fields consumers read today, it
+ * would be free to drift from the real analysis, and nothing would notice.
+ * `carbon-analysis-adapter-corpus.test.mjs` diffs the two over every shipped
+ * permutation and finds zero differences.
+ *
+ * These views exist for `engine-webgpu`, which reads format-package JSON for
+ * Carbon reflection instead of reading `Tr2Shader`. That is a recorded layering
+ * defect and is not this port's to fix; the views keep it working unchanged
+ * while the wire format moves underneath it. They go away with that cleanup.
+ */
+
+/**
+ * Resolves the permutation Carbon's own `GetShader()` would select with no
+ * option overrides.
+ *
+ * Carbon multiplies each axis's default option by the running product of the
+ * preceding axes' option counts. The chunk package stored a single selected
+ * body and its index; the container carries every permutation, so the view has
+ * to name a default rather than inherit one, and Carbon's own default is the
+ * only defensible choice.
+ *
+ * @param {object} container Loaded container.
+ * @returns {number} Permutation index.
+ */
+function defaultPermutationIndex(container) {
+  let multiplier = 1;
+  let index = 0;
+  for (const axis of container.carbon.permutations) {
+    index += axis.defaultOption * multiplier;
+    multiplier *= axis.options.length || 1;
+  }
+  return index < container.carbon.records.length ? index : 0;
+}
+
+/**
+ * Rebuilds the runtime effect description for one permutation.
+ *
+ * @param {object} container Loaded container.
+ * @param {number} permutationIndex Permutation index.
+ * @param {string} source Source label.
+ * @returns {object} Runtime-shaped effect description.
+ */
+function describeRuntime(container, permutationIndex, source) {
+  return runtimeDescriptionFromCarbon(container.GetDescription(permutationIndex), {
+    effectName: source,
+    version: container.carbon.version,
+    bytecodeFor: (stage, stageType) => new HlslShaderBytecode({
+      stageType,
+      // Carbon's six stage names, not WebGPU's three. A three-entry table
+      // reports a geometry stage as null, which the corpus caught.
+      stageName: hlslShaderStageName(stageType),
+      bytes: stage.shaderData.bytes,
+      shaderSize: stage.shaderData.size,
+      stringTableOffset: stage.shaderData.offset,
+      effectName: source
+    })
+  });
+}
+
+/**
+ * Derives the analysis document for one permutation.
+ *
+ * One field is honestly different from the stored `ANLS` it replaces:
+ * `stages[].shaderBytecode` describes the **WGSL** program the container
+ * carries, where the stored document described the source DXBC. The container
+ * does not carry DXBC, so reproducing the old numbers would mean inventing
+ * them. Nothing in the engine's read surface uses this field; it is a
+ * diagnostic.
+ *
+ * @param {object} container Loaded container.
+ * @param {object} [options] View options.
+ * @param {string} [options.source] Source label.
+ * @param {number} [options.permutationIndex] Permutation to describe.
+ * @returns {object} Analysis document.
+ */
+function deriveAnalysis(container, options = {}) {
+  const source = options.source || container.sourcePath || "memory";
+  const permutationIndex = options.permutationIndex ?? defaultPermutationIndex(container);
+  const effectDescription = describeRuntime(container, permutationIndex, source);
+  return buildEffectAnalysis({
+    effectDescription,
+    bindingManifest: HlslEffectBindingManifest.fromEffectDescription(effectDescription, {
+      effectName: source
+    }),
+    effectRes: {
+      sourcePath: source,
+      m_compilerVersion: null
+    },
+    selection: {
+      bodyIndex: permutationIndex,
+      selectedOptions: container.carbon.permutations.map(axis => ({
+        name: axis.name.value,
+        value: axis.options[axis.defaultOption]?.value ?? null
+      }))
+    }
+  }, {
+    source,
+    decodeBytecode: false,
+    decodeInstructions: false
+  });
+}
+
+/**
+ * Derives the WGSL set document for one permutation.
+ *
+ * `sourceMap` is absent rather than empty, and that is not an oversight: its
+ * offsets index DXBC bytes the container does not carry, so it is a translator
+ * diagnostic and was dropped on write. It was separately measured to suppress
+ * no sharing, so keeping it would have bought nothing either.
+ *
+ * @param {object} container Loaded container.
+ * @param {object} [options] View options.
+ * @param {number} [options.permutationIndex] Permutation to describe.
+ * @returns {object} WGSL set document.
+ */
+function deriveWgsl(container, options = {}) {
+  const permutationIndex = options.permutationIndex ?? defaultPermutationIndex(container);
+  const body = container.GetBackendBodyPrograms(permutationIndex);
+  const shaders = [];
+  const layouts = [];
+  const resourceTransforms = [];
+  for (const pass of body?.passes ?? []) {
+    for (const shader of pass.shaders) {
+      shaders.push({
+        key: shader.key,
+        techniqueName: shader.techniqueName,
+        passIndex: shader.passIndex,
+        stageName: shader.stageName,
+        stage: shader.stage,
+        stageType: shader.stageType,
+        entryPoint: shader.entryPoint,
+        code: shader.code,
+        ...(shader.threadGroupSize ? {
+          threadGroupSize: [...shader.threadGroupSize]
+        } : {})
+      });
+    }
+    for (const layout of pass.layouts) layouts.push(layout);
+    for (const transform of pass.resourceTransforms ?? []) resourceTransforms.push(transform);
+  }
+  return {
+    format: "CJS_WGSL_SET",
+    formatVersion: WGSL_SET_VERSION,
+    shaders,
+    layouts,
+    ...(resourceTransforms.length ? {
+      resourceTransforms
+    } : {})
+  };
+}
+
+/**
+ * Derives the `WGSB` body-set view the chunk package used to store.
+ *
+ * `engine-webgpu` resolves a permutation's translated programs through this,
+ * which is part of the recorded layering defect -- it should read the shader,
+ * not a package document. The view keeps that path working unchanged while the
+ * wire format moves underneath it, and goes away with the cleanup.
+ *
+ * Nothing here is stored. A body's status is whether its stages carry programs,
+ * its passes are the record tree's passes, and a pass unit is that pass's
+ * shaders and layouts. Bodies are keyed by distinct stored offset, which is
+ * exactly what Carbon's alias dedupe produces.
+ *
+ * @param {object} container Loaded container.
+ * @returns {object} Body-set document.
+ */
+function deriveBackendBodySet(container) {
+  const bodyKeys = container.bodyKeyByOffset;
+  const passUnits = [];
+  const bodies = [];
+  const seen = new Set();
+  for (let index = 0; index < container.carbon.records.length; index += 1) {
+    const offset = container.carbon.records[index].offset;
+    if (seen.has(offset)) continue;
+    seen.add(offset);
+    const bodyKey = bodyKeys.get(offset);
+    const body = container.GetBackendBodyPrograms(index);
+    if (!body || body.status !== "translated") {
+      bodies.push({
+        bodyKey,
+        representativePermutationIndex: index,
+        status: "unsupported",
+        error: body?.error ?? "body carries no translated programs",
+        passCount: 0,
+        passes: []
+      });
+      continue;
+    }
+    const passes = [];
+    for (const pass of body.passes) {
+      const unit = {
+        key: `unit${passUnits.length}`,
+        // Hashed from the unit's own content. The chunk body set stored
+        // this digest to detect a unit drifting from what referenced it;
+        // derived from the content it identifies, it cannot.
+        sha256: sha256Utf8(`${JSON.stringify({
+          shaders: pass.shaders,
+          layouts: pass.layouts,
+          resourceTransforms: pass.resourceTransforms ?? []
+        })}
+`),
+        wgslSetVersion: WGSL_SET_VERSION,
+        shaders: pass.shaders,
+        layouts: pass.layouts,
+        ...(pass.resourceTransforms?.length ? {
+          resourceTransforms: pass.resourceTransforms
+        } : {})
+      };
+      passUnits.push(unit);
+      passes.push({
+        passKey: pass.passKey,
+        unitKey: unit.key
+      });
+    }
+    bodies.push({
+      bodyKey,
+      representativePermutationIndex: index,
+      status: "translated",
+      error: null,
+      passCount: passes.length,
+      passes
+    });
+  }
+  return {
+    format: "CJS_WGSL_BODY_SET",
+    formatVersion: 1,
+    bodyCount: bodies.length,
+    translatedBodyCount: bodies.filter(body => body.status === "translated").length,
+    passUnitCount: passUnits.length,
+    passUnits,
+    bodies
+  };
+}
+
+/**
+ * Finds the permutation a package resolves to.
+ *
+ * A "selected" package is not a different format -- the container always carries
+ * every permutation. What makes it selected is that exactly one body was
+ * translated, so the resolved permutation is the first one whose body carries
+ * programs. When every body is translated, there is nothing to single out and
+ * Carbon's own default applies.
+ *
+ * @param {object} container Loaded container.
+ * @returns {number} Permutation index.
+ */
+function resolvedPermutationIndex(container) {
+  const translated = [];
+  const seen = new Set();
+  for (let index = 0; index < container.carbon.records.length; index += 1) {
+    const offset = container.carbon.records[index].offset;
+    if (seen.has(offset)) continue;
+    seen.add(offset);
+    const body = container.GetBackendBodyPrograms(index);
+    if (body?.status === "translated") translated.push(index);
+    if (translated.length > 1) return defaultPermutationIndex(container);
+  }
+  return translated.length === 1 ? translated[0] : defaultPermutationIndex(container);
+}
+
+/**
+ * Derives the `META`-shaped view the chunk package used to store.
+ *
+ * Every field here is recovered from the records rather than carried:
+ * `selectedOptions` from the resolved permutation's option indices, and
+ * `wgslSelection` from which passes and stages actually hold programs. Build-time
+ * *policy* -- `bodyMode`, `sourceIdentity`, `completeness` -- is deliberately not
+ * here: it describes how the artifact was produced, not what it is, and Carbon
+ * stores none of it.
+ *
+ * @param {object} container Loaded container.
+ * @param {object} [options] View options.
+ * @param {string} [options.source] Source label.
+ * @param {number} [options.permutationIndex] Permutation to describe.
+ * @returns {object} Metadata document.
+ */
+function deriveMetadata(container, options = {}) {
+  const source = options.source || container.sourcePath || "memory";
+  const permutationIndex = options.permutationIndex ?? resolvedPermutationIndex(container);
+  const variant = container.permutationGraph.variants[permutationIndex];
+  const axes = container.carbon.permutations;
+  const selectedOptions = axes.map((axis, axisIndex) => ({
+    name: axis.name.value,
+    value: axis.options[variant?.optionIndices?.[axisIndex] ?? axis.defaultOption]?.value ?? null
+  }));
+  const body = container.GetBackendBodyPrograms(permutationIndex);
+  const selectedStageKeys = (body?.passes ?? []).flatMap(pass => pass.shaders.map(shader => shader.key));
+  const passKeys = (body?.passes ?? []).map(pass => pass.passKey);
+  return {
+    effectName: source,
+    sourcePath: source,
+    bodyIndex: permutationIndex,
+    selectedOptions,
+    ...(passKeys.length === 1 ? {
+      wgslSelection: {
+        mode: "explicit",
+        completePasses: true,
+        techniqueName: passKeys[0].slice(0, passKeys[0].lastIndexOf(".pass")),
+        passIndex: Number(/\.pass([0-9]+)$/u.exec(passKeys[0])?.[1] ?? 0),
+        requestedStageNames: Array.from(new Set((body?.passes ?? []).flatMap(pass => pass.shaders.map(shader => shader.stageName)))),
+        selectedStageKeys
+      }
+    } : {})
+  };
+}
+
+/**
+ * Derives the `INFO`-shaped summary the chunk package used to store.
+ *
+ * Everything here is counted from the records rather than trusted from a stored
+ * field, which is why no digest accompanies it: a count derived from the thing
+ * it counts cannot disagree with it.
+ *
+ * @param {object} container Loaded container.
+ * @param {object} [options] View options.
+ * @param {string} [options.source] Source label.
+ * @returns {object} Info document.
+ */
+function deriveInfo(container, options = {}) {
+  const source = options.source || container.sourcePath || "memory";
+  const graph = container.permutationGraph;
+  return {
+    format: "CEWGPU",
+    packageKind: "tr2-effect-webgpu",
+    sourcePath: source,
+    effectVersion: container.carbon.version,
+    compilerVersion: [...container.carbon.compilerVersion],
+    permutationCount: graph.variants.length,
+    uniqueBodyCount: graph.bodies.length
+  };
+}
+
+export { defaultPermutationIndex, deriveAnalysis, deriveBackendBodySet, deriveInfo, deriveMetadata, deriveWgsl, resolvedPermutationIndex };
+//# sourceMappingURL=containerViews.js.map

package/dist/formats/webgpu/core/cewgpu/containerViews.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"containerViews.js","sources":["../../../../../../src/formats/webgpu/core/cewgpu/containerViews.js"],"sourcesContent":["import { HlslEffectBindingManifest } from \"../../../hlsl/core/tr2/shader/HlslEffectBindingManifest.js\";\nimport { HlslShaderBytecode } from \"../../../hlsl/core/HlslShaderBytecode.js\";\nimport { hlslShaderStageName } from \"../../../hlsl/core/tr2/HlslRenderContextEnum.js\";\nimport { runtimeDescriptionFromCarbon } from \"../../../hlsl/core/carbonDescriptionToRuntime.js\";\nimport { buildEffectAnalysis } from \"../helpers.js\";\nimport { WGSL_SET_VERSION } from \"../wgsl/buildWgslSet.js\";\nimport { sha256Utf8 } from \"../../../../format/effect/sha256.js\";\n\n/**\n * Derived compatibility views over a container.\n *\n * The chunk package stored `ANLS` and `WGSL` as documents beside the reflection\n * they were computed from, and carried digests to detect the two disagreeing.\n * The container stores one document, so these are **views**: functions of the\n * records, computed on read. The class of bug the digests guarded cannot occur,\n * because there is no second copy to drift.\n *\n * The analysis view is deliberately not a reimplementation. It runs\n * `buildEffectAnalysis` — the same function the packager runs on source — over a\n * description rebuilt by `runtimeDescriptionFromCarbon`. That is what keeps the\n * view honest: if it were rewritten to emit the fields consumers read today, it\n * would be free to drift from the real analysis, and nothing would notice.\n * `carbon-analysis-adapter-corpus.test.mjs` diffs the two over every shipped\n * permutation and finds zero differences.\n *\n * These views exist for `engine-webgpu`, which reads format-package JSON for\n * Carbon reflection instead of reading `Tr2Shader`. That is a recorded layering\n * defect and is not this port's to fix; the views keep it working unchanged\n * while the wire format moves underneath it. They go away with that cleanup.\n */\n\n/**\n * Resolves the permutation Carbon's own `GetShader()` would select with no\n * option overrides.\n *\n * Carbon multiplies each axis's default option by the running product of the\n * preceding axes' option counts. The chunk package stored a single selected\n * body and its index; the container carries every permutation, so the view has\n * to name a default rather than inherit one, and Carbon's own default is the\n * only defensible choice.\n *\n * @param {object} container Loaded container.\n * @returns {number} Permutation index.\n */\nexport function defaultPermutationIndex(container)\n{\n    let multiplier = 1;\n    let index = 0;\n    for (const axis of container.carbon.permutations)\n    {\n        index += axis.defaultOption * multiplier;\n        multiplier *= axis.options.length || 1;\n    }\n    return index < container.carbon.records.length ? index : 0;\n}\n\n/**\n * Rebuilds the runtime effect description for one permutation.\n *\n * @param {object} container Loaded container.\n * @param {number} permutationIndex Permutation index.\n * @param {string} source Source label.\n * @returns {object} Runtime-shaped effect description.\n */\nfunction describeRuntime(container, permutationIndex, source)\n{\n    return runtimeDescriptionFromCarbon(container.GetDescription(permutationIndex), {\n        effectName: source,\n        version: container.carbon.version,\n        bytecodeFor: (stage, stageType) => new HlslShaderBytecode({\n            stageType,\n            // Carbon's six stage names, not WebGPU's three. A three-entry table\n            // reports a geometry stage as null, which the corpus caught.\n            stageName: hlslShaderStageName(stageType),\n            bytes: stage.shaderData.bytes,\n            shaderSize: stage.shaderData.size,\n            stringTableOffset: stage.shaderData.offset,\n            effectName: source\n        })\n    });\n}\n\n/**\n * Derives the analysis document for one permutation.\n *\n * One field is honestly different from the stored `ANLS` it replaces:\n * `stages[].shaderBytecode` describes the **WGSL** program the container\n * carries, where the stored document described the source DXBC. The container\n * does not carry DXBC, so reproducing the old numbers would mean inventing\n * them. Nothing in the engine's read surface uses this field; it is a\n * diagnostic.\n *\n * @param {object} container Loaded container.\n * @param {object} [options] View options.\n * @param {string} [options.source] Source label.\n * @param {number} [options.permutationIndex] Permutation to describe.\n * @returns {object} Analysis document.\n */\nexport function deriveAnalysis(container, options = {})\n{\n    const source = options.source || container.sourcePath || \"memory\";\n    const permutationIndex = options.permutationIndex ?? defaultPermutationIndex(container);\n    const effectDescription = describeRuntime(container, permutationIndex, source);\n\n    return buildEffectAnalysis({\n        effectDescription,\n        bindingManifest: HlslEffectBindingManifest.fromEffectDescription(effectDescription, {\n            effectName: source\n        }),\n        effectRes: {\n            sourcePath: source,\n            m_compilerVersion: null\n        },\n        selection: {\n            bodyIndex: permutationIndex,\n            selectedOptions: container.carbon.permutations.map((axis) => ({\n                name: axis.name.value,\n                value: axis.options[axis.defaultOption]?.value ?? null\n            }))\n        }\n    }, { source, decodeBytecode: false, decodeInstructions: false });\n}\n\n/**\n * Derives the WGSL set document for one permutation.\n *\n * `sourceMap` is absent rather than empty, and that is not an oversight: its\n * offsets index DXBC bytes the container does not carry, so it is a translator\n * diagnostic and was dropped on write. It was separately measured to suppress\n * no sharing, so keeping it would have bought nothing either.\n *\n * @param {object} container Loaded container.\n * @param {object} [options] View options.\n * @param {number} [options.permutationIndex] Permutation to describe.\n * @returns {object} WGSL set document.\n */\nexport function deriveWgsl(container, options = {})\n{\n    const permutationIndex = options.permutationIndex ?? defaultPermutationIndex(container);\n    const body = container.GetBackendBodyPrograms(permutationIndex);\n    const shaders = [];\n    const layouts = [];\n    const resourceTransforms = [];\n\n    for (const pass of body?.passes ?? [])\n    {\n        for (const shader of pass.shaders)\n        {\n            shaders.push({\n                key: shader.key,\n                techniqueName: shader.techniqueName,\n                passIndex: shader.passIndex,\n                stageName: shader.stageName,\n                stage: shader.stage,\n                stageType: shader.stageType,\n                entryPoint: shader.entryPoint,\n                code: shader.code,\n                ...(shader.threadGroupSize ? { threadGroupSize: [ ...shader.threadGroupSize ] } : {})\n            });\n        }\n        for (const layout of pass.layouts) layouts.push(layout);\n        for (const transform of pass.resourceTransforms ?? []) resourceTransforms.push(transform);\n    }\n\n    return {\n        format: \"CJS_WGSL_SET\",\n        formatVersion: WGSL_SET_VERSION,\n        shaders,\n        layouts,\n        ...(resourceTransforms.length ? { resourceTransforms } : {})\n    };\n}\n\n/**\n * Derives the `WGSB` body-set view the chunk package used to store.\n *\n * `engine-webgpu` resolves a permutation's translated programs through this,\n * which is part of the recorded layering defect -- it should read the shader,\n * not a package document. The view keeps that path working unchanged while the\n * wire format moves underneath it, and goes away with the cleanup.\n *\n * Nothing here is stored. A body's status is whether its stages carry programs,\n * its passes are the record tree's passes, and a pass unit is that pass's\n * shaders and layouts. Bodies are keyed by distinct stored offset, which is\n * exactly what Carbon's alias dedupe produces.\n *\n * @param {object} container Loaded container.\n * @returns {object} Body-set document.\n */\nexport function deriveBackendBodySet(container)\n{\n    const bodyKeys = container.bodyKeyByOffset;\n    const passUnits = [];\n    const bodies = [];\n    const seen = new Set();\n\n    for (let index = 0; index < container.carbon.records.length; index += 1)\n    {\n        const offset = container.carbon.records[index].offset;\n        if (seen.has(offset)) continue;\n        seen.add(offset);\n\n        const bodyKey = bodyKeys.get(offset);\n        const body = container.GetBackendBodyPrograms(index);\n\n        if (!body || body.status !== \"translated\")\n        {\n            bodies.push({\n                bodyKey,\n                representativePermutationIndex: index,\n                status: \"unsupported\",\n                error: body?.error ?? \"body carries no translated programs\",\n                passCount: 0,\n                passes: []\n            });\n            continue;\n        }\n\n        const passes = [];\n        for (const pass of body.passes)\n        {\n            const unit = {\n                key: `unit${passUnits.length}`,\n                // Hashed from the unit's own content. The chunk body set stored\n                // this digest to detect a unit drifting from what referenced it;\n                // derived from the content it identifies, it cannot.\n                sha256: sha256Utf8(`${JSON.stringify({\n                    shaders: pass.shaders,\n                    layouts: pass.layouts,\n                    resourceTransforms: pass.resourceTransforms ?? []\n                })}\n`),\n                wgslSetVersion: WGSL_SET_VERSION,\n                shaders: pass.shaders,\n                layouts: pass.layouts,\n                ...(pass.resourceTransforms?.length\n                    ? { resourceTransforms: pass.resourceTransforms }\n                    : {})\n            };\n            passUnits.push(unit);\n            passes.push({ passKey: pass.passKey, unitKey: unit.key });\n        }\n\n        bodies.push({\n            bodyKey,\n            representativePermutationIndex: index,\n            status: \"translated\",\n            error: null,\n            passCount: passes.length,\n            passes\n        });\n    }\n\n    return {\n        format: \"CJS_WGSL_BODY_SET\",\n        formatVersion: 1,\n        bodyCount: bodies.length,\n        translatedBodyCount: bodies.filter((body) => body.status === \"translated\").length,\n        passUnitCount: passUnits.length,\n        passUnits,\n        bodies\n    };\n}\n\n/**\n * Finds the permutation a package resolves to.\n *\n * A \"selected\" package is not a different format -- the container always carries\n * every permutation. What makes it selected is that exactly one body was\n * translated, so the resolved permutation is the first one whose body carries\n * programs. When every body is translated, there is nothing to single out and\n * Carbon's own default applies.\n *\n * @param {object} container Loaded container.\n * @returns {number} Permutation index.\n */\nexport function resolvedPermutationIndex(container)\n{\n    const translated = [];\n    const seen = new Set();\n\n    for (let index = 0; index < container.carbon.records.length; index += 1)\n    {\n        const offset = container.carbon.records[index].offset;\n        if (seen.has(offset)) continue;\n        seen.add(offset);\n\n        const body = container.GetBackendBodyPrograms(index);\n        if (body?.status === \"translated\") translated.push(index);\n        if (translated.length > 1) return defaultPermutationIndex(container);\n    }\n\n    return translated.length === 1 ? translated[0] : defaultPermutationIndex(container);\n}\n\n/**\n * Derives the `META`-shaped view the chunk package used to store.\n *\n * Every field here is recovered from the records rather than carried:\n * `selectedOptions` from the resolved permutation's option indices, and\n * `wgslSelection` from which passes and stages actually hold programs. Build-time\n * *policy* -- `bodyMode`, `sourceIdentity`, `completeness` -- is deliberately not\n * here: it describes how the artifact was produced, not what it is, and Carbon\n * stores none of it.\n *\n * @param {object} container Loaded container.\n * @param {object} [options] View options.\n * @param {string} [options.source] Source label.\n * @param {number} [options.permutationIndex] Permutation to describe.\n * @returns {object} Metadata document.\n */\nexport function deriveMetadata(container, options = {})\n{\n    const source = options.source || container.sourcePath || \"memory\";\n    const permutationIndex = options.permutationIndex ?? resolvedPermutationIndex(container);\n    const variant = container.permutationGraph.variants[permutationIndex];\n    const axes = container.carbon.permutations;\n\n    const selectedOptions = axes.map((axis, axisIndex) => ({\n        name: axis.name.value,\n        value: axis.options[variant?.optionIndices?.[axisIndex] ?? axis.defaultOption]?.value ?? null\n    }));\n\n    const body = container.GetBackendBodyPrograms(permutationIndex);\n    const selectedStageKeys = (body?.passes ?? [])\n        .flatMap((pass) => pass.shaders.map((shader) => shader.key));\n    const passKeys = (body?.passes ?? []).map((pass) => pass.passKey);\n\n    return {\n        effectName: source,\n        sourcePath: source,\n        bodyIndex: permutationIndex,\n        selectedOptions,\n        ...(passKeys.length === 1\n            ? {\n                wgslSelection: {\n                    mode: \"explicit\",\n                    completePasses: true,\n                    techniqueName: passKeys[0].slice(0, passKeys[0].lastIndexOf(\".pass\")),\n                    passIndex: Number(/\\.pass([0-9]+)$/u.exec(passKeys[0])?.[1] ?? 0),\n                    requestedStageNames: Array.from(new Set(\n                        (body?.passes ?? []).flatMap((pass) => pass.shaders.map((shader) => shader.stageName))\n                    )),\n                    selectedStageKeys\n                }\n            }\n            : {})\n    };\n}\n\n/**\n * Derives the `INFO`-shaped summary the chunk package used to store.\n *\n * Everything here is counted from the records rather than trusted from a stored\n * field, which is why no digest accompanies it: a count derived from the thing\n * it counts cannot disagree with it.\n *\n * @param {object} container Loaded container.\n * @param {object} [options] View options.\n * @param {string} [options.source] Source label.\n * @returns {object} Info document.\n */\nexport function deriveInfo(container, options = {})\n{\n    const source = options.source || container.sourcePath || \"memory\";\n    const graph = container.permutationGraph;\n    return {\n        format: \"CEWGPU\",\n        packageKind: \"tr2-effect-webgpu\",\n        sourcePath: source,\n        effectVersion: container.carbon.version,\n        compilerVersion: [ ...container.carbon.compilerVersion ],\n        permutationCount: graph.variants.length,\n        uniqueBodyCount: graph.bodies.length\n    };\n}\n\nexport default deriveAnalysis;\n"],"names":["defaultPermutationIndex","container","multiplier","index","axis","carbon","permutations","defaultOption","options","length","records","describeRuntime","permutationIndex","source","runtimeDescriptionFromCarbon","GetDescription","effectName","version","bytecodeFor","stage","stageType","HlslShaderBytecode","stageName","hlslShaderStageName","bytes","shaderData","shaderSize","size","stringTableOffset","offset","deriveAnalysis","sourcePath","effectDescription","buildEffectAnalysis","bindingManifest","HlslEffectBindingManifest","fromEffectDescription","effectRes","m_compilerVersion","selection","bodyIndex","selectedOptions","map","name","value","decodeBytecode","decodeInstructions","deriveWgsl","body","GetBackendBodyPrograms","shaders","layouts","resourceTransforms","pass","passes","shader","push","key","techniqueName","passIndex","entryPoint","code","threadGroupSize","layout","transform","format","formatVersion","WGSL_SET_VERSION","deriveBackendBodySet","bodyKeys","bodyKeyByOffset","passUnits","bodies","seen","Set","has","add","bodyKey","get","status","representativePermutationIndex","error","passCount","unit","sha256","sha256Utf8","JSON","stringify","wgslSetVersion","passKey","unitKey","bodyCount","translatedBodyCount","filter","passUnitCount","resolvedPermutationIndex","translated","deriveMetadata","variant","permutationGraph","variants","axes","axisIndex","optionIndices","selectedStageKeys","flatMap","passKeys","wgslSelection","mode","completePasses","slice","lastIndexOf","Number","exec","requestedStageNames","Array","from","deriveInfo","graph","packageKind","effectVersion","compilerVersion","permutationCount","uniqueBodyCount"],"mappings":"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"}

package/dist/formats/webgpu/core/cewgpu/validateContainer.js

@@ -0,0 +1,90 @@
+import { WebgpuReadError } from '../errors.js';
+
+/**
+ * Structural validation for a loaded WebGPU effect container.
+ *
+ * This replaces `validateEffectPackageEnvelope`, which was 1762 lines. Most of
+ * that is **deleted rather than translated**, and the reason matters: those
+ * checks were not format invariants. The chunk container shattered one logical
+ * tree into flat string-keyed arrays across `INFO`, `META`, `ANLS`, `WGSL`,
+ * `PGRF` and `WGSB`, each holding a projection of the same effect, and roughly
+ * 600 lines asserted that the projections still agreed with each other. A record
+ * layout makes that question unaskable: containment replaces reference, position
+ * replaces key, and the count word before an array replaces `Array.isArray`.
+ *
+ * What is deliberately **not** re-checked here, because phase 1 already enforces
+ * it and checking twice means two places to keep correct:
+ *
+ * - count caps, arena containment, offset-table density and positional indexing,
+ *   and the version range — `CjsCarbonEffectReader`;
+ * - every sized record parsing to exactly its declared end — Rule 1, in the
+ *   record codec and the block codec;
+ * - duplicate stage type within a pass, and stage-type range — the shape adapter
+ *   fails closed on both, which is where a runtime description is built.
+ *
+ * What remains is the one thing that is genuinely this layer's: the container
+ * admits all six of Carbon's stage types by design, and WebGPU can express three.
+ * That restriction belongs to the backend, not to the container — the Carbon
+ * region is backend-invariant, and a container that admitted only three would not
+ * be Carbon's container.
+ */
+
+/** Stage types WebGPU can express, by Carbon's `InputStageType` numbering. */
+const WEBGPU_STAGE_TYPES = new Set([0, 1, 2]);
+
+/**
+ * Validates a loaded container for WebGPU consumption.
+ *
+ * @param {object} container Loaded `CewgpuContainer`.
+ * @param {object} [options] Validation options.
+ * @param {string} [options.source] Source label for diagnostics.
+ * @throws {WebgpuReadError} When the container cannot serve WebGPU.
+ */
+function validateEffectContainer(container, options = {}) {
+  const source = options.source || container.sourcePath || "memory";
+  if (!container?.IsGood()) {
+    throw new WebgpuReadError("CEWGPU container is not readable", {
+      source,
+      cause: container?.readError ?? null
+    });
+  }
+  if (!container.carbon.records.length) {
+    throw new WebgpuReadError("CEWGPU container declares no permutation bodies", {
+      source
+    });
+  }
+
+  // One check per distinct stored body. Aliased rows share a blob, so checking
+  // per permutation would re-check identical bytes up to twenty times over on
+  // the effects that alias hardest.
+  const checked = new Set();
+  for (let index = 0; index < container.carbon.records.length; index += 1) {
+    const offset = container.carbon.records[index].offset;
+    if (checked.has(offset)) continue;
+    checked.add(offset);
+    const description = container.GetDescription(index);
+    for (const technique of description.techniques) {
+      for (const [passIndex, pass] of technique.passes.entries()) {
+        for (const stage of pass.stages) {
+          // A stage carrying no program is reflection-only: the body
+          // is known, the translation is not, and the emitter says so
+          // with a zero-length payload. Those are legitimate — 107
+          // shipped body-passes carry a geometry stage — so the rule
+          // is about stages with a program, not about stages.
+          if (stage.shaderData.size === 0) continue;
+          if (!WEBGPU_STAGE_TYPES.has(stage.type)) {
+            throw new WebgpuReadError(`CEWGPU container carries a program for stage type ${stage.type}, ` + "which WebGPU cannot express", {
+              source,
+              permutationIndex: index,
+              pass: `${technique.name.value}.pass${passIndex}`,
+              stageType: stage.type
+            });
+          }
+        }
+      }
+    }
+  }
+}
+
+export { validateEffectContainer };
+//# sourceMappingURL=validateContainer.js.map

package/dist/formats/webgpu/core/cewgpu/validateContainer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateContainer.js","sources":["../../../../../../src/formats/webgpu/core/cewgpu/validateContainer.js"],"sourcesContent":["import { WebgpuReadError } from \"../errors.js\";\n\n/**\n * Structural validation for a loaded WebGPU effect container.\n *\n * This replaces `validateEffectPackageEnvelope`, which was 1762 lines. Most of\n * that is **deleted rather than translated**, and the reason matters: those\n * checks were not format invariants. The chunk container shattered one logical\n * tree into flat string-keyed arrays across `INFO`, `META`, `ANLS`, `WGSL`,\n * `PGRF` and `WGSB`, each holding a projection of the same effect, and roughly\n * 600 lines asserted that the projections still agreed with each other. A record\n * layout makes that question unaskable: containment replaces reference, position\n * replaces key, and the count word before an array replaces `Array.isArray`.\n *\n * What is deliberately **not** re-checked here, because phase 1 already enforces\n * it and checking twice means two places to keep correct:\n *\n * - count caps, arena containment, offset-table density and positional indexing,\n *   and the version range — `CjsCarbonEffectReader`;\n * - every sized record parsing to exactly its declared end — Rule 1, in the\n *   record codec and the block codec;\n * - duplicate stage type within a pass, and stage-type range — the shape adapter\n *   fails closed on both, which is where a runtime description is built.\n *\n * What remains is the one thing that is genuinely this layer's: the container\n * admits all six of Carbon's stage types by design, and WebGPU can express three.\n * That restriction belongs to the backend, not to the container — the Carbon\n * region is backend-invariant, and a container that admitted only three would not\n * be Carbon's container.\n */\n\n/** Stage types WebGPU can express, by Carbon's `InputStageType` numbering. */\nconst WEBGPU_STAGE_TYPES = new Set([ 0, 1, 2 ]);\n\n/**\n * Validates a loaded container for WebGPU consumption.\n *\n * @param {object} container Loaded `CewgpuContainer`.\n * @param {object} [options] Validation options.\n * @param {string} [options.source] Source label for diagnostics.\n * @throws {WebgpuReadError} When the container cannot serve WebGPU.\n */\nexport function validateEffectContainer(container, options = {})\n{\n    const source = options.source || container.sourcePath || \"memory\";\n\n    if (!container?.IsGood())\n    {\n        throw new WebgpuReadError(\"CEWGPU container is not readable\", {\n            source,\n            cause: container?.readError ?? null\n        });\n    }\n\n    if (!container.carbon.records.length)\n    {\n        throw new WebgpuReadError(\"CEWGPU container declares no permutation bodies\", { source });\n    }\n\n    // One check per distinct stored body. Aliased rows share a blob, so checking\n    // per permutation would re-check identical bytes up to twenty times over on\n    // the effects that alias hardest.\n    const checked = new Set();\n\n    for (let index = 0; index < container.carbon.records.length; index += 1)\n    {\n        const offset = container.carbon.records[index].offset;\n        if (checked.has(offset)) continue;\n        checked.add(offset);\n\n        const description = container.GetDescription(index);\n\n        for (const technique of description.techniques)\n        {\n            for (const [ passIndex, pass ] of technique.passes.entries())\n            {\n                for (const stage of pass.stages)\n                {\n                    // A stage carrying no program is reflection-only: the body\n                    // is known, the translation is not, and the emitter says so\n                    // with a zero-length payload. Those are legitimate — 107\n                    // shipped body-passes carry a geometry stage — so the rule\n                    // is about stages with a program, not about stages.\n                    if (stage.shaderData.size === 0) continue;\n\n                    if (!WEBGPU_STAGE_TYPES.has(stage.type))\n                    {\n                        throw new WebgpuReadError(\n                            `CEWGPU container carries a program for stage type ${stage.type}, `\n                            + \"which WebGPU cannot express\",\n                            {\n                                source,\n                                permutationIndex: index,\n                                pass: `${technique.name.value}.pass${passIndex}`,\n                                stageType: stage.type\n                            }\n                        );\n                    }\n                }\n            }\n        }\n    }\n}\n\nexport default validateEffectContainer;\n"],"names":["WEBGPU_STAGE_TYPES","Set","validateEffectContainer","container","options","source","sourcePath","IsGood","WebgpuReadError","cause","readError","carbon","records","length","checked","index","offset","has","add","description","GetDescription","technique","techniques","passIndex","pass","passes","entries","stage","stages","shaderData","size","type","permutationIndex","name","value","stageType"],"mappings":";;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,MAAMA,kBAAkB,GAAG,IAAIC,GAAG,CAAC,CAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAE,CAAC;;AAE/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAASC,uBAAuBA,CAACC,SAAS,EAAEC,OAAO,GAAG,EAAE,EAC/D;EACI,MAAMC,MAAM,GAAGD,OAAO,CAACC,MAAM,IAAIF,SAAS,CAACG,UAAU,IAAI,QAAQ;AAEjE,EAAA,IAAI,CAACH,SAAS,EAAEI,MAAM,EAAE,EACxB;AACI,IAAA,MAAM,IAAIC,eAAe,CAAC,kCAAkC,EAAE;MAC1DH,MAAM;AACNI,MAAAA,KAAK,EAAEN,SAAS,EAAEO,SAAS,IAAI;AACnC,KAAC,CAAC;AACN,EAAA;EAEA,IAAI,CAACP,SAAS,CAACQ,MAAM,CAACC,OAAO,CAACC,MAAM,EACpC;AACI,IAAA,MAAM,IAAIL,eAAe,CAAC,iDAAiD,EAAE;AAAEH,MAAAA;AAAO,KAAC,CAAC;AAC5F,EAAA;;AAEA;AACA;AACA;AACA,EAAA,MAAMS,OAAO,GAAG,IAAIb,GAAG,EAAE;AAEzB,EAAA,KAAK,IAAIc,KAAK,GAAG,CAAC,EAAEA,KAAK,GAAGZ,SAAS,CAACQ,MAAM,CAACC,OAAO,CAACC,MAAM,EAAEE,KAAK,IAAI,CAAC,EACvE;IACI,MAAMC,MAAM,GAAGb,SAAS,CAACQ,MAAM,CAACC,OAAO,CAACG,KAAK,CAAC,CAACC,MAAM;AACrD,IAAA,IAAIF,OAAO,CAACG,GAAG,CAACD,MAAM,CAAC,EAAE;AACzBF,IAAAA,OAAO,CAACI,GAAG,CAACF,MAAM,CAAC;AAEnB,IAAA,MAAMG,WAAW,GAAGhB,SAAS,CAACiB,cAAc,CAACL,KAAK,CAAC;AAEnD,IAAA,KAAK,MAAMM,SAAS,IAAIF,WAAW,CAACG,UAAU,EAC9C;AACI,MAAA,KAAK,MAAM,CAAEC,SAAS,EAAEC,IAAI,CAAE,IAAIH,SAAS,CAACI,MAAM,CAACC,OAAO,EAAE,EAC5D;AACI,QAAA,KAAK,MAAMC,KAAK,IAAIH,IAAI,CAACI,MAAM,EAC/B;AACI;AACA;AACA;AACA;AACA;AACA,UAAA,IAAID,KAAK,CAACE,UAAU,CAACC,IAAI,KAAK,CAAC,EAAE;UAEjC,IAAI,CAAC9B,kBAAkB,CAACiB,GAAG,CAACU,KAAK,CAACI,IAAI,CAAC,EACvC;YACI,MAAM,IAAIvB,eAAe,CACrB,CAAA,kDAAA,EAAqDmB,KAAK,CAACI,IAAI,CAAA,EAAA,CAAI,GACjE,6BAA6B,EAC/B;cACI1B,MAAM;AACN2B,cAAAA,gBAAgB,EAAEjB,KAAK;cACvBS,IAAI,EAAE,GAAGH,SAAS,CAACY,IAAI,CAACC,KAAK,CAAA,KAAA,EAAQX,SAAS,CAAA,CAAE;cAChDY,SAAS,EAAER,KAAK,CAACI;AACrB,aACJ,CAAC;AACL,UAAA;AACJ,QAAA;AACJ,MAAA;AACJ,IAAA;AACJ,EAAA;AACJ;;;;"}

package/dist/formats/webgpu/core/effectBackendBodySet.js

@@ -9,19 +9,20 @@ import { buildWgslSet } from './wgsl/buildWgslSet.js';
 import { buildResourceTransformPlan } from './wgsl/buildResourceTransformPlan.js';
 import { sha256Utf8, sha256Bytes } from '../../../format/effect/sha256.js';
 import { selectEffectStages } from './packageEffectSelection.js';
+import { compareUtf8 } from '../../../format/compareUtf8.js';
 import { isParticleClearEffectCandidate, preflightParticleClearEffectProfile, particleClearEffectProofFor } from './wgsl/lowerParticleClearComputePrograms.js';
 
 const EFFECT_BACKEND_BODY_SET_CHUNK = "WGSB";
 const EFFECT_BACKEND_BODY_SET_FORMAT = "CJS_WGSL_BODY_SET";
 const EFFECT_BACKEND_BODY_SET_VERSION = 1;
 
-/**
- * One translation unit is exactly one pass of one body: the binding plan, the
- * resource-transform plan, and every stage's emitted WGSL are derived together.
- * Bodies that share an identical pass signature therefore share one unit.
- *
- * @param {object} pass Pass entry carrying its ordered stage records.
- * @returns {string} Stable signature for the pass translation unit.
+/**
+ * One translation unit is exactly one pass of one body: the binding plan, the
+ * resource-transform plan, and every stage's emitted WGSL are derived together.
+ * Bodies that share an identical pass signature therefore share one unit.
+ *
+ * @param {object} pass Pass entry carrying its ordered stage records.
+ * @returns {string} Stable signature for the pass translation unit.
  */
 function passUnitSignature(pass) {
   return JSON.stringify({
@@ -33,7 +34,7 @@ function passUnitSignature(pass) {
       // An effect profile changes emission, so two otherwise identical
       // passes must not share one unit when their proofs differ.
       effectProfileProof: stage.effectProfileProof ? sha256Utf8(JSON.stringify(stage.effectProfileProof)) : null
-    })).sort((left, right) => left.stageName.localeCompare(right.stageName))
+    })).sort((left, right) => compareUtf8(left.stageName, right.stageName))
   });
 }
 function collectBodyStageBytecode(effectDescription) {
@@ -156,19 +157,19 @@ function translatePassUnit(pass, programForKey, source, bindingPolicy) {
   })));
 }
 
-/**
- * Translate every unique source body into backend programs, layouts, and
- * resource transforms, sharing one translation unit between bodies whose pass
- * is byte-for-byte identical.
- *
+/**
+ * Translate every unique source body into backend programs, layouts, and
+ * resource transforms, sharing one translation unit between bodies whose pass
+ * is byte-for-byte identical.
+ *
  * A body that cannot be lowered is retained as an explicitly unsupported
- * record. Its complete source reflection stays in `RFLX`, so a partial backend
- * never removes source truth.
- *
- * @param {object} effectRes Loaded version-15 `Tr2EffectRes`.
- * @param {object} permutationGraph Validated `PGRF` document.
- * @param {object} [options] Source label, stage selection, and binding policy.
- * @returns {object} Frozen `CJS_WGSL_BODY_SET` document.
+ * in-memory record carrying its reason. Portable source reflection is built
+ * separately from the same effect; this body-set document does not store it.
+ *
+ * @param {object} effectRes Loaded version-15 `Tr2EffectRes`.
+ * @param {object} permutationGraph Validated `PGRF` document.
+ * @param {object} [options] Source label, stage selection, and binding policy.
+ * @returns {object} Frozen `CJS_WGSL_BODY_SET` document.
  */
 function buildEffectBackendBodySet(effectRes, permutationGraph, options = {}) {
   const source = options.source || "memory";