project-tiny-context-harness 0.8.12 → 0.8.13

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

@@ -0,0 +1,197 @@
+import { DESIGN_RESOURCE_AUTHORITY_PROJECTION_SCHEMA, DESIGN_RESOURCE_RECOVERY_INPUT_SCHEMA, DESIGN_RESOURCE_RECOVERY_SCHEMA } from "./design-resource-recovery-schema.js";
+import type { DesignResourceRecoveryWriteback, DesignResourceWritebackInput } from "./design-resource-recovery-patch-types.js";
+import type { SourceItemKind } from "./long-task-source-authority-types.js";
+export type DesignResourceDecisionOrigin = "user-direct" | "necessary-derived" | "repository-evidence-backed" | "provider-suggested";
+export type DesignResourceDecisionStatus = "accepted" | "rejected" | "unresolved";
+export type DesignResourceDecisionAuthority = "explicit-user" | "none" | `delegated:${string}`;
+export type DesignResourceSemanticKind = "exact-visual" | "product" | "business" | "permission" | "data" | "algorithm" | "commercial" | "safety-security" | "technical";
+export type DesignResourceTextEncoding = "utf8" | "utf8-bom" | "utf16le" | "utf16be";
+export type DesignResourceEolPolicy = "none" | "lf" | "crlf" | "cr" | "mixed";
+export interface DesignResourceRecoveryBaseInput {
+    locator: string;
+    raw_byte_digest: string;
+    materialization: {
+        kind: "repository-source";
+    } | {
+        kind: "authorized-recovery-snapshot";
+        authorization_ref: string;
+    };
+    scope_ceiling: string;
+    in_scope_keys: string[];
+    explicitly_excluded_keys: string[];
+}
+export interface DesignResourceRecoveryBase extends DesignResourceRecoveryBaseInput {
+    encoding: DesignResourceTextEncoding;
+    eol_policy: DesignResourceEolPolicy;
+}
+export interface DesignResourceDelegation {
+    key: string;
+    source_ref: string;
+    allowed_origins: DesignResourceDecisionOrigin[];
+    allowed_target_keys: string[];
+    allowed_semantic_kinds: DesignResourceSemanticKind[];
+}
+export type DesignResourceAuthorityProjection = {
+    schema_version: typeof DESIGN_RESOURCE_AUTHORITY_PROJECTION_SCHEMA;
+    mode: "explicit-user";
+    target_keys: string[];
+    semantic_kinds: DesignResourceSemanticKind[];
+    allowed_origins: DesignResourceDecisionOrigin[];
+    meaning_sha256: string;
+} | {
+    schema_version: typeof DESIGN_RESOURCE_AUTHORITY_PROJECTION_SCHEMA;
+    mode: "delegation";
+    delegation_key: string;
+    allowed_target_keys: string[];
+    allowed_semantic_kinds: DesignResourceSemanticKind[];
+    allowed_origins: DesignResourceDecisionOrigin[];
+};
+export interface DesignResourceAuthoritySourceItem {
+    source_ref: string;
+    locator: string;
+    raw_byte_digest: string;
+    source_item_key: string;
+    source_item_kind: SourceItemKind;
+    source_item_text_sha256: string;
+}
+export interface DesignResourceDelta {
+    delta_id: string;
+    sequence: number;
+    supersedes: string[];
+    proposes_replacement_of: string[];
+    operation: "add" | "replace" | "remove" | "preserve";
+    semantic_kind: DesignResourceSemanticKind;
+    target_keys: string[];
+    before_semantics: unknown;
+    after_semantics: unknown;
+    origin: DesignResourceDecisionOrigin;
+    decision_authority: DesignResourceDecisionAuthority;
+    evidence_refs: string[];
+    source_refs: string[];
+    explicitly_unchanged_keys: string[];
+    status: DesignResourceDecisionStatus;
+}
+export type DesignResourceAuthorityIdentity = {
+    kind: "repository-file" | "external-immutable";
+    locator: string;
+    raw_byte_digest: string;
+} | {
+    kind: "not-applicable";
+    rationale: string;
+};
+export interface DesignResourceProviderIdentity {
+    key: string;
+    locator: string;
+    immutable_identity: string;
+}
+export interface DesignResourceProviderResourceIdentity extends DesignResourceProviderIdentity {
+    raw_byte_digest: string;
+}
+export interface DesignResourceProviderReferences {
+    project: DesignResourceProviderIdentity;
+    run: DesignResourceProviderIdentity;
+    resources: DesignResourceProviderResourceIdentity[];
+}
+export interface DesignResourceSelectedResourceBinding {
+    key: string;
+    identity_kind: "repository-snapshot" | "external-immutable";
+    locator: string;
+    raw_byte_digest: string;
+    condition_refs: string[];
+}
+export type DesignResourceDownstreamOwner = {
+    kind: "selected-source-record";
+    locator: string;
+    raw_byte_digest: string;
+    resource_key: string;
+} | {
+    kind: "external-immutable";
+    locator: string;
+    raw_byte_digest: string;
+    resource_key: string;
+};
+export type DesignResourceFinalDisposition = {
+    kind: "proposal-written";
+    operation_id: string;
+} | {
+    kind: "resource-owned-exact-visual";
+    resource_ref: string;
+    condition_refs: string[];
+    downstream_owner: DesignResourceDownstreamOwner;
+} | {
+    kind: "not-adopted";
+} | {
+    kind: "unresolved";
+};
+export interface DesignResourceAuditExpectations {
+    changed: Array<{
+        key: string;
+        delta_ids: string[];
+        resource_refs: string[];
+        condition_refs: string[];
+    }>;
+    unchanged: Array<{
+        key: string;
+        resource_refs: string[];
+        condition_refs: string[];
+        basis_source_refs: string[];
+    }>;
+    resource_decisions: Array<{
+        key: string;
+        resource_ref: string;
+        semantic_kind: DesignResourceSemanticKind;
+        bindings: Array<{
+            binding_id: string;
+            delta_id: string;
+            target_key: string;
+            final_disposition: DesignResourceFinalDisposition;
+        }>;
+        condition_refs: string[];
+    }>;
+    blast_radius: Array<{
+        key: string;
+    }>;
+    inactive_delta_leakage: Array<{
+        delta_id: string;
+        reason: "rejected" | "unresolved" | "superseded";
+    }>;
+}
+export interface DesignResourceRecoveryCreateInput {
+    schema_version: typeof DESIGN_RESOURCE_RECOVERY_INPUT_SCHEMA;
+    session_id: string;
+    disclosure_review: {
+        reviewed: true;
+        contains_sensitive_raw_values: false;
+    };
+    base: DesignResourceRecoveryBaseInput;
+    authority_sources: DesignResourceAuthoritySourceItem[];
+    delegations: DesignResourceDelegation[];
+    deltas: DesignResourceDelta[];
+    decision_sets: {
+        accepted_delta_ids: string[];
+        rejected_delta_ids: string[];
+        unresolved_delta_ids: string[];
+    };
+    audit_expectations: DesignResourceAuditExpectations;
+    design_authority: DesignResourceAuthorityIdentity;
+    provider: DesignResourceProviderReferences;
+    selected_resource_bindings: DesignResourceSelectedResourceBinding[];
+    writeback?: DesignResourceWritebackInput;
+}
+export interface DesignResourceRecoveryCheckpoint extends Omit<DesignResourceRecoveryCreateInput, "schema_version" | "base" | "writeback"> {
+    schema_version: typeof DESIGN_RESOURCE_RECOVERY_SCHEMA;
+    owner: "ty-context-design-resource-recovery";
+    base: DesignResourceRecoveryBase;
+    writeback?: DesignResourceRecoveryWriteback;
+}
+export interface DesignResourceReplayProjection {
+    status: "replayable";
+    base: DesignResourceRecoveryBase;
+    ordered_active_accepted_deltas: DesignResourceDelta[];
+    rejected_deltas: DesignResourceDelta[];
+    unresolved_deltas: DesignResourceDelta[];
+    superseded_delta_ids: string[];
+    explicitly_unchanged_keys: string[];
+    design_authority: DesignResourceAuthorityIdentity;
+    external_revalidation_required: string[];
+}

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

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

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

