project-tiny-context-harness 0.8.12 → 0.8.13

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

@@ -0,0 +1,121 @@
+export function indexDesignResourceSelectedResources(state) {
+    uniqueRows(state.selected_resource_bindings.map((row) => row.key), "selected_resource_key");
+    uniqueRows(state.selected_resource_bindings.map((row) => row.locator), "selected_resource_locator");
+    const provider = new Map(state.provider.resources.map((row) => [row.key, row]));
+    const result = new Map();
+    for (const row of state.selected_resource_bindings) {
+        requireNonEmpty(row.condition_refs, `selected_resource_conditions:${row.key}`);
+        uniqueRows(row.condition_refs, `selected_resource_condition:${row.key}`);
+        const declared = provider.get(row.key);
+        if (!declared)
+            invalid(`selected_resource_not_declared:${row.key}`);
+        if (declared.raw_byte_digest !== row.raw_byte_digest)
+            invalid(`selected_resource_digest_mismatch:${row.key}`);
+        result.set(row.key, row);
+    }
+    return result;
+}
+export function validateDesignResourceDecisionCatalog(rows, deltasById, activeChangedByTarget, superseded, selectedResources) {
+    const bindingIds = [];
+    const bindingTuples = [];
+    const activeOwnerTuples = [];
+    for (const row of rows) {
+        validateDesignResourceConditions([row.resource_ref], row.condition_refs, selectedResources, `resource_decision_expectation:${row.key}`);
+        uniqueRows(row.bindings.map((binding) => binding.binding_id), `resource_decision_binding_id:${row.key}`);
+        for (const binding of row.bindings) {
+            bindingIds.push(binding.binding_id);
+            bindingTuples.push(resourceBindingIdentity(row.resource_ref, binding.target_key, binding.delta_id));
+            const delta = deltasById.get(binding.delta_id);
+            if (!delta)
+                invalid(`resource_decision_delta_unknown:${row.key}:${binding.delta_id}`);
+            if (!delta.target_keys.includes(binding.target_key))
+                invalid(`resource_decision_target_mismatch:${row.key}:${binding.target_key}:${binding.delta_id}`);
+            if (delta.semantic_kind !== row.semantic_kind)
+                invalid(`resource_decision_semantic_kind_mismatch:${row.key}:${binding.delta_id}`);
+            const isActiveChanged = delta.status === "accepted" &&
+                !superseded.has(delta.delta_id) &&
+                delta.operation !== "preserve";
+            validateFrozenDisposition(row, binding, delta, isActiveChanged, selectedResources);
+            if (isActiveChanged)
+                activeOwnerTuples.push(deltaTarget(binding));
+        }
+    }
+    uniqueRows(bindingIds, "resource_decision_binding_id_global");
+    uniqueRows(bindingTuples, "resource_decision_binding_tuple_global");
+    const expectedActive = [...activeChangedByTarget].flatMap(([target, deltaIds]) => deltaIds.map((deltaId) => `${deltaId}\u0000${target}`));
+    assertExactSet(activeOwnerTuples, expectedActive, "resource_decision_active_owner_universe");
+}
+export function validateDesignResourceConditions(resourceRefs, conditionRefs, selected, label) {
+    requireNonEmpty(resourceRefs, `${label}:resource_refs_empty`);
+    requireNonEmpty(conditionRefs, `${label}:condition_refs_empty`);
+    uniqueRows(resourceRefs, `${label}:resource_ref`);
+    uniqueRows(conditionRefs, `${label}:condition_ref`);
+    for (const resourceRef of resourceRefs) {
+        const resource = selected.get(resourceRef);
+        if (!resource)
+            invalid(`${label}:resource_unselected:${resourceRef}`);
+        for (const condition of conditionRefs)
+            if (!resource.condition_refs.includes(condition))
+                invalid(`${label}:condition_undeclared:${resourceRef}:${condition}`);
+    }
+}
+function validateFrozenDisposition(row, binding, delta, isActiveChanged, selectedResources) {
+    const disposition = binding.final_disposition;
+    if (!isActiveChanged) {
+        const required = delta.status === "unresolved" ? "unresolved" : "not-adopted";
+        if (disposition.kind !== required)
+            invalid(`resource_decision_inactive_disposition:${row.key}:${binding.binding_id}:${required}`);
+        return;
+    }
+    if (disposition.kind === "proposal-written")
+        return;
+    if (disposition.kind !== "resource-owned-exact-visual")
+        invalid(`resource_decision_active_disposition:${row.key}:${binding.binding_id}`);
+    if (delta.semantic_kind !== "exact-visual")
+        invalid(`resource_decision_nonvisual_resource_owner:${row.key}`);
+    if (disposition.resource_ref !== row.resource_ref)
+        invalid(`resource_decision_owner_resource:${binding.binding_id}`);
+    assertExactSet(disposition.condition_refs, row.condition_refs, `resource_decision_owner_conditions:${binding.binding_id}`);
+    const selected = selectedResources.get(disposition.resource_ref);
+    if (!selected)
+        invalid(`resource_decision_owner_unselected:${binding.binding_id}`);
+    const owner = disposition.downstream_owner;
+    if (owner.resource_key !== disposition.resource_ref ||
+        owner.locator !== selected.locator ||
+        owner.raw_byte_digest !== selected.raw_byte_digest)
+        invalid(`resource_decision_owner_identity:${binding.binding_id}`);
+    const requiredOwnerKind = selected.identity_kind === "repository-snapshot"
+        ? "selected-source-record"
+        : "external-immutable";
+    if (owner.kind !== requiredOwnerKind)
+        invalid(`resource_decision_owner_kind:${binding.binding_id}`);
+}
+function deltaTarget(binding) {
+    return `${binding.delta_id}\u0000${binding.target_key}`;
+}
+function resourceBindingIdentity(resourceRef, targetKey, deltaId) {
+    return `${resourceRef}\u0000${targetKey}\u0000${deltaId}`;
+}
+function requireNonEmpty(values, code) {
+    if (!values.length)
+        invalid(code);
+}
+function uniqueRows(values, code) {
+    if (new Set(values).size !== values.length)
+        invalid(`duplicate:${code}`);
+}
+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-catalog-shape.d.ts

