project-tiny-context-harness 0.8.12 → 0.8.13

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

@@ -0,0 +1,174 @@
+import { DESIGN_RESOURCE_RECOVERY_AUDIT_SCHEMA } from "./design-resource-recovery-schema.js";
+import { arrayOf, digest, literal, object, oneOf, optionalArrayOf, parseStrictJsonObject, stringSet, text, } from "./design-resource-recovery-codec-primitives.js";
+import { parseAuthorityIdentity, parseDecisionAuthority, } from "./design-resource-recovery-shape.js";
+import { parseDesignResourceFinalDisposition } from "./design-resource-recovery-final-disposition-shape.js";
+const ORIGINS = [
+    "user-direct",
+    "necessary-derived",
+    "repository-evidence-backed",
+    "provider-suggested",
+];
+const STATUSES = ["accepted", "rejected", "unresolved"];
+const SEMANTIC_KINDS = [
+    "exact-visual",
+    "product",
+    "business",
+    "permission",
+    "data",
+    "algorithm",
+    "commercial",
+    "safety-security",
+    "technical",
+];
+export function parseDesignResourceReconciliationAudit(content) {
+    const row = object(parseStrictJsonObject(content, "reconciliation_audit"), "reconciliation_audit", [
+        "schema_version",
+        "session_id",
+        "base_raw_byte_digest",
+        "design_authority",
+        "provider_run",
+        "resource_identities",
+        "accepted_delta_ids",
+        "rejected_delta_ids",
+        "unresolved_delta_ids",
+        "changed_keys",
+        "explicitly_unchanged",
+        "requirements_to_resource",
+        "resource_to_requirements",
+        "unexpected_blast_radius",
+        "inactive_delta_leakage",
+    ], ["writeback_target_raw_byte_digest"]);
+    literal(row.schema_version, DESIGN_RESOURCE_RECOVERY_AUDIT_SCHEMA, "reconciliation_audit.schema_version");
+    return {
+        schema_version: DESIGN_RESOURCE_RECOVERY_AUDIT_SCHEMA,
+        session_id: text(row.session_id, "reconciliation_audit.session_id"),
+        base_raw_byte_digest: digest(row.base_raw_byte_digest, "reconciliation_audit.base_raw_byte_digest"),
+        design_authority: parseAuthorityIdentity(row.design_authority, "reconciliation_audit.design_authority"),
+        provider_run: parseProviderRun(row.provider_run),
+        resource_identities: optionalArrayOf(row.resource_identities, "reconciliation_audit.resource_identities", parseResourceIdentity),
+        ...(row.writeback_target_raw_byte_digest === undefined
+            ? {}
+            : {
+                writeback_target_raw_byte_digest: digest(row.writeback_target_raw_byte_digest, "reconciliation_audit.writeback_target_raw_byte_digest"),
+            }),
+        accepted_delta_ids: stringSet(row.accepted_delta_ids, "reconciliation_audit.accepted_delta_ids", { allowEmpty: true }),
+        rejected_delta_ids: stringSet(row.rejected_delta_ids, "reconciliation_audit.rejected_delta_ids", { allowEmpty: true }),
+        unresolved_delta_ids: stringSet(row.unresolved_delta_ids, "reconciliation_audit.unresolved_delta_ids", { allowEmpty: true }),
+        changed_keys: stringSet(row.changed_keys, "reconciliation_audit.changed_keys", { allowEmpty: true }),
+        explicitly_unchanged: optionalArrayOf(row.explicitly_unchanged, "reconciliation_audit.explicitly_unchanged", parseUnchanged),
+        requirements_to_resource: optionalArrayOf(row.requirements_to_resource, "reconciliation_audit.requirements_to_resource", parseRequirementFinding),
+        resource_to_requirements: optionalArrayOf(row.resource_to_requirements, "reconciliation_audit.resource_to_requirements", parseResourceFinding),
+        unexpected_blast_radius: optionalArrayOf(row.unexpected_blast_radius, "reconciliation_audit.unexpected_blast_radius", parseBlastFinding),
+        inactive_delta_leakage: optionalArrayOf(row.inactive_delta_leakage, "reconciliation_audit.inactive_delta_leakage", parseLeakage),
+    };
+}
+function parseProviderRun(value) {
+    const row = object(value, "reconciliation_audit.provider_run", [
+        "key",
+        "locator",
+        "immutable_identity",
+    ]);
+    return {
+        key: text(row.key, "provider_run.key"),
+        locator: text(row.locator, "provider_run.locator"),
+        immutable_identity: text(row.immutable_identity, "provider_run.immutable_identity"),
+    };
+}
+function parseResourceIdentity(value, label) {
+    const row = object(value, label, ["key", "raw_byte_digest"]);
+    return {
+        key: text(row.key, `${label}.key`),
+        raw_byte_digest: digest(row.raw_byte_digest, `${label}.raw_byte_digest`),
+    };
+}
+function parseUnchanged(value, label) {
+    const row = object(value, label, [
+        "key",
+        "verdict",
+        "resource_refs",
+        "condition_refs",
+        "basis_source_refs",
+    ]);
+    return {
+        key: text(row.key, `${label}.key`),
+        verdict: oneOf(row.verdict, ["preserved", "changed", "unresolved"], `${label}.verdict`),
+        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 parseRequirementFinding(value, label) {
+    const row = object(value, label, [
+        "key",
+        "verdict",
+        "delta_ids",
+        "resource_refs",
+        "condition_refs",
+    ]);
+    return {
+        key: text(row.key, `${label}.key`),
+        verdict: oneOf(row.verdict, ["covered", "missing", "distorted", "unsupported", "unresolved"], `${label}.verdict`),
+        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 parseResourceFinding(value, label) {
+    const row = object(value, label, [
+        "key",
+        "resource_ref",
+        "status",
+        "semantic_kind",
+        "delta_ids",
+        "condition_refs",
+        "requirement_bindings",
+    ]);
+    return {
+        key: text(row.key, `${label}.key`),
+        resource_ref: text(row.resource_ref, `${label}.resource_ref`),
+        status: oneOf(row.status, STATUSES, `${label}.status`),
+        semantic_kind: oneOf(row.semantic_kind, SEMANTIC_KINDS, `${label}.semantic_kind`),
+        delta_ids: stringSet(row.delta_ids, `${label}.delta_ids`),
+        condition_refs: stringSet(row.condition_refs, `${label}.condition_refs`),
+        requirement_bindings: arrayOf(row.requirement_bindings, `${label}.requirement_bindings`, parseRequirementBinding),
+    };
+}
+function parseRequirementBinding(value, label) {
+    const row = object(value, label, [
+        "binding_id",
+        "requirement_key",
+        "delta_id",
+        "origin",
+        "decision_authority",
+        "source_refs",
+        "final_disposition",
+    ]);
+    return {
+        binding_id: text(row.binding_id, `${label}.binding_id`),
+        requirement_key: text(row.requirement_key, `${label}.requirement_key`),
+        delta_id: text(row.delta_id, `${label}.delta_id`),
+        origin: oneOf(row.origin, ORIGINS, `${label}.origin`),
+        decision_authority: parseDecisionAuthority(row.decision_authority, `${label}.decision_authority`),
+        source_refs: stringSet(row.source_refs, `${label}.source_refs`, {
+            allowEmpty: true,
+        }),
+        final_disposition: parseDesignResourceFinalDisposition(row.final_disposition, `${label}.final_disposition`),
+    };
+}
+function parseBlastFinding(value, label) {
+    const row = object(value, label, ["key", "verdict"]);
+    return {
+        key: text(row.key, `${label}.key`),
+        verdict: oneOf(row.verdict, ["expected", "unexpected", "unresolved"], `${label}.verdict`),
+    };
+}
+function parseLeakage(value, label) {
+    const row = object(value, label, ["delta_id", "inactive_reason", "leaked"]);
+    if (typeof row.leaked !== "boolean")
+        throw new Error(`design_resource_recovery_invalid:${label}.leaked:boolean_required`);
+    return {
+        delta_id: text(row.delta_id, `${label}.delta_id`),
+        inactive_reason: oneOf(row.inactive_reason, ["rejected", "unresolved", "superseded"], `${label}.inactive_reason`),
+        leaked: row.leaked,
+    };
+}

package/dist/lib/design-resource-reconciliation-types.d.ts

@@ -0,0 +1,62 @@
+import { DESIGN_RESOURCE_RECOVERY_AUDIT_SCHEMA } from "./design-resource-recovery-schema.js";
+import type { DesignResourceAuthorityIdentity, DesignResourceDecisionAuthority, DesignResourceDecisionOrigin, DesignResourceDecisionStatus, DesignResourceFinalDisposition, DesignResourceProviderIdentity, DesignResourceSemanticKind } from "./design-resource-recovery-types.js";
+export interface DesignResourceReconciliationAudit {
+    schema_version: typeof DESIGN_RESOURCE_RECOVERY_AUDIT_SCHEMA;
+    session_id: string;
+    base_raw_byte_digest: string;
+    design_authority: DesignResourceAuthorityIdentity;
+    provider_run: DesignResourceProviderIdentity;
+    resource_identities: Array<{
+        key: string;
+        raw_byte_digest: string;
+    }>;
+    writeback_target_raw_byte_digest?: string;
+    accepted_delta_ids: string[];
+    rejected_delta_ids: string[];
+    unresolved_delta_ids: string[];
+    changed_keys: string[];
+    explicitly_unchanged: Array<{
+        key: string;
+        verdict: "preserved" | "changed" | "unresolved";
+        resource_refs: string[];
+        condition_refs: string[];
+        basis_source_refs: string[];
+    }>;
+    requirements_to_resource: Array<{
+        key: string;
+        verdict: "covered" | "missing" | "distorted" | "unsupported" | "unresolved";
+        delta_ids: string[];
+        resource_refs: string[];
+        condition_refs: string[];
+    }>;
+    resource_to_requirements: Array<{
+        key: string;
+        resource_ref: string;
+        status: DesignResourceDecisionStatus;
+        semantic_kind: DesignResourceSemanticKind;
+        delta_ids: string[];
+        condition_refs: string[];
+        requirement_bindings: Array<{
+            binding_id: string;
+            requirement_key: string;
+            delta_id: string;
+            origin: DesignResourceDecisionOrigin;
+            decision_authority: DesignResourceDecisionAuthority;
+            source_refs: string[];
+            final_disposition: DesignResourceFinalDisposition;
+        }>;
+    }>;
+    unexpected_blast_radius: Array<{
+        key: string;
+        verdict: "expected" | "unexpected" | "unresolved";
+    }>;
+    inactive_delta_leakage: Array<{
+        delta_id: string;
+        inactive_reason: "rejected" | "unresolved" | "superseded";
+        leaked: boolean;
+    }>;
+}
+export interface DesignResourceReconciliationResult {
+    status: "reconciliation-balanced" | "blocked";
+    findings: string[];
+}

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

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

package/dist/lib/design-resource-reconciliation.d.ts

@@ -0,0 +1,3 @@
+import type { DesignResourceRecoveryCheckpoint } from "./design-resource-recovery-types.js";
+import type { DesignResourceReconciliationAudit, DesignResourceReconciliationResult } from "./design-resource-reconciliation-types.js";
+export declare function reconcileDesignResourceWriteback(checkpoint: DesignResourceRecoveryCheckpoint, audit: DesignResourceReconciliationAudit): DesignResourceReconciliationResult;

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

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

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

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

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