project-tiny-context-harness 0.8.11 → 0.8.13

package/dist/lib/design-resource-recovery-delta-policy.js

@@ -0,0 +1,108 @@
+import { validateDesignResourceDeltaAuthority } from "./design-resource-recovery-authority-policy.js";
+import { canonicalValueJson } from "./strict-codec.js";
+export function validateDesignResourceDeltas(deltas, scope, excluded, delegations, authoritySources) {
+    const byId = new Map();
+    const superseded = new Set();
+    for (let index = 0; index < deltas.length; index += 1) {
+        const delta = deltas[index];
+        validateDeltaShape(delta, index, byId, scope, excluded);
+        validateDesignResourceDeltaAuthority(delta, delegations, authoritySources);
+        assertDisjoint(new Set(delta.supersedes), new Set(delta.proposes_replacement_of), `delta_replacement_relation_overlap:${delta.delta_id}`);
+        validateSupersession(delta, byId, superseded);
+        validateProposedReplacement(delta, byId, superseded);
+        byId.set(delta.delta_id, delta);
+    }
+    return { byId, superseded };
+}
+function validateDeltaShape(delta, index, byId, scope, excluded) {
+    assertUnique(delta.target_keys, `delta_target_duplicate:${delta.delta_id}`);
+    assertUnique(delta.supersedes, `delta_supersedes_duplicate:${delta.delta_id}`);
+    assertUnique(delta.proposes_replacement_of, `delta_proposes_replacement_duplicate:${delta.delta_id}`);
+    assertUnique(delta.evidence_refs, `delta_evidence_ref_duplicate:${delta.delta_id}`);
+    assertUnique(delta.source_refs, `delta_source_ref_duplicate:${delta.delta_id}`);
+    assertUnique(delta.explicitly_unchanged_keys, `delta_unchanged_duplicate:${delta.delta_id}`);
+    if (delta.sequence !== index + 1)
+        invalid(`delta_sequence:${delta.delta_id}:${delta.sequence}:${index + 1}`);
+    if (byId.has(delta.delta_id))
+        invalid(`delta_id_duplicate:${delta.delta_id}`);
+    assertSubset(new Set(delta.target_keys), scope, `delta_target_outside_scope:${delta.delta_id}`);
+    assertDisjoint(new Set(delta.target_keys), excluded, `delta_target_excluded:${delta.delta_id}`);
+    assertDisjoint(new Set(delta.target_keys), new Set(delta.explicitly_unchanged_keys), `delta_changed_and_unchanged_overlap:${delta.delta_id}`);
+    validateOperationSemantics(delta);
+}
+function validateSupersession(delta, byId, superseded) {
+    for (const earlier of delta.supersedes) {
+        const replaced = byId.get(earlier);
+        if (!replaced)
+            invalid(`delta_supersedes_missing_or_later:${delta.delta_id}:${earlier}`);
+        if (delta.status !== "accepted")
+            invalid(`delta_superseder_not_accepted:${delta.delta_id}`);
+        if (replaced.status !== "accepted")
+            invalid(`delta_supersedes_nonaccepted:${delta.delta_id}:${earlier}`);
+        if (superseded.has(earlier))
+            invalid(`delta_superseded_more_than_once:${earlier}`);
+        validateReplacementRelationship(delta, replaced, "supersedes");
+        superseded.add(earlier);
+    }
+}
+function validateProposedReplacement(delta, byId, superseded) {
+    for (const earlier of delta.proposes_replacement_of) {
+        const proposed = byId.get(earlier);
+        if (!proposed)
+            invalid(`delta_proposes_replacement_missing_or_later:${delta.delta_id}:${earlier}`);
+        if (delta.status === "accepted")
+            invalid(`accepted_delta_uses_proposal_relation:${delta.delta_id}`);
+        if (proposed.status !== "accepted" || superseded.has(earlier))
+            invalid(`delta_proposes_replacement_of_inactive:${delta.delta_id}:${earlier}`);
+        validateReplacementRelationship(delta, proposed, "proposes_replacement_of");
+    }
+}
+function validateOperationSemantics(delta) {
+    const before = canonicalValueJson(delta.before_semantics);
+    const after = canonicalValueJson(delta.after_semantics);
+    if (delta.operation === "add" && delta.before_semantics !== null)
+        invalid(`delta_add_before_must_be_null:${delta.delta_id}`);
+    if (delta.operation === "remove" && delta.after_semantics !== null)
+        invalid(`delta_remove_after_must_be_null:${delta.delta_id}`);
+    if (delta.operation === "preserve" && before !== after)
+        invalid(`delta_preserve_semantics_changed:${delta.delta_id}`);
+    if (delta.operation !== "preserve" && before === after)
+        invalid(`delta_change_semantics_equal:${delta.delta_id}`);
+    if (delta.operation === "preserve" &&
+        (delta.supersedes.length || delta.proposes_replacement_of.length))
+        invalid(`delta_preserve_cannot_replace:${delta.delta_id}`);
+    if (delta.status === "accepted" && !delta.source_refs.length)
+        invalid(`accepted_delta_source_refs_required:${delta.delta_id}`);
+}
+function validateReplacementRelationship(replacement, previous, relation) {
+    assertEqualSet(new Set(replacement.target_keys), new Set(previous.target_keys), `delta_${relation}_target_mismatch:${replacement.delta_id}:${previous.delta_id}`);
+    if (canonicalValueJson(replacement.before_semantics) !==
+        canonicalValueJson(previous.after_semantics))
+        invalid(`delta_${relation}_semantic_mismatch:${replacement.delta_id}:${previous.delta_id}`);
+    if (replacement.semantic_kind !== previous.semantic_kind)
+        invalid(`delta_${relation}_semantic_kind_mismatch:${replacement.delta_id}:${previous.delta_id}`);
+}
+function assertUnique(values, code) {
+    if (new Set(values).size !== values.length)
+        invalid(code);
+}
+function assertSubset(candidate, owner, code) {
+    const outside = [...candidate].filter((value) => !owner.has(value));
+    if (outside.length)
+        invalid(`${code}:${outside.sort(compareText).join(",")}`);
+}
+function assertDisjoint(left, right, code) {
+    const overlap = [...left].filter((value) => right.has(value));
+    if (overlap.length)
+        invalid(`${code}:${overlap.sort(compareText).join(",")}`);
+}
+function assertEqualSet(left, right, code) {
+    if (left.size !== right.size || [...left].some((value) => !right.has(value)))
+        invalid(code);
+}
+function invalid(code) {
+    throw new Error(`design_resource_recovery_invalid:${code}`);
+}
+function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/lib/design-resource-recovery-files.d.ts

