@carbonenginejs/runtime-resource 0.12.1 → 0.13.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"containerViews.js","sources":["../../../../../../src/formats/webgpu/core/carbonWebgpu/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: \"CARBON_WEBGPU\",\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 → carbonWebgpu}/validateContainer.js

@@ -1,90 +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
+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 `CarbonWebgpuContainer`.
+ * @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("Carbon WebGPU container is not readable", {
+      source,
+      cause: container?.readError ?? null
+    });
+  }
+  if (!container.carbon.records.length) {
+    throw new WebgpuReadError("Carbon WebGPU 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(`Carbon WebGPU 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/carbonWebgpu/validateContainer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateContainer.js","sources":["../../../../../../src/formats/webgpu/core/carbonWebgpu/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 `CarbonWebgpuContainer`.\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(\"Carbon WebGPU 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(\"Carbon WebGPU 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                            `Carbon WebGPU 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,yCAAyC,EAAE;MACjEH,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,wDAAwD,EAAE;AAAEH,MAAAA;AAAO,KAAC,CAAC;AACnG,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,yDAAA,EAA4DmB,KAAK,CAACI,IAAI,CAAA,EAAA,CAAI,GACxE,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/effectAnalysis.js

@@ -1,82 +1,82 @@
-import { readEffectAnalysis as readEffectAnalysis$1 } from '../../hlsl/core/analysis.js';
-
-/**
- * Copy supported byte containers into an independent active byte view.
- *
- * @param {Array|ArrayBuffer|ArrayBufferView|null|undefined} value Byte source.
- * @param {string} context Error context.
- * @returns {Uint8Array|null} Copied bytes, or null when absent.
- */
-function normalizeBytecodeBytes(value, context) {
-  if (value === undefined || value === null) return null;
-  if (Array.isArray(value)) {
-    for (let index = 0; index < value.length; index++) {
-      if (!Object.prototype.hasOwnProperty.call(value, index) || !Number.isInteger(value[index]) || value[index] < 0 || value[index] > 255) {
-        throw new TypeError(`${context} must contain only byte values`);
-      }
-    }
-    return Uint8Array.from(value);
-  }
-  if (value instanceof Uint8Array) return Uint8Array.from(value);
-  if (value instanceof ArrayBuffer) return new Uint8Array(value.slice(0));
-  if (ArrayBuffer.isView(value)) {
-    return Uint8Array.from(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
-  }
-  throw new TypeError(`${context} must be an array or byte view`);
-}
-function collectStageBytecodeByKey(effectDescription) {
-  const bytecodeByKey = new Map();
-  for (const technique of effectDescription?.techniques ?? []) {
-    for (let passIndex = 0; passIndex < technique.passes.length; passIndex++) {
-      const stageInputs = technique.passes[passIndex].stageInputs;
-      for (let stageType = 0; stageType < stageInputs.length; stageType++) {
-        const stage = stageInputs[stageType];
-        if (!stage?.m_exists) continue;
-        const stageName = stage.cjsShaderBytecode?.stageName;
-        const bytecodeStageType = stage.cjsShaderBytecode?.stageType;
-        const value = stage.cjsShaderBytecode?.bytes;
-        if (!stageName || value === undefined || value === null) continue;
-        if (!Number.isInteger(bytecodeStageType) || bytecodeStageType !== stageType) {
-          throw new Error(`${technique.name}.pass${passIndex}.${stageName} stage type metadata is inconsistent`);
-        }
-        const key = `${technique.name}.pass${passIndex}.${stageName}`;
-        if (bytecodeByKey.has(key)) {
-          throw new Error(`Resolved effect contains duplicate stage bytecode ${key}`);
-        }
-        const bytes = normalizeBytecodeBytes(value, `${key} stage bytecode`);
-        if (!bytes?.length) {
-          throw new TypeError(`${key} stage bytecode must be a non-empty byte view`);
-        }
-        bytecodeByKey.set(key, {
-          techniqueName: technique.name,
-          passIndex,
-          stageType,
-          stageName,
-          bytes
-        });
-      }
-    }
-  }
-  return bytecodeByKey;
-}
-
-/**
- * Resolve one compiled-effect permutation for WebGPU packaging.
- *
- * format-hlsl owns source parsing, selected-permutation resolution, and the
- * binding manifest. This adapter adds only a validated transient byte index.
- *
- * @param {Uint8Array|ArrayBuffer|Buffer|DataView} input Tr2 effect bytes.
- * @param {object} [options] Source and permutation options.
- * @returns {object} Resolved raw effect, selection, reflection, and transient stage bytes.
- */
-function readEffectAnalysis(input, options = {}) {
-  const resolved = readEffectAnalysis$1(input, options);
-  return {
-    ...resolved,
-    stageBytecodeByKey: collectStageBytecodeByKey(resolved.effectDescription)
-  };
-}
-
-export { normalizeBytecodeBytes, readEffectAnalysis };
-//# sourceMappingURL=effectAnalysis.js.map
+import { readEffectAnalysis as readEffectAnalysis$1 } from '../../hlsl/core/analysis.js';
+
+/**
+ * Copy supported byte containers into an independent active byte view.
+ *
+ * @param {Array|ArrayBuffer|ArrayBufferView|null|undefined} value Byte source.
+ * @param {string} context Error context.
+ * @returns {Uint8Array|null} Copied bytes, or null when absent.
+ */
+function normalizeBytecodeBytes(value, context) {
+  if (value === undefined || value === null) return null;
+  if (Array.isArray(value)) {
+    for (let index = 0; index < value.length; index++) {
+      if (!Object.prototype.hasOwnProperty.call(value, index) || !Number.isInteger(value[index]) || value[index] < 0 || value[index] > 255) {
+        throw new TypeError(`${context} must contain only byte values`);
+      }
+    }
+    return Uint8Array.from(value);
+  }
+  if (value instanceof Uint8Array) return Uint8Array.from(value);
+  if (value instanceof ArrayBuffer) return new Uint8Array(value.slice(0));
+  if (ArrayBuffer.isView(value)) {
+    return Uint8Array.from(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
+  }
+  throw new TypeError(`${context} must be an array or byte view`);
+}
+function collectStageBytecodeByKey(effectDescription) {
+  const bytecodeByKey = new Map();
+  for (const technique of effectDescription?.techniques ?? []) {
+    for (let passIndex = 0; passIndex < technique.passes.length; passIndex++) {
+      const stageInputs = technique.passes[passIndex].stageInputs;
+      for (let stageType = 0; stageType < stageInputs.length; stageType++) {
+        const stage = stageInputs[stageType];
+        if (!stage?.m_exists) continue;
+        const stageName = stage.cjsShaderBytecode?.stageName;
+        const bytecodeStageType = stage.cjsShaderBytecode?.stageType;
+        const value = stage.cjsShaderBytecode?.bytes;
+        if (!stageName || value === undefined || value === null) continue;
+        if (!Number.isInteger(bytecodeStageType) || bytecodeStageType !== stageType) {
+          throw new Error(`${technique.name}.pass${passIndex}.${stageName} stage type metadata is inconsistent`);
+        }
+        const key = `${technique.name}.pass${passIndex}.${stageName}`;
+        if (bytecodeByKey.has(key)) {
+          throw new Error(`Resolved effect contains duplicate stage bytecode ${key}`);
+        }
+        const bytes = normalizeBytecodeBytes(value, `${key} stage bytecode`);
+        if (!bytes?.length) {
+          throw new TypeError(`${key} stage bytecode must be a non-empty byte view`);
+        }
+        bytecodeByKey.set(key, {
+          techniqueName: technique.name,
+          passIndex,
+          stageType,
+          stageName,
+          bytes
+        });
+      }
+    }
+  }
+  return bytecodeByKey;
+}
+
+/**
+ * Resolve one compiled-effect permutation for WebGPU packaging.
+ *
+ * format-hlsl owns source parsing, selected-permutation resolution, and the
+ * binding manifest. This adapter adds only a validated transient byte index.
+ *
+ * @param {Uint8Array|ArrayBuffer|Buffer|DataView} input Tr2 effect bytes.
+ * @param {object} [options] Source and permutation options.
+ * @returns {object} Resolved raw effect, selection, reflection, and transient stage bytes.
+ */
+function readEffectAnalysis(input, options = {}) {
+  const resolved = readEffectAnalysis$1(input, options);
+  return {
+    ...resolved,
+    stageBytecodeByKey: collectStageBytecodeByKey(resolved.effectDescription)
+  };
+}
+
+export { normalizeBytecodeBytes, readEffectAnalysis };
+//# sourceMappingURL=effectAnalysis.js.map