@carbonenginejs/runtime-resource 0.12.1 → 0.13.0

package/dist/format/effect/effectBodyInventory.js

@@ -0,0 +1,146 @@
+/**
+ * Groups a Carbon effect's permutation rows onto the distinct bodies they
+ * address.
+ *
+ * A container's offset table is dense and positionally indexed, and rows alias:
+ * several permutations routinely point at one compiled body. Anything that walks
+ * bodies rather than permutations needs that grouping first, or it does the same
+ * work once per row — a 4,096-row file with 128 distinct bodies would translate
+ * each of them thirty-two times.
+ *
+ * This is pure container geometry: offsets, byte ranges, and byte equality. It
+ * carried no reflection when it lived beside the effect-reflection document, and
+ * it outlived that document for exactly that reason.
+ */
+
+const EFFECT_VERSION = 15;
+const EFFECT_BODY_COUNT_MAX = 0x10000;
+const UINT32_MAX = 0xffffffff;
+
+/**
+ * Validates one offset-table row against the file it indexes.
+ *
+ * @param {object} record Offset-table row.
+ * @param {number} permutationIndex Position of the row in the table.
+ * @param {number} sourceByteLength Size of the source file.
+ * @returns {{offset:number, byteLength:number}} Normalized source record.
+ */
+function normalizeBodySourceRecord(record, permutationIndex, sourceByteLength) {
+  const end = record?.offset + record?.size;
+  if (!record || record.index !== permutationIndex || !Number.isSafeInteger(record.offset) || record.offset < 0 || record.offset > UINT32_MAX || !Number.isSafeInteger(record.size) || record.size < 1 || record.size > UINT32_MAX || !Number.isSafeInteger(end) || record.end !== end || !Number.isSafeInteger(sourceByteLength) || end > sourceByteLength) {
+    throw new Error(`Effect body index ${permutationIndex} disagrees with its source record`);
+  }
+  return Object.freeze({
+    offset: record.offset,
+    byteLength: record.size
+  });
+}
+
+/**
+ * Rejects source records that partially overlap.
+ *
+ * Rows may alias exactly — that is how a container shares one body between
+ * permutations — but a partial overlap means two bodies claim the same bytes
+ * with different extents, which no reading of the file can satisfy.
+ *
+ * @param {Array<{offset:number, byteLength:number}>} sourceRecords Records.
+ */
+function validateDisjointBodySourceRecords(sourceRecords) {
+  const unique = new Map();
+  for (const record of sourceRecords) {
+    const key = `${record.offset}:${record.byteLength}`;
+    if (!unique.has(key)) unique.set(key, record);
+  }
+  const ordered = Array.from(unique.values()).sort((left, right) => left.offset - right.offset || left.byteLength - right.byteLength);
+  for (let index = 1; index < ordered.length; index += 1) {
+    const previous = ordered[index - 1];
+    const current = ordered[index];
+    if (current.offset < previous.offset + previous.byteLength) {
+      throw new Error("Effect body source records partially overlap");
+    }
+  }
+}
+
+/**
+ * A cheap content key, used only to shrink the set of byte-equality comparisons.
+ *
+ * @param {Uint8Array} bytes Body bytes.
+ * @returns {string} Length-qualified FNV-1a fingerprint.
+ */
+function fingerprintBytes(bytes) {
+  let hash = 0x811c9dc5;
+  for (const value of bytes) {
+    hash = Math.imul(hash ^ value, 0x01000193) >>> 0;
+  }
+  return `${bytes.byteLength}:${hash.toString(16).padStart(8, "0")}`;
+}
+
+/**
+ * Byte equality. The fingerprint narrows candidates; this decides.
+ *
+ * @param {Uint8Array} left Left bytes.
+ * @param {Uint8Array} right Right bytes.
+ * @returns {boolean} Whether the two are byte-identical.
+ */
+function bytesEqual(left, right) {
+  return left.byteLength === right.byteLength && left.every((value, index) => value === right[index]);
+}
+
+/**
+ * Groups permutation rows onto the distinct bodies they address.
+ *
+ * Rows are grouped by byte range first, then by content: two ranges holding
+ * identical bytes are one body, which is what makes the count "unique bodies"
+ * rather than "distinct offsets".
+ *
+ * @param {object} effectRes Loaded version-15 effect resource.
+ * @returns {ReadonlyArray<object>} Frozen groups, each with its representative
+ *     permutation index, source record, and every variant that shares it.
+ */
+function enumerateUniqueEffectBodies(effectRes) {
+  if (!effectRes || typeof effectRes !== "object" || effectRes.m_version !== EFFECT_VERSION || !(effectRes.m_data instanceof Uint8Array) || !Array.isArray(effectRes.m_offsets) || effectRes.m_offsetCount !== effectRes.m_offsets.length || !effectRes.m_offsets.length) {
+    throw new TypeError("Effect body inventory requires a loaded version-15 effect resource");
+  }
+  if (effectRes.m_offsets.length > EFFECT_BODY_COUNT_MAX) {
+    throw new RangeError(`Effect body inventory exceeds ${EFFECT_BODY_COUNT_MAX} records`);
+  }
+  const sourceRecords = effectRes.m_offsets.map((record, permutationIndex) => normalizeBodySourceRecord(record, permutationIndex, effectRes.m_data.byteLength));
+  validateDisjointBodySourceRecords(sourceRecords);
+  const groups = [];
+  const groupByRange = new Map();
+  const groupsByFingerprint = new Map();
+  for (const [permutationIndex, sourceRecord] of sourceRecords.entries()) {
+    const rangeKey = `${sourceRecord.offset}:${sourceRecord.byteLength}`;
+    let group = groupByRange.get(rangeKey);
+    if (!group) {
+      const bytes = effectRes.m_data.subarray(sourceRecord.offset, sourceRecord.offset + sourceRecord.byteLength);
+      const fingerprint = fingerprintBytes(bytes);
+      const candidates = groupsByFingerprint.get(fingerprint) ?? [];
+      group = candidates.find(candidate => bytesEqual(candidate.bytes, bytes));
+      if (!group) {
+        group = {
+          bytes,
+          permutationIndex,
+          sourceRecord,
+          variants: []
+        };
+        candidates.push(group);
+        groupsByFingerprint.set(fingerprint, candidates);
+        groups.push(group);
+      }
+      groupByRange.set(rangeKey, group);
+    }
+    group.variants.push({
+      permutationIndex,
+      sourceRecord
+    });
+  }
+  return Object.freeze(groups.map(group => Object.freeze({
+    permutationIndex: group.permutationIndex,
+    sourceRecord: group.sourceRecord,
+    variants: Object.freeze(group.variants.map(variant => Object.freeze(variant)))
+  })));
+}
+
+export { enumerateUniqueEffectBodies };
+//# sourceMappingURL=effectBodyInventory.js.map

