project-tiny-context-harness 0.11.0 → 0.12.0

package/dist/lib/long-task-verification-preview.d.ts

@@ -1,65 +0,0 @@
-import type { CompiledCheckV2, CompiledDeliveryContractV2 } from "./long-task-delivery-types.js";
-export interface VerificationExecutionPreviewV1 {
-    schema_version: "long-task-verification-preview-v1";
-    compiled_identity: string;
-    authority_revision: number;
-    acceptance_authorized: false;
-    executes_checks: false;
-    writes_progress: false;
-    selected_outcome: string | null;
-    selected_check: string | null;
-    main_raw_executions: MainRawExecutionPreviewV1[];
-    counterfactual_executions: CounterfactualExecutionPreviewV1[];
-    summary: {
-        selected_checks: number;
-        unique_main_runner_invocations: number;
-        counterfactual_runner_invocation_upper_bound: number;
-        declared_runner_invocation_upper_bound: number;
-        declared_command_attempt_upper_bound: number;
-    };
-    limitations: string[];
-}
-interface MainRawExecutionPreviewV1 {
-    raw_execution_identity: string;
-    check_refs: string[];
-    execution_target: CompiledCheckV2["execution_target"];
-    execution_target_definition: CompiledCheckV2["execution_target_definition"];
-    runner: RunnerPreviewV1;
-    environment_requirements: CompiledCheckV2["environment_requirements"];
-}
-interface CounterfactualExecutionPreviewV1 {
-    scope: "global" | "outcome";
-    outcome_key: string | null;
-    control_key: string;
-    check_ref: string;
-    raw_execution_identity: string;
-    mutation: {
-        type: "remove_paths";
-        paths: string[];
-    } | {
-        type: "replace_file";
-        path: string;
-        fixture_path: string;
-    } | {
-        type: "replace_json_value";
-        path: string;
-        pointer: string;
-        value: unknown;
-    } | {
-        type: "replace_text";
-        path: string;
-        match: string;
-        replacement: string;
-    };
-    runner: RunnerPreviewV1;
-}
-type RunnerPreviewV1 = Pick<CompiledCheckV2["runner"], "type" | "target" | "argv" | "cwd" | "timeout_ms" | "effect" | "retry_policy" | "idempotent" | "resolved_cwd" | "resolved_target" | "definition_sha256">;
-export declare function previewVerificationExecution(workdirInput: string, selection?: {
-    outcome?: string;
-    check?: string;
-}): Promise<VerificationExecutionPreviewV1>;
-export declare function projectVerificationExecutionPreview(compiled: CompiledDeliveryContractV2, authorityRevision: number, selection?: {
-    outcome?: string;
-    check?: string;
-}): VerificationExecutionPreviewV1;
-export {};

package/dist/lib/long-task-verification-preview.js