@@ -0,0 +1,37 @@
+export declare const DESIGN_RESOURCE_RECOVERY_ROOT = "tmp/ty-context/design-resource-recovery";
+export interface RecoveryFileSnapshot {
+    relative: string;
+    absolute: string;
+    bytes: Buffer;
+    raw_byte_digest: string;
+    mode: number;
+}
+export declare function recoveryCheckpointRelativePath(sessionId: string): string;
+export declare function readRecoveryRepositoryFile(repository: string, locatorInput: string, label: string): Promise<RecoveryFileSnapshot>;
+export declare function readRecoveryCheckpointFile(repository: string, sessionId: string): Promise<RecoveryFileSnapshot>;
+export declare function createRecoveryCheckpointFile(repository: string, sessionId: string, bytes: Uint8Array): Promise<{
+    path: string;
+    raw_byte_digest: string;
+    changed: boolean;
+}>;
+export declare function updateRecoveryCheckpointFile(repository: string, sessionId: string, bytes: Uint8Array, expectedCurrentDigest: string): Promise<{
+    path: string;
+    raw_byte_digest: string;
+    changed: boolean;
+}>;
+export declare function atomicCasWrite(repository: string, relativeInput: string, bytes: Uint8Array, expectedCurrentDigest: string | null, mode: number): Promise<string>;
+export declare function removeRecoveryCheckpointFile(repository: string, sessionId: string, expectedDigest: string): Promise<{
+    status: "removed";
+    path: string;
+    checkpoint_removed: true;
+    session_directory_removed: true;
+    retained_entries: [];
+} | {
+    status: "partial";
+    path: string;
+    checkpoint_removed: boolean;
+    session_directory_removed: false;
+    retained_entries: string[];
+    reason: "unowned_entries" | "session_directory_cleanup_failed";
+}>;
+export declare function deriveDigestCasState(current: string, before: string, after: string): "unapplied" | "applied" | "conflict";