@@ -0,0 +1,3 @@
+import type { DesignResourceAuditExpectations, DesignResourceSelectedResourceBinding } from "./design-resource-recovery-types.js";
+export declare function parseAuditExpectations(value: unknown, label: string): DesignResourceAuditExpectations;
+export declare function parseSelectedResourceBinding(value: unknown, label: string): DesignResourceSelectedResourceBinding;

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

@@ -0,0 +1,104 @@
+import { arrayOf, digest, object, oneOf, optionalArrayOf, stringSet, text, } from "./design-resource-recovery-codec-primitives.js";
+import { DESIGN_RESOURCE_SEMANTIC_KINDS } from "./design-resource-recovery-shape.js";
+import { parseDesignResourceFinalDisposition } from "./design-resource-recovery-final-disposition-shape.js";
+export function parseAuditExpectations(value, label) {
+    const row = object(value, label, [
+        "changed",
+        "unchanged",
+        "resource_decisions",
+        "blast_radius",
+        "inactive_delta_leakage",
+    ]);
+    return {
+        changed: optionalArrayOf(row.changed, `${label}.changed`, parseChanged),
+        unchanged: optionalArrayOf(row.unchanged, `${label}.unchanged`, parseUnchanged),
+        resource_decisions: optionalArrayOf(row.resource_decisions, `${label}.resource_decisions`, parseResourceDecision),
+        blast_radius: optionalArrayOf(row.blast_radius, `${label}.blast_radius`, parseKeyRow),
+        inactive_delta_leakage: optionalArrayOf(row.inactive_delta_leakage, `${label}.inactive_delta_leakage`, parseInactiveDelta),
+    };
+}
+export function parseSelectedResourceBinding(value, label) {
+    const row = object(value, label, [
+        "key",
+        "identity_kind",
+        "locator",
+        "raw_byte_digest",
+        "condition_refs",
+    ]);
+    return {
+        key: text(row.key, `${label}.key`),
+        identity_kind: oneOf(row.identity_kind, ["repository-snapshot", "external-immutable"], `${label}.identity_kind`),
+        locator: text(row.locator, `${label}.locator`),
+        raw_byte_digest: digest(row.raw_byte_digest, `${label}.raw_byte_digest`),
+        condition_refs: stringSet(row.condition_refs, `${label}.condition_refs`),
+    };
+}
+function parseChanged(value, label) {
+    const row = object(value, label, [
+        "key",
+        "delta_ids",
+        "resource_refs",
+        "condition_refs",
+    ]);
+    return {
+        key: text(row.key, `${label}.key`),
+        delta_ids: stringSet(row.delta_ids, `${label}.delta_ids`),
+        resource_refs: stringSet(row.resource_refs, `${label}.resource_refs`),
+        condition_refs: stringSet(row.condition_refs, `${label}.condition_refs`),
+    };
+}
+function parseUnchanged(value, label) {
+    const row = object(value, label, [
+        "key",
+        "resource_refs",
+        "condition_refs",
+        "basis_source_refs",
+    ]);
+    return {
+        key: text(row.key, `${label}.key`),
+        resource_refs: stringSet(row.resource_refs, `${label}.resource_refs`),
+        condition_refs: stringSet(row.condition_refs, `${label}.condition_refs`),
+        basis_source_refs: stringSet(row.basis_source_refs, `${label}.basis_source_refs`),
+    };
+}
+function parseResourceDecision(value, label) {
+    const row = object(value, label, [
+        "key",
+        "resource_ref",
+        "semantic_kind",
+        "bindings",
+        "condition_refs",
+    ]);
+    return {
+        key: text(row.key, `${label}.key`),
+        resource_ref: text(row.resource_ref, `${label}.resource_ref`),
+        semantic_kind: oneOf(row.semantic_kind, DESIGN_RESOURCE_SEMANTIC_KINDS, `${label}.semantic_kind`),
+        bindings: arrayOf(row.bindings, `${label}.bindings`, parseBinding),
+        condition_refs: stringSet(row.condition_refs, `${label}.condition_refs`),
+    };
+}
+function parseBinding(value, label) {
+    const row = object(value, label, [
+        "binding_id",
+        "delta_id",
+        "target_key",
+        "final_disposition",
+    ]);
+    return {
+        binding_id: text(row.binding_id, `${label}.binding_id`),
+        delta_id: text(row.delta_id, `${label}.delta_id`),
+        target_key: text(row.target_key, `${label}.target_key`),
+        final_disposition: parseDesignResourceFinalDisposition(row.final_disposition, `${label}.final_disposition`),
+    };
+}
+function parseKeyRow(value, label) {
+    const row = object(value, label, ["key"]);
+    return { key: text(row.key, `${label}.key`) };
+}
+function parseInactiveDelta(value, label) {
+    const row = object(value, label, ["delta_id", "reason"]);
+    return {
+        delta_id: text(row.delta_id, `${label}.delta_id`),
+        reason: oneOf(row.reason, ["rejected", "unresolved", "superseded"], `${label}.reason`),
+    };
+}

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

@@ -0,0 +1,9 @@
+import type { DesignResourceAuthoritySourceItem, DesignResourceDelta, DesignResourceRecoveryCheckpoint, DesignResourceRecoveryCreateInput, DesignResourceSelectedResourceBinding } from "./design-resource-recovery-types.js";
+type RecoveryState = DesignResourceRecoveryCreateInput | DesignResourceRecoveryCheckpoint;
+export interface ValidatedRecoveryCatalog {
+    changed: Set<string>;
+    unchanged: Set<string>;
+    selectedResources: Map<string, DesignResourceSelectedResourceBinding>;
+}
+export declare function validateDesignResourceRecoveryCatalog(state: RecoveryState, deltasById: Map<string, DesignResourceDelta>, activeAccepted: DesignResourceDelta[], superseded: Set<string>, authoritySources: Map<string, DesignResourceAuthoritySourceItem>): ValidatedRecoveryCatalog;
+export {};

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,5 @@
+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>;
+};