project-tiny-context-harness 0.8.17 → 0.12.0

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

@@ -1,204 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { execFile } from "node:child_process";
-import { lstat, open, readFile, readdir, rename, rmdir, unlink, } from "node:fs/promises";
-import path from "node:path";
-import { promisify } from "node:util";
-import { normalizeRepositoryFile } from "./long-task-paths.js";
-import { assertProtectedRepositoryFile, assertSafeRepositoryFilePath, ensureSafeRepositoryDirectory, resolveInsideRepository, } from "./repository-path-safety.js";
-import { sha256Hex } from "./strict-codec.js";
-export const DESIGN_RESOURCE_RECOVERY_ROOT = "tmp/ty-context/design-resource-recovery";
-const execFileAsync = promisify(execFile);
-export function recoveryCheckpointRelativePath(sessionId) {
-    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/u.test(sessionId))
-        invalid(`unsafe_session_id:${sessionId}`);
-    return `${DESIGN_RESOURCE_RECOVERY_ROOT}/${sessionId}/checkpoint.json`;
-}
-export async function readRecoveryRepositoryFile(repository, locatorInput, label) {
-    const relative = normalizeRepositoryFile(locatorInput, label);
-    const absolute = resolveInsideRepository(repository, relative, label);
-    const safe = await assertProtectedRepositoryFile(repository, absolute, label);
-    const [bytes, status] = await Promise.all([readFile(safe), lstat(safe)]);
-    return {
-        relative,
-        absolute: safe,
-        bytes,
-        raw_byte_digest: sha256Hex(bytes),
-        mode: status.mode,
-    };
-}
-export async function readRecoveryCheckpointFile(repository, sessionId) {
-    return readRecoveryRepositoryFile(repository, recoveryCheckpointRelativePath(sessionId), "design_resource_recovery_checkpoint");
-}
-export async function createRecoveryCheckpointFile(repository, sessionId, bytes) {
-    const relative = recoveryCheckpointRelativePath(sessionId);
-    await assertRecoveryPathIgnored(repository, relative);
-    await ensureRecoverySessionDirectory(repository, sessionId);
-    const existing = await readOptionalRepositoryFile(repository, relative);
-    const expectedDigest = sha256Hex(bytes);
-    if (existing) {
-        if (existing.raw_byte_digest !== expectedDigest)
-            invalid(`checkpoint_collision:${relative}`);
-        return { path: relative, raw_byte_digest: expectedDigest, changed: false };
-    }
-    const result = await atomicCasWrite(repository, relative, bytes, null, 0o600);
-    return { path: relative, raw_byte_digest: result, changed: true };
-}
-export async function updateRecoveryCheckpointFile(repository, sessionId, bytes, expectedCurrentDigest) {
-    const relative = recoveryCheckpointRelativePath(sessionId);
-    await assertRecoveryPathIgnored(repository, relative);
-    const existing = await readRecoveryCheckpointFile(repository, sessionId);
-    if (existing.raw_byte_digest !== expectedCurrentDigest)
-        invalid(`checkpoint_update_cas_conflict:${expectedCurrentDigest}:${existing.raw_byte_digest}`);
-    const nextDigest = sha256Hex(bytes);
-    if (nextDigest === existing.raw_byte_digest)
-        return { path: relative, raw_byte_digest: nextDigest, changed: false };
-    const written = await atomicCasWrite(repository, relative, bytes, expectedCurrentDigest, existing.mode);
-    return { path: relative, raw_byte_digest: written, changed: true };
-}
-export async function atomicCasWrite(repository, relativeInput, bytes, expectedCurrentDigest, mode) {
-    const relative = normalizeRepositoryFile(relativeInput, "design_resource_recovery_write_target");
-    const destination = await assertSafeRepositoryFilePath(repository, relative, "design_resource_recovery_write_target", { destinationMayBeAbsent: true });
-    const current = await readOptionalRepositoryFile(repository, relative);
-    assertExpectedDigest(current?.raw_byte_digest ?? null, expectedCurrentDigest);
-    const digest = sha256Hex(bytes);
-    const temporary = path.join(path.dirname(destination.absolute), `.${path.basename(destination.absolute)}.ty-context-dra-${randomUUID()}.tmp`);
-    let created = false;
-    try {
-        const handle = await open(temporary, "wx", mode & 0o777);
-        created = true;
-        try {
-            await handle.writeFile(bytes);
-            await handle.sync();
-        }
-        finally {
-            await handle.close();
-        }
-        const tempBytes = await readFile(temporary);
-        if (sha256Hex(tempBytes) !== digest)
-            invalid("temporary_readback_mismatch");
-        const beforeRename = await readOptionalRepositoryFile(repository, relative);
-        assertExpectedDigest(beforeRename?.raw_byte_digest ?? null, expectedCurrentDigest);
-        await rename(temporary, destination.absolute);
-        created = false;
-        const after = await readRecoveryRepositoryFile(repository, relative, "design_resource_recovery_write_readback");
-        if (after.raw_byte_digest !== digest)
-            invalid("post_write_readback_mismatch");
-        return digest;
-    }
-    catch (error) {
-        if (!created)
-            throw error;
-        try {
-            await cleanupOwnedTemporary(temporary, digest);
-        }
-        catch (cleanupError) {
-            throw new AggregateError([error, cleanupError], "design_resource_recovery_cleanup_failed");
-        }
-        throw error;
-    }
-}
-export async function removeRecoveryCheckpointFile(repository, sessionId, expectedDigest) {
-    const snapshot = await readRecoveryCheckpointFile(repository, sessionId);
-    if (snapshot.raw_byte_digest !== expectedDigest)
-        invalid(`checkpoint_remove_cas_conflict:${expectedDigest}:${snapshot.raw_byte_digest}`);
-    const sessionDirectory = path.dirname(snapshot.absolute);
-    const before = (await readdir(sessionDirectory)).sort();
-    const unowned = before.filter((entry) => entry !== "checkpoint.json");
-    if (unowned.length)
-        return {
-            status: "partial",
-            path: snapshot.relative,
-            checkpoint_removed: false,
-            session_directory_removed: false,
-            retained_entries: before,
-            reason: "unowned_entries",
-        };
-    await unlink(snapshot.absolute);
-    try {
-        await rmdir(sessionDirectory);
-    }
-    catch {
-        const retained = await readdir(sessionDirectory).catch(() => []);
-        return {
-            status: "partial",
-            path: snapshot.relative,
-            checkpoint_removed: true,
-            session_directory_removed: false,
-            retained_entries: retained.sort(),
-            reason: "session_directory_cleanup_failed",
-        };
-    }
-    return {
-        status: "removed",
-        path: snapshot.relative,
-        checkpoint_removed: true,
-        session_directory_removed: true,
-        retained_entries: [],
-    };
-}
-export function deriveDigestCasState(current, before, after) {
-    if (current === before)
-        return "unapplied";
-    if (current === after)
-        return "applied";
-    return "conflict";
-}
-async function ensureRecoverySessionDirectory(repository, sessionId) {
-    const relative = `${DESIGN_RESOURCE_RECOVERY_ROOT}/${sessionId}`;
-    await ensureSafeRepositoryDirectory(repository, relative, "design_resource_recovery_session");
-    const absolute = resolveInsideRepository(repository, relative, "design_resource_recovery_session");
-    const entries = await readdir(absolute);
-    const collisions = entries.filter((entry) => entry !== "checkpoint.json");
-    if (collisions.length)
-        invalid(`session_directory_collision:${collisions.sort().join(",")}`);
-}
-async function assertRecoveryPathIgnored(repository, relative) {
-    try {
-        await execFileAsync("git", ["check-ignore", "--quiet", "--", relative], {
-            cwd: repository,
-            windowsHide: true,
-        });
-    }
-    catch (error) {
-        if (error.code === 1)
-            invalid(`checkpoint_path_not_ignored:${relative}`);
-        throw error;
-    }
-    try {
-        await execFileAsync("git", ["ls-files", "--error-unmatch", "--", relative], { cwd: repository, windowsHide: true });
-        invalid(`checkpoint_path_tracked:${relative}`);
-    }
-    catch (error) {
-        if (error.code !== 1)
-            throw error;
-    }
-}
-async function readOptionalRepositoryFile(repository, relative) {
-    try {
-        return await readRecoveryRepositoryFile(repository, relative, "design_resource_recovery_optional_file");
-    }
-    catch (error) {
-        if (error.message.includes("protected_input_not_found:"))
-            return null;
-        throw error;
-    }
-}
-function assertExpectedDigest(actual, expected) {
-    if (actual === expected)
-        return;
-    invalid(`cas_conflict:${expected ?? "absent"}:${actual ?? "absent"}`);
-}
-async function cleanupOwnedTemporary(temporary, expectedDigest) {
-    const status = await lstat(temporary).catch(() => null);
-    if (!status)
-        return;
-    if (status.isSymbolicLink() || !status.isFile())
-        invalid("temporary_cleanup_collision");
-    const digest = sha256Hex(await readFile(temporary));
-    if (digest !== expectedDigest)
-        invalid("temporary_cleanup_identity_mismatch");
-    await unlink(temporary);
-}
-function invalid(reason) {
-    throw new Error(`design_resource_recovery_invalid:${reason}`);
-}

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