package/dist/lib/design-resource-recovery-files.js

@@ -0,0 +1,204 @@
+import { randomUUID } from "node:crypto";
+import { execFile } from "node:child_process";
+import { lstat, open, readFile, readdir, rename, rmdir, unlink, } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { normalizeRepositoryFile } from "./long-task-paths.js";
+import { assertProtectedRepositoryFile, assertSafeRepositoryFilePath, ensureSafeRepositoryDirectory, resolveInsideRepository, } from "./repository-path-safety.js";
+import { sha256Hex } from "./strict-codec.js";
+export const DESIGN_RESOURCE_RECOVERY_ROOT = "tmp/ty-context/design-resource-recovery";
+const execFileAsync = promisify(execFile);
+export function recoveryCheckpointRelativePath(sessionId) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u.test(sessionId))
+        invalid(`unsafe_session_id:${sessionId}`);
+    return `${DESIGN_RESOURCE_RECOVERY_ROOT}/${sessionId}/checkpoint.json`;
+}
+export async function readRecoveryRepositoryFile(repository, locatorInput, label) {
+    const relative = normalizeRepositoryFile(locatorInput, label);
+    const absolute = resolveInsideRepository(repository, relative, label);
+    const safe = await assertProtectedRepositoryFile(repository, absolute, label);
+    const [bytes, status] = await Promise.all([readFile(safe), lstat(safe)]);
+    return {
+        relative,
+        absolute: safe,
+        bytes,
+        raw_byte_digest: sha256Hex(bytes),
+        mode: status.mode,
+    };
+}
+export async function readRecoveryCheckpointFile(repository, sessionId) {
+    return readRecoveryRepositoryFile(repository, recoveryCheckpointRelativePath(sessionId), "design_resource_recovery_checkpoint");
+}
+export async function createRecoveryCheckpointFile(repository, sessionId, bytes) {
+    const relative = recoveryCheckpointRelativePath(sessionId);
+    await assertRecoveryPathIgnored(repository, relative);
+    await ensureRecoverySessionDirectory(repository, sessionId);
+    const existing = await readOptionalRepositoryFile(repository, relative);
+    const expectedDigest = sha256Hex(bytes);
+    if (existing) {
+        if (existing.raw_byte_digest !== expectedDigest)
+            invalid(`checkpoint_collision:${relative}`);
+        return { path: relative, raw_byte_digest: expectedDigest, changed: false };
+    }
+    const result = await atomicCasWrite(repository, relative, bytes, null, 0o600);
+    return { path: relative, raw_byte_digest: result, changed: true };
+}
+export async function updateRecoveryCheckpointFile(repository, sessionId, bytes, expectedCurrentDigest) {
+    const relative = recoveryCheckpointRelativePath(sessionId);
+    await assertRecoveryPathIgnored(repository, relative);
+    const existing = await readRecoveryCheckpointFile(repository, sessionId);
+    if (existing.raw_byte_digest !== expectedCurrentDigest)
+        invalid(`checkpoint_update_cas_conflict:${expectedCurrentDigest}:${existing.raw_byte_digest}`);
+    const nextDigest = sha256Hex(bytes);
+    if (nextDigest === existing.raw_byte_digest)
+        return { path: relative, raw_byte_digest: nextDigest, changed: false };
+    const written = await atomicCasWrite(repository, relative, bytes, expectedCurrentDigest, existing.mode);
+    return { path: relative, raw_byte_digest: written, changed: true };
+}
+export async function atomicCasWrite(repository, relativeInput, bytes, expectedCurrentDigest, mode) {
+    const relative = normalizeRepositoryFile(relativeInput, "design_resource_recovery_write_target");
+    const destination = await assertSafeRepositoryFilePath(repository, relative, "design_resource_recovery_write_target", { destinationMayBeAbsent: true });
+    const current = await readOptionalRepositoryFile(repository, relative);
+    assertExpectedDigest(current?.raw_byte_digest ?? null, expectedCurrentDigest);
+    const digest = sha256Hex(bytes);
+    const temporary = path.join(path.dirname(destination.absolute), `.${path.basename(destination.absolute)}.ty-context-dra-${randomUUID()}.tmp`);
+    let created = false;
+    try {
+        const handle = await open(temporary, "wx", mode & 0o777);
+        created = true;
+        try {
+            await handle.writeFile(bytes);
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        const tempBytes = await readFile(temporary);
+        if (sha256Hex(tempBytes) !== digest)
+            invalid("temporary_readback_mismatch");
+        const beforeRename = await readOptionalRepositoryFile(repository, relative);
+        assertExpectedDigest(beforeRename?.raw_byte_digest ?? null, expectedCurrentDigest);
+        await rename(temporary, destination.absolute);
+        created = false;
+        const after = await readRecoveryRepositoryFile(repository, relative, "design_resource_recovery_write_readback");
+        if (after.raw_byte_digest !== digest)
+            invalid("post_write_readback_mismatch");
+        return digest;
+    }
+    catch (error) {
+        if (!created)
+            throw error;
+        try {
+            await cleanupOwnedTemporary(temporary, digest);
+        }
+        catch (cleanupError) {
+            throw new AggregateError([error, cleanupError], "design_resource_recovery_cleanup_failed");
+        }
+        throw error;
+    }
+}
+export async function removeRecoveryCheckpointFile(repository, sessionId, expectedDigest) {
+    const snapshot = await readRecoveryCheckpointFile(repository, sessionId);
+    if (snapshot.raw_byte_digest !== expectedDigest)
+        invalid(`checkpoint_remove_cas_conflict:${expectedDigest}:${snapshot.raw_byte_digest}`);
+    const sessionDirectory = path.dirname(snapshot.absolute);
+    const before = (await readdir(sessionDirectory)).sort();
+    const unowned = before.filter((entry) => entry !== "checkpoint.json");
+    if (unowned.length)
+        return {
+            status: "partial",
+            path: snapshot.relative,
+            checkpoint_removed: false,
+            session_directory_removed: false,
+            retained_entries: before,
+            reason: "unowned_entries",
+        };
+    await unlink(snapshot.absolute);
+    try {
+        await rmdir(sessionDirectory);
+    }
+    catch {
+        const retained = await readdir(sessionDirectory).catch(() => []);
+        return {
+            status: "partial",
+            path: snapshot.relative,
+            checkpoint_removed: true,
+            session_directory_removed: false,
+            retained_entries: retained.sort(),
+            reason: "session_directory_cleanup_failed",
+        };
+    }
+    return {
+        status: "removed",
+        path: snapshot.relative,
+        checkpoint_removed: true,
+        session_directory_removed: true,
+        retained_entries: [],
+    };
+}
+export function deriveDigestCasState(current, before, after) {
+    if (current === before)
+        return "unapplied";
+    if (current === after)
+        return "applied";
+    return "conflict";
+}
+async function ensureRecoverySessionDirectory(repository, sessionId) {
+    const relative = `${DESIGN_RESOURCE_RECOVERY_ROOT}/${sessionId}`;
+    await ensureSafeRepositoryDirectory(repository, relative, "design_resource_recovery_session");
+    const absolute = resolveInsideRepository(repository, relative, "design_resource_recovery_session");
+    const entries = await readdir(absolute);
+    const collisions = entries.filter((entry) => entry !== "checkpoint.json");
+    if (collisions.length)
+        invalid(`session_directory_collision:${collisions.sort().join(",")}`);
+}
+async function assertRecoveryPathIgnored(repository, relative) {
+    try {
+        await execFileAsync("git", ["check-ignore", "--quiet", "--", relative], {
+            cwd: repository,
+            windowsHide: true,
+        });
+    }
+    catch (error) {
+        if (error.code === 1)
+            invalid(`checkpoint_path_not_ignored:${relative}`);
+        throw error;
+    }
+    try {
+        await execFileAsync("git", ["ls-files", "--error-unmatch", "--", relative], { cwd: repository, windowsHide: true });
+        invalid(`checkpoint_path_tracked:${relative}`);
+    }
+    catch (error) {
+        if (error.code !== 1)
+            throw error;
+    }
+}
+async function readOptionalRepositoryFile(repository, relative) {
+    try {
+        return await readRecoveryRepositoryFile(repository, relative, "design_resource_recovery_optional_file");
+    }
+    catch (error) {
+        if (error.message.includes("protected_input_not_found:"))
+            return null;
+        throw error;
+    }
+}
+function assertExpectedDigest(actual, expected) {
+    if (actual === expected)
+        return;
+    invalid(`cas_conflict:${expected ?? "absent"}:${actual ?? "absent"}`);
+}
+async function cleanupOwnedTemporary(temporary, expectedDigest) {
+    const status = await lstat(temporary).catch(() => null);
+    if (!status)
+        return;
+    if (status.isSymbolicLink() || !status.isFile())
+        invalid("temporary_cleanup_collision");
+    const digest = sha256Hex(await readFile(temporary));
+    if (digest !== expectedDigest)
+        invalid("temporary_cleanup_identity_mismatch");
+    await unlink(temporary);
+}
+function invalid(reason) {
+    throw new Error(`design_resource_recovery_invalid:${reason}`);
+}

package/dist/lib/design-resource-recovery-final-disposition-shape.d.ts

@@ -0,0 +1,2 @@
+import type { DesignResourceFinalDisposition } from "./design-resource-recovery-types.js";
+export declare function parseDesignResourceFinalDisposition(value: unknown, label: string): DesignResourceFinalDisposition;

package/dist/lib/design-resource-recovery-final-disposition-shape.js

@@ -0,0 +1,47 @@
+import { digest, object, oneOf, stringSet, text, } from "./design-resource-recovery-codec-primitives.js";
+export function parseDesignResourceFinalDisposition(value, label) {
+    const first = object(value, label, ["kind"], ["operation_id", "resource_ref", "condition_refs", "downstream_owner"]);
+    const kind = oneOf(first.kind, [
+        "proposal-written",
+        "resource-owned-exact-visual",
+        "not-adopted",
+        "unresolved",
+    ], `${label}.kind`);
+    if (kind === "proposal-written") {
+        const row = object(value, label, ["kind", "operation_id"]);
+        return {
+            kind,
+            operation_id: text(row.operation_id, `${label}.operation_id`),
+        };
+    }
+    if (kind === "resource-owned-exact-visual") {
+        const row = object(value, label, [
+            "kind",
+            "resource_ref",
+            "condition_refs",
+            "downstream_owner",
+        ]);
+        return {
+            kind,
+            resource_ref: text(row.resource_ref, `${label}.resource_ref`),
+            condition_refs: stringSet(row.condition_refs, `${label}.condition_refs`),
+            downstream_owner: parseDownstreamOwner(row.downstream_owner, `${label}.downstream_owner`),
+        };
+    }
+    object(value, label, ["kind"]);
+    return { kind };
+}
+function parseDownstreamOwner(value, label) {
+    const row = object(value, label, [
+        "kind",
+        "locator",
+        "raw_byte_digest",
+        "resource_key",
+    ]);
+    return {
+        kind: oneOf(row.kind, ["selected-source-record", "external-immutable"], `${label}.kind`),
+        locator: text(row.locator, `${label}.locator`),
+        raw_byte_digest: digest(row.raw_byte_digest, `${label}.raw_byte_digest`),
+        resource_key: text(row.resource_key, `${label}.resource_key`),
+    };
+}

package/dist/lib/design-resource-recovery-patch-types.d.ts

@@ -0,0 +1,54 @@
+import { DESIGN_RESOURCE_PATCH_SCHEMA } from "./design-resource-recovery-schema.js";
+import type { DesignResourceEolPolicy, DesignResourceTextEncoding } from "./design-resource-recovery-types.js";
+export interface DesignResourceTextSemanticProjection {
+    semantic_path: string[];
+    start_offset: number;
+    end_offset: number;
+}
+export interface DesignResourcePatchSemanticBinding {
+    delta_id: string;
+    target_key: string;
+    before_semantics_sha256: string;
+    after_semantics_sha256: string;
+    before_text_projection: DesignResourceTextSemanticProjection | null;
+    after_text_projection: DesignResourceTextSemanticProjection | null;
+}
+export interface DesignResourcePatchSourceSpan {
+    coordinate_system: "utf16-code-unit-v1";
+    start_offset: number;
+    end_offset: number;
+    before_text_sha256: string;
+}
+export interface DesignResourceExactPatchOperation {
+    operation_id: string;
+    operation: "add" | "replace" | "remove";
+    target_key: string;
+    delta_id: string;
+    before_text: string;
+    after_text: string;
+    before_text_sha256: string;
+    after_text_sha256: string;
+    source_span: DesignResourcePatchSourceSpan;
+    semantic_binding: DesignResourcePatchSemanticBinding;
+    expected_occurrences: 1;
+}
+export interface DesignResourceExactPatch {
+    schema_version: typeof DESIGN_RESOURCE_PATCH_SCHEMA;
+    operations: DesignResourceExactPatchOperation[];
+}
+export interface DesignResourceWritebackInput {
+    target_locator: string;
+    pre_write_raw_byte_digest: string;
+    patch: DesignResourceExactPatch;
+    patch_identity: string;
+    expected_post_write_raw_byte_digest: string;
+    resource_identities: Array<{
+        key: string;
+        raw_byte_digest: string;
+    }>;
+    proposal_written_delta_ids: string[];
+}
+export interface DesignResourceRecoveryWriteback extends DesignResourceWritebackInput {
+    target_encoding: DesignResourceTextEncoding;
+    target_eol_policy: Exclude<DesignResourceEolPolicy, "mixed">;
+}

package/dist/lib/design-resource-recovery-patch-types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/design-resource-recovery-replay.d.ts

@@ -0,0 +1,7 @@
+import type { DesignResourceDelta, DesignResourceRecoveryCheckpoint, DesignResourceRecoveryCreateInput, DesignResourceReplayProjection } from "./design-resource-recovery-types.js";
+type RecoveryState = DesignResourceRecoveryCreateInput | DesignResourceRecoveryCheckpoint;
+export declare function validateDesignResourceRecoverySemantics(state: RecoveryState): void;
+export declare function createDesignResourceReplayProjection(checkpoint: DesignResourceRecoveryCheckpoint): DesignResourceReplayProjection;
+export declare function acceptedSupersededDeltaIds(deltas: DesignResourceDelta[]): Set<string>;
+export declare function activeAcceptedDesignResourceDeltas(deltas: DesignResourceDelta[], superseded?: Set<string>): DesignResourceDelta[];
+export {};

package/dist/lib/design-resource-recovery-replay.js

@@ -0,0 +1,112 @@
+import { indexDesignResourceAuthoritySources, indexDesignResourceDelegations, validateDesignResourceBaseMaterialization, } from "./design-resource-recovery-authority-policy.js";
+import { validateDesignResourceDeltas } from "./design-resource-recovery-delta-policy.js";
+import { validateDesignResourceRecoveryCatalog } from "./design-resource-recovery-catalog.js";
+import { validateRecoveryProviderAndWriteback } from "./design-resource-recovery-writeback-policy.js";
+export function validateDesignResourceRecoverySemantics(state) {
+    validateTopLevelUniqueness(state);
+    const scope = new Set(state.base.in_scope_keys);
+    const excluded = new Set(state.base.explicitly_excluded_keys);
+    assertDisjoint(scope, excluded, "base_scope_and_exclusions_overlap");
+    const authoritySources = indexDesignResourceAuthoritySources(state.authority_sources);
+    validateDesignResourceBaseMaterialization(state, authoritySources);
+    const delegations = indexDesignResourceDelegations(state.delegations, scope, authoritySources);
+    const { byId, superseded } = validateDesignResourceDeltas(state.deltas, scope, excluded, delegations, authoritySources);
+    assertDecisionSets(state, byId);
+    const activeAccepted = activeAcceptedDesignResourceDeltas(state.deltas, superseded);
+    validateActiveAcceptedTargetUniqueness(activeAccepted);
+    validateDesignResourceRecoveryCatalog(state, byId, activeAccepted, superseded, authoritySources);
+    if (state.selected_resource_bindings.length &&
+        !state.audit_expectations.resource_decisions.length)
+        invalid("resource_decision_universe_required");
+    validateRecoveryProviderAndWriteback(state, activeAccepted);
+}
+export function createDesignResourceReplayProjection(checkpoint) {
+    validateDesignResourceRecoverySemantics(checkpoint);
+    const superseded = acceptedSupersededDeltaIds(checkpoint.deltas);
+    const external = [
+        `provider-project:${checkpoint.provider.project.key}`,
+        `provider-run:${checkpoint.provider.run.key}`,
+        ...checkpoint.provider.resources.map((resource) => `provider-resource:${resource.key}`),
+    ];
+    if (checkpoint.design_authority.kind === "external-immutable")
+        external.push(`design-authority:${checkpoint.design_authority.locator}`);
+    return {
+        status: "replayable",
+        base: checkpoint.base,
+        ordered_active_accepted_deltas: activeAcceptedDesignResourceDeltas(checkpoint.deltas, superseded),
+        rejected_deltas: checkpoint.deltas.filter((delta) => delta.status === "rejected"),
+        unresolved_deltas: checkpoint.deltas.filter((delta) => delta.status === "unresolved"),
+        superseded_delta_ids: [...superseded].sort(compareText),
+        explicitly_unchanged_keys: checkpoint.audit_expectations.unchanged.map((row) => row.key),
+        design_authority: checkpoint.design_authority,
+        external_revalidation_required: external.sort(compareText),
+    };
+}
+export function acceptedSupersededDeltaIds(deltas) {
+    return new Set(deltas
+        .filter((delta) => delta.status === "accepted")
+        .flatMap((delta) => delta.supersedes));
+}
+export function activeAcceptedDesignResourceDeltas(deltas, superseded = acceptedSupersededDeltaIds(deltas)) {
+    return deltas.filter((delta) => delta.status === "accepted" && !superseded.has(delta.delta_id));
+}
+function assertDecisionSets(state, byId) {
+    const expected = {
+        accepted_delta_ids: state.deltas
+            .filter((delta) => delta.status === "accepted")
+            .map((delta) => delta.delta_id),
+        rejected_delta_ids: state.deltas
+            .filter((delta) => delta.status === "rejected")
+            .map((delta) => delta.delta_id),
+        unresolved_delta_ids: state.deltas
+            .filter((delta) => delta.status === "unresolved")
+            .map((delta) => delta.delta_id),
+    };
+    for (const [key, values] of Object.entries(state.decision_sets)) {
+        assertUnique(values, `decision_set_duplicate:${key}`);
+        for (const value of values)
+            if (!byId.has(value))
+                invalid(`decision_set_delta_missing:${key}:${value}`);
+        assertEqualSet(new Set(values), new Set(expected[key]), `decision_set_mismatch:${key}`);
+    }
+}
+function validateTopLevelUniqueness(state) {
+    assertUnique(state.base.in_scope_keys, "base_in_scope_duplicate");
+    assertUnique(state.base.explicitly_excluded_keys, "base_explicit_exclusion_duplicate");
+    assertUnique(state.provider.resources.map((resource) => resource.key), "provider_resource_key_duplicate");
+    assertUnique(state.provider.resources.map((resource) => resource.locator), "provider_resource_locator_duplicate");
+}
+function validateActiveAcceptedTargetUniqueness(activeAccepted) {
+    const owner = new Map();
+    for (const delta of activeAccepted)
+        for (const target of delta.target_keys) {
+            const prior = owner.get(target);
+            if (prior)
+                invalid(`active_accepted_target_collision:${target}:${prior},${delta.delta_id}`);
+            owner.set(target, delta.delta_id);
+        }
+}
+function assertUnique(values, code) {
+    if (new Set(values).size !== values.length)
+        invalid(code);
+}
+function assertSubset(candidate, owner, code) {
+    const outside = [...candidate].filter((value) => !owner.has(value));
+    if (outside.length)
+        invalid(`${code}:${outside.sort(compareText).join(",")}`);
+}
+function assertDisjoint(left, right, code) {
+    const overlap = [...left].filter((value) => right.has(value));
+    if (overlap.length)
+        invalid(`${code}:${overlap.sort(compareText).join(",")}`);
+}
+function assertEqualSet(left, right, code) {
+    if (left.size !== right.size || [...left].some((value) => !right.has(value)))
+        invalid(code);
+}
+function invalid(code) {
+    throw new Error(`design_resource_recovery_invalid:${code}`);
+}
+function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}

