@world-engines/tmw 0.1.0-alpha.0

package/dist/compiler-compatibility-gate.js

@@ -0,0 +1,609 @@
+import { compileTargetProfileDigest, parseCompileTargetProfile, } from "./compile-target-profile.js";
+import { captureNeutralSourceCompileInput, decodeNeutralScenarioSource, sha256Bytes, sha256Hex, } from "@world-engines/scenario-author-source";
+import { compileNeutralScenarioSource, } from "./neutral-source-compiler.js";
+import { tmwSha256Hex } from "./runtime-contract.js";
+export const ACCEPTED_NEUTRAL_SOURCE_CORPUS_SCHEMA_VERSION = 1;
+const IDENTIFIER_PATTERN = /^[a-z0-9][a-z0-9._-]{0,127}$/u;
+const SHA256_PATTERN = /^[0-9a-f]{64}$/u;
+const SECTION_KEY_PATTERN = /^[a-z][a-z0-9_.-]{0,127}$/u;
+const DECIMAL_UINT_PATTERN = /^(?:0|[1-9][0-9]*)$/u;
+function decodeBase64Bytes(value) {
+    let binary;
+    try {
+        binary = globalThis.atob(value);
+    }
+    catch {
+        throw new Error("accepted_fixture_base64_invalid");
+    }
+    return Uint8Array.from(binary, (character) => character.charCodeAt(0));
+}
+function compareAscii(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function requireIdentifier(value, code) {
+    if (typeof value !== "string" || !IDENTIFIER_PATTERN.test(value))
+        throw new Error(code);
+    return value;
+}
+function requireText(value, code) {
+    if (typeof value !== "string"
+        || value.length === 0
+        || value !== value.trim().normalize("NFC"))
+        throw new Error(code);
+    return value;
+}
+function requireSha256(value, code) {
+    if (typeof value !== "string" || !SHA256_PATTERN.test(value))
+        throw new Error(code);
+    return value;
+}
+function requireRelativePath(value, code) {
+    const path = requireText(value, code);
+    if (path.startsWith("/")
+        || path.includes("\\")
+        || path.split("/").some((part) => part.length === 0 || part === "." || part === ".."))
+        throw new Error(code);
+    return path;
+}
+function requireSectionKey(value, code) {
+    if (typeof value !== "string"
+        || !SECTION_KEY_PATTERN.test(value)
+        || value !== value.normalize("NFC"))
+        throw new Error(code);
+    return value;
+}
+function requireByteLength(value, code) {
+    if (typeof value !== "string" || !DECIMAL_UINT_PATTERN.test(value))
+        throw new Error(code);
+    return value;
+}
+function parseSectionDigests(value, index) {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new Error(`accepted_fixture_section_digests_required:${index}`);
+    }
+    const digests = value.map((item, digestIndex) => {
+        if (typeof item !== "object" || item === null || Array.isArray(item)) {
+            throw new Error(`accepted_fixture_section_digest_invalid:${index}:${digestIndex}`);
+        }
+        const digest = item;
+        const keys = Object.keys(digest).sort();
+        const expected = ["byte_length", "section_key", "sha256"];
+        if (keys.length !== expected.length
+            || keys.some((key, keyIndex) => key !== expected[keyIndex]))
+            throw new Error(`accepted_fixture_section_digest_fields_mismatch:${index}:${digestIndex}`);
+        return Object.freeze({
+            section_key: requireSectionKey(digest.section_key, `accepted_fixture_section_key_invalid:${index}:${digestIndex}`),
+            sha256: requireSha256(digest.sha256, `accepted_fixture_section_digest_hash_invalid:${index}:${digestIndex}`),
+            byte_length: requireByteLength(digest.byte_length, `accepted_fixture_section_byte_length_invalid:${index}:${digestIndex}`),
+        });
+    });
+    for (let digestIndex = 1; digestIndex < digests.length; digestIndex += 1) {
+        const previous = digests[digestIndex - 1];
+        const current = digests[digestIndex];
+        if (previous === undefined || current === undefined) {
+            throw new Error(`accepted_fixture_section_digest_invalid:${index}`);
+        }
+        if (compareAscii(previous.section_key, current.section_key) !== -1) {
+            throw new Error(`accepted_fixture_section_digests_unsorted:${index}`);
+        }
+    }
+    if (new Set(digests.map((digest) => digest.section_key)).size !== digests.length) {
+        throw new Error(`accepted_fixture_section_digest_duplicate:${index}`);
+    }
+    return Object.freeze(digests);
+}
+function parseByteRangeWitnesses(value, index) {
+    if (!Array.isArray(value)) {
+        throw new Error(`accepted_fixture_byte_range_witnesses_required:${index}`);
+    }
+    const witnesses = value.map((item, witnessIndex) => {
+        if (typeof item !== "object" || item === null || Array.isArray(item)) {
+            throw new Error(`accepted_fixture_byte_range_witness_invalid:${index}:${witnessIndex}`);
+        }
+        const witness = item;
+        const keys = Object.keys(witness).sort();
+        const expected = ["end", "kind", "path", "sha256", "start"];
+        if (keys.length !== expected.length
+            || keys.some((key, keyIndex) => key !== expected[keyIndex]))
+            throw new Error(`accepted_fixture_byte_range_witness_fields_mismatch:${index}:${witnessIndex}`);
+        const start = requireByteLength(witness.start, `accepted_fixture_byte_range_start_invalid:${index}:${witnessIndex}`);
+        const end = requireByteLength(witness.end, `accepted_fixture_byte_range_end_invalid:${index}:${witnessIndex}`);
+        if (!(BigInt(start) < BigInt(end))) {
+            throw new Error(`accepted_fixture_byte_range_bounds_invalid:${index}:${witnessIndex}`);
+        }
+        return Object.freeze({
+            kind: requireIdentifier(witness.kind, `accepted_fixture_byte_range_kind_invalid:${index}:${witnessIndex}`),
+            path: requireText(witness.path, `accepted_fixture_byte_range_path_invalid:${index}:${witnessIndex}`),
+            start,
+            end,
+            sha256: requireSha256(witness.sha256, `accepted_fixture_byte_range_hash_invalid:${index}:${witnessIndex}`),
+        });
+    });
+    for (let witnessIndex = 1; witnessIndex < witnesses.length; witnessIndex += 1) {
+        const previous = witnesses[witnessIndex - 1];
+        const current = witnesses[witnessIndex];
+        if (previous === undefined || current === undefined) {
+            throw new Error(`accepted_fixture_byte_range_witness_invalid:${index}`);
+        }
+        const startOrder = BigInt(previous.start) < BigInt(current.start)
+            ? -1
+            : BigInt(previous.start) > BigInt(current.start) ? 1 : 0;
+        const pathOrder = compareAscii(previous.path, current.path);
+        if (startOrder === 1 || (startOrder === 0 && pathOrder !== -1)) {
+            throw new Error(`accepted_fixture_byte_range_witnesses_unsorted:${index}`);
+        }
+        if (BigInt(previous.end) > BigInt(current.start)) {
+            throw new Error(`accepted_fixture_byte_range_witness_overlap:${index}`);
+        }
+    }
+    if (new Set(witnesses.map((witness) => `${witness.kind}:${witness.path}:${witness.start}:${witness.end}`)).size
+        !== witnesses.length)
+        throw new Error(`accepted_fixture_byte_range_witness_duplicate:${index}`);
+    return Object.freeze(witnesses);
+}
+function parseContentWitnesses(value, index) {
+    if (!Array.isArray(value)) {
+        throw new Error(`accepted_fixture_content_witnesses_required:${index}`);
+    }
+    const witnesses = value.map((item, witnessIndex) => {
+        if (typeof item !== "object" || item === null || Array.isArray(item)) {
+            throw new Error(`accepted_fixture_content_witness_invalid:${index}:${witnessIndex}`);
+        }
+        const witness = item;
+        const keys = Object.keys(witness).sort();
+        const expected = ["kind", "metrics", "section_key", "sha256"];
+        if (keys.length !== expected.length
+            || keys.some((key, keyIndex) => key !== expected[keyIndex]))
+            throw new Error(`accepted_fixture_content_witness_fields_mismatch:${index}:${witnessIndex}`);
+        if (typeof witness.metrics !== "object"
+            || witness.metrics === null
+            || Array.isArray(witness.metrics))
+            throw new Error(`accepted_fixture_content_witness_metrics_invalid:${index}:${witnessIndex}`);
+        const metricsEntries = Object.entries(witness.metrics)
+            .sort(([left], [right]) => compareAscii(left, right))
+            .map(([key, metricValue], metricIndex) => {
+            if (!/^[a-z][a-z0-9_]{0,127}$/u.test(key)) {
+                throw new Error(`accepted_fixture_content_witness_metric_key_invalid:${index}:${witnessIndex}:${metricIndex}`);
+            }
+            if (typeof metricValue !== "string"
+                || metricValue.length === 0
+                || metricValue !== metricValue.trim().normalize("NFC"))
+                throw new Error(`accepted_fixture_content_witness_metric_value_invalid:${index}:${witnessIndex}:${key}`);
+            return [key, metricValue];
+        });
+        const metricKeys = metricsEntries.map(([key]) => key);
+        if (JSON.stringify(metricKeys) !== JSON.stringify([...metricKeys].sort(compareAscii))) {
+            throw new Error(`accepted_fixture_content_witness_metrics_unsorted:${index}:${witnessIndex}`);
+        }
+        if (new Set(metricKeys).size !== metricKeys.length) {
+            throw new Error(`accepted_fixture_content_witness_metric_duplicate:${index}:${witnessIndex}`);
+        }
+        return Object.freeze({
+            kind: requireIdentifier(witness.kind, `accepted_fixture_content_witness_kind_invalid:${index}:${witnessIndex}`),
+            section_key: requireSectionKey(witness.section_key, `accepted_fixture_content_witness_section_key_invalid:${index}:${witnessIndex}`),
+            sha256: requireSha256(witness.sha256, `accepted_fixture_content_witness_hash_invalid:${index}:${witnessIndex}`),
+            metrics: Object.freeze(Object.fromEntries(metricsEntries)),
+        });
+    });
+    for (let witnessIndex = 1; witnessIndex < witnesses.length; witnessIndex += 1) {
+        const previous = witnesses[witnessIndex - 1];
+        const current = witnesses[witnessIndex];
+        if (previous === undefined || current === undefined) {
+            throw new Error(`accepted_fixture_content_witness_invalid:${index}`);
+        }
+        const kindOrder = compareAscii(previous.kind, current.kind);
+        const sectionOrder = compareAscii(previous.section_key, current.section_key);
+        if (kindOrder === 1 || (kindOrder === 0 && sectionOrder !== -1)) {
+            throw new Error(`accepted_fixture_content_witnesses_unsorted:${index}`);
+        }
+    }
+    if (new Set(witnesses.map((witness) => `${witness.kind}:${witness.section_key}`)).size
+        !== witnesses.length)
+        throw new Error(`accepted_fixture_content_witness_duplicate:${index}`);
+    return Object.freeze(witnesses);
+}
+function parseMutationWitnesses(value, index) {
+    if (!Array.isArray(value)) {
+        throw new Error(`accepted_fixture_mutation_witnesses_required:${index}`);
+    }
+    const witnesses = value.map((item, witnessIndex) => {
+        if (typeof item !== "object" || item === null || Array.isArray(item)) {
+            throw new Error(`accepted_fixture_mutation_witness_invalid:${index}:${witnessIndex}`);
+        }
+        const witness = item;
+        const keys = Object.keys(witness).sort();
+        const expected = [
+            "after_head_sha256",
+            "after_manifest_sha256",
+            "after_revision",
+            "after_source_sha256",
+            "after_value_sha256",
+            "author_client",
+            "before_head_sha256",
+            "before_manifest_sha256",
+            "before_revision",
+            "before_source_base64",
+            "before_source_sha256",
+            "before_value_sha256",
+            "changed_field_path",
+            "changed_section_key",
+            "operation_id",
+            "preserved_section_digests",
+            "preserved_unknown_sha256s",
+        ];
+        if (keys.length !== expected.length
+            || keys.some((key, keyIndex) => key !== expected[keyIndex]))
+            throw new Error(`accepted_fixture_mutation_witness_fields_mismatch:${index}:${witnessIndex}`);
+        if (!Array.isArray(witness.preserved_section_digests) || witness.preserved_section_digests.length === 0) {
+            throw new Error(`accepted_fixture_mutation_preserved_sections_required:${index}:${witnessIndex}`);
+        }
+        const preserved = witness.preserved_section_digests.map((digestValue, digestIndex) => {
+            if (typeof digestValue !== "object" || digestValue === null || Array.isArray(digestValue)) {
+                throw new Error(`accepted_fixture_mutation_preserved_section_invalid:${index}:${witnessIndex}:${digestIndex}`);
+            }
+            const digest = digestValue;
+            const digestKeys = Object.keys(digest).sort();
+            if (digestKeys.length !== 2 || digestKeys[0] !== "section_key" || digestKeys[1] !== "sha256") {
+                throw new Error(`accepted_fixture_mutation_preserved_section_fields_mismatch:${index}:${witnessIndex}:${digestIndex}`);
+            }
+            return Object.freeze({
+                section_key: requireSectionKey(digest.section_key, `accepted_fixture_mutation_preserved_section_key_invalid:${index}:${witnessIndex}:${digestIndex}`),
+                sha256: requireSha256(digest.sha256, `accepted_fixture_mutation_preserved_section_hash_invalid:${index}:${witnessIndex}:${digestIndex}`),
+            });
+        });
+        for (let digestIndex = 1; digestIndex < preserved.length; digestIndex += 1) {
+            const previous = preserved[digestIndex - 1];
+            const current = preserved[digestIndex];
+            if (previous === undefined || current === undefined || compareAscii(previous.section_key, current.section_key) !== -1) {
+                throw new Error(`accepted_fixture_mutation_preserved_sections_unsorted:${index}:${witnessIndex}`);
+            }
+        }
+        if (!Array.isArray(witness.preserved_unknown_sha256s)) {
+            throw new Error(`accepted_fixture_mutation_preserved_unknown_required:${index}:${witnessIndex}`);
+        }
+        const unknown = witness.preserved_unknown_sha256s.map((item, unknownIndex) => {
+            if (typeof item !== "string" || !/^(?:[a-z][a-z0-9_.-]+:)?[0-9]+:[0-9a-f]{64}$/u.test(item)) {
+                throw new Error(`accepted_fixture_mutation_preserved_unknown_invalid:${index}:${witnessIndex}:${unknownIndex}`);
+            }
+            return item;
+        });
+        for (let unknownIndex = 1; unknownIndex < unknown.length; unknownIndex += 1) {
+            if (compareAscii(unknown[unknownIndex - 1] ?? "", unknown[unknownIndex] ?? "") !== -1) {
+                throw new Error(`accepted_fixture_mutation_preserved_unknown_unsorted:${index}:${witnessIndex}`);
+            }
+        }
+        let beforeBytes;
+        try {
+            beforeBytes = decodeBase64Bytes(String(witness.before_source_base64));
+        }
+        catch {
+            throw new Error(`accepted_fixture_mutation_before_source_invalid:${index}:${witnessIndex}`);
+        }
+        if (beforeBytes.byteLength === 0) {
+            throw new Error(`accepted_fixture_mutation_before_source_empty:${index}:${witnessIndex}`);
+        }
+        return Object.freeze({
+            after_head_sha256: requireSha256(witness.after_head_sha256, `accepted_fixture_mutation_after_head_invalid:${index}:${witnessIndex}`),
+            after_manifest_sha256: requireSha256(witness.after_manifest_sha256, `accepted_fixture_mutation_after_manifest_invalid:${index}:${witnessIndex}`),
+            after_revision: requireByteLength(witness.after_revision, `accepted_fixture_mutation_after_revision_invalid:${index}:${witnessIndex}`),
+            after_source_sha256: requireSha256(witness.after_source_sha256, `accepted_fixture_mutation_after_source_invalid:${index}:${witnessIndex}`),
+            after_value_sha256: requireSha256(witness.after_value_sha256, `accepted_fixture_mutation_after_value_invalid:${index}:${witnessIndex}`),
+            author_client: requireIdentifier(witness.author_client, `accepted_fixture_mutation_author_client_invalid:${index}:${witnessIndex}`),
+            before_head_sha256: requireSha256(witness.before_head_sha256, `accepted_fixture_mutation_before_head_invalid:${index}:${witnessIndex}`),
+            before_manifest_sha256: requireSha256(witness.before_manifest_sha256, `accepted_fixture_mutation_before_manifest_invalid:${index}:${witnessIndex}`),
+            before_revision: requireByteLength(witness.before_revision, `accepted_fixture_mutation_before_revision_invalid:${index}:${witnessIndex}`),
+            before_source_base64: requireText(witness.before_source_base64, `accepted_fixture_mutation_before_source_text_invalid:${index}:${witnessIndex}`),
+            before_source_sha256: requireSha256(witness.before_source_sha256, `accepted_fixture_mutation_before_source_hash_invalid:${index}:${witnessIndex}`),
+            before_value_sha256: requireSha256(witness.before_value_sha256, `accepted_fixture_mutation_before_value_invalid:${index}:${witnessIndex}`),
+            changed_field_path: requireText(witness.changed_field_path, `accepted_fixture_mutation_changed_field_path_invalid:${index}:${witnessIndex}`),
+            changed_section_key: requireSectionKey(witness.changed_section_key, `accepted_fixture_mutation_changed_section_invalid:${index}:${witnessIndex}`),
+            operation_id: requireIdentifier(witness.operation_id, `accepted_fixture_mutation_operation_id_invalid:${index}:${witnessIndex}`),
+            preserved_section_digests: Object.freeze(preserved),
+            preserved_unknown_sha256s: Object.freeze(unknown),
+        });
+    });
+    for (let witnessIndex = 1; witnessIndex < witnesses.length; witnessIndex += 1) {
+        const previous = witnesses[witnessIndex - 1];
+        const current = witnesses[witnessIndex];
+        if (previous === undefined || current === undefined || compareAscii(previous.operation_id, current.operation_id) !== -1) {
+            throw new Error(`accepted_fixture_mutation_witnesses_unsorted:${index}`);
+        }
+    }
+    if (new Set(witnesses.map((witness) => witness.operation_id)).size !== witnesses.length) {
+        throw new Error(`accepted_fixture_mutation_witness_duplicate:${index}`);
+    }
+    return Object.freeze(witnesses);
+}
+function parseSizeWitnesses(value, index) {
+    if (!Array.isArray(value)) {
+        throw new Error(`accepted_fixture_size_witnesses_required:${index}`);
+    }
+    const witnesses = value.map((item, witnessIndex) => {
+        if (typeof item !== "object" || item === null || Array.isArray(item)) {
+            throw new Error(`accepted_fixture_size_witness_invalid:${index}:${witnessIndex}`);
+        }
+        const witness = item;
+        const keys = Object.keys(witness).sort();
+        const expected = ["kind", "limit_bytes", "plus_one_byte_length", "source_byte_length"];
+        if (keys.length !== expected.length
+            || keys.some((key, keyIndex) => key !== expected[keyIndex]))
+            throw new Error(`accepted_fixture_size_witness_fields_mismatch:${index}:${witnessIndex}`);
+        const limit = requireByteLength(witness.limit_bytes, `accepted_fixture_size_limit_invalid:${index}:${witnessIndex}`);
+        const sourceLength = requireByteLength(witness.source_byte_length, `accepted_fixture_size_source_length_invalid:${index}:${witnessIndex}`);
+        const plusOne = requireByteLength(witness.plus_one_byte_length, `accepted_fixture_size_plus_one_invalid:${index}:${witnessIndex}`);
+        if (BigInt(plusOne) !== BigInt(limit) + 1n) {
+            throw new Error(`accepted_fixture_size_plus_one_not_limit_plus_one:${index}:${witnessIndex}`);
+        }
+        return Object.freeze({
+            kind: requireIdentifier(witness.kind, `accepted_fixture_size_kind_invalid:${index}:${witnessIndex}`),
+            limit_bytes: limit,
+            source_byte_length: sourceLength,
+            plus_one_byte_length: plusOne,
+        });
+    });
+    for (let witnessIndex = 1; witnessIndex < witnesses.length; witnessIndex += 1) {
+        const previous = witnesses[witnessIndex - 1];
+        const current = witnesses[witnessIndex];
+        if (previous === undefined || current === undefined || compareAscii(previous.kind, current.kind) !== -1) {
+            throw new Error(`accepted_fixture_size_witnesses_unsorted:${index}`);
+        }
+    }
+    if (new Set(witnesses.map((witness) => witness.kind)).size !== witnesses.length) {
+        throw new Error(`accepted_fixture_size_witness_duplicate:${index}`);
+    }
+    return Object.freeze(witnesses);
+}
+function parseTargetProfiles(value, index) {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new Error(`accepted_fixture_target_profiles_required:${index}`);
+    }
+    const profiles = value.map((item, profileIndex) => {
+        try {
+            return parseCompileTargetProfile(item);
+        }
+        catch (error) {
+            const code = error instanceof Error ? error.message : "compile_target_profile_invalid";
+            throw new Error(`accepted_fixture_target_profile_invalid:${index}:${profileIndex}:${code}`);
+        }
+    });
+    const identities = profiles.map((profile) => JSON.stringify([
+        profile.compiler_release,
+        profile.runtime_semantics,
+        profile.sdk_schema,
+        profile.artifact_format,
+        ...profile.stage_versions.map((stage) => `${stage.stage_id}:${stage.stage_version}`),
+    ]));
+    if (new Set(identities).size !== identities.length) {
+        throw new Error(`accepted_fixture_target_profile_duplicate:${index}`);
+    }
+    const sorted = [...profiles].sort((left, right) => compareAscii(left.compiler_release, right.compiler_release)
+        || compareAscii(left.runtime_semantics, right.runtime_semantics)
+        || compareAscii(left.sdk_schema, right.sdk_schema)
+        || compareAscii(left.artifact_format, right.artifact_format));
+    if (sorted.some((profile, profileIndex) => profile !== profiles[profileIndex])) {
+        throw new Error(`accepted_fixture_target_profiles_unsorted:${index}`);
+    }
+    return Object.freeze(profiles);
+}
+export function parseAcceptedNeutralSourceCorpus(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error("accepted_source_corpus_object_required");
+    }
+    const root = value;
+    const rootKeys = Object.keys(root).sort();
+    if (rootKeys.length !== 2
+        || rootKeys[0] !== "schema_version"
+        || rootKeys[1] !== "sources")
+        throw new Error("accepted_source_corpus_fields_mismatch");
+    if (root.schema_version !== ACCEPTED_NEUTRAL_SOURCE_CORPUS_SCHEMA_VERSION) {
+        throw new Error("accepted_source_corpus_schema_version_invalid");
+    }
+    if (!Array.isArray(root.sources) || root.sources.length === 0) {
+        throw new Error("accepted_source_corpus_empty");
+    }
+    const sources = root.sources.map((value, index) => {
+        if (typeof value !== "object" || value === null || Array.isArray(value)) {
+            throw new Error(`accepted_source_corpus_entry_invalid:${index}`);
+        }
+        const entry = value;
+        const keys = Object.keys(entry).sort();
+        const expected = [
+            "acceptance_ref",
+            "byte_range_witnesses",
+            "content_witnesses",
+            "fixture_id",
+            "manifest_sha256",
+            "mutation_witnesses",
+            "relative_path",
+            "scenario_id",
+            "section_digests",
+            "size_witnesses",
+            "source_sha256",
+            "target_profiles",
+        ];
+        if (keys.length !== expected.length
+            || keys.some((key, keyIndex) => key !== expected[keyIndex]))
+            throw new Error(`accepted_source_corpus_entry_fields_mismatch:${index}`);
+        return Object.freeze({
+            fixture_id: requireIdentifier(entry.fixture_id, `accepted_fixture_id_invalid:${index}`),
+            relative_path: requireRelativePath(entry.relative_path, `accepted_fixture_path_invalid:${index}`),
+            source_sha256: requireSha256(entry.source_sha256, `accepted_fixture_source_hash_invalid:${index}`),
+            scenario_id: requireText(entry.scenario_id, `accepted_fixture_scenario_id_invalid:${index}`),
+            manifest_sha256: requireSha256(entry.manifest_sha256, `accepted_fixture_manifest_hash_invalid:${index}`),
+            acceptance_ref: requireText(entry.acceptance_ref, `accepted_fixture_acceptance_ref_invalid:${index}`),
+            section_digests: parseSectionDigests(entry.section_digests, index),
+            target_profiles: parseTargetProfiles(entry.target_profiles, index),
+            byte_range_witnesses: parseByteRangeWitnesses(entry.byte_range_witnesses, index),
+            content_witnesses: parseContentWitnesses(entry.content_witnesses, index),
+            mutation_witnesses: parseMutationWitnesses(entry.mutation_witnesses, index),
+            size_witnesses: parseSizeWitnesses(entry.size_witnesses, index),
+        });
+    }).sort((left, right) => compareAscii(left.fixture_id, right.fixture_id));
+    if (new Set(sources.map((entry) => entry.fixture_id)).size !== sources.length
+        || new Set(sources.map((entry) => entry.relative_path)).size !== sources.length
+        || new Set(sources.map((entry) => entry.scenario_id)).size !== sources.length
+        || new Set(sources.map((entry) => entry.source_sha256)).size !== sources.length)
+        throw new Error("accepted_source_corpus_entry_duplicate");
+    return Object.freeze({
+        schema_version: ACCEPTED_NEUTRAL_SOURCE_CORPUS_SCHEMA_VERSION,
+        sources: Object.freeze(sources),
+    });
+}
+export async function evaluateCompilerCandidate(candidate, corpusValue, loadFixture) {
+    let corpus;
+    try {
+        corpus = parseAcceptedNeutralSourceCorpus(corpusValue);
+    }
+    catch (error) {
+        return Object.freeze({
+            promotable: false,
+            passes: Object.freeze([]),
+            failures: Object.freeze([{
+                    fixture_id: "$corpus",
+                    code: error instanceof Error ? error.message : "accepted_source_corpus_invalid",
+                }]),
+        });
+    }
+    const passes = [];
+    const failures = [];
+    for (const entry of corpus.sources) {
+        try {
+            const bytes = await loadFixture(entry.relative_path);
+            if (!(bytes instanceof Uint8Array))
+                throw new Error("accepted_fixture_bytes_invalid");
+            if (await tmwSha256Hex(bytes) !== entry.source_sha256) {
+                throw new Error("accepted_fixture_source_hash_mismatch");
+            }
+            const source = await decodeNeutralScenarioSource(bytes.slice());
+            if (source.scenario_id !== entry.scenario_id
+                || source.manifest === undefined
+                || sha256Hex(source.manifest.manifest_sha256) !== entry.manifest_sha256) {
+                throw new Error("accepted_fixture_source_identity_mismatch");
+            }
+            const actualDigests = [...source.manifest.sections]
+                .map((identity) => Object.freeze({
+                section_key: identity.section_key,
+                sha256: sha256Hex(identity.sha256),
+                byte_length: identity.byte_length,
+            }))
+                .sort((left, right) => compareAscii(left.section_key, right.section_key));
+            if (actualDigests.length !== entry.section_digests.length
+                || actualDigests.some((digest, digestIndex) => {
+                    const expected = entry.section_digests[digestIndex];
+                    return expected === undefined
+                        || digest.section_key !== expected.section_key
+                        || digest.sha256 !== expected.sha256
+                        || digest.byte_length !== expected.byte_length;
+                }))
+                throw new Error("accepted_fixture_section_digest_mismatch");
+            if (entry.byte_range_witnesses.some((witness) => {
+                const start = Number(witness.start);
+                const end = Number(witness.end);
+                return !Number.isSafeInteger(start)
+                    || !Number.isSafeInteger(end)
+                    || start < 0
+                    || end > bytes.byteLength;
+            }))
+                throw new Error("accepted_fixture_byte_range_out_of_bounds");
+            for (const witness of entry.byte_range_witnesses) {
+                const start = Number(witness.start);
+                const end = Number(witness.end);
+                if (sha256Hex(await sha256Bytes(bytes.subarray(start, end))) !== witness.sha256) {
+                    throw new Error("accepted_fixture_byte_range_digest_mismatch");
+                }
+            }
+            for (const witness of entry.content_witnesses) {
+                const section = source.sections.find((item) => item.section_key === witness.section_key);
+                if (section === undefined)
+                    throw new Error("accepted_fixture_content_witness_section_missing");
+                if (sha256Hex(await sha256Bytes(section.payload)) !== witness.sha256) {
+                    throw new Error("accepted_fixture_content_witness_digest_mismatch");
+                }
+            }
+            for (const witness of entry.size_witnesses) {
+                if (String(bytes.byteLength) !== witness.source_byte_length) {
+                    throw new Error("accepted_fixture_size_source_length_mismatch");
+                }
+                if (witness.kind === "max_size_boundary" && String(bytes.byteLength) !== witness.limit_bytes) {
+                    throw new Error("accepted_fixture_size_limit_mismatch");
+                }
+                if (BigInt(witness.plus_one_byte_length) !== BigInt(witness.limit_bytes) + 1n) {
+                    throw new Error("accepted_fixture_size_plus_one_mismatch");
+                }
+            }
+            for (const witness of entry.mutation_witnesses) {
+                if (witness.after_source_sha256 !== entry.source_sha256 || witness.after_manifest_sha256 !== entry.manifest_sha256) {
+                    throw new Error("accepted_fixture_mutation_after_identity_mismatch");
+                }
+                const beforeBytes = decodeBase64Bytes(witness.before_source_base64);
+                if (sha256Hex(await sha256Bytes(beforeBytes)) !== witness.before_source_sha256) {
+                    throw new Error("accepted_fixture_mutation_before_source_hash_mismatch");
+                }
+                const before = await decodeNeutralScenarioSource(beforeBytes.slice());
+                if (before.manifest === undefined || sha256Hex(before.manifest.manifest_sha256) !== witness.before_manifest_sha256) {
+                    throw new Error("accepted_fixture_mutation_before_manifest_mismatch");
+                }
+                const beforeDigest = new Map(before.manifest.sections.map((identity) => [identity.section_key, sha256Hex(identity.sha256)]));
+                const afterDigest = new Map(source.manifest.sections.map((identity) => [identity.section_key, sha256Hex(identity.sha256)]));
+                if (beforeDigest.get(witness.changed_section_key) === afterDigest.get(witness.changed_section_key)) {
+                    throw new Error("accepted_fixture_mutation_changed_section_unmodified");
+                }
+                for (const preserved of witness.preserved_section_digests) {
+                    if (beforeDigest.get(preserved.section_key) !== preserved.sha256 || afterDigest.get(preserved.section_key) !== preserved.sha256) {
+                        throw new Error("accepted_fixture_mutation_preserved_section_mismatch");
+                    }
+                }
+            }
+            const candidateProfile = parseCompileTargetProfile(candidate.target_profile);
+            const candidateDigest = await compileTargetProfileDigest(candidateProfile);
+            const declaredDigests = await Promise.all(entry.target_profiles.map((profile) => compileTargetProfileDigest(profile)));
+            if (!declaredDigests.includes(candidateDigest)) {
+                throw new Error("accepted_fixture_target_profile_not_declared");
+            }
+            const input = await captureNeutralSourceCompileInput({
+                witness: {
+                    owner_id: "accepted-source-corpus",
+                    scenario_id: entry.scenario_id,
+                    source_revision: 1,
+                    manifest_digest: entry.manifest_sha256,
+                    source_digest: sha256Hex(await sha256Bytes(bytes)),
+                    revision_digest: entry.source_sha256,
+                    previous_head_digest: null,
+                    head_digest: entry.manifest_sha256,
+                },
+                source_bytes: bytes,
+            });
+            const compiled = await compileNeutralScenarioSource(input, candidate.target_profile, candidate.registry, candidate.createCache());
+            if (!compiled.ok) {
+                const first = compiled.diagnostics[0];
+                throw new Error(first?.code ?? "accepted_fixture_compile_failed");
+            }
+            if (compiled.receipt.scenario_id !== entry.scenario_id
+                || compiled.receipt.source_manifest_sha256 !== entry.manifest_sha256)
+                throw new Error("accepted_fixture_compile_identity_mismatch");
+            passes.push(Object.freeze({
+                fixture_id: entry.fixture_id,
+                source_sha256: entry.source_sha256,
+                manifest_sha256: entry.manifest_sha256,
+                receipt: compiled.receipt,
+            }));
+        }
+        catch (error) {
+            failures.push(Object.freeze({
+                fixture_id: entry.fixture_id,
+                code: error instanceof Error ? error.message : "accepted_fixture_evaluation_failed",
+            }));
+        }
+    }
+    return failures.length === 0
+        ? Object.freeze({
+            promotable: true,
+            passes: Object.freeze(passes),
+            failures: Object.freeze([]),
+        })
+        : Object.freeze({
+            promotable: false,
+            passes: Object.freeze(passes),
+            failures: Object.freeze(failures),
+        });
+}