project-tiny-context-harness 0.11.0 → 0.12.0

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

@@ -1,62 +0,0 @@
-export const ACTIVE_AUTHORITY_TRANSITION_POLICY = {
-    compile_first: {
-        reads_authority: "none",
-        modifies_authority: true,
-        requires_lock: true,
-        cas: "expected_null",
-    },
-    compile_revise: {
-        reads_authority: "active_snapshot",
-        modifies_authority: true,
-        requires_lock: true,
-        cas: "expected_identity",
-    },
-    verify: {
-        reads_authority: "active_snapshot",
-        modifies_authority: false,
-        requires_lock: false,
-        cas: "recheck_before_progress_write",
-    },
-    final_gate: {
-        reads_authority: "active_snapshot",
-        modifies_authority: false,
-        requires_lock: false,
-        cas: "recheck_before_acceptance",
-    },
-    stop_accepted_clear: {
-        reads_authority: "accepted_identity",
-        modifies_authority: true,
-        requires_lock: true,
-        cas: "expected_identity",
-    },
-    close_accepted_clear: {
-        reads_authority: "accepted_identity",
-        modifies_authority: true,
-        requires_lock: true,
-        cas: "expected_identity",
-    },
-    abandon_valid: {
-        reads_authority: "active_snapshot",
-        modifies_authority: true,
-        requires_lock: true,
-        cas: "expected_identity",
-    },
-    abandon_corrupt: {
-        reads_authority: "deterministic_local_paths",
-        modifies_authority: true,
-        requires_lock: true,
-        cas: "explicit_force",
-    },
-    legacy_migration: {
-        reads_authority: "legacy_plus_matching_cache",
-        modifies_authority: true,
-        requires_lock: true,
-        cas: "expected_legacy_identity",
-    },
-    verifier_migration: {
-        reads_authority: "active_snapshot",
-        modifies_authority: true,
-        requires_lock: true,
-        cas: "expected_identity",
-    },
-};

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

