project-tiny-context-harness 0.11.0 → 0.12.0

package/dist/lib/design-resource-reconciliation.js

@@ -1,224 +0,0 @@
-import { acceptedSupersededDeltaIds, activeAcceptedDesignResourceDeltas, validateDesignResourceRecoverySemantics, } from "./design-resource-recovery-replay.js";
-import { canonicalValueJson } from "./strict-codec.js";
-export function reconcileDesignResourceWriteback(checkpoint, audit) {
-    validateDesignResourceRecoverySemantics(checkpoint);
-    const findings = [];
-    compareValue(findings, "session_identity", audit.session_id, checkpoint.session_id);
-    compareValue(findings, "base_identity", audit.base_raw_byte_digest, checkpoint.base.raw_byte_digest);
-    compareValue(findings, "design_authority_identity", canonicalValueJson(audit.design_authority), canonicalValueJson(checkpoint.design_authority));
-    compareValue(findings, "provider_run_identity", canonicalValueJson(audit.provider_run), canonicalValueJson(checkpoint.provider.run));
-    if (checkpoint.writeback) {
-        if (!audit.writeback_target_raw_byte_digest)
-            findings.push("missing:writeback_target_identity");
-        else
-            compareValue(findings, "writeback_target_identity", audit.writeback_target_raw_byte_digest, checkpoint.writeback.expected_post_write_raw_byte_digest);
-    }
-    else if (audit.writeback_target_raw_byte_digest)
-        findings.push("unexpected:writeback_target_identity");
-    compareIdentityRows(findings, "resource_identity", audit.resource_identities, checkpoint.selected_resource_bindings.map((row) => ({
-        key: row.key,
-        raw_byte_digest: row.raw_byte_digest,
-    })));
-    const superseded = acceptedSupersededDeltaIds(checkpoint.deltas);
-    const activeAccepted = activeAcceptedDesignResourceDeltas(checkpoint.deltas, superseded);
-    const changed = checkpoint.audit_expectations.changed.map((row) => row.key);
-    compareExactSet(findings, "accepted_delta_ids", audit.accepted_delta_ids, activeAccepted.map((delta) => delta.delta_id));
-    compareExactSet(findings, "rejected_delta_ids", audit.rejected_delta_ids, checkpoint.decision_sets.rejected_delta_ids);
-    compareExactSet(findings, "unresolved_delta_ids", audit.unresolved_delta_ids, checkpoint.decision_sets.unresolved_delta_ids);
-    compareExactSet(findings, "changed_keys", audit.changed_keys, changed);
-    validateUnchanged(checkpoint, audit, findings);
-    validateRequirements(checkpoint, audit, findings);
-    validateResourceDecisions(checkpoint, audit, activeAccepted, superseded, findings);
-    validateBlastAndLeakage(checkpoint, audit, findings);
-    findings.sort(compareText);
-    return {
-        status: findings.length ? "blocked" : "reconciliation-balanced",
-        findings,
-    };
-}
-function validateUnchanged(checkpoint, audit, findings) {
-    uniqueRows(audit.explicitly_unchanged.map((row) => row.key), "unchanged");
-    const expected = checkpoint.audit_expectations.unchanged;
-    compareExactSet(findings, "explicitly_unchanged_keys", audit.explicitly_unchanged.map((row) => row.key), expected.map((row) => row.key));
-    const expectedByKey = new Map(expected.map((row) => [row.key, row]));
-    for (const row of audit.explicitly_unchanged) {
-        if (row.verdict !== "preserved")
-            findings.push(`unchanged_${row.verdict}:${row.key}`);
-        const frozen = expectedByKey.get(row.key);
-        if (!frozen)
-            continue;
-        compareExactSet(findings, `unchanged_resources:${row.key}`, row.resource_refs, frozen.resource_refs);
-        compareExactSet(findings, `unchanged_conditions:${row.key}`, row.condition_refs, frozen.condition_refs);
-        compareExactSet(findings, `unchanged_basis_sources:${row.key}`, row.basis_source_refs, frozen.basis_source_refs);
-    }
-}
-function validateRequirements(checkpoint, audit, findings) {
-    uniqueRows(audit.requirements_to_resource.map((row) => row.key), "requirements_to_resource");
-    const expected = checkpoint.audit_expectations.changed;
-    compareExactSet(findings, "requirements_to_resource_keys", audit.requirements_to_resource.map((row) => row.key), expected.map((row) => row.key));
-    const expectedByKey = new Map(expected.map((row) => [row.key, row]));
-    for (const row of audit.requirements_to_resource) {
-        if (row.verdict !== "covered")
-            findings.push(`requirement_${row.verdict}:${row.key}`);
-        const frozen = expectedByKey.get(row.key);
-        if (!frozen)
-            continue;
-        compareExactSet(findings, `requirement_delta_ids:${row.key}`, row.delta_ids, frozen.delta_ids);
-        compareExactSet(findings, `requirement_resources:${row.key}`, row.resource_refs, frozen.resource_refs);
-        compareExactSet(findings, `requirement_conditions:${row.key}`, row.condition_refs, frozen.condition_refs);
-    }
-}
-function validateResourceDecisions(checkpoint, audit, activeAccepted, superseded, findings) {
-    uniqueRows(audit.resource_to_requirements.map((row) => row.key), "resource_to_requirements");
-    const expected = checkpoint.audit_expectations.resource_decisions;
-    compareExactSet(findings, "resource_decision_keys", audit.resource_to_requirements.map((row) => row.key), expected.map((row) => row.key));
-    const expectedByKey = new Map(expected.map((row) => [row.key, row]));
-    const allDeltas = new Map(checkpoint.deltas.map((delta) => [delta.delta_id, delta]));
-    const activeIds = new Set(activeAccepted.map((delta) => delta.delta_id));
-    const globalBindingIds = [];
-    const globalBindingTuples = [];
-    const finalOwnerTuples = [];
-    for (const row of audit.resource_to_requirements) {
-        for (const binding of row.requirement_bindings) {
-            globalBindingIds.push(binding.binding_id);
-            globalBindingTuples.push(resourceBindingIdentity(row.resource_ref, binding.requirement_key, binding.delta_id));
-        }
-        const frozen = expectedByKey.get(row.key);
-        if (!frozen)
-            continue;
-        compareValue(findings, `resource_decision_resource:${row.key}`, row.resource_ref, frozen.resource_ref);
-        compareValue(findings, `resource_decision_semantic_kind:${row.key}`, row.semantic_kind, frozen.semantic_kind);
-        compareExactSet(findings, `resource_decision_conditions:${row.key}`, row.condition_refs, frozen.condition_refs);
-        compareExactSet(findings, `resource_decision_delta_ids:${row.key}`, row.delta_ids, frozen.bindings.map((binding) => binding.delta_id));
-        uniqueRows(row.requirement_bindings.map((binding) => binding.binding_id), `resource_requirement_binding_ids:${row.key}`);
-        compareExactSet(findings, `resource_decision_binding_ids:${row.key}`, row.requirement_bindings.map((binding) => binding.binding_id), frozen.bindings.map((binding) => binding.binding_id));
-        const frozenBindings = new Map(frozen.bindings.map((binding) => [binding.binding_id, binding]));
-        for (const binding of row.requirement_bindings) {
-            const expectedBinding = frozenBindings.get(binding.binding_id);
-            if (!expectedBinding)
-                continue;
-            compareValue(findings, `resource_binding_target:${binding.binding_id}`, binding.requirement_key, expectedBinding.target_key);
-            compareValue(findings, `resource_binding_delta:${binding.binding_id}`, binding.delta_id, expectedBinding.delta_id);
-            const delta = allDeltas.get(binding.delta_id);
-            if (!delta) {
-                findings.push(`resource_decision_delta_unknown:${binding.binding_id}`);
-                continue;
-            }
-            compareValue(findings, `resource_decision_status:${binding.binding_id}`, row.status, delta.status);
-            if (!delta.target_keys.includes(binding.requirement_key))
-                findings.push(`resource_decision_target_mismatch:${binding.binding_id}`);
-            compareValue(findings, `resource_binding_semantic_kind:${binding.binding_id}`, row.semantic_kind, delta.semantic_kind);
-            compareValue(findings, `resource_decision_origin:${binding.binding_id}`, binding.origin, delta.origin);
-            compareValue(findings, `resource_decision_authority:${binding.binding_id}`, binding.decision_authority, delta.decision_authority);
-            compareExactSet(findings, `resource_decision_sources:${binding.binding_id}`, binding.source_refs, delta.source_refs);
-            validateFinalDisposition(checkpoint, row, binding, delta, expectedBinding.final_disposition, activeIds, superseded, findings);
-            if (delta.status === "accepted" &&
-                activeIds.has(delta.delta_id) &&
-                delta.operation !== "preserve")
-                finalOwnerTuples.push(deltaTarget(delta.delta_id, binding.requirement_key));
-        }
-    }
-    uniqueRows(globalBindingIds, "resource_binding_id_global");
-    uniqueRows(globalBindingTuples, "resource_binding_tuple_global");
-    uniqueRows(finalOwnerTuples, "final_owner_tuple_global");
-    const expectedOwners = activeAccepted.flatMap((delta) => delta.operation === "preserve"
-        ? []
-        : delta.target_keys.map((target) => deltaTarget(delta.delta_id, target)));
-    compareExactSet(findings, "active_delta_final_owners", finalOwnerTuples, expectedOwners);
-}
-function validateFinalDisposition(checkpoint, row, binding, delta, frozen, activeIds, superseded, findings) {
-    const disposition = binding.final_disposition;
-    compareValue(findings, `resource_decision_frozen_disposition:${binding.binding_id}`, canonicalValueJson(disposition), canonicalValueJson(frozen));
-    const active = activeIds.has(delta.delta_id) && !superseded.has(delta.delta_id);
-    if (delta.status === "rejected" || (delta.status === "accepted" && !active)) {
-        if (disposition.kind !== "not-adopted")
-            findings.push(`resource_decision_inactive_owner:${binding.binding_id}`);
-        return;
-    }
-    if (delta.status === "unresolved") {
-        findings.push(`resource_decision_unresolved:${row.key}`);
-        if (disposition.kind !== "unresolved")
-            findings.push(`resource_decision_unresolved_owner:${binding.binding_id}`);
-        return;
-    }
-    if (delta.operation === "preserve") {
-        findings.push(`resource_decision_preserve_owner_forbidden:${binding.binding_id}`);
-        return;
-    }
-    if (disposition.kind === "proposal-written") {
-        const operation = checkpoint.writeback?.patch.operations.find((candidate) => candidate.operation_id === disposition.operation_id);
-        if (!operation)
-            findings.push(`proposal_owner_operation_missing:${binding.binding_id}`);
-        else if (operation.semantic_binding.delta_id !== delta.delta_id ||
-            operation.semantic_binding.target_key !== binding.requirement_key)
-            findings.push(`proposal_owner_operation_binding_mismatch:${binding.binding_id}`);
-        return;
-    }
-    if (disposition.kind !== "resource-owned-exact-visual") {
-        findings.push(`resource_decision_accepted_owner_missing:${binding.binding_id}`);
-        return;
-    }
-    if (delta.semantic_kind !== "exact-visual")
-        findings.push(`resource_owner_nonvisual_meaning:${binding.binding_id}`);
-    if (disposition.resource_ref !== row.resource_ref)
-        findings.push(`resource_owner_identity_mismatch:${binding.binding_id}`);
-    compareExactSet(findings, `resource_owner_conditions:${binding.binding_id}`, disposition.condition_refs, row.condition_refs);
-    const owner = disposition.downstream_owner;
-    if (owner.resource_key !== disposition.resource_ref)
-        findings.push(`resource_owner_record_mismatch:${binding.binding_id}`);
-}
-function validateBlastAndLeakage(checkpoint, audit, findings) {
-    uniqueRows(audit.unexpected_blast_radius.map((row) => row.key), "unexpected_blast_radius");
-    compareExactSet(findings, "unexpected_blast_radius_keys", audit.unexpected_blast_radius.map((row) => row.key), checkpoint.audit_expectations.blast_radius.map((row) => row.key));
-    for (const row of audit.unexpected_blast_radius)
-        if (row.verdict !== "expected")
-            findings.push(`${row.verdict}_blast_radius:${row.key}`);
-    uniqueRows(audit.inactive_delta_leakage.map((row) => row.delta_id), "inactive_delta_leakage");
-    const expected = checkpoint.audit_expectations.inactive_delta_leakage;
-    compareExactSet(findings, "inactive_delta_leakage_ids", audit.inactive_delta_leakage.map((row) => row.delta_id), expected.map((row) => row.delta_id));
-    const expectedById = new Map(expected.map((row) => [row.delta_id, row]));
-    const active = new Set(activeAcceptedDesignResourceDeltas(checkpoint.deltas).map((delta) => delta.delta_id));
-    for (const row of audit.inactive_delta_leakage) {
-        const frozen = expectedById.get(row.delta_id);
-        if (frozen)
-            compareValue(findings, `inactive_delta_reason:${row.delta_id}`, row.inactive_reason, frozen.reason);
-        if (active.has(row.delta_id))
-            findings.push(`active_delta_in_inactive_universe:${row.delta_id}`);
-        if (row.leaked)
-            findings.push(`decision_leaked:${row.delta_id}`);
-    }
-}
-function compareIdentityRows(findings, label, actual, expected) {
-    uniqueRows(actual.map((row) => row.key), `${label}:actual`);
-    uniqueRows(expected.map((row) => row.key), `${label}:expected`);
-    compareExactSet(findings, `${label}_keys`, actual.map((row) => row.key), expected.map((row) => row.key));
-    const expectedByKey = new Map(expected.map((row) => [row.key, row]));
-    for (const row of actual)
-        compareValue(findings, `${label}:${row.key}`, row.raw_byte_digest, expectedByKey.get(row.key)?.raw_byte_digest ?? "missing");
-}
-function compareExactSet(findings, label, actual, expected) {
-    uniqueRows(actual, `${label}:actual`);
-    uniqueRows(expected, `${label}:expected`);
-    const left = [...actual].sort(compareText);
-    const right = [...expected].sort(compareText);
-    if (left.length !== right.length ||
-        left.some((value, index) => value !== right[index]))
-        findings.push(`set_mismatch:${label}`);
-}
-function compareValue(findings, label, actual, expected) {
-    if (actual !== expected)
-        findings.push(`identity_mismatch:${label}`);
-}
-function uniqueRows(values, label) {
-    if (new Set(values).size !== values.length)
-        throw new Error(`design_resource_recovery_invalid:audit_duplicate:${label}`);
-}
-function resourceBindingIdentity(resourceRef, requirementKey, deltaId) {
-    return `${resourceRef}\u0000${requirementKey}\u0000${deltaId}`;
-}
-function deltaTarget(deltaId, targetKey) {
-    return `${deltaId}\u0000${targetKey}`;
-}
-function compareText(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}