@@ -1,2 +0,0 @@
-import type { DesignResourceFinalDisposition } from "./design-resource-recovery-types.js";
-export declare function parseDesignResourceFinalDisposition(value: unknown, label: string): DesignResourceFinalDisposition;

package/dist/lib/design-resource-recovery-final-disposition-shape.js

@@ -1,47 +0,0 @@
-import { digest, object, oneOf, stringSet, text, } from "./design-resource-recovery-codec-primitives.js";
-export function parseDesignResourceFinalDisposition(value, label) {
-    const first = object(value, label, ["kind"], ["operation_id", "resource_ref", "condition_refs", "downstream_owner"]);
-    const kind = oneOf(first.kind, [
-        "proposal-written",
-        "resource-owned-exact-visual",
-        "not-adopted",
-        "unresolved",
-    ], `${label}.kind`);
-    if (kind === "proposal-written") {
-        const row = object(value, label, ["kind", "operation_id"]);
-        return {
-            kind,
-            operation_id: text(row.operation_id, `${label}.operation_id`),
-        };
-    }
-    if (kind === "resource-owned-exact-visual") {
-        const row = object(value, label, [
-            "kind",
-            "resource_ref",
-            "condition_refs",
-            "downstream_owner",
-        ]);
-        return {
-            kind,
-            resource_ref: text(row.resource_ref, `${label}.resource_ref`),
-            condition_refs: stringSet(row.condition_refs, `${label}.condition_refs`),
-            downstream_owner: parseDownstreamOwner(row.downstream_owner, `${label}.downstream_owner`),
-        };
-    }
-    object(value, label, ["kind"]);
-    return { kind };
-}
-function parseDownstreamOwner(value, label) {
-    const row = object(value, label, [
-        "kind",
-        "locator",
-        "raw_byte_digest",
-        "resource_key",
-    ]);
-    return {
-        kind: oneOf(row.kind, ["selected-source-record", "external-immutable"], `${label}.kind`),
-        locator: text(row.locator, `${label}.locator`),
-        raw_byte_digest: digest(row.raw_byte_digest, `${label}.raw_byte_digest`),
-        resource_key: text(row.resource_key, `${label}.resource_key`),
-    };
-}

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

