project-tiny-context-harness 0.2.84 → 0.6.0

package/dist/lib/long-task-authority-types.d.ts

@@ -0,0 +1,96 @@
+import type { ProofSurface } from "./long-task-contract-types.js";
+import type { CompiledSourceItemV2 } from "./long-task-source-authority-types.js";
+import type { WorkspaceManifestV2 } from "./long-task-workspace-runtime-types.js";
+export interface AuthorityHashesV2 {
+    source_authority_hash: string;
+    product_authority_hash: string;
+    acceptance_authority_hash: string;
+    risk_authority_hash: string;
+    technical_authority_hash: string;
+}
+export interface ProductSemanticProjectionV2 {
+    task_goal: string;
+    global_non_goals: Array<{
+        key: string;
+        statement: string;
+    }>;
+    outcomes: Array<{
+        key: string;
+        title: string;
+        observable_result: string;
+        owner: {
+            label: string;
+            owner_surfaces: string[];
+        };
+        requirements: Array<{
+            key: string;
+            statement: string;
+            required_proof_surfaces: ProofSurface[];
+        }>;
+        controls: Array<{
+            key: string;
+            location: string;
+            trigger: string;
+            input: string;
+            loading_state: string;
+            empty_state: string;
+            success_state: string;
+            failure_state: string;
+            feedback: string;
+        }>;
+        non_completing_outcomes: Array<{
+            key: string;
+            statement: string;
+        }>;
+    }>;
+}
+export interface GlobalSemanticProjectionV2 {
+    constraints: Array<{
+        key: string;
+        statement: string;
+    }>;
+    forbidden_shortcuts: Array<{
+        key: string;
+        statement: string;
+    }>;
+}
+export interface ContextAuthoritySnapshotV2 {
+    mode: "referenced" | "full";
+    topology_sha256: string;
+    files: string[];
+    sha256: Record<string, string>;
+    controlling_files?: string[];
+    supporting_files?: string[];
+}
+export interface NextAuthorityMaterialsV2 {
+    source_hashes: Record<string, string>;
+    source_items: CompiledSourceItemV2[];
+    context_snapshot: ContextAuthoritySnapshotV2;
+    product_semantics: ProductSemanticProjectionV2;
+    global_semantics: GlobalSemanticProjectionV2;
+}
+export interface AuthorityMaterialHashesV2 {
+    source_hashes_sha256: string;
+    context_snapshot_sha256: string;
+    product_semantics_sha256: string;
+    global_semantics_sha256: string;
+}
+export interface InitialTaskBaseV2 {
+    git_commit: string;
+    git_tree: string;
+    workspace_manifest: WorkspaceManifestV2;
+}
+export interface VerifierContentAuthority {
+    package_name: string;
+    bundle_sha256: string;
+    schema_sha256: string;
+    hook_sha256: string;
+    bundle_files: Record<string, string>;
+}
+export interface VerifierRuntimeLocator {
+    package_version: string;
+    package_root: string;
+}
+export interface VerifierIdentityV2 extends VerifierContentAuthority, VerifierRuntimeLocator {
+    package_name: "project-tiny-context-harness";
+}

package/dist/lib/long-task-authority-types.js

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

package/dist/lib/long-task-authority.d.ts

@@ -0,0 +1,7 @@
+import type { AuthorityHashesV2, CompiledDeliveryContractV2, DeliveryContractV2, DeliveryOutcomeV2 } from "./long-task-delivery-types.js";
+export declare function computeAuthorityHashes(contract: DeliveryContractV2): AuthorityHashesV2;
+export declare function outcomeAuthorityHash(outcome: DeliveryOutcomeV2): string;
+export declare function changedAuthoritySections(previous: AuthorityHashesV2, next: AuthorityHashesV2): string[];
+export declare function protectedAuthorityChanged(previous: CompiledDeliveryContractV2, next: AuthorityHashesV2): string[];
+export declare function acceptanceSemanticsChanged(previous: CompiledDeliveryContractV2, next: DeliveryContractV2): boolean;
+export declare function isMonotonicAcceptanceStrengthening(previous: CompiledDeliveryContractV2, next: DeliveryContractV2): boolean;

package/dist/lib/long-task-authority.js