package/dist/lib/design-resource-recovery-authority-policy.d.ts

@@ -1,8 +0,0 @@
-import type { DesignResourceAuthoritySourceItem, DesignResourceDelegation, DesignResourceDelta, DesignResourceRecoveryCheckpoint, DesignResourceRecoveryCreateInput } from "./design-resource-recovery-types.js";
-export declare function isDesignResourceAuthoritativeMeaningSourceKind(kind: string): boolean;
-type RecoveryState = DesignResourceRecoveryCreateInput | DesignResourceRecoveryCheckpoint;
-export declare function validateDesignResourceDeltaAuthority(delta: DesignResourceDelta, delegations: Map<string, DesignResourceDelegation>, authoritySources: Map<string, DesignResourceAuthoritySourceItem>): void;
-export declare function indexDesignResourceDelegations(values: DesignResourceDelegation[], scope: Set<string>, authoritySources: Map<string, DesignResourceAuthoritySourceItem>): Map<string, DesignResourceDelegation>;
-export declare function indexDesignResourceAuthoritySources(values: DesignResourceAuthoritySourceItem[]): Map<string, DesignResourceAuthoritySourceItem>;
-export declare function validateDesignResourceBaseMaterialization(state: RecoveryState, authoritySources: Map<string, DesignResourceAuthoritySourceItem>): void;
-export {};

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

