project-tiny-context-harness 0.8.16 → 0.11.0

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

@@ -0,0 +1,96 @@
+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-execution.d.ts

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

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

@@ -6,6 +6,7 @@ import OUTCOMES_SCHEMA from "../schemas/long-task-delivery-v2/long-task-outcomes
 import { checkLongTaskCompletionGate } from "./long-task-hook-preflight.js";
 import { assertProtectedRepositoryFile } from "./long-task-protected-files.js";
 import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
+import { WINDOWS_JOB_SUPERVISOR_ASSET_RELATIVE_FILES } from "./long-task-windows-job-supervisor-protocol.js";
 const REQUIRED_ENTRYPOINTS = [
     "cli.js",
     "long-task-hook.js",
@@ -45,11 +46,21 @@ async function verifierBundleFiles(packageRoot) {
             relativeFiles.add(`lib/${file}`);
     relativeFiles.add("schemas/long-task-delivery-v2/long-task-delivery-v2.schema.json");
     relativeFiles.add("schemas/long-task-delivery-v2/long-task-outcomes-v2.schema.json");
-    const rows = await Promise.all([...relativeFiles]
-        .sort()
-        .map(async (relative) => [
-        relative,
-        sha256Hex(await readFile(await assertProtectedRepositoryFile(packageRoot, path.join(distRoot, ...relative.split("/")), `package_owned_verifier:${relative}`))),
+    const bundleTargets = [
+        ...[...relativeFiles].map((relative) => ({
+            key: relative,
+            absolute: path.join(distRoot, ...relative.split("/")),
+        })),
+        ...WINDOWS_JOB_SUPERVISOR_ASSET_RELATIVE_FILES.map((relative) => ({
+            key: relative,
+            absolute: path.join(packageRoot, ...relative.split("/")),
+        })),
+    ];
+    const rows = await Promise.all(bundleTargets
+        .sort((left, right) => left.key.localeCompare(right.key))
+        .map(async ({ key, absolute }) => [
+        key,
+        sha256Hex(await readFile(await assertProtectedRepositoryFile(packageRoot, absolute, `package_owned_verifier:${key}`))),
     ]));
     return Object.fromEntries(rows);
 }

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

@@ -1,14 +1,16 @@
 import { deliveryCompileFreshness } from "./long-task-freshness.js";
 import { assertVerifierAuthorityCurrent } from "./long-task-freshness.js";
 import { enrichCheckResultFindings, enrichFinding, } from "./long-task-finding-context.js";
-import { executeCheckRunner } from "./long-task-check-runner.js";
 import { prepareExecutionObservationUniverse } from "./long-task-execution-observation.js";
-import { evaluateCheckEvidence, evaluateGlobalCounterfactuals, evaluateOutcomeCounterfactuals, } from "./long-task-evidence-v2.js";
+import { evaluateCheckEvidence } from "./long-task-evidence-v2.js";
 import { matchesRepoPattern } from "./long-task-paths.js";
-import { activeAuthorityIdentityMatches, loadActiveLongTaskAuthority, writeProgressRecord, } from "./long-task-state.js";
+import { deriveRepairFrontier } from "./long-task-repair-frontier.js";
+import { activeAuthorityIdentityMatches, loadActiveLongTaskAuthority, readProgressRecords, writeProgressRecord, } from "./long-task-state.js";
 import { createProgressRecord } from "./long-task-progress.js";
 import { changedWorkspacePaths, createWorkspaceSnapshot, repositoryRoot, } from "./long-task-workspace.js";
 import { classifyWorkspaceScope, protectedWorkspacePaths, } from "./long-task-workspace-scope.js";
+import { evaluateSelectedCounterfactuals } from "./long-task-verifier-counterfactuals.js";
+import { executePreparedRawExecutionGroups } from "./long-task-verifier-execution.js";
 export async function verifyDeliveryContract(workdir, selection = {}) {
     const repository = await repositoryRoot(process.cwd());
     const active = (await loadActiveLongTaskAuthority(repository, { migrate_legacy: true })).authority;
@@ -25,6 +27,7 @@ export async function verifyDeliveryContract(workdir, selection = {}) {
         worktree_identity: active.worktree_identity,
     };
     const selected = selectChecks(compiled, selection);
+    const existingProgress = await readProgressRecords(active.workdir);
     const snapshot = await createWorkspaceSnapshot(compiled.repository_root, compiled.workdir, `verify-${compiled.task.id}`);
     try {
         const run = await runDeliveryChecks(compiled, snapshot, selected, true);
@@ -51,6 +54,12 @@ export async function verifyDeliveryContract(workdir, selection = {}) {
                 message: "Active Authority changed while targeted verification was running.",
                 next_action: "Discard the stale progress and rerun verification against the active Authority Revision.",
             });
+            const repairFrontier = deriveRepairFrontier({
+                compiled,
+                manifest: snapshot.manifest,
+                progress: existingProgress,
+                findings: run.findings,
+            });
             return {
                 schema_version: "long-task-targeted-progress-v2",
                 compiled_identity: compiled.compiled_identity,
@@ -61,10 +70,21 @@ export async function verifyDeliveryContract(workdir, selection = {}) {
                 updated_progress_records: [],
                 check_results: run.check_results,
                 findings: run.findings,
+                repair_frontier: repairFrontier,
                 completed_at: new Date().toISOString(),
             };
         }
         await Promise.all(records.map((record) => writeProgressRecord(workdir, record)));
+        const updatedProgress = {
+            ...existingProgress,
+            ...Object.fromEntries(records.map((record) => [record.check_internal_id, record])),
+        };
+        const repairFrontier = deriveRepairFrontier({
+            compiled,
+            manifest: snapshot.manifest,
+            progress: updatedProgress,
+            findings: run.findings,
+        });
         return {
             schema_version: "long-task-targeted-progress-v2",
             compiled_identity: compiled.compiled_identity,
@@ -75,6 +95,7 @@ export async function verifyDeliveryContract(workdir, selection = {}) {
             updated_progress_records: records.map((record) => record.check_internal_id),
             check_results: run.check_results,
             findings: run.findings,
+            repair_frontier: repairFrontier,
             completed_at: new Date().toISOString(),
         };
     }
@@ -86,12 +107,16 @@ async function resolved(workdir) {
     return (await import("node:path")).default.resolve(workdir);
 }
 export async function runDeliveryChecks(compiled, snapshot, checks, includeCounterfactuals, finalGate = false) {
+    const completeChecks = allCompiledChecks(compiled);
     const observationAuthorityPaths = [
-        compiled.contract_file,
-        ...Object.keys(compiled.contract_files),
-        ...Object.keys(compiled.source_hashes),
-        ...compiled.context_snapshot.files,
-    ];
+        ...new Set([
+            compiled.contract_file,
+            ...Object.keys(compiled.contract_files),
+            ...Object.keys(compiled.source_hashes),
+            ...compiled.context_snapshot.files,
+            ...completeChecks.flatMap((check) => check.protected_authority_paths ?? []),
+        ]),
+    ].sort((left, right) => Buffer.from(left).compare(Buffer.from(right)));
     const findings = await preRunFindings(compiled, snapshot.manifest);
     if (finalGate)
         findings.push(...finalPathFindings(compiled, snapshot.manifest));
@@ -101,8 +126,6 @@ export async function runDeliveryChecks(compiled, snapshot, checks, includeCount
             check_results: [],
             findings: findings.map((finding) => enrichFinding(compiled, finding)),
         };
-    const rawExecutions = new Map();
-    const completeChecks = allCompiledChecks(compiled);
     const selectedExecutionGroups = rawExecutionGroups(checks);
     const completeExecutionGroups = selectedExecutionGroups.map((group) => completeChecks.filter((check) => check.raw_execution_identity === group[0].raw_execution_identity));
     const preparedExecutionGroups = await prepareExecutionObservationUniverse({
@@ -111,28 +134,11 @@ export async function runDeliveryChecks(compiled, snapshot, checks, includeCount
         workspace_manifest: snapshot.manifest,
         protected_authority_paths: observationAuthorityPaths,
     });
-    try {
-        const pending = [];
-        for (const [index, group] of selectedExecutionGroups.entries()) {
-            const prepared = preparedExecutionGroups[index];
-            if (!prepared)
-                throw new Error("raw_execution_group_prepare_missing");
-            pending.push({
-                raw_execution_identity: group[0].raw_execution_identity,
-                raw: await executeCheckRunner(group[0], prepared.execution_root, prepared.runner_context),
-                prepared,
-            });
-        }
-        const finalized = await Promise.all(pending.map(async (entry) => ({
-            raw_execution_identity: entry.raw_execution_identity,
-            raw: await entry.prepared.finalize(entry.raw),
-        })));
-        for (const entry of finalized)
-            rawExecutions.set(entry.raw_execution_identity, entry.raw);
-    }
-    finally {
-        await Promise.all(preparedExecutionGroups.map((prepared) => prepared.dispose()));
-    }
+    const rawExecutions = await executePreparedRawExecutionGroups({
+        selected_groups: selectedExecutionGroups,
+        complete_groups: completeExecutionGroups,
+        prepared_groups: preparedExecutionGroups,
+    });
     const mainCheckResults = [];
     for (const check of checks) {
         const raw = rawExecutions.get(check.raw_execution_identity);
@@ -143,39 +149,20 @@ export async function runDeliveryChecks(compiled, snapshot, checks, includeCount
             : undefined;
         mainCheckResults.push(await evaluateCheckEvidence(check, raw, snapshot.root, outcome, observationAuthorityPaths));
     }
-    const counterfactualFindings = [];
-    if (includeCounterfactuals) {
-        // Counterfactual sensitivity is a closure condition for an otherwise
-        // passing proof. A failed or externally blocked owning Check already
-        // blocks acceptance; rerunning its oracle in a mutated sandbox can only
-        // obscure that primary status (for example, by turning a typed external
-        // blocker into an integrity failure).
-        const passingCheckIds = new Set(mainCheckResults
-            .filter((result) => result.status === "passed")
-            .map((result) => result.internal_id));
-        const selectedGlobalCheckKeys = new Set(checks
-            .filter((check) => check.outcome_key === null &&
-            passingCheckIds.has(check.internal_id))
-            .map((check) => check.key));
-        if (selectedGlobalCheckKeys.size)
-            counterfactualFindings.push(...(await evaluateGlobalCounterfactuals(compiled, snapshot.root, selectedGlobalCheckKeys, snapshot.manifest, mainCheckResults, rawExecutions, completeChecks)));
-        const outcomeKeys = new Set(checks
-            .map((check) => check.outcome_key)
-            .filter((key) => Boolean(key)));
-        for (const outcome of compiled.outcomes.filter((item) => outcomeKeys.has(item.key))) {
-            const selectedKeys = new Set(checks
-                .filter((check) => check.outcome_key === outcome.key &&
-                passingCheckIds.has(check.internal_id))
-                .map((check) => check.key));
-            counterfactualFindings.push(...(await evaluateOutcomeCounterfactuals({
-                ...outcome,
-                acceptance: {
-                    ...outcome.acceptance,
-                    counterfactual_controls: outcome.acceptance.counterfactual_controls.filter((control) => selectedKeys.has(control.check_key)),
-                },
-            }, snapshot.root, snapshot.manifest, observationAuthorityPaths, mainCheckResults, rawExecutions, completeChecks)));
-        }
-    }
+    // Sensitivity runs only for otherwise passing owners, so an external or
+    // failed primary result cannot be obscured by a mutated-sandbox finding.
+    const counterfactualFindings = includeCounterfactuals
+        ? await evaluateSelectedCounterfactuals({
+            compiled,
+            selected_checks: checks,
+            complete_checks: completeChecks,
+            snapshot_root: snapshot.root,
+            snapshot_manifest: snapshot.manifest,
+            observation_authority_paths: observationAuthorityPaths,
+            baseline_results: mainCheckResults,
+            baseline_executions: rawExecutions,
+        })
+        : [];
     const unassignedCounterfactuals = counterfactualFindings.filter((finding) => !mainCheckResults.some((result) => findingBelongsToCheck(finding, result)));
     const unassignedFinding = unassignedCounterfactuals.length
         ? unassignedCounterfactualFinding(unassignedCounterfactuals)

package/dist/lib/long-task-windows-job-supervisor-helper.d.ts

@@ -0,0 +1 @@
+export declare function runOneWindowsJobHelperRequest(powershell: string, helper: string, request: string, helperTimeoutMs: number): Promise<string>;

package/dist/lib/long-task-windows-job-supervisor-helper.js

@@ -0,0 +1,104 @@
+import { spawn } from "node:child_process";
+const HELPER_RESPONSE_LIMIT = 64 * 1024;
+const HELPER_DIAGNOSTIC_LIMIT = 1024 * 1024;
+const HELPER_TERMINATION_GRACE_MS = 5_000;
+export function runOneWindowsJobHelperRequest(powershell, helper, request, helperTimeoutMs) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(powershell, [
+            "-NoLogo",
+            "-NoProfile",
+            "-NonInteractive",
+            "-ExecutionPolicy",
+            "Bypass",
+            "-File",
+            helper,
+        ], {
+            shell: false,
+            windowsHide: true,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const stdout = [];
+        const stderr = [];
+        let stdoutBytes = 0;
+        let stderrBytes = 0;
+        let settled = false;
+        let pendingError = null;
+        let terminationTimer = null;
+        const timer = setTimeout(() => {
+            stopHelper(new Error("process_observer_windows_job_unavailable:helper_timeout"));
+        }, helperTimeoutMs);
+        child.stdout.on("data", (chunk) => {
+            stdoutBytes += chunk.length;
+            if (stdoutBytes > HELPER_RESPONSE_LIMIT) {
+                stopHelper(new Error("process_observer_windows_job_result_invalid:response_limit"));
+                return;
+            }
+            stdout.push(Buffer.from(chunk));
+        });
+        child.stderr.on("data", (chunk) => {
+            const remaining = HELPER_DIAGNOSTIC_LIMIT - stderrBytes;
+            if (remaining <= 0)
+                return;
+            const retained = Buffer.from(chunk).subarray(0, remaining);
+            stderr.push(retained);
+            stderrBytes += retained.length;
+        });
+        child.stdin.once("error", (error) => stopHelper(new Error(`process_observer_windows_job_unavailable:request_write:${message(error)}`)));
+        child.once("error", (error) => {
+            const helperError = new Error(`process_observer_windows_job_unavailable:helper_spawn:${message(error)}`);
+            if (child.pid)
+                stopHelper(helperError);
+            else
+                finish(helperError);
+        });
+        child.once("close", (status, signal) => {
+            if (pendingError) {
+                finish(pendingError);
+                return;
+            }
+            if (status !== 0) {
+                const diagnostic = Buffer.concat(stderr)
+                    .toString("utf8")
+                    .trim()
+                    .slice(0, 16_384)
+                    .replace(/[\r\n]+/gu, " ");
+                finish(new Error(`process_observer_windows_job_unavailable:helper_exit:${status}:${signal}:${diagnostic}`));
+                return;
+            }
+            const response = Buffer.concat(stdout).toString("utf8");
+            if (!/^[^\r\n]+(?:\r?\n)?$/u.test(response)) {
+                finish(new Error("process_observer_windows_job_result_invalid:response_lines"));
+                return;
+            }
+            finish(undefined, response.replace(/\r?\n$/u, ""));
+        });
+        child.stdin.end(`${request}\n`, "utf8");
+        function stopHelper(error) {
+            if (settled)
+                return;
+            pendingError ??= error;
+            child.stdin.destroy();
+            if (!child.pid) {
+                finish(pendingError);
+                return;
+            }
+            child.kill("SIGKILL");
+            terminationTimer ??= setTimeout(() => finish(pendingError), HELPER_TERMINATION_GRACE_MS);
+        }
+        function finish(error, response) {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (terminationTimer)
+                clearTimeout(terminationTimer);
+            if (error)
+                reject(error);
+            else
+                resolve(response);
+        }
+    });
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/lib/long-task-windows-job-supervisor-protocol.d.ts

@@ -0,0 +1,28 @@
+export { parseWindowsJobSupervisorResult, type WindowsJobSupervisorResult, } from "./long-task-windows-job-supervisor-result.js";
+export declare const WINDOWS_JOB_SUPERVISOR_REQUEST_SCHEMA = "formal-process-supervisor-request-v1";
+export declare const WINDOWS_JOB_SUPERVISOR_ASSET_RELATIVE_FILES: readonly ["assets/runtime/windows-job-supervisor/formal_process_supervisor_native_types.cs", "assets/runtime/windows-job-supervisor/formal_process_supervisor_native_run.cs", "assets/runtime/windows-job-supervisor/formal_process_supervisor_native_helpers.cs", "assets/runtime/windows-job-supervisor/windows_job_process_supervisor.ps1"];
+export interface WindowsJobSupervisorRequest {
+    schema_version: typeof WINDOWS_JOB_SUPERVISOR_REQUEST_SCHEMA;
+    request_id: string;
+    executable: string;
+    argv: string[];
+    cwd: string;
+    stdout_path: string;
+    stderr_path: string;
+    timeout_ms: number;
+    combined_output_limit_bytes: number;
+    environment: Record<string, string>;
+}
+export declare function createWindowsJobSupervisorRequest(input: {
+    requestId: string;
+    executable: string;
+    argv: readonly string[];
+    cwd: string;
+    stdoutPath: string;
+    stderrPath: string;
+    timeoutMs: number;
+    combinedOutputLimitBytes: number;
+    environment: NodeJS.ProcessEnv;
+}): WindowsJobSupervisorRequest;
+export declare function assertFreshWindowsJobStreamTarget(target: string): Promise<void>;
+export declare function readWindowsJobStream(target: string, expectedBytes: number, maximumBytes: number): Promise<Buffer>;

package/dist/lib/long-task-windows-job-supervisor-protocol.js

@@ -0,0 +1,124 @@
+import { lstat, open, realpath } from "node:fs/promises";
+import path from "node:path";
+export { parseWindowsJobSupervisorResult, } from "./long-task-windows-job-supervisor-result.js";
+export const WINDOWS_JOB_SUPERVISOR_REQUEST_SCHEMA = "formal-process-supervisor-request-v1";
+export const WINDOWS_JOB_SUPERVISOR_ASSET_RELATIVE_FILES = [
+    "assets/runtime/windows-job-supervisor/formal_process_supervisor_native_types.cs",
+    "assets/runtime/windows-job-supervisor/formal_process_supervisor_native_run.cs",
+    "assets/runtime/windows-job-supervisor/formal_process_supervisor_native_helpers.cs",
+    "assets/runtime/windows-job-supervisor/windows_job_process_supervisor.ps1",
+];
+export function createWindowsJobSupervisorRequest(input) {
+    if (!validIdentity(input.requestId) ||
+        !validAbsolutePath(input.executable) ||
+        !validAbsolutePath(input.cwd) ||
+        !validAbsolutePath(input.stdoutPath) ||
+        !validAbsolutePath(input.stderrPath) ||
+        !Number.isSafeInteger(input.timeoutMs) ||
+        input.timeoutMs <= 0 ||
+        input.timeoutMs > 2_147_483_647 ||
+        !Number.isSafeInteger(input.combinedOutputLimitBytes) ||
+        input.combinedOutputLimitBytes <= 0 ||
+        !input.argv.every(validString))
+        invalidResult("request_invalid");
+    const environment = {};
+    for (const [key, value] of Object.entries(input.environment)) {
+        if (value === undefined)
+            continue;
+        if (!validEnvironmentKey(key) ||
+            !validString(value) ||
+            value.includes("\r") ||
+            value.includes("\n"))
+            invalidResult(`environment_invalid:${key}`);
+        environment[key] = value;
+    }
+    return {
+        schema_version: WINDOWS_JOB_SUPERVISOR_REQUEST_SCHEMA,
+        request_id: input.requestId,
+        executable: input.executable,
+        argv: [...input.argv],
+        cwd: input.cwd,
+        stdout_path: input.stdoutPath,
+        stderr_path: input.stderrPath,
+        timeout_ms: input.timeoutMs,
+        combined_output_limit_bytes: input.combinedOutputLimitBytes,
+        environment,
+    };
+}
+export async function assertFreshWindowsJobStreamTarget(target) {
+    try {
+        await lstat(target);
+        invalidResult("stream_preexisting");
+    }
+    catch (error) {
+        if (nodeErrorCode(error) !== "ENOENT")
+            throw error;
+    }
+}
+export async function readWindowsJobStream(target, expectedBytes, maximumBytes) {
+    if (!nonnegativeSafeInteger(expectedBytes) ||
+        !nonnegativeSafeInteger(maximumBytes) ||
+        expectedBytes > maximumBytes)
+        invalidResult("stream_bounds");
+    const before = await lstat(target).catch(() => invalidResult("stream_missing"));
+    if (!before.isFile() ||
+        before.isSymbolicLink() ||
+        before.nlink !== 1 ||
+        before.size !== expectedBytes ||
+        before.size > maximumBytes)
+        invalidResult("stream_identity");
+    if (normalizeHostPath(await realpath(target)) !==
+        normalizeHostPath(path.resolve(target)))
+        invalidResult("stream_reparse");
+    const handle = await open(target, "r");
+    try {
+        const opened = await handle.stat();
+        assertSameFile(opened, before);
+        const bytes = await handle.readFile();
+        const after = await handle.stat();
+        assertSameFile(after, opened);
+        if (bytes.length !== expectedBytes)
+            invalidResult("stream_identity");
+        return bytes;
+    }
+    finally {
+        await handle.close();
+    }
+}
+function assertSameFile(actual, expected) {
+    if (!actual.isFile() ||
+        actual.size !== expected.size ||
+        actual.dev !== expected.dev ||
+        actual.ino !== expected.ino)
+        invalidResult("stream_identity");
+}
+function nonnegativeSafeInteger(value) {
+    return Number.isSafeInteger(value) && Number(value) >= 0;
+}
+function validIdentity(value) {
+    return validString(value) && value.length > 0 && value.length <= 256;
+}
+function validString(value) {
+    return typeof value === "string" && !value.includes("\u0000");
+}
+function validAbsolutePath(value) {
+    return validString(value) && path.isAbsolute(value);
+}
+function validEnvironmentKey(value) {
+    return (validString(value) &&
+        value.length > 0 &&
+        !value.includes("=") &&
+        !value.includes("\r") &&
+        !value.includes("\n"));
+}
+function normalizeHostPath(value) {
+    return process.platform === "win32" ? value.toLowerCase() : value;
+}
+function nodeErrorCode(error) {
+    return error && typeof error === "object" && "code" in error
+        ? String(error.code)
+        : null;
+}
+function invalidResult(detail) {
+    throw new Error(`process_observer_windows_job_result_invalid:${detail}`);
+}