project-tiny-context-harness 0.8.17 → 0.12.0

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

@@ -1,332 +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 { 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(),
-    });
-}
-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 executionRoot = processExecution
-        ? await mkdtemp(path.join(os.tmpdir(), "ty-context-process-snapshot-"))
-        : input.snapshot_root;
-    if (processExecution)
-        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))) {
-            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) {
-                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) {
-            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)
-            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-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,
-    }));
-}

package/dist/lib/long-task-explain-claim-links.d.ts

@@ -1,47 +0,0 @@
-import type { ClaimCoverageSummaryV2, DeliveryContractV2, SourceClaimV2 } from "./long-task-delivery-types.js";
-type ClaimDisposition = Extract<SourceClaimV2["disposition"], {
-    type: "claim";
-}>;
-type GlobalDisposition = Extract<SourceClaimV2["disposition"], {
-    type: "global_constraint";
-}>;
-type ResultDisposition = Extract<SourceClaimV2["disposition"], {
-    type: "outcome_result";
-}>;
-export declare function explainOutcomeClaimLinks(contract: DeliveryContractV2, coverage: ClaimCoverageSummaryV2, disposition: ClaimDisposition): {
-    type: "claim";
-    reference: string;
-    source_backed: boolean;
-    checks: string[];
-    assertions: (string | null)[];
-    required_proof_surfaces: import("./long-task-contract-types.js").ProofSurface[];
-    covered_proof_surfaces: import("./long-task-contract-types.js").ProofSurface[];
-    evidence_adapters: (import("./long-task-evidence-adapter-types.js").EvidenceAdapter | null)[];
-}[];
-export declare function explainOutcomeResultLinks(contract: DeliveryContractV2, coverage: ClaimCoverageSummaryV2, disposition: ResultDisposition): {
-    type: "outcome_result";
-    reference: string;
-    source_backed: boolean;
-    checks: string[];
-}[];
-export declare function explainGlobalClaimLinks(contract: DeliveryContractV2, coverage: ClaimCoverageSummaryV2, disposition: GlobalDisposition): {
-    type: "global_constraint";
-    reference: string;
-    source_backed: boolean;
-    checks: string[];
-    assertions: (string | null)[];
-    evidence_adapters: (import("./long-task-evidence-adapter-types.js").EvidenceAdapter | null)[];
-    counterfactuals: {
-        key: string;
-        check_key: string;
-        binding_ref: string;
-        owning_outcome: string;
-        owner_paths: string[];
-        carrier_paths: string[];
-        expected_assertion_failures: string[];
-        preserved_assertions: string[];
-        allowed_fanout_assertions: string[];
-        mutation: import("./long-task-counterfactual-types.js").CounterfactualMutationV2;
-    }[];
-}[];
-export {};

package/dist/lib/long-task-explain-claim-links.js

@@ -1,90 +0,0 @@
-import { evidenceAdapterForRunner } from "./long-task-evidence-adapter-policy.js";
-export function explainOutcomeClaimLinks(contract, coverage, disposition) {
-    return disposition.refs.map((reference) => {
-        const [outcomeKey, ...parts] = reference.split(".");
-        const proof = coverage.claims_by_outcome[outcomeKey]?.[parts.join(".")];
-        return {
-            type: disposition.type,
-            reference,
-            source_backed: sourceBacked(contract, reference),
-            checks: proof ? unique(proof.proofs.map((item) => item.check_key)) : [],
-            assertions: proof
-                ? unique(proof.proofs.map((item) => item.assertion_key))
-                : [],
-            required_proof_surfaces: proof ? proof.required_surfaces : [],
-            covered_proof_surfaces: proof ? proof.covered_surfaces : [],
-            evidence_adapters: proof
-                ? unique(proof.proofs.map((item) => outcomeAdapter(contract, outcomeKey, item.check_key)))
-                : [],
-        };
-    });
-}
-export function explainOutcomeResultLinks(contract, coverage, disposition) {
-    const proof = coverage.claims_by_outcome[disposition.ref.split(".")[0]]?.result;
-    return [
-        {
-            type: disposition.type,
-            reference: disposition.ref,
-            source_backed: sourceBacked(contract, disposition.ref),
-            checks: proof ? unique(proof.proofs.map((item) => item.check_key)) : [],
-        },
-    ];
-}
-export function explainGlobalClaimLinks(contract, coverage, disposition) {
-    return disposition.refs.map((reference) => {
-        const proof = coverage.claims_by_global[reference];
-        return {
-            type: disposition.type,
-            reference,
-            source_backed: sourceBacked(contract, reference),
-            checks: proof ? unique(proof.proofs.map((item) => item.check_key)) : [],
-            assertions: proof
-                ? unique(proof.proofs.map((item) => item.assertion_key))
-                : [],
-            evidence_adapters: proof
-                ? unique(proof.proofs.map((item) => globalAdapter(contract, item.check_key)))
-                : [],
-            counterfactuals: contract.global.acceptance.counterfactual_controls
-                .filter((control) => control.claims.includes(reference))
-                .map((control) => {
-                const [outcomeKey, bindingKey] = control.binding_ref.split(".");
-                const outcome = contract.outcomes.find((item) => item.key === outcomeKey);
-                const binding = outcome?.technical.bindings.find((item) => item.key === bindingKey);
-                return {
-                    key: control.key,
-                    check_key: control.check_key,
-                    binding_ref: control.binding_ref,
-                    owning_outcome: outcomeKey,
-                    owner_paths: outcome?.product.owner.path_globs ?? [],
-                    carrier_paths: binding?.carrier_paths ?? [],
-                    expected_assertion_failures: control.expected_assertion_failures,
-                    preserved_assertions: control.preserved_assertions,
-                    allowed_fanout_assertions: control.allowed_fanout_assertions,
-                    mutation: control.mutation,
-                };
-            }),
-        };
-    });
-}
-function unique(values) {
-    return values.filter((value, index) => values.indexOf(value) === index);
-}
-function sourceBacked(contract, reference) {
-    return contract.source_claims.some((source) => {
-        const disposition = source.disposition;
-        if (disposition.type === "outcome_result")
-            return disposition.ref === reference;
-        return ((disposition.type === "claim" ||
-            disposition.type === "global_constraint") &&
-            disposition.refs.includes(reference));
-    });
-}
-function outcomeAdapter(contract, outcomeKey, checkKey) {
-    const outcome = contract.outcomes.find((item) => item.key === outcomeKey);
-    const check = outcome?.acceptance.checks.find((candidate) => candidate.key === checkKey);
-    return check ? evidenceAdapterForRunner(check.runner.type) : null;
-}
-function globalAdapter(contract, checkKey) {
-    const check = contract.global.acceptance.checks.find((candidate) => candidate.key === checkKey);
-    return check ? evidenceAdapterForRunner(check.runner.type) : null;
-}