@@ -1,54 +0,0 @@
-import { DESIGN_RESOURCE_PATCH_SCHEMA } from "./design-resource-recovery-schema.js";
-import type { DesignResourceEolPolicy, DesignResourceTextEncoding } from "./design-resource-recovery-types.js";
-export interface DesignResourceTextSemanticProjection {
-    semantic_path: string[];
-    start_offset: number;
-    end_offset: number;
-}
-export interface DesignResourcePatchSemanticBinding {
-    delta_id: string;
-    target_key: string;
-    before_semantics_sha256: string;
-    after_semantics_sha256: string;
-    before_text_projection: DesignResourceTextSemanticProjection | null;
-    after_text_projection: DesignResourceTextSemanticProjection | null;
-}
-export interface DesignResourcePatchSourceSpan {
-    coordinate_system: "utf16-code-unit-v1";
-    start_offset: number;
-    end_offset: number;
-    before_text_sha256: string;
-}
-export interface DesignResourceExactPatchOperation {
-    operation_id: string;
-    operation: "add" | "replace" | "remove";
-    target_key: string;
-    delta_id: string;
-    before_text: string;
-    after_text: string;
-    before_text_sha256: string;
-    after_text_sha256: string;
-    source_span: DesignResourcePatchSourceSpan;
-    semantic_binding: DesignResourcePatchSemanticBinding;
-    expected_occurrences: 1;
-}
-export interface DesignResourceExactPatch {
-    schema_version: typeof DESIGN_RESOURCE_PATCH_SCHEMA;
-    operations: DesignResourceExactPatchOperation[];
-}
-export interface DesignResourceWritebackInput {
-    target_locator: string;
-    pre_write_raw_byte_digest: string;
-    patch: DesignResourceExactPatch;
-    patch_identity: string;
-    expected_post_write_raw_byte_digest: string;
-    resource_identities: Array<{
-        key: string;
-        raw_byte_digest: string;
-    }>;
-    proposal_written_delta_ids: string[];
-}
-export interface DesignResourceRecoveryWriteback extends DesignResourceWritebackInput {
-    target_encoding: DesignResourceTextEncoding;
-    target_eol_policy: Exclude<DesignResourceEolPolicy, "mixed">;
-}

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

