vouchington-tooling 0.20.0 → 0.22.0

package/dist/browser-session-runner/attempt.mjs

@@ -1,6 +1,7 @@
 import { createOutputConsumer } from './output.mjs';
 import { tailText } from './tail.mjs';
 import { TailQueue } from './tail-queue.mjs';
+import { terminateAttempt } from './termination.mjs';
 import { createWatchdogLifecycle, registerWatchdogSetup } from './watchdog.mjs';
 export function runAttempt(options, deps, deadline, attempt) {
     return new Promise((resolve, reject) => {
@@ -18,8 +19,17 @@ export function runAttempt(options, deps, deadline, attempt) {
         const drainTimeoutMs = options.graceMs + (options.processGroupDrainMs ?? options.graceMs);
         const tail = new TailQueue(maxTail);
         let startupProgress = false, semanticProgress = false;
-        let failure, hasFailure = false, childExited = false, closeExit, draining = false, drainDone = false, reason = 'exit', complete = false, terminating = false;
-        let killTimer, stallTimer;
+        let failure, hasFailure = false, closeExit, draining = false, drainDone = false, complete = false;
+        let stallTimer;
+        const control = {
+            childExited: false,
+            deps,
+            graceMs: options.graceMs,
+            killTimer: undefined,
+            process,
+            reason: 'exit',
+            terminating: false,
+        };
         const watchdog = createWatchdogLifecycle();
         const listeners = [];
         const captureFailure = (error) => !hasFailure && ((failure = error), (hasFailure = true));
@@ -28,18 +38,18 @@ export function runAttempt(options, deps, deadline, attempt) {
                 return;
             complete = true;
             deps.clearTimeout(deadlineTimer);
-            if (killTimer)
-                deps.clearTimeout(killTimer);
+            if (control.killTimer)
+                deps.clearTimeout(control.killTimer);
             deps.clearTimeout(stallTimer);
             watchdog.complete(captureFailure);
             for (const remove of listeners)
                 remove();
             const result = {
                 attempts: 0,
-                deadlineExceeded: reason === 'deadline',
+                deadlineExceeded: control.reason === 'deadline',
                 diagnosticTail: tailText(tail.toBuffer(), maxTail),
                 exit,
-                reason,
+                reason: control.reason,
                 semanticProgress,
                 startupProgress,
             };
@@ -48,37 +58,8 @@ export function runAttempt(options, deps, deadline, attempt) {
             else
                 resolve(result);
         };
-        const signal = (value) => {
-            try {
-                deps.killProcessGroup(process.processGroupId, value);
-            }
-            catch { }
-            try {
-                process.kill(value);
-            }
-            catch { }
-        };
         const terminate = (nextReason) => {
-            if (nextReason === 'deadline' && childExited && reason === 'exit')
-                return;
-            if (nextReason === 'parent-signal' || nextReason === 'deadline') {
-                if (reason === 'exit' || reason === 'startup-stall' || reason === 'semantic-stall')
-                    reason = nextReason;
-                else if (reason !== nextReason)
-                    return;
-            }
-            else if (reason !== 'exit')
-                return;
-            else if (nextReason !== 'exit')
-                reason = nextReason;
-            if (terminating)
-                return;
-            terminating = true;
-            killTimer = deps.setTimeout(() => {
-                if (deps.isProcessGroupAlive(process.processGroupId))
-                    signal('SIGKILL');
-            }, options.graceMs);
-            signal('SIGTERM');
+            terminateAttempt(control, nextReason);
         };
         const fail = (error) => {
             if (hasFailure || complete)
@@ -108,12 +89,12 @@ export function runAttempt(options, deps, deadline, attempt) {
             const event = options.onLine(value);
             if (event === 'startup' && !startupProgress) {
                 startupProgress = true;
-                if (!childExited)
+                if (!control.childExited)
                     armStall(options.semanticStallMs, 'semantic-stall');
             }
             if (event === 'semantic') {
                 semanticProgress = true;
-                if (startupProgress && !childExited)
+                if (startupProgress && !control.childExited)
                     armStall(options.semanticStallMs, 'semantic-stall');
             }
         };
@@ -146,13 +127,13 @@ export function runAttempt(options, deps, deadline, attempt) {
         }
         process.on('error', () => terminate('exit'));
         process.on('exit', () => {
-            if (reason === 'exit' && deps.now() >= deadline)
-                reason = 'deadline';
-            childExited = true;
+            if (control.reason === 'exit' && deps.now() >= deadline)
+                control.reason = 'deadline';
+            control.childExited = true;
             deps.clearTimeout(stallTimer);
             if (!deps.isProcessGroupAlive(process.processGroupId))
                 return;
-            terminate(reason);
+            terminate(control.reason);
             drain();
         });
         process.on('close', (code, value) => {
@@ -163,15 +144,15 @@ export function runAttempt(options, deps, deadline, attempt) {
                 catch (error) {
                     fail(error);
                 }
-            if (!childExited &&
+            if (!control.childExited &&
                 deps.now() >= deadline &&
-                reason !== 'parent-signal' &&
-                reason !== 'deadline')
-                reason = 'deadline';
+                control.reason !== 'parent-signal' &&
+                control.reason !== 'deadline')
+                control.reason = 'deadline';
             closeExit = { code, signal: value };
             if (!deps.isProcessGroupAlive(process.processGroupId))
                 return finish(closeExit);
-            terminate(reason);
+            terminate(control.reason);
             drain();
             if (drainDone || hasFailure)
                 finish(closeExit);
@@ -183,7 +164,7 @@ export function runAttempt(options, deps, deadline, attempt) {
                 now: () => deps.now(),
                 process,
                 terminate: () => {
-                    if (!childExited)
+                    if (!control.childExited)
                         terminate('provider-watchdog');
                 },
             });

package/dist/browser-session-runner/termination.d.mts

@@ -0,0 +1,11 @@
+import type { BrowserSessionDeps, BrowserSessionProcess, BrowserSessionResult } from './types.mts';
+export type AttemptControl = {
+    childExited: boolean;
+    deps: BrowserSessionDeps;
+    graceMs: number;
+    killTimer: unknown;
+    process: BrowserSessionProcess;
+    reason: BrowserSessionResult['reason'];
+    terminating: boolean;
+};
+export declare function terminateAttempt(control: AttemptControl, nextReason: BrowserSessionResult['reason']): void;

package/dist/browser-session-runner/termination.mjs

@@ -0,0 +1,34 @@
+function signalProcess(control, value) {
+    try {
+        control.deps.killProcessGroup(control.process.processGroupId, value);
+    }
+    catch { }
+    try {
+        control.process.kill(value);
+    }
+    catch { }
+}
+export function terminateAttempt(control, nextReason) {
+    if (nextReason === 'deadline' && control.childExited && control.reason === 'exit')
+        return;
+    if (nextReason === 'parent-signal' || nextReason === 'deadline') {
+        if (control.reason === 'exit' ||
+            control.reason === 'startup-stall' ||
+            control.reason === 'semantic-stall')
+            control.reason = nextReason;
+        else if (control.reason !== nextReason)
+            return;
+    }
+    else if (control.reason !== 'exit')
+        return;
+    else if (nextReason !== 'exit')
+        control.reason = nextReason;
+    if (control.terminating)
+        return;
+    control.terminating = true;
+    control.killTimer = control.deps.setTimeout(() => {
+        if (control.deps.isProcessGroupAlive(control.process.processGroupId))
+            signalProcess(control, 'SIGKILL');
+    }, control.graceMs);
+    signalProcess(control, 'SIGTERM');
+}

package/dist/cli/parse-direct-options.d.mts

@@ -0,0 +1,26 @@
+type ParsedFlagOptions = {
+    values: Record<string, string | undefined>;
+    workflowDirectories: string[];
+    actionDirectories: string[];
+};
+type FlagOptionFailure = {
+    kind: 'error';
+    message: string;
+} | {
+    kind: 'help';
+};
+type LinkSkillCli = FlagOptionFailure | {
+    kind: 'link-skill';
+    name: string;
+    sourceRoot: string;
+    targetRoot: string;
+};
+type HttpOriginCli = FlagOptionFailure | {
+    kind: 'http-origin';
+    field: string;
+    value: string;
+};
+export declare function parseLinkSkill(args: readonly string[]): LinkSkillCli;
+export declare function parseHttpOrigin(args: readonly string[]): HttpOriginCli;
+export declare function parseOptions(args: readonly string[], allowed: readonly string[], command: string, missingValue: string | ((flag: string) => string)): ParsedFlagOptions | FlagOptionFailure;
+export {};

package/dist/cli/parse-direct-options.mjs

@@ -0,0 +1,72 @@
+export function parseLinkSkill(args) {
+    const [name, ...flags] = args;
+    if (name === undefined || name.startsWith('-'))
+        return { kind: 'error', message: 'link-skill requires a skill name' };
+    const options = parseOptions(flags, ['source-root', 'target-root'], 'link-skill', 'path');
+    if ('kind' in options)
+        return options;
+    const sourceRoot = options.values['source-root'];
+    const targetRoot = options.values['target-root'];
+    if (sourceRoot === undefined || targetRoot === undefined) {
+        return { kind: 'error', message: 'link-skill requires --source-root and --target-root' };
+    }
+    return {
+        kind: 'link-skill',
+        name,
+        sourceRoot,
+        targetRoot,
+    };
+}
+export function parseHttpOrigin(args) {
+    let field = 'origin';
+    const values = [];
+    let index = 0;
+    while (index < args.length) {
+        const flag = args[index];
+        index += 1;
+        if (flag === '--help' || flag === '-h')
+            return { kind: 'help' };
+        if (flag === '--field') {
+            const value = args[index];
+            if (value === undefined)
+                return { kind: 'error', message: '--field requires a name' };
+            field = value;
+            index += 1;
+            continue;
+        }
+        if (flag === '--') {
+            values.push(...args.slice(index));
+            break;
+        }
+        if (flag.startsWith('-'))
+            return { kind: 'error', message: `unknown http-origin option: ${flag}` };
+        values.push(flag);
+    }
+    if (values.length > 1)
+        return { kind: 'error', message: 'http-origin accepts at most one value' };
+    return { kind: 'http-origin', field, value: values[0] ?? '' };
+}
+export function parseOptions(args, allowed, command, missingValue) {
+    const result = { values: {}, workflowDirectories: [], actionDirectories: [] };
+    for (let index = 0; index < args.length; index += 1) {
+        const flag = args[index];
+        if (flag === '--help' || flag === '-h')
+            return { kind: 'help' };
+        if (!flag.startsWith('--') || !allowed.includes(flag.slice(2))) {
+            return { kind: 'error', message: `unknown ${command} option: ${flag}` };
+        }
+        const value = args[index + 1];
+        if (value === undefined) {
+            const noun = typeof missingValue === 'string' ? missingValue : missingValue(flag);
+            return { kind: 'error', message: `${flag} requires a ${noun}` };
+        }
+        if (flag === '--workflow-directory')
+            result.workflowDirectories.push(value);
+        else if (flag === '--action-directory')
+            result.actionDirectories.push(value);
+        else
+            result.values[flag.slice(2)] = value;
+        index += 1;
+    }
+    return result;
+}

package/dist/cli/parse-forwarded-commands.d.mts

@@ -0,0 +1,42 @@
+type ForwardedCommand = {
+    kind: 'with-host-lock';
+    args: string[];
+} | {
+    kind: 'agent-harness-config';
+    args: string[];
+} | {
+    kind: 'pnpm-install';
+    args: string[];
+} | {
+    kind: 'vitest-blob-manifest';
+    args: string[];
+} | {
+    kind: 'vitest-report-attempt';
+    args: string[];
+} | {
+    kind: 'prepare-vitest-reports';
+    args: string[];
+} | {
+    kind: 'nuget-central-version';
+    args: string[];
+} | {
+    kind: 'swift-semantic-equal';
+    args: string[];
+} | {
+    kind: 'post-review';
+    args: string[];
+} | {
+    kind: 'stage-review-payload';
+    args: string[];
+} | {
+    kind: 'retrospective-transcript';
+    args: string[];
+} | {
+    kind: 'retrospective-facts';
+    args: string[];
+} | {
+    kind: 'agent-blackboard';
+    args: string[];
+};
+export declare function parseForwardedCommand(command: string | undefined, args: string[]): ForwardedCommand | undefined;
+export {};

package/dist/cli/parse-forwarded-commands.mjs

@@ -0,0 +1,29 @@
+export function parseForwardedCommand(command, args) {
+    if (command === 'with-host-lock')
+        return { kind: 'with-host-lock', args };
+    if (command === 'agent-harness-config')
+        return { kind: 'agent-harness-config', args };
+    if (command === 'pnpm-install')
+        return { kind: 'pnpm-install', args };
+    if (command === 'vitest-blob-manifest')
+        return { kind: 'vitest-blob-manifest', args };
+    if (command === 'vitest-report-attempt')
+        return { kind: 'vitest-report-attempt', args };
+    if (command === 'prepare-vitest-reports')
+        return { kind: 'prepare-vitest-reports', args };
+    if (command === 'nuget-central-version')
+        return { kind: 'nuget-central-version', args };
+    if (command === 'swift-semantic-equal')
+        return { kind: 'swift-semantic-equal', args };
+    if (command === 'post-review')
+        return { kind: 'post-review', args };
+    if (command === 'stage-review-payload')
+        return { kind: 'stage-review-payload', args };
+    if (command === 'retrospective-transcript')
+        return { kind: 'retrospective-transcript', args };
+    if (command === 'retrospective-facts')
+        return { kind: 'retrospective-facts', args };
+    if (command === 'agent-blackboard')
+        return { kind: 'agent-blackboard', args };
+    return undefined;
+}

package/dist/cli/parse-options.d.mts

@@ -1,7 +1,6 @@
 import type { ParsedCli } from './parse.mts';
-export declare function parseLinkSkill(args: readonly string[]): ParsedCli;
+export { parseHttpOrigin, parseLinkSkill } from './parse-direct-options.mts';
 export declare function parseRunnerPortPolicy(args: readonly string[]): ParsedCli;
-export declare function parseHttpOrigin(args: readonly string[]): ParsedCli;
 export declare function parseRequireUpToDate(args: readonly string[]): ParsedCli;
 export declare function parseGitleaksDirectoryScan(args: readonly string[]): ParsedCli;
 export declare function parseAstGrepPack(args: readonly string[]): ParsedCli;

package/dist/cli/parse-options.mjs

@@ -1,22 +1,5 @@
-export function parseLinkSkill(args) {
-    const [name, ...flags] = args;
-    if (name === undefined || name.startsWith('-'))
-        return { kind: 'error', message: 'link-skill requires a skill name' };
-    const options = parseOptions(flags, ['source-root', 'target-root'], 'link-skill', 'path');
-    if ('kind' in options)
-        return options;
-    const sourceRoot = options.values['source-root'];
-    const targetRoot = options.values['target-root'];
-    if (sourceRoot === undefined || targetRoot === undefined) {
-        return { kind: 'error', message: 'link-skill requires --source-root and --target-root' };
-    }
-    return {
-        kind: 'link-skill',
-        name,
-        sourceRoot,
-        targetRoot,
-    };
-}
+import { parseOptions } from './parse-direct-options.mjs';
+export { parseHttpOrigin, parseLinkSkill } from './parse-direct-options.mjs';
 export function parseRunnerPortPolicy(args) {
     const options = parseOptions(args, ['file', 'reserved'], 'runner-port-policy', (flag) => flag === '--reserved' ? 'port' : 'path');
     if ('kind' in options)
@@ -33,35 +16,6 @@ export function parseRunnerPortPolicy(args) {
         ...(reserved === undefined ? {} : { reserved }),
     };
 }
-export function parseHttpOrigin(args) {
-    let field = 'origin';
-    const values = [];
-    let index = 0;
-    while (index < args.length) {
-        const flag = args[index];
-        index += 1;
-        if (flag === '--help' || flag === '-h')
-            return { kind: 'help' };
-        if (flag === '--field') {
-            const value = args[index];
-            if (value === undefined)
-                return { kind: 'error', message: '--field requires a name' };
-            field = value;
-            index += 1;
-            continue;
-        }
-        if (flag === '--') {
-            values.push(...args.slice(index));
-            break;
-        }
-        if (flag.startsWith('-'))
-            return { kind: 'error', message: `unknown http-origin option: ${flag}` };
-        values.push(flag);
-    }
-    if (values.length > 1)
-        return { kind: 'error', message: 'http-origin accepts at most one value' };
-    return { kind: 'http-origin', field, value: values[0] ?? '' };
-}
 export function parseRequireUpToDate(args) {
     const options = parseOptions(args, ['remote', 'branch'], 'require-up-to-date', 'name');
     if ('kind' in options)
@@ -122,27 +76,3 @@ export function parseGhaWorkspacePolicy(args) {
             : { actionDirectories: options.actionDirectories }),
     };
 }
-function parseOptions(args, allowed, command, missingValue) {
-    const result = { values: {}, workflowDirectories: [], actionDirectories: [] };
-    for (let index = 0; index < args.length; index += 1) {
-        const flag = args[index];
-        if (flag === '--help' || flag === '-h')
-            return { kind: 'help' };
-        if (!flag.startsWith('--') || !allowed.includes(flag.slice(2))) {
-            return { kind: 'error', message: `unknown ${command} option: ${flag}` };
-        }
-        const value = args[index + 1];
-        if (value === undefined) {
-            const noun = typeof missingValue === 'string' ? missingValue : missingValue(flag);
-            return { kind: 'error', message: `${flag} requires a ${noun}` };
-        }
-        if (flag === '--workflow-directory')
-            result.workflowDirectories.push(value);
-        else if (flag === '--action-directory')
-            result.actionDirectories.push(value);
-        else
-            result.values[flag.slice(2)] = value;
-        index += 1;
-    }
-    return result;
-}

package/dist/cli/parse.mjs

@@ -1,5 +1,6 @@
 import { parseGhaArtifactsCleanup, } from './parse-gha-artifacts-cleanup.mjs';
 import { parseGhaRuntimeAudit } from './parse-gha-runtime-audit.mjs';
+import { parseForwardedCommand } from './parse-forwarded-commands.mjs';
 import { commandNames } from './usage.mjs';
 import { parseAstGrepExamples, parseAstGrepPack, parseGhaWorkspacePolicy, parseGitleaksDirectoryScan, parseHttpOrigin, parseLinkSkill, parseRequireUpToDate, parseRunnerPortPolicy, } from './parse-options.mjs';
 const SCRIPT_COMMANDS = new Set([
@@ -35,40 +36,17 @@ export function parseCli(argv) {
     const help = parseCommandHelp(command, rest);
     if (help)
         return help;
+    const forwarded = parseForwardedCommand(command, rest);
+    if (forwarded)
+        return forwarded;
     if (command === 'runner-port-policy')
         return parseRunnerPortPolicy(rest);
-    if (command === 'with-host-lock')
-        return { kind: 'with-host-lock', args: rest };
-    if (command === 'agent-harness-config')
-        return { kind: 'agent-harness-config', args: rest };
     if (command === 'gha-runtime-audit')
         return parseGhaRuntimeAudit(rest);
-    if (command === 'pnpm-install')
-        return { kind: 'pnpm-install', args: rest };
-    if (command === 'vitest-blob-manifest')
-        return { kind: 'vitest-blob-manifest', args: rest };
-    if (command === 'vitest-report-attempt')
-        return { kind: 'vitest-report-attempt', args: rest };
-    if (command === 'prepare-vitest-reports')
-        return { kind: 'prepare-vitest-reports', args: rest };
-    if (command === 'nuget-central-version')
-        return { kind: 'nuget-central-version', args: rest };
-    if (command === 'swift-semantic-equal')
-        return { kind: 'swift-semantic-equal', args: rest };
-    if (command === 'post-review')
-        return { kind: 'post-review', args: rest };
-    if (command === 'stage-review-payload')
-        return { kind: 'stage-review-payload', args: rest };
     if (command === 'http-origin')
         return parseHttpOrigin(rest);
-    if (command === 'retrospective-transcript')
-        return { kind: 'retrospective-transcript', args: rest };
     if (command === 'link-skill')
         return parseLinkSkill(rest);
-    if (command === 'retrospective-facts')
-        return { kind: 'retrospective-facts', args: rest };
-    if (command === 'agent-blackboard')
-        return { kind: 'agent-blackboard', args: rest };
     if (command === 'require-up-to-date')
         return parseRequireUpToDate(rest);
     if (command === 'gitleaks-directory-scan')

package/dist/compiler-build/freshness.d.mts

@@ -0,0 +1,27 @@
+type Probe = {
+    key: string;
+    replay(): unknown;
+    value: unknown;
+};
+export type CompilerHostProbeSnapshot = {
+    probes: readonly Probe[];
+    stableDuringCapture: boolean;
+};
+export interface CompilerFilesystemHost {
+    directoryExists?(path: string): boolean;
+    fileExists(path: string): boolean;
+    getDirectories?(path: string): string[];
+    readDirectory?(path: string, extensions?: readonly string[], exclude?: readonly string[], include?: readonly string[], depth?: number): string[];
+    readFile(path: string): string | undefined;
+    realpath?(path: string): string;
+}
+export interface CompilerHostTrackingOptions {
+    afterRead?(path: string): boolean | void;
+    readFileReplay?: 'always' | 'when-filesystem-metadata-stable';
+}
+export declare function trackCompilerHost<Host extends CompilerFilesystemHost>(host: Host, options?: CompilerHostTrackingOptions): {
+    host: Host;
+    snapshot(): CompilerHostProbeSnapshot;
+};
+export declare function compilerHostProbesAreFresh(snapshot: CompilerHostProbeSnapshot): boolean;
+export {};

package/dist/compiler-build/freshness.mjs

@@ -0,0 +1,116 @@
+import { statSync } from 'node:fs';
+import { normalize } from 'node:path';
+export function trackCompilerHost(host, options) {
+    const probes = new Map();
+    let stableDuringCapture = true;
+    const record = (key, value, replay) => {
+        const existing = probes.get(key);
+        if (existing && !sameValue(existing.value, value))
+            stableDuringCapture = false;
+        else if (!existing)
+            probes.set(key, { key, replay, value });
+        return value;
+    };
+    const wrapBoolean = (operation, original) => (path) => {
+        const key = `${operation}:${normalizedPath(path)}`;
+        return record(key, original(path), () => original(path));
+    };
+    const capturePaths = (key, originalPaths, replay) => {
+        record(key, normalizedPaths(originalPaths), () => normalizedPaths(replay()));
+        return originalPaths;
+    };
+    const wrapPaths = (operation, original) => (path) => capturePaths(`${operation}:${normalizedPath(path)}`, original(path), () => original(path));
+    const readFile = host.readFile.bind(host);
+    host.readFile = (path) => {
+        const key = `readFile:${normalizedPath(path)}`;
+        const usesMetadataReplay = options?.readFileReplay === 'when-filesystem-metadata-stable';
+        const before = usesMetadataReplay ? fileMetadata(path) : undefined;
+        const value = readFile(path);
+        if (options?.afterRead?.(path))
+            stableDuringCapture = false;
+        const after = usesMetadataReplay ? fileMetadata(path) : undefined;
+        if (usesMetadataReplay && !sameMetadata(before, after))
+            stableDuringCapture = false;
+        return record(key, value, () => {
+            const current = usesMetadataReplay ? fileMetadata(path) : undefined;
+            return usesMetadataReplay &&
+                value !== undefined &&
+                after !== undefined &&
+                sameMetadata(after, current)
+                ? value
+                : readFile(path);
+        });
+    };
+    host.fileExists = wrapBoolean('fileExists', host.fileExists.bind(host));
+    if (host.directoryExists)
+        host.directoryExists = wrapBoolean('directoryExists', host.directoryExists.bind(host));
+    if (host.getDirectories)
+        host.getDirectories = wrapPaths('getDirectories', host.getDirectories.bind(host));
+    if (host.readDirectory) {
+        const readDirectory = host.readDirectory.bind(host);
+        host.readDirectory = (path, extensions, exclude, include, depth) => {
+            const argumentsKey = JSON.stringify([extensions, exclude, include, depth]);
+            const key = `readDirectory:${normalizedPath(path)}:${argumentsKey}`;
+            return capturePaths(key, readDirectory(path, extensions, exclude, include, depth), () => readDirectory(path, extensions, exclude, include, depth));
+        };
+    }
+    if (host.realpath) {
+        const realpath = host.realpath.bind(host);
+        host.realpath = (path) => {
+            const key = `realpath:${normalizedPath(path)}`;
+            const read = () => normalizedPath(realpath(path));
+            return record(key, read(), read);
+        };
+    }
+    return {
+        host,
+        snapshot: () => ({
+            probes: [...probes.values()].toSorted((left, right) => left.key.localeCompare(right.key)),
+            stableDuringCapture,
+        }),
+    };
+}
+export function compilerHostProbesAreFresh(snapshot) {
+    return (snapshot.stableDuringCapture &&
+        snapshot.probes.every((probe) => {
+            try {
+                return sameValue(probe.value, probe.replay());
+            }
+            catch (error) {
+                if (isMissingFilesystemInput(error))
+                    return false;
+                throw error;
+            }
+        }));
+}
+function fileMetadata(path) {
+    try {
+        const stat = statSync(path, { bigint: true });
+        return { ctimeNs: stat.ctimeNs, mtimeNs: stat.mtimeNs, size: stat.size };
+    }
+    catch (error) {
+        if (isMissingFilesystemInput(error))
+            return undefined;
+        throw error;
+    }
+}
+function normalizedPath(path) {
+    return normalize(path).replaceAll('\\', '/');
+}
+function normalizedPaths(paths) {
+    return [...new Set(paths.map(normalizedPath))].toSorted();
+}
+function sameMetadata(left, right) {
+    return (left?.ctimeNs === right?.ctimeNs &&
+        left?.mtimeNs === right?.mtimeNs &&
+        left?.size === right?.size);
+}
+function sameValue(left, right) {
+    return Array.isArray(left) && Array.isArray(right)
+        ? left.length === right.length && left.every((value, index) => value === right[index])
+        : left === right;
+}
+function isMissingFilesystemInput(error) {
+    const code = error.code;
+    return code === 'ENOENT' || code === 'ENOTDIR';
+}

package/dist/compiler-build/index.d.mts

@@ -0,0 +1,2 @@
+export { compilerHostProbesAreFresh, trackCompilerHost, type CompilerFilesystemHost, type CompilerHostProbeSnapshot, type CompilerHostTrackingOptions, } from './freshness.mts';
+export { settleBuild, type SettlementCallbacks, type SettlementConfirmation, } from './settlement.mts';

package/dist/compiler-build/index.mjs

@@ -0,0 +1,2 @@
+export { compilerHostProbesAreFresh, trackCompilerHost, } from './freshness.mjs';
+export { settleBuild, } from './settlement.mjs';