@carbonenginejs/runtime-resource 0.9.2 → 0.11.0

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

@@ -0,0 +1,104 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,101 @@
+import { WebglReadError } from '../errors.js';
+
+/**
+ * Returns a byte view for supported binary inputs without copying when possible.
+ *
+ * @param {ArrayBuffer|ArrayBufferView|Uint8Array} value Binary payload to normalize.
+ * @returns {Uint8Array} Byte view over the supplied payload.
+ */
+function asUint8Array(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);
+  }
+  throw new TypeError("Expected an ArrayBuffer or Uint8Array");
+}
+
+/**
+ * Minimal little-endian binary reader for the flat CEWG chunk container.
+ *
+ * Trimmed from Carbon's compiled-effect `WebglReader` (see
+ * `@carbonenginejs/format-dxbc`'s and `@carbonenginejs/format-hlsl`'s vendored
+ * copies): the CEWG format has no string table, so only raw-byte and uint32
+ * reads plus offset/remaining tracking are implemented here.
+ */
+class WebglReader {
+  /**
+  * Creates a reader over a byte payload.
+  *
+  * @param {ArrayBuffer|ArrayBufferView|Uint8Array} bytes Source payload.
+  * @param {object} [options] Reader bounds and metadata.
+  * @param {number} [options.offset] Initial byte offset.
+  * @param {number} [options.end] Exclusive end offset.
+  * @param {string} [options.source] Source name used in error details.
+  */
+  constructor(bytes, options = {}) {
+    this.bytes = asUint8Array(bytes);
+    this.view = new DataView(this.bytes.buffer, this.bytes.byteOffset, this.bytes.byteLength);
+    this.offset = Number(options.offset) || 0;
+    this.end = Number.isInteger(options.end) ? options.end : this.bytes.length;
+    this.source = options.source || "memory";
+  }
+
+  /**
+  * Returns the unread byte count inside the configured reader bounds.
+  *
+  * @returns {number} Remaining bytes.
+  */
+  get remaining() {
+    return this.end - this.offset;
+  }
+
+  /**
+  * Reads a byte range from the payload.
+  *
+  * @param {number} size Byte count to read.
+  * @returns {Uint8Array} View over the read bytes.
+  */
+  readRaw(size) {
+    this._require(size);
+    const start = this.offset;
+    this.offset += size;
+    return this.bytes.subarray(start, start + size);
+  }
+
+  /**
+  * Reads a little-endian unsigned 32-bit integer.
+  *
+  * @returns {number} Integer value.
+  */
+  readUint32() {
+    this._require(4);
+    const value = this.view.getUint32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+
+  /**
+  * Ensures the requested read fits inside the configured payload bounds.
+  *
+  * @param {number} size Requested byte count.
+  * @private
+  */
+  _require(size) {
+    if (!Number.isInteger(size) || size < 0 || this.offset + size > this.end) {
+      throw new WebglReadError("Unexpected end of CEWG package data", {
+        source: this.source,
+        offset: this.offset,
+        requested: size,
+        end: this.end
+      });
+    }
+  }
+}
+
+export { WebglReader, asUint8Array };
+//# sourceMappingURL=binary.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"binary.js","sources":["../../../../../../src/formats/webgl/core/cewg/binary.js"],"sourcesContent":["import { WebglReadError } from \"../errors.js\";\n\n/**\n * Returns a byte view for supported binary inputs without copying when possible.\n *\n * @param {ArrayBuffer|ArrayBufferView|Uint8Array} value Binary payload to normalize.\n * @returns {Uint8Array} Byte view over the supplied payload.\n */\nexport function asUint8Array(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    throw new TypeError(\"Expected an ArrayBuffer or Uint8Array\");\n}\n\n/**\n * Minimal little-endian binary reader for the flat CEWG chunk container.\n *\n * Trimmed from Carbon's compiled-effect `WebglReader` (see\n * `@carbonenginejs/format-dxbc`'s and `@carbonenginejs/format-hlsl`'s vendored\n * copies): the CEWG format has no string table, so only raw-byte and uint32\n * reads plus offset/remaining tracking are implemented here.\n */\nexport class WebglReader\n{\n    /**\n   * Creates a reader over a byte payload.\n   *\n   * @param {ArrayBuffer|ArrayBufferView|Uint8Array} bytes Source payload.\n   * @param {object} [options] Reader bounds and metadata.\n   * @param {number} [options.offset] Initial byte offset.\n   * @param {number} [options.end] Exclusive end offset.\n   * @param {string} [options.source] Source name used in error details.\n   */\n    constructor(bytes, options = {})\n    {\n        this.bytes = asUint8Array(bytes);\n        this.view = new DataView(this.bytes.buffer, this.bytes.byteOffset, this.bytes.byteLength);\n        this.offset = Number(options.offset) || 0;\n        this.end = Number.isInteger(options.end) ? options.end : this.bytes.length;\n        this.source = options.source || \"memory\";\n    }\n\n    /**\n   * Returns the unread byte count inside the configured reader bounds.\n   *\n   * @returns {number} Remaining bytes.\n   */\n    get remaining()\n    {\n        return this.end - this.offset;\n    }\n\n    /**\n   * Reads a byte range from the payload.\n   *\n   * @param {number} size Byte count to read.\n   * @returns {Uint8Array} View over the read bytes.\n   */\n    readRaw(size)\n    {\n        this._require(size);\n        const start = this.offset;\n        this.offset += size;\n        return this.bytes.subarray(start, start + size);\n    }\n\n    /**\n   * Reads a little-endian unsigned 32-bit integer.\n   *\n   * @returns {number} Integer value.\n   */\n    readUint32()\n    {\n        this._require(4);\n        const value = this.view.getUint32(this.offset, true);\n        this.offset += 4;\n        return value;\n    }\n\n    /**\n   * Ensures the requested read fits inside the configured payload bounds.\n   *\n   * @param {number} size Requested byte count.\n   * @private\n   */\n    _require(size)\n    {\n        if (!Number.isInteger(size) || size < 0 || this.offset + size > this.end)\n        {\n            throw new WebglReadError(\"Unexpected end of CEWG package data\", {\n                source: this.source,\n                offset: this.offset,\n                requested: size,\n                end: this.end\n            });\n        }\n    }\n}\n"],"names":["asUint8Array","value","Uint8Array","ArrayBuffer","isView","buffer","byteOffset","byteLength","TypeError","WebglReader","constructor","bytes","options","view","DataView","offset","Number","end","isInteger","length","source","remaining","readRaw","size","_require","start","subarray","readUint32","getUint32","WebglReadError","requested"],"mappings":"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"}

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

@@ -0,0 +1,81 @@
+/**
+ * Inspects CEWG stage records for complete WebGL2 raster passes.
+ *
+ * Geometry and compute stages are not raster-pair members. A raster pass is
+ * complete only when both its vertex and pixel records exist and their shared
+ * shader records contain successful translated source.
+ *
+ * @param {object[]} stages CEWG stage records.
+ * @param {object[]} shaders CEWG translated shader records.
+ * @returns {{ expectedPassCount: number, completePassCount: number, incompletePasses: object[] }}
+ */
+function inspectCewgRasterCompleteness(stages, shaders) {
+  const shaderMap = new Map((shaders || []).map(shader => [shader.key, shader]));
+  const usesSharedShaders = Array.isArray(shaders);
+  const groups = new Map();
+  for (const stage of stages || []) {
+    if (stage.stageName !== "vertex" && stage.stageName !== "pixel") continue;
+    const key = [stage.bodyKey || "selected", stage.techniqueName || "Main", Number.isInteger(stage.passIndex) ? stage.passIndex : 0].join(":");
+    let group = groups.get(key);
+    if (!group) {
+      group = {
+        key,
+        bodyKey: stage.bodyKey || "selected",
+        techniqueName: stage.techniqueName || "Main",
+        passIndex: Number.isInteger(stage.passIndex) ? stage.passIndex : 0,
+        vertex: null,
+        pixel: null,
+        duplicateStages: []
+      };
+      groups.set(key, group);
+    }
+    if (group[stage.stageName]) {
+      group.duplicateStages.push(stage.stageName);
+    }
+    group[stage.stageName] = stage;
+  }
+  const incompletePasses = [];
+  let completePassCount = 0;
+  for (const group of groups.values()) {
+    const missingStages = [];
+    const unavailableStages = [];
+    for (const stageName of ["vertex", "pixel"]) {
+      const stage = group[stageName];
+      if (!stage) {
+        missingStages.push(stageName);
+        continue;
+      }
+      const shader = usesSharedShaders ? shaderMap.get(stage.shaderKey) : stage;
+      if (!shader?.hlsl2webgl?.ok || !shader.source) {
+        unavailableStages.push({
+          stageName,
+          stageKey: stage.key,
+          shaderKey: stage.shaderKey,
+          excluded: shader?.excluded || null,
+          reason: shader?.hlsl2webgl?.validationError || shader?.hlsl2webgl?.reason || shader?.hlsl2webgl?.error || shader?.excluded?.reason || "translated source is unavailable"
+        });
+      }
+    }
+    if (!missingStages.length && !unavailableStages.length && !group.duplicateStages.length) {
+      completePassCount += 1;
+      continue;
+    }
+    incompletePasses.push({
+      key: group.key,
+      bodyKey: group.bodyKey,
+      techniqueName: group.techniqueName,
+      passIndex: group.passIndex,
+      missingStages,
+      unavailableStages,
+      duplicateStages: [...new Set(group.duplicateStages)].sort()
+    });
+  }
+  return {
+    expectedPassCount: groups.size,
+    completePassCount,
+    incompletePasses
+  };
+}
+
+export { inspectCewgRasterCompleteness };
+//# sourceMappingURL=cewgCompleteness.js.map

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

@@ -0,0 +1 @@
+{"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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"}