@@ -1,7 +0,0 @@
-import type { DesignResourceDelta, DesignResourceRecoveryCheckpoint, DesignResourceRecoveryCreateInput, DesignResourceReplayProjection } from "./design-resource-recovery-types.js";
-type RecoveryState = DesignResourceRecoveryCreateInput | DesignResourceRecoveryCheckpoint;
-export declare function validateDesignResourceRecoverySemantics(state: RecoveryState): void;
-export declare function createDesignResourceReplayProjection(checkpoint: DesignResourceRecoveryCheckpoint): DesignResourceReplayProjection;
-export declare function acceptedSupersededDeltaIds(deltas: DesignResourceDelta[]): Set<string>;
-export declare function activeAcceptedDesignResourceDeltas(deltas: DesignResourceDelta[], superseded?: Set<string>): DesignResourceDelta[];
-export {};

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

@@ -1,112 +0,0 @@
-import { indexDesignResourceAuthoritySources, indexDesignResourceDelegations, validateDesignResourceBaseMaterialization, } from "./design-resource-recovery-authority-policy.js";
-import { validateDesignResourceDeltas } from "./design-resource-recovery-delta-policy.js";
-import { validateDesignResourceRecoveryCatalog } from "./design-resource-recovery-catalog.js";
-import { validateRecoveryProviderAndWriteback } from "./design-resource-recovery-writeback-policy.js";
-export function validateDesignResourceRecoverySemantics(state) {
-    validateTopLevelUniqueness(state);
-    const scope = new Set(state.base.in_scope_keys);
-    const excluded = new Set(state.base.explicitly_excluded_keys);
-    assertDisjoint(scope, excluded, "base_scope_and_exclusions_overlap");
-    const authoritySources = indexDesignResourceAuthoritySources(state.authority_sources);
-    validateDesignResourceBaseMaterialization(state, authoritySources);
-    const delegations = indexDesignResourceDelegations(state.delegations, scope, authoritySources);
-    const { byId, superseded } = validateDesignResourceDeltas(state.deltas, scope, excluded, delegations, authoritySources);
-    assertDecisionSets(state, byId);
-    const activeAccepted = activeAcceptedDesignResourceDeltas(state.deltas, superseded);
-    validateActiveAcceptedTargetUniqueness(activeAccepted);
-    validateDesignResourceRecoveryCatalog(state, byId, activeAccepted, superseded, authoritySources);
-    if (state.selected_resource_bindings.length &&
-        !state.audit_expectations.resource_decisions.length)
-        invalid("resource_decision_universe_required");
-    validateRecoveryProviderAndWriteback(state, activeAccepted);
-}
-export function createDesignResourceReplayProjection(checkpoint) {
-    validateDesignResourceRecoverySemantics(checkpoint);
-    const superseded = acceptedSupersededDeltaIds(checkpoint.deltas);
-    const external = [
-        `provider-project:${checkpoint.provider.project.key}`,
-        `provider-run:${checkpoint.provider.run.key}`,
-        ...checkpoint.provider.resources.map((resource) => `provider-resource:${resource.key}`),
-    ];
-    if (checkpoint.design_authority.kind === "external-immutable")
-        external.push(`design-authority:${checkpoint.design_authority.locator}`);
-    return {
-        status: "replayable",
-        base: checkpoint.base,
-        ordered_active_accepted_deltas: activeAcceptedDesignResourceDeltas(checkpoint.deltas, superseded),
-        rejected_deltas: checkpoint.deltas.filter((delta) => delta.status === "rejected"),
-        unresolved_deltas: checkpoint.deltas.filter((delta) => delta.status === "unresolved"),
-        superseded_delta_ids: [...superseded].sort(compareText),
-        explicitly_unchanged_keys: checkpoint.audit_expectations.unchanged.map((row) => row.key),
-        design_authority: checkpoint.design_authority,
-        external_revalidation_required: external.sort(compareText),
-    };
-}
-export function acceptedSupersededDeltaIds(deltas) {
-    return new Set(deltas
-        .filter((delta) => delta.status === "accepted")
-        .flatMap((delta) => delta.supersedes));
-}
-export function activeAcceptedDesignResourceDeltas(deltas, superseded = acceptedSupersededDeltaIds(deltas)) {
-    return deltas.filter((delta) => delta.status === "accepted" && !superseded.has(delta.delta_id));
-}
-function assertDecisionSets(state, byId) {
-    const expected = {
-        accepted_delta_ids: state.deltas
-            .filter((delta) => delta.status === "accepted")
-            .map((delta) => delta.delta_id),
-        rejected_delta_ids: state.deltas
-            .filter((delta) => delta.status === "rejected")
-            .map((delta) => delta.delta_id),
-        unresolved_delta_ids: state.deltas
-            .filter((delta) => delta.status === "unresolved")
-            .map((delta) => delta.delta_id),
-    };
-    for (const [key, values] of Object.entries(state.decision_sets)) {
-        assertUnique(values, `decision_set_duplicate:${key}`);
-        for (const value of values)
-            if (!byId.has(value))
-                invalid(`decision_set_delta_missing:${key}:${value}`);
-        assertEqualSet(new Set(values), new Set(expected[key]), `decision_set_mismatch:${key}`);
-    }
-}
-function validateTopLevelUniqueness(state) {
-    assertUnique(state.base.in_scope_keys, "base_in_scope_duplicate");
-    assertUnique(state.base.explicitly_excluded_keys, "base_explicit_exclusion_duplicate");
-    assertUnique(state.provider.resources.map((resource) => resource.key), "provider_resource_key_duplicate");
-    assertUnique(state.provider.resources.map((resource) => resource.locator), "provider_resource_locator_duplicate");
-}
-function validateActiveAcceptedTargetUniqueness(activeAccepted) {
-    const owner = new Map();
-    for (const delta of activeAccepted)
-        for (const target of delta.target_keys) {
-            const prior = owner.get(target);
-            if (prior)
-                invalid(`active_accepted_target_collision:${target}:${prior},${delta.delta_id}`);
-            owner.set(target, 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 assertDisjoint(left, right, code) {
-    const overlap = [...left].filter((value) => right.has(value));
-    if (overlap.length)
-        invalid(`${code}:${overlap.sort(compareText).join(",")}`);
-}
-function assertEqualSet(left, right, code) {
-    if (left.size !== right.size || [...left].some((value) => !right.has(value)))
-        invalid(code);
-}
-function invalid(code) {
-    throw new Error(`design_resource_recovery_invalid:${code}`);
-}
-function compareText(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}

package/dist/lib/design-resource-recovery-repository-bindings.d.ts

@@ -1,9 +0,0 @@
-import type { DesignResourceRecoveryCheckpoint, DesignResourceRecoveryCreateInput } from "./design-resource-recovery-types.js";
-type RecoveryState = DesignResourceRecoveryCreateInput | DesignResourceRecoveryCheckpoint;
-export declare function validateSelectedResourceRepositoryBindings(repository: string, state: RecoveryState): Promise<{
-    external_revalidation_required: boolean;
-}>;
-export declare function validateReconciliationDownstreamOwners(repository: string, checkpoint: DesignResourceRecoveryCheckpoint): Promise<{
-    external_revalidation_required: boolean;
-}>;
-export {};

package/dist/lib/design-resource-recovery-repository-bindings.js

@@ -1,49 +0,0 @@
-import { readRecoveryRepositoryFile } from "./design-resource-recovery-files.js";
-export async function validateSelectedResourceRepositoryBindings(repository, state) {
-    let external = false;
-    for (const binding of state.selected_resource_bindings) {
-        if (binding.identity_kind === "external-immutable") {
-            external = true;
-            continue;
-        }
-        const snapshot = await readRecoveryRepositoryFile(repository, binding.locator, `design_resource_recovery_selected_resource_${binding.key}`);
-        assertDigest(`selected_resource:${binding.key}`, snapshot.raw_byte_digest, binding.raw_byte_digest);
-    }
-    return { external_revalidation_required: external };
-}
-export async function validateReconciliationDownstreamOwners(repository, checkpoint) {
-    const selected = new Map(checkpoint.selected_resource_bindings.map((row) => [row.key, row]));
-    const current = await validateSelectedResourceRepositoryBindings(repository, checkpoint);
-    for (const row of checkpoint.audit_expectations.resource_decisions)
-        for (const binding of row.bindings) {
-            const disposition = binding.final_disposition;
-            if (disposition.kind !== "resource-owned-exact-visual")
-                continue;
-            const selectedResource = selected.get(disposition.resource_ref);
-            if (!selectedResource)
-                invalid(`downstream_owner_resource_unselected:${binding.binding_id}`);
-            const owner = disposition.downstream_owner;
-            if (owner.resource_key !== disposition.resource_ref ||
-                owner.locator !== selectedResource.locator ||
-                owner.raw_byte_digest !== selectedResource.raw_byte_digest)
-                invalid(`selected_source_owner_identity_mismatch:${binding.binding_id}`);
-            if (selectedResource.identity_kind === "external-immutable") {
-                if (owner.kind !== "external-immutable")
-                    invalid(`external_owner_kind_mismatch:${binding.binding_id}`);
-                current.external_revalidation_required = true;
-                continue;
-            }
-            if (owner.kind !== "selected-source-record")
-                invalid(`selected_source_owner_kind_mismatch:${binding.binding_id}`);
-            const snapshot = await readRecoveryRepositoryFile(repository, owner.locator, `design_resource_recovery_downstream_owner_${binding.binding_id}`);
-            assertDigest(`downstream_owner:${binding.binding_id}`, snapshot.raw_byte_digest, owner.raw_byte_digest);
-        }
-    return current;
-}
-function assertDigest(label, actual, expected) {
-    if (actual !== expected)
-        invalid(`${label}_digest_mismatch:${expected}:${actual}`);
-}
-function invalid(reason) {
-    throw new Error(`design_resource_recovery_invalid:${reason}`);
-}

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

@@ -1,5 +0,0 @@
-export declare const DESIGN_RESOURCE_RECOVERY_INPUT_SCHEMA: "design-resource-recovery-input-v4";
-export declare const DESIGN_RESOURCE_RECOVERY_SCHEMA: "design-resource-recovery-checkpoint-v4";
-export declare const DESIGN_RESOURCE_RECOVERY_AUDIT_SCHEMA: "design-resource-reconciliation-audit-v4";
-export declare const DESIGN_RESOURCE_PATCH_SCHEMA: "design-resource-exact-patch-v4";
-export declare const DESIGN_RESOURCE_AUTHORITY_PROJECTION_SCHEMA: "ty-dra-authority-v1";

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

@@ -1,5 +0,0 @@
-export const DESIGN_RESOURCE_RECOVERY_INPUT_SCHEMA = "design-resource-recovery-input-v4";
-export const DESIGN_RESOURCE_RECOVERY_SCHEMA = "design-resource-recovery-checkpoint-v4";
-export const DESIGN_RESOURCE_RECOVERY_AUDIT_SCHEMA = "design-resource-reconciliation-audit-v4";
-export const DESIGN_RESOURCE_PATCH_SCHEMA = "design-resource-exact-patch-v4";
-export const DESIGN_RESOURCE_AUTHORITY_PROJECTION_SCHEMA = "ty-dra-authority-v1";

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

@@ -1,10 +0,0 @@
-import { type DesignResourceAuthorityIdentity, type DesignResourceAuthoritySourceItem, type DesignResourceDecisionAuthority, type DesignResourceDelegation, type DesignResourceDelta, type DesignResourceRecoveryBase, type DesignResourceRecoveryBaseInput } from "./design-resource-recovery-types.js";
-export declare const DESIGN_RESOURCE_ORIGINS: readonly ["user-direct", "necessary-derived", "repository-evidence-backed", "provider-suggested"];
-export declare const DESIGN_RESOURCE_SEMANTIC_KINDS: readonly ["exact-visual", "product", "business", "permission", "data", "algorithm", "commercial", "safety-security", "technical"];
-export declare function parseRecoveryBaseInput(value: unknown, label: string): DesignResourceRecoveryBaseInput;
-export declare function parseRecoveryBase(value: unknown, label: string): DesignResourceRecoveryBase;
-export declare function parseDelegation(value: unknown, label: string): DesignResourceDelegation;
-export declare function parseAuthoritySourceItem(value: unknown, label: string): DesignResourceAuthoritySourceItem;
-export declare function parseDelta(value: unknown, label: string): DesignResourceDelta;
-export declare function parseAuthorityIdentity(value: unknown, label: string): DesignResourceAuthorityIdentity;
-export declare function parseDecisionAuthority(value: unknown, label: string): DesignResourceDecisionAuthority;