@@ -1,131 +0,0 @@
-import type { DeliveryControlV2, DeliveryOutcomeV2, ProofSurface } from "./long-task-contract-types.js";
-import type { ClaimApplicabilityV2, DeliveryStageV2, ExecutionTargetV2, TargetProfileV2 } from "./long-task-semantic-contract-types.js";
-import type { DeliverySurfaceBindingV2 } from "./long-task-ui-surface-types.js";
-import type { CompiledSourceItemV2 } from "./long-task-source-authority-types.js";
-import type { SemanticFactGlobalBindingsV2 } from "./long-task-semantic-fact-binding-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;
-    target_profile: TargetProfileV2;
-    execution_targets: ExecutionTargetV2[];
-    stages: DeliveryStageV2[];
-    global_non_goals: Array<{
-        key: string;
-        statement: string;
-        applicability_refs: string[];
-    }>;
-    outcomes: Array<{
-        key: string;
-        title: string;
-        stage: string;
-        applicability: ClaimApplicabilityV2[];
-        observable_result: string;
-        result_applicability_refs: string[];
-        success_path_required: boolean;
-        degradation_path_required: boolean;
-        owner: {
-            label: string;
-            owner_surfaces: string[];
-        };
-        requirements: Array<{
-            key: string;
-            statement: string;
-            required_proof_surfaces: ProofSurface[];
-            applicability_refs: string[];
-        }>;
-        controls: Array<{
-            key: string;
-            surface: string;
-            region: string;
-            location: string;
-            control_type: string;
-            label_content: string;
-            user_task: string;
-            visibility: string;
-            availability: string;
-            trigger: string;
-            input: string;
-            validation: string;
-            default_value: string;
-            interaction: string;
-            navigation_result: string;
-            loading_state: string;
-            empty_state: string;
-            success_state: string;
-            failure_state: string;
-            recovery: string;
-            permission: string;
-            feedback: string;
-            accessibility: string;
-            field_coverage: DeliveryControlV2["field_coverage"];
-        }>;
-        control_relation_closure: DeliveryOutcomeV2["product"]["control_relation_closure"];
-        control_relations: DeliveryOutcomeV2["product"]["control_relations"];
-        surface_bindings: DeliverySurfaceBindingV2[];
-        non_completing_outcomes: Array<{
-            key: string;
-            statement: string;
-        }>;
-    }>;
-}
-export interface GlobalSemanticProjectionV2 {
-    applicability: ClaimApplicabilityV2[];
-    semantic_fact_bindings: SemanticFactGlobalBindingsV2 | null;
-    constraints: Array<{
-        key: string;
-        statement: string;
-        applicability_refs: string[];
-    }>;
-    forbidden_shortcuts: Array<{
-        key: string;
-        statement: string;
-        applicability_refs: 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

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

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

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

@@ -1,202 +0,0 @@
-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,
-            semantic_fact_manifest: contract.semantic_fact_manifest,
-        }),
-        product_authority_hash: hash({
-            goal: contract.task.goal,
-            target_profile: contract.task.target_profile,
-            execution_targets: contract.task.execution_targets,
-            stages: contract.stages,
-            global: {
-                applicability: contract.global.applicability,
-                semantic_fact_bindings: contract.global.semantic_fact_bindings ?? null,
-                product: contract.global.product,
-            },
-            outcomes: contract.outcomes.map((outcome) => ({
-                key: outcome.key,
-                stage: outcome.stage,
-                applicability: outcome.applicability,
-                ...(outcome.semantic_fact_bindings
-                    ? {
-                        semantic_fact_bindings: {
-                            manifest_ref: outcome.semantic_fact_bindings.manifest_ref,
-                            facts: outcome.semantic_fact_bindings.facts,
-                        },
-                    }
-                    : {}),
-                product: outcome.product,
-            })),
-        }),
-        acceptance_authority_hash: hash({
-            global_semantic_fact_bindings: contract.global.semantic_fact_bindings ?? null,
-            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,
-                ...(outcome.semantic_fact_bindings
-                    ? { semantic_fact_proofs: outcome.semantic_fact_bindings.proofs }
-                    : {}),
-                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({
-        stage: outcome.stage,
-        applicability: outcome.applicability,
-        semantic_fact_bindings: outcome.semantic_fact_bindings,
-        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 (!same(previous.global.acceptance.external_confirmations, next.global.acceptance.external_confirmations) ||
-        !counterfactualsStrengthened(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) ||
-            !counterfactualsStrengthened(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 ||
-            !same(previousCheck.execution_target, nextCheck.execution_target) ||
-            !subset(previousCheck.journey_roles, nextCheck.journey_roles) ||
-            !subset(previousCheck.scenario.given, nextCheck.scenario.given) ||
-            !subset(previousCheck.scenario.when, nextCheck.scenario.when) ||
-            !subset(previousCheck.verification_inputs, nextCheck.verification_inputs) ||
-            !subset(previousCheck.input_paths, nextCheck.input_paths) ||
-            !subset(previousCheck.expected_output_paths, nextCheck.expected_output_paths) ||
-            !subset(previousCheck.artifact_globs, nextCheck.artifact_globs) ||
-            !subset(previousCheck.environment_requirements, nextCheck.environment_requirements) ||
-            !assertionsStrengthened(previousCheck.positive_assertions, nextCheck.positive_assertions) ||
-            !assertionsStrengthened(previousCheck.negative_assertions, nextCheck.negative_assertions))
-            return false;
-    }
-    return true;
-}
-function assertionsStrengthened(previous, next) {
-    const nextAssertions = new Map(next.map((assertion) => [assertion.key, assertion]));
-    for (const previousAssertion of previous) {
-        const nextAssertion = nextAssertions.get(previousAssertion.key);
-        if (!nextAssertion ||
-            previousAssertion.criterion !== nextAssertion.criterion ||
-            !same(previousAssertion.claims, nextAssertion.claims) ||
-            previousAssertion.applicability_ref !== nextAssertion.applicability_ref ||
-            previousAssertion.observation !== nextAssertion.observation ||
-            previousAssertion.operator !== nextAssertion.operator ||
-            !same(previousAssertion.expected, nextAssertion.expected) ||
-            !subset(previousAssertion.evidence_capabilities, nextAssertion.evidence_capabilities))
-            return false;
-    }
-    return true;
-}
-function counterfactualsStrengthened(previous, next) {
-    return previous.every((control) => next.some((candidate) => same(candidate.binding_key, control.binding_key) &&
-        same(candidate.binding_ref, control.binding_ref) &&
-        candidate.check_key === control.check_key &&
-        same(candidate.mutation, control.mutation) &&
-        subset(control.claims, candidate.claims) &&
-        subset(control.expected_assertion_failures, candidate.expected_assertion_failures) &&
-        subset(control.preserved_assertions, candidate.preserved_assertions) &&
-        subset(candidate.allowed_fanout_assertions ?? [], control.allowed_fanout_assertions ?? [])));
-}
-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

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

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

@@ -1,3 +0,0 @@
-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" | "evidence_records" | "error">;
-export declare function invalidEvidence(exitCode: number, error: string): Pick<RawCommandExecutionV2, "execution_status" | "exit_code" | "observations" | "evidence_records" | "error">;

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

@@ -1,84 +0,0 @@
-import { extractPlaywrightEvidence } from "./long-task-playwright-evidence.js";
-import { decodeEvidenceCapabilityRecords } from "./long-task-evidence-capability-policy.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" &&
-            payload.schema_version !== "long-task-check-result-v3")
-            return invalidEvidence(exitCode, "check_evidence_schema_invalid");
-        if (payload.execution_status === "blocked_external")
-            return {
-                execution_status: "blocked_external",
-                exit_code: exitCode,
-                observations: {},
-                evidence_records: [],
-                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");
-        const evidenceRecords = payload.schema_version === "long-task-check-result-v3"
-            ? decodeEvidenceCapabilityRecords(payload.evidence_records)
-            : [];
-        return {
-            execution_status: "completed",
-            exit_code: exitCode,
-            observations: payload.observations,
-            evidence_records: evidenceRecords,
-            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: {},
-        evidence_records: [],
-        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,
-            evidence_records: extracted.evidence_records,
-            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: {},
-                evidence_records: [],
-                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

@@ -1,21 +0,0 @@
-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";
-    journey_roles: "authority_metadata";
-    execution_target: "raw_execution";
-    scenario: "per_check_evidence";
-    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

@@ -1,48 +0,0 @@
-import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
-export const CHECK_EXECUTION_INPUT_POLICY = {
-    key: "authority_metadata",
-    journey_roles: "authority_metadata",
-    execution_target: "raw_execution",
-    scenario: "per_check_evidence",
-    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;
-    projection.execution_target_definition = check.execution_target_definition;
-    projection.known_execution_targets = check.known_execution_targets;
-    projection.design_conformance_targets =
-        check.design_conformance_targets ?? [];
-    projection.package_observation_protocol = (check.observation_authorities ?? []).some((authority) => authority.authority === "package_process_json_exact")
-        ? "ty-context-product-observation-v1"
-        : null;
-    projection.process_runtime_closure_identity =
-        check.process_runtime_closure?.closure_identity ?? null;
-    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

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