@@ -0,0 +1,142 @@
+import { CHECK_AUTHORITY_POLICY, projectFieldsByPolicy, } from "./long-task-authority-policy.js";
+import { evidenceAdapterForRunner } from "./long-task-evidence-adapter-policy.js";
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+const ACCEPTANCE_CHECK_POLICIES = new Set([
+    "identity",
+    "semantic_user_review",
+    "proof_additive",
+    "output_requirement",
+]);
+const TECHNICAL_CHECK_POLICIES = new Set([
+    "identity",
+    "runner_authority",
+    "input_coverage",
+]);
+export function computeAuthorityHashes(contract) {
+    return {
+        source_authority_hash: hash({
+            source_paths: contract.task.source_paths,
+            source_claims: contract.source_claims,
+        }),
+        product_authority_hash: hash({
+            goal: contract.task.goal,
+            global: contract.global.product,
+            outcomes: contract.outcomes.map((outcome) => ({
+                key: outcome.key,
+                product: outcome.product,
+            })),
+        }),
+        acceptance_authority_hash: hash({
+            external_confirmations: contract.global.acceptance.external_confirmations,
+            global_checks: contract.global.acceptance.checks.map(acceptanceCheck),
+            global_counterfactual_controls: contract.global.acceptance.counterfactual_controls,
+            outcomes: contract.outcomes.map((outcome) => ({
+                key: outcome.key,
+                checks: outcome.acceptance.checks.map(acceptanceCheck),
+                population: outcome.acceptance.population,
+                counterfactual_controls: outcome.acceptance.counterfactual_controls,
+            })),
+        }),
+        risk_authority_hash: hash(contract.risk),
+        technical_authority_hash: hash({
+            global: contract.global.technical,
+            outcomes: contract.outcomes.map((outcome) => ({
+                key: outcome.key,
+                technical: outcome.technical,
+                checks: [...outcome.acceptance.checks.map(technicalCheck)],
+            })),
+            global_checks: contract.global.acceptance.checks.map(technicalCheck),
+        }),
+    };
+}
+export function outcomeAuthorityHash(outcome) {
+    return hash({
+        product: outcome.product,
+        acceptance: {
+            checks: outcome.acceptance.checks.map(acceptanceCheck),
+            population: outcome.acceptance.population,
+            counterfactual_controls: outcome.acceptance.counterfactual_controls,
+        },
+    });
+}
+export function changedAuthoritySections(previous, next) {
+    return Object.keys(previous)
+        .filter((key) => previous[key] !== next[key])
+        .map((key) => key.replace(/_authority_hash$/u, ""));
+}
+export function protectedAuthorityChanged(previous, next) {
+    return changedAuthoritySections(previous.authority_hashes, next).filter((section) => section !== "technical");
+}
+export function acceptanceSemanticsChanged(previous, next) {
+    return !same(acceptanceSemantics(previous), acceptanceSemantics(next));
+}
+export function isMonotonicAcceptanceStrengthening(previous, next) {
+    if (!acceptanceSemanticsChanged(previous, next))
+        return false;
+    if (!subset(previous.global.acceptance.external_confirmations, next.global.acceptance.external_confirmations) ||
+        !subset(previous.global.acceptance.counterfactual_controls ?? [], next.global.acceptance.counterfactual_controls) ||
+        !checksStrengthened(previous.global.acceptance.checks, next.global.acceptance.checks))
+        return false;
+    const nextOutcomes = new Map(next.outcomes.map((outcome) => [outcome.key, outcome]));
+    if (nextOutcomes.size !== previous.outcomes.length)
+        return false;
+    for (const previousOutcome of previous.outcomes) {
+        const nextOutcome = nextOutcomes.get(previousOutcome.key);
+        if (!nextOutcome)
+            return false;
+        if (!checksStrengthened(previousOutcome.acceptance.checks, nextOutcome.acceptance.checks) ||
+            !optionalStrengthened(previousOutcome.acceptance.population, nextOutcome.acceptance.population) ||
+            !subset(previousOutcome.acceptance.counterfactual_controls, nextOutcome.acceptance.counterfactual_controls))
+            return false;
+    }
+    return true;
+}
+function acceptanceCheck(check) {
+    return {
+        ...projectFieldsByPolicy(check, CHECK_AUTHORITY_POLICY, ACCEPTANCE_CHECK_POLICIES),
+        evidence_adapter: evidenceAdapterForRunner(check.runner.type),
+    };
+}
+function technicalCheck(check) {
+    return projectFieldsByPolicy(check, CHECK_AUTHORITY_POLICY, TECHNICAL_CHECK_POLICIES);
+}
+function acceptanceSemantics(contract) {
+    return {
+        external_confirmations: contract.global.acceptance.external_confirmations,
+        global_checks: contract.global.acceptance.checks.map(acceptanceCheck),
+        global_counterfactual_controls: contract.global.acceptance.counterfactual_controls ?? [],
+        outcomes: contract.outcomes.map((outcome) => ({
+            key: outcome.key,
+            checks: outcome.acceptance.checks.map(acceptanceCheck),
+            population: outcome.acceptance.population,
+            counterfactual_controls: outcome.acceptance.counterfactual_controls,
+        })),
+    };
+}
+function checksStrengthened(previous, next) {
+    const nextChecks = new Map(next.map((check) => [check.key, check]));
+    for (const previousCheck of previous) {
+        const nextCheck = nextChecks.get(previousCheck.key);
+        if (!nextCheck ||
+            previousCheck.proof_surface !== nextCheck.proof_surface ||
+            !subset(previousCheck.positive_assertions, nextCheck.positive_assertions) ||
+            !subset(previousCheck.negative_assertions, nextCheck.negative_assertions))
+            return false;
+    }
+    return true;
+}
+function subset(previous, next) {
+    const available = new Set(next.map((item) => canonicalValueJson(item)));
+    return previous.every((item) => available.has(canonicalValueJson(item)));
+}
+function optionalStrengthened(previous, next) {
+    return previous === null || previous === undefined
+        ? true
+        : same(previous, next);
+}
+function same(left, right) {
+    return canonicalValueJson(left) === canonicalValueJson(right);
+}
+function hash(value) {
+    return sha256Hex(canonicalValueJson(value));
+}

