project-tiny-context-harness 0.11.0 → 0.12.0

package/dist/lib/design-resource-implementation-feasibility-validation-support.d.ts

@@ -1,10 +0,0 @@
-import type { DesignResourceImplementationFeasibilityV1, DesignResourceTechnicalSourceRecordV1 } from "./design-resource-implementation-feasibility-types.js";
-export declare function invalidFeasibility(code: string, detail: string): never;
-export declare function unique(values: string[], code: string, detail?: string): void;
-export declare function requireKnownRefs<T>(refs: string[], values: Map<string, T>, code: string, detail?: string): void;
-export declare function requireSourceRole(refs: string[], sources: Map<string, DesignResourceTechnicalSourceRecordV1>, role: DesignResourceTechnicalSourceRecordV1["roles"][number], code: string, detail: string): void;
-export declare function requireAtLeastOneSourceRole(refs: string[], sources: Map<string, DesignResourceTechnicalSourceRecordV1>, role: DesignResourceTechnicalSourceRecordV1["roles"][number], code: string, detail: string): void;
-export declare function assertSameSet(actual: string[], expected: string[], code: string): void;
-export declare function assertNoExactVisualValues(values: string[], detail: string): void;
-export declare function validateNoExactVisualValueCarriers(document: DesignResourceImplementationFeasibilityV1): void;
-export declare function cellPair(familyRef: string, profileRef: string): string;

package/dist/lib/design-resource-implementation-feasibility-validation-support.js

