project-tiny-context-harness 0.8.17 → 0.12.0

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

@@ -1,103 +0,0 @@
-import { indexDesignResourceSelectedResources, validateDesignResourceConditions, validateDesignResourceDecisionCatalog, } from "./design-resource-recovery-catalog-resources.js";
-export function validateDesignResourceRecoveryCatalog(state, deltasById, activeAccepted, superseded, authoritySources) {
-    const catalog = state.audit_expectations;
-    uniqueRows(catalog.changed.map((row) => row.key), "changed_key");
-    uniqueRows(catalog.unchanged.map((row) => row.key), "unchanged_key");
-    uniqueRows(catalog.resource_decisions.map((row) => row.key), "resource_decision_key");
-    uniqueRows(catalog.blast_radius.map((row) => row.key), "blast_radius_key");
-    uniqueRows(catalog.inactive_delta_leakage.map((row) => row.delta_id), "inactive_delta_id");
-    const selectedResources = indexDesignResourceSelectedResources(state);
-    const activeChangedByTarget = activeChangedTargetIndex(activeAccepted);
-    const changed = new Set(activeChangedByTarget.keys());
-    const unchanged = new Set(catalog.unchanged.map((row) => row.key));
-    assertExactSet(catalog.changed.map((row) => row.key), [...changed], "audit_expectation_changed_keys");
-    assertDisjoint(changed, unchanged, "changed_and_unchanged_overlap");
-    const scope = new Set(state.base.in_scope_keys);
-    assertSubset(unchanged, scope, "explicit_unchanged_outside_scope");
-    for (const delta of activeAccepted) {
-        if (delta.operation === "preserve")
-            assertSubset(new Set(delta.target_keys), unchanged, `preserve_delta_not_explicitly_unchanged:${delta.delta_id}`);
-    }
-    for (const delta of state.deltas)
-        assertSubset(new Set(delta.explicitly_unchanged_keys), unchanged, `delta_unchanged_not_declared:${delta.delta_id}`);
-    for (const row of catalog.changed) {
-        assertExactSet(row.delta_ids, activeChangedByTarget.get(row.key) ?? [], `audit_expectation_changed_delta_ids:${row.key}`);
-        validateDesignResourceConditions(row.resource_refs, row.condition_refs, selectedResources, `audit_expectation_changed:${row.key}`);
-    }
-    for (const row of catalog.unchanged) {
-        validateDesignResourceConditions(row.resource_refs, row.condition_refs, selectedResources, `audit_expectation_unchanged:${row.key}`);
-        requireNonEmpty(row.basis_source_refs, `unchanged_basis_empty:${row.key}`);
-        for (const sourceRef of row.basis_source_refs)
-            if (!authoritySources.has(sourceRef))
-                invalid(`unchanged_basis_source_unresolved:${row.key}:${sourceRef}`);
-    }
-    const blast = new Set(catalog.blast_radius.map((row) => row.key));
-    assertSubset(new Set(state.base.explicitly_excluded_keys), blast, "explicit_exclusions_missing_from_blast_universe");
-    validateInactiveCatalog(state, catalog.inactive_delta_leakage, superseded);
-    validateDesignResourceDecisionCatalog(catalog.resource_decisions, deltasById, activeChangedByTarget, superseded, selectedResources);
-    return { changed, unchanged, selectedResources };
-}
-function activeChangedTargetIndex(activeAccepted) {
-    const result = new Map();
-    for (const delta of activeAccepted) {
-        if (delta.operation === "preserve")
-            continue;
-        for (const target of delta.target_keys) {
-            const owners = result.get(target) ?? [];
-            owners.push(delta.delta_id);
-            result.set(target, owners);
-        }
-    }
-    for (const [target, owners] of result)
-        if (owners.length !== 1)
-            invalid(`active_accepted_target_collision:${target}:${owners.join(",")}`);
-    return result;
-}
-function validateInactiveCatalog(state, rows, superseded) {
-    const expected = new Map();
-    for (const delta of state.deltas) {
-        if (delta.status === "rejected")
-            expected.set(delta.delta_id, "rejected");
-        else if (delta.status === "unresolved")
-            expected.set(delta.delta_id, "unresolved");
-    }
-    for (const deltaId of superseded)
-        expected.set(deltaId, "superseded");
-    assertExactSet(rows.map((row) => row.delta_id), [...expected.keys()], "inactive_delta_expectation_ids");
-    for (const row of rows)
-        if (expected.get(row.delta_id) !== row.reason)
-            invalid(`inactive_delta_reason_mismatch:${row.delta_id}`);
-}
-function requireNonEmpty(values, code) {
-    if (!values.length)
-        invalid(code);
-}
-function uniqueRows(values, code) {
-    if (new Set(values).size !== values.length)
-        invalid(`duplicate:${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 assertExactSet(actual, expected, code) {
-    uniqueRows(actual, `${code}:actual`);
-    uniqueRows(expected, `${code}:expected`);
-    const left = [...actual].sort(compareText);
-    const right = [...expected].sort(compareText);
-    if (left.length !== right.length ||
-        left.some((value, index) => value !== right[index]))
-        invalid(code);
-}
-function compareText(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}
-function invalid(code) {
-    throw new Error(`design_resource_recovery_invalid:${code}`);
-}

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

@@ -1,2 +0,0 @@
-import { removeRecoveryCheckpointFile } from "./design-resource-recovery-files.js";
-export declare function removeDesignResourceRecoveryCheckpoint(repository: string, sessionId: string, expectedDigest: string): Promise<Awaited<ReturnType<typeof removeRecoveryCheckpointFile>>>;

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

@@ -1,11 +0,0 @@
-import { parseDesignResourceRecoveryCheckpoint } from "./design-resource-recovery-codec.js";
-import { readRecoveryCheckpointFile, removeRecoveryCheckpointFile, } from "./design-resource-recovery-files.js";
-import { validateDesignResourceRecoverySemantics } from "./design-resource-recovery-replay.js";
-export async function removeDesignResourceRecoveryCheckpoint(repository, sessionId, expectedDigest) {
-    const snapshot = await readRecoveryCheckpointFile(repository, sessionId);
-    const checkpoint = parseDesignResourceRecoveryCheckpoint(snapshot.bytes.toString("utf8"));
-    if (checkpoint.session_id !== sessionId)
-        throw new Error("design_resource_recovery_invalid:session_identity_mismatch");
-    validateDesignResourceRecoverySemantics(checkpoint);
-    return removeRecoveryCheckpointFile(repository, sessionId, expectedDigest);
-}

package/dist/lib/design-resource-recovery-codec-primitives.d.ts

@@ -1,19 +0,0 @@
-export declare function parseStrictJsonObject(content: string, label: string): Record<string, unknown>;
-export declare function object(value: unknown, label: string, required?: string[], optional?: string[]): Record<string, unknown>;
-export declare function text(value: unknown, label: string): string;
-export declare function multilineText(value: unknown, label: string, options?: {
-    allowEmpty?: boolean;
-}): string;
-export declare function digest(value: unknown, label: string): string;
-export declare function integer(value: unknown, label: string, minimum?: number): number;
-export declare function literal<T extends string | number | boolean>(value: unknown, expected: T, label: string): T;
-export declare function oneOf<const T extends readonly string[]>(value: unknown, allowed: T, label: string): T[number];
-export declare function stringSet(value: unknown, label: string, options?: {
-    allowEmpty?: boolean;
-}): string[];
-export declare function arrayOf<T>(value: unknown, label: string, parse: (item: unknown, label: string) => T, options?: {
-    allowEmpty?: boolean;
-}): T[];
-export declare function optionalArrayOf<T>(value: unknown, label: string, parse: (item: unknown, label: string) => T): T[];
-export declare function unknownSemantics(record: Record<string, unknown>, key: string, label: string): unknown;
-export declare function invalid(label: string, reason: string): Error;

package/dist/lib/design-resource-recovery-codec-primitives.js

@@ -1,92 +0,0 @@
-import { parseStrictYaml } from "./strict-codec.js";
-export function parseStrictJsonObject(content, label) {
-    try {
-        JSON.parse(content);
-    }
-    catch (error) {
-        throw invalid(label, `json:${message(error)}`);
-    }
-    return object(parseStrictYaml(content), label);
-}
-export function object(value, label, required = [], optional = []) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        throw invalid(label, "object_required");
-    const record = value;
-    const allowed = new Set([...required, ...optional]);
-    if (allowed.size)
-        for (const key of Object.keys(record))
-            if (!allowed.has(key))
-                throw invalid(label, `unknown_field:${key}`);
-    for (const key of required)
-        if (!Object.hasOwn(record, key))
-            throw invalid(label, `missing_field:${key}`);
-    return record;
-}
-export function text(value, label) {
-    if (typeof value !== "string" || !value.trim() || /[\0\r\n\t]/u.test(value))
-        throw invalid(label, "non_empty_single_line_string_required");
-    return value;
-}
-export function multilineText(value, label, options = {}) {
-    if (typeof value !== "string" ||
-        (!options.allowEmpty && !value.length) ||
-        value.includes("\0"))
-        throw invalid(label, options.allowEmpty ? "text_required" : "non_empty_text_required");
-    return value;
-}
-export function digest(value, label) {
-    const result = text(value, label);
-    if (!/^[0-9a-f]{64}$/u.test(result))
-        throw invalid(label, "sha256_required");
-    return result;
-}
-export function integer(value, label, minimum = 0) {
-    if (!Number.isSafeInteger(value) || value < minimum)
-        throw invalid(label, `integer_at_least_${minimum}_required`);
-    return value;
-}
-export function literal(value, expected, label) {
-    if (value !== expected)
-        throw invalid(label, `expected:${String(expected)}`);
-    return expected;
-}
-export function oneOf(value, allowed, label) {
-    const result = text(value, label);
-    if (!allowed.includes(result))
-        throw invalid(label, `unsupported:${result}`);
-    return result;
-}
-export function stringSet(value, label, options = {}) {
-    if (!Array.isArray(value))
-        throw invalid(label, "array_required");
-    const result = value.map((item, index) => text(item, `${label}[${index}]`));
-    if (!options.allowEmpty && !result.length)
-        throw invalid(label, "non_empty_array_required");
-    if (new Set(result).size !== result.length)
-        throw invalid(label, "duplicate_value");
-    return result.sort(compareText);
-}
-export function arrayOf(value, label, parse, options = {}) {
-    if (!Array.isArray(value))
-        throw invalid(label, "array_required");
-    if (!options.allowEmpty && !value.length)
-        throw invalid(label, "non_empty_array_required");
-    return value.map((item, index) => parse(item, `${label}[${index}]`));
-}
-export function optionalArrayOf(value, label, parse) {
-    return arrayOf(value, label, parse, { allowEmpty: true });
-}
-export function unknownSemantics(record, key, label) {
-    if (!Object.hasOwn(record, key))
-        throw invalid(label, `missing_field:${key}`);
-    return record[key];
-}
-export function invalid(label, reason) {
-    return new Error(`design_resource_recovery_invalid:${label}:${reason}`);
-}
-function message(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function compareText(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}

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

@@ -1,4 +0,0 @@
-import { type DesignResourceRecoveryCheckpoint, type DesignResourceRecoveryCreateInput } from "./design-resource-recovery-types.js";
-export declare function parseDesignResourceRecoveryCreateInput(content: string): DesignResourceRecoveryCreateInput;
-export declare function parseDesignResourceRecoveryCheckpoint(content: string): DesignResourceRecoveryCheckpoint;
-export declare function encodeDesignResourceRecoveryCheckpoint(checkpoint: DesignResourceRecoveryCheckpoint): string;

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

@@ -1,93 +0,0 @@
-import { parseAuditExpectations, parseSelectedResourceBinding, } from "./design-resource-recovery-catalog-shape.js";
-import { DESIGN_RESOURCE_RECOVERY_INPUT_SCHEMA, DESIGN_RESOURCE_RECOVERY_SCHEMA, } from "./design-resource-recovery-schema.js";
-import { literal, object, optionalArrayOf, parseStrictJsonObject, stringSet, text, } from "./design-resource-recovery-codec-primitives.js";
-import { parseAuthorityIdentity, parseAuthoritySourceItem, parseDelegation, parseDelta, parseRecoveryBase, parseRecoveryBaseInput, } from "./design-resource-recovery-shape.js";
-import { parseProviderReferences, parseWritebackInput, } from "./design-resource-recovery-writeback-shape.js";
-import { canonicalJson } from "./strict-codec.js";
-const COMMON_FIELDS = [
-    "session_id",
-    "disclosure_review",
-    "base",
-    "authority_sources",
-    "delegations",
-    "deltas",
-    "decision_sets",
-    "audit_expectations",
-    "design_authority",
-    "provider",
-    "selected_resource_bindings",
-];
-export function parseDesignResourceRecoveryCreateInput(content) {
-    const row = parseStrictJsonObject(content, "create_input");
-    const root = object(row, "create_input", ["schema_version", ...COMMON_FIELDS], ["writeback"]);
-    literal(root.schema_version, DESIGN_RESOURCE_RECOVERY_INPUT_SCHEMA, "create_input.schema_version");
-    return {
-        schema_version: DESIGN_RESOURCE_RECOVERY_INPUT_SCHEMA,
-        ...parseCommon(root, false),
-        ...(root.writeback === undefined
-            ? {}
-            : {
-                writeback: parseWritebackInput(root.writeback, "create_input.writeback", false),
-            }),
-    };
-}
-export function parseDesignResourceRecoveryCheckpoint(content) {
-    const row = parseStrictJsonObject(content, "checkpoint");
-    const root = object(row, "checkpoint", ["schema_version", "owner", ...COMMON_FIELDS], ["writeback"]);
-    literal(root.schema_version, DESIGN_RESOURCE_RECOVERY_SCHEMA, "checkpoint.schema_version");
-    literal(root.owner, "ty-context-design-resource-recovery", "checkpoint.owner");
-    return {
-        schema_version: DESIGN_RESOURCE_RECOVERY_SCHEMA,
-        owner: "ty-context-design-resource-recovery",
-        ...parseCommon(root, true),
-        ...(root.writeback === undefined
-            ? {}
-            : {
-                writeback: parseWritebackInput(root.writeback, "checkpoint.writeback", true),
-            }),
-    };
-}
-export function encodeDesignResourceRecoveryCheckpoint(checkpoint) {
-    return canonicalJson(checkpoint);
-}
-function parseCommon(root, complete) {
-    const disclosure = object(root.disclosure_review, "disclosure_review", [
-        "reviewed",
-        "contains_sensitive_raw_values",
-    ]);
-    literal(disclosure.reviewed, true, "disclosure_review.reviewed");
-    literal(disclosure.contains_sensitive_raw_values, false, "disclosure_review.contains_sensitive_raw_values");
-    const decisionSets = object(root.decision_sets, "decision_sets", [
-        "accepted_delta_ids",
-        "rejected_delta_ids",
-        "unresolved_delta_ids",
-    ]);
-    return {
-        session_id: parseSessionId(root.session_id),
-        disclosure_review: {
-            reviewed: true,
-            contains_sensitive_raw_values: false,
-        },
-        base: complete
-            ? parseRecoveryBase(root.base, "base")
-            : parseRecoveryBaseInput(root.base, "base"),
-        authority_sources: optionalArrayOf(root.authority_sources, "authority_sources", parseAuthoritySourceItem),
-        delegations: optionalArrayOf(root.delegations, "delegations", parseDelegation),
-        deltas: optionalArrayOf(root.deltas, "deltas", parseDelta),
-        decision_sets: {
-            accepted_delta_ids: stringSet(decisionSets.accepted_delta_ids, "decision_sets.accepted_delta_ids", { allowEmpty: true }),
-            rejected_delta_ids: stringSet(decisionSets.rejected_delta_ids, "decision_sets.rejected_delta_ids", { allowEmpty: true }),
-            unresolved_delta_ids: stringSet(decisionSets.unresolved_delta_ids, "decision_sets.unresolved_delta_ids", { allowEmpty: true }),
-        },
-        audit_expectations: parseAuditExpectations(root.audit_expectations, "audit_expectations"),
-        design_authority: parseAuthorityIdentity(root.design_authority, "design_authority"),
-        provider: parseProviderReferences(root.provider, "provider"),
-        selected_resource_bindings: optionalArrayOf(root.selected_resource_bindings, "selected_resource_bindings", parseSelectedResourceBinding),
-    };
-}
-function parseSessionId(value) {
-    const result = text(value, "session_id");
-    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u.test(result))
-        throw new Error("design_resource_recovery_invalid:session_id:unsafe");
-    return result;
-}

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

@@ -1,9 +0,0 @@
-import type { DesignResourceAuthorityIdentity, DesignResourceRecoveryCheckpoint } from "./design-resource-recovery-types.js";
-export declare function loadCurrentDesignResourceRecoveryCheckpoint(repository: string, sessionId: string, options?: {
-    validateSelectedResources?: boolean;
-}): Promise<{
-    checkpoint: DesignResourceRecoveryCheckpoint;
-    path: string;
-    digest: string;
-}>;
-export declare function validateDesignResourceRepositoryAuthority(repository: string, authority: DesignResourceAuthorityIdentity): Promise<void>;

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

@@ -1,41 +0,0 @@
-import { readRecoveryCheckpointFile, readRecoveryRepositoryFile, } from "./design-resource-recovery-files.js";
-import { parseDesignResourceRecoveryCheckpoint } from "./design-resource-recovery-codec.js";
-import { validateDesignResourceRecoverySemantics } from "./design-resource-recovery-replay.js";
-import { decodeDesignResourceText } from "./design-resource-recovery-text.js";
-import { validateDesignResourceAuthoritySourceItems } from "./design-resource-recovery-source-authority.js";
-import { validateSelectedResourceRepositoryBindings } from "./design-resource-recovery-repository-bindings.js";
-export async function loadCurrentDesignResourceRecoveryCheckpoint(repository, sessionId, options = {}) {
-    const snapshot = await readRecoveryCheckpointFile(repository, sessionId);
-    const checkpoint = parseDesignResourceRecoveryCheckpoint(snapshot.bytes.toString("utf8"));
-    if (checkpoint.session_id !== sessionId)
-        invalid("session_identity_mismatch");
-    validateDesignResourceRecoverySemantics(checkpoint);
-    const base = await readRecoveryRepositoryFile(repository, checkpoint.base.locator, "design_resource_recovery_base");
-    assertDigest("base", base.raw_byte_digest, checkpoint.base.raw_byte_digest);
-    const decoded = decodeDesignResourceText(base.bytes);
-    if (decoded.encoding !== checkpoint.base.encoding ||
-        decoded.eol_policy !== checkpoint.base.eol_policy)
-        invalid("base_text_identity_changed");
-    await validateDesignResourceRepositoryAuthority(repository, checkpoint.design_authority);
-    await validateDesignResourceAuthoritySourceItems(repository, checkpoint);
-    if (options.validateSelectedResources !== false)
-        await validateSelectedResourceRepositoryBindings(repository, checkpoint);
-    return {
-        checkpoint,
-        path: snapshot.relative,
-        digest: snapshot.raw_byte_digest,
-    };
-}
-export async function validateDesignResourceRepositoryAuthority(repository, authority) {
-    if (authority.kind !== "repository-file")
-        return;
-    const snapshot = await readRecoveryRepositoryFile(repository, authority.locator, "design_resource_recovery_design_authority");
-    assertDigest("design_authority", snapshot.raw_byte_digest, authority.raw_byte_digest);
-}
-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-delta-policy.d.ts

@@ -1,5 +0,0 @@
-import type { DesignResourceAuthoritySourceItem, DesignResourceDelegation, DesignResourceDelta } from "./design-resource-recovery-types.js";
-export declare function validateDesignResourceDeltas(deltas: DesignResourceDelta[], scope: Set<string>, excluded: Set<string>, delegations: Map<string, DesignResourceDelegation>, authoritySources: Map<string, DesignResourceAuthoritySourceItem>): {
-    byId: Map<string, DesignResourceDelta>;
-    superseded: Set<string>;
-};

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

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

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