package/dist/lib/long-task-boundary-check.d.ts

@@ -0,0 +1,15 @@
+export type BoundaryCheckDecisionV2 = "single_contract" | "decision_required";
+export interface BoundaryCandidateV2 {
+    observable_result: string;
+    executable_acceptance: boolean;
+    separation_reason: string;
+    preserves_atomic_loop: boolean;
+}
+export interface BoundaryCheckInputV2 {
+    atomic_user_loop: boolean;
+    capacity_requires_fragments: boolean;
+    capacity_available: boolean;
+    split_motivations: string[];
+    candidates: BoundaryCandidateV2[];
+}
+export declare function evaluateContractBoundary(input: BoundaryCheckInputV2): BoundaryCheckDecisionV2;

package/dist/lib/long-task-boundary-check.js

@@ -0,0 +1,9 @@
+export function evaluateContractBoundary(input) {
+    if (!input.candidates.length)
+        return "decision_required";
+    if (input.candidates.some((candidate) => !candidate.observable_result.trim() ||
+        !candidate.executable_acceptance ||
+        !candidate.separation_reason.trim()))
+        return "decision_required";
+    return "single_contract";
+}

package/dist/lib/long-task-check-evidence-decoder.d.ts

@@ -0,0 +1,3 @@
+import type { CompiledCheckV2, RawCommandExecutionV2 } from "./long-task-delivery-types.js";
+export declare function decodeCheckEvidence(check: CompiledCheckV2, exitCode: number, stdout: Buffer, stderr: Buffer): Pick<RawCommandExecutionV2, "execution_status" | "exit_code" | "observations" | "error">;
+export declare function invalidEvidence(exitCode: number, error: string): Pick<RawCommandExecutionV2, "execution_status" | "exit_code" | "observations" | "error">;

package/dist/lib/long-task-check-evidence-decoder.js