@@ -1,120 +0,0 @@
-import path from "node:path";
-import { loadActiveLongTaskAuthority } from "./long-task-state.js";
-import { selectChecks } from "./long-task-verifier-v2.js";
-import { repositoryRoot } from "./long-task-workspace.js";
-export async function previewVerificationExecution(workdirInput, selection = {}) {
-    const repository = await repositoryRoot(process.cwd());
-    const active = (await loadActiveLongTaskAuthority(repository, { migrate_legacy: true })).authority;
-    if (!active)
-        throw new Error("active_task_missing");
-    if (active.workdir !== path.resolve(workdirInput))
-        throw new Error("active_task_workdir_mismatch");
-    return projectVerificationExecutionPreview(active.authority_snapshot, active.authority_revision, selection);
-}
-export function projectVerificationExecutionPreview(compiled, authorityRevision, selection = {}) {
-    const selected = selectChecks(compiled, selection);
-    const mainRawExecutions = mainExecutionPreviews(selected);
-    const counterfactualExecutions = counterfactualExecutionPreviews(compiled, selected);
-    const declaredRunnerInvocationUpperBound = mainRawExecutions.length + counterfactualExecutions.length;
-    return {
-        schema_version: "long-task-verification-preview-v1",
-        compiled_identity: compiled.compiled_identity,
-        authority_revision: authorityRevision,
-        acceptance_authorized: false,
-        executes_checks: false,
-        writes_progress: false,
-        selected_outcome: selection.outcome ?? null,
-        selected_check: selection.check ?? null,
-        main_raw_executions: mainRawExecutions,
-        counterfactual_executions: counterfactualExecutions,
-        summary: {
-            selected_checks: selected.length,
-            unique_main_runner_invocations: mainRawExecutions.length,
-            counterfactual_runner_invocation_upper_bound: counterfactualExecutions.length,
-            declared_runner_invocation_upper_bound: declaredRunnerInvocationUpperBound,
-            declared_command_attempt_upper_bound: [
-                ...mainRawExecutions.map((entry) => entry.runner),
-                ...counterfactualExecutions.map((entry) => entry.runner),
-            ].reduce((total, runner) => total + maximumAttempts(runner), 0),
-        },
-        limitations: [
-            "This preview does not evaluate current-snapshot pre-run findings; verification may stop before invoking a runner.",
-            "Counts describe Harness runner invocations and declared retry attempts, not subprocesses, builds, elapsed time, or work performed internally by a project runner.",
-            "The preview is not verification evidence and cannot authorize acceptance.",
-        ],
-    };
-}
-function mainExecutionPreviews(checks) {
-    const groups = new Map();
-    for (const check of checks) {
-        const existing = groups.get(check.raw_execution_identity) ?? [];
-        existing.push(check);
-        groups.set(check.raw_execution_identity, existing);
-    }
-    return [...groups.entries()]
-        .sort(([left], [right]) => left.localeCompare(right))
-        .map(([rawExecutionIdentity, groupedChecks]) => {
-        const check = groupedChecks[0];
-        return {
-            raw_execution_identity: rawExecutionIdentity,
-            check_refs: groupedChecks.map(checkRef).sort(),
-            execution_target: check.execution_target,
-            execution_target_definition: check.execution_target_definition,
-            runner: runnerPreview(check),
-            environment_requirements: check.environment_requirements,
-        };
-    });
-}
-function counterfactualExecutionPreviews(compiled, checks) {
-    const selected = new Map(checks.map((check) => [checkRef(check), check]));
-    const result = [];
-    for (const control of compiled.global.acceptance.counterfactual_controls) {
-        const check = selected.get(`GLOBAL:${control.check_key}`);
-        if (check)
-            result.push({
-                scope: "global",
-                outcome_key: null,
-                control_key: control.key,
-                check_ref: checkRef(check),
-                raw_execution_identity: check.raw_execution_identity,
-                mutation: control.mutation,
-                runner: runnerPreview(check),
-            });
-    }
-    for (const outcome of compiled.outcomes)
-        for (const control of outcome.acceptance.counterfactual_controls) {
-            const check = selected.get(`${outcome.key}:${control.check_key}`);
-            if (check)
-                result.push({
-                    scope: "outcome",
-                    outcome_key: outcome.key,
-                    control_key: control.key,
-                    check_ref: checkRef(check),
-                    raw_execution_identity: check.raw_execution_identity,
-                    mutation: control.mutation,
-                    runner: runnerPreview(check),
-                });
-        }
-    return result.sort((left, right) => `${left.check_ref}:${left.control_key}`.localeCompare(`${right.check_ref}:${right.control_key}`));
-}
-function checkRef(check) {
-    return `${check.outcome_key ?? "GLOBAL"}:${check.key}`;
-}
-function runnerPreview(check) {
-    return {
-        type: check.runner.type,
-        target: check.runner.target,
-        argv: check.runner.argv,
-        cwd: check.runner.cwd,
-        timeout_ms: check.runner.timeout_ms,
-        effect: check.runner.effect,
-        retry_policy: check.runner.retry_policy,
-        idempotent: check.runner.idempotent,
-        resolved_cwd: check.runner.resolved_cwd,
-        resolved_target: check.runner.resolved_target,
-        definition_sha256: check.runner.definition_sha256,
-    };
-}
-function maximumAttempts(runner) {
-    return runner.retry_policy === "transient_once" ? 2 : 1;
-}

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

