@carbonenginejs/runtime-resource 0.12.2 → 0.13.0

package/dist/formats/webgl/core/cewg/CewgPackageBuilder.js

@@ -1,104 +0,0 @@
-const CEWG_MAGIC = "CEWG";
-const CEWG_VERSION = 1;
-const textEncoder = new TextEncoder();
-
-/**
- * Builds CarbonEngineJS CEWG shader package bytes.
- */
-class CewgPackageBuilder {
-  /**
-  * Builds a CEWG v1 package from ordered chunks.
-  *
-  * @param {Array<[string, string|object|Uint8Array|ArrayBuffer|ArrayBufferView]>} chunks Ordered package chunks.
-  * @returns {Uint8Array} Package bytes.
-  */
-  static build(chunks) {
-    const encodedChunks = chunks.map(([tag, value]) => ({
-      tag: normalizeTag(tag),
-      bytes: normalizeChunkValue(value)
-    }));
-    const tags = new Set();
-    for (const chunk of encodedChunks) {
-      if (tags.has(chunk.tag)) {
-        throw new Error(`CEWG package contains duplicate chunk tag ${chunk.tag}`);
-      }
-      tags.add(chunk.tag);
-    }
-    const size = CEWG_MAGIC.length + 8 + encodedChunks.reduce((sum, chunk) => sum + 8 + chunk.bytes.length, 0);
-    const out = new Uint8Array(size);
-    const view = new DataView(out.buffer, out.byteOffset, out.byteLength);
-    let offset = 0;
-    offset = writeAscii(out, offset, CEWG_MAGIC);
-    view.setUint32(offset, CEWG_VERSION, true);
-    offset += 4;
-    view.setUint32(offset, encodedChunks.length, true);
-    offset += 4;
-    for (const chunk of encodedChunks) {
-      offset = writeAscii(out, offset, chunk.tag);
-      view.setUint32(offset, chunk.bytes.length, true);
-      offset += 4;
-      out.set(chunk.bytes, offset);
-      offset += chunk.bytes.length;
-    }
-    return out;
-  }
-}
-
-/**
- * Normalizes a package chunk tag.
- *
- * @param {string} tag Four-character chunk tag.
- * @returns {string} Normalized tag.
- */
-function normalizeTag(tag) {
-  if (typeof tag !== "string" || tag.length !== 4 || [...tag].some(character => {
-    const code = character.charCodeAt(0);
-    return code < 0x21 || code > 0x7e;
-  })) {
-    throw new Error(`CEWG chunk tag must contain four printable ASCII characters: ${tag}`);
-  }
-  return tag;
-}
-
-/**
- * Normalizes a package chunk payload.
- *
- * @param {string|object|Uint8Array|ArrayBuffer|ArrayBufferView} value Chunk payload.
- * @returns {Uint8Array} Payload bytes.
- */
-function normalizeChunkValue(value) {
-  if (typeof value === "string") {
-    return textEncoder.encode(value);
-  }
-  if (value instanceof Uint8Array) {
-    return value;
-  }
-  if (value instanceof ArrayBuffer) {
-    return new Uint8Array(value);
-  }
-  if (ArrayBuffer.isView(value)) {
-    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-  }
-  if (value && typeof value === "object") {
-    return textEncoder.encode(`${JSON.stringify(value)}\n`);
-  }
-  throw new Error("Unsupported CEWG chunk value");
-}
-
-/**
- * Writes ASCII text into a byte buffer.
- *
- * @param {Uint8Array} out Output buffer.
- * @param {number} offset Current byte offset.
- * @param {string} value ASCII text.
- * @returns {number} Updated byte offset.
- */
-function writeAscii(out, offset, value) {
-  for (let i = 0; i < value.length; i += 1) {
-    out[offset + i] = value.charCodeAt(i) & 0xff;
-  }
-  return offset + value.length;
-}
-
-export { CewgPackageBuilder };
-//# sourceMappingURL=CewgPackageBuilder.js.map

package/dist/formats/webgl/core/cewg/CewgPackageBuilder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"CewgPackageBuilder.js","sources":["../../../../../../src/formats/webgl/core/cewg/CewgPackageBuilder.js"],"sourcesContent":["const CEWG_MAGIC = \"CEWG\";\nconst CEWG_VERSION = 1;\nconst textEncoder = new TextEncoder();\n\n/**\n * Builds CarbonEngineJS CEWG shader package bytes.\n */\nexport class CewgPackageBuilder\n{\n    /**\n   * Builds a CEWG v1 package from ordered chunks.\n   *\n   * @param {Array<[string, string|object|Uint8Array|ArrayBuffer|ArrayBufferView]>} chunks Ordered package chunks.\n   * @returns {Uint8Array} Package bytes.\n   */\n    static build(chunks)\n    {\n        const encodedChunks = chunks.map(([ tag, value ]) => ({\n            tag: normalizeTag(tag),\n            bytes: normalizeChunkValue(value)\n        }));\n        const tags = new Set();\n        for (const chunk of encodedChunks)\n        {\n            if (tags.has(chunk.tag))\n            {\n                throw new Error(`CEWG package contains duplicate chunk tag ${chunk.tag}`);\n            }\n            tags.add(chunk.tag);\n        }\n\n        const size = CEWG_MAGIC.length + 8 + encodedChunks.reduce((sum, chunk) => sum + 8 + chunk.bytes.length, 0);\n        const out = new Uint8Array(size);\n        const view = new DataView(out.buffer, out.byteOffset, out.byteLength);\n        let offset = 0;\n\n        offset = writeAscii(out, offset, CEWG_MAGIC);\n        view.setUint32(offset, CEWG_VERSION, true);\n        offset += 4;\n        view.setUint32(offset, encodedChunks.length, true);\n        offset += 4;\n\n        for (const chunk of encodedChunks)\n        {\n            offset = writeAscii(out, offset, chunk.tag);\n            view.setUint32(offset, chunk.bytes.length, true);\n            offset += 4;\n            out.set(chunk.bytes, offset);\n            offset += chunk.bytes.length;\n        }\n\n        return out;\n    }\n}\n\n/**\n * Normalizes a package chunk tag.\n *\n * @param {string} tag Four-character chunk tag.\n * @returns {string} Normalized tag.\n */\nfunction normalizeTag(tag)\n{\n    if (typeof tag !== \"string\"\n        || tag.length !== 4\n        || [ ...tag ].some((character) =>\n        {\n            const code = character.charCodeAt(0);\n            return code < 0x21 || code > 0x7e;\n        }))\n    {\n        throw new Error(`CEWG chunk tag must contain four printable ASCII characters: ${tag}`);\n    }\n    return tag;\n}\n\n/**\n * Normalizes a package chunk payload.\n *\n * @param {string|object|Uint8Array|ArrayBuffer|ArrayBufferView} value Chunk payload.\n * @returns {Uint8Array} Payload bytes.\n */\nfunction normalizeChunkValue(value)\n{\n    if (typeof value === \"string\")\n    {\n        return textEncoder.encode(value);\n    }\n    if (value instanceof Uint8Array)\n    {\n        return value;\n    }\n    if (value instanceof ArrayBuffer)\n    {\n        return new Uint8Array(value);\n    }\n    if (ArrayBuffer.isView(value))\n    {\n        return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);\n    }\n    if (value && typeof value === \"object\")\n    {\n        return textEncoder.encode(`${JSON.stringify(value)}\\n`);\n    }\n    throw new Error(\"Unsupported CEWG chunk value\");\n}\n\n/**\n * Writes ASCII text into a byte buffer.\n *\n * @param {Uint8Array} out Output buffer.\n * @param {number} offset Current byte offset.\n * @param {string} value ASCII text.\n * @returns {number} Updated byte offset.\n */\nfunction writeAscii(out, offset, value)\n{\n    for (let i = 0; i < value.length; i += 1)\n    {\n        out[offset + i] = value.charCodeAt(i) & 0xff;\n    }\n    return offset + value.length;\n}\n"],"names":["CEWG_MAGIC","CEWG_VERSION","textEncoder","TextEncoder","CewgPackageBuilder","build","chunks","encodedChunks","map","tag","value","normalizeTag","bytes","normalizeChunkValue","tags","Set","chunk","has","Error","add","size","length","reduce","sum","out","Uint8Array","view","DataView","buffer","byteOffset","byteLength","offset","writeAscii","setUint32","set","some","character","code","charCodeAt","encode","ArrayBuffer","isView","JSON","stringify","i"],"mappings":"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"}

package/dist/formats/webgl/core/cewg/binary.js

@@ -1,19 +0,0 @@
-import { CjsByteReader } from '../../../../format/CjsByteReader.js';
-import { WebglReadError } from '../errors.js';
-export { asUint8Array } from '@carbonenginejs/runtime-utils/bytes';
-
-/**
- * Little-endian binary reader for the CEWG package container.
- *
- * The implementation is `CjsByteReader` in `src/format/`; this subclass only
- * supplies the error class and message this format reports. The CEWG container
- * has no string table, so only the raw-byte and `uint32` reads are exercised —
- * but they are now the shared ones rather than a third copy.
- */
-class WebglReader extends CjsByteReader {
-  static ReadError = WebglReadError;
-  static endOfDataMessage = "Unexpected end of CEWG package data";
-}
-
-export { WebglReader };
-//# sourceMappingURL=binary.js.map