package/dist/lib/design-resource-recovery-repository-bindings.d.ts

@@ -0,0 +1,9 @@
+import type { DesignResourceRecoveryCheckpoint, DesignResourceRecoveryCreateInput } from "./design-resource-recovery-types.js";
+type RecoveryState = DesignResourceRecoveryCreateInput | DesignResourceRecoveryCheckpoint;
+export declare function validateSelectedResourceRepositoryBindings(repository: string, state: RecoveryState): Promise<{
+    external_revalidation_required: boolean;
+}>;
+export declare function validateReconciliationDownstreamOwners(repository: string, checkpoint: DesignResourceRecoveryCheckpoint): Promise<{
+    external_revalidation_required: boolean;
+}>;
+export {};

package/dist/lib/design-resource-recovery-repository-bindings.js

@@ -0,0 +1,49 @@
+import { readRecoveryRepositoryFile } from "./design-resource-recovery-files.js";
+export async function validateSelectedResourceRepositoryBindings(repository, state) {
+    let external = false;
+    for (const binding of state.selected_resource_bindings) {
+        if (binding.identity_kind === "external-immutable") {
+            external = true;
+            continue;
+        }
+        const snapshot = await readRecoveryRepositoryFile(repository, binding.locator, `design_resource_recovery_selected_resource_${binding.key}`);
+        assertDigest(`selected_resource:${binding.key}`, snapshot.raw_byte_digest, binding.raw_byte_digest);
+    }
+    return { external_revalidation_required: external };
+}
+export async function validateReconciliationDownstreamOwners(repository, checkpoint) {
+    const selected = new Map(checkpoint.selected_resource_bindings.map((row) => [row.key, row]));
+    const current = await validateSelectedResourceRepositoryBindings(repository, checkpoint);
+    for (const row of checkpoint.audit_expectations.resource_decisions)
+        for (const binding of row.bindings) {
+            const disposition = binding.final_disposition;
+            if (disposition.kind !== "resource-owned-exact-visual")
+                continue;
+            const selectedResource = selected.get(disposition.resource_ref);
+            if (!selectedResource)
+                invalid(`downstream_owner_resource_unselected:${binding.binding_id}`);
+            const owner = disposition.downstream_owner;
+            if (owner.resource_key !== disposition.resource_ref ||
+                owner.locator !== selectedResource.locator ||
+                owner.raw_byte_digest !== selectedResource.raw_byte_digest)
+                invalid(`selected_source_owner_identity_mismatch:${binding.binding_id}`);
+            if (selectedResource.identity_kind === "external-immutable") {
+                if (owner.kind !== "external-immutable")
+                    invalid(`external_owner_kind_mismatch:${binding.binding_id}`);
+                current.external_revalidation_required = true;
+                continue;
+            }
+            if (owner.kind !== "selected-source-record")
+                invalid(`selected_source_owner_kind_mismatch:${binding.binding_id}`);
+            const snapshot = await readRecoveryRepositoryFile(repository, owner.locator, `design_resource_recovery_downstream_owner_${binding.binding_id}`);
+            assertDigest(`downstream_owner:${binding.binding_id}`, snapshot.raw_byte_digest, owner.raw_byte_digest);
+        }
+    return current;
+}
+function assertDigest(label, actual, expected) {
+    if (actual !== expected)
+        invalid(`${label}_digest_mismatch:${expected}:${actual}`);
+}
+function invalid(reason) {
+    throw new Error(`design_resource_recovery_invalid:${reason}`);
+}

