@visulima/task-runner 1.0.0-alpha.6 → 1.0.0-alpha.8

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@visulima/task-runner",
-  "version": "1.0.0-alpha.6",
+  "version": "1.0.0-alpha.8",
   "description": "A task runner with caching support for monorepo workspaces",
   "keywords": [
-    "visulima",
-    "task-runner",
     "cache",
     "monorepo",
-    "task",
     "runner",
+    "task",
+    "task-runner",
+    "visulima",
     "workspace"
   ],
   "homepage": "https://visulima.com/packages/task-runner",
@@ -53,18 +53,18 @@
   ],
   "dependencies": {
     "@lydell/node-pty": "1.2.0-beta.12",
-    "@visulima/humanizer": "3.0.0-alpha.10",
-    "@visulima/path": "3.0.0-alpha.9"
+    "@visulima/humanizer": "3.0.0-alpha.11",
+    "@visulima/path": "3.0.0-alpha.10"
   },
   "optionalDependencies": {
-    "@visulima/task-runner-binding-darwin-arm64": "1.0.0-alpha.6",
-    "@visulima/task-runner-binding-linux-arm64-gnu": "1.0.0-alpha.6",
-    "@visulima/task-runner-binding-darwin-x64": "1.0.0-alpha.6",
-    "@visulima/task-runner-binding-linux-arm64-musl": "1.0.0-alpha.6",
-    "@visulima/task-runner-binding-linux-x64-gnu": "1.0.0-alpha.6",
-    "@visulima/task-runner-binding-linux-x64-musl": "1.0.0-alpha.6",
-    "@visulima/task-runner-binding-win32-arm64-msvc": "1.0.0-alpha.6",
-    "@visulima/task-runner-binding-win32-x64-msvc": "1.0.0-alpha.6"
+    "@visulima/task-runner-binding-darwin-arm64": "1.0.0-alpha.8",
+    "@visulima/task-runner-binding-darwin-x64": "1.0.0-alpha.8",
+    "@visulima/task-runner-binding-linux-arm64-gnu": "1.0.0-alpha.8",
+    "@visulima/task-runner-binding-linux-arm64-musl": "1.0.0-alpha.8",
+    "@visulima/task-runner-binding-linux-x64-gnu": "1.0.0-alpha.8",
+    "@visulima/task-runner-binding-linux-x64-musl": "1.0.0-alpha.8",
+    "@visulima/task-runner-binding-win32-arm64-msvc": "1.0.0-alpha.8",
+    "@visulima/task-runner-binding-win32-x64-msvc": "1.0.0-alpha.8"
   },
   "engines": {
     "node": "^22.14.0 || >=24.10.0"

package/dist/affected.d.ts

@@ -1,82 +0,0 @@
-import type { AffectedScope, ProjectConfiguration, ProjectGraph } from "./types.d.ts";
-/**
- * Options for determining affected projects.
- */
-interface AffectedOptions {
-    /** The base ref to compare against (default: "main") */
-    base?: string;
-    /**
-     * Control how far downstream (dependents of changed projects) to include.
-     * @default "deep"
-     */
-    downstream?: AffectedScope;
-    /** The head ref to compare (default: "HEAD") */
-    head?: string;
-    /** Project graph for dependency resolution */
-    projectGraph: ProjectGraph;
-    /** All project configurations keyed by name */
-    projects: Record<string, ProjectConfiguration>;
-    /**
-     * Control how far upstream (dependencies of changed projects) to include.
-     * @default "none"
-     */
-    upstream?: AffectedScope;
-    /** The workspace root directory */
-    workspaceRoot: string;
-}
-/**
- * Result of affected detection.
- */
-interface AffectedResult {
-    /** All affected projects (union of changed, downstream, and upstream) */
-    affectedProjects: string[];
-    /** Files that changed between base and head */
-    changedFiles: string[];
-    /** Projects that were directly changed */
-    changedProjects: string[];
-    /** Projects affected because they depend on changed projects */
-    downstreamProjects: string[];
-    /** Projects that changed projects depend on */
-    upstreamProjects: string[];
-}
-/**
- * Builds a map from each project to the set of projects that depend on it (reverse/downstream).
- */
-declare const buildReverseDependencyMap: (projectGraph: ProjectGraph) => Map<string, Set<string>>;
-/**
- * Builds a map from each project to the set of projects it depends on (forward/upstream).
- */
-declare const buildForwardDependencyMap: (projectGraph: ProjectGraph) => Map<string, Set<string>>;
-/**
- * Expands a set of changed projects based on upstream/downstream scope settings.
- * Returns a new set containing all affected projects.
- */
-declare const expandAffected: (changedProjects: Set<string>, projectGraph: ProjectGraph, options: {
-    downstream: AffectedScope;
-    upstream: AffectedScope;
-}) => {
-    affected: Set<string>;
-    downstream: Set<string>;
-    upstream: Set<string>;
-};
-/**
- * Gets the list of files changed between two git refs.
- * Uses execFile with argument arrays to prevent command injection.
- */
-declare const getChangedFiles: (workspaceRoot: string, base: string, head: string) => Promise<string[]>;
-/**
- * Determines which projects are affected by changes between two git refs.
- *
- * Uses `git diff` to find changed files, maps them to projects based on
- * project roots, then walks the project dependency graph to find all
- * transitively affected projects.
- *
- * This is the same strategy used by `nx affected` and `turbo run --filter=[base...]`.
- */
-declare const getAffectedProjects: (options: AffectedOptions) => Promise<AffectedResult>;
-/**
- * Filters tasks to only include those that are affected by changes.
- */
-declare const filterAffectedTasks: (taskIds: string[], affectedProjects: Set<string>) => string[];
-export type { AffectedOptions, AffectedResult };
-export { buildForwardDependencyMap, buildReverseDependencyMap, expandAffected, filterAffectedTasks, getAffectedProjects, getChangedFiles };

package/dist/archive.d.ts

@@ -1,38 +0,0 @@
-/**
- * Shared tar + brotli archive helpers.
- *
- * Both the local cache (`cache.ts`) and remote cache (`remote-cache.ts`)
- * archive file trees into compressed tarballs. This module consolidates
- * the compression parameters and stream plumbing so both paths stay in
- * sync — same brotli quality, same error-handling shape, one place to
- * audit.
- */
-/**
- * Brotli quality 4 hits a sweet spot for cache tarballs: ~15–20% smaller
- * than gzip on typical source/dist payloads at comparable throughput.
- * Higher qualities (8+) reach diminishing returns and noticeably slow
- * down cache writes; lower qualities (1–3) give up ratio for speed we
- * don't need on IO-bound workloads.
- */
-export declare const BROTLI_COMPRESS_OPTIONS: {
-    params: Record<number, number>;
-};
-/** Plain tar: `sourceDir` → `outputPath`, no compression. */
-export declare const createTar: (sourceDirectory: string, outputPath: string) => Promise<void>;
-/** Plain tar extract into `destinationDirectory`. */
-export declare const extractTar: (archivePath: string, destinationDirectory: string) => Promise<void>;
-/** tar + gzip (`-czf`). Used when Turborepo-protocol compatibility matters. */
-export declare const createTarGz: (sourceDirectory: string, outputPath: string) => Promise<void>;
-export declare const extractTarGz: (archivePath: string, destinationDirectory: string) => Promise<void>;
-/**
- * Creates an uncompressed tar, then streams it through brotli into
- * `outputPath`. Two-step (tar-to-temp, brotli-stream) to avoid
- * shelling out to an external `brotli` binary that may not exist.
- * Cleans up the intermediate tar even when compression fails.
- */
-export declare const createTarBrotli: (sourceDirectory: string, outputPath: string) => Promise<void>;
-/**
- * Inverse of {@link createTarBrotli}: decompresses into a temp tar,
- * then extracts. Temp is cleaned in `finally`.
- */
-export declare const extractTarBrotli: (archivePath: string, destinationDirectory: string) => Promise<void>;

package/dist/cache.d.ts

@@ -1,138 +0,0 @@
-import type { TaskFingerprint } from "./fingerprint.d.ts";
-import type { OutputSpec } from "./types.d.ts";
-/**
- * Represents a cached task result.
- */
-interface CachedResult {
-    /** The exit code of the original task execution */
-    code: number;
-    /** The auto-fingerprint data, if auto-fingerprinting was used */
-    fingerprint?: TaskFingerprint;
-    /** The hash that was used as the cache key */
-    hash: string;
-    /** The terminal output of the original task execution */
-    terminalOutput: string;
-}
-/**
- * Options for creating a Cache instance.
- */
-interface CacheOptions {
-    /** The cache directory (defaults to `{workspaceRoot}/.task-runner-cache`) */
-    cacheDirectory?: string;
-    /**
-     * Optional isolation namespace appended to the cache directory
-     * as `<cacheDir>/ns/<namespace>`. When the caller derives the
-     * namespace from the resolved global-env fingerprint, flipping an
-     * env var sends writes into a new namespace while keeping the old
-     * namespace intact — rolling the env back restores the old hits.
-     *
-     * Filesystem-safe segment; callers are responsible for sanitising
-     * (slashes/colons would break path resolution).
-     */
-    cacheNamespace?: string;
-    /** Maximum age of cache entries in milliseconds (default: 7 days) */
-    maxCacheAge?: number;
-    /** Maximum cache size (e.g., "500MB", "1GB") */
-    maxCacheSize?: string;
-    /** The workspace root directory */
-    workspaceRoot: string;
-}
-/**
- * Directory name (relative to `workspaceRoot`) where the task runner writes
- * its cache by default. Exported so callers that manage the cache from the
- * outside — e.g. a CLI `cache clean` command — can reach the same default
- * without hard-coding the literal.
- */
-declare const DEFAULT_CACHE_DIRECTORY_NAME = ".task-runner-cache";
-/**
- * Parses a human-readable cache size string into bytes.
- * Delegates to @visulima/humanizer's parseBytes with base-2 (1024) multipliers.
- */
-declare const parseCacheSize: (sizeString: string) => number;
-/**
- * Formats a byte count into a human-readable string.
- * Delegates to @visulima/humanizer's formatBytes with base-2 (1024) multipliers.
- */
-declare const formatCacheSize: (bytes: number) => string;
-/**
- * Local file-based cache for task results.
- *
- * Cache structure:
- * ```
- * .task-runner-cache/
- *   <hash>/
- *     outputs/          (Archived build outputs)
- *     code              (Exit code)
- *     terminalOutput    (Captured terminal output)
- *     fingerprint.json  (Auto-fingerprint data, optional)
- *     .commit           (Marker indicating complete cache entry)
- *   .task-index.json    (Task ID -> hash mapping for auto-fingerprint)
- * ```
- *
- * Atomicity: Cache entries are written to a temporary directory first,
- * then renamed into place. The `.commit` marker ensures readers only
- * see complete entries.
- */
-declare class Cache {
-    #private;
-    constructor(options: CacheOptions);
-    /**
-     * Gets the cache directory path.
-     */
-    get cacheDirectory(): string;
-    /**
-     * Retrieves a cached result for the given task hash.
-     * Returns undefined if no valid cache entry exists.
-     */
-    get(hash: string): Promise<CachedResult | undefined>;
-    /**
-     * Stores a task result in the cache.
-     *
-     * Uses atomic write: builds the entry in a temporary directory,
-     * then renames into place to avoid partial reads by concurrent processes.
-     *
-     * `outputs` accepts the richer `OutputSpec[]` shape — glob
-     * patterns, negative globs, and `{ auto: true }` entries. Pass
-     * `autoWrites` alongside `{ auto: true }` so the resolver knows
-     * which files the task actually wrote; otherwise auto entries
-     * contribute nothing.
-     */
-    put(hash: string, terminalOutput: string, outputs: OutputSpec[], code: number, fingerprint?: TaskFingerprint, autoWrites?: ReadonlyArray<string>): Promise<void>;
-    /**
-     * Restores cached outputs from the compressed `outputs.tar.br`
-     * archive. Returns `true` either when the archive was extracted
-     * successfully OR when the entry simply has no outputs to restore.
-     *
-     * The restore flow stages into a temp directory, then swaps each
-     * top-level entry into place (see {@link restoreOutputsCompressed})
-     * so a mid-restore failure never destroys the user's working tree.
-     * The `outputs` parameter is no longer consulted at restore time —
-     * the archive is authoritative, and top-level entries in the
-     * extracted staging become the set of swap roots. Still accepted
-     * for backward compat.
-     */
-    restoreOutputs(hash: string, _outputs?: OutputSpec[]): Promise<boolean>;
-    /**
-     * Retrieves the most recent cached result for a task by its ID.
-     * Used in auto-fingerprint mode where the hash is derived from
-     * tracked file accesses rather than computed upfront.
-     */
-    getByTaskId(taskId: string): Promise<CachedResult | undefined>;
-    /**
-     * Stores the mapping from task ID to cache hash.
-     * Uses a write queue to serialize concurrent writes and prevent lost updates.
-     * Each write is atomic (temp file + rename).
-     */
-    setTaskIndex(taskId: string, hash: string): Promise<void>;
-    /**
-     * Removes old cache entries that exceed the maximum age,
-     * and enforces the maximum cache size by evicting oldest entries.
-     */
-    removeOldEntries(): Promise<void>;
-    /**
-     * Clears the entire cache.
-     */
-    clear(): Promise<void>;
-}
-export type { CachedResult, CacheOptions };
-export { Cache, DEFAULT_CACHE_DIRECTORY_NAME, formatCacheSize, parseCacheSize };

package/dist/chrome-trace.d.ts

@@ -1,53 +0,0 @@
-import type { RunSummary } from "./run-summary.d.ts";
-/**
- * A single event in the Chrome Tracing JSON format. Chrome's
- * chrome://tracing viewer and Perfetto both accept an array of these.
- *
- * Fields track the subset we actually emit:
- * - `ph: "X"` — "complete" span (has duration)
- * - `ph: "s"` / `ph: "f"` — flow start / finish (connects two spans)
- *
- * See the Chrome Trace Event Format spec on docs.google.com
- * (document id: 1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU)
- * for the full specification.
- */
-export interface ChromeTraceEvent {
-    args?: Record<string, unknown>;
-    /** Event category — grouped in the viewer's search/filter UI. */
-    cat: string;
-    /** Duration in microseconds — only set for `ph: "X"` events. */
-    dur?: number;
-    /** Flow ID — used to draw an arrow from flow-start to flow-finish. */
-    id?: number;
-    /** Human label shown on the timeline. */
-    name: string;
-    /**
-     * Event phase:
-     * - `"X"` — complete (span with duration)
-     * - `"s"` — flow start
-     * - `"f"` — flow finish
-     * - `"M"` — metadata
-     */
-    ph: "f" | "M" | "s" | "X";
-    pid: number;
-    tid: number;
-    /** Timestamp in microseconds. */
-    ts: number;
-}
-/**
- * Converts a {@link RunSummary} into a Chrome Tracing event list that
- * renders as a gantt chart in chrome://tracing or Perfetto.
- *
- * Each task becomes a `"X"` span; dependency edges become flow arrows
- * from the dependency's finish to the dependent task's start.
- * Parallel tasks are assigned synthetic `tid` values (lane 0, 1, 2, …)
- * based on the smallest free lane at the task's start time, so the
- * timeline clearly shows concurrency without requiring real thread IDs.
- */
-export declare const toChromeTrace: (summary: RunSummary) => ChromeTraceEvent[];
-/**
- * Writes a Chrome Tracing JSON file at `outputPath`. Consumers (e.g.
- * a CLI `--profile out.json` flag) call this after the run completes
- * with a RunSummary produced by the task orchestrator.
- */
-export declare const writeChromeTrace: (summary: RunSummary, outputPath: string) => Promise<void>;

package/dist/command-parser/expand-arguments.d.ts

@@ -1,11 +0,0 @@
-import type { ConcurrentCommandConfig } from "../types.d.ts";
-/**
- * Expands argument placeholders in command strings.
- *
- * Placeholders:
- *   {1}, {2}, ...  -> specific positional argument
- *   {@}            -> all arguments, individually quoted
- *   {*}            -> all arguments as a single quoted string
- *   \{1}           -> literal {1} (escaped)
- */
-export declare const expandArguments: (config: ConcurrentCommandConfig, additionalArguments: string[]) => ConcurrentCommandConfig;

package/dist/command-parser/expand-shortcut.d.ts

@@ -1,15 +0,0 @@
-import type { ConcurrentCommandConfig } from "../types.d.ts";
-/**
- * Expands package manager shortcuts into full commands.
- *
- * This parser transforms shorthand notation into proper package manager
- * invocations. No user input is involved -- command strings originate
- * from the calling code which reads package.json scripts.
- *
- * Examples:
- *   npm:build    -> npm run build
- *   pnpm:test    -> pnpm run test
- *   node:script  -> node --run script
- *   deno:task    -> deno task task
- */
-export declare const expandShortcut: (config: ConcurrentCommandConfig) => ConcurrentCommandConfig;

package/dist/command-parser/expand-wildcard.d.ts

@@ -1,13 +0,0 @@
-import type { ConcurrentCommandConfig } from "../types.d.ts";
-/**
- * Expands wildcard patterns in package manager "run" commands.
- *
- * Reads scripts from package.json and matches against the wildcard pattern.
- * Returns one ConcurrentCommandConfig per matching script.
- *
- * Example: "npm run watch-*" with scripts { "watch-js": "...", "watch-css": "..." }
- *          -> ["npm run watch-js", "npm run watch-css"]
- *
- * No user input is involved -- patterns come from the calling code.
- */
-export declare const expandWildcard: (config: ConcurrentCommandConfig) => ConcurrentCommandConfig | ConcurrentCommandConfig[];

package/dist/command-parser/index.d.ts

@@ -1,18 +0,0 @@
-import type { ConcurrentCommandConfig, ConcurrentCommandInput } from "../types.d.ts";
-export interface ParseCommandsOptions {
-    /** Additional arguments for placeholder expansion ({1}, {@}, {*}). */
-    additionalArguments?: string[];
-}
-/**
- * Parse and expand command inputs through the full pipeline:
- * 1. Normalize string inputs to config objects
- * 2. Strip surrounding quotes
- * 3. Expand package manager shortcuts (npm:build -> npm run build)
- * 4. Expand wildcard patterns (npm run watch-* -> multiple commands)
- * 5. Expand argument placeholders ({1}, {@}, {*})
- */
-export declare const parseCommands: (inputs: ConcurrentCommandInput[], options?: ParseCommandsOptions) => ConcurrentCommandConfig[];
-export { expandArguments } from "./expand-arguments.d.ts";
-export { expandShortcut } from "./expand-shortcut.d.ts";
-export { expandWildcard } from "./expand-wildcard.d.ts";
-export { stripQuotes } from "./strip-quotes.d.ts";

package/dist/command-parser/strip-quotes.d.ts

@@ -1,6 +0,0 @@
-import type { ConcurrentCommandConfig } from "../types.d.ts";
-/**
- * Removes surrounding quotes from a command string.
- * Handles both single and double quotes.
- */
-export declare const stripQuotes: (config: ConcurrentCommandConfig) => ConcurrentCommandConfig;

package/dist/concurrent-fallback.d.ts

@@ -1,16 +0,0 @@
-/**
- * Pure JavaScript fallback for the concurrent process runner.
- * Used when the native Rust addon is not available.
- *
- * SECURITY NOTE: Commands executed here originate from package.json scripts
- * (trusted input, not user-supplied). Shell execution via spawn() with
- * explicit shell binary (sh -c / cmd.exe /s /c) is intentional -- package
- * scripts require shell features (pipes, redirects, env expansion).
- * This is the same approach used by npm/pnpm/yarn themselves.
- */
-import type { ConcurrentCommandConfig, ConcurrentRunnerOptions, ConcurrentRunResult } from "./types.d.ts";
-/**
- * Run commands concurrently using pure JavaScript (child_process.spawn).
- * This is the fallback when the native Rust addon is unavailable.
- */
-export declare const runConcurrentFallback: (commands: ConcurrentCommandConfig[], options: ConcurrentRunnerOptions) => Promise<ConcurrentRunResult>;

package/dist/concurrent.d.ts

@@ -1,23 +0,0 @@
-/**
- * Public API for the concurrent process runner.
- *
- * Uses the native Rust addon when available, falling back to
- * a pure JavaScript implementation. Integrates flow controllers
- * (restart, teardown, timings) around the core runner.
- */
-import type { ConcurrentCommandInput, ConcurrentRunnerOptions, ConcurrentRunResult } from "./types.d.ts";
-/**
- * Run commands concurrently with output streaming and process management.
- *
- * Automatically uses the native Rust addon for performance when available,
- * falling back to a pure JavaScript implementation.
- *
- * Supports flow controllers:
- * - `restart`: retry failed commands with configurable delay/backoff
- * - `teardown`: run cleanup commands after all processes complete
- * - `timings`: print a timing summary table
- * @param commands Array of command strings or config objects
- * @param options Runner options (maxProcesses, killOthers, restart, teardown, etc.)
- * @returns Promise resolving to the run result with close events and success status
- */
-export declare const runConcurrently: (commands: ConcurrentCommandInput[], options?: ConcurrentRunnerOptions) => Promise<ConcurrentRunResult>;

package/dist/default-task-runner.d.ts

@@ -1,44 +0,0 @@
-import type { Task, TaskResults, TaskRunnerContext, TaskRunnerOptions } from "./types.d.ts";
-/**
- * The default task runner implementation.
- *
- * Runs tasks with caching, scheduling, and lifecycle support.
- * Supports two caching modes:
- *
- * 1. **Nx-style** (default): Explicit input declarations with upfront hash computation.
- * 2. **Auto-fingerprint** (Vite Task-style): Set `autoFingerprint: true` to automatically
- * track file accesses and use them for cache invalidation.
- * @example
- * ```ts
- * import { defaultTaskRunner } from "@visulima/task-runner";
- *
- * // Nx-style (explicit inputs)
- * const results = await defaultTaskRunner(tasks, options, context);
- *
- * // Vite Task-style (auto-fingerprinting)
- * const results = await defaultTaskRunner(tasks, {
- *     ...options,
- *     autoFingerprint: true,
- *     fingerprintEnvPatterns: ["VITE_*", "NODE_ENV"],
- *     cacheDiagnostics: true,
- * }, context);
- *
- * // With remote cache
- * const results = await defaultTaskRunner(tasks, {
- *     ...options,
- *     remoteCache: {
- *         url: "https://cache.example.com",
- *         token: process.env.CACHE_TOKEN,
- *         teamId: "my-team",
- *     },
- * }, context);
- *
- * // Dry-run (inspect hashes without executing)
- * const results = await defaultTaskRunner(tasks, {
- *     ...options,
- *     dryRun: true,
- * }, context);
- * ```
- */
-declare const defaultTaskRunner: (_tasks: Task[], options: TaskRunnerOptions, context: TaskRunnerContext) => Promise<TaskResults>;
-export { defaultTaskRunner };

package/dist/detect-shell.d.ts

@@ -1,19 +0,0 @@
-/**
- * Detects the configured script shell for npm/pnpm/yarn.
- *
- * Resolution order:
- * 1. `npm_config_script_shell` env var (set by npm when running scripts)
- * 2. `npm config get script-shell` subprocess (cached after first call)
- * 3. Platform default (undefined = let the runner use /bin/sh or cmd.exe)
- */
-/**
- * Detect the npm script-shell configuration.
- *
- * Returns the shell path if configured, or undefined to use platform defaults.
- * The result is cached after the first call.
- */
-export declare const detectScriptShell: () => string | undefined;
-/**
- * Reset the cached shell path. Useful for testing.
- */
-export declare const resetShellCache: () => void;

package/dist/file-access-tracker.d.ts

@@ -1,59 +0,0 @@
-/**
- * Represents a file access recorded during task execution.
- *
- * Write-intent accesses (`"write"`) are emitted when a task opens a file
- * with `O_WRONLY`/`O_RDWR`/`O_CREAT`/`O_TRUNC` flags (strace) or calls
- * `writeFile`/`appendFile`/`unlink`/`rename` (preload script).
- * The orchestrator uses the overlap of reads and writes to the same
- * workspace path to detect self-modifying tasks and skip caching.
- */
-export interface FileAccess {
-    /** The absolute path of the file */
-    path: string;
-    /** The type of access */
-    type: "missing" | "read" | "readdir" | "stat" | "write";
-}
-/**
- * Result of tracking file accesses during a command execution.
- */
-export interface TrackingResult {
-    /** All file accesses recorded */
-    accesses: FileAccess[];
-    /** The command exit code */
-    code: number;
-    /** The command stdout + stderr output */
-    output: string;
-}
-/**
- * Tracks which files a child process accesses during execution.
- *
- * Uses `strace` on Linux to intercept syscalls (open, openat, stat, lstat, access, getdents).
- * Falls back to no tracking on unsupported platforms.
- */
-export declare class FileAccessTracker {
-    #private;
-    constructor(workspaceRoot: string, excludePatterns?: RegExp[]);
-    /**
-     * Returns true if file access tracking is supported on the current platform.
-     */
-    isSupported(): boolean;
-    /**
-     * Runs a command and tracks all file system accesses.
-     * On unsupported platforms, runs the command without tracking.
-     */
-    track(command: string, options?: {
-        cwd?: string;
-        env?: Record<string, string | undefined>;
-    }): Promise<TrackingResult>;
-    /**
-     * Kills all active child processes. Called on abort/signal to prevent orphans.
-     */
-    killAll(): void;
-}
-/**
- * Generates a preload script that can be used with NODE_OPTIONS to
- * track file accesses in Node.js child processes.
- *
- * This is an alternative to strace that works cross-platform for Node.js processes.
- */
-export declare const generatePreloadScript: (outputPath: string) => string;

package/dist/fingerprint.d.ts

@@ -1,54 +0,0 @@
-import type { FileAccess } from "./file-access-tracker.d.ts";
-/**
- * Represents a stored fingerprint for a task execution.
- */
-export interface TaskFingerprint {
-    /** Hash of the command arguments */
-    commandHash: string;
-    /** Directory listings recorded during execution (path -> sorted entries) */
-    directoryListings: Record<string, string[]>;
-    /** Hashes of fingerprinted environment variables */
-    envHashes: Record<string, string>;
-    /** Content hashes of files that were read during execution */
-    fileHashes: Record<string, string>;
-    /** Paths of files that were probed but didn't exist (ENOENT) */
-    missingFiles: string[];
-    /**
-     * Workspace-relative paths that were both read **and** written
-     * during execution. Populated when the tracker emits
-     * {@link FileAccess} entries with `"write"` type. The orchestrator
-     * uses a non-empty value here to skip caching a self-modifying
-     * task, whose fingerprint would otherwise capture post-write state
-     * and trigger false cache hits.
-     */
-    modifiedInputs?: string[];
-}
-/**
- * Describes why a cache miss occurred.
- */
-export interface CacheMissReason {
-    currentHash?: string;
-    detail: string;
-    previousHash?: string;
-    type: "file-changed" | "file-created" | "file-deleted" | "directory-changed" | "env-changed" | "args-changed" | "no-fingerprint";
-}
-/**
- * Manages task fingerprints for auto-detection caching.
- *
- * Records which files a task accesses during execution, stores content
- * hashes, and on subsequent runs checks if any accessed file has changed.
- */
-export declare class FingerprintManager {
-    #private;
-    constructor(workspaceRoot: string);
-    createFingerprint(accesses: FileAccess[], command: string, args: Record<string, unknown>, envVariables: Record<string, string | undefined>, envPatterns?: string[], untrackedEnvVariables?: string[]): Promise<TaskFingerprint>;
-    /**
-     * Validates a stored fingerprint against the current state.
-     * Returns null if valid (cache hit), or an array of reasons (cache miss).
-     *
-     * Does NOT use the file hash cache — validation must see current disk state.
-     */
-    validate(fingerprint: TaskFingerprint): Promise<CacheMissReason[] | undefined>;
-    validateCommand(fingerprint: TaskFingerprint, command: string, args: Record<string, unknown>): CacheMissReason | undefined;
-    formatMissReasons(reasons: CacheMissReason[]): string;
-}

package/dist/flow-controllers/index.d.ts

@@ -1,7 +0,0 @@
-export type { InputHandlerOptions } from "./input-handler.d.ts";
-export { createInputHandler } from "./input-handler.d.ts";
-export { formatTimingTable, logTimings } from "./log-timings.d.ts";
-export type { RestartOptions } from "./restart-process.d.ts";
-export { withRestart } from "./restart-process.d.ts";
-export type { TeardownOptions } from "./teardown.d.ts";
-export { runTeardown } from "./teardown.d.ts";