package/dist/formats/webgl/core/cewg/binary.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"binary.js","sources":["../../../../../../src/formats/webgl/core/cewg/binary.js"],"sourcesContent":["import { CjsByteReader } from \"../../../../format/CjsByteReader.js\";\nimport { WebglReadError } from \"../errors.js\";\n\nexport { asUint8Array } from \"@carbonenginejs/runtime-utils/bytes\";\n\n/**\n * Little-endian binary reader for the CEWG package container.\n *\n * The implementation is `CjsByteReader` in `src/format/`; this subclass only\n * supplies the error class and message this format reports. The CEWG container\n * has no string table, so only the raw-byte and `uint32` reads are exercised —\n * but they are now the shared ones rather than a third copy.\n */\nexport class WebglReader extends CjsByteReader\n{\n    static ReadError = WebglReadError;\n\n    static endOfDataMessage = \"Unexpected end of CEWG package data\";\n}\n\nexport default WebglReader;\n"],"names":["WebglReader","CjsByteReader","ReadError","WebglReadError","endOfDataMessage"],"mappings":";;;;AAKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMA,WAAW,SAASC,aAAa,CAC9C;EACI,OAAOC,SAAS,GAAGC,cAAc;EAEjC,OAAOC,gBAAgB,GAAG,qCAAqC;AACnE;;;;"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"cewgCompleteness.js","sources":["../../../../../src/formats/webgl/core/cewgCompleteness.js"],"sourcesContent":["/**\n * Inspects CEWG stage records for complete WebGL2 raster passes.\n *\n * Geometry and compute stages are not raster-pair members. A raster pass is\n * complete only when both its vertex and pixel records exist and their shared\n * shader records contain successful translated source.\n *\n * @param {object[]} stages CEWG stage records.\n * @param {object[]} shaders CEWG translated shader records.\n * @returns {{ expectedPassCount: number, completePassCount: number, incompletePasses: object[] }}\n */\nexport function inspectCewgRasterCompleteness(stages, shaders)\n{\n    const shaderMap = new Map((shaders || []).map((shader) => [ shader.key, shader ]));\n    const usesSharedShaders = Array.isArray(shaders);\n    const groups = new Map();\n\n    for (const stage of stages || [])\n    {\n        if (stage.stageName !== \"vertex\" && stage.stageName !== \"pixel\") continue;\n\n        const key = [\n            stage.bodyKey || \"selected\",\n            stage.techniqueName || \"Main\",\n            Number.isInteger(stage.passIndex) ? stage.passIndex : 0\n        ].join(\":\");\n        let group = groups.get(key);\n        if (!group)\n        {\n            group = {\n                key,\n                bodyKey: stage.bodyKey || \"selected\",\n                techniqueName: stage.techniqueName || \"Main\",\n                passIndex: Number.isInteger(stage.passIndex) ? stage.passIndex : 0,\n                vertex: null,\n                pixel: null,\n                duplicateStages: []\n            };\n            groups.set(key, group);\n        }\n        if (group[stage.stageName])\n        {\n            group.duplicateStages.push(stage.stageName);\n        }\n        group[stage.stageName] = stage;\n    }\n\n    const incompletePasses = [];\n    let completePassCount = 0;\n\n    for (const group of groups.values())\n    {\n        const missingStages = [];\n        const unavailableStages = [];\n\n        for (const stageName of [ \"vertex\", \"pixel\" ])\n        {\n            const stage = group[stageName];\n            if (!stage)\n            {\n                missingStages.push(stageName);\n                continue;\n            }\n\n            const shader = usesSharedShaders ? shaderMap.get(stage.shaderKey) : stage;\n            if (!shader?.hlsl2webgl?.ok || !shader.source)\n            {\n                unavailableStages.push({\n                    stageName,\n                    stageKey: stage.key,\n                    shaderKey: stage.shaderKey,\n                    excluded: shader?.excluded || null,\n                    reason: shader?.hlsl2webgl?.validationError\n            || shader?.hlsl2webgl?.reason\n            || shader?.hlsl2webgl?.error\n            || shader?.excluded?.reason\n            || \"translated source is unavailable\"\n                });\n            }\n        }\n\n        if (!missingStages.length && !unavailableStages.length && !group.duplicateStages.length)\n        {\n            completePassCount += 1;\n            continue;\n        }\n\n        incompletePasses.push({\n            key: group.key,\n            bodyKey: group.bodyKey,\n            techniqueName: group.techniqueName,\n            passIndex: group.passIndex,\n            missingStages,\n            unavailableStages,\n            duplicateStages: [ ...new Set(group.duplicateStages) ].sort()\n        });\n    }\n\n    return {\n        expectedPassCount: groups.size,\n        completePassCount,\n        incompletePasses\n    };\n}\n\n/**\n * Checks the host-side routing contract emitted for compute-as-fragment\n * programs. A boolean marker is insufficient: the runtime needs the original\n * dispatch shape, dispatch-origin uniform, and every UAV render-target route.\n */\nexport function isCewgComputeFragmentContract(value)\n{\n    if (!value || typeof value !== \"object\" || Array.isArray(value)) return false;\n    if (!Array.isArray(value.threadGroup)\n    || value.threadGroup.length !== 3\n    || value.threadGroup.some((item) => !Number.isSafeInteger(item) || item < 1))\n    {\n        return false;\n    }\n    if (value.dispatchOriginUniform !== null\n    && (typeof value.dispatchOriginUniform !== \"string\" || !value.dispatchOriginUniform)) return false;\n    if (!Array.isArray(value.uavOutputs) || !value.uavOutputs.length) return false;\n\n    const locations = new Set();\n    const names = new Set();\n    const routes = new Set();\n    for (const output of value.uavOutputs)\n    {\n        if (!output || typeof output !== \"object\") return false;\n        if (!Number.isSafeInteger(output.register) || output.register < 0) return false;\n        if (output.slice !== null && (!Number.isSafeInteger(output.slice) || output.slice < 0)) return false;\n        if (!Number.isSafeInteger(output.location) || output.location < 0 || locations.has(output.location)) return false;\n        if (typeof output.glslName !== \"string\" || !output.glslName || names.has(output.glslName)) return false;\n        const route = `${output.register}:${output.slice === null ? \"dynamic\" : output.slice}`;\n        if (routes.has(route)) return false;\n        locations.add(output.location);\n        names.add(output.glslName);\n        routes.add(route);\n    }\n    return true;\n}\n\nconst DIAGNOSTIC_INTEGRITY_CODES = new Set([\n    \"declared_partial_package\",\n    \"failed_body\",\n    \"failed_metadata_body\",\n    \"filtered_package_scope\",\n    \"incomplete_pass_stage_family\",\n    \"unsupported_pass_stage_family\",\n    \"unsupported_stage\",\n    \"unavailable_stage_shader\",\n    \"unadapted_compute_stage\",\n    \"variant_body_has_no_program\"\n]);\n\n/** Returns true only for integrity failures allowed in explicit diagnostic packages. */\nexport function isCewgDiagnosticIntegrityError(error)\n{\n    return DIAGNOSTIC_INTEGRITY_CODES.has(error?.code);\n}\n\n/** Requires one unambiguous copy of every runtime-critical CEWG chunk. */\nexport function inspectCewgCoreChunks(chunks)\n{\n    const errors = [];\n    for (const tag of [ \"INFO\", \"META\", \"GLSL\" ])\n    {\n        const count = (chunks || []).filter((chunk) => chunk?.tag === tag).length;\n        if (count !== 1)\n        {\n            errors.push({\n                code: \"invalid_core_chunk_cardinality\",\n                tag,\n                count,\n                message: `CEWG package must contain exactly one ${tag} chunk; found ${count}`\n            });\n        }\n    }\n    return { ok: errors.length === 0, errors };\n}\n\n/** Formats a bounded error message for incomplete CEWG raster passes. */\nexport function formatIncompleteCewgPasses(incompletePasses, limit = 8)\n{\n    return (incompletePasses || []).slice(0, limit).map((entry) =>\n    {\n        const problems = [\n            ...entry.missingStages.map((stage) => `missing ${stage}`),\n            ...entry.unavailableStages.map((stage) => `${stage.stageName}: ${stage.reason}`),\n            ...(entry.duplicateStages || []).map((stage) => `duplicate ${stage}`)\n        ];\n        return `${entry.bodyKey} ${entry.techniqueName}[${entry.passIndex}] (${problems.join(\", \")})`;\n    }).join(\"; \");\n}\n\n/**\n * Inspects the complete all-permutation CEWG graph and declared package\n * failure counts. Legacy selected-only stage arrays receive the stage checks\n * that are possible without variant/body/shader tables.\n */\nexport function inspectCewgPackageIntegrity(info, metadata, glsl)\n{\n    const errors = [];\n    if (!glsl || typeof glsl !== \"object\")\n    {\n        addIntegrityError(errors, \"missing_glsl_set\", \"CEWG GLSL stage set is missing\");\n        return { ok: false, errors };\n    }\n\n    checkEnvelopeValue(info, \"format\", \"CEWG\", \"INFO\", errors);\n    if (![ 1, 2, 3 ].includes(info?.formatVersion))\n    {\n        addIntegrityError(\n            errors,\n            \"invalid_package_envelope\",\n            `INFO formatVersion must be 1, 2, or 3, got ${info?.formatVersion ?? \"<missing>\"}`,\n            {\n                section: \"INFO\",\n                field: \"formatVersion\",\n                expected: [ 1, 2, 3 ],\n                actual: info?.formatVersion ?? null\n            }\n        );\n    }\n    checkEnvelopeValue(glsl, \"format\", \"CEWG_GLSL_SET\", \"GLSL\", errors);\n    checkEnvelopeValue(glsl, \"formatVersion\", 1, \"GLSL\", errors);\n    checkSourceIdentity(info, errors);\n    const packageModes = new Map([\n        [ \"tr2-effect-webgl-permutations\", \"all\" ],\n        [ \"tr2-effect-webgl\", \"selected\" ]\n    ]);\n    const expectedMode = packageModes.get(info?.packageKind);\n    if (!expectedMode)\n    {\n        addIntegrityError(\n            errors,\n            \"unsupported_package_kind\",\n            `INFO packageKind is not a supported effect package: ${info?.packageKind ?? \"<missing>\"}`\n        );\n    }\n    if (![ \"all\", \"selected\" ].includes(info?.permutationMode))\n    {\n        addIntegrityError(errors, \"invalid_permutation_mode\", `INFO permutationMode is invalid: ${info?.permutationMode ?? \"<missing>\"}`);\n    }\n    if (![ \"all\", \"selected\" ].includes(glsl.permutationMode))\n    {\n        addIntegrityError(errors, \"invalid_permutation_mode\", `GLSL permutationMode is invalid: ${glsl.permutationMode ?? \"<missing>\"}`);\n    }\n    if (expectedMode && info?.permutationMode !== expectedMode)\n    {\n        addIntegrityError(\n            errors,\n            \"package_mode_mismatch\",\n            `INFO packageKind ${info.packageKind} requires permutationMode ${expectedMode}`\n        );\n    }\n    if (info?.permutationMode !== glsl.permutationMode)\n    {\n        addIntegrityError(\n            errors,\n            \"package_mode_mismatch\",\n            `INFO permutationMode ${info?.permutationMode ?? \"<missing>\"} does not match GLSL ${glsl.permutationMode ?? \"<missing>\"}`\n        );\n    }\n\n    checkPackageSelection(info?.selection, glsl.selection, errors);\n    if (expectedMode)\n    {\n        for (const field of [ \"variants\", \"bodies\", \"stages\", \"shaders\" ])\n        {\n            if (!Array.isArray(glsl[field]))\n            {\n                addIntegrityError(errors, \"missing_graph_array\", `GLSL ${field} array is required`, { field });\n            }\n        }\n        if (!metadata || typeof metadata !== \"object\")\n        {\n            addIntegrityError(errors, \"missing_metadata\", \"CEWG META object is required\");\n        }\n        else\n        {\n            for (const field of [ \"variants\", \"bodies\", \"permutations\" ])\n            {\n                if (!Array.isArray(metadata[field]))\n                {\n                    addIntegrityError(errors, \"missing_metadata_array\", `META ${field} array is required`, { field });\n                }\n            }\n        }\n    }\n\n    const stages = Array.isArray(glsl.stages) ? glsl.stages : [];\n    const usesSharedShaders = Array.isArray(glsl.shaders);\n    const shaders = usesSharedShaders ? glsl.shaders : [];\n    const bodies = Array.isArray(glsl.bodies) ? glsl.bodies : [];\n    const variants = Array.isArray(glsl.variants) ? glsl.variants : [];\n    const metadataBodies = Array.isArray(metadata?.bodies) ? metadata.bodies : [];\n    const metadataVariants = Array.isArray(metadata?.variants) ? metadata.variants : [];\n    const stageMap = keyedRecords(stages, \"stage\", errors);\n    const shaderMap = usesSharedShaders ? keyedRecords(shaders, \"shader\", errors) : new Map();\n    const bodyMap = keyedRecords(bodies, \"body\", errors);\n    const metadataBodyMap = keyedRecords(metadataBodies, \"metadata body\", errors);\n    const variantMap = usesSharedShaders ? keyedRecords(variants, \"variant\", errors) : new Map();\n    const metadataVariantMap = usesSharedShaders\n        ? keyedRecords(metadataVariants, \"metadata variant\", errors)\n        : new Map();\n    if (usesSharedShaders)\n    {\n        if (!variants.length) addIntegrityError(errors, \"missing_variants\", \"Shared-shader CEWG package has no variants\");\n    }\n    const referencedStages = new Set();\n    const referencedShaders = new Set();\n    const referencedBodies = new Set();\n    const passGroups = new Map();\n\n    for (const field of [ \"failedShaderCount\", \"excludedShaderCount\", \"failedBodyCount\" ])\n    {\n        const count = Number(info?.[field] || 0);\n        if (count > 0)\n        {\n            addIntegrityError(errors, \"declared_partial_package\", `INFO ${field} is ${count}`, { field, count });\n        }\n    }\n\n    const completeness = inspectCewgRasterCompleteness(stages, usesSharedShaders ? shaders : undefined);\n    checkRequiredCount(info, \"bodyStageCount\", stages.length, errors);\n    if (usesSharedShaders)\n    {\n        const excludedShaderCount = shaders.filter((shader) => shader?.excluded).length;\n        const failedShaderCount = shaders.filter((shader) => !shader?.hlsl2webgl?.ok && !shader?.excluded).length;\n        const failedBodyCount = bodies.filter((body) => body?.error).length;\n        const availableShaderCount = shaders.filter((shader) => shader?.hlsl2webgl?.ok && shader.source).length;\n        checkRequiredCount(info, \"permutationCount\", variants.length, errors);\n        checkRequiredCount(info, \"uniqueBodyCount\", bodies.length, errors);\n        checkRequiredCount(info, \"uniqueShaderCount\", shaders.length, errors);\n        checkRequiredCount(info, \"translatedShaderCount\", shaders.length - failedShaderCount - excludedShaderCount, errors);\n        checkRequiredCount(info, \"excludedShaderCount\", excludedShaderCount, errors);\n        checkRequiredCount(info, \"failedShaderCount\", failedShaderCount, errors);\n        checkRequiredCount(info, \"failedBodyCount\", failedBodyCount, errors);\n        checkRequiredCount(info, \"availableShaderCount\", availableShaderCount, errors);\n        checkRequiredCount(info, \"expectedRasterPassCount\", completeness.expectedPassCount, errors);\n        checkRequiredCount(info, \"completeRasterPassCount\", completeness.completePassCount, errors);\n        checkRequiredCount(info, \"incompleteRasterPassCount\", completeness.incompletePasses.length, errors);\n    }\n\n    if (usesSharedShaders)\n    {\n        const permutationIndexes = new Set();\n        for (const variant of variants)\n        {\n            referencedBodies.add(variant.bodyKey);\n            if (!bodyMap.has(variant.bodyKey))\n            {\n                addIntegrityError(\n                    errors,\n                    \"missing_variant_body\",\n                    `Variant ${variant.key || \"<unknown>\"} references missing body ${variant.bodyKey}`,\n                    { variantKey: variant.key || null, bodyKey: variant.bodyKey || null }\n                );\n            }\n            if (!Number.isSafeInteger(variant.permutationIndex) || variant.permutationIndex < 0)\n            {\n                addIntegrityError(\n                    errors,\n                    \"invalid_permutation_index\",\n                    `Variant ${variant.key || \"<unknown>\"} has invalid permutation index ${variant.permutationIndex}`,\n                    { variantKey: variant.key || null, permutationIndex: variant.permutationIndex }\n                );\n            }\n            else if (permutationIndexes.has(variant.permutationIndex))\n            {\n                addIntegrityError(\n                    errors,\n                    \"duplicate_permutation_index\",\n                    `Permutation index ${variant.permutationIndex} is used more than once`,\n                    { permutationIndex: variant.permutationIndex }\n                );\n            }\n            else\n            {\n                permutationIndexes.add(variant.permutationIndex);\n            }\n\n            const metadataVariant = metadataVariantMap.get(variant.key);\n            if (!metadataVariant)\n            {\n                addIntegrityError(\n                    errors,\n                    \"missing_metadata_variant\",\n                    `GLSL variant ${variant.key || \"<unknown>\"} has no matching metadata variant`,\n                    { variantKey: variant.key || null }\n                );\n            }\n            else if (metadataVariant.bodyKey !== variant.bodyKey\n        || metadataVariant.permutationIndex !== variant.permutationIndex)\n            {\n                addIntegrityError(\n                    errors,\n                    \"variant_metadata_mismatch\",\n                    `GLSL variant ${variant.key} does not match its metadata body/permutation mapping`,\n                    { variantKey: variant.key }\n                );\n            }\n        }\n\n        for (const variant of metadataVariants)\n        {\n            if (variant?.key && !variantMap.has(variant.key))\n            {\n                addIntegrityError(\n                    errors,\n                    \"orphan_metadata_variant\",\n                    `Metadata variant ${variant.key} has no matching GLSL variant`,\n                    { variantKey: variant.key }\n                );\n            }\n        }\n\n        for (const variant of metadataVariants)\n        {\n            if (!metadataBodyMap.has(variant.bodyKey))\n            {\n                addIntegrityError(\n                    errors,\n                    \"missing_metadata_variant_body\",\n                    `Metadata variant ${variant.key || \"<unknown>\"} references missing body ${variant.bodyKey}`,\n                    { variantKey: variant.key || null, bodyKey: variant.bodyKey || null }\n                );\n            }\n            if (variant.tableIndexMatchesPermutationIndex !== true\n        || !Number.isSafeInteger(variant.tableIndex)\n        || variant.tableIndex < 0\n        || variant.tableIndex !== variant.permutationIndex)\n            {\n                addIntegrityError(\n                    errors,\n                    \"permutation_table_mismatch\",\n                    `Variant ${variant.key || \"<unknown>\"} table index does not match its permutation index`,\n                    { variantKey: variant.key || null }\n                );\n            }\n        }\n        checkPermutationCoverage(metadata?.permutations, info?.permutationMode, variants, errors);\n\n        for (const body of bodies)\n        {\n            if (!metadataBodyMap.has(body.key))\n            {\n                addIntegrityError(\n                    errors,\n                    \"missing_metadata_body\",\n                    `GLSL body ${body.key || \"<unknown>\"} has no matching metadata body`,\n                    { bodyKey: body.key || null }\n                );\n            }\n            if (!referencedBodies.has(body.key))\n            {\n                addIntegrityError(errors, \"orphan_body\", `Body ${body.key} is not referenced by a variant`, { bodyKey: body.key });\n            }\n            if (body.error)\n            {\n                addIntegrityError(errors, \"failed_body\", `Body ${body.key} failed: ${body.error}`, { bodyKey: body.key });\n            }\n            if (!Array.isArray(body.stages))\n            {\n                addIntegrityError(errors, \"missing_body_stages\", `Body ${body.key} has no stage list`, { bodyKey: body.key });\n                continue;\n            }\n\n            const localStages = new Set();\n            for (const stageKey of body.stages)\n            {\n                if (localStages.has(stageKey))\n                {\n                    addIntegrityError(\n                        errors,\n                        \"duplicate_body_stage_reference\",\n                        `Body ${body.key} references stage ${stageKey} more than once`,\n                        { bodyKey: body.key, stageKey }\n                    );\n                }\n                localStages.add(stageKey);\n                referencedStages.add(stageKey);\n\n                const stage = stageMap.get(stageKey);\n                if (!stage)\n                {\n                    addIntegrityError(\n                        errors,\n                        \"missing_body_stage\",\n                        `Body ${body.key} references missing stage ${stageKey}`,\n                        { bodyKey: body.key, stageKey }\n                    );\n                }\n                else if (stage.bodyKey !== body.key)\n                {\n                    addIntegrityError(\n                        errors,\n                        \"stage_body_mismatch\",\n                        `Stage ${stageKey} belongs to ${stage.bodyKey}, not ${body.key}`,\n                        { bodyKey: body.key, stageKey, stageBodyKey: stage.bodyKey || null }\n                    );\n                }\n            }\n        }\n    }\n\n    for (const body of metadataBodies)\n    {\n        if (body?.key && !bodyMap.has(body.key))\n        {\n            addIntegrityError(\n                errors,\n                \"orphan_metadata_body\",\n                `Metadata body ${body.key} has no matching GLSL body`,\n                { bodyKey: body.key }\n            );\n        }\n        if (body.error)\n        {\n            addIntegrityError(\n                errors,\n                \"failed_metadata_body\",\n                `Metadata body ${body.key} failed: ${body.error}`,\n                { bodyKey: body.key }\n            );\n        }\n    }\n\n    for (const stage of stages)\n    {\n        if (!stage || typeof stage !== \"object\")\n        {\n            addIntegrityError(errors, \"invalid_stage_record\", \"GLSL stage record must be an object\");\n            continue;\n        }\n        const expectedStageTypes = { vertex: 0, pixel: 1, compute: 2, geometry: 3, hull: 4, domain: 5 };\n        if (typeof stage.techniqueName !== \"string\" || !stage.techniqueName)\n        {\n            addIntegrityError(errors, \"invalid_stage_technique\", `Stage ${stage.key || \"<unknown>\"} has no technique name`);\n        }\n        if (!Number.isSafeInteger(stage.passIndex) || stage.passIndex < 0)\n        {\n            addIntegrityError(\n                errors,\n                \"invalid_stage_pass_index\",\n                `Stage ${stage.key || \"<unknown>\"} has invalid pass index ${stage.passIndex}`,\n                { stageKey: stage.key || null, passIndex: stage.passIndex }\n            );\n        }\n        if (expectedStageTypes[stage.stageName] !== stage.stageType)\n        {\n            addIntegrityError(\n                errors,\n                \"stage_type_mismatch\",\n                `Stage ${stage.key || \"<unknown>\"} type ${stage.stageType} does not match ${stage.stageName || \"<missing>\"}`,\n                { stageKey: stage.key || null, stageType: stage.stageType, stageName: stage.stageName || null }\n            );\n        }\n        if (usesSharedShaders)\n        {\n            const expectedLocalKey = `${stage.techniqueName}.pass${stage.passIndex}.${stage.stageName}`;\n            if (stage.localKey !== expectedLocalKey || stage.key !== `${stage.bodyKey}.${expectedLocalKey}`)\n            {\n                addIntegrityError(\n                    errors,\n                    \"stage_key_mismatch\",\n                    `Stage ${stage.key || \"<unknown>\"} does not match its body/technique/pass/stage identity`,\n                    { stageKey: stage.key || null }\n                );\n            }\n        }\n        if (typeof stage.techniqueName === \"string\"\n      && stage.techniqueName\n      && Number.isSafeInteger(stage.passIndex)\n      && stage.passIndex >= 0)\n        {\n            const passKey = `${stage.bodyKey || \"selected\"}:${stage.techniqueName}:${stage.passIndex}`;\n            const group = passGroups.get(passKey) || [];\n            group.push(stage);\n            passGroups.set(passKey, group);\n        }\n\n        if (usesSharedShaders && !bodyMap.has(stage.bodyKey))\n        {\n            addIntegrityError(\n                errors,\n                \"missing_stage_body\",\n                `Stage ${stage.key} references missing body ${stage.bodyKey}`,\n                { stageKey: stage.key, bodyKey: stage.bodyKey || null }\n            );\n        }\n        if (usesSharedShaders && !referencedStages.has(stage.key))\n        {\n            addIntegrityError(errors, \"orphan_stage\", `Stage ${stage.key} is not referenced by its body`, { stageKey: stage.key });\n        }\n\n        const shader = usesSharedShaders ? shaderMap.get(stage.shaderKey) : stage;\n        if (usesSharedShaders)\n        {\n            referencedShaders.add(stage.shaderKey);\n            if (!shader)\n            {\n                addIntegrityError(\n                    errors,\n                    \"missing_stage_shader\",\n                    `Stage ${stage.key} references missing shader ${stage.shaderKey}`,\n                    { stageKey: stage.key, shaderKey: stage.shaderKey || null }\n                );\n                continue;\n            }\n            if (shader.stageName !== stage.stageName)\n            {\n                addIntegrityError(\n                    errors,\n                    \"shader_stage_mismatch\",\n                    `Shader ${shader.key} is ${shader.stageName || \"<missing>\"}, not ${stage.stageName}`,\n                    { stageKey: stage.key, shaderKey: shader.key }\n                );\n            }\n            for (const field of [ \"bindings\", \"stageInputs\", \"stageOutputs\" ])\n            {\n                if (!Array.isArray(shader[field]))\n                {\n                    addIntegrityError(\n                        errors,\n                        \"missing_runtime_contract\",\n                        `Shader ${shader.key} has no ${field} runtime contract array`,\n                        { stageKey: stage.key, shaderKey: shader.key, field }\n                    );\n                }\n            }\n\n            const metadataBody = metadataBodyMap.get(stage.bodyKey);\n            const manifestStages = metadataBody?.manifest?.stages;\n            if (!Array.isArray(manifestStages))\n            {\n                addIntegrityError(\n                    errors,\n                    \"missing_manifest_stages\",\n                    `Metadata body ${stage.bodyKey} has no manifest stage array`,\n                    { bodyKey: stage.bodyKey, stageKey: stage.key }\n                );\n            }\n            else\n            {\n                const manifestStage = manifestStages.find((entry) => entry?.techniqueName === stage.techniqueName\n          && entry.passIndex === stage.passIndex\n          && entry.stageType === stage.stageType\n          && entry.stageName === stage.stageName);\n                if (!manifestStage)\n                {\n                    addIntegrityError(\n                        errors,\n                        \"missing_manifest_stage\",\n                        `Stage ${stage.key} has no matching META manifest stage`,\n                        { bodyKey: stage.bodyKey, stageKey: stage.key }\n                    );\n                }\n                else if (stage.stageName === \"vertex\" && Array.isArray(shader.stageInputs))\n                {\n                    const expectedInputs = (manifestStage.pipelineInputs || []).filter((input) => Number(input?.usedMask || 0) !== 0);\n                    for (const input of expectedInputs)\n                    {\n                        if (!shader.stageInputs.some((entry) => entry?.register === input.registerIndex\n              && normalizeSemanticName(entry.semanticName) === normalizeSemanticName(input.usageName)\n              && entry.semanticIndex === input.usageIndex))\n                        {\n                            addIntegrityError(\n                                errors,\n                                \"vertex_input_contract_mismatch\",\n                                `Vertex shader ${shader.key} is missing manifest input ${input.usageName}${input.usageIndex} at register ${input.registerIndex}`,\n                                { stageKey: stage.key, shaderKey: shader.key, register: input.registerIndex }\n                            );\n                        }\n                    }\n                }\n                if (manifestStage) validateShaderRuntimeContract(shader, stage, manifestStage, errors);\n            }\n        }\n\n        if (![ \"vertex\", \"pixel\", \"compute\" ].includes(stage.stageName))\n        {\n            addIntegrityError(\n                errors,\n                \"unsupported_stage\",\n                `Stage ${stage.key} uses unsupported WebGL2 stage ${stage.stageName}`,\n                { stageKey: stage.key, stageName: stage.stageName || null }\n            );\n            continue;\n        }\n\n        if (!shader?.hlsl2webgl?.ok || !shader.source)\n        {\n            addIntegrityError(\n                errors,\n                \"unavailable_stage_shader\",\n                `Stage ${stage.key} has no successful translated source`,\n                { stageKey: stage.key, shaderKey: stage.shaderKey || null }\n            );\n        }\n        if (stage.stageName === \"compute\")\n        {\n            const computeIssue = computeFragmentShaderIssue(shader);\n            if (computeIssue)\n            {\n                addIntegrityError(\n                    errors,\n                    \"unadapted_compute_stage\",\n                    `Compute stage ${stage.key} ${computeIssue}`,\n                    { stageKey: stage.key, shaderKey: stage.shaderKey || null }\n                );\n            }\n        }\n    }\n\n    for (const [ passKey, passStages ] of passGroups)\n    {\n        const counts = { vertex: 0, pixel: 0, compute: 0, other: 0 };\n        for (const stage of passStages)\n        {\n            if (stage.stageName in counts && stage.stageName !== \"other\") counts[stage.stageName] += 1;\n            else counts.other += 1;\n        }\n        const raster = counts.vertex === 1 && counts.pixel === 1 && counts.compute === 0 && counts.other === 0;\n        const compute = counts.vertex === 0 && counts.pixel === 0 && counts.compute === 1 && counts.other === 0;\n        if (!raster && !compute)\n        {\n            const duplicate = Object.values(counts).some((count) => count > 1);\n            const mixed = counts.compute > 0 && (counts.vertex > 0 || counts.pixel > 0);\n            const code = duplicate || mixed\n                ? \"invalid_pass_stage_family\"\n                : counts.other > 0\n                    ? \"unsupported_pass_stage_family\"\n                    : \"incomplete_pass_stage_family\";\n            addIntegrityError(\n                errors,\n                code,\n                `Pass ${passKey} must contain exactly one vertex/pixel pair or one compute stage`,\n                { passKey, counts }\n            );\n        }\n    }\n\n    if (usesSharedShaders)\n    {\n        for (const shader of shaders)\n        {\n            if (!referencedShaders.has(shader.key))\n            {\n                addIntegrityError(errors, \"orphan_shader\", `Shader ${shader.key} is not referenced by a stage`, { shaderKey: shader.key });\n            }\n        }\n\n        const completeBodies = new Set();\n        for (const stage of stages)\n        {\n            const shader = shaderMap.get(stage.shaderKey);\n            if (stage.stageName === \"compute\"\n        && isCewgComputeFragmentContract(shader?.computeFragment)\n        && shader?.hlsl2webgl?.ok\n        && shader.source)\n            {\n                completeBodies.add(stage.bodyKey);\n            }\n        }\n        for (const body of bodies)\n        {\n            if (completeness.incompletePasses.some((pass) => pass.bodyKey === body.key)) continue;\n            if (completeness.expectedPassCount > 0)\n            {\n                const hasCompleteRaster = stages.some((stage) =>\n                    stage.bodyKey === body.key\n          && stage.stageName === \"vertex\"\n          && completeness.incompletePasses.every((pass) =>\n              pass.bodyKey !== body.key\n            || pass.techniqueName !== stage.techniqueName\n            || pass.passIndex !== stage.passIndex\n          )\n          && stages.some((pixel) =>\n              pixel.bodyKey === body.key\n            && pixel.techniqueName === stage.techniqueName\n            && pixel.passIndex === stage.passIndex\n            && pixel.stageName === \"pixel\"\n          )\n                );\n                if (hasCompleteRaster) completeBodies.add(body.key);\n            }\n        }\n        for (const variant of variants)\n        {\n            if (bodyMap.has(variant.bodyKey) && !completeBodies.has(variant.bodyKey))\n            {\n                addIntegrityError(\n                    errors,\n                    \"variant_body_has_no_program\",\n                    `Variant ${variant.key || \"<unknown>\"} body ${variant.bodyKey} has no complete WebGL2 program`,\n                    { variantKey: variant.key || null, bodyKey: variant.bodyKey || null }\n                );\n            }\n        }\n    }\n\n    return { ok: errors.length === 0, errors };\n}\n\n/** Formats bounded package-integrity errors for CLI output. */\nexport function formatCewgIntegrityErrors(errors, limit = 8)\n{\n    return (errors || []).slice(0, limit).map((entry) => `${entry.code}: ${entry.message}`).join(\"; \");\n}\n\nfunction keyedRecords(records, label, errors)\n{\n    const map = new Map();\n    for (const record of records)\n    {\n        if (!record?.key)\n        {\n            addIntegrityError(errors, `missing_${label.replace(/\\s+/g, \"_\")}_key`, `${label} record has no key`);\n            continue;\n        }\n        if (map.has(record.key))\n        {\n            addIntegrityError(errors, `duplicate_${label.replace(/\\s+/g, \"_\")}_key`, `Duplicate ${label} key ${record.key}`);\n            continue;\n        }\n        map.set(record.key, record);\n    }\n    return map;\n}\n\nfunction checkPackageSelection(infoSelection, glslSelection, errors)\n{\n    const valid = (selection) => selection\n    && typeof selection === \"object\"\n    && !Array.isArray(selection)\n    && (selection.technique === null || (typeof selection.technique === \"string\" && selection.technique.length > 0))\n    && (selection.pass === null || (Number.isSafeInteger(selection.pass) && selection.pass >= 0))\n    && (selection.stage === null || (typeof selection.stage === \"string\" && selection.stage.length > 0));\n    if (!valid(infoSelection) || !valid(glslSelection))\n    {\n        addIntegrityError(errors, \"invalid_package_selection\", \"INFO and GLSL must contain valid selection descriptors\");\n        return;\n    }\n    if (infoSelection.technique !== glslSelection.technique\n    || infoSelection.pass !== glslSelection.pass\n    || infoSelection.stage !== glslSelection.stage)\n    {\n        addIntegrityError(errors, \"package_selection_mismatch\", \"INFO and GLSL selection descriptors do not match\");\n    }\n    if (infoSelection.technique !== null || infoSelection.pass !== null || infoSelection.stage !== null)\n    {\n        addIntegrityError(\n            errors,\n            \"filtered_package_scope\",\n            \"Technique/pass/stage filters produce a diagnostic partial package\",\n            { selection: { ...infoSelection } }\n        );\n    }\n}\n\nfunction checkPermutationCoverage(permutations, mode, variants, errors)\n{\n    if (!Array.isArray(permutations)) return;\n    let count = 1;\n    let defaultIndex = 0;\n    let multiplier = 1;\n    const names = new Set();\n    for (const permutation of permutations)\n    {\n        const optionCount = Array.isArray(permutation?.options) ? permutation.options.length : 0;\n        if (typeof permutation?.name !== \"string\" || !permutation.name || names.has(permutation.name))\n        {\n            addIntegrityError(\n                errors,\n                \"invalid_permutation_description\",\n                `Permutation name is missing or duplicated: ${permutation?.name || \"<missing>\"}`\n            );\n            return;\n        }\n        names.add(permutation.name);\n        if (optionCount < 1)\n        {\n            addIntegrityError(\n                errors,\n                \"invalid_permutation_description\",\n                `Permutation ${permutation?.name || \"<unknown>\"} has no options`\n            );\n            return;\n        }\n        const optionValues = new Set();\n        if (permutation.options.some((option) => typeof option !== \"string\" || !option || optionValues.has(option)\n      || !optionValues.add(option)))\n        {\n            addIntegrityError(\n                errors,\n                \"invalid_permutation_description\",\n                `Permutation ${permutation.name} has a missing or duplicate option value`\n            );\n            return;\n        }\n        if (!Number.isSafeInteger(permutation.defaultOption)\n      || permutation.defaultOption < 0\n      || permutation.defaultOption >= optionCount)\n        {\n            addIntegrityError(\n                errors,\n                \"invalid_permutation_description\",\n                `Permutation ${permutation.name || \"<unknown>\"} has invalid default option ${permutation.defaultOption}`\n            );\n            return;\n        }\n        defaultIndex += permutation.defaultOption * multiplier;\n        multiplier *= optionCount;\n        count *= optionCount;\n        if (!Number.isSafeInteger(count) || !Number.isSafeInteger(defaultIndex))\n        {\n            addIntegrityError(errors, \"invalid_permutation_description\", \"Permutation table exceeds safe integer range\");\n            return;\n        }\n    }\n\n    const indexes = new Set(variants.map((variant) => variant?.permutationIndex));\n    if (mode === \"all\")\n    {\n        if (variants.length !== count)\n        {\n            addIntegrityError(\n                errors,\n                \"incomplete_permutation_coverage\",\n                `All-permutation package has ${variants.length} variants, expected ${count}`,\n                { actual: variants.length, expected: count }\n            );\n            return;\n        }\n        for (let index = 0; index < count; index += 1)\n        {\n            if (!indexes.has(index))\n            {\n                addIntegrityError(\n                    errors,\n                    \"incomplete_permutation_coverage\",\n                    `All-permutation package is missing index ${index}`,\n                    { permutationIndex: index }\n                );\n                break;\n            }\n        }\n    }\n    else if (mode === \"selected\"\n    && (variants.length !== 1 || variants[0]?.permutationIndex !== defaultIndex))\n    {\n        addIntegrityError(\n            errors,\n            \"invalid_selected_permutation\",\n            `Selected package must contain only default permutation index ${defaultIndex}`,\n            { expected: defaultIndex, actual: variants.map((variant) => variant?.permutationIndex) }\n        );\n    }\n}\n\nfunction checkEnvelopeValue(record, field, expected, label, errors)\n{\n    if (record?.[field] !== expected)\n    {\n        addIntegrityError(\n            errors,\n            \"invalid_package_envelope\",\n            `${label} ${field} must be ${expected}, got ${record?.[field] ?? \"<missing>\"}`,\n            { section: label, field, expected, actual: record?.[field] ?? null }\n        );\n    }\n}\n\nfunction checkSourceIdentity(info, errors)\n{\n    const identity = info?.sourceIdentity;\n    const optionalString = (value) => value === null || (typeof value === \"string\" && value.length > 0);\n    const optionalMd5 = (value) => value === null || /^[0-9a-f]{32}$/u.test(value || \"\");\n    const valid = identity\n    && typeof identity === \"object\"\n    && !Array.isArray(identity)\n    && typeof identity.filePath === \"string\"\n    && identity.filePath.length > 0\n    && optionalString(identity.logicalPath)\n    && optionalString(identity.game)\n    && optionalString(identity.client)\n    && optionalString(identity.build)\n    && Number.isSafeInteger(identity.byteLength)\n    && identity.byteLength >= 0\n    && optionalMd5(identity.md5)\n    && /^[0-9a-f]{64}$/u.test(identity.sha256 || \"\")\n    && info.sourceByteLength === identity.byteLength\n    && info.sourceMd5 === identity.md5\n    && info.sourceSha256 === identity.sha256;\n    if (!valid)\n    {\n        addIntegrityError(\n            errors,\n            \"invalid_source_identity\",\n            \"INFO source identity is missing, malformed, or inconsistent with its checksum fields\"\n        );\n    }\n}\n\nfunction checkRequiredCount(info, field, actual, errors)\n{\n    if (!Number.isSafeInteger(info?.[field]) || info[field] < 0)\n    {\n        addIntegrityError(\n            errors,\n            \"invalid_declared_count\",\n            `INFO ${field} must be a non-negative safe integer`,\n            { field, declared: info?.[field] ?? null, actual }\n        );\n    }\n    else if (info[field] !== actual)\n    {\n        addIntegrityError(\n            errors,\n            \"declared_count_mismatch\",\n            `INFO ${field} is ${info[field]}, graph contains ${actual}`,\n            { field, declared: info[field], actual }\n        );\n    }\n}\n\nfunction computeFragmentShaderIssue(shader)\n{\n    const contract = shader?.computeFragment;\n    if (!isCewgComputeFragmentContract(contract)) return \"has no valid compute-fragment host contract\";\n    if (!Array.isArray(shader.bindings)) return \"has no binding metadata for its compute-fragment host contract\";\n\n    const bindings = shader.bindings.filter((binding) => binding?.kind === \"uavTexture\");\n    if (bindings.length !== contract.uavOutputs.length)\n    {\n        return \"compute-fragment UAV routes do not match its binding metadata\";\n    }\n    for (const output of contract.uavOutputs)\n    {\n        if (!bindings.some((binding) => binding.registerIndex === output.register\n      && binding.slice === output.slice\n      && binding.location === output.location\n      && binding.name === output.glslName))\n        {\n            return `compute-fragment route ${output.glslName} does not match its binding metadata`;\n        }\n        const declaration = new RegExp(\n            `layout\\\\s*\\\\(\\\\s*location\\\\s*=\\\\s*${output.location}\\\\s*\\\\)\\\\s*out\\\\b[^;]*\\\\b${escapeRegExp(output.glslName)}\\\\s*;`\n        );\n        if (!declaration.test(shader.source))\n        {\n            return `compute-fragment route ${output.glslName} is not declared at output location ${output.location}`;\n        }\n    }\n\n    const dispatchBindings = shader.bindings.filter((binding) => binding?.kind === \"dispatchUniform\");\n    if (contract.dispatchOriginUniform === null)\n    {\n        if (dispatchBindings.length) return \"declares unexpected dispatch-origin binding metadata\";\n    }\n    else\n    {\n        if (dispatchBindings.length !== 1 || dispatchBindings[0].name !== contract.dispatchOriginUniform)\n        {\n            return \"dispatch-origin uniform does not match its binding metadata\";\n        }\n        const declaration = new RegExp(`uniform\\\\s+ivec3\\\\s+${escapeRegExp(contract.dispatchOriginUniform)}\\\\s*;`);\n        if (!declaration.test(shader.source)) return \"dispatch-origin uniform is not declared in translated source\";\n    }\n    return null;\n}\n\nfunction validateShaderRuntimeContract(shader, stage, manifestStage, errors)\n{\n    if (stage.stageName === \"vertex\" && Array.isArray(shader.stageInputs))\n    {\n        const registers = new Set();\n        const names = new Set();\n        const expectedInputs = (manifestStage.pipelineInputs || []).filter((input) => Number(input?.usedMask || 0) !== 0);\n        for (const input of shader.stageInputs)\n        {\n            if (!Number.isSafeInteger(input?.register)\n        || input.register < 0\n        || registers.has(input.register)\n        || typeof input.name !== \"string\"\n        || !input.name\n        || names.has(input.name))\n            {\n                addIntegrityError(\n                    errors,\n                    \"invalid_vertex_input_contract\",\n                    `Vertex shader ${shader.key} has an invalid or duplicate emitted input`,\n                    { stageKey: stage.key, shaderKey: shader.key }\n                );\n                continue;\n            }\n            registers.add(input.register);\n            names.add(input.name);\n            if (!expectedInputs.some((entry) => entry.registerIndex === input.register\n        && normalizeSemanticName(entry.usageName) === normalizeSemanticName(input.semanticName)\n        && entry.usageIndex === input.semanticIndex))\n            {\n                addIntegrityError(\n                    errors,\n                    \"vertex_input_contract_mismatch\",\n                    `Vertex shader ${shader.key} input ${input.name} is not present in its manifest pipeline inputs`,\n                    { stageKey: stage.key, shaderKey: shader.key, register: input.register }\n                );\n            }\n            const declaration = new RegExp(`\\\\bin\\\\b[^;]*\\\\b${escapeRegExp(input.name)}\\\\s*;`);\n            if (!declaration.test(shader.source))\n            {\n                addIntegrityError(\n                    errors,\n                    \"vertex_input_declaration_mismatch\",\n                    `Vertex shader ${shader.key} input ${input.name} is not declared in translated source`,\n                    { stageKey: stage.key, shaderKey: shader.key, inputName: input.name }\n                );\n            }\n        }\n    }\n\n    if (!Array.isArray(shader.bindings)) return;\n    const manifestBindings = Array.isArray(manifestStage.bindings) ? manifestStage.bindings : [];\n    for (const binding of shader.bindings)\n    {\n        if (typeof binding?.samplerType !== \"string\" || !binding.samplerType) continue;\n        const uniform = new RegExp(\n            `uniform\\\\s+(?:(?:lowp|mediump|highp)\\\\s+)?${escapeRegExp(binding.samplerType)}\\\\s+${escapeRegExp(binding.name)}\\\\s*;`\n        );\n        if (!uniform.test(shader.source))\n        {\n            addIntegrityError(\n                errors,\n                \"sampler_binding_declaration_mismatch\",\n                `Shader ${shader.key} sampler ${binding.name || \"<missing>\"} is not declared as ${binding.samplerType}`,\n                { stageKey: stage.key, shaderKey: shader.key, bindingName: binding.name || null }\n            );\n        }\n        if (!Number.isSafeInteger(binding.registerIndex)\n      || binding.registerIndex < 0\n      || !manifestBindings.some((entry) => entry?.kind === \"resource\" && entry.registerIndex === binding.registerIndex))\n        {\n            addIntegrityError(\n                errors,\n                \"sampler_resource_contract_mismatch\",\n                `Shader ${shader.key} sampler ${binding.name || \"<missing>\"} has no matching manifest resource register`,\n                { stageKey: stage.key, shaderKey: shader.key, register: binding.registerIndex }\n            );\n        }\n\n        const comparison = binding.samplerType.endsWith(\"Shadow\");\n        if ((binding.comparison === true) !== comparison)\n        {\n            addIntegrityError(\n                errors,\n                \"comparison_sampler_contract_mismatch\",\n                `Shader ${shader.key} sampler ${binding.name || \"<missing>\"} comparison metadata disagrees with ${binding.samplerType}`,\n                { stageKey: stage.key, shaderKey: shader.key, bindingName: binding.name || null }\n            );\n        }\n        if (comparison)\n        {\n            const samplerRegisters = binding.samplerRegisterIndices;\n            if (!Array.isArray(samplerRegisters)\n        || !samplerRegisters.length\n        || new Set(samplerRegisters).size !== samplerRegisters.length\n        || samplerRegisters.some((register) => !Number.isSafeInteger(register)\n          || register < 0\n          || !manifestBindings.some((entry) => entry?.kind === \"sampler\"\n            && entry.registerIndex === register\n            && entry.carbon?.sampler?.comparison === true)))\n            {\n                addIntegrityError(\n                    errors,\n                    \"comparison_sampler_contract_mismatch\",\n                    `Shader ${shader.key} comparison sampler ${binding.name || \"<missing>\"} has invalid manifest sampler pairing`,\n                    { stageKey: stage.key, shaderKey: shader.key, bindingName: binding.name || null }\n                );\n            }\n        }\n    }\n}\n\nfunction normalizeSemanticName(value)\n{\n    const name = String(value || \"\").toUpperCase();\n    if (name === \"BITANGENT\") return \"BINORMAL\";\n    if (name === \"BLENDWEIGHTS\") return \"BLENDWEIGHT\";\n    return name;\n}\n\nfunction escapeRegExp(value)\n{\n    return String(value).replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\n\nfunction addIntegrityError(errors, code, message, details = {})\n{\n    errors.push({ code, message, ...details });\n}\n"],"names":["inspectCewgRasterCompleteness","stages","shaders","shaderMap","Map","map","shader","key","usesSharedShaders","Array","isArray","groups","stage","stageName","bodyKey","techniqueName","Number","isInteger","passIndex","join","group","get","vertex","pixel","duplicateStages","set","push","incompletePasses","completePassCount","values","missingStages","unavailableStages","shaderKey","hlsl2webgl","ok","source","stageKey","excluded","reason","validationError","error","length","Set","sort","expectedPassCount","size"],"mappings":"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"}

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