package/dist/format/effect/effectBodyInventory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effectBodyInventory.js","sources":["../../../../src/format/effect/effectBodyInventory.js"],"sourcesContent":["/**\n * Groups a Carbon effect's permutation rows onto the distinct bodies they\n * address.\n *\n * A container's offset table is dense and positionally indexed, and rows alias:\n * several permutations routinely point at one compiled body. Anything that walks\n * bodies rather than permutations needs that grouping first, or it does the same\n * work once per row — a 4,096-row file with 128 distinct bodies would translate\n * each of them thirty-two times.\n *\n * This is pure container geometry: offsets, byte ranges, and byte equality. It\n * carried no reflection when it lived beside the effect-reflection document, and\n * it outlived that document for exactly that reason.\n */\n\nconst EFFECT_VERSION = 15;\nconst EFFECT_BODY_COUNT_MAX = 0x10000;\nconst UINT32_MAX = 0xffffffff;\n\n/**\n * Validates one offset-table row against the file it indexes.\n *\n * @param {object} record Offset-table row.\n * @param {number} permutationIndex Position of the row in the table.\n * @param {number} sourceByteLength Size of the source file.\n * @returns {{offset:number, byteLength:number}} Normalized source record.\n */\nfunction normalizeBodySourceRecord(record, permutationIndex, sourceByteLength)\n{\n    const end = record?.offset + record?.size;\n    if (!record || record.index !== permutationIndex\n        || !Number.isSafeInteger(record.offset) || record.offset < 0\n        || record.offset > UINT32_MAX\n        || !Number.isSafeInteger(record.size) || record.size < 1\n        || record.size > UINT32_MAX\n        || !Number.isSafeInteger(end)\n        || record.end !== end\n        || !Number.isSafeInteger(sourceByteLength)\n        || end > sourceByteLength)\n    {\n        throw new Error(\n            `Effect body index ${permutationIndex} disagrees with its source record`\n        );\n    }\n    return Object.freeze({\n        offset: record.offset,\n        byteLength: record.size\n    });\n}\n\n/**\n * Rejects source records that partially overlap.\n *\n * Rows may alias exactly — that is how a container shares one body between\n * permutations — but a partial overlap means two bodies claim the same bytes\n * with different extents, which no reading of the file can satisfy.\n *\n * @param {Array<{offset:number, byteLength:number}>} sourceRecords Records.\n */\nfunction validateDisjointBodySourceRecords(sourceRecords)\n{\n    const unique = new Map();\n    for (const record of sourceRecords)\n    {\n        const key = `${record.offset}:${record.byteLength}`;\n        if (!unique.has(key)) unique.set(key, record);\n    }\n    const ordered = Array.from(unique.values()).sort((left, right) =>\n        left.offset - right.offset || left.byteLength - right.byteLength);\n    for (let index = 1; index < ordered.length; index += 1)\n    {\n        const previous = ordered[index - 1];\n        const current = ordered[index];\n        if (current.offset < previous.offset + previous.byteLength)\n        {\n            throw new Error(\n                \"Effect body source records partially overlap\"\n            );\n        }\n    }\n}\n\n/**\n * A cheap content key, used only to shrink the set of byte-equality comparisons.\n *\n * @param {Uint8Array} bytes Body bytes.\n * @returns {string} Length-qualified FNV-1a fingerprint.\n */\nfunction fingerprintBytes(bytes)\n{\n    let hash = 0x811c9dc5;\n    for (const value of bytes)\n    {\n        hash = Math.imul(hash ^ value, 0x01000193) >>> 0;\n    }\n    return `${bytes.byteLength}:${hash.toString(16).padStart(8, \"0\")}`;\n}\n\n/**\n * Byte equality. The fingerprint narrows candidates; this decides.\n *\n * @param {Uint8Array} left Left bytes.\n * @param {Uint8Array} right Right bytes.\n * @returns {boolean} Whether the two are byte-identical.\n */\nfunction bytesEqual(left, right)\n{\n    return left.byteLength === right.byteLength\n        && left.every((value, index) => value === right[index]);\n}\n\n/**\n * Groups permutation rows onto the distinct bodies they address.\n *\n * Rows are grouped by byte range first, then by content: two ranges holding\n * identical bytes are one body, which is what makes the count \"unique bodies\"\n * rather than \"distinct offsets\".\n *\n * @param {object} effectRes Loaded version-15 effect resource.\n * @returns {ReadonlyArray<object>} Frozen groups, each with its representative\n *     permutation index, source record, and every variant that shares it.\n */\nexport function enumerateUniqueEffectBodies(effectRes)\n{\n    if (!effectRes || typeof effectRes !== \"object\"\n        || effectRes.m_version !== EFFECT_VERSION\n        || !(effectRes.m_data instanceof Uint8Array)\n        || !Array.isArray(effectRes.m_offsets)\n        || effectRes.m_offsetCount !== effectRes.m_offsets.length\n        || !effectRes.m_offsets.length)\n    {\n        throw new TypeError(\n            \"Effect body inventory requires a loaded version-15 effect resource\"\n        );\n    }\n    if (effectRes.m_offsets.length > EFFECT_BODY_COUNT_MAX)\n    {\n        throw new RangeError(\n            `Effect body inventory exceeds ${EFFECT_BODY_COUNT_MAX} records`\n        );\n    }\n\n    const sourceRecords = effectRes.m_offsets.map((record, permutationIndex) =>\n        normalizeBodySourceRecord(\n            record,\n            permutationIndex,\n            effectRes.m_data.byteLength\n        ));\n    validateDisjointBodySourceRecords(sourceRecords);\n\n    const groups = [];\n    const groupByRange = new Map();\n    const groupsByFingerprint = new Map();\n    for (const [ permutationIndex, sourceRecord ] of sourceRecords.entries())\n    {\n        const rangeKey = `${sourceRecord.offset}:${sourceRecord.byteLength}`;\n        let group = groupByRange.get(rangeKey);\n        if (!group)\n        {\n            const bytes = effectRes.m_data.subarray(\n                sourceRecord.offset,\n                sourceRecord.offset + sourceRecord.byteLength\n            );\n            const fingerprint = fingerprintBytes(bytes);\n            const candidates = groupsByFingerprint.get(fingerprint) ?? [];\n            group = candidates.find((candidate) =>\n                bytesEqual(candidate.bytes, bytes));\n            if (!group)\n            {\n                group = {\n                    bytes,\n                    permutationIndex,\n                    sourceRecord,\n                    variants: []\n                };\n                candidates.push(group);\n                groupsByFingerprint.set(fingerprint, candidates);\n                groups.push(group);\n            }\n            groupByRange.set(rangeKey, group);\n        }\n        group.variants.push({\n            permutationIndex,\n            sourceRecord\n        });\n    }\n\n    return Object.freeze(groups.map((group) => Object.freeze({\n        permutationIndex: group.permutationIndex,\n        sourceRecord: group.sourceRecord,\n        variants: Object.freeze(group.variants.map((variant) =>\n            Object.freeze(variant)))\n    })));\n}\n\nexport default enumerateUniqueEffectBodies;\n"],"names":["EFFECT_VERSION","EFFECT_BODY_COUNT_MAX","UINT32_MAX","normalizeBodySourceRecord","record","permutationIndex","sourceByteLength","end","offset","size","index","Number","isSafeInteger","Error","Object","freeze","byteLength","validateDisjointBodySourceRecords","sourceRecords","unique","Map","key","has","set","ordered","Array","from","values","sort","left","right","length","previous","current","fingerprintBytes","bytes","hash","value","Math","imul","toString","padStart","bytesEqual","every","enumerateUniqueEffectBodies","effectRes","m_version","m_data","Uint8Array","isArray","m_offsets","m_offsetCount","TypeError","RangeError","map","groups","groupByRange","groupsByFingerprint","sourceRecord","entries","rangeKey","group","get","subarray","fingerprint","candidates","find","candidate","variants","push","variant"],"mappings":"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"}