@@ -1,12 +0,0 @@
-import type { VerifierContentAuthority, VerifierIdentityV2, VerifierRuntimeLocator } from "./long-task-delivery-types.js";
-export interface VerifierAuthorityDiffV2 {
-    verifier_content_changed: boolean;
-    verifier_runtime_locator_changed: boolean;
-    verifier_files_changed: string[];
-    previous_verifier: VerifierIdentityV2;
-    next_verifier: VerifierIdentityV2;
-}
-export declare function verifierContentAuthority(identity: VerifierIdentityV2): VerifierContentAuthority;
-export declare function verifierRuntimeLocator(identity: VerifierIdentityV2): VerifierRuntimeLocator;
-export declare function verifierAuthorityDiff(previous: VerifierIdentityV2, next: VerifierIdentityV2): VerifierAuthorityDiffV2;
-export declare function verifierIdentityMatches(previous: VerifierIdentityV2, next: VerifierIdentityV2): boolean;

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

@@ -1,49 +0,0 @@
-import { canonicalValueJson } from "./strict-codec.js";
-export function verifierContentAuthority(identity) {
-    return {
-        package_name: identity.package_name,
-        bundle_sha256: identity.bundle_sha256,
-        schema_sha256: identity.schema_sha256,
-        hook_sha256: identity.hook_sha256,
-        bundle_files: identity.bundle_files,
-    };
-}
-export function verifierRuntimeLocator(identity) {
-    return {
-        package_version: identity.package_version,
-        package_root: identity.package_root,
-    };
-}
-export function verifierAuthorityDiff(previous, next) {
-    const contentChanged = canonicalValueJson(verifierContentAuthority(previous)) !==
-        canonicalValueJson(verifierContentAuthority(next));
-    const locatorChanged = canonicalValueJson(verifierRuntimeLocator(previous)) !==
-        canonicalValueJson(verifierRuntimeLocator(next));
-    return {
-        verifier_content_changed: contentChanged,
-        verifier_runtime_locator_changed: locatorChanged,
-        verifier_files_changed: changedVerifierFiles(previous, next),
-        previous_verifier: previous,
-        next_verifier: next,
-    };
-}
-export function verifierIdentityMatches(previous, next) {
-    const diff = verifierAuthorityDiff(previous, next);
-    return (!diff.verifier_content_changed && !diff.verifier_runtime_locator_changed);
-}
-function changedVerifierFiles(previous, next) {
-    const files = new Set([
-        ...Object.keys(previous.bundle_files),
-        ...Object.keys(next.bundle_files),
-    ]);
-    const changed = [...files].filter((file) => previous.bundle_files[file] !== next.bundle_files[file]);
-    if (previous.bundle_sha256 !== next.bundle_sha256)
-        changed.push("<bundle>");
-    if (previous.schema_sha256 !== next.schema_sha256)
-        changed.push("<schema>");
-    if (previous.hook_sha256 !== next.hook_sha256)
-        changed.push("<hook>");
-    if (previous.package_name !== next.package_name)
-        changed.push("<package-name>");
-    return [...new Set(changed)].sort();
-}

package/dist/lib/long-task-verifier-counterfactuals.d.ts