package/dist/lib/design-resource-recovery-schema.d.ts

@@ -0,0 +1,5 @@
+export declare const DESIGN_RESOURCE_RECOVERY_INPUT_SCHEMA: "design-resource-recovery-input-v4";
+export declare const DESIGN_RESOURCE_RECOVERY_SCHEMA: "design-resource-recovery-checkpoint-v4";
+export declare const DESIGN_RESOURCE_RECOVERY_AUDIT_SCHEMA: "design-resource-reconciliation-audit-v4";
+export declare const DESIGN_RESOURCE_PATCH_SCHEMA: "design-resource-exact-patch-v4";
+export declare const DESIGN_RESOURCE_AUTHORITY_PROJECTION_SCHEMA: "ty-dra-authority-v1";

package/dist/lib/design-resource-recovery-schema.js

@@ -0,0 +1,5 @@
+export const DESIGN_RESOURCE_RECOVERY_INPUT_SCHEMA = "design-resource-recovery-input-v4";
+export const DESIGN_RESOURCE_RECOVERY_SCHEMA = "design-resource-recovery-checkpoint-v4";
+export const DESIGN_RESOURCE_RECOVERY_AUDIT_SCHEMA = "design-resource-reconciliation-audit-v4";
+export const DESIGN_RESOURCE_PATCH_SCHEMA = "design-resource-exact-patch-v4";
+export const DESIGN_RESOURCE_AUTHORITY_PROJECTION_SCHEMA = "ty-dra-authority-v1";