@@ -1,75 +0,0 @@
-const EXACT_VISUAL_VALUE_PATTERNS = [
-    /#[0-9a-f]{3,8}\b/iu,
-    /\b(?:rgb|rgba|hsl|hsla|hwb|lab|lch|oklab|oklch)\s*\(/iu,
-    /\b\d+(?:\.\d+)?(?:px|rem|em|pt|pc|vh|vw|vmin|vmax|ch|ex|deg)\b/iu,
-    /\b(?:color|background|font(?:-family|-size|-weight)?|line-height|border-radius|radius|padding|margin|gap|width|height|opacity|duration|easing|shadow)\s*[:=]\s*\S+/iu,
-    /--[a-z0-9_-]+\s*:\s*\S+/iu,
-];
-const TIME_VALUE_PATTERN = /\b\d+(?:\.\d+)?\s*(?:milliseconds?|msecs?|ms|seconds?|secs?|sec|s)\b/giu;
-const MOTION_TIME_CONTEXT = /\b(?:animation|transition|motion|duration|delay|easing|timeline|keyframes?|fade|spring|stagger|enter|exit|hover|press|ease(?:-in|-out|-in-out)?)\b/iu;
-const TECHNICAL_TIME_CONTEXT = /\b(?:build|compile|bundle|generation|ci|tests?|startup|initialization|latency|timeout|network|benchmark|runtime\s+cost|render\s+cost|benchmark\s+execution)\b/iu;
-const TIME_CONTEXT_RADIUS = 80;
-export function invalidFeasibility(code, detail) {
-    throw new Error(`design_resource_implementation_feasibility_invalid:${code}${detail ? `:${detail}` : ""}`);
-}
-export function unique(values, code, detail = "") {
-    if (new Set(values).size !== values.length)
-        invalidFeasibility(code, detail || values.join(","));
-}
-export function requireKnownRefs(refs, values, code, detail = "") {
-    for (const ref of refs)
-        if (!values.has(ref))
-            invalidFeasibility(code, detail ? `${detail}:${ref}` : ref);
-}
-export function requireSourceRole(refs, sources, role, code, detail) {
-    requireKnownRefs(refs, sources, code, detail);
-    for (const ref of refs)
-        if (!sources.get(ref).roles.includes(role))
-            invalidFeasibility(code, `${detail}:${ref}:${role}`);
-}
-export function requireAtLeastOneSourceRole(refs, sources, role, code, detail) {
-    if (!refs.some((ref) => sources.get(ref)?.roles.includes(role)))
-        invalidFeasibility(code, `${detail}:${role}`);
-}
-export function assertSameSet(actual, expected, code) {
-    const left = [...actual].sort(compareText);
-    const right = [...expected].sort(compareText);
-    if (left.length !== right.length ||
-        left.some((value, index) => value !== right[index]))
-        invalidFeasibility(code, `${left.join(",")}:${right.join(",")}`);
-}
-export function assertNoExactVisualValues(values, detail) {
-    for (const value of values)
-        if (EXACT_VISUAL_VALUE_PATTERNS.some((pattern) => pattern.test(value)) ||
-            hasForbiddenTimeValue(value))
-            invalidFeasibility("exact_visual_value_forbidden", detail);
-}
-function hasForbiddenTimeValue(value) {
-    for (const match of value.matchAll(TIME_VALUE_PATTERN)) {
-        const index = match.index;
-        const context = value.slice(Math.max(0, index - TIME_CONTEXT_RADIUS), Math.min(value.length, index + match[0].length + TIME_CONTEXT_RADIUS));
-        if (MOTION_TIME_CONTEXT.test(context))
-            return true;
-        if (!TECHNICAL_TIME_CONTEXT.test(context))
-            return true;
-    }
-    return false;
-}
-export function validateNoExactVisualValueCarriers(document) {
-    for (const observation of document.substrate_observations)
-        if (observation.reason !== null)
-            assertNoExactVisualValues([observation.reason], `substrate_observation:${observation.kind}:reason`);
-    for (const cell of document.component_family_cells)
-        for (const realization of cell.feasible_realizations) {
-            assertNoExactVisualValues(realization.observed_costs, `realization:${realization.key}:observed_costs`);
-            assertNoExactVisualValues(realization.observed_risks, `realization:${realization.key}:observed_risks`);
-        }
-    for (const blocker of document.blockers)
-        assertNoExactVisualValues([blocker.description], `blocker:${blocker.key}:description`);
-}
-export function cellPair(familyRef, profileRef) {
-    return `${familyRef}\0${profileRef}`;
-}
-function compareText(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}

package/dist/lib/design-resource-implementation-feasibility-validation.d.ts

@@ -1,3 +0,0 @@
-import type { DesignResourceTechnicalFeasibilityInputV1, LoadedDesignResourceImplementationFeasibilityV1 } from "./design-resource-implementation-feasibility-types.js";
-import type { DesignResourceImplementationFeasibilityTargetModel } from "./design-resource-implementation-feasibility-model.js";
-export declare function readAndValidateDesignResourceImplementationFeasibility(repository: string, handoffPath: string, inputs: DesignResourceTechnicalFeasibilityInputV1[], targetModels: Map<string, DesignResourceImplementationFeasibilityTargetModel>, canonicalResourcePaths: Set<string>): Promise<LoadedDesignResourceImplementationFeasibilityV1[]>;

package/dist/lib/design-resource-implementation-feasibility-validation.js

@@ -1,138 +0,0 @@
-import { readFile, stat } from "node:fs/promises";
-import path from "node:path";
-import { parseDesignResourceImplementationFeasibilityJson } from "./design-resource-implementation-feasibility-shape.js";
-import { loadDesignResourceFeasibilityDecisionSource, } from "./design-resource-implementation-feasibility-source-decision.js";
-import { validateFeasibilityDocument } from "./design-resource-implementation-feasibility-validation-document.js";
-import { invalidFeasibility, unique, } from "./design-resource-implementation-feasibility-validation-support.js";
-import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
-import { sha256Hex } from "./strict-codec.js";
-const FEASIBILITY_MAX_BYTES = 2_097_152;
-const TECHNICAL_SOURCE_MAX_BYTES = 16_777_216;
-export async function readAndValidateDesignResourceImplementationFeasibility(repository, handoffPath, inputs, targetModels, canonicalResourcePaths) {
-    unique(inputs.map((item) => item.key), "input_key_duplicate");
-    unique(inputs.map((item) => item.path), "input_path_duplicate");
-    unique(inputs.map((item) => item.target_ref), "input_target_duplicate");
-    for (const input of inputs)
-        if (!targetModels.has(input.target_ref))
-            invalidFeasibility("input_target_unknown", input.target_ref);
-    validateTargetInputCoverage(inputs, targetModels);
-    const loaded = [];
-    const sourcePathIdentities = new Map();
-    for (const input of inputs) {
-        const model = targetModels.get(input.target_ref);
-        if (!model)
-            invalidFeasibility("input_target_unknown", input.target_ref);
-        if (input.path === handoffPath)
-            invalidFeasibility("input_must_not_be_handoff", input.key);
-        if (canonicalResourcePaths.has(input.path))
-            invalidFeasibility("input_mixed_into_canonical_resources", input.path);
-        const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...input.path.split("/")), `design_resource_feasibility:${input.key}`);
-        const size = (await stat(file)).size;
-        if (size > FEASIBILITY_MAX_BYTES)
-            invalidFeasibility("input_byte_limit_exceeded", `${input.key}:bytes=${size}:limit=${FEASIBILITY_MAX_BYTES}`);
-        const bytes = await readFile(file);
-        const digest = sha256Hex(bytes);
-        if (digest !== input.sha256)
-            invalidFeasibility("input_digest_mismatch", `${input.key}:${input.sha256}:${digest}`);
-        const content = bytes.toString("utf8");
-        if (!Buffer.from(content, "utf8").equals(bytes))
-            invalidFeasibility("input_utf8_invalid", input.key);
-        const document = parseDesignResourceImplementationFeasibilityJson(content);
-        if (document.key !== input.key)
-            invalidFeasibility("input_key_mismatch", `${input.key}:${document.key}`);
-        if (document.target_ref !== input.target_ref)
-            invalidFeasibility("input_target_mismatch", `${input.target_ref}:${document.target_ref}`);
-        const decisionSources = await validateTechnicalSourceRecords(repository, handoffPath, input.path, document.source_records, canonicalResourcePaths, sourcePathIdentities);
-        await validateFeasibilityDocument(repository, document, model, decisionSources);
-        loaded.push({
-            index: input,
-            document,
-            identity: {
-                key: input.key,
-                target_ref: input.target_ref,
-                path: input.path,
-                sha256: digest,
-                realization_mode: document.realization_mode,
-                component_family_cells: document.component_family_cells.length,
-                blockers: document.blockers.length,
-            },
-        });
-    }
-    return loaded;
-}
-function validateTargetInputCoverage(inputs, targetModels) {
-    if (!inputs.length)
-        return;
-    const indexedTargets = new Set(inputs.map((item) => item.target_ref));
-    for (const model of targetModels.values())
-        if (model.source_profile_kind !== "reference" &&
-            !indexedTargets.has(model.target_ref))
-            invalidFeasibility("implementation_target_input_missing", model.target_ref);
-}
-async function validateTechnicalSourceRecords(repository, handoffPath, inputPath, records, canonicalResourcePaths, sharedPathIdentities) {
-    const decisionSources = new Map();
-    unique(records.map((item) => item.key), "source_record_key_duplicate");
-    unique(records.map((item) => `${item.path}\0${item.locator.kind}\0${item.locator.value}`), "source_record_locator_duplicate");
-    for (const record of records) {
-        if (!record.roles.length)
-            invalidFeasibility("source_record_roles_required", record.key);
-        unique(record.roles, "source_record_role_duplicate", record.key);
-        if (record.path === handoffPath || record.path === inputPath)
-            invalidFeasibility("source_record_self_reference", `${record.key}:${record.path}`);
-        if (canonicalResourcePaths.has(record.path))
-            invalidFeasibility("technical_source_mixed_into_canonical_resources", record.path);
-        validateSharedSourceIdentity(record, sharedPathIdentities);
-        const file = await assertProtectedRepositoryFile(repository, path.resolve(repository, ...record.path.split("/")), `design_resource_feasibility_source:${record.key}`);
-        const size = (await stat(file)).size;
-        if (size > TECHNICAL_SOURCE_MAX_BYTES)
-            invalidFeasibility("source_record_byte_limit_exceeded", `${record.key}:bytes=${size}:limit=${TECHNICAL_SOURCE_MAX_BYTES}`);
-        const bytes = await readFile(file);
-        const digest = sha256Hex(bytes);
-        if (digest !== record.sha256)
-            invalidFeasibility("source_record_digest_mismatch", `${record.key}:${record.sha256}:${digest}`);
-        const decisionSource = validateSourceLocator(record, bytes);
-        if (decisionSource)
-            decisionSources.set(record.key, decisionSource);
-    }
-    return decisionSources;
-}
-function validateSharedSourceIdentity(record, sharedPathIdentities) {
-    const identity = `${record.media_type}\0${record.sha256}`;
-    const previous = sharedPathIdentities.get(record.path);
-    if (previous && previous !== identity)
-        invalidFeasibility("source_record_path_identity_conflict", record.path);
-    sharedPathIdentities.set(record.path, identity);
-}
-function validateSourceLocator(record, bytes) {
-    if (record.locator.kind === "whole_resource")
-        return null;
-    const content = bytes.toString("utf8");
-    if (!Buffer.from(content, "utf8").equals(bytes))
-        invalidFeasibility("source_record_utf8_invalid", record.key);
-    if (record.locator.kind === "source_item")
-        return loadDesignResourceFeasibilityDecisionSource(record, content);
-    if (record.locator.kind === "json_pointer") {
-        validateJsonPointer(record, content);
-        return null;
-    }
-    if (!content.includes(record.locator.value))
-        invalidFeasibility("source_record_locator_unresolved", `${record.key}:${record.locator.value}`);
-    return null;
-}
-function validateJsonPointer(record, content) {
-    let current;
-    try {
-        current = JSON.parse(content);
-    }
-    catch {
-        invalidFeasibility("source_record_json_invalid", record.key);
-    }
-    for (const raw of record.locator.value.slice(1).split("/")) {
-        const segment = raw.replace(/~1/gu, "/").replace(/~0/gu, "~");
-        if (!current ||
-            typeof current !== "object" ||
-            !Object.hasOwn(current, segment))
-            invalidFeasibility("source_record_locator_unresolved", `${record.key}:${record.locator.value}`);
-        current = current[segment];
-    }
-}

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

@@ -1,2 +0,0 @@
-import type { DesignResourceReconciliationAudit } from "./design-resource-reconciliation-types.js";
-export declare function parseDesignResourceReconciliationAudit(content: string): DesignResourceReconciliationAudit;

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

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

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

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

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

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