@@ -1,11 +0,0 @@
-import type { CheckExecutionResultV2, CompiledCheckV2, CompiledDeliveryContractV2, LongTaskFindingV2, RawCommandExecutionV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-export declare function evaluateSelectedCounterfactuals(input: {
-    compiled: CompiledDeliveryContractV2;
-    selected_checks: readonly CompiledCheckV2[];
-    complete_checks: readonly CompiledCheckV2[];
-    snapshot_root: string;
-    snapshot_manifest: WorkspaceManifestV2;
-    observation_authority_paths: readonly string[];
-    baseline_results: readonly CheckExecutionResultV2[];
-    baseline_executions: ReadonlyMap<string, RawCommandExecutionV2>;
-}): Promise<LongTaskFindingV2[]>;

package/dist/lib/long-task-verifier-counterfactuals.js

@@ -1,96 +0,0 @@
-import { counterfactualExecutionMayOverlap, evaluateGlobalCounterfactuals, evaluateOutcomeCounterfactuals, } from "./long-task-evidence-v2.js";
-import { MAX_OVERLAPPING_RUNNERS } from "./long-task-verifier-execution.js";
-export async function evaluateSelectedCounterfactuals(input) {
-    const passingCheckIds = new Set(input.baseline_results
-        .filter((result) => result.status === "passed")
-        .map((result) => result.internal_id));
-    const tasks = [
-        ...globalCounterfactualTasks(input, passingCheckIds),
-        ...outcomeCounterfactualTasks(input, passingCheckIds),
-    ];
-    const findings = [];
-    for (let index = 0; index < tasks.length;) {
-        const batch = eligibleCounterfactualBatch(tasks, index);
-        const results = await Promise.all(batch.map((task) => task.run()));
-        for (const result of results)
-            findings.push(...result);
-        index += batch.length;
-    }
-    return findings;
-}
-function globalCounterfactualTasks(input, passingCheckIds) {
-    const selectedCheckKeys = new Set(input.selected_checks
-        .filter((check) => check.outcome_key === null && passingCheckIds.has(check.internal_id))
-        .map((check) => check.key));
-    return input.compiled.global.acceptance.counterfactual_controls
-        .filter((control) => selectedCheckKeys.has(control.check_key))
-        .map((control) => {
-        const selectedCompiled = {
-            ...input.compiled,
-            global: {
-                ...input.compiled.global,
-                acceptance: {
-                    ...input.compiled.global.acceptance,
-                    counterfactual_controls: [control],
-                },
-            },
-        };
-        const check = input.compiled.global.acceptance.checks.find((candidate) => candidate.key === control.check_key);
-        return {
-            overlap_eligible: counterfactualExecutionMayOverlap({
-                check,
-                control,
-                protected_authority_paths: input.observation_authority_paths,
-            }),
-            run: () => evaluateGlobalCounterfactuals(selectedCompiled, input.snapshot_root, new Set([control.check_key]), input.snapshot_manifest, input.baseline_results, input.baseline_executions, input.complete_checks),
-        };
-    });
-}
-function outcomeCounterfactualTasks(input, passingCheckIds) {
-    const selectedOutcomeKeys = new Set(input.selected_checks
-        .map((check) => check.outcome_key)
-        .filter((key) => Boolean(key)));
-    return input.compiled.outcomes
-        .filter((outcome) => selectedOutcomeKeys.has(outcome.key))
-        .flatMap((outcome) => {
-        const selectedCheckKeys = new Set(input.selected_checks
-            .filter((check) => check.outcome_key === outcome.key &&
-            passingCheckIds.has(check.internal_id))
-            .map((check) => check.key));
-        return outcome.acceptance.counterfactual_controls
-            .filter((control) => selectedCheckKeys.has(control.check_key))
-            .map((control) => {
-            const check = outcome.acceptance.checks.find((candidate) => candidate.key === control.check_key);
-            const selectedOutcome = {
-                ...outcome,
-                acceptance: {
-                    ...outcome.acceptance,
-                    counterfactual_controls: [control],
-                },
-            };
-            return {
-                overlap_eligible: counterfactualExecutionMayOverlap({
-                    check,
-                    control,
-                    protected_authority_paths: input.observation_authority_paths,
-                }),
-                run: () => evaluateOutcomeCounterfactuals(selectedOutcome, input.snapshot_root, input.snapshot_manifest, input.observation_authority_paths, input.baseline_results, input.baseline_executions, input.complete_checks),
-            };
-        });
-    });
-}
-function eligibleCounterfactualBatch(tasks, index) {
-    const first = tasks[index];
-    if (!first)
-        return [];
-    const batch = [first];
-    if (!first.overlap_eligible)
-        return batch;
-    while (batch.length < MAX_OVERLAPPING_RUNNERS) {
-        const next = tasks[index + batch.length];
-        if (!next?.overlap_eligible)
-            break;
-        batch.push(next);
-    }
-    return batch;
-}

package/dist/lib/long-task-verifier-dependency-closure.d.ts

@@ -1,3 +0,0 @@
-import type { WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-export declare function freezeLocalVerifierDependencyClosure(repository: string, roots: Iterable<string>, manifest: WorkspaceManifestV2, runtimeOwnedPatterns?: readonly string[]): Promise<Record<string, string>>;
-export declare function packageScriptVerifierRoots(script: string, packageFile: string, manifest: WorkspaceManifestV2): string[];

package/dist/lib/long-task-verifier-dependency-closure.js

@@ -1,183 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { classifyRepositoryPatternOverlap, matchesRepoPattern, } from "./long-task-paths.js";
-import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
-import { sha256Hex } from "./strict-codec.js";
-const SCRIPT_EXTENSIONS = new Set([
-    ".js",
-    ".jsx",
-    ".mjs",
-    ".cjs",
-    ".ts",
-    ".tsx",
-    ".mts",
-    ".cts",
-]);
-const RESOLUTION_EXTENSIONS = [
-    "",
-    ".js",
-    ".mjs",
-    ".cjs",
-    ".jsx",
-    ".ts",
-    ".mts",
-    ".cts",
-    ".tsx",
-    ".json",
-];
-export async function freezeLocalVerifierDependencyClosure(repository, roots, manifest, runtimeOwnedPatterns = []) {
-    const available = new Set(manifest.files.map((file) => file.path));
-    const result = {};
-    const queued = [...new Set(roots)].filter((file) => SCRIPT_EXTENSIONS.has(path.posix.extname(file).toLowerCase()));
-    const visited = new Set();
-    while (queued.length) {
-        const relative = queued.shift();
-        if (visited.has(relative))
-            continue;
-        visited.add(relative);
-        if (!available.has(relative))
-            throw new Error(`verification_dependency_not_found:${relative}`);
-        const absolute = await assertProtectedRepositoryFile(repository, path.join(repository, ...relative.split("/")), "verification_dependency");
-        const bytes = await readFile(absolute);
-        result[relative] = sha256Hex(bytes);
-        const source = bytes.toString("utf8");
-        if (hasNonLiteralLoader(source))
-            throw new Error(`verification_dependency_dynamic_unresolved:${relative}`);
-        for (const specifier of staticSpecifiers(source)) {
-            if (!isLocalSpecifier(specifier))
-                continue;
-            const dependency = resolveLocalSpecifier(relative, specifier, available);
-            const unresolvedBase = localSpecifierBase(relative, specifier);
-            if ((dependency &&
-                runtimeOwnedPatterns.some((pattern) => matchesRepoPattern(dependency, pattern))) ||
-                (!dependency &&
-                    unresolvedBase &&
-                    runtimeOwnedPatterns.some((pattern) => runtimePatternOwns(unresolvedBase, pattern))))
-                continue;
-            if (!dependency)
-                throw new Error(`verification_dependency_not_found:${relative}:${specifier}`);
-            if (SCRIPT_EXTENSIONS.has(path.posix.extname(dependency).toLowerCase()))
-                queued.push(dependency);
-            else {
-                const dependencyFile = await assertProtectedRepositoryFile(repository, path.join(repository, ...dependency.split("/")), "verification_dependency");
-                result[dependency] = sha256Hex(await readFile(dependencyFile));
-            }
-        }
-    }
-    return sortRecord(result);
-}
-export function packageScriptVerifierRoots(script, packageFile, manifest) {
-    const tokens = staticPackageScriptTokens(script);
-    if (!tokens.length || !["node", "node.exe"].includes(tokens[0].toLowerCase()))
-        throw new Error("package_script_dependency_closure_unresolved:node_entry_required");
-    if (tokens.length < 2 || tokens[1].startsWith("-"))
-        throw new Error("package_script_dependency_closure_unresolved:static_entry_required");
-    const packageDirectory = path.posix.dirname(packageFile);
-    const candidate = path.posix.normalize(path.posix.join(packageDirectory === "." ? "" : packageDirectory, tokens[1]));
-    if (candidate === ".." ||
-        candidate.startsWith("../") ||
-        !manifest.files.some((file) => file.path === candidate) ||
-        !SCRIPT_EXTENSIONS.has(path.posix.extname(candidate).toLowerCase()))
-        throw new Error(`package_script_dependency_closure_unresolved:entry_not_found:${tokens[1]}`);
-    return [candidate];
-}
-function staticPackageScriptTokens(script) {
-    const tokens = [];
-    let current = "";
-    let quote = null;
-    for (let index = 0; index < script.length; index += 1) {
-        const character = script[index];
-        if (!quote && /\s/u.test(character)) {
-            if (current) {
-                tokens.push(current);
-                current = "";
-            }
-            continue;
-        }
-        if (character === "'" || character === '"') {
-            if (!quote) {
-                quote = character;
-                continue;
-            }
-            if (quote === character) {
-                quote = null;
-                continue;
-            }
-        }
-        if ((!quote && /[&|;<>()]/u.test(character)) ||
-            character === "`" ||
-            character === "$" ||
-            character === "%" ||
-            character === "!")
-            throw new Error("package_script_dependency_closure_unresolved:dynamic_shell_syntax");
-        current += character;
-    }
-    if (quote)
-        throw new Error("package_script_dependency_closure_unresolved:unterminated_quote");
-    if (current)
-        tokens.push(current);
-    return tokens;
-}
-function staticSpecifiers(source) {
-    const result = [];
-    const patterns = [
-        /\b(?:import|export)\s+(?:[^"'`]*?\s+from\s+)?["']([^"']+)["']/gu,
-        /\bimport\s*\(\s*["']([^"']+)["']\s*\)/gu,
-        /\brequire\s*\(\s*["']([^"']+)["']\s*\)/gu,
-        /\brequire\.resolve\s*\(\s*["']([^"']+)["']\s*\)/gu,
-        /\bmodule\.require\s*\(\s*["']([^"']+)["']\s*\)/gu,
-        /\bnew\s+URL\s*\(\s*["']([^"']+)["']\s*,\s*import\.meta\.url\s*\)/gu,
-    ];
-    for (const pattern of patterns)
-        for (const match of source.matchAll(pattern))
-            result.push(match[1]);
-    return [...new Set(result)];
-}
-function hasNonLiteralLoader(source) {
-    return (/\b(?:import|require)\s*\(\s*(?!["'])[^)]/u.test(source) ||
-        /\brequire\.resolve\s*\(\s*(?!["'])[^)]/u.test(source) ||
-        /\bmodule\.require\s*\(\s*(?!["'])[^)]/u.test(source) ||
-        /\bnew\s+URL\s*\(\s*(?!["'])[^,]+,\s*import\.meta\.url\s*\)/u.test(source) ||
-        /\bcreateRequire\b/u.test(source));
-}
-function isLocalSpecifier(specifier) {
-    return (specifier.startsWith("./") ||
-        specifier.startsWith("../") ||
-        specifier.startsWith("/"));
-}
-function resolveLocalSpecifier(importer, specifier, available) {
-    const base = localSpecifierBase(importer, specifier);
-    if (!base)
-        return null;
-    if (base.startsWith("../") || base === "..")
-        return null;
-    for (const extension of RESOLUTION_EXTENSIONS) {
-        const candidate = `${base}${extension}`;
-        if (available.has(candidate))
-            return candidate;
-    }
-    for (const extension of RESOLUTION_EXTENSIONS.slice(1)) {
-        const candidate = `${base}/index${extension}`;
-        if (available.has(candidate))
-            return candidate;
-    }
-    return null;
-}
-function localSpecifierBase(importer, specifier) {
-    const base = specifier.startsWith("/")
-        ? specifier.slice(1)
-        : path.posix.normalize(path.posix.join(path.posix.dirname(importer), specifier));
-    const canonicalBase = base.replace(/\/+$/u, "") || ".";
-    return canonicalBase === ".." || canonicalBase.startsWith("../")
-        ? null
-        : canonicalBase;
-}
-function runtimePatternOwns(base, pattern) {
-    const directoryPattern = base === "." ? "**" : `${base}/**`;
-    return ((base !== "." && matchesRepoPattern(base, pattern)) ||
-        classifyRepositoryPatternOverlap(directoryPattern, pattern).status ===
-            "proven_overlap");
-}
-function sortRecord(value) {
-    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)));
-}

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

@@ -1,9 +0,0 @@
-import type { CompiledCheckV2, RawCommandExecutionV2 } from "./long-task-delivery-types.js";
-import type { PreparedExecutionObservationGroupV2 } from "./long-task-execution-observation.js";
-export declare const MAX_OVERLAPPING_RUNNERS = 3;
-export declare function executePreparedRawExecutionGroups(input: {
-    selected_groups: readonly (readonly CompiledCheckV2[])[];
-    complete_groups: readonly (readonly CompiledCheckV2[])[];
-    prepared_groups: readonly PreparedExecutionObservationGroupV2[];
-}): Promise<Map<string, RawCommandExecutionV2>>;
-export declare function rawExecutionGroupMayOverlap(checks: readonly CompiledCheckV2[]): boolean;

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

@@ -1,67 +0,0 @@
-import { executeCheckRunner } from "./long-task-check-runner.js";
-export const MAX_OVERLAPPING_RUNNERS = 3;
-export async function executePreparedRawExecutionGroups(input) {
-    try {
-        const tasks = preparedRawExecutionTasks(input);
-        const pending = [];
-        for (let index = 0; index < tasks.length;) {
-            const batch = eligibleRunnerBatch(tasks, index);
-            pending.push(...(await Promise.all(batch.map((task) => task.run()))));
-            index += batch.length;
-        }
-        const finalized = await Promise.all(pending.map(async (entry) => ({
-            raw_execution_identity: entry.raw_execution_identity,
-            raw: await entry.prepared.finalize(entry.raw),
-        })));
-        return new Map(finalized.map((entry) => [entry.raw_execution_identity, entry.raw]));
-    }
-    finally {
-        await Promise.all(input.prepared_groups.map((prepared) => prepared.dispose()));
-    }
-}
-function preparedRawExecutionTasks(input) {
-    return input.selected_groups.map((group, index) => {
-        const prepared = input.prepared_groups[index];
-        const complete = input.complete_groups[index];
-        if (!prepared || !complete)
-            throw new Error("raw_execution_group_prepare_missing");
-        return {
-            overlap_eligible: rawExecutionGroupMayOverlap(complete),
-            run: async () => ({
-                raw_execution_identity: group[0].raw_execution_identity,
-                raw: await executeCheckRunner(group[0], prepared.execution_root, prepared.runner_context),
-                prepared,
-            }),
-        };
-    });
-}
-function eligibleRunnerBatch(tasks, index) {
-    const first = tasks[index];
-    if (!first)
-        return [];
-    const batch = [first];
-    if (!first.overlap_eligible)
-        return batch;
-    while (batch.length < MAX_OVERLAPPING_RUNNERS) {
-        const next = tasks[index + batch.length];
-        if (!next?.overlap_eligible)
-            break;
-        batch.push(next);
-    }
-    return batch;
-}
-export function rawExecutionGroupMayOverlap(checks) {
-    if (!checks.length)
-        return false;
-    const runner = checks[0].runner;
-    if (runner.effect !== "read_only" ||
-        !runner.idempotent ||
-        runner.retry_policy !== "none" ||
-        checks[0].environment_requirements.some((requirement) => requirement.kind === "loopback_tcp"))
-        return false;
-    const processChecks = checks.filter((check) => (check.observation_authorities ?? []).some((authority) => authority.authority === "package_process_json_exact"));
-    if (!processChecks.length)
-        return false;
-    const closureIdentities = new Set(processChecks.map((check) => check.process_runtime_closure?.closure_identity ?? null));
-    return closureIdentities.size === 1 && !closureIdentities.has(null);
-}

package/dist/lib/long-task-verifier-identity.d.ts

@@ -1,2 +0,0 @@
-import type { VerifierIdentityV2 } from "./long-task-delivery-types.js";
-export declare function captureVerifierIdentity(repositoryRoot: string, requireHook: boolean): Promise<VerifierIdentityV2>;