project-tiny-context-harness 0.11.0 → 0.12.0

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

@@ -1,66 +0,0 @@
-import { readFile, readdir } from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import DELIVERY_SCHEMA from "../schemas/long-task-delivery-v2/long-task-delivery-v2.schema.json" with { type: "json" };
-import OUTCOMES_SCHEMA from "../schemas/long-task-delivery-v2/long-task-outcomes-v2.schema.json" with { type: "json" };
-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",
-    "commands/long-task.js",
-    "commands/delivery-set.js",
-    "lib/context-graph-snapshot.js",
-    "lib/strict-codec.js",
-];
-export async function captureVerifierIdentity(repositoryRoot, requireHook) {
-    const packageRoot = fileURLToPath(new URL("../../", import.meta.url));
-    const packageFile = await assertProtectedRepositoryFile(packageRoot, path.join(packageRoot, "package.json"), "package_owned_verifier_package");
-    const packageJson = JSON.parse(await readFile(packageFile, "utf8"));
-    const files = await verifierBundleFiles(packageRoot);
-    const hook = requireHook
-        ? await checkLongTaskCompletionGate(repositoryRoot, packageRoot)
-        : null;
-    if (hook && hook.status !== "available")
-        throw new Error(`completion_gate_unavailable:${hook.findings.join(",")}`);
-    return {
-        package_name: "project-tiny-context-harness",
-        package_version: packageJson.version,
-        package_root: packageRoot,
-        bundle_sha256: sha256Hex(canonicalValueJson(files)),
-        bundle_files: files,
-        schema_sha256: sha256Hex(canonicalValueJson({
-            delivery: DELIVERY_SCHEMA,
-            outcomes: OUTCOMES_SCHEMA,
-        })),
-        hook_sha256: hook?.hook_sha256 ?? "not-required",
-    };
-}
-async function verifierBundleFiles(packageRoot) {
-    const distRoot = path.join(packageRoot, "dist");
-    const relativeFiles = new Set(REQUIRED_ENTRYPOINTS);
-    for (const file of await readdir(path.join(distRoot, "lib")))
-        if (/^long-task-.*\.js$/u.test(file))
-            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 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.d.ts

@@ -1,17 +0,0 @@
-import type { CheckExecutionResultV2, CompiledCheckV2, CompiledDeliveryContractV2, LongTaskFindingV2, TargetedVerificationResultV2, WorkspaceManifestV2 } from "./long-task-delivery-types.js";
-import { type WorkspaceSnapshotV2 } from "./long-task-workspace.js";
-export interface DeliveryRunV2 {
-    snapshot: WorkspaceManifestV2;
-    check_results: CheckExecutionResultV2[];
-    findings: LongTaskFindingV2[];
-}
-export declare function verifyDeliveryContract(workdir: string, selection?: {
-    outcome?: string;
-    check?: string;
-}): Promise<TargetedVerificationResultV2>;
-export declare function runDeliveryChecks(compiled: CompiledDeliveryContractV2, snapshot: WorkspaceSnapshotV2, checks: CompiledCheckV2[], includeCounterfactuals: boolean, finalGate?: boolean): Promise<DeliveryRunV2>;
-export declare function allCompiledChecks(compiled: CompiledDeliveryContractV2): CompiledCheckV2[];
-export declare function selectChecks(compiled: CompiledDeliveryContractV2, selection: {
-    outcome?: string;
-    check?: string;
-}): CompiledCheckV2[];

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

@@ -1,317 +0,0 @@
-import { deliveryCompileFreshness } from "./long-task-freshness.js";
-import { assertVerifierAuthorityCurrent } from "./long-task-freshness.js";
-import { enrichCheckResultFindings, enrichFinding, } from "./long-task-finding-context.js";
-import { prepareExecutionObservationUniverse } from "./long-task-execution-observation.js";
-import { evaluateCheckEvidence } from "./long-task-evidence-v2.js";
-import { matchesRepoPattern } from "./long-task-paths.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;
-    if (!active)
-        throw new Error("active_task_missing");
-    if (active.workdir !== (await resolved(workdir)))
-        throw new Error("active_task_workdir_mismatch");
-    await assertVerifierAuthorityCurrent(repository, active.verifier_identity);
-    const compiled = active.authority_snapshot;
-    const expectedAuthority = {
-        task_id: active.task_id,
-        authority_revision: active.authority_revision,
-        compiled_identity: active.active_authority_identity,
-        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);
-        const records = run.check_results.map((result) => {
-            const check = selected.find((item) => item.internal_id === result.internal_id);
-            if (!check)
-                throw new Error(`compiled_check_not_found:${result.internal_id}`);
-            return createProgressRecord(compiled, snapshot.manifest, check, result);
-        });
-        let authorityChanged = false;
-        try {
-            const current = (await loadActiveLongTaskAuthority(repository)).authority;
-            authorityChanged =
-                !current || !activeAuthorityIdentityMatches(current, expectedAuthority);
-        }
-        catch {
-            authorityChanged = true;
-        }
-        if (authorityChanged) {
-            run.findings.push({
-                code: "active_authority_changed_during_verify",
-                outcome_key: null,
-                check_key: null,
-                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,
-                snapshot_sha256: snapshot.manifest.snapshot_sha256,
-                acceptance_authorized: false,
-                selected_outcome: selection.outcome ?? null,
-                selected_check: selection.check ?? null,
-                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,
-            snapshot_sha256: snapshot.manifest.snapshot_sha256,
-            acceptance_authorized: false,
-            selected_outcome: selection.outcome ?? null,
-            selected_check: selection.check ?? null,
-            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(),
-        };
-    }
-    finally {
-        await snapshot.dispose();
-    }
-}
-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 = [
-        ...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));
-    if (findings.length)
-        return {
-            snapshot: snapshot.manifest,
-            check_results: [],
-            findings: findings.map((finding) => enrichFinding(compiled, finding)),
-        };
-    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({
-        groups: completeExecutionGroups,
-        snapshot_root: snapshot.root,
-        workspace_manifest: snapshot.manifest,
-        protected_authority_paths: observationAuthorityPaths,
-    });
-    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);
-        if (!raw)
-            throw new Error("raw_execution_group_result_missing");
-        const outcome = check.outcome_key
-            ? compiled.outcomes.find((item) => item.key === check.outcome_key)
-            : undefined;
-        mainCheckResults.push(await evaluateCheckEvidence(check, raw, snapshot.root, outcome, observationAuthorityPaths));
-    }
-    // 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)
-        : null;
-    const checkResults = applyCounterfactualFindings(mainCheckResults, counterfactualFindings, unassignedFinding).map((result) => enrichCheckResultFindings(compiled, result));
-    findings.push(...checkResults.flatMap((result) => result.findings));
-    if (unassignedFinding && !checkResults.length)
-        findings.push(unassignedFinding);
-    return {
-        snapshot: snapshot.manifest,
-        check_results: checkResults,
-        findings: findings.map((finding) => enrichFinding(compiled, finding)),
-    };
-}
-function rawExecutionGroups(checks) {
-    const groups = new Map();
-    for (const check of checks) {
-        const group = groups.get(check.raw_execution_identity);
-        if (group)
-            group.push(check);
-        else
-            groups.set(check.raw_execution_identity, [check]);
-    }
-    return [...groups.values()];
-}
-function applyCounterfactualFindings(checkResults, findings, unassignedFinding) {
-    return checkResults.map((result, index) => {
-        const projected = findings.filter((finding) => findingBelongsToCheck(finding, result));
-        const invariantFindings = unassignedFinding && index === 0 ? [unassignedFinding] : [];
-        const projectedFindings = [...projected, ...invariantFindings];
-        if (!projectedFindings.length)
-            return result;
-        return {
-            ...result,
-            status: result.status === "passed" ? "invalid_evidence" : result.status,
-            claim_proofs: [],
-            findings: [...result.findings, ...projectedFindings],
-        };
-    });
-}
-function findingBelongsToCheck(finding, result) {
-    return (finding.check_key !== null &&
-        finding.check_key === result.check_key &&
-        finding.outcome_key === result.outcome_key);
-}
-function unassignedCounterfactualFinding(actual) {
-    return {
-        code: "counterfactual_finding_unassigned",
-        outcome_key: null,
-        check_key: null,
-        message: "A Counterfactual Finding could not be assigned to its owning Check Result.",
-        actual,
-        next_action: "Repair the Counterfactual evaluator ownership invariant before trusting verification progress.",
-    };
-}
-function finalPathFindings(compiled, manifest) {
-    const findings = [];
-    for (const check of allCompiledChecks(compiled))
-        for (const pattern of check.expected_output_paths)
-            if (!manifest.files.some((file) => matchesRepoPattern(file.path, pattern)))
-                findings.push({
-                    code: "expected_output_path_missing",
-                    outcome_key: check.outcome_key,
-                    check_key: check.key,
-                    message: `Expected output path did not exist: ${pattern}`,
-                    expected: pattern,
-                    next_action: "Create the declared output and rerun verification.",
-                });
-    for (const outcome of compiled.outcomes)
-        for (const binding of outcome.technical.bindings)
-            if (binding.existence === "planned" &&
-                !plannedBindingRequiredPatterns(binding).every((pattern) => manifest.files.some((file) => matchesRepoPattern(file.path, pattern))) &&
-                !outcome.acceptance.checks.some((check) => (check.observation_authorities ?? []).some((authority) => authority.authority === "package_static_json_exact" &&
-                    authority.carrier_refs.some((carrier) => carrier.binding_ref === `${outcome.key}.${binding.key}`))))
-                findings.push({
-                    code: "binding_missing",
-                    outcome_key: outcome.key,
-                    check_key: null,
-                    claim_keys: outcome.generated_claims.some((claim) => claim.local_key === `obligation.${binding.key}`)
-                        ? [`obligation.${binding.key}`]
-                        : [],
-                    message: `Planned binding is missing: ${binding.target}`,
-                    expected: binding.carrier_paths,
-                    next_action: "Implement the declared binding and rerun verification.",
-                });
-    for (const check of allCompiledChecks(compiled))
-        for (const runtimePath of check.process_runtime_closure
-            ?.allowed_runtime_files ?? [])
-            if (!manifest.files.some((file) => file.path === runtimePath))
-                findings.push({
-                    code: "process_runtime_input_missing",
-                    outcome_key: check.outcome_key,
-                    check_key: check.key,
-                    message: `Declared process runtime input did not exist in the Final Gate candidate: ${runtimePath}`,
-                    expected: runtimePath,
-                    next_action: "Materialize the Source-backed product root and every declared production runtime input, then rerun Final Gate.",
-                });
-    return findings;
-}
-function plannedBindingRequiredPatterns(binding) {
-    return binding.kind === "file" || binding.kind === "path_glob"
-        ? [binding.target]
-        : binding.carrier_paths;
-}
-export function allCompiledChecks(compiled) {
-    return [
-        ...compiled.global.acceptance.checks,
-        ...compiled.outcomes.flatMap((outcome) => outcome.acceptance.checks),
-    ];
-}
-export function selectChecks(compiled, selection) {
-    const checks = allCompiledChecks(compiled);
-    if (selection.outcome &&
-        !compiled.outcomes.some((outcome) => outcome.key === selection.outcome))
-        throw new Error(`outcome_not_found:${selection.outcome}`);
-    const filtered = checks.filter((check) => (!selection.outcome || check.outcome_key === selection.outcome) &&
-        (!selection.check || check.key === selection.check));
-    if (selection.check && !filtered.length)
-        throw new Error(`check_not_found:${selection.check}`);
-    return filtered;
-}
-async function preRunFindings(compiled, current) {
-    const stale = await deliveryCompileFreshness(compiled);
-    if (stale.length)
-        return stale.map((code) => ({
-            code,
-            outcome_key: null,
-            check_key: null,
-            message: "A compiled Contract input changed.",
-            next_action: "Run ty-context long-task compile --revise after reviewing the Contract change.",
-        }));
-    const changed = changedWorkspacePaths(compiled.initial_task_base.workspace_manifest, current);
-    const classification = classifyWorkspaceScope(compiled, changed, protectedWorkspacePaths({
-        contract_files: compiled.contract_files,
-        source_hashes: compiled.source_hashes,
-        context_hashes: compiled.context_snapshot.sha256,
-        checks: allCompiledChecks(compiled),
-    }));
-    const escaped = classification.blocking_paths;
-    return escaped.length
-        ? [
-            {
-                code: "scope_escape",
-                outcome_key: null,
-                check_key: null,
-                message: `Changed paths escape the Contract boundary (forbidden: ${classification.forbidden.join(",") || "none"}; unclassified: ${classification.unclassified.join(",") || "none"}).`,
-                actual: escaped,
-                next_action: "Review risk/ownership, revise declared change paths and recompile in the same Goal.",
-            },
-        ]
-        : [];
-}

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

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

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

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

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

@@ -1,124 +0,0 @@
-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}`);
-}

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

@@ -1,11 +0,0 @@
-export interface WindowsJobSupervisorResult {
-    process_id: number;
-    exit_code: number;
-    timed_out: boolean;
-    output_overflow: boolean;
-    stdout_bytes: number;
-    stderr_bytes: number;
-    started_at: string;
-    completed_at: string;
-}
-export declare function parseWindowsJobSupervisorResult(line: string, requestId: string): WindowsJobSupervisorResult;