@@ -1,331 +0,0 @@
-import { EFFECT_PERMUTATION_GRAPH_CHUNK, EFFECT_PERMUTATION_GRAPH_FORMAT, EFFECT_PERMUTATION_GRAPH_VERSION, validateEffectPermutationGraph } from '../../../format/effect/effectPermutationGraph.js';
-import { EFFECT_REFLECTION_CHUNK, EFFECT_REFLECTION_BLOB_CHUNK, validateEffectReflectionPointer, effectReflectionForPermutation } from '../../../format/effect/effectReflectionPackage.js';
-import { inspectCewgRasterCompleteness } from './cewgCompleteness.js';
-import { markEffectReflectionValidated } from './cewg/CewgPackage.js';
-import { sha256Bytes } from '../../../format/effect/sha256.js';
-
-const EFFECT_INFO_VERSION = 3;
-const EFFECT_PACKAGE_KINDS = new Set(["tr2-effect-webgl", "tr2-effect-webgl-permutations"]);
-const REQUIRED_EFFECT_CHUNKS = Object.freeze(["INFO", "META", "GLSL"]);
-const SEMANTIC_VERSION = /^[0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/u;
-const SHA256 = /^[0-9a-f]{64}$/u;
-
-/**
- * Validates the canonical CEWG effect envelope after the binary container has
- * been decoded. Generic CEWG containers without a recognized package kind
- * remain readable.
- *
- * @param {object} pkg Loaded CEWG package.
- * @returns {boolean} True when the package is generic, legacy, or valid.
- */
-function validateEffectPackageEnvelope(pkg) {
-  if (!pkg.GetChunk("INFO")) return true;
-  const info = requireRecord(pkg.GetJson("INFO"), "CEWG INFO");
-  if (!EFFECT_PACKAGE_KINDS.has(info.packageKind)) return true;
-  for (const tag of REQUIRED_EFFECT_CHUNKS) {
-    if (!pkg.GetChunk(tag)) {
-      throw new Error(`CEWG effect package requires ${tag}`);
-    }
-  }
-  if (info.format !== "CEWG") {
-    throw new Error("CEWG INFO format is malformed");
-  }
-  if (info.formatVersion === 1) {
-    return true;
-  }
-  if (info.formatVersion !== EFFECT_INFO_VERSION) {
-    throw new Error(`CEWG INFO schema must be version ${EFFECT_INFO_VERSION}`);
-  }
-  if (info.targetBackend !== "webgl" || info.backendPackage !== "@carbonenginejs/runtime-resource/formats/webgl" || !SEMANTIC_VERSION.test(info.backendPackageVersion) || info.translator !== "dxbc-js-emitter" || !SEMANTIC_VERSION.test(info.translatorVersion)) {
-    throw new Error("CEWG INFO producer provenance is malformed");
-  }
-  const sourceIdentity = validateSourceIdentity(info.sourceIdentity);
-  if (info.sourceByteLength !== sourceIdentity.byteLength || info.sourceSha256 !== sourceIdentity.sha256) {
-    throw new Error("CEWG INFO source identity fields disagree");
-  }
-  requireString(info.sourcePath, "CEWG INFO.sourcePath");
-  requireUint(info.defaultPermutationIndex, "CEWG INFO.defaultPermutationIndex");
-  requireUint(info.sourceEffectVersion, "CEWG INFO.sourceEffectVersion");
-  const expectedMode = info.packageKind === "tr2-effect-webgl-permutations" ? "all" : "selected";
-  if (info.permutationMode !== expectedMode) {
-    throw new Error("CEWG INFO package kind and permutation mode disagree");
-  }
-  const graphPointer = requireRecord(info.permutationGraph, "CEWG INFO.permutationGraph");
-  if (graphPointer.chunk !== EFFECT_PERMUTATION_GRAPH_CHUNK || graphPointer.format !== EFFECT_PERMUTATION_GRAPH_FORMAT || graphPointer.formatVersion !== EFFECT_PERMUTATION_GRAPH_VERSION || !SHA256.test(graphPointer.sha256)) {
-    throw new Error("CEWG INFO.permutationGraph is malformed");
-  }
-  const graphChunk = pkg.GetChunk(EFFECT_PERMUTATION_GRAPH_CHUNK);
-  if (!graphChunk) {
-    throw new Error(`CEWG INFO.permutationGraph requires ${EFFECT_PERMUTATION_GRAPH_CHUNK}`);
-  }
-  if (sha256Bytes(graphChunk.bytes) !== graphPointer.sha256) {
-    throw new Error("CEWG INFO permutation-graph digest disagrees with PGRF");
-  }
-  const graph = requireRecord(pkg.GetJson(EFFECT_PERMUTATION_GRAPH_CHUNK), "CEWG PGRF");
-  const graphCounts = validateEffectPermutationGraph(graph, {
-    sourceByteLength: sourceIdentity.byteLength
-  });
-  if (requireUint(graphPointer.permutationCount, "CEWG INFO.permutationGraph.permutationCount") !== graphCounts.permutationCount || requireUint(graphPointer.uniqueBodyCount, "CEWG INFO.permutationGraph.uniqueBodyCount") !== graphCounts.uniqueBodyCount || info.sourcePermutationCount !== graphCounts.permutationCount || info.sourceUniqueBodyCount !== graphCounts.uniqueBodyCount) {
-    throw new Error("CEWG INFO permutation-graph counts disagree with PGRF");
-  }
-  if (info.defaultPermutationIndex >= graphCounts.permutationCount) {
-    throw new Error("CEWG default permutation index is absent from PGRF");
-  }
-  const metadata = requireRecord(pkg.GetJson("META"), "CEWG META");
-  const glsl = requireRecord(pkg.GetJson("GLSL"), "CEWG GLSL");
-  validateBackendGraph(info, metadata, glsl, graph);
-  if (metadata.sourcePath !== info.sourcePath) {
-    throw new Error("CEWG META source path disagrees with INFO");
-  }
-  validateCompleteness(info);
-  if (info.formatVersion === 2) {
-    if (info.sourceEffectVersion < 8 || info.sourceEffectVersion > 14) {
-      throw new Error("CEWG INFO v2 source effect version must be 8-14");
-    }
-    if (Object.prototype.hasOwnProperty.call(info, "effectReflection") || pkg.GetChunk(EFFECT_REFLECTION_CHUNK) || pkg.GetChunk(EFFECT_REFLECTION_BLOB_CHUNK)) {
-      throw new Error("CEWG INFO v2 cannot contain complete effect reflection");
-    }
-    return true;
-  }
-  const reflectionChunk = pkg.GetChunk(EFFECT_REFLECTION_CHUNK);
-  const blobChunk = pkg.GetChunk(EFFECT_REFLECTION_BLOB_CHUNK);
-  if (!reflectionChunk || !blobChunk) {
-    throw new Error("CEWG INFO v3 requires RFLX and RBLB");
-  }
-  const reflection = requireRecord(pkg.GetJson(EFFECT_REFLECTION_CHUNK), "CEWG RFLX");
-  if (info.sourceEffectVersion !== 15 || reflection.source?.effectVersion !== info.sourceEffectVersion) {
-    throw new Error("CEWG INFO v3 source effect version disagrees with RFLX");
-  }
-  validateEffectReflectionPointer(requireRecord(info.effectReflection, "CEWG INFO.effectReflection"), reflection, blobChunk.bytes, {
-    permutationGraph: graph,
-    sourceIdentity,
-    sourcePath: info.sourcePath,
-    reflectionBytes: reflectionChunk.bytes
-  });
-  validateReflectionBackendGraph(reflection, graph, metadata, glsl);
-  markEffectReflectionValidated(pkg);
-  return true;
-}
-function validateReflectionBackendGraph(reflection, graph, metadata, glsl) {
-  const metadataBodies = new Map(metadata.bodies.map(body => [body.key, body]));
-  const checkedBodies = new Set();
-  for (const variant of metadata.variants) {
-    if (checkedBodies.has(variant.bodyKey)) continue;
-    checkedBodies.add(variant.bodyKey);
-    const metadataBody = metadataBodies.get(variant.bodyKey);
-    const reflected = effectReflectionForPermutation(reflection, graph, variant.permutationIndex);
-    const manifest = requireRecord(metadataBody?.manifest, `CEWG META body ${variant.bodyKey} manifest`);
-    const reflectedPasses = [];
-    const reflectedStages = [];
-    for (const technique of requireArray(reflected.techniques, `CEWG RFLX body ${variant.bodyKey} techniques`)) {
-      for (const [passIndex, pass] of requireArray(technique.passes, `CEWG RFLX technique ${technique.name} passes`).entries()) {
-        reflectedPasses.push({
-          techniqueName: technique.name,
-          passIndex,
-          states: pass.renderStates
-        });
-        for (const stage of requireArray(pass.stages, `CEWG RFLX ${technique.name}.pass${passIndex} stages`)) {
-          reflectedStages.push({
-            techniqueName: technique.name,
-            passIndex,
-            stage
-          });
-        }
-      }
-    }
-    const manifestPasses = requireArray(manifest.passes, `CEWG META body ${variant.bodyKey} passes`);
-    const manifestStages = requireArray(manifest.stages, `CEWG META body ${variant.bodyKey} stages`);
-    if (manifestPasses.length !== reflectedPasses.length || manifestStages.length !== reflectedStages.length) {
-      throw new Error(`CEWG META body ${variant.bodyKey} disagrees with RFLX pass/stage counts`);
-    }
-    for (const reflectedPass of reflectedPasses) {
-      const manifestPass = manifestPasses.find(entry => entry.techniqueName === reflectedPass.techniqueName && entry.passIndex === reflectedPass.passIndex);
-      if (!manifestPass || !jsonEqual(manifestPass.states, reflectedPass.states)) {
-        throw new Error(`CEWG META pass ${reflectedPass.techniqueName}.pass${reflectedPass.passIndex} disagrees with RFLX`);
-      }
-    }
-    for (const reflectedStage of reflectedStages) {
-      const stage = reflectedStage.stage;
-      const sourceProgram = stage.sourceProgram;
-      const signature = stage.input?.signature;
-      const manifestStage = manifestStages.find(entry => entry.techniqueName === reflectedStage.techniqueName && entry.passIndex === reflectedStage.passIndex && entry.stageType === stage.stageType && entry.stageName === stage.stageName);
-      if (!manifestStage || sourceProgram?.kind !== "stage" || sourceProgram.stageType !== manifestStage.stageType || sourceProgram.stageName !== manifestStage.stageName || sourceProgram.shaderSize !== manifestStage.shaderBytecode?.shaderSize || sourceProgram.stringTableOffset !== manifestStage.shaderBytecode?.stringTableOffset || !samePipelineInputs(signature?.pipelineInputs, manifestStage.pipelineInputs) || !jsonEqual(signature?.threadGroupSize, manifestStage.threadGroupSize)) {
-        throw new Error(`CEWG META stage ${reflectedStage.techniqueName}.pass${reflectedStage.passIndex}.${stage.stageName} disagrees with RFLX`);
-      }
-    }
-  }
-  if (checkedBodies.size !== metadataBodies.size || requireArray(glsl.bodies, "CEWG GLSL.bodies").some(body => !checkedBodies.has(body.key))) {
-    throw new Error("CEWG backend body inventory disagrees with RFLX");
-  }
-}
-function validateSourceIdentity(value) {
-  const identity = requireRecord(value, "CEWG INFO.sourceIdentity");
-  requireString(identity.logicalPath, "CEWG INFO.sourceIdentity.logicalPath");
-  requireUint(identity.byteLength, "CEWG INFO.sourceIdentity.byteLength");
-  if (!SHA256.test(identity.sha256)) {
-    throw new Error("CEWG INFO.sourceIdentity.sha256 is malformed");
-  }
-  return identity;
-}
-function validateCompleteness(info) {
-  const completeness = requireRecord(info.completeness, "CEWG INFO.completeness");
-  for (const key of ["packageValid", "sourceComplete", "backendComplete", "runtimeComplete"]) {
-    if (typeof completeness[key] !== "boolean") {
-      throw new Error(`CEWG INFO.completeness.${key} must be boolean`);
-    }
-  }
-  if (!completeness.packageValid || completeness.runtimeComplete) {
-    throw new Error("CEWG INFO completeness overstates runtime coverage");
-  }
-  if (info.formatVersion === 3) {
-    if (info.sourceBodyCoverage !== "all-unique" || !completeness.sourceComplete || info.backendProgramCoverage !== (selectionCoversWholeEffect(info.selection) ? "all-stages" : "filtered")) {
-      throw new Error("CEWG INFO v3 source coverage is inconsistent");
-    }
-  } else if (Object.prototype.hasOwnProperty.call(info, "sourceBodyCoverage") || Object.prototype.hasOwnProperty.call(info, "backendBodyCoverage") || Object.prototype.hasOwnProperty.call(info, "backendProgramCoverage") || completeness.sourceComplete) {
-    throw new Error("CEWG INFO v2 source coverage is inconsistent");
-  }
-  const expectedBackendCoverage = info.permutationMode === "all" ? "all" : "selected";
-  if (info.formatVersion === 3 && info.backendBodyCoverage !== expectedBackendCoverage || completeness.backendComplete) {
-    throw new Error("CEWG INFO backend coverage is inconsistent");
-  }
-}
-function selectionCoversWholeEffect(value) {
-  const selection = requireRecord(value, "CEWG INFO.selection");
-  return selection.technique === null && selection.pass === null && selection.stage === null;
-}
-function validateBackendGraph(info, metadata, glsl, graph) {
-  if (glsl.format !== "CEWG_GLSL_SET" || glsl.formatVersion !== 1 || glsl.permutationMode !== info.permutationMode || !jsonEqual(glsl.selection, info.selection)) {
-    throw new Error("CEWG GLSL envelope disagrees with INFO");
-  }
-  const metadataVariants = requireArray(metadata.variants, "CEWG META.variants");
-  const glslVariants = requireArray(glsl.variants, "CEWG GLSL.variants");
-  const metadataBodies = requireArray(metadata.bodies, "CEWG META.bodies");
-  const glslBodies = requireArray(glsl.bodies, "CEWG GLSL.bodies");
-  const stages = requireArray(glsl.stages, "CEWG GLSL.stages");
-  const shaders = requireArray(glsl.shaders, "CEWG GLSL.shaders");
-  if (metadataVariants.length !== info.permutationCount || glslVariants.length !== info.permutationCount) {
-    throw new Error("CEWG backend variant counts disagree with INFO");
-  }
-  const expectedIndices = info.permutationMode === "all" ? graph.variants.map(variant => variant.permutationIndex) : [info.defaultPermutationIndex];
-  if (expectedIndices.length !== metadataVariants.length) {
-    throw new Error("CEWG backend permutation coverage disagrees with INFO");
-  }
-  for (let index = 0; index < expectedIndices.length; index++) {
-    const expected = expectedIndices[index];
-    const metadataVariant = requireRecord(metadataVariants[index], `CEWG META variant ${index}`);
-    const glslVariant = requireRecord(glslVariants[index], `CEWG GLSL variant ${index}`);
-    if (metadataVariant.permutationIndex !== expected || glslVariant.permutationIndex !== expected || metadataVariant.key !== glslVariant.key || metadataVariant.bodyKey !== glslVariant.bodyKey) {
-      throw new Error(`CEWG backend variant ${index} is inconsistent`);
-    }
-    const sourceVariant = graph.variants[expected];
-    if (metadataVariant.bodyOffset !== sourceVariant.sourceRecord.offset || metadataVariant.bodySize !== sourceVariant.sourceRecord.byteLength) {
-      throw new Error(`CEWG backend variant ${index} disagrees with PGRF`);
-    }
-  }
-  if (metadataBodies.length !== info.uniqueBodyCount || glslBodies.length !== info.uniqueBodyCount || stages.length !== info.bodyStageCount || shaders.length !== info.uniqueShaderCount) {
-    throw new Error("CEWG backend graph counts disagree with INFO");
-  }
-  const metadataBodyMap = keyedRecordMap(metadataBodies, "CEWG META body");
-  const glslBodyMap = keyedRecordMap(glslBodies, "CEWG GLSL body");
-  const stageMap = keyedRecordMap(stages, "CEWG GLSL stage");
-  const shaderMap = keyedRecordMap(shaders, "CEWG GLSL shader");
-  const variantKeys = new Set();
-  const referencedBodies = new Set();
-  for (const [index, variant] of glslVariants.entries()) {
-    if (typeof variant.key !== "string" || !variant.key || variantKeys.has(variant.key) || !glslBodyMap.has(variant.bodyKey) || !metadataBodyMap.has(metadataVariants[index].bodyKey)) {
-      throw new Error(`CEWG backend variant ${index} references an invalid body`);
-    }
-    variantKeys.add(variant.key);
-    referencedBodies.add(variant.bodyKey);
-  }
-  const referencedStages = new Set();
-  for (const body of glslBodies) {
-    const metadataBody = metadataBodyMap.get(body.key);
-    const bodyStages = requireArray(body.stages, `CEWG GLSL body ${body.key}.stages`);
-    if (!metadataBody || referencedBodies.has(body.key) === false || bodyStages.length !== new Set(bodyStages).size) {
-      throw new Error(`CEWG backend body ${body.key} is inconsistent`);
-    }
-    for (const stageKey of bodyStages) {
-      const stage = stageMap.get(stageKey);
-      if (!stage || stage.bodyKey !== body.key) {
-        throw new Error(`CEWG backend body ${body.key} references an invalid stage`);
-      }
-      referencedStages.add(stageKey);
-    }
-  }
-  const referencedShaders = new Set();
-  for (const stage of stages) {
-    if (!referencedStages.has(stage.key) || !glslBodyMap.has(stage.bodyKey) || !shaderMap.has(stage.shaderKey)) {
-      throw new Error(`CEWG backend stage ${stage.key} is inconsistent`);
-    }
-    referencedShaders.add(stage.shaderKey);
-  }
-  if (referencedStages.size !== stageMap.size || referencedShaders.size !== shaderMap.size) {
-    throw new Error("CEWG backend graph contains orphan stages or shaders");
-  }
-  const excludedShaderCount = shaders.filter(shader => shader.excluded).length;
-  const failedShaderCount = shaders.filter(shader => !shader.hlsl2webgl?.ok && !shader.excluded).length;
-  const failedBodyCount = glslBodies.filter(body => body.error).length;
-  const availableShaderCount = shaders.filter(shader => shader.hlsl2webgl?.ok && shader.source).length;
-  const raster = inspectCewgRasterCompleteness(stages, shaders);
-  const counts = {
-    translatedShaderCount: shaders.length - failedShaderCount - excludedShaderCount,
-    excludedShaderCount,
-    failedShaderCount,
-    failedBodyCount,
-    availableShaderCount,
-    expectedRasterPassCount: raster.expectedPassCount,
-    completeRasterPassCount: raster.completePassCount,
-    incompleteRasterPassCount: raster.incompletePasses.length
-  };
-  for (const [field, actual] of Object.entries(counts)) {
-    if (info[field] !== actual) {
-      throw new Error(`CEWG INFO.${field} disagrees with the backend graph`);
-    }
-  }
-}
-function keyedRecordMap(records, context) {
-  const map = new Map();
-  for (const [index, value] of records.entries()) {
-    const record = requireRecord(value, `${context} ${index}`);
-    if (typeof record.key !== "string" || !record.key || map.has(record.key)) {
-      throw new Error(`${context} ${index} has a missing or duplicate key`);
-    }
-    map.set(record.key, record);
-  }
-  return map;
-}
-function samePipelineInputs(reflected, manifest) {
-  const fields = ["usage", "registerIndex", "usageIndex", "usedMask", "type", "dimension"];
-  return Array.isArray(reflected) && Array.isArray(manifest) && reflected.length === manifest.length && reflected.every((entry, index) => fields.every(field => entry[field] === manifest[index]?.[field]));
-}
-function requireRecord(value, context) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error(`${context} must be an object`);
-  }
-  return value;
-}
-function requireArray(value, context) {
-  if (!Array.isArray(value)) {
-    throw new Error(`${context} must be an array`);
-  }
-  return value;
-}
-function requireString(value, context) {
-  if (typeof value !== "string" || !value) {
-    throw new Error(`${context} must be a non-empty string`);
-  }
-  return value;
-}
-function requireUint(value, context) {
-  if (!Number.isSafeInteger(value) || value < 0) {
-    throw new Error(`${context} must be a non-negative safe integer`);
-  }
-  return value;
-}
-function jsonEqual(left, right) {
-  return JSON.stringify(left) === JSON.stringify(right);
-}
-
-export { EFFECT_INFO_VERSION, validateEffectPackageEnvelope };
-//# sourceMappingURL=effectPackageValidation.js.map