@world-engines/tmw 0.1.0-alpha.0

package/dist/compiler-release-authority.js

@@ -0,0 +1,676 @@
+import { compileTargetProfileDigest, parseCompileTargetProfile, } from "./compile-target-profile.js";
+import { evaluateCompilerCandidate, parseAcceptedNeutralSourceCorpus, } from "./compiler-compatibility-gate.js";
+import { InMemoryCompilerStageCache, } from "./compiler-stage-cache.js";
+import { assertRegistryMatchesTargetProfile, } from "./compiler-stage-registry.js";
+import { canonicalNeutralSourceCompilerReceiptBytes, compileNeutralScenarioSource, } from "./neutral-source-compiler.js";
+import { canonicalTmwBytes, isSha256Hex, tmwSha256Hex, } from "./runtime-contract.js";
+import { captureNeutralSourceCompileInput, } from "@world-engines/scenario-author-source";
+export const COMPILER_RELEASE_AUTHORITY_SCHEMA_VERSION = 1;
+function requireRecord(value, code) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error(code);
+    }
+    return value;
+}
+async function parseReleaseIdentity(value) {
+    if (value === null)
+        return null;
+    const record = requireRecord(value, "compiler_release_identity_invalid");
+    const compilerRelease = requireIdentifier(String(record.compiler_release ?? ""), "compiler_release_identity_invalid");
+    const targetProfile = parseCompileTargetProfile(record.target_profile);
+    const targetProfileSha256 = requireSha256(String(record.target_profile_sha256 ?? ""), "compiler_release_identity_digest_invalid");
+    if (compilerRelease !== targetProfile.compiler_release) {
+        throw new Error("compiler_release_identity_profile_mismatch");
+    }
+    if (await compileTargetProfileDigest(targetProfile) !== targetProfileSha256) {
+        throw new Error("compiler_release_identity_digest_mismatch");
+    }
+    return Object.freeze({
+        compiler_release: compilerRelease,
+        target_profile: targetProfile,
+        target_profile_sha256: targetProfileSha256,
+    });
+}
+/**
+ * Browser 与 Node 生产消费者共用的只读 authority adapter。唯一状态来自调用方
+ * 注入的 Edge readback；adapter 不缓存、不初始化 active，也不能执行 promotion。
+ */
+export class ReadbackCompilerReleaseStore {
+    #load;
+    constructor(load) {
+        this.#load = load;
+    }
+    async read() {
+        return parseAuthoritySnapshot(await this.#load());
+    }
+    async writeOnce() {
+        throw new Error("compiler_release_readback_store_read_only");
+    }
+}
+async function parseAuthoritySnapshot(value) {
+    const envelope = requireRecord(value, "compiler_release_readback_invalid");
+    if (envelope.schema_version !== COMPILER_RELEASE_AUTHORITY_SCHEMA_VERSION) {
+        throw new Error("compiler_release_readback_schema_invalid");
+    }
+    if (!Number.isSafeInteger(envelope.revision) || Number(envelope.revision) < 0) {
+        throw new Error("compiler_release_readback_revision_invalid");
+    }
+    return Object.freeze({
+        schema_version: COMPILER_RELEASE_AUTHORITY_SCHEMA_VERSION,
+        revision: Number(envelope.revision),
+        active: await parseReleaseIdentity(envelope.active),
+        previous_active: await parseReleaseIdentity(envelope.previous_active),
+    });
+}
+export class RemoteCompilerReleaseAuthority {
+    #transport;
+    #currentPath;
+    constructor(transport, currentPath = "/v1/compiler-releases/current") {
+        this.#transport = transport;
+        this.#currentPath = currentPath;
+    }
+    async read() {
+        const response = await this.#transport.request({
+            method: "GET",
+            path: this.#currentPath,
+        });
+        if (response.status !== 200)
+            throw new Error(`compiler_release_readback_failed:${response.status}`);
+        return parseAuthoritySnapshot(response.body);
+    }
+    async readOperation(operationId) {
+        requireIdentifier(operationId, "compiler_release_operation_id_invalid");
+        const response = await this.#transport.request({
+            method: "GET",
+            path: `/_internal/compiler-releases/operations/${encodeURIComponent(operationId)}`,
+        });
+        if (response.status === 404)
+            return null;
+        if (response.status !== 200)
+            throw new Error(`compiler_release_operation_readback_failed:${response.status}`);
+        const envelope = requireRecord(response.body, "compiler_release_operation_readback_invalid");
+        if (envelope.operation_id !== operationId) {
+            throw new Error("compiler_release_operation_readback_identity_mismatch");
+        }
+        const receipt = requireRecord(envelope.receipt, "compiler_release_operation_receipt_invalid");
+        if (receipt.operation_id !== operationId) {
+            throw new Error("compiler_release_operation_receipt_identity_mismatch");
+        }
+        const digest = requireSha256(String(receipt.receipt_sha256 ?? ""), "compiler_release_operation_receipt_digest_invalid");
+        const { receipt_sha256: _digest, ...core } = receipt;
+        if (await tmwSha256Hex(canonicalTmwBytes(core)) !== digest) {
+            throw new Error("compiler_release_operation_receipt_digest_mismatch");
+        }
+        return receipt;
+    }
+    async apply(kind, expectedRevision, receipt) {
+        const response = await this.#transport.request({
+            method: "POST",
+            path: `/_internal/compiler-releases/${kind}`,
+            body: {
+                operation_id: receipt.operation_id,
+                expected_revision: expectedRevision,
+                receipt,
+            },
+        });
+        if (response.status !== 200)
+            throw new Error(`compiler_release_mutation_failed:${response.status}`);
+        const envelope = requireRecord(response.body, "compiler_release_mutation_readback_invalid");
+        return parseAuthoritySnapshot(envelope.authority);
+    }
+}
+/**
+ * 生产 promotion：先从唯一 Edge authority 做 operation readback；未提交时在冻结快照上
+ * 执行完整 corpus KAT，再把完整 receipt 交给 Edge CAS。网络结果不确定时以同一
+ * operation_id 重试会先读回 receipt，不会重复推进 pointer。
+ */
+export async function promotePersistedCompilerReleaseCandidate(input) {
+    const replay = await input.authority.readOperation(input.operation_id);
+    if (replay !== null) {
+        if (replay.operation_kind !== "promote_candidate") {
+            throw new Error(`compiler_release_operation_conflict:${input.operation_id}`);
+        }
+        const candidate = await identityFromCandidate(input.candidate);
+        const source = sourceIdentity(cloneSourceSnapshot(await input.live_store.snapshot()));
+        if (!identitiesEqual(replay.candidate, candidate)
+            || replay.corpus_digest !== await digestCorpus(input.corpus_value)
+            || !sourceIdentitiesEqual(replay.source_before, source)
+            || !sourceIdentitiesEqual(replay.source_after, source)) {
+            throw new Error(`compiler_release_operation_conflict:${input.operation_id}`);
+        }
+        return Object.freeze({ promotable: true, switched: false, receipt: replay });
+    }
+    const before = await input.authority.read();
+    const localStore = new InMemoryCompilerReleaseStore(before);
+    const outcome = await promoteCompilerReleaseCandidate({ ...input, store: localStore });
+    if (!outcome.promotable)
+        return outcome;
+    const after = await input.authority.apply("promote", before.revision, outcome.receipt);
+    if (!identitiesEqual(after.active, outcome.receipt.active_after)) {
+        throw new Error("compiler_release_promotion_readback_mismatch");
+    }
+    const persisted = await input.authority.readOperation(input.operation_id);
+    if (persisted?.receipt_sha256 !== outcome.receipt.receipt_sha256) {
+        throw new Error("compiler_release_operation_readback_mismatch");
+    }
+    return Object.freeze({ ...outcome, receipt: persisted });
+}
+export async function rollbackPersistedCompilerRelease(input) {
+    const replay = await input.authority.readOperation(input.operation_id);
+    if (replay !== null) {
+        if (replay.operation_kind !== "rollback_active") {
+            throw new Error(`compiler_release_operation_conflict:${input.operation_id}`);
+        }
+        const source = sourceIdentity(cloneSourceSnapshot(await input.live_store.snapshot()));
+        if (replay.corpus_digest !== requireSha256(input.corpus_digest, "compiler_release_corpus_digest_invalid")
+            || !sourceIdentitiesEqual(replay.source_before, source)
+            || !sourceIdentitiesEqual(replay.source_after, source)) {
+            throw new Error(`compiler_release_operation_conflict:${input.operation_id}`);
+        }
+        return replay;
+    }
+    const before = await input.authority.read();
+    const localStore = new InMemoryCompilerReleaseStore(before);
+    const receipt = await rollbackCompilerRelease({ ...input, store: localStore });
+    const after = await input.authority.apply("rollback", before.revision, receipt);
+    if (!identitiesEqual(after.active, receipt.active_after)) {
+        throw new Error("compiler_release_rollback_readback_mismatch");
+    }
+    const persisted = await input.authority.readOperation(input.operation_id);
+    if (persisted?.receipt_sha256 !== receipt.receipt_sha256) {
+        throw new Error("compiler_release_operation_readback_mismatch");
+    }
+    return persisted;
+}
+function requireIdentifier(value, code) {
+    if (value.length === 0 || value !== value.trim().normalize("NFC")) {
+        throw new Error(code);
+    }
+    return value;
+}
+function requireSha256(value, code) {
+    if (!isSha256Hex(value))
+        throw new Error(code);
+    return value;
+}
+function bytesEqual(left, right) {
+    if (left.byteLength !== right.byteLength)
+        return false;
+    let difference = 0;
+    for (let index = 0; index < left.byteLength; index += 1) {
+        difference |= (left[index] ?? 0) ^ (right[index] ?? 0);
+    }
+    return difference === 0;
+}
+function cloneBytes(bytes) {
+    return bytes.slice();
+}
+function cloneIdentity(identity) {
+    if (identity === null)
+        return null;
+    return Object.freeze({
+        compiler_release: identity.compiler_release,
+        target_profile: parseCompileTargetProfile(identity.target_profile),
+        target_profile_sha256: requireSha256(identity.target_profile_sha256, "compiler_release_identity_digest_invalid"),
+    });
+}
+function sourceIdentity(snapshot) {
+    return Object.freeze({
+        source_sha256: snapshot.source_sha256,
+        manifest_sha256: snapshot.manifest_sha256,
+        head_digest: snapshot.head_digest,
+        source_revision: snapshot.source_revision,
+        author_operation_count: snapshot.author_operation_count,
+    });
+}
+function sourceIdentitiesEqual(left, right) {
+    return left.source_sha256 === right.source_sha256
+        && left.manifest_sha256 === right.manifest_sha256
+        && left.head_digest === right.head_digest
+        && left.source_revision === right.source_revision
+        && left.author_operation_count === right.author_operation_count;
+}
+function cloneSourceSnapshot(snapshot) {
+    if (!(snapshot.source_bytes instanceof Uint8Array)
+        || !Number.isSafeInteger(snapshot.source_revision)
+        || snapshot.source_revision < 1
+        || !Number.isSafeInteger(snapshot.author_operation_count)
+        || snapshot.author_operation_count < 0)
+        throw new Error("compiler_release_source_snapshot_invalid");
+    return Object.freeze({
+        source_bytes: cloneBytes(snapshot.source_bytes),
+        source_sha256: requireSha256(snapshot.source_sha256, "compiler_release_source_digest_invalid"),
+        manifest_sha256: requireSha256(snapshot.manifest_sha256, "compiler_release_manifest_digest_invalid"),
+        head_digest: requireSha256(snapshot.head_digest, "compiler_release_head_digest_invalid"),
+        source_revision: snapshot.source_revision,
+        author_operation_count: snapshot.author_operation_count,
+    });
+}
+function sourceSnapshotsEqual(left, right) {
+    return left.source_sha256 === right.source_sha256
+        && left.manifest_sha256 === right.manifest_sha256
+        && left.head_digest === right.head_digest
+        && left.source_revision === right.source_revision
+        && left.author_operation_count === right.author_operation_count
+        && bytesEqual(left.source_bytes, right.source_bytes);
+}
+function identitiesEqual(left, right) {
+    if (left === null || right === null)
+        return left === right;
+    return left.compiler_release === right.compiler_release
+        && left.target_profile_sha256 === right.target_profile_sha256;
+}
+function compilerIdentitiesCompatible(left, right) {
+    const expected = left.target_profile;
+    const actual = right.target_profile;
+    return left.compiler_release === right.compiler_release
+        && expected.schema_version === actual.schema_version
+        && expected.sdk_schema === actual.sdk_schema
+        && expected.artifact_format === actual.artifact_format
+        && expected.stage_versions.length === actual.stage_versions.length
+        && expected.stage_versions.every((stage, index) => {
+            const other = actual.stage_versions[index];
+            return other !== undefined
+                && stage.stage_id === other.stage_id
+                && stage.stage_version === other.stage_version;
+        });
+}
+function storeSnapshotsEqual(left, right) {
+    return identitiesEqual(left.active, right.active)
+        && identitiesEqual(left.previous_active, right.previous_active);
+}
+async function identityFromCandidate(candidate) {
+    const targetProfile = parseCompileTargetProfile(candidate.target_profile);
+    assertRegistryMatchesTargetProfile(candidate.registry, targetProfile);
+    return Object.freeze({
+        compiler_release: targetProfile.compiler_release,
+        target_profile: targetProfile,
+        target_profile_sha256: await compileTargetProfileDigest(targetProfile),
+    });
+}
+async function digestCorpus(value) {
+    return tmwSha256Hex(canonicalTmwBytes(parseAcceptedNeutralSourceCorpus(value)));
+}
+function unknownContentWitnessesFromPasses(corpusValue, passes) {
+    const corpus = parseAcceptedNeutralSourceCorpus(corpusValue);
+    const passed = new Set(passes.map((entry) => entry.fixture_id));
+    const witnesses = [];
+    for (const entry of corpus.sources) {
+        if (!passed.has(entry.fixture_id))
+            continue;
+        for (const witness of entry.byte_range_witnesses) {
+            witnesses.push(Object.freeze({
+                kind: witness.kind,
+                path: `${entry.fixture_id}:${witness.path}`,
+                sha256: witness.sha256,
+            }));
+        }
+        for (const witness of entry.content_witnesses) {
+            if (witness.kind === "unknown_protobuf_fields"
+                || witness.kind === "unknown_future_section"
+                || witness.kind === "empty_section_payload") {
+                witnesses.push(Object.freeze({
+                    kind: witness.kind,
+                    path: `${entry.fixture_id}:${witness.section_key}`,
+                    sha256: witness.sha256,
+                }));
+            }
+        }
+    }
+    return Object.freeze(witnesses);
+}
+async function sealReceipt(core) {
+    return Object.freeze({
+        ...core,
+        receipt_sha256: await tmwSha256Hex(canonicalTmwBytes(core)),
+    });
+}
+function replayOrConflict(existing, next) {
+    if (existing.receipt_sha256 === next.receipt_sha256)
+        return existing;
+    if (existing.operation_id === next.operation_id
+        && existing.operation_kind === next.operation_kind
+        && existing.corpus_digest === next.corpus_digest
+        && identitiesEqual(existing.candidate, next.candidate)
+        && identitiesEqual(existing.active_before, next.active_before)
+        && identitiesEqual(existing.active_after, next.active_after)
+        && sourceIdentitiesEqual(existing.source_before, next.source_before)
+        && sourceIdentitiesEqual(existing.source_after, next.source_after))
+        return existing;
+    throw new Error(`compiler_release_operation_conflict:${next.operation_id}`);
+}
+export class InMemoryCompilerReleaseStore {
+    #snapshot;
+    constructor(initial = Object.freeze({
+        active: null,
+        previous_active: null,
+    })) {
+        this.#snapshot = Object.freeze({
+            active: cloneIdentity(initial.active),
+            previous_active: cloneIdentity(initial.previous_active),
+        });
+    }
+    async read() {
+        return Object.freeze({
+            active: cloneIdentity(this.#snapshot.active),
+            previous_active: cloneIdentity(this.#snapshot.previous_active),
+        });
+    }
+    async writeOnce(expected, next) {
+        const current = await this.read();
+        const wanted = Object.freeze({
+            active: cloneIdentity(expected.active),
+            previous_active: cloneIdentity(expected.previous_active),
+        });
+        const following = Object.freeze({
+            active: cloneIdentity(next.active),
+            previous_active: cloneIdentity(next.previous_active),
+        });
+        if (storeSnapshotsEqual(current, following))
+            return "already_present";
+        if (!storeSnapshotsEqual(current, wanted)) {
+            throw new Error("compiler_release_store_cas_mismatch");
+        }
+        this.#snapshot = following;
+        return "stored";
+    }
+}
+export class MapBackedCompilerReleaseClearableCache {
+    #inner = new InMemoryCompilerStageCache();
+    #keys = new Set();
+    async read(cacheKey) {
+        return this.#inner.read(cacheKey);
+    }
+    async writeOnce(entry) {
+        const result = await this.#inner.writeOnce(entry);
+        this.#keys.add(entry.cache_key);
+        return result;
+    }
+    async delete(cacheKey) {
+        this.#keys.delete(cacheKey);
+        await this.#inner.delete(cacheKey);
+    }
+    async keys() {
+        return Object.freeze([...this.#keys].sort());
+    }
+    async clear() {
+        const observed = await this.keys();
+        await Promise.all(observed.map((cacheKey) => this.delete(cacheKey)));
+    }
+}
+export class InMemoryCompilerReleaseDerivedStore {
+    #objects = new Map();
+    async read(objectId) {
+        const bytes = this.#objects.get(objectId);
+        return bytes === undefined ? null : cloneBytes(bytes);
+    }
+    async writeOnce(objectId, bytes) {
+        requireIdentifier(objectId, "compiler_release_derived_object_id_invalid");
+        if (!(bytes instanceof Uint8Array)) {
+            throw new Error("compiler_release_derived_bytes_invalid");
+        }
+        const existing = this.#objects.get(objectId);
+        if (existing !== undefined) {
+            if (!bytesEqual(existing, bytes)) {
+                throw new Error("compiler_release_derived_write_conflict");
+            }
+            return "already_present";
+        }
+        this.#objects.set(objectId, cloneBytes(bytes));
+        return "stored";
+    }
+    async delete(objectId) {
+        this.#objects.delete(objectId);
+    }
+}
+export class FrozenCompilerReleaseLiveStore {
+    #snapshot;
+    constructor(snapshot) {
+        this.#snapshot = cloneSourceSnapshot(snapshot);
+    }
+    async snapshot() {
+        return cloneSourceSnapshot(this.#snapshot);
+    }
+    async mutateWorkingProjection(mutator) {
+        const nextBytes = mutator(cloneBytes(this.#snapshot.source_bytes));
+        if (!(nextBytes instanceof Uint8Array)) {
+            throw new Error("compiler_release_live_store_mutation_invalid");
+        }
+        this.#snapshot = Object.freeze({
+            ...this.#snapshot,
+            source_bytes: cloneBytes(nextBytes),
+            source_sha256: await tmwSha256Hex(nextBytes),
+        });
+    }
+}
+const operationReceipts = new Map();
+function existingOperationReceipt(operationId) {
+    return operationReceipts.get(operationId);
+}
+function rememberReceipt(receipt) {
+    const existing = existingOperationReceipt(receipt.operation_id);
+    if (existing !== undefined)
+        return replayOrConflict(existing, receipt);
+    operationReceipts.set(receipt.operation_id, receipt);
+    return receipt;
+}
+async function buildPromotionReceipt(input, kind, candidateIdentity, activeBefore, activeAfter, previousActive, sourceBefore, sourceAfter, passes, failures) {
+    if (!sourceSnapshotsEqual(sourceBefore, sourceAfter)) {
+        throw new Error("compiler_release_source_mutated");
+    }
+    const core = Object.freeze({
+        receipt_schema_version: COMPILER_RELEASE_AUTHORITY_SCHEMA_VERSION,
+        operation_id: requireIdentifier(input.operation_id, "compiler_release_operation_id_invalid"),
+        operation_kind: kind,
+        corpus_digest: await digestCorpus(input.corpus_value),
+        candidate: candidateIdentity,
+        active_before: cloneIdentity(activeBefore),
+        active_after: cloneIdentity(activeAfter),
+        previous_active: cloneIdentity(previousActive),
+        source_before: sourceIdentity(sourceBefore),
+        source_after: sourceIdentity(sourceAfter),
+        fixture_passes: Object.freeze([...passes]),
+        fixture_failures: Object.freeze([...failures]),
+        unknown_content_witnesses: unknownContentWitnessesFromPasses(input.corpus_value, passes),
+    });
+    return rememberReceipt(await sealReceipt(core));
+}
+async function inspectCompilerReleaseCandidate(input) {
+    const sourceBefore = cloneSourceSnapshot(await input.live_store.snapshot());
+    const candidateIdentity = await identityFromCandidate(input.candidate);
+    const gate = await evaluateCompilerCandidate(input.candidate, input.corpus_value, input.load_fixture);
+    const sourceAfter = cloneSourceSnapshot(await input.live_store.snapshot());
+    return Object.freeze({
+        candidateIdentity,
+        sourceBefore,
+        sourceAfter,
+        passes: gate.passes,
+        failures: gate.failures,
+        promotable: gate.promotable,
+    });
+}
+export async function evaluateCompilerReleaseCandidate(input, activeBefore = null) {
+    const inspected = await inspectCompilerReleaseCandidate(input);
+    if (inspected.promotable) {
+        return Object.freeze({
+            promotable: true,
+            switched: false,
+            receipt: await buildPromotionReceipt(input, "evaluate_candidate", inspected.candidateIdentity, activeBefore, activeBefore, activeBefore, inspected.sourceBefore, inspected.sourceAfter, inspected.passes, inspected.failures),
+        });
+    }
+    return Object.freeze({
+        promotable: false,
+        switched: false,
+        receipt: await buildPromotionReceipt(input, "reject_candidate", inspected.candidateIdentity, activeBefore, activeBefore, activeBefore, inspected.sourceBefore, inspected.sourceAfter, inspected.passes, inspected.failures),
+    });
+}
+export async function promoteCompilerReleaseCandidate(input) {
+    const existing = existingOperationReceipt(input.operation_id);
+    if (existing !== undefined) {
+        if (existing.operation_kind === "reject_candidate") {
+            return Object.freeze({
+                promotable: false,
+                switched: false,
+                receipt: existing,
+            });
+        }
+        if (existing.operation_kind !== "promote_candidate") {
+            throw new Error(`compiler_release_operation_conflict:${input.operation_id}`);
+        }
+        return Object.freeze({
+            promotable: true,
+            switched: false,
+            receipt: existing,
+        });
+    }
+    const storeBefore = await input.store.read();
+    const inspected = await inspectCompilerReleaseCandidate(input);
+    if (!inspected.promotable) {
+        const current = await input.store.read();
+        if (!identitiesEqual(current.active, storeBefore.active)) {
+            throw new Error("compiler_release_active_drift");
+        }
+        return Object.freeze({
+            promotable: false,
+            switched: false,
+            receipt: await buildPromotionReceipt(input, "reject_candidate", inspected.candidateIdentity, storeBefore.active, storeBefore.active, storeBefore.previous_active, inspected.sourceBefore, inspected.sourceAfter, inspected.passes, inspected.failures),
+        });
+    }
+    const next = Object.freeze({
+        active: inspected.candidateIdentity,
+        previous_active: storeBefore.active,
+    });
+    await input.store.writeOnce(storeBefore, next);
+    const storeAfter = await input.store.read();
+    const sourceAfter = cloneSourceSnapshot(await input.live_store.snapshot());
+    if (!sourceSnapshotsEqual(inspected.sourceBefore, sourceAfter)) {
+        throw new Error("compiler_release_source_mutated");
+    }
+    return Object.freeze({
+        promotable: true,
+        switched: !identitiesEqual(storeBefore.active, storeAfter.active),
+        receipt: await buildPromotionReceipt(input, "promote_candidate", inspected.candidateIdentity, storeBefore.active, storeAfter.active, storeAfter.previous_active, inspected.sourceBefore, sourceAfter, inspected.passes, inspected.failures),
+    });
+}
+export async function rollbackCompilerRelease(input) {
+    const existing = existingOperationReceipt(input.operation_id);
+    if (existing !== undefined) {
+        if (existing.operation_kind !== "rollback_active") {
+            throw new Error(`compiler_release_operation_conflict:${input.operation_id}`);
+        }
+        return existing;
+    }
+    const sourceBefore = cloneSourceSnapshot(await input.live_store.snapshot());
+    const storeBefore = await input.store.read();
+    if (storeBefore.previous_active === null) {
+        throw new Error("compiler_release_rollback_previous_missing");
+    }
+    const next = Object.freeze({
+        active: storeBefore.previous_active,
+        previous_active: storeBefore.active,
+    });
+    await input.store.writeOnce(storeBefore, next);
+    const storeAfter = await input.store.read();
+    const sourceAfter = cloneSourceSnapshot(await input.live_store.snapshot());
+    if (!sourceSnapshotsEqual(sourceBefore, sourceAfter)) {
+        throw new Error("compiler_release_source_mutated");
+    }
+    if (storeBefore.active === null) {
+        throw new Error("compiler_release_rollback_active_missing");
+    }
+    const core = Object.freeze({
+        receipt_schema_version: COMPILER_RELEASE_AUTHORITY_SCHEMA_VERSION,
+        operation_id: requireIdentifier(input.operation_id, "compiler_release_operation_id_invalid"),
+        operation_kind: "rollback_active",
+        corpus_digest: requireSha256(input.corpus_digest, "compiler_release_corpus_digest_invalid"),
+        candidate: storeBefore.active,
+        active_before: storeBefore.active,
+        active_after: storeAfter.active,
+        previous_active: storeAfter.previous_active,
+        source_before: sourceIdentity(sourceBefore),
+        source_after: sourceIdentity(sourceAfter),
+        fixture_passes: Object.freeze([]),
+        fixture_failures: Object.freeze([]),
+        unknown_content_witnesses: Object.freeze([]),
+    });
+    return rememberReceipt(await sealReceipt(core));
+}
+export async function captureCompilerReleaseBuild(input) {
+    const snapshot = cloneSourceSnapshot(await input.live_store.snapshot());
+    const targetProfile = parseCompileTargetProfile(input.target_profile);
+    const source = await captureNeutralSourceCompileInput({
+        witness: input.witness,
+        source_bytes: snapshot.source_bytes,
+    });
+    return Object.freeze({
+        operation_id: requireIdentifier(input.operation_id, "compiler_release_operation_id_invalid"),
+        source,
+        target_profile: targetProfile,
+        target_profile_sha256: await compileTargetProfileDigest(targetProfile),
+    });
+}
+async function derivedDigest(objects) {
+    return tmwSha256Hex(canonicalTmwBytes(objects.map((object) => ({
+        stage_id: object.stage_id,
+        stage_version: object.stage_version,
+        media_type: object.media_type,
+        byte_length: object.byte_length,
+        sha256: object.sha256,
+    }))));
+}
+export async function rebuildCompilerReleaseArtifact(input) {
+    assertRegistryMatchesTargetProfile(input.registry, input.captured.target_profile);
+    const compiled = await compileNeutralScenarioSource(input.captured.source, input.captured.target_profile, input.registry, input.cache);
+    if (!compiled.ok) {
+        const first = compiled.diagnostics[0];
+        throw new Error(first?.code ?? "compiler_release_rebuild_failed");
+    }
+    const receiptBytes = canonicalNeutralSourceCompilerReceiptBytes(compiled.receipt);
+    const artifactDigest = await derivedDigest(compiled.derived_objects);
+    const witnessDigest = await tmwSha256Hex(receiptBytes);
+    if (compiled.receipt.receipt_sha256 !== witnessDigest) {
+        throw new Error("compiler_release_rebuild_witness_mismatch");
+    }
+    await input.derived_store.writeOnce(input.object_id, receiptBytes);
+    return Object.freeze({
+        ok: true,
+        operation_id: input.captured.operation_id,
+        compiler_release: compiled.receipt.compiler_release,
+        target_profile_sha256: compiled.receipt.target_profile_sha256,
+        source_manifest_sha256: compiled.receipt.source_manifest_sha256,
+        receipt: compiled.receipt,
+        derived_objects: compiled.derived_objects,
+        artifact_digest: artifactDigest,
+        witness_digest: witnessDigest,
+        cache_keys: await input.cache.keys(),
+    });
+}
+export async function clearAndRebuildCompilerReleaseArtifact(input) {
+    await input.cache.clear();
+    await input.derived_store.delete(input.object_id);
+    return rebuildCompilerReleaseArtifact(input);
+}
+export async function requireActiveCompilerRelease(store, expected) {
+    const current = await store.read();
+    if (current.active === null) {
+        throw new Error("compiler_release_active_missing");
+    }
+    const expectedIdentity = Object.freeze({
+        compiler_release: expected.compiler_release,
+        target_profile: parseCompileTargetProfile(expected),
+        target_profile_sha256: await compileTargetProfileDigest(expected),
+    });
+    if (!compilerIdentitiesCompatible(current.active, expectedIdentity)) {
+        throw new Error(`compiler_release_active_mismatch:${current.active.compiler_release}`);
+    }
+    return expectedIdentity;
+}
+/** @deprecated 生产 caller 必须注入 Edge readback；保留导出仅为增量兼容并始终 fail-closed。 */
+export const defaultCompilerReleaseStore = Object.freeze({
+    async read() {
+        throw new Error("compiler_release_authority_unconfigured");
+    },
+    async writeOnce() {
+        throw new Error("compiler_release_authority_unconfigured");
+    },
+});