project-tiny-context-harness 0.11.0 → 0.12.0

package/dist/lib/long-task-execution-observation.d.ts

@@ -1,31 +0,0 @@
-import type { CheckRunnerExecutionContextV2, CompiledCheckV2, RawCommandExecutionV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-import { type CounterfactualSandboxV2 } from "./long-task-counterfactual-sandbox.js";
-export interface PreparedExecutionObservationGroupV2 {
-    readonly execution_root: string;
-    readonly runner_context: CheckRunnerExecutionContextV2;
-    finalize(raw: RawCommandExecutionV2): Promise<RawCommandExecutionV2>;
-    dispose(): Promise<void>;
-}
-/**
- * Freezes every selected Raw Execution group's observation inputs before the
- * caller is allowed to start any runner. Keeping this as one owner prevents a
- * prior execution from priming a later group's supposedly pre-run carrier.
- */
-export declare function prepareExecutionObservationUniverse(input: {
-    groups: readonly (readonly CompiledCheckV2[])[];
-    snapshot_root: string;
-    workspace_manifest: WorkspaceManifestV2;
-    protected_authority_paths?: readonly string[];
-}): Promise<PreparedExecutionObservationGroupV2[]>;
-export declare function prepareExecutionObservationGroup(input: {
-    checks: readonly CompiledCheckV2[];
-    snapshot_root: string;
-    workspace_manifest: WorkspaceManifestV2;
-    protected_authority_paths?: readonly string[];
-}): Promise<PreparedExecutionObservationGroupV2>;
-export declare function prepareCounterfactualExecutionObservationGroup(input: {
-    checks: readonly CompiledCheckV2[];
-    sandbox: CounterfactualSandboxV2;
-    workspace_manifest: WorkspaceManifestV2;
-    protected_authority_paths?: readonly string[];
-}): Promise<PreparedExecutionObservationGroupV2>;

package/dist/lib/long-task-execution-observation.js

@@ -1,349 +0,0 @@
-import { chmod, copyFile, mkdir, mkdtemp, rm } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { createJsonPointerExactBudget } from "./long-task-json-pointer-observation.js";
-import { counterfactualSandboxProcessExecution, } from "./long-task-counterfactual-sandbox.js";
-import { matchesRepoPattern } from "./long-task-paths.js";
-import { StaticObservationFreezeError, createObservationInputFreezeBudget, freezeObservationInputFile, freezeStaticObservationCarrier, } from "./long-task-static-observation-freeze.js";
-const PROCESS_INPUT_FREEZE_LIMITS = Object.freeze({
-    max_artifacts: 4_096,
-    max_file_bytes: 268_435_456,
-    max_total_artifact_bytes: 536_870_912,
-});
-function createProcessInputFreezeBudget() {
-    return createObservationInputFreezeBudget({
-        max_artifacts: PROCESS_INPUT_FREEZE_LIMITS.max_artifacts,
-        max_total_artifact_bytes: PROCESS_INPUT_FREEZE_LIMITS.max_total_artifact_bytes,
-    });
-}
-/**
- * Freezes every selected Raw Execution group's observation inputs before the
- * caller is allowed to start any runner. Keeping this as one owner prevents a
- * prior execution from priming a later group's supposedly pre-run carrier.
- */
-export async function prepareExecutionObservationUniverse(input) {
-    const prepared = [];
-    const processInputBudget = createProcessInputFreezeBudget();
-    for (const checks of input.groups)
-        prepared.push(await prepareExecutionObservationGroupWithBudget({
-            checks,
-            snapshot_root: input.snapshot_root,
-            workspace_manifest: input.workspace_manifest,
-            protected_authority_paths: input.protected_authority_paths,
-            process_input_budget: processInputBudget,
-        }));
-    return prepared;
-}
-export async function prepareExecutionObservationGroup(input) {
-    return prepareExecutionObservationGroupWithBudget({
-        ...input,
-        process_input_budget: createProcessInputFreezeBudget(),
-    });
-}
-export async function prepareCounterfactualExecutionObservationGroup(input) {
-    const processExecution = counterfactualSandboxProcessExecution(input.sandbox);
-    return prepareExecutionObservationGroupWithBudget({
-        checks: input.checks,
-        snapshot_root: processExecution?.root ?? input.sandbox.root,
-        workspace_manifest: input.workspace_manifest,
-        protected_authority_paths: input.protected_authority_paths,
-        process_input_budget: createProcessInputFreezeBudget(),
-        direct_process_execution_root: processExecution !== null,
-    });
-}
-async function prepareExecutionObservationGroupWithBudget(input) {
-    if (!input.checks.length)
-        throw new Error("execution_observation_check_group_required");
-    const rawIdentity = input.checks[0].raw_execution_identity;
-    if (input.checks.some((check) => check.raw_execution_identity !== rawIdentity))
-        throw new Error("execution_observation_raw_identity_mismatch");
-    const states = authorityCarrierStates(input.checks, input.workspace_manifest);
-    const groups = observationCarrierGroups(states);
-    const exactBudget = createJsonPointerExactBudget();
-    const processInputBudget = input.process_input_budget;
-    const processExecution = states.some((state) => state.authority.authority === "package_process_json_exact");
-    const directProcessExecution = processExecution && input.direct_process_execution_root === true;
-    const executionRoot = processExecution && !directProcessExecution
-        ? await mkdtemp(path.join(os.tmpdir(), "ty-context-process-snapshot-"))
-        : input.snapshot_root;
-    if (processExecution && !directProcessExecution)
-        await mkdir(path.resolve(executionRoot, input.checks[0].runner.resolved_cwd), { recursive: true });
-    for (const group of groups) {
-        if ((input.protected_authority_paths ?? []).some((pattern) => matchesRepoPattern(group.artifact_path, pattern))) {
-            if (directProcessExecution)
-                await rm(path.resolve(executionRoot, ...group.artifact_path.split("/")), { recursive: true, force: true });
-            for (const state of group.authority_states)
-                recordAuthorityFailure(state, "observation_expected_authority_forbidden");
-            continue;
-        }
-        try {
-            const includesStaticAuthority = group.authority_states.some((state) => state.authority.authority === "package_static_json_exact");
-            const includesProcessAuthority = group.authority_states.some((state) => state.authority.authority === "package_process_json_exact");
-            let sourceIdentity = null;
-            if (processExecution && !directProcessExecution) {
-                const sourceFrozen = await freezeObservationInputFile({
-                    snapshot_root: input.snapshot_root,
-                    workspace_manifest: input.workspace_manifest,
-                    artifact_path: group.artifact_path,
-                    max_file_bytes: PROCESS_INPUT_FREEZE_LIMITS.max_file_bytes,
-                    budget: processInputBudget,
-                });
-                try {
-                    const target = path.resolve(executionRoot, ...group.artifact_path.split("/"));
-                    await mkdir(path.dirname(target), { recursive: true });
-                    await copyFile(path.resolve(input.snapshot_root, ...group.artifact_path.split("/")), target);
-                    const verifiedSource = await sourceFrozen.verifyPostRun();
-                    sourceIdentity = verifiedSource.pre_run_identity;
-                    await chmod(target, sourceIdentity.mode & 0o777);
-                }
-                finally {
-                    sourceFrozen.dispose();
-                }
-            }
-            group.frozen = includesStaticAuthority
-                ? await freezeStaticObservationCarrier({
-                    snapshot_root: executionRoot,
-                    workspace_manifest: input.workspace_manifest,
-                    artifact_path: group.artifact_path,
-                    budget: exactBudget,
-                    input_freeze_budget: includesProcessAuthority
-                        ? processInputBudget
-                        : undefined,
-                })
-                : await freezeObservationInputFile({
-                    snapshot_root: executionRoot,
-                    workspace_manifest: input.workspace_manifest,
-                    artifact_path: group.artifact_path,
-                    max_file_bytes: PROCESS_INPUT_FREEZE_LIMITS.max_file_bytes,
-                    budget: processInputBudget,
-                });
-            if (sourceIdentity &&
-                (group.frozen.pre_run_identity.content_sha256 !==
-                    sourceIdentity.content_sha256 ||
-                    group.frozen.pre_run_identity.size !== sourceIdentity.size))
-                throw new Error("process_observation_input_snapshot_copy_mismatch");
-        }
-        catch (error) {
-            if (directProcessExecution)
-                await rm(path.resolve(executionRoot, ...group.artifact_path.split("/")), { recursive: true, force: true });
-            const reason = observationFailureReason(error);
-            for (const state of group.authority_states)
-                recordAuthorityFailure(state, reason);
-        }
-    }
-    const processAuthorities = states
-        .filter((state) => state.authority.authority === "package_process_json_exact")
-        .map((state) => state.authority);
-    const processRuntimeClosureIdentities = [
-        ...new Set(input.checks
-            .filter((check) => (check.observation_authorities ?? []).some((authority) => authority.authority === "package_process_json_exact"))
-            .map((check) => check.process_runtime_closure?.closure_identity ?? null)),
-    ];
-    if (processExecution &&
-        (processRuntimeClosureIdentities.length !== 1 ||
-            processRuntimeClosureIdentities[0] === null))
-        throw new Error("process_runtime_closure_identity_mismatch");
-    let disposed = false;
-    const dispose = async () => {
-        if (disposed)
-            return;
-        disposed = true;
-        for (const group of groups)
-            group.frozen?.dispose();
-        if (processExecution && !directProcessExecution)
-            await rm(executionRoot, { recursive: true, force: true });
-    };
-    return {
-        execution_root: executionRoot,
-        runner_context: {
-            snapshot_sha256: input.workspace_manifest.snapshot_sha256,
-            observation_authorities: processAuthorities,
-            ...(processExecution
-                ? {
-                    process_runtime_closure_identity: processRuntimeClosureIdentities[0],
-                }
-                : {}),
-        },
-        finalize: async (raw) => {
-            try {
-                const verified = new Map();
-                for (const group of groups) {
-                    if (!group.frozen)
-                        continue;
-                    try {
-                        verified.set(group.artifact_path, await group.frozen.verifyPostRun());
-                    }
-                    catch (error) {
-                        const reason = observationFailureReason(error);
-                        for (const state of group.authority_states)
-                            recordAuthorityFailure(state, reason);
-                    }
-                }
-                return {
-                    ...raw,
-                    package_observations: finalizePackageObservations(states, verified, raw.package_observations ?? [], exactBudget),
-                };
-            }
-            finally {
-                await dispose();
-            }
-        },
-        dispose,
-    };
-}
-function authorityCarrierStates(checks, manifest) {
-    const states = [];
-    for (const check of checks)
-        for (const authority of check.observation_authorities ?? []) {
-            if (authority.authority !== "package_static_json_exact" &&
-                authority.authority !== "package_process_json_exact")
-                continue;
-            const state = {
-                check,
-                authority: authority,
-                artifact_paths: [],
-                reason: null,
-            };
-            const carrierPatterns = authority.carrier_refs.flatMap((carrier) => carrier.carrier_paths);
-            addPatternClosure(state, manifest, carrierPatterns);
-            if (authority.authority === "package_process_json_exact") {
-                const closure = check.process_runtime_closure;
-                if (!closure)
-                    recordAuthorityFailure(state, "process_runtime_closure_identity_mismatch");
-                else
-                    state.artifact_paths.push(...closure.allowed_runtime_files);
-            }
-            state.artifact_paths = [...new Set(state.artifact_paths)].sort();
-            if (authority.authority === "package_static_json_exact" &&
-                state.artifact_paths.length !== 1)
-                recordAuthorityFailure(state, "static_observation_manifest_invalid");
-            states.push(state);
-        }
-    return states;
-}
-function addPatternClosure(state, manifest, patterns) {
-    for (const pattern of new Set(patterns)) {
-        let matches;
-        try {
-            matches = manifest.files
-                .filter((file) => matchesRepoPattern(file.path, pattern))
-                .map((file) => file.path);
-        }
-        catch {
-            recordAuthorityFailure(state, "static_observation_manifest_invalid");
-            continue;
-        }
-        if (!matches.length) {
-            recordAuthorityFailure(state, "static_observation_not_in_pre_run_snapshot");
-            continue;
-        }
-        state.artifact_paths.push(...matches);
-    }
-}
-function observationCarrierGroups(states) {
-    const groups = new Map();
-    for (const state of states)
-        for (const artifactPath of state.artifact_paths) {
-            const existing = groups.get(artifactPath);
-            if (existing)
-                existing.authority_states.push(state);
-            else
-                groups.set(artifactPath, {
-                    artifact_path: artifactPath,
-                    authority_states: [state],
-                    frozen: null,
-                });
-        }
-    return [...groups.values()].sort((left, right) => left.artifact_path.localeCompare(right.artifact_path));
-}
-function finalizePackageObservations(states, verified, submitted, budget) {
-    const processStates = states.filter((state) => state.authority.authority === "package_process_json_exact");
-    const observations = submitted.filter((candidate) => {
-        const matching = processStates.filter((state) => packageObservationMatchesAuthority(candidate, state.authority));
-        return !matching.some((state) => state.reason !== null);
-    });
-    for (const state of processStates)
-        if (state.reason)
-            observations.push(failedObservation(state.authority, state.reason));
-    for (const state of states.filter((candidate) => candidate.authority.authority === "package_static_json_exact")) {
-        if (state.reason) {
-            observations.push(failedObservation(state.authority, state.reason));
-            continue;
-        }
-        const carrier = verified.get(state.artifact_paths[0]);
-        if (!carrier || !isVerifiedStaticObservationCarrier(carrier)) {
-            observations.push(failedObservation(state.authority, "static_observation_not_in_pre_run_snapshot"));
-            continue;
-        }
-        try {
-            const extracted = carrier.extractJsonPointerExactValue({
-                locator: {
-                    kind: "json_pointer",
-                    value: state.authority.locator_policy.value,
-                },
-                sensitivity: "plain",
-                budget,
-            });
-            observations.push({
-                authority: "package_static_json_exact",
-                observation_identity: state.authority.observation_identity,
-                assertion_ref: state.authority.assertion_ref,
-                obligation_ref: state.authority.obligation_ref,
-                method: state.authority.method,
-                raw_value: extracted.raw_value,
-                observation: extracted.observation,
-                reason: null,
-            });
-        }
-        catch (error) {
-            observations.push(failedObservation(state.authority, observationFailureReason(error)));
-        }
-    }
-    return observations;
-}
-function isVerifiedStaticObservationCarrier(value) {
-    return "extractJsonPointerExactValue" in value;
-}
-function packageObservationMatchesAuthority(observation, authority) {
-    return (observation.authority === authority.authority &&
-        observation.observation_identity === authority.observation_identity &&
-        observation.assertion_ref === authority.assertion_ref &&
-        observation.obligation_ref === authority.obligation_ref &&
-        observation.method === authority.method);
-}
-function failedObservation(authority, reason) {
-    return {
-        authority: authority.authority,
-        observation_identity: authority.observation_identity,
-        assertion_ref: authority.assertion_ref,
-        obligation_ref: authority.obligation_ref,
-        method: authority.method,
-        raw_value: undefined,
-        observation: null,
-        reason,
-    };
-}
-function recordAuthorityFailure(state, reason) {
-    if (state.reason)
-        return;
-    state.reason =
-        state.authority.authority === "package_process_json_exact"
-            ? processInputFailureReason(reason)
-            : reason;
-}
-function processInputFailureReason(reason) {
-    if (reason === "observation_expected_authority_forbidden")
-        return reason;
-    if (reason === "process_runtime_closure_identity_mismatch")
-        return reason;
-    if (reason.startsWith("process_observation_input_"))
-        return reason;
-    if (reason.startsWith("static_observation_"))
-        return `process_observation_input_${reason.slice("static_observation_".length)}`;
-    return "process_observation_input_freeze_invalid";
-}
-function observationFailureReason(error) {
-    if (error instanceof StaticObservationFreezeError)
-        return error.code;
-    return error instanceof Error ? error.message : String(error);
-}

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

@@ -1,4 +0,0 @@
-import type { DeliveryAssertionV2, DeliveryContractV2, SemanticFactExpectationV2 } from "./long-task-delivery-types.js";
-import type { SemanticFactManifestV1 } from "./semantic-fact-types.js";
-export declare function resolveExpectedAuthority(contract: DeliveryContractV2, outcomeKey: string | null, assertion: DeliveryAssertionV2, manifest: SemanticFactManifestV1, expectations: SemanticFactExpectationV2[]): string;
-export declare function claimAuthorityStatement(contract: DeliveryContractV2, outcomeKey: string | null, localClaim: string): string;

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

@@ -1,126 +0,0 @@
-import { controlFieldFacts } from "./long-task-control-fields.js";
-export function resolveExpectedAuthority(contract, outcomeKey, assertion, manifest, expectations) {
-    const expectation = expectations.find((item) => item.assertion_ref === assertion.key);
-    if (expectation)
-        return resolveSemanticFactExpectedAuthority(assertion, expectation);
-    const fullClaim = outcomeKey
-        ? `${outcomeKey}.${assertion.claims[0]}`
-        : assertion.claims[0];
-    const canonical = `contract-claim:${fullClaim}`;
-    const sourceAuthorities = contract.source_claims.filter((source) => sourceClaimRefs(source).includes(fullClaim));
-    const declared = assertion.expected_authority_ref;
-    let authorityStatement = claimAuthorityStatement(contract, outcomeKey, assertion.claims[0]);
-    let resolved = canonical;
-    if (declared) {
-        const source = sourceAuthorities.find((item) => [item.key, `source:${item.key}`].includes(declared));
-        const factRef = declared.startsWith("semantic-fact:")
-            ? declared.slice("semantic-fact:".length)
-            : declared;
-        const fact = manifest.facts.find((item) => item.key === factRef);
-        if (declared === canonical)
-            resolved = canonical;
-        else if (source) {
-            resolved = `source:${source.key}`;
-            authorityStatement = source.statement;
-        }
-        else if (fact)
-            return resolveBoundFactAuthority(contract, outcomeKey, assertion, fact);
-        else
-            fail("expected_authority_ref_unknown", `${outcomeKey ?? "GLOBAL"}:${assertion.key}:${declared}`);
-    }
-    if ("expected" in assertion &&
-        assertion.expected !== true &&
-        assertion.expected !== false &&
-        !authorityContainsExpected(authorityStatement, assertion.expected))
-        fail("expected_value_not_projected_from_authority", `${outcomeKey ?? "GLOBAL"}:${assertion.key}:${resolved}`);
-    return resolved;
-}
-function resolveSemanticFactExpectedAuthority(assertion, expectation) {
-    const canonical = `semantic-proof:${expectation.proof_ref}`;
-    if (assertion.expected_authority_ref &&
-        ![
-            canonical,
-            `semantic-fact:${expectation.fact_ref}`,
-            expectation.fact_ref,
-            expectation.proof_ref,
-        ].includes(assertion.expected_authority_ref))
-        fail("expected_authority_ref_mismatch", `${assertion.key}:${assertion.expected_authority_ref}:${canonical}`);
-    return canonical;
-}
-function resolveBoundFactAuthority(contract, outcomeKey, assertion, fact) {
-    if (!semanticFactBoundToAssertion(contract, outcomeKey, assertion, fact.key))
-        fail("expected_authority_fact_not_bound_to_claim", `${outcomeKey ?? "GLOBAL"}:${assertion.key}:${fact.key}`);
-    if ("expected" in assertion &&
-        fact.expected.representation === "inline" &&
-        JSON.stringify(assertion.expected) !== JSON.stringify(fact.expected.value))
-        fail("expected_authority_value_mismatch", `${assertion.key}:${fact.key}`);
-    return `semantic-fact:${fact.key}`;
-}
-function semanticFactBoundToAssertion(contract, outcomeKey, assertion, factRef) {
-    if (!outcomeKey || !assertion.applicability_ref)
-        return false;
-    const outcome = contract.outcomes.find((item) => item.key === outcomeKey);
-    return Boolean(outcome?.semantic_fact_bindings.facts.some((binding) => binding.fact_ref === factRef &&
-        binding.claim_ref === assertion.claims[0] &&
-        binding.applicability_ref === assertion.applicability_ref));
-}
-export function claimAuthorityStatement(contract, outcomeKey, localClaim) {
-    return outcomeKey
-        ? outcomeClaimAuthorityStatement(contract, outcomeKey, localClaim)
-        : globalClaimAuthorityStatement(contract, localClaim);
-}
-function globalClaimAuthorityStatement(contract, localClaim) {
-    if (localClaim.startsWith("non_goal."))
-        return (contract.global.product.non_goals.find((item) => `non_goal.${item.key}` === localClaim)?.statement ?? "");
-    if (localClaim.startsWith("constraint."))
-        return (contract.global.technical.constraints.find((item) => `constraint.${item.key}` === localClaim)?.statement ?? "");
-    return (contract.global.technical.forbidden_shortcuts.find((item) => `forbidden_shortcut.${item.key}` === localClaim)?.statement ?? "");
-}
-function outcomeClaimAuthorityStatement(contract, outcomeKey, localClaim) {
-    const outcome = contract.outcomes.find((item) => item.key === outcomeKey);
-    if (localClaim === "result")
-        return outcome.product.observable_result;
-    if (localClaim.startsWith("requirement."))
-        return keyedStatement(outcome.product.requirements, "requirement", localClaim);
-    if (localClaim.startsWith("control."))
-        return controlAuthorityStatement(outcome, localClaim);
-    if (localClaim === "control_relation_closure")
-        return outcome.product.control_relation_closure.statement;
-    if (localClaim.startsWith("control_relation."))
-        return keyedStatement(outcome.product.control_relations, "control_relation", localClaim);
-    if (localClaim.startsWith("non_completing."))
-        return keyedStatement(outcome.product.non_completing_outcomes, "non_completing", localClaim);
-    if (localClaim.startsWith("obligation."))
-        return keyedStatement(outcome.technical.obligations, "obligation", localClaim);
-    if (localClaim.startsWith("forbidden_shortcut."))
-        return keyedStatement(outcome.technical.forbidden_shortcuts, "forbidden_shortcut", localClaim);
-    return (outcome.semantic_fact_bindings.facts.find((item) => item.claim_ref === localClaim)?.fact_ref ?? "");
-}
-function controlAuthorityStatement(outcome, localClaim) {
-    const [, controlKey, field] = localClaim.split(".");
-    const control = outcome.product.controls.find((item) => item.key === controlKey);
-    return control
-        ? (controlFieldFacts(control).find((item) => item.claim_field === field)
-            ?.statement ?? "")
-        : "";
-}
-function keyedStatement(rows, prefix, localClaim) {
-    return (rows.find((item) => `${prefix}.${item.key}` === localClaim)?.statement ?? "");
-}
-function sourceClaimRefs(source) {
-    if (source.disposition.type === "decision_required")
-        return [];
-    if (source.disposition.type === "outcome_result")
-        return [source.disposition.ref];
-    return source.disposition.refs;
-}
-function authorityContainsExpected(statement, expected) {
-    if (typeof expected === "string")
-        return statement.includes(expected);
-    if (typeof expected === "number")
-        return statement.includes(String(expected));
-    return statement.includes(JSON.stringify(expected));
-}
-function fail(code, detail) {
-    throw new Error(`delivery_contract_invalid:${code}:${detail}`);
-}

package/dist/lib/long-task-explain-acceptance-link.d.ts

@@ -1,50 +0,0 @@
-import type { ClaimCoverageSummaryV2, DeliveryContractV2, SourceClaimV2 } from "./long-task-delivery-types.js";
-type AcceptanceDisposition = Extract<SourceClaimV2["disposition"], {
-    type: "acceptance";
-}>;
-export declare function explainAcceptanceLinks(contract: DeliveryContractV2, coverage: ClaimCoverageSummaryV2, disposition: AcceptanceDisposition): ({
-    type: "acceptance";
-    reference: string;
-    scope: "global" | "outcome";
-    outcome_key: string | null;
-    criterion: string | null;
-    claims: string[];
-    source_backed_claims: string[];
-    required_proof_surfaces: Record<string, string[]>;
-    covered_proof_surfaces: Record<string, string[]>;
-    proof_surface: import("./long-task-contract-types.js").ProofSurface;
-    evidence_adapter: import("./long-task-evidence-adapter-types.js").EvidenceAdapter;
-    observation: string;
-    counterfactuals: {
-        key: string;
-        claims: string[];
-        binding_ref: string;
-        owning_outcome_key: string;
-        expected_assertion_failures: string[];
-        preserved_assertions: string[];
-        allowed_fanout_assertions: string[];
-    }[] | {
-        key: string;
-        claims: string[];
-        binding_key: string;
-        owning_outcome_key: string | null;
-        expected_assertion_failures: string[];
-        preserved_assertions: string[];
-        allowed_fanout_assertions: string[];
-    }[];
-} | {
-    type: string;
-    reference: string;
-    scope: null;
-    outcome_key: null;
-    criterion: null;
-    claims: never[];
-    source_backed_claims: never[];
-    required_proof_surfaces: {};
-    covered_proof_surfaces: {};
-    proof_surface: null;
-    evidence_adapter: null;
-    observation: null;
-    counterfactuals: never[];
-})[];
-export {};

package/dist/lib/long-task-explain-acceptance-link.js

@@ -1,100 +0,0 @@
-import { resolveAcceptanceAssertion } from "./long-task-acceptance-reference.js";
-import { evidenceAdapterForRunner } from "./long-task-evidence-adapter-policy.js";
-export function explainAcceptanceLinks(contract, coverage, disposition) {
-    return disposition.refs.map((reference) => {
-        const resolved = resolveAcceptanceAssertion(contract, reference);
-        if (!resolved)
-            return missingAcceptanceLink(reference);
-        const { assertion, check } = resolved;
-        const required = {};
-        const covered = {};
-        for (const claim of assertion.claims) {
-            if (resolved.scope === "outcome") {
-                const proof = coverage.claims_by_outcome[resolved.outcome_key]?.[claim];
-                required[claim] = proof ? proof.required_surfaces : [];
-                covered[claim] = proof ? proof.covered_surfaces : [];
-            }
-            else {
-                const proof = coverage.claims_by_global[claim];
-                required[claim] = [];
-                covered[claim] = proof
-                    ? [...new Set(proof.proofs.map((item) => item.proof_surface))].sort()
-                    : [];
-            }
-        }
-        const counterfactuals = acceptanceCounterfactuals(contract, resolved.scope, resolved.outcome_key, resolved.check_key, resolved.assertion_key);
-        return {
-            type: disposition.type,
-            reference,
-            scope: resolved.scope,
-            outcome_key: resolved.outcome_key,
-            criterion: assertion.criterion ?? null,
-            claims: assertion.claims,
-            source_backed_claims: assertion.claims.filter((claim) => sourceBacked(contract, resolved.scope, resolved.outcome_key, claim)),
-            required_proof_surfaces: required,
-            covered_proof_surfaces: covered,
-            proof_surface: check.proof_surface,
-            evidence_adapter: evidenceAdapterForRunner(check.runner.type),
-            observation: assertion.observation,
-            counterfactuals,
-        };
-    });
-}
-function missingAcceptanceLink(reference) {
-    return {
-        type: "acceptance",
-        reference,
-        scope: null,
-        outcome_key: null,
-        criterion: null,
-        claims: [],
-        source_backed_claims: [],
-        required_proof_surfaces: {},
-        covered_proof_surfaces: {},
-        proof_surface: null,
-        evidence_adapter: null,
-        observation: null,
-        counterfactuals: [],
-    };
-}
-function sourceBacked(contract, scope, outcomeKey, claim) {
-    if (scope === "global")
-        return contract.source_claims.some((source) => source.disposition.type === "global_constraint" &&
-            source.disposition.refs.includes(claim));
-    const reference = `${outcomeKey}.${claim}`;
-    return contract.source_claims.some((source) => {
-        const disposition = source.disposition;
-        return ((disposition.type === "claim" || disposition.type === "outcome_result") &&
-            (disposition.type === "outcome_result"
-                ? disposition.ref === reference
-                : disposition.refs.includes(reference)));
-    });
-}
-function acceptanceCounterfactuals(contract, scope, outcomeKey, checkKey, assertionKey) {
-    if (scope === "global")
-        return contract.global.acceptance.counterfactual_controls
-            .filter((control) => control.check_key === checkKey &&
-            control.expected_assertion_failures.includes(assertionKey))
-            .map((control) => ({
-            key: control.key,
-            claims: control.claims,
-            binding_ref: control.binding_ref,
-            owning_outcome_key: control.binding_ref.split(".")[0],
-            expected_assertion_failures: control.expected_assertion_failures,
-            preserved_assertions: control.preserved_assertions,
-            allowed_fanout_assertions: control.allowed_fanout_assertions,
-        }));
-    const outcome = contract.outcomes.find((item) => item.key === outcomeKey);
-    return (outcome?.acceptance.counterfactual_controls ?? [])
-        .filter((control) => control.check_key === checkKey &&
-        control.expected_assertion_failures.includes(assertionKey))
-        .map((control) => ({
-        key: control.key,
-        claims: control.claims,
-        binding_key: control.binding_key,
-        owning_outcome_key: outcomeKey,
-        expected_assertion_failures: control.expected_assertion_failures,
-        preserved_assertions: control.preserved_assertions,
-        allowed_fanout_assertions: control.allowed_fanout_assertions,
-    }));
-}