@@ -0,0 +1,5 @@
+import type { DesignResourceDelta, DesignResourceRecoveryCheckpoint, DesignResourceRecoveryCreateInput } from "./design-resource-recovery-types.js";
+type RecoveryState = DesignResourceRecoveryCreateInput | DesignResourceRecoveryCheckpoint;
+export declare function validateRecoveryProviderAndWriteback(state: RecoveryState, activeAccepted: DesignResourceDelta[]): void;
+export declare function renderDesignResourceProposalScalarCarrier(targetKey: string, semanticPath: string[], value: string | number | boolean | null, operationId?: string): string;
+export {};

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

@@ -0,0 +1,326 @@
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+export function validateRecoveryProviderAndWriteback(state, activeAccepted) {
+    const resourceKeys = uniqueValues(state.provider.resources.map((resource) => resource.key), "provider_resource_key_duplicate");
+    uniqueValues(state.provider.resources.map((resource) => resource.locator), "provider_resource_locator_duplicate");
+    const selectedKeys = uniqueValues(state.selected_resource_bindings.map((resource) => resource.key), "selected_resource_key_duplicate");
+    assertSubset(selectedKeys, resourceKeys, "selected_resource_not_declared");
+    const proposalBindings = frozenProposalBindings(state, activeAccepted);
+    if (!proposalBindings.size) {
+        if (state.writeback)
+            invalid("writeback_without_proposal_owner");
+        return;
+    }
+    if (!state.writeback)
+        invalid("proposal_owner_writeback_required");
+    const writeback = state.writeback;
+    if (writeback.target_locator === state.base.locator)
+        invalid("writeback_target_must_not_replace_immutable_base");
+    assertExactSet(writeback.proposal_written_delta_ids, [...new Set([...proposalBindings.values()].map((row) => row.deltaId))], "writeback_proposal_delta_set_mismatch");
+    validatePatch(writeback.patch.operations, activeAccepted, proposalBindings);
+    const patchIdentity = sha256Hex(canonicalValueJson(writeback.patch));
+    if (patchIdentity !== writeback.patch_identity)
+        invalid(`patch_identity_mismatch:${writeback.patch_identity}:${patchIdentity}`);
+    uniqueValues(writeback.resource_identities.map((resource) => resource.key), "writeback_resource_identity_duplicate");
+    const resources = new Map(state.provider.resources.map((resource) => [resource.key, resource]));
+    assertExactSet(writeback.resource_identities.map((row) => row.key), [...selectedKeys], "writeback_resource_set_mismatch");
+    for (const identity of writeback.resource_identities) {
+        const provider = resources.get(identity.key);
+        if (!provider || provider.raw_byte_digest !== identity.raw_byte_digest)
+            invalid(`writeback_resource_identity_mismatch:${identity.key}`);
+    }
+}
+function frozenProposalBindings(state, activeAccepted) {
+    const active = new Set(activeAccepted
+        .filter((delta) => delta.operation !== "preserve")
+        .flatMap((delta) => delta.target_keys.map((target) => deltaTarget(delta.delta_id, target))));
+    const result = new Map();
+    const operationIds = [];
+    for (const row of state.audit_expectations.resource_decisions)
+        for (const binding of row.bindings) {
+            if (binding.final_disposition.kind !== "proposal-written")
+                continue;
+            const identity = deltaTarget(binding.delta_id, binding.target_key);
+            if (!active.has(identity))
+                invalid(`proposal_owner_inactive:${binding.binding_id}`);
+            if (result.has(identity))
+                invalid(`proposal_owner_duplicate:${binding.binding_id}`);
+            const item = {
+                deltaId: binding.delta_id,
+                targetKey: binding.target_key,
+                operationId: binding.final_disposition.operation_id,
+            };
+            result.set(identity, item);
+            operationIds.push(item.operationId);
+        }
+    uniqueValues(operationIds, "proposal_owner_operation_duplicate");
+    return result;
+}
+function validatePatch(operations, activeAccepted, expectedBindings) {
+    uniqueValues(operations.map((operation) => operation.operation_id), "patch_operation_id_duplicate");
+    const activeById = new Map(activeAccepted.map((delta) => [delta.delta_id, delta]));
+    const bindingIdentities = [];
+    for (const operation of operations) {
+        if (operation.before_text === operation.after_text)
+            invalid(`patch_operation_no_change:${operation.operation_id}`);
+        assertDigest(operation.before_text_sha256, sha256Hex(operation.before_text), `patch_before_text_digest:${operation.operation_id}`);
+        assertDigest(operation.after_text_sha256, sha256Hex(operation.after_text), `patch_after_text_digest:${operation.operation_id}`);
+        validateSourceSpanMetadata(operation);
+        const operationBinding = validateSemanticBinding(operation, operation.semantic_binding, activeById);
+        const frozen = expectedBindings.get(operationBinding.identity);
+        if (!frozen)
+            invalid(`patch_binding_not_proposal_owned:${operation.operation_id}:${operationBinding.identity}`);
+        if (frozen.operationId !== operation.operation_id)
+            invalid(`patch_operation_owner_mismatch:${operation.operation_id}`);
+        bindingIdentities.push(operationBinding.identity);
+    }
+    validateSourceSpanLayout(operations);
+    uniqueValues(bindingIdentities, "patch_binding_duplicate_global");
+    assertExactSet(bindingIdentities, [...expectedBindings.keys()], "writeback_patch_binding_universe_mismatch");
+}
+function validateSourceSpanLayout(operations) {
+    const ordered = [...operations].sort((left, right) => left.source_span.start_offset - right.source_span.start_offset ||
+        left.source_span.end_offset - right.source_span.end_offset ||
+        left.operation_id.localeCompare(right.operation_id));
+    for (let index = 1; index < ordered.length; index += 1) {
+        const previous = ordered[index - 1];
+        const current = ordered[index];
+        if (current.source_span.start_offset < previous.source_span.end_offset)
+            invalid(`patch_source_span_overlap:${previous.operation_id}:${current.operation_id}`);
+    }
+}
+function validateSourceSpanMetadata(operation) {
+    const span = operation.source_span;
+    if (span.start_offset < 0 ||
+        span.end_offset <= span.start_offset ||
+        span.end_offset - span.start_offset !== operation.before_text.length)
+        invalid(`patch_source_span_range:${operation.operation_id}`);
+    if (span.before_text_sha256 !== operation.before_text_sha256)
+        invalid(`patch_source_span_digest:${operation.operation_id}`);
+}
+function validateSemanticBinding(operation, binding, activeById) {
+    const operationId = operation.operation_id;
+    const delta = activeById.get(binding.delta_id);
+    if (!delta)
+        invalid(`patch_binding_inactive_or_unknown:${operationId}:${binding.delta_id}`);
+    if (delta.operation === "preserve")
+        invalid(`patch_binding_preserve_delta:${operationId}:${binding.delta_id}`);
+    if (operation.delta_id !== binding.delta_id ||
+        operation.target_key !== binding.target_key)
+        invalid(`patch_operation_binding_identity:${operationId}`);
+    if (!delta.target_keys.includes(binding.target_key))
+        invalid(`patch_binding_target_mismatch:${operationId}:${binding.delta_id}:${binding.target_key}`);
+    if (operation.operation !== delta.operation)
+        invalid(`patch_operation_semantic_operation:${operationId}`);
+    assertDigest(binding.before_semantics_sha256, sha256Hex(canonicalValueJson(delta.before_semantics)), `patch_before_semantics:${operationId}:${binding.delta_id}:${binding.target_key}`);
+    assertDigest(binding.after_semantics_sha256, sha256Hex(canonicalValueJson(delta.after_semantics)), `patch_after_semantics:${operationId}:${binding.delta_id}:${binding.target_key}`);
+    validateOperationProjection(operation, delta, binding);
+    return { identity: deltaTarget(binding.delta_id, binding.target_key) };
+}
+function validateOperationProjection(operation, delta, binding) {
+    const operationId = operation.operation_id;
+    if (operation.operation === "add") {
+        if (delta.before_semantics !== null ||
+            delta.after_semantics === null ||
+            binding.before_text_projection !== null ||
+            !operation.after_text.length)
+            invalid(`patch_add_shape:${operationId}`);
+        validateCanonicalCarrierAdd(operation, delta, binding);
+        return;
+    }
+    if (operation.operation === "remove") {
+        if (delta.before_semantics === null ||
+            delta.after_semantics !== null ||
+            binding.after_text_projection !== null ||
+            operation.after_text !== "")
+            invalid(`patch_remove_shape:${operationId}`);
+        validateCanonicalCarrierRemove(operation, delta, binding);
+        return;
+    }
+    if (delta.before_semantics === null ||
+        delta.after_semantics === null ||
+        !operation.after_text.length)
+        invalid(`patch_replace_shape:${operationId}`);
+    validateTextProjection(operationId, "before", operation.before_text, delta.before_semantics, binding.before_text_projection);
+    validateTextProjection(operationId, "after", operation.after_text, delta.after_semantics, binding.after_text_projection);
+    const beforeProjection = binding.before_text_projection;
+    const afterProjection = binding.after_text_projection;
+    if (!beforeProjection || !afterProjection)
+        invalid(`patch_replace_projection_required:${operationId}`);
+    if (operation.before_text.slice(0, beforeProjection.start_offset) !==
+        operation.after_text.slice(0, afterProjection.start_offset))
+        invalid(`patch_replace_scaffold_prefix:${operationId}`);
+    if (operation.before_text.slice(beforeProjection.end_offset) !==
+        operation.after_text.slice(afterProjection.end_offset))
+        invalid(`patch_replace_scaffold_suffix:${operationId}`);
+}
+function validateCanonicalCarrierAdd(operation, delta, binding) {
+    const operationId = operation.operation_id;
+    const leaf = uniqueScalarLeaf(delta.after_semantics, operationId, "after");
+    const carrier = renderDesignResourceProposalScalarCarrier(operation.target_key, leaf.path, leaf.value, operationId);
+    if (countLiteral(operation.before_text, carrier) !== 0 ||
+        countLiteral(operation.after_text, carrier) !== 1)
+        invalid(`patch_add_carrier_count:${operationId}`);
+    const carrierLine = carrierLineFragment(operation.after_text, carrier);
+    const anchorFirst = operation.after_text === operation.before_text + carrierLine;
+    const anchorLast = operation.after_text === carrierLine + operation.before_text;
+    if (!anchorFirst && !anchorLast)
+        invalid(`patch_add_anchor_or_carrier:${operationId}`);
+    if (anchorFirst && !/(?:\r\n|\n|\r)$/u.test(operation.before_text))
+        invalid(`patch_add_carrier_line_boundary:${operationId}`);
+    validateCarrierProjection(operationId, "after", operation.after_text, leaf, binding.after_text_projection, anchorFirst ? operation.before_text.length : 0, carrier);
+}
+function countLiteral(text, value) {
+    let count = 0;
+    let offset = 0;
+    while (true) {
+        const found = text.indexOf(value, offset);
+        if (found < 0)
+            return count;
+        count += 1;
+        offset = found + value.length;
+    }
+}
+function validateCanonicalCarrierRemove(operation, delta, binding) {
+    const operationId = operation.operation_id;
+    const leaf = uniqueScalarLeaf(delta.before_semantics, operationId, "before");
+    const carrier = renderDesignResourceProposalScalarCarrier(operation.target_key, leaf.path, leaf.value, operationId);
+    if (operation.before_text !==
+        carrierLineFragment(operation.before_text, carrier))
+        invalid(`patch_remove_carrier:${operationId}`);
+    validateCarrierProjection(operationId, "before", operation.before_text, leaf, binding.before_text_projection, 0, carrier);
+}
+function carrierLineFragment(text, carrier) {
+    for (const eol of ["\r\n", "\n", "\r"])
+        if (text.includes(`${carrier}${eol}`))
+            return `${carrier}${eol}`;
+    return "";
+}
+function validateCarrierProjection(operationId, side, text, leaf, projection, carrierOffset, carrier) {
+    if (!projection)
+        invalid(`patch_${side}_semantic_projection_required:${operationId}`);
+    if (!samePath(projection.semantic_path, leaf.path))
+        invalid(`patch_${side}_semantic_path:${operationId}`);
+    const scalar = canonicalCarrierScalar(leaf.value, operationId, side);
+    const marker = `\"value\":${scalar}`;
+    const relative = carrier.indexOf(marker);
+    if (relative < 0)
+        invalid(`patch_${side}_carrier_scalar:${operationId}`);
+    const expectedStart = carrierOffset + relative + `\"value\":`.length;
+    const expectedEnd = expectedStart + scalar.length;
+    if (projection.start_offset !== expectedStart ||
+        projection.end_offset !== expectedEnd ||
+        text.slice(expectedStart, expectedEnd) !== scalar)
+        invalid(`patch_${side}_carrier_projection:${operationId}`);
+}
+function validateTextProjection(operationId, side, text, semantics, projection) {
+    if (!projection)
+        invalid(`patch_${side}_semantic_projection_required:${operationId}`);
+    const leaf = uniqueScalarLeaf(semantics, operationId, side);
+    if (!samePath(projection.semantic_path, leaf.path))
+        invalid(`patch_${side}_semantic_path:${operationId}`);
+    if (projection.start_offset < 0 ||
+        projection.end_offset <= projection.start_offset ||
+        projection.end_offset > text.length)
+        invalid(`patch_${side}_projection_range:${operationId}`);
+    const actual = text.slice(projection.start_offset, projection.end_offset);
+    if (actual !== renderSemanticScalar(leaf.value, operationId, side))
+        invalid(`patch_${side}_semantic_text_mismatch:${operationId}`);
+}
+function uniqueScalarLeaf(semantics, operationId, side) {
+    const leaves = [];
+    collectScalarLeaves(semantics, [], leaves, operationId, side);
+    if (leaves.length !== 1)
+        invalid(`patch_${side}_semantic_leaf_count:${operationId}:${leaves.length}`);
+    return leaves[0];
+}
+function collectScalarLeaves(value, path, leaves, operationId, side) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean" ||
+        (typeof value === "number" && Number.isFinite(value))) {
+        leaves.push({ path, value });
+        return;
+    }
+    if (typeof value !== "object" || Array.isArray(value))
+        invalid(`patch_${side}_semantic_scalar_tree:${operationId}`);
+    for (const key of Object.keys(value).sort())
+        collectScalarLeaves(value[key], [...path, key], leaves, operationId, side);
+}
+function samePath(left, right) {
+    return (left.length === right.length &&
+        left.every((value, index) => value === right[index]));
+}
+function renderSemanticScalar(value, operationId, side) {
+    if (typeof value === "string") {
+        assertSafeStringScalar(value, operationId, side);
+        return value;
+    }
+    if (typeof value === "number" && Number.isFinite(value))
+        return String(value);
+    if (typeof value === "boolean")
+        return String(value);
+    if (value === null)
+        return "null";
+    invalid(`patch_${side}_semantic_scalar_required:${operationId}`);
+}
+export function renderDesignResourceProposalScalarCarrier(targetKey, semanticPath, value, operationId = "carrier") {
+    assertSafeCarrierCommentComponent(targetKey, operationId, "target_key");
+    for (const segment of semanticPath)
+        assertSafeCarrierCommentComponent(segment, operationId, "semantic_path");
+    if (typeof value === "string") {
+        assertSafeStringScalar(value, operationId, "carrier");
+        assertSafeCarrierCommentComponent(value, operationId, "value");
+    }
+    if (!targetKey.length ||
+        semanticPath.some((segment) => !segment.length) ||
+        (typeof value === "number" && !Number.isFinite(value)))
+        invalid(`patch_carrier_value:${operationId}`);
+    return `<!-- ty-dra-proposal-scalar-v1 ${canonicalValueJson({
+        semantic_path: semanticPath,
+        target_key: targetKey,
+        value,
+    })} -->`;
+}
+function assertSafeCarrierCommentComponent(value, operationId, field) {
+    if (/--/u.test(value))
+        invalid(`patch_carrier_comment_escape:${operationId}:${field}`);
+}
+function canonicalCarrierScalar(value, operationId, side) {
+    if (typeof value === "string")
+        assertSafeStringScalar(value, operationId, side);
+    return canonicalValueJson(value);
+}
+function assertSafeStringScalar(value, operationId, side) {
+    if (!value.length || /[\p{Cc}\p{Cs}]/u.test(value))
+        invalid(`patch_${side}_semantic_scalar_control:${operationId}`);
+}
+function deltaTarget(deltaId, target) {
+    return `${deltaId}\u0000${target}`;
+}
+function assertDigest(actual, expected, code) {
+    if (actual !== expected)
+        invalid(`${code}:${actual}:${expected}`);
+}
+function uniqueValues(values, code) {
+    const result = new Set(values);
+    if (result.size !== values.length)
+        invalid(code);
+    return result;
+}
+function assertSubset(candidate, owner, code) {
+    const outside = [...candidate].filter((value) => !owner.has(value));
+    if (outside.length)
+        invalid(`${code}:${outside.sort().join(",")}`);
+}
+function assertExactSet(actual, expected, code) {
+    uniqueValues(actual, `${code}:actual_duplicate`);
+    uniqueValues(expected, `${code}:expected_duplicate`);
+    const left = [...actual].sort();
+    const right = [...expected].sort();
+    if (left.length !== right.length ||
+        left.some((value, index) => value !== right[index]))
+        invalid(code);
+}
+function invalid(code) {
+    throw new Error(`design_resource_recovery_invalid:${code}`);
+}

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

@@ -0,0 +1,6 @@
+import { type DesignResourceExactPatch, type DesignResourceRecoveryWriteback, type DesignResourceWritebackInput } from "./design-resource-recovery-patch-types.js";
+import { type DesignResourceProviderReferences } from "./design-resource-recovery-types.js";
+export declare function parseProviderReferences(value: unknown, label: string): DesignResourceProviderReferences;
+export declare function parsePatch(value: unknown, label: string): DesignResourceExactPatch;
+export declare function parseWritebackInput(value: unknown, label: string, complete: false): DesignResourceWritebackInput;
+export declare function parseWritebackInput(value: unknown, label: string, complete: true): DesignResourceRecoveryWriteback;