@@ -1,123 +0,0 @@
-const AUTHORITATIVE_MEANING_SOURCE_KINDS = new Set([
-    "outcome_result",
-    "requirement",
-    "control",
-    "acceptance",
-    "technical_obligation",
-    "risk_fact",
-]);
-export function isDesignResourceAuthoritativeMeaningSourceKind(kind) {
-    return AUTHORITATIVE_MEANING_SOURCE_KINDS.has(kind);
-}
-export function validateDesignResourceDeltaAuthority(delta, delegations, authoritySources) {
-    validateDeltaSourceReferences(delta, authoritySources);
-    validateAcceptedAuthorityPresence(delta, authoritySources);
-    const delegation = validateDeltaDelegation(delta, delegations);
-    validateNonvisualMeaningSource(delta, delegation, authoritySources);
-}
-export function indexDesignResourceDelegations(values, scope, authoritySources) {
-    const result = new Map();
-    for (const value of values) {
-        if (result.has(value.key))
-            invalid(`delegation_duplicate:${value.key}`);
-        assertUnique(value.allowed_origins, `delegation_origin_duplicate:${value.key}`);
-        assertUnique(value.allowed_semantic_kinds, `delegation_semantic_kind_duplicate:${value.key}`);
-        assertUnique(value.allowed_target_keys, `delegation_target_duplicate:${value.key}`);
-        const source = authoritySources.get(value.source_ref);
-        if (!source)
-            invalid(`delegation_source_ref_unresolved:${value.key}`);
-        if (source.source_item_kind !== "decision")
-            invalid(`delegation_source_not_decision:${value.key}`);
-        assertSubset(new Set(value.allowed_target_keys), scope, `delegation_target_outside_scope:${value.key}`);
-        result.set(value.key, value);
-    }
-    return result;
-}
-export function indexDesignResourceAuthoritySources(values) {
-    const result = new Map();
-    const identities = new Set();
-    for (const value of values) {
-        if (result.has(value.source_ref))
-            invalid(`authority_source_ref_duplicate:${value.source_ref}`);
-        const identity = `${value.locator}\u0000${value.source_item_key}`;
-        if (identities.has(identity))
-            invalid(`authority_source_item_aliased:${value.locator}:${value.source_item_key}`);
-        identities.add(identity);
-        result.set(value.source_ref, value);
-    }
-    return result;
-}
-export function validateDesignResourceBaseMaterialization(state, authoritySources) {
-    if (state.base.materialization.kind !== "authorized-recovery-snapshot")
-        return;
-    const source = authoritySources.get(state.base.materialization.authorization_ref);
-    if (!source)
-        invalid("base_snapshot_authorization_ref_unresolved");
-    if (source.source_item_kind !== "decision")
-        invalid("base_snapshot_authorization_not_decision");
-}
-function validateDeltaSourceReferences(delta, authoritySources) {
-    for (const sourceRef of delta.source_refs)
-        if (!authoritySources.has(sourceRef))
-            invalid(`delta_source_ref_unresolved:${delta.delta_id}:${sourceRef}`);
-}
-function validateAcceptedAuthorityPresence(delta, authoritySources) {
-    if (delta.status !== "accepted")
-        return;
-    if (delta.origin !== "necessary-derived" &&
-        delta.decision_authority === "none")
-        invalid(`accepted_delta_authority_required:${delta.delta_id}`);
-    if (delta.origin === "provider-suggested" &&
-        delta.decision_authority !== "explicit-user" &&
-        !delta.decision_authority.startsWith("delegated:"))
-        invalid(`provider_suggestion_not_authorized:${delta.delta_id}`);
-    if (delta.origin === "provider-suggested" && !delta.evidence_refs.length)
-        invalid(`provider_suggestion_evidence_required:${delta.delta_id}`);
-    if (delta.decision_authority === "explicit-user" &&
-        !delta.source_refs.some((sourceRef) => authoritySources.get(sourceRef)?.source_item_kind === "decision"))
-        invalid(`explicit_user_source_decision_required:${delta.delta_id}`);
-}
-function validateDeltaDelegation(delta, delegations) {
-    if (!delta.decision_authority.startsWith("delegated:"))
-        return undefined;
-    const key = delta.decision_authority.slice("delegated:".length);
-    const delegation = delegations.get(key);
-    if (!delegation)
-        invalid(`delegation_not_found:${delta.delta_id}:${key}`);
-    if (!delta.source_refs.includes(delegation.source_ref))
-        invalid(`delegation_source_not_bound:${delta.delta_id}:${key}`);
-    if (!delegation.allowed_origins.includes(delta.origin))
-        invalid(`delegation_origin_not_allowed:${delta.delta_id}:${key}`);
-    if (!delegation.allowed_semantic_kinds.includes(delta.semantic_kind))
-        invalid(`delegation_semantic_kind_not_allowed:${delta.delta_id}:${key}`);
-    assertSubset(new Set(delta.target_keys), new Set(delegation.allowed_target_keys), `delegation_target_not_allowed:${delta.delta_id}:${key}`);
-    return delegation;
-}
-function validateNonvisualMeaningSource(delta, delegation, authoritySources) {
-    if (delta.status !== "accepted" || delta.semantic_kind === "exact-visual")
-        return;
-    const found = delta.source_refs.some((sourceRef) => {
-        if (sourceRef === delegation?.source_ref)
-            return false;
-        const kind = authoritySources.get(sourceRef)?.source_item_kind ?? "";
-        return (isDesignResourceAuthoritativeMeaningSourceKind(kind) ||
-            (delta.decision_authority === "explicit-user" && kind === "decision"));
-    });
-    if (!found)
-        invalid(`nonvisual_meaning_source_required:${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 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-catalog-resources.d.ts

@@ -1,6 +0,0 @@
-import type { DesignResourceDelta, DesignResourceRecoveryCheckpoint, DesignResourceRecoveryCreateInput, DesignResourceSelectedResourceBinding } from "./design-resource-recovery-types.js";
-type RecoveryState = DesignResourceRecoveryCreateInput | DesignResourceRecoveryCheckpoint;
-export declare function indexDesignResourceSelectedResources(state: RecoveryState): Map<string, DesignResourceSelectedResourceBinding>;
-export declare function validateDesignResourceDecisionCatalog(rows: RecoveryState["audit_expectations"]["resource_decisions"], deltasById: Map<string, DesignResourceDelta>, activeChangedByTarget: Map<string, string[]>, superseded: Set<string>, selectedResources: Map<string, DesignResourceSelectedResourceBinding>): void;
-export declare function validateDesignResourceConditions(resourceRefs: string[], conditionRefs: string[], selected: Map<string, DesignResourceSelectedResourceBinding>, label: string): void;
-export {};

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

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

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

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

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