project-tiny-context-harness 0.8.17 → 0.12.0

package/dist/lib/long-task-status-v2.js

@@ -1,351 +0,0 @@
-import path from "node:path";
-import { compileDeliveryContract } from "./long-task-delivery-compiler.js";
-import { authorityRevisionDecisionNextAction } from "./long-task-authority-revision-brief.js";
-import { projectAuthorityRevisionDecision } from "./long-task-authority-revision-summary.js";
-import { runDeliveryFinalGate } from "./long-task-final-v2.js";
-import { deliveryCompileFreshness } from "./long-task-freshness.js";
-import { activeAuthorityLockExists, clearActiveBindingCas, inspectCompiledCache, loadActiveLongTaskAuthority, readActiveLongTaskBinding, readFinalReceipt, readPendingAuthorityRevision, readProgressRecords, } from "./long-task-state.js";
-import { projectDeliveryStatus, } from "./long-task-status-projection.js";
-import { captureWorkspaceManifest, currentGitState, repositoryRoot, } from "./long-task-workspace.js";
-export async function readDeliveryStatus(workdir) {
-    const root = await repositoryRoot(process.cwd());
-    const loaded = await loadActiveLongTaskAuthority(root);
-    const active = loaded.authority;
-    if (!active)
-        throw new Error("active_task_missing");
-    if (active.workdir !== path.resolve(workdir))
-        throw new Error("active_task_workdir_mismatch");
-    return readDeliveryStatusForAuthority(active);
-}
-async function readDeliveryStatusForAuthority(active) {
-    const compiled = active.authority_snapshot;
-    const cacheStatus = await inspectCompiledCache(active);
-    const current = await captureWorkspaceManifest(compiled.repository_root, compiled.workdir);
-    const stale = await deliveryCompileFreshness(compiled);
-    const [progress, pending] = await Promise.all([
-        readProgressRecords(active.workdir),
-        readPendingAuthorityRevision(active.workdir),
-    ]);
-    let receipt = null;
-    let receiptError = null;
-    try {
-        receipt = await readFinalReceipt(compiled.repository_root, compiled.workdir);
-    }
-    catch (error) {
-        receiptError = message(error);
-    }
-    const projection = projectDeliveryStatus({
-        compiled,
-        manifest: current,
-        stale,
-        progress,
-        receipt,
-        receiptError,
-    });
-    return {
-        schema_version: "long-task-status-v2",
-        task_id: compiled.task.id,
-        compiled_identity: compiled.compiled_identity,
-        effective_risk: compiled.effective_risk,
-        workspace_snapshot_sha256: current.snapshot_sha256,
-        acceptance_authority: "live_final_gate_required",
-        acceptance_scope: "declared_machine_authority",
-        native_goal_effect: "none",
-        final_result: projection.finalResult,
-        final_workflow_status: projection.finalWorkflowStatus,
-        external_confirmations: compiled.global.acceptance.external_confirmations,
-        target_profile: compiled.task.target_profile,
-        target_state: projection.targetState,
-        outcomes: projection.outcomes,
-        stages: projection.stages,
-        ready_stages: projection.readyStages,
-        ready_outcomes: projection.readyOutcomes,
-        ready_for_implementation: projection.readyOutcomes,
-        needs_reverify: projection.needsReverify,
-        progress_passing: projection.progressPassing,
-        progress_failing: projection.progressFailing,
-        pending_authority_revision: pending
-            ? projectAuthorityRevisionDecision(pending)
-            : null,
-        findings: [
-            ...projection.findings,
-            ...(cacheStatus === "compiled_cache_matching"
-                ? []
-                : [cacheDiagnostic(cacheStatus)]),
-        ],
-    };
-}
-export async function resumeDeliveryTask(workdir) {
-    const root = await repositoryRoot(process.cwd());
-    const loaded = await loadActiveLongTaskAuthority(root);
-    const active = loaded.authority;
-    if (!active)
-        throw new Error("active_task_missing");
-    if (active.workdir !== path.resolve(workdir))
-        throw new Error("active_task_workdir_mismatch");
-    const compiled = active.authority_snapshot;
-    // Status capture runs git write-tree; finish it before git status can refresh
-    // the same repository index inside currentGitState.
-    const status = await readDeliveryStatusForAuthority(active);
-    const git = await currentGitState(compiled.repository_root);
-    return {
-        schema_version: "long-task-resume-v2",
-        task: {
-            id: compiled.task.id,
-            title: compiled.task.title,
-            goal: compiled.task.goal,
-            target_profile: compiled.task.target_profile,
-            execution_targets: compiled.task.execution_targets,
-        },
-        contract_identity: compiled.compiled_identity,
-        authority_revision: compiled.authority_revision,
-        effective_risk: compiled.effective_risk,
-        context_refs: compiled.task.context_refs,
-        git,
-        acceptance_authority: "live_final_gate_required",
-        acceptance_scope: "declared_machine_authority",
-        native_goal_effect: "none",
-        last_gate: status.final_result,
-        final_workflow_status: status.final_workflow_status,
-        external_confirmations: status.external_confirmations,
-        target_profile: status.target_profile,
-        target_state: status.target_state,
-        outcomes: status.outcomes,
-        stages: status.stages,
-        ready_stages: status.ready_stages,
-        ready_outcomes: status.ready_outcomes,
-        ready_for_implementation: status.ready_for_implementation,
-        needs_reverify: status.needs_reverify,
-        progress_passing: status.progress_passing,
-        progress_failing: status.progress_failing,
-        pending_authority_revision: status.pending_authority_revision,
-        recent_findings: status.findings,
-        next_safe_action: nextAction(status),
-    };
-}
-export async function doctorDeliveryTask(workdirInput) {
-    const root = await repositoryRoot(process.cwd());
-    let loaded;
-    try {
-        loaded = await loadActiveLongTaskAuthority(root);
-    }
-    catch (error) {
-        const finding = doctorAuthorityFinding(message(error));
-        return {
-            schema_version: "long-task-doctor-v2",
-            status: finding,
-            healthy: false,
-            findings: [finding],
-            next_action: `ty-context long-task abandon ${path.resolve(workdirInput)} --force-corrupt-state`,
-        };
-    }
-    const active = loaded.authority;
-    if (!active)
-        return { status: "no_active_task", healthy: true };
-    if (active.workdir !== path.resolve(workdirInput))
-        throw new Error("active_task_workdir_mismatch");
-    const findings = [
-        "active_authority_valid",
-        await inspectCompiledCache(active),
-    ];
-    if (await activeAuthorityLockExists(root))
-        findings.push("active_authority_lock_present");
-    let currentAuthorityIdentity = null;
-    try {
-        const compiled = await compileDeliveryContract(active.workdir, root, {
-            live_gate: true,
-            initial_task_base: active.initial_task_base,
-            authority_revision: active.authority_revision,
-            require_completion_gate: true,
-        });
-        currentAuthorityIdentity = compiled.compiled_identity;
-        if (compiled.compiled_identity !== active.active_authority_identity)
-            findings.push("active_authority_source_mismatch");
-    }
-    catch (error) {
-        findings.push(`active_authority_source_invalid:${message(error)}`);
-    }
-    return {
-        schema_version: "long-task-doctor-v2",
-        status: findings[0],
-        healthy: !findings.some((finding) => finding === "active_authority_lock_present" ||
-            finding === "active_authority_source_mismatch" ||
-            finding.startsWith("active_authority_source_invalid:")),
-        task_id: active.task_id,
-        authority_revision: active.authority_revision,
-        marker_and_record: "matched",
-        contract: "available",
-        current_authority_identity: currentAuthorityIdentity,
-        active_authority_identity: active.active_authority_identity,
-        verifier_identity: active.verifier_identity.bundle_sha256,
-        hook: "available",
-        source_context_fresh: !findings.some((finding) => finding.startsWith("active_authority_source_")),
-        compiled_cache: findings.find((finding) => finding.startsWith("compiled_cache_")),
-        findings,
-        ...(findings.includes("active_authority_lock_present")
-            ? {
-                next_action: `ty-context long-task abandon ${path.resolve(workdirInput)} --force-corrupt-state`,
-            }
-            : {}),
-    };
-}
-export async function stopCheckDeliveryTask(workdirInput, messageText = "") {
-    const root = await repositoryRoot(process.cwd());
-    let active;
-    try {
-        active = await readActiveLongTaskBinding(root);
-    }
-    catch (error) {
-        return {
-            continue: false,
-            reason: "long_task_state_invalid",
-            message: message(error),
-        };
-    }
-    if (!active)
-        return { continue: true, reason: "no_active_task" };
-    if (active.workdir !== path.resolve(workdirInput))
-        return { continue: false, reason: "active_task_workdir_mismatch" };
-    try {
-        const result = await runDeliveryFinalGate(active.workdir);
-        if (result.workflow_status === "machine_accepted" ||
-            result.workflow_status === "machine_accepted_external_pending") {
-            try {
-                await clearActiveBindingCas({
-                    repository_root: root,
-                    workdir: active.workdir,
-                    task_id: active.task_id,
-                    authority_revision: active.authority_revision,
-                    compiled_identity: active.active_authority_identity,
-                    worktree_identity: active.worktree_identity,
-                });
-            }
-            catch (error) {
-                if (message(error).includes("active_authority_clear_compare_and_swap_failed"))
-                    return {
-                        continue: false,
-                        reason: "active_authority_changed_after_final_gate",
-                        workflow_status: result.workflow_status,
-                        external_confirmations: result.external_confirmations,
-                        target_profile: result.target_profile,
-                        target_state: result.target_state,
-                        stage_results: result.stage_results,
-                        message: "Active Authority changed after the Live Final Gate; the accepted identity was not cleared.",
-                    };
-                throw error;
-            }
-            return {
-                continue: true,
-                reason: result.workflow_status,
-                workflow_status: result.workflow_status,
-                external_confirmations: result.external_confirmations,
-                target_profile: result.target_profile,
-                target_state: result.target_state,
-                stage_results: result.stage_results,
-                acceptance_scope: "declared_machine_authority",
-                native_goal_effect: "none",
-                message: acceptedScopeMessage(result.workflow_status, result.external_confirmations, result.target_profile),
-            };
-        }
-        return {
-            continue: false,
-            reason: `live_final_gate_${result.workflow_status}`,
-            workflow_status: result.workflow_status,
-            external_confirmations: result.external_confirmations,
-            target_profile: result.target_profile,
-            target_state: result.target_state,
-            stage_results: result.stage_results,
-            message: messageText ||
-                result.findings.at(-1)?.next_action ||
-                "Repair the failing Check and rerun Stop.",
-        };
-    }
-    catch (error) {
-        if (message(error).includes("verifier_authority_migration_required"))
-            return {
-                continue: false,
-                reason: "verifier_authority_migration_required",
-            };
-        return {
-            continue: false,
-            reason: "live_final_gate_error",
-            message: message(error),
-        };
-    }
-}
-export async function closeDeliveryTask(workdir) {
-    const root = await repositoryRoot(process.cwd());
-    const active = await readActiveLongTaskBinding(root);
-    if (!active || active.workdir !== path.resolve(workdir))
-        throw new Error("active_task_missing_or_mismatched");
-    const result = await runDeliveryFinalGate(active.workdir);
-    if (result.workflow_status !== "machine_accepted" &&
-        result.workflow_status !== "machine_accepted_external_pending")
-        throw new Error(`close_live_final_gate_failed:${result.workflow_status}`);
-    await clearActiveBindingCas({
-        repository_root: root,
-        workdir: active.workdir,
-        task_id: active.task_id,
-        authority_revision: active.authority_revision,
-        compiled_identity: active.active_authority_identity,
-        worktree_identity: active.worktree_identity,
-    });
-    return {
-        status: "closed",
-        workflow_status: result.workflow_status,
-        external_confirmations: result.external_confirmations,
-        target_profile: result.target_profile,
-        target_state: result.target_state,
-        stage_results: result.stage_results,
-        acceptance_scope: "declared_machine_authority",
-        closed_scope: "machine_authority",
-        native_goal_effect: "none",
-    };
-}
-function acceptedScopeMessage(workflowStatus, confirmations, targetProfile) {
-    const scope = `Declared machine Authority accepted for target ${targetProfile.key}:${targetProfile.required_state} and cleared. This result has no direct effect on the platform-native Goal; before completing it, confirm current Goal/user meaning is fully represented by accepted Source and no revision, blocker, or omitted requirement remains.`;
-    if (workflowStatus === "machine_accepted")
-        return scope;
-    const pending = confirmations
-        .map((confirmation) => `${confirmation.key} (${confirmation.owner})`)
-        .join(", ");
-    return `${scope} Complete external delivery remains pending: ${pending}. Do not report complete external delivery.`;
-}
-function nextAction(status) {
-    if (status.pending_authority_revision)
-        return authorityRevisionDecisionNextAction(status.pending_authority_revision);
-    if (status.findings.length)
-        return status.findings.at(-1).next_action;
-    if (status.ready_outcomes.length) {
-        const outcome = status.ready_outcomes[0];
-        if (status.outcomes[outcome] === "progress_stale")
-            return `Targeted evidence for Outcome ${outcome} on the acceptance/verification frontier is stale. This is a freshness fact, not an implementation gate or immediate per-edit rerun instruction: coalesce relevant changes and refresh the cheapest reliable declared Check only before relying on this Progress. Implementation may continue, and Final Gate needs no targeted refresh because it reruns every Check.`;
-        return `Outcome ${outcome} is on the advisory acceptance/verification frontier. Implementation order remains Goal-owned; run its declared Check when the feedback value justifies the cost, or continue in-scope implementation before the complete Final Gate.`;
-    }
-    return "Create a clean candidate commit; Stop will run the authoritative Live Final Gate.";
-}
-function message(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-function cacheDiagnostic(code) {
-    return {
-        code,
-        outcome_key: null,
-        check_key: null,
-        message: code === "compiled_cache_missing_repairable"
-            ? "The compiled cache projection is missing; active authority remains valid."
-            : "The compiled cache projection does not match active authority and was ignored.",
-        next_action: "Run ty-context long-task compile to rebuild the cache projection from active authority.",
-    };
-}
-function doctorAuthorityFinding(error) {
-    if (error.includes("legacy_v2_active_authority_manual_required"))
-        return "legacy_v2_active_authority_manual_required";
-    if (error.includes("active_authority_continuity_unrecoverable"))
-        return "active_authority_continuity_unrecoverable";
-    if (error.includes("marker") ||
-        error.includes("active_binding_marker") ||
-        error.includes("active_binding_record_missing"))
-        return "marker_record_mismatch";
-    return "active_authority_invalid";
-}

package/dist/lib/long-task-target-policy.d.ts

@@ -1,6 +0,0 @@
-import { type CompiledClaimsV2 } from "./long-task-claims.js";
-import type { DeliveryContractV2 } from "./long-task-delivery-types.js";
-type Reporter = (message: string) => void;
-export declare function validateExecutionTargets(contract: DeliveryContractV2, report?: Reporter): void;
-export declare function validateExternalConfirmationImpacts(contract: DeliveryContractV2, claims: CompiledClaimsV2, report?: Reporter): void;
-export {};

package/dist/lib/long-task-target-policy.js

@@ -1,150 +0,0 @@
-import { outcomeResultExternallyBlocked, } from "./long-task-claims.js";
-const FAMILY_CAPABILITY = {
-    browser: "browser-runtime",
-    native: "native-runtime",
-    desktop: "desktop-runtime",
-    service: "service-runtime",
-    process: "process-runtime",
-    external: "external-runtime",
-};
-export function validateExecutionTargets(contract, report) {
-    const targets = indexExecutionTargets(contract, report);
-    const requiredTargetRefs = contract.task.target_profile.required_target_refs;
-    validateRequiredTargetRefs(contract, targets, report);
-    for (const [outcomeKey, check] of allChecks(contract))
-        validateCheckTarget(outcomeKey, check, targets, report);
-    validateCriticalPathTargets(contract, requiredTargetRefs, report);
-}
-function indexExecutionTargets(contract, report) {
-    const targets = new Map();
-    for (const target of contract.task.execution_targets) {
-        if (targets.has(target.key))
-            issue(report, "execution_target_key_duplicate", target.key);
-        targets.set(target.key, target);
-        if (!target.capabilities.length)
-            issue(report, "execution_target_capability_required", target.key);
-        if (new Set(target.capabilities).size !== target.capabilities.length)
-            issue(report, "execution_target_capability_duplicate", target.key);
-        const familyCapability = FAMILY_CAPABILITY[target.runtime_family];
-        if (!target.capabilities.includes(familyCapability))
-            issue(report, "execution_target_family_capability_required", `${target.key}:${familyCapability}`);
-    }
-    if (![...targets.values()].some((target) => target.role === "product"))
-        issue(report, "product_execution_target_required", contract.task.id);
-    return targets;
-}
-function validateRequiredTargetRefs(contract, targets, report) {
-    const required = contract.task.target_profile.required_target_refs;
-    if (!required.length)
-        issue(report, "target_profile_required_target_refs_required", contract.task.id);
-    if (new Set(required).size !== required.length)
-        issue(report, "target_profile_required_target_refs_duplicate", contract.task.id);
-    for (const targetRef of required) {
-        const target = targets.get(targetRef);
-        if (!target)
-            issue(report, "target_profile_required_target_ref_unknown", targetRef);
-        else if (target.role !== "product")
-            issue(report, "target_profile_required_target_must_be_product", targetRef);
-        else {
-            for (const capability of ["cold-start", "production-root"])
-                if (!target.capabilities.includes(capability))
-                    issue(report, "required_target_capability_missing", `${targetRef}:${capability}`);
-        }
-    }
-}
-function validateCheckTarget(outcomeKey, check, targets, report) {
-    const target = targets.get(check.execution_target.target_ref);
-    const label = `${outcomeKey ?? "GLOBAL"}:${check.key}`;
-    if (!target) {
-        issue(report, "check_execution_target_unknown", `${label}:${check.execution_target.target_ref}`);
-        return;
-    }
-    if ((check.runner.type === "playwright_test" ||
-        check.proof_surface === "ui_browser") &&
-        target.runtime_family !== "browser")
-        issue(report, "browser_check_target_mismatch", `${label}:${target.key}`);
-    if (provesTargetRuntime(check) &&
-        target.runtime_family === "browser" &&
-        check.runner.type !== "playwright_test")
-        issue(report, "browser_target_runtime_requires_playwright", `${label}:${target.key}`);
-    if (provesTargetRuntime(check) &&
-        ["native", "desktop"].includes(target.runtime_family) &&
-        check.runner.type !== "project_binary")
-        issue(report, "native_target_runtime_requires_project_binary", `${label}:${target.key}`);
-    validateStageGateTarget(label, check, target, report);
-    validateConformanceTarget(outcomeKey, check, target, report);
-}
-function validateStageGateTarget(label, check, target, report) {
-    if (!check.journey_roles.includes("stage_gate"))
-        return;
-    if (target.role !== "product")
-        issue(report, "stage_gate_product_target_required", `${label}:${target.key}`);
-    if (check.execution_target.entrypoint !== "root")
-        issue(report, "stage_gate_root_entrypoint_required", label);
-}
-function validateConformanceTarget(outcomeKey, check, target, report) {
-    if (!check.journey_roles.includes("conformance"))
-        return;
-    if (outcomeKey !== null)
-        issue(report, "conformance_check_must_be_global", `${outcomeKey}:${check.key}`);
-    if (target.role !== "product" || check.execution_target.entrypoint !== "root")
-        issue(report, "conformance_root_product_target_required", check.key);
-}
-function validateCriticalPathTargets(contract, requiredTargetRefs, report) {
-    for (const outcomeKey of contract.risk.facts.critical_user_path) {
-        const outcome = contract.outcomes.find((candidate) => candidate.key === outcomeKey);
-        if (!outcome)
-            continue;
-        if (outcomeResultExternallyBlocked(contract, outcome.key))
-            continue;
-        for (const targetRef of requiredTargetRefs)
-            if (!outcome.acceptance.checks.some((check) => provesSuccess(check, targetRef)))
-                issue(report, "critical_path_required_target_proof_missing", `${outcome.key}:${targetRef}`);
-    }
-}
-function provesSuccess(check, targetRef) {
-    return (check.execution_target.target_ref === targetRef &&
-        check.journey_roles.includes("success") &&
-        check.execution_target.entrypoint === "root" &&
-        provesTargetRuntime(check));
-}
-function provesTargetRuntime(check) {
-    return [...check.positive_assertions, ...check.negative_assertions].some((assertion) => assertion.evidence_capabilities.includes("target_runtime"));
-}
-export function validateExternalConfirmationImpacts(contract, claims, report) {
-    const claimRefs = new Set();
-    for (const [outcomeKey, values] of Object.entries(claims.by_outcome))
-        for (const claim of values)
-            claimRefs.add(`${outcomeKey}.${claim.local_key}`);
-    for (const claim of claims.by_global)
-        claimRefs.add(`GLOBAL.${claim.local_key}`);
-    for (const confirmation of contract.global.acceptance
-        .external_confirmations) {
-        if (!confirmation.impact_claims.length)
-            issue(report, "external_confirmation_impact_required", confirmation.key);
-        for (const claim of confirmation.impact_claims)
-            if (!claimRefs.has(claim))
-                issue(report, "external_confirmation_impact_unknown", `${confirmation.key}:${claim}`);
-        if (confirmation.kind === "functional_prerequisite" &&
-            !confirmation.blocks_target)
-            issue(report, "functional_prerequisite_must_block_target", confirmation.key);
-        if (confirmation.kind === "production_release_gate" &&
-            contract.task.target_profile.required_state ===
-                "production_release_ready" &&
-            !confirmation.blocks_target)
-            issue(report, "production_gate_must_block_release_target", confirmation.key);
-    }
-}
-function allChecks(contract) {
-    return [
-        ...contract.global.acceptance.checks.map((check) => [null, check]),
-        ...contract.outcomes.flatMap((outcome) => outcome.acceptance.checks.map((check) => [outcome.key, check])),
-    ];
-}
-function issue(report, code, detail) {
-    const message = `delivery_contract_invalid:${code}:${detail}`;
-    if (report)
-        report(message);
-    else
-        throw new Error(message);
-}

package/dist/lib/long-task-technical-shape.d.ts

@@ -1,3 +0,0 @@
-import type { DeliveryBindingV2, RollbackRecoveryV2 } from "./long-task-delivery-types.js";
-export declare function parseBindings(value: unknown, label: string): DeliveryBindingV2[];
-export declare function parseRollback(value: unknown, label: string): RollbackRecoveryV2;

package/dist/lib/long-task-technical-shape.js

@@ -1,44 +0,0 @@
-import { array, fail, key, literal, object, repositoryFile, repositoryPattern, repositoryPatterns, string, strings, } from "./long-task-shape-primitives.js";
-export function parseBindings(value, label) {
-    return array(value, label).map((item, index) => {
-        const itemLabel = `${label}[${index}]`;
-        const row = object(item, itemLabel, ["key", "kind", "target", "carrier_paths"], ["existence", "verification_check_key"]);
-        const kindValue = literal(row.kind, ["path_glob", "file", "verified"], `${itemLabel}.kind`);
-        const verificationCheckKey = Object.hasOwn(row, "verification_check_key")
-            ? key(row.verification_check_key, `${itemLabel}.verification_check_key`)
-            : undefined;
-        if (kindValue === "verified" && !verificationCheckKey)
-            fail(`${itemLabel}.verification_check_key`, "is required for verified");
-        if (kindValue !== "verified" && verificationCheckKey)
-            fail(`${itemLabel}.verification_check_key`, "is only allowed for verified");
-        const target = kindValue === "file"
-            ? repositoryFile(row.target, `${itemLabel}.target`)
-            : kindValue === "path_glob"
-                ? repositoryPattern(row.target, `${itemLabel}.target`)
-                : string(row.target, `${itemLabel}.target`);
-        return {
-            key: key(row.key, `${itemLabel}.key`),
-            kind: kindValue,
-            target,
-            carrier_paths: repositoryPatterns(row.carrier_paths, `${itemLabel}.carrier_paths`),
-            existence: Object.hasOwn(row, "existence")
-                ? literal(row.existence, ["existing", "planned"], `${itemLabel}.existence`)
-                : "existing",
-            ...(verificationCheckKey
-                ? { verification_check_key: verificationCheckKey }
-                : {}),
-        };
-    });
-}
-export function parseRollback(value, label) {
-    const row = object(value, label, [
-        "rollback",
-        "recovery",
-        "verification_check_keys",
-    ]);
-    return {
-        rollback: string(row.rollback, `${label}.rollback`),
-        recovery: string(row.recovery, `${label}.recovery`),
-        verification_check_keys: strings(row.verification_check_keys, `${label}.verification_check_keys`),
-    };
-}

package/dist/lib/long-task-ui-design-policy.d.ts

@@ -1,17 +0,0 @@
-import type { CompiledClaimsV2 } from "./long-task-claims.js";
-import type { DeliveryCheckV2, DeliveryContractV2, DeliveryOutcomeV2, ProductClaimV2 } from "./long-task-delivery-types.js";
-import { type Reporter } from "./long-task-ui-surface-validation.js";
-interface UiDesignBindingContext {
-    outcome: DeliveryOutcomeV2;
-    binding: DeliveryOutcomeV2["product"]["surface_bindings"][number];
-    outcomeClaims: Map<string, ProductClaimV2>;
-    claims: CompiledClaimsV2;
-    checks: Map<string, DeliveryCheckV2>;
-    confirmations: Map<string, DeliveryContractV2["global"]["acceptance"]["external_confirmations"][number]>;
-    carriers: string[];
-    designTargetKeys: Set<string>;
-    designAssertionRefs: Set<string>;
-    report?: Reporter;
-}
-export declare function validateUiDesignBinding(context: UiDesignBindingContext): void;
-export {};