@@ -0,0 +1,74 @@
+import { extractPlaywrightEvidence } from "./long-task-playwright-evidence.js";
+export function decodeCheckEvidence(check, exitCode, stdout, stderr) {
+    if (check.runner.type === "playwright_test")
+        return decodePlaywright(check, exitCode, stdout, stderr);
+    const lines = stdout
+        .toString("utf8")
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    try {
+        const payload = JSON.parse(lines.at(-1) ?? "");
+        if (payload.schema_version !== "long-task-check-result-v2")
+            return invalidEvidence(exitCode, "check_evidence_schema_invalid");
+        if (payload.execution_status === "blocked_external")
+            return {
+                execution_status: "blocked_external",
+                exit_code: exitCode,
+                observations: {},
+                error: `blocked_external:${String(payload.reason ?? "unspecified")}`,
+            };
+        if (payload.execution_status !== "completed")
+            return invalidEvidence(exitCode, "check_evidence_execution_status_invalid");
+        if (!payload.observations ||
+            typeof payload.observations !== "object" ||
+            Array.isArray(payload.observations))
+            return invalidEvidence(exitCode, "check_evidence_observations_invalid");
+        return {
+            execution_status: "completed",
+            exit_code: exitCode,
+            observations: payload.observations,
+            error: null,
+        };
+    }
+    catch (error) {
+        return invalidEvidence(exitCode, `check_evidence_json_invalid:${message(error)}`);
+    }
+}
+export function invalidEvidence(exitCode, error) {
+    return {
+        execution_status: "invalid_evidence",
+        exit_code: exitCode,
+        observations: {},
+        error,
+    };
+}
+function decodePlaywright(check, exitCode, stdout, stderr) {
+    try {
+        const report = JSON.parse(stdout.toString("utf8"));
+        const extracted = extractPlaywrightEvidence(check, report, exitCode);
+        if (extracted.error)
+            return invalidEvidence(exitCode, extracted.error);
+        return {
+            execution_status: "completed",
+            exit_code: exitCode,
+            observations: extracted.observations,
+            error: null,
+        };
+    }
+    catch (error) {
+        const combined = `${stdout.toString("utf8")}\n${stderr.toString("utf8")}`;
+        if (exitCode !== 0 &&
+            /Cannot find module|command not found|not recognized|Executable doesn't exist|browserType\.launch/iu.test(combined))
+            return {
+                execution_status: "infrastructure_error",
+                exit_code: exitCode,
+                observations: {},
+                error: `playwright_startup_failed:${message(error)}`,
+            };
+        return invalidEvidence(exitCode, `playwright_report_invalid:${message(error)}`);
+    }
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/lib/long-task-check-execution-policy.d.ts

@@ -0,0 +1,18 @@
+import type { CompiledCheckV2 } from "./long-task-delivery-types.js";
+export type CheckExecutionInputPolicy = "raw_execution" | "raw_execution_via_runner_freeze" | "per_check_evidence" | "progress_scope" | "final_gate_evidence" | "authority_metadata";
+export declare const CHECK_EXECUTION_INPUT_POLICY: {
+    key: "authority_metadata";
+    proof_surface: "authority_metadata";
+    runner: "raw_execution";
+    verification_inputs: "raw_execution_via_runner_freeze";
+    input_paths: "progress_scope";
+    expected_output_paths: "final_gate_evidence";
+    artifact_globs: "per_check_evidence";
+    positive_assertions: "per_check_evidence";
+    negative_assertions: "per_check_evidence";
+    environment_requirements: "raw_execution";
+};
+type CompiledCheckWithoutRawIdentity = Omit<CompiledCheckV2, "raw_execution_identity">;
+export declare function rawExecutionInputProjection(check: CompiledCheckWithoutRawIdentity): Record<string, unknown>;
+export declare function computeRawExecutionIdentity(check: CompiledCheckWithoutRawIdentity): string;
+export {};

package/dist/lib/long-task-check-execution-policy.js

@@ -0,0 +1,36 @@
+import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+export const CHECK_EXECUTION_INPUT_POLICY = {
+    key: "authority_metadata",
+    proof_surface: "authority_metadata",
+    runner: "raw_execution",
+    verification_inputs: "raw_execution_via_runner_freeze",
+    input_paths: "progress_scope",
+    expected_output_paths: "final_gate_evidence",
+    artifact_globs: "per_check_evidence",
+    positive_assertions: "per_check_evidence",
+    negative_assertions: "per_check_evidence",
+    environment_requirements: "raw_execution",
+};
+export function rawExecutionInputProjection(check) {
+    const projection = {};
+    projection.evidence_adapter = check.evidence_adapter;
+    for (const field of Object.keys(CHECK_EXECUTION_INPUT_POLICY)) {
+        const policy = CHECK_EXECUTION_INPUT_POLICY[field];
+        if (policy === "raw_execution") {
+            if (field === "runner")
+                projection[field] = check.runner.execution_identity;
+            else if (field === "environment_requirements")
+                projection[field] = [...check.environment_requirements].sort((left, right) => canonicalValueJson(left).localeCompare(canonicalValueJson(right)));
+            else
+                projection[field] = check[field];
+        }
+        else if (policy === "raw_execution_via_runner_freeze")
+            projection[field] = {
+                frozen_via_runner_execution_identity: check.runner.execution_identity,
+            };
+    }
+    return projection;
+}
+export function computeRawExecutionIdentity(check) {
+    return sha256Hex(canonicalValueJson(rawExecutionInputProjection(check)));
+}

package/dist/lib/long-task-check-runner.d.ts

@@ -0,0 +1,2 @@
+import type { CompiledCheckV2, RawCommandExecutionV2 } from "./long-task-delivery-types.js";
+export declare function executeCheckRunner(check: CompiledCheckV2, snapshotRoot: string): Promise<RawCommandExecutionV2>;

package/dist/lib/long-task-check-runner.js

@@ -0,0 +1,181 @@
+import { spawn } from "node:child_process";
+import { access } from "node:fs/promises";
+import net from "node:net";
+import path from "node:path";
+import { decodeCheckEvidence, invalidEvidence, } from "./long-task-check-evidence-decoder.js";
+import { declaredEnvironmentValues, outputContainsDeclaredEnvironmentValue, runnerEnvironment, } from "./long-task-runner-environment.js";
+import { resolveInsideRepository } from "./long-task-workspace.js";
+import { sha256Hex } from "./strict-codec.js";
+const OUTPUT_LIMIT = 2 * 1024 * 1024;
+export async function executeCheckRunner(check, snapshotRoot) {
+    const started = Date.now();
+    const unavailable = await probeEnvironment(check.environment_requirements, snapshotRoot);
+    if (unavailable)
+        return {
+            raw_execution_identity: check.raw_execution_identity,
+            execution_identity: check.raw_execution_identity,
+            execution_status: "blocked_external",
+            exit_code: -1,
+            observations: {},
+            stdout_sha256: sha256Hex(""),
+            stderr_sha256: sha256Hex(""),
+            attempts: 0,
+            duration_ms: Date.now() - started,
+            error: unavailable,
+        };
+    const retryAllowed = check.runner.retry_policy === "transient_once" &&
+        check.runner.idempotent &&
+        (check.runner.effect === "read_only" ||
+            check.runner.effect === "test_sandbox");
+    const maximumAttempts = retryAllowed ? 2 : 1;
+    for (let attempt = 1; attempt <= maximumAttempts; attempt += 1) {
+        try {
+            const raw = await runOnce(check, snapshotRoot);
+            const secrets = declaredEnvironmentValues(check.environment_requirements);
+            const decoded = outputContainsDeclaredEnvironmentValue(raw, secrets)
+                ? invalidEvidence(raw.exit_code, "check_evidence_contains_declared_environment_value")
+                : decodeCheckEvidence(check, raw.exit_code, raw.stdout, raw.stderr);
+            return {
+                raw_execution_identity: check.raw_execution_identity,
+                execution_identity: check.raw_execution_identity,
+                ...decoded,
+                stdout_sha256: sha256Hex(raw.stdout),
+                stderr_sha256: sha256Hex(raw.stderr),
+                attempts: attempt,
+                duration_ms: Date.now() - started,
+            };
+        }
+        catch (error) {
+            const reason = message(error);
+            if (attempt < maximumAttempts)
+                continue;
+            return {
+                raw_execution_identity: check.raw_execution_identity,
+                execution_identity: check.raw_execution_identity,
+                execution_status: "infrastructure_error",
+                exit_code: -1,
+                observations: {},
+                stdout_sha256: sha256Hex(""),
+                stderr_sha256: sha256Hex(reason),
+                attempts: attempt,
+                duration_ms: Date.now() - started,
+                error: reason,
+            };
+        }
+    }
+    throw new Error("unreachable");
+}
+async function runOnce(check, snapshotRoot) {
+    const runner = check.runner;
+    const cwd = resolveInsideRepository(snapshotRoot, runner.resolved_cwd || ".", "runner.resolved_cwd");
+    const executable = runner.type === "project_binary"
+        ? resolveInsideRepository(snapshotRoot, runner.resolved_target, "runner.resolved_target")
+        : runner.executable;
+    const argv = [...runner.executable_argv_prefix, ...runner.argv];
+    return new Promise((resolve, reject) => {
+        const child = spawn(executable, argv, {
+            cwd,
+            shell: false,
+            windowsHide: true,
+            env: runnerEnvironment(check.environment_requirements),
+        });
+        const stdout = [];
+        const stderr = [];
+        let size = 0;
+        let settled = false;
+        const capture = (target) => (chunk) => {
+            size += chunk.length;
+            if (size > OUTPUT_LIMIT) {
+                child.kill();
+                if (!settled) {
+                    settled = true;
+                    reject(new Error("command_output_limit_exceeded"));
+                }
+                return;
+            }
+            target.push(Buffer.from(chunk));
+        };
+        child.stdout.on("data", capture(stdout));
+        child.stderr.on("data", capture(stderr));
+        child.on("error", (error) => {
+            if (!settled) {
+                settled = true;
+                reject(new Error(`command_spawn_error:${message(error)}`));
+            }
+        });
+        const timer = setTimeout(() => {
+            child.kill();
+            if (!settled) {
+                settled = true;
+                reject(new Error("command_timeout"));
+            }
+        }, runner.timeout_ms);
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            if (settled)
+                return;
+            settled = true;
+            resolve({
+                exit_code: code ?? -1,
+                stdout: Buffer.concat(stdout),
+                stderr: Buffer.concat(stderr),
+            });
+        });
+    });
+}
+async function probeEnvironment(requirements, snapshotRoot) {
+    for (const requirement of requirements) {
+        let available = false;
+        if (requirement.kind === "executable")
+            available = await executableExists(requirement.target);
+        else if (requirement.kind === "env_var")
+            available = Boolean(process.env[requirement.target]);
+        else if (requirement.kind === "file")
+            available = Boolean((await statSafe(resolveInsideRepository(snapshotRoot, requirement.target, `environment.${requirement.key}`)))?.isFile());
+        else if (requirement.kind === "directory")
+            available = Boolean((await statSafe(resolveInsideRepository(snapshotRoot, requirement.target, `environment.${requirement.key}`)))?.isDirectory());
+        else if ("host" in requirement)
+            available = await loopbackAvailable(requirement.host, requirement.port, requirement.timeout_ms);
+        if (!available)
+            return `environment_requirement_unavailable:${requirement.key}`;
+    }
+    return null;
+}
+async function executableExists(target) {
+    if (path.isAbsolute(target))
+        return access(target)
+            .then(() => true)
+            .catch(() => false);
+    const names = process.platform === "win32"
+        ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM")
+            .split(";")
+            .flatMap((extension) => [target, `${target}${extension}`])
+        : [target];
+    for (const folder of (process.env.PATH ?? "").split(path.delimiter))
+        for (const name of names)
+            if (await access(path.join(folder, name))
+                .then(() => true)
+                .catch(() => false))
+                return true;
+    return false;
+}
+async function loopbackAvailable(host, port, timeoutMs) {
+    return new Promise((resolve) => {
+        const socket = net.createConnection({ host, port });
+        const finish = (value) => {
+            socket.destroy();
+            resolve(value);
+        };
+        socket.setTimeout(timeoutMs, () => finish(false));
+        socket.once("connect", () => finish(true));
+        socket.once("error", () => finish(false));
+    });
+}
+async function statSafe(file) {
+    return import("node:fs/promises")
+        .then(({ stat }) => stat(file))
+        .catch(() => null);
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

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

@@ -0,0 +1,2 @@
+import type { DeliveryCheckV2 } from "./long-task-delivery-types.js";
+export declare function parseCheck(value: unknown, label: string): DeliveryCheckV2;