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

package/dist/index.d.ts

@@ -1,49 +1,2507 @@
-export type { AffectedOptions, AffectedResult } from "./affected.d.ts";
-export { buildForwardDependencyMap, buildReverseDependencyMap, expandAffected, filterAffectedTasks, getAffectedProjects, getChangedFiles } from "./affected.d.ts";
-export type { CachedResult, CacheOptions } from "./cache.d.ts";
-export { Cache, DEFAULT_CACHE_DIRECTORY_NAME, formatCacheSize, parseCacheSize } from "./cache.d.ts";
-export type { ChromeTraceEvent } from "./chrome-trace.d.ts";
-export { toChromeTrace, writeChromeTrace } from "./chrome-trace.d.ts";
-export type { ParseCommandsOptions } from "./command-parser/index.d.ts";
-export { expandArguments, expandShortcut, expandWildcard, parseCommands, stripQuotes } from "./command-parser/index.d.ts";
-export { runConcurrently } from "./concurrent.d.ts";
-export { runConcurrentFallback } from "./concurrent-fallback.d.ts";
-export { defaultTaskRunner } from "./default-task-runner.d.ts";
-export { detectScriptShell } from "./detect-shell.d.ts";
-export type { FileAccess, TrackingResult } from "./file-access-tracker.d.ts";
-export { FileAccessTracker, generatePreloadScript } from "./file-access-tracker.d.ts";
-export type { CacheMissReason, TaskFingerprint } from "./fingerprint.d.ts";
-export { FingerprintManager } from "./fingerprint.d.ts";
-export type { InputHandlerOptions, RestartOptions, TeardownOptions } from "./flow-controllers/index.d.ts";
-export { createInputHandler, formatTimingTable, logTimings, runTeardown, withRestart } from "./flow-controllers/index.d.ts";
-export type { DetectedFramework } from "./framework-inference.d.ts";
-export { detectFrameworks, getFrameworkEnvVariables, inferFrameworkEnvPatterns } from "./framework-inference.d.ts";
-export type { GraphFormat, GraphJson, GraphVisualizerOptions } from "./graph-visualizer.d.ts";
-export { projectGraphToDot, toGraphAscii, toGraphHtml, toGraphJson, toGraphvizDot } from "./graph-visualizer.d.ts";
-export type { FileSnapshot, IncrementalHasherOptions } from "./incremental-hasher.d.ts";
-export { IncrementalFileHasher } from "./incremental-hasher.d.ts";
-export { CompositeLifeCycle, ConsoleLifeCycle, EmptyLifeCycle } from "./life-cycle.d.ts";
-export type { PackageLockfileHash, ResolvedDependency } from "./lockfile-hasher.d.ts";
-export { extractPackageName, LockfileHasher, parseNpmLockfile, parsePnpmLockfile, parseYarnLockfile } from "./lockfile-hasher.d.ts";
-export type { LogMode } from "./log-reporter.d.ts";
-export { createLogReporter, LogReporter } from "./log-reporter.d.ts";
-export { isNativeAvailable, loadNativeBindings } from "./native-binding.d.ts";
-export { resolveOutputs } from "./output-resolver.d.ts";
-export { enforceProjectConstraints } from "./project-constraints.d.ts";
-export type { RemoteCacheCompression, RemoteCacheOptions, RemoteCacheSigning } from "./remote-cache.d.ts";
-export { RemoteCache } from "./remote-cache.d.ts";
-export type { RunSummary, TaskSummary } from "./run-summary.d.ts";
-export { generateRunSummary, getLastRunSummaryPath, readLastRunSummary, writeLastRunSummary, writeRunSummary } from "./run-summary.d.ts";
-export { createTaskGraph, getTaskId, parseTaskId } from "./task-graph.d.ts";
-export { findCycle, findCycles, getDependentTasks, getLeafTasks, getTransitiveDependencies, makeAcyclic, reverseTaskGraph, walkTaskGraph, } from "./task-graph-utils.d.ts";
-export type { TaskHasher, TaskHasherOptions } from "./task-hasher.d.ts";
-export { computeTaskHash, InProcessTaskHasher } from "./task-hasher.d.ts";
-export type { TaskOrchestratorOptions } from "./task-orchestrator.d.ts";
-export { TaskOrchestrator } from "./task-orchestrator.d.ts";
-export type { PartitionOptions } from "./task-scheduler.d.ts";
-export { parsePartition, TaskScheduler } from "./task-scheduler.d.ts";
-export { TerminalBuffer } from "./terminal-buffer.d.ts";
-export type { TrackedExecutionResult } from "./tracked-executor.d.ts";
-export { TrackedTaskExecutor } from "./tracked-executor.d.ts";
-export type { AffectedScope, ConcurrentCloseEvent, ConcurrentCommandConfig, ConcurrentCommandInput, ConcurrentRunnerOptions, ConcurrentRunResult, ConstraintsConfig, ConstraintViolation, DependencyKindRules, DependencyType, EnvironmentInput, ExternalDependencyInput, FileSetBase, FileSetInput, FileSetPattern, InputDefinition, LifeCycleInterface, NamedInputs, OutputSpec, ProcessEvent, ProjectConfiguration, ProjectGraph, ProjectGraphDependency, ProjectGraphProjectNode, RuntimeInput, TagRelationships, TargetConfiguration, TargetDependencyConfig, Task, TaskExecutionOptions, TaskExecutor, TaskGraph, TaskHashDetails, TaskPriority, TaskResult, TaskResults, TaskRunnerContext, TaskRunnerOptions, TasksRunner, TaskStatus, TaskTarget, TypeBoundaries, WorkspaceConfiguration, } from "./types.d.ts";
-export { collectFiles, createFailureResult, hashFile, hashStrings, readPackageDeps, resolveTaskCwd, sortObjectKeys, uniqueId } from "./utils.d.ts";
+import { Readable, Writable } from 'node:stream';
+/**
+* A predicate clause that can match a single value, a list of values
+* (any-of), or — for env vars only — a `{ name, equals?, exists? }`
+* triplet. `not.*` mirrors of every clause provide a negative form
+* without having to wrap the whole `when` in a compound expression.
+*
+* Examples:
+*   `os: "linux"`              — runs only on linux
+*   `os: ["linux", "darwin"]`  — runs on linux or macOS
+*   `not.os: "windows"`        — runs everywhere except windows
+*   `env: "CI"`                — runs only when `process.env.CI` is truthy
+*   `env: { name: "NODE_ENV", equals: "production" }`
+*   `branch: ["main", "alpha"]`
+*   `ci: true`                 — runs only inside CI
+*/
+interface WhenCondition {
+  /** Match against the current git branch (HEAD). */
+  branch?: string | string[];
+  /**
+  * Run only when invoked inside CI when `true`, only outside CI
+  * when `false`. Detects CI via the `CI` env var (the convention
+  * GitHub Actions, GitLab, CircleCI, Jenkins, etc. all share).
+  */
+  ci?: boolean;
+  /**
+  * Match against environment variables. A bare string asserts the
+  * variable is set and non-empty; the object form lets you match
+  * an exact value or just assert presence/absence.
+  */
+  env?: EnvMatcher | EnvMatcher[];
+  /** Negative mirrors. A task runs only when *all* `not.*` clauses fail. */
+  not?: {
+    branch?: string | string[];
+    ci?: boolean;
+    env?: EnvMatcher | EnvMatcher[];
+    os?: NodePlatform | NodePlatform[];
+  };
+  /**
+  * Match `process.platform` (`"linux" | "darwin" | "win32" | "freebsd"
+  * | "openbsd" | "sunos" | "aix"`). Pass `"windows"` as an alias for
+  * `"win32"` — easier to remember and matches what people type.
+  */
+  os?: NodePlatform | NodePlatform[];
+}
+/**
+* An environment-variable match. The string form is shorthand for
+* `{ name, exists: true }` (set + non-empty). The object form
+* supports either presence assertions or exact-value matching.
+*/
+type EnvMatcher = string | {
+  /** Match this exact value. Mutually exclusive with `exists`. */
+  equals?: string;
+  /** Assert the variable is set & non-empty (`true`) or unset/empty (`false`). */
+  exists?: boolean;
+  /** Variable name. */
+  name: string;
+};
+/** Aliased platform list — `"windows"` is sugar for Node's `"win32"`. */
+type NodePlatform = "aix" | "darwin" | "freebsd" | "linux" | "openbsd" | "sunos" | "windows" | "win32";
+/**
+* Inputs for {@link evaluateWhen}. Pulled into a struct so tests can
+* inject deterministic values and CLIs can reuse the same env/branch
+* lookup across many task evaluations.
+*/
+interface WhenContext {
+  /** Current git branch. Pass an empty string when not in a repo. */
+  branch?: string;
+  /** Whether we're inside CI. Defaults to `process.env.CI` truthy check. */
+  ci?: boolean;
+  /** Environment variables to match against. Defaults to `process.env`. */
+  env?: Record<string, string | undefined>;
+  /** Platform string. Defaults to `process.platform`. */
+  platform?: NodePlatform;
+}
+declare const getCurrentBranch: (cwd: string) => string;
+/** Test-only escape hatch — clears every cached branch result. */
+declare const resetBranchCache: () => void;
+/**
+* Evaluates a {@link WhenCondition} against the supplied context (or the
+* live process state when omitted). Returns `true` when the task should
+* run, `false` when every positive clause matches and every `not.*`
+* clause is also satisfied.
+*
+* Semantics:
+*   - All positive clauses must match (AND).
+*   - All `not.*` clauses must not match (AND).
+*   - Within a single clause, an array means any-of (OR).
+*   - An empty/undefined `when` always returns `true`.
+*/
+declare const evaluateWhen: (when: WhenCondition | undefined, context?: WhenContext) => boolean;
+/**
+* Returns a short human-readable explanation of why a `when` clause
+* skipped a task. Used by lifecycle handlers to print diagnostics.
+* Returns an empty string when the condition evaluates to true.
+*/
+declare const explainWhen: (when: WhenCondition | undefined, context?: WhenContext) => string;
+/**
+* Represents a target that a task executes against.
+*/
+interface TaskTarget {
+  /** Optional configuration name */
+  configuration?: string;
+  /** The project name */
+  project: string;
+  /** The target name (e.g., "build", "test", "lint") */
+  target: string;
+}
+/**
+* Represents a single task to be executed.
+*/
+/**
+* Scheduling priority hint. The scheduler picks higher-priority tasks
+* out of the ready-queue first; ties fall through to the graph-derived
+* signals (dependent count, project depth).
+*
+* Use `"high"` for long-running leaves you want to kick off early
+* (integration tests, e2e suites) so their wall-clock overlaps with
+* the main build phase. Use `"low"` for work you don't mind deferring
+* (linters, coverage uploads) when faster tasks contend for slots.
+*/
+type TaskPriority = "high" | "low" | "normal";
+/**
+* A single entry in a task's `outputs` list.
+*
+* - `string` — a literal path *or* a glob pattern relative to the
+*   workspace root. Prefix with `!` to exclude files the positive
+*   patterns would otherwise include (e.g. `"!dist/cache/**"`).
+* - `{ auto: true }` — use whatever files the task actually wrote
+*   during execution (resolved from the file-access tracker). Lets
+*   authors who don't know their exact output layout cache results
+*   without listing every path. Silently behaves as "no outputs" when
+*   tracking isn't active for this task.
+*/
+type OutputSpec = string | {
+  auto: true;
+};
+interface Task {
+  /**
+  * When `true`, this task runs after the main task graph completes
+  * — even if upstream tasks failed or the run was interrupted.
+  * Used for cleanup, teardown, or notification tasks. Carried over
+  * from {@link TargetConfiguration.always} at task graph creation.
+  */
+  always?: boolean;
+  /** Whether this task is eligible for caching */
+  cache?: boolean;
+  /** Hash of the task inputs for caching */
+  hash?: string;
+  /** Detailed hash information */
+  hashDetails?: TaskHashDetails;
+  /** Unique identifier for the task, typically "project:target:configuration" */
+  id: string;
+  /**
+  * Output patterns this task produces. Each entry is either a
+  * literal path, a glob (`"dist/**"`), a negative glob
+  * (`"!dist/cache/**"`), or `{ auto: true }` to pick up whatever
+  * files the task wrote during execution.
+  */
+  outputs: OutputSpec[];
+  /** Overrides/extra options passed to the task */
+  overrides: Record<string, unknown>;
+  /** Whether this task supports parallel execution */
+  parallelism?: boolean;
+  /**
+  * Explicit scheduling priority. Outranks the scheduler's
+  * graph-derived heuristics. Defaults to `"normal"` when absent.
+  */
+  priority?: TaskPriority;
+  /** The project root directory */
+  projectRoot?: string;
+  /** The target this task executes */
+  target: TaskTarget;
+  /**
+  * Predicate that gates execution. Evaluated by the orchestrator
+  * just before the task is launched; tasks whose `when` returns
+  * `false` are marked `"skipped"` without ever invoking the
+  * executor. Carried over from {@link TargetConfiguration.when}.
+  */
+  when?: WhenCondition;
+}
+/**
+* Represents detailed hash information for a task.
+*/
+interface TaskHashDetails {
+  /** The command hash */
+  command: string;
+  /** Hash of implicit dependencies */
+  implicitDeps?: Record<string, string>;
+  /** Hashes of input files */
+  nodes: Record<string, string>;
+  /** Hash of runtime values */
+  runtime?: Record<string, string>;
+}
+/**
+* Represents a directed acyclic graph of tasks.
+*/
+interface TaskGraph {
+  /** Dependencies for each task */
+  dependencies: Record<string, string[]>;
+  /** Top-level tasks that no other task depends on (the final outputs to run) */
+  roots: string[];
+  /** All tasks in the graph, keyed by task ID */
+  tasks: Record<string, Task>;
+}
+/**
+* Possible states of a task after execution.
+*/
+type TaskStatus = "success" | "failure" | "skipped" | "local-cache" | "local-cache-kept-existing" | "remote-cache";
+/**
+* Result of executing a task.
+*/
+interface TaskResult {
+  /** The exit code, if applicable */
+  code?: number;
+  /**
+  * Set when auto-fingerprint tracking was attempted for this task but
+  * returned zero workspace accesses — usually a static binary on
+  * macOS/Windows, where the Node preload can't attach. Caching is
+  * skipped to avoid persisting an empty fingerprint that would
+  * produce false cache hits on every subsequent run.
+  */
+  emptyFingerprint?: boolean;
+  /** The end time of the task */
+  endTime?: number;
+  /**
+  * Set when the task modified one or more of its own tracked input
+  * files during execution. Caching is skipped in this case — the
+  * fingerprint captured before the run would mismatch the post-run
+  * contents and produce false cache hits on subsequent runs.
+  */
+  selfModified?: boolean;
+  /** The start time of the task */
+  startTime?: number;
+  status: TaskStatus;
+  task: Task;
+  /** The terminal output produced during execution */
+  terminalOutput?: string;
+}
+/**
+* Map of task results, keyed by task ID.
+*/
+type TaskResults = Map<string, TaskResult>;
+/**
+* Configuration for a project in the workspace.
+*/
+interface ProjectConfiguration {
+  /** Implicit dependencies on other projects */
+  implicitDependencies?: string[];
+  /**
+  * Project layer in the dependency hierarchy. Used by
+  * `enforceLayerRelationships` to ensure projects only depend on
+  * projects at the same or lower layer.
+  *
+  * Hierarchy (lowest → highest):
+  * `configuration < library < scaffolding < tool < automation < application`
+  */
+  layer?: "application" | "automation" | "configuration" | "library" | "scaffolding" | "tool";
+  /** The project type */
+  projectType?: "library" | "application";
+  /** The root directory of the project, relative to workspace root */
+  root: string;
+  /** The source root directory */
+  sourceRoot?: string;
+  /** Tags for filtering */
+  tags?: string[];
+  /** Named targets and their configurations */
+  targets?: Record<string, TargetConfiguration>;
+}
+/**
+* Configuration for a target within a project.
+*/
+interface TargetConfiguration {
+  /**
+  * When `true`, this target runs after the main task graph
+  * completes — even if upstream tasks failed. Useful for cleanup,
+  * teardown, notifications, or anything that should fire
+  * regardless of build outcome. Always-tasks are not part of the
+  * normal dependency graph and never block other tasks.
+  */
+  always?: boolean;
+  /** Whether this target is cacheable */
+  cache?: boolean;
+  /** The command to run (alternative to executor) */
+  command?: string;
+  /** Named configurations (e.g., "production", "development") */
+  configurations?: Record<string, Record<string, unknown>>;
+  /** Other targets this target depends on */
+  dependsOn?: (string | TargetDependencyConfig)[];
+  /** The executor/command to run */
+  executor?: string;
+  /** Input patterns for cache invalidation */
+  inputs?: (string | InputDefinition)[];
+  /** Options passed to the executor */
+  options?: Record<string, unknown>;
+  /** Output patterns produced by this target */
+  outputs?: string[];
+  /** Whether this target supports parallel execution */
+  parallelism?: boolean;
+  /**
+  * Predicate that gates execution. When the condition evaluates
+  * to `false` for the current environment, the task is skipped
+  * (marked `"skipped"`, not failed). Combine with `os`, `env`,
+  * `branch`, and `ci` clauses for granular control:
+  *
+  *   ```ts
+  *   when: { os: "linux", ci: true, env: "DEPLOY_TOKEN" }
+  *   ```
+  */
+  when?: WhenCondition;
+}
+/**
+* Defines a dependency on another target.
+*/
+interface TargetDependencyConfig {
+  /** Whether this is a dependency on the same project */
+  dependencies?: boolean;
+  /** Params to pass through */
+  params?: "forward" | "ignore";
+  /** The project name (if different from the current project) */
+  projects?: string | string[];
+  /** The target name */
+  target: string;
+}
+/**
+* Defines an input for cache invalidation.
+*/
+type InputDefinition = FileSetInput | RuntimeInput | EnvironmentInput | ExternalDependencyInput;
+/**
+* Controls how a glob pattern is anchored.
+* - "package" (default): pattern is resolved relative to the project root
+* - "workspace": pattern is resolved relative to the workspace root
+*/
+type FileSetBase = "package" | "workspace";
+/**
+* An input based on file patterns.
+*
+* `fileset` may be a bare glob string (package-root relative) or an object
+* form `{ pattern, base }` to anchor explicitly to the workspace root.
+* Negation (`!` prefix) works in both forms.
+*/
+interface FileSetInput {
+  fileset: FileSetPattern | string;
+}
+/**
+* Object form of a fileset pattern, for anchoring to the workspace root.
+*/
+interface FileSetPattern {
+  /** Anchor for the pattern. */
+  base: FileSetBase;
+  /** Glob pattern (may start with `!` for negation). */
+  pattern: string;
+}
+/**
+* An input based on a runtime command.
+*/
+interface RuntimeInput {
+  runtime: string;
+}
+/**
+* An input based on environment variables.
+*/
+interface EnvironmentInput {
+  env: string;
+}
+/**
+* An input based on external dependency versions.
+*/
+interface ExternalDependencyInput {
+  externalDependencies: string[];
+}
+/**
+* Defines tag-based dependency rules.
+* Each key is a tag name. The value is the list of tags that a dependency
+* must have at least one of, when the source project has that tag.
+*
+* Example: `{ "frontend": ["shared", "frontend"] }` means a project tagged
+* "frontend" can only depend on projects tagged "shared" or "frontend".
+*/
+type TagRelationships = Record<string, string[]>;
+/**
+* Defines project-type-based dependency rules.
+*/
+interface TypeBoundaries {
+  /**
+  * Custom rules mapping project types to allowed dependency types.
+  * Example: `{ "application": ["library"] }` means applications can only
+  * depend on libraries.
+  */
+  allowedDependencyTypes?: Record<string, string[]>;
+  /**
+  * When true, no project may depend on an "application" type project.
+  * Applications are typically deployment targets, not libraries.
+  * @default true
+  */
+  enforceApplicationBoundary?: boolean;
+}
+/**
+* Rules based on the dependency kind (dependencies vs devDependencies vs peerDependencies).
+*/
+interface DependencyKindRules {
+  /**
+  * When true, a "library" project must not have workspace-internal devDependencies
+  * on other libraries that are also in its production dependencies.
+  * Prevents publishing libraries that silently rely on dev-only workspace packages.
+  * @default false
+  */
+  noDevDependencyOnProductionDep?: boolean;
+  /**
+  * When true, production `dependencies` must not point to "application" type projects.
+  * devDependencies on applications are allowed (e.g., for testing).
+  * @default false
+  */
+  noProductionDependencyOnApplication?: boolean;
+}
+/**
+* Configuration for project constraint enforcement.
+*/
+interface ConstraintsConfig {
+  /** Rules based on the dependency kind (static vs devDependency vs peerDependency) */
+  dependencyKindRules?: DependencyKindRules;
+  /**
+  * When true, projects can only depend on projects at the same or
+  * lower layer in the hierarchy:
+  *
+  *   configuration < library < scaffolding < tool < automation < application
+  *
+  * Projects without an explicit `layer` are unconstrained.
+  * @default false
+  */
+  enforceLayerRelationships?: boolean;
+  /** Tag-based dependency rules */
+  tagRelationships?: TagRelationships;
+  /** Project-type-based dependency rules */
+  typeBoundaries?: TypeBoundaries;
+}
+/**
+* A single constraint violation detected in the project graph.
+*/
+interface ConstraintViolation {
+  /** The project being depended on */
+  dependencyProject: string;
+  /** Human-readable description of the violation */
+  message: string;
+  /** The type of rule that was violated */
+  rule: "dependency-kind" | "layer-relationship" | "tag-relationship" | "type-boundary";
+  /** The project that has the invalid dependency */
+  sourceProject: string;
+}
+/**
+* Controls how far to traverse the dependency graph in a given direction.
+* - "none": Don't traverse — only directly changed projects are included.
+* - "direct": Include only immediate neighbors (one hop).
+* - "deep": Include all transitive neighbors (full chain).
+*/
+type AffectedScope = "deep" | "direct" | "none";
+/**
+* Workspace configuration containing all project configurations.
+*/
+interface WorkspaceConfiguration {
+  /** All projects in the workspace, keyed by project name */
+  projects: Record<string, ProjectConfiguration>;
+}
+/**
+* The kind of dependency relationship between projects.
+* - "static": Production dependency (from `dependencies` in package.json)
+* - "dynamic": Dynamically resolved dependency (e.g., lazy imports)
+* - "implicit": Declared via `implicitDependencies` in project config
+* - "devDependency": Development-only dependency (from `devDependencies`)
+* - "peerDependency": Peer dependency (from `peerDependencies`)
+*/
+type DependencyType = "devDependency" | "dynamic" | "implicit" | "peerDependency" | "static";
+/**
+* A dependency relationship in the project graph.
+*/
+interface ProjectGraphDependency {
+  /** The source project */
+  source: string;
+  /** The target project */
+  target: string;
+  /** The type of dependency */
+  type: DependencyType;
+}
+/**
+* A node in the project graph.
+*/
+interface ProjectGraphProjectNode {
+  /** The project configuration */
+  data: ProjectConfiguration;
+  /** The project name */
+  name: string;
+  /** The type of project */
+  type: "library" | "application";
+}
+/**
+* The project graph represents the dependency relationships between projects.
+*/
+interface ProjectGraph {
+  /** All dependency relationships */
+  dependencies: Record<string, ProjectGraphDependency[]>;
+  /** All project nodes, keyed by project name */
+  nodes: Record<string, ProjectGraphProjectNode>;
+}
+/**
+* Named input definitions that can be referenced by name.
+*/
+interface NamedInputs {
+  [name: string]: (string | InputDefinition)[];
+}
+/**
+* Configuration for the task runner.
+*/
+interface TaskRunnerOptions {
+  /**
+  * Scan each task's resolved command text for `$VAR`/`${VAR}`
+  * references and automatically fingerprint those env vars. Catches
+  * tasks like `curl ${VERCEL_URL}/api` where the user forgot to
+  * declare the reference in `envVars`/`globalEnv`.
+  * @default false
+  */
+  autoEnvVars?: boolean;
+  /**
+  * Enable auto-fingerprinting mode (Vite Task-style).
+  * When enabled, the task runner automatically tracks which files
+  * a task accesses during execution and uses that for cache invalidation
+  * instead of requiring manual input configuration.
+  *
+  * Falls back to explicit inputs (Nx-style) when file tracking
+  * is not supported on the current platform.
+  * @default false
+  */
+  autoFingerprint?: boolean;
+  /**
+  * Whether to show cache miss diagnostics (why a cache miss occurred).
+  * @default false
+  */
+  cacheDiagnostics?: boolean;
+  /** Directory for storing cache */
+  cacheDirectory?: string;
+  /**
+  * Dry-run mode: compute hashes and check cache but don't execute tasks.
+  * Useful for debugging cache hits/misses.
+  * @default false
+  */
+  dryRun?: boolean;
+  /** Custom environment variables to include in hash */
+  envVars?: string[];
+  /**
+  * Environment variable patterns to include in auto-fingerprint.
+  * Supports wildcard patterns like "VITE_*".
+  * Only used when autoFingerprint is enabled.
+  */
+  fingerprintEnvPatterns?: string[];
+  /**
+  * Enable framework environment variable inference.
+  * When true, automatically detects common frontend frameworks and includes
+  * their public env var prefixes in the task hash:
+  * - Next.js: NEXT_PUBLIC_*
+  * - Vite: VITE_*
+  * - Create React App: REACT_APP_*
+  * - Gatsby: GATSBY_*
+  * - Nuxt: NUXT_PUBLIC_*
+  * - Expo: EXPO_PUBLIC_*
+  *
+  * Matches Turborepo's framework inference behavior.
+  * @default false
+  */
+  frameworkInference?: boolean;
+  /**
+  * Global environment variables that invalidate ALL task hashes.
+  * Matches Turborepo's `globalEnv`.
+  */
+  globalEnv?: string[];
+  /**
+  * Global input files that invalidate ALL task hashes when changed.
+  * These are workspace-root-relative paths.
+  *
+  * Default: ["package-lock.json", "pnpm-lock.yaml", "yarn.lock",
+  * "tsconfig.base.json", ".env"]
+  *
+  * When any global input changes, every task's hash changes,
+  * forcing a full rebuild. This matches Turborepo's `globalDependencies`.
+  */
+  globalInputs?: string[];
+  /**
+  * When `true`, file hashes are cached in a persistent mtime+size
+  * indexed snapshot under `node_modules/.cache/task-runner/`. On
+  * subsequent runs, unchanged files skip content re-reads — cuts
+  * cold-cache fingerprint time dramatically on large workspaces.
+  *
+  * Changed or new files still get full content hashing. Safe to
+  * leave on by default; overhead when nothing matches is a single
+  * `stat` call per file.
+  * @default false
+  */
+  incrementalFileHashing?: boolean;
+  /** Maximum age of cache entries in milliseconds */
+  maxCacheAge?: number;
+  /** Maximum cache size (e.g., "1GB") */
+  maxCacheSize?: string;
+  /** Named inputs for cache invalidation */
+  namedInputs?: NamedInputs;
+  /**
+  * When `true`, the cache directory is partitioned by a hash of
+  * the resolved `globalEnv` values. Changing a globalEnv var moves
+  * cache writes into a new namespace; rolling it back reuses the
+  * old namespace and its hits. Without this option, any globalEnv
+  * change silently busts every cached entry.
+  *
+  * Keep disabled when globalEnv is stable across runs — the extra
+  * path depth offers no value, and misconfigured namespaces can
+  * hide stale hits.
+  * @default false
+  */
+  namespaceByGlobalEnv?: boolean;
+  /** Maximum number of parallel tasks */
+  parallel?: number | boolean;
+  /**
+  * Remote cache configuration.
+  * When configured, the task runner will check the remote cache
+  * after a local cache miss, and upload results after execution.
+  */
+  remoteCache?: {
+    /**
+    * Called when a fire-and-forget upload fails.
+    * Since uploads are non-blocking, errors are silently swallowed by default.
+    * Provide this callback to log or report upload failures.
+    */
+    onUploadError?: (hash: string, error: unknown) => void;
+    /** Enable remote reads (default: true) */
+    read?: boolean;
+    /** Team/namespace for cache isolation */
+    teamId?: string;
+    /** Authentication token */
+    token?: string;
+    /** Remote cache server URL */
+    url: string;
+    /** Enable remote writes (default: true) */
+    write?: boolean;
+  };
+  /** Whether to skip cache reads */
+  skipNxCache?: boolean;
+  /**
+  * Enable smart lockfile hashing.
+  * Instead of hashing the entire lockfile (which busts ALL caches),
+  * only hash the resolved versions of each package's actual dependencies.
+  * This matches Turborepo's smart lockfile hashing behavior.
+  * @default false
+  */
+  smartLockfileHashing?: boolean;
+  /**
+  * Generate a detailed JSON run summary after execution.
+  * When true, writes a summary file to `.task-runner/runs/` containing
+  * all task inputs, outputs, hashes, timings, and cache status.
+  *
+  * Useful for debugging cache misses and comparing runs.
+  * Matches Turborepo's `--summarize` flag.
+  * @default false
+  */
+  summarize?: boolean;
+  /** Target-specific default configurations */
+  targetDefaults?: Record<string, Partial<TargetConfiguration>>;
+  /**
+  * Environment variables that should be passed to tasks but NOT
+  * included in the cache fingerprint. Useful for CI-specific vars.
+  * Only used when autoFingerprint is enabled.
+  */
+  untrackedEnvVars?: string[];
+}
+/**
+* Options for executing a task.
+*/
+interface TaskExecutionOptions {
+  /** Whether to capture output */
+  captureOutput?: boolean;
+  /** The working directory */
+  cwd?: string;
+  /** Environment variables */
+  env?: Record<string, string>;
+  /** Stream output as it arrives */
+  streamOutput?: boolean;
+}
+/**
+* A task executor function.
+*/
+type TaskExecutor = (task: Task, options: TaskExecutionOptions) => Promise<{
+  code: number;
+  terminalOutput: string;
+}>;
+/**
+* The function type for a task runner.
+*/
+type TasksRunner = (tasks: Task[], options: TaskRunnerOptions, context: TaskRunnerContext) => Promise<TaskResults>;
+/**
+* Context provided to the task runner.
+*/
+interface TaskRunnerContext {
+  /** Lifecycle hooks */
+  lifeCycle: LifeCycleInterface;
+  /** The project graph */
+  projectGraph: ProjectGraph;
+  /** The task executor */
+  taskExecutor: TaskExecutor;
+  /** The task graph */
+  taskGraph: TaskGraph;
+  /** The workspace root directory */
+  workspaceRoot: string;
+}
+/**
+* Input for a concurrent command -- either a string or a config object.
+*/
+type ConcurrentCommandInput = string | {
+  command: string;
+  cwd?: string;
+  env?: Record<string, string>;
+  name?: string; /** Initial PTY dimensions (only used when stdin is "pty"). */
+  ptySize?: {
+    cols: number;
+    rows: number;
+  };
+  stdin?: "inherit" | "null" | "pipe" | "pty";
+};
+/**
+* Configuration for a single command to run concurrently.
+*/
+interface ConcurrentCommandConfig {
+  /** The command string to execute (passed to shell). */
+  command: string;
+  /** Working directory for the command. */
+  cwd?: string;
+  /** Additional environment variables merged with process env. */
+  env?: Record<string, string>;
+  /** Human-readable name for this command (used in prefixes/logs). */
+  name?: string;
+  /**
+  * Initial PTY dimensions. Only used when stdin is "pty".
+  * Defaults to 80x24 if not specified.
+  */
+  ptySize?: {
+    cols: number;
+    rows: number;
+  };
+  /** Whether to use shell execution (default: true). */
+  shell?: boolean;
+  /**
+  * Stdin mode for the child process.
+  * - "null" (default): stdin closed, child cannot read input
+  * - "pipe": stdin is piped, can be written to programmatically
+  * - "inherit": child inherits parent's stdin (for interactive commands like vite dev)
+  * - "pty": child runs inside a pseudo-terminal (isatty() returns true, enables interactive prompts)
+  */
+  stdin?: "inherit" | "null" | "pipe" | "pty";
+}
+/**
+* Options controlling the concurrent runner behavior.
+*/
+interface ConcurrentRunnerOptions {
+  /** Conditions under which to kill other processes: "success", "failure". */
+  killOthers?: ("failure" | "success")[];
+  /** Signal to send when killing processes (default: "SIGTERM"). */
+  killSignal?: string;
+  /** Milliseconds to wait after kill signal before sending SIGKILL (default: 5000). */
+  killTimeout?: number;
+  /** Maximum number of processes to run simultaneously. 0 = unlimited. */
+  maxProcesses?: number;
+  /** Callback for real-time process events. */
+  onEvent?: (event: ProcessEvent) => void;
+  /** Restart options for failed commands. */
+  restart?: {
+    /** Delay between restarts in ms. "exponential" for 2^attempt * 1000ms. */
+    delay?: number | "exponential";
+    /** Maximum restart attempts per command. 0 = no restarts. -1 = infinite. */
+    tries: number;
+  };
+  /**
+  * Custom shell path for command execution.
+  * Overrides the platform default (/bin/sh on Unix, cmd.exe on Windows).
+  * Automatically detected from npm's `script-shell` config if not set.
+  */
+  shellPath?: string;
+  /** Success condition: "first", "last", "all", or "command-&lt;name|index>". */
+  successCondition?: string;
+  /** Commands to run sequentially after all processes complete. */
+  teardown?: string[];
+  /** Working directory for teardown commands. */
+  teardownCwd?: string;
+  /** Print a timing summary table after completion. Default: false. */
+  timings?: boolean;
+}
+/**
+* An event emitted during concurrent execution.
+*/
+interface ProcessEvent {
+  /** Command name (for close events). */
+  commandName?: string;
+  /** Duration in milliseconds (for close events). */
+  durationMs?: number;
+  /** Exit code (for close events). */
+  exitCode?: number;
+  /** Index of the command that produced this event. */
+  index: number;
+  /** Kill the child process/PTY. Only present on "started" events. */
+  kill?: (signal?: string) => void;
+  /** Whether the process was killed (for close events). */
+  killed?: boolean;
+  /** Event type: "stdout", "stderr", "close", "error", "started". */
+  kind: "close" | "error" | "started" | "stderr" | "stdout";
+  /** Error message (for error events). */
+  message?: string;
+  /** Resize the child's PTY. Only present on "started" events with stdin "pty". */
+  resize?: (cols: number, rows: number) => void;
+  /** Text content (for stdout/stderr events). */
+  text?: string;
+  /** Write data to the child's stdin (pipe) or PTY. Only present on "started" events. */
+  write?: (data: string) => void;
+}
+/**
+* Result of a close event for a single command.
+*/
+interface ConcurrentCloseEvent {
+  /** The command string that was executed. */
+  command: string;
+  /** Duration in milliseconds. */
+  durationMs: number;
+  /** Exit code. -1 if killed by signal. */
+  exitCode: number;
+  /** Index of the command. */
+  index: number;
+  /** Whether the process was forcefully killed. */
+  killed: boolean;
+  /** The command name (if provided). */
+  name?: string;
+}
+/**
+* Overall result of a concurrent run.
+*/
+interface ConcurrentRunResult {
+  /** Close events for all commands, in completion order. */
+  closeEvents: ConcurrentCloseEvent[];
+  /** Whether the run succeeded according to the success condition. */
+  success: boolean;
+}
+/**
+* Interface for lifecycle event handlers.
+*/
+interface LifeCycleInterface {
+  endCommand?: () => void;
+  endTasks?: (taskResults: TaskResult[]) => void;
+  /**
+  * Called when a running task emits data on stderr, in the order the
+  * data arrives. Executors that support streaming output (`vis run`'s
+  * concurrent executor) forward chunks here verbatim. Executors that
+  * only buffer full output (e.g. the simple test executor) skip this
+  * hook — rely on `printTaskTerminalOutput` for the final dump.
+  *
+  * Handlers should be non-blocking; the orchestrator doesn't await.
+  */
+  onTaskStderr?: (task: Task, chunk: string) => void;
+  /**
+  * Called when a running task emits data on stdout, in the order the
+  * data arrives. See {@link LifeCycleInterface.onTaskStderr} for
+  * semantics — same contract, different stream.
+  */
+  onTaskStdout?: (task: Task, chunk: string) => void;
+  /** Called when a cache miss occurs with diagnostic information */
+  printCacheMiss?: (task: Task, reasons: string) => void;
+  /**
+  * Called when caching was skipped because auto-fingerprint tracking
+  * came back empty — a signal that the tracker (strace or Node
+  * preload) couldn't observe the task's file access, typically
+  * because it's a static binary on a platform without strace.
+  * `reason` is a short human-readable diagnostic.
+  */
+  printEmptyFingerprintWarning?: (task: Task, reason: string) => void;
+  /**
+  * Called when caching is skipped because the task modified one or
+  * more of its own tracked inputs. `modifiedFiles` lists the
+  * workspace-relative paths that changed between pre- and
+  * post-execution hashes.
+  */
+  printSelfModifyingSkip?: (task: Task, modifiedFiles: string[]) => void;
+  printTaskTerminalOutput?: (task: Task, status: TaskStatus, terminalOutput: string) => void;
+  /**
+  * Called when a task is skipped because its `when` clause did not
+  * match the current environment. `reason` is a short
+  * human-readable diagnostic produced by {@link import("./when-condition").explainWhen}.
+  *
+  * Co-fires with `printTaskTerminalOutput` (status `"skipped"`,
+  * output `"Skipped: [reason]"`). Pick one to render — implementing
+  * both will double-report the skip.
+  */
+  printWhenSkip?: (task: Task, reason: string) => void;
+  scheduleTask?: (task: Task) => void;
+  startCommand?: () => void;
+  startTasks?: (tasks: Task[]) => void;
+}
+/**
+* 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[];
+/**
+* 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.
+*/
+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.
+*/
+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.
+*/
+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.
+*/
+declare const generatePreloadScript: (outputPath: string) => string;
+/**
+* Represents a stored fingerprint for a task execution.
+*/
+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.
+*/
+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.
+*/
+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;
+}
+/**
+* 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 `&lt;cacheDir>/ns/&lt;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/
+*   &lt;hash&gt;/
+*     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>;
+}
+/**
+* Summary of a single task execution.
+*/
+interface TaskSummary {
+  /** Whether the task was cacheable */
+  cacheable: boolean;
+  /** Cache status */
+  cacheStatus: "HIT" | "MISS" | "REMOTE_HIT" | "SKIPPED";
+  /** Dependencies on other tasks */
+  dependencies: string[];
+  /** Duration in milliseconds */
+  duration: number | undefined;
+  /** End time (ISO 8601) */
+  endTime: string | undefined;
+  /** Exit code */
+  exitCode: number | undefined;
+  /** The computed cache hash */
+  hash: string | undefined;
+  /** Detailed hash information */
+  hashDetails: TaskHashDetails | undefined;
+  /** The task's declared outputs (glob patterns, literals, or `{ auto: true }`). */
+  outputs: OutputSpec[];
+  /** Start time (ISO 8601) */
+  startTime: string | undefined;
+  /** The task target */
+  target: {
+    configuration?: string;
+    project: string;
+    target: string;
+  };
+  /** The task ID (e.g., "app:build") */
+  taskId: string;
+}
+/**
+* Complete summary of a task runner execution.
+*/
+interface RunSummary {
+  /** Total duration in milliseconds */
+  duration: number;
+  /** Run end time (ISO 8601) */
+  endTime: string;
+  /** Environment info */
+  environment: {
+    /** Architecture */
+    arch: string;
+    /** Node.js version */
+    nodeVersion: string;
+    /** Platform */
+    platform: string;
+  };
+  /** Unique run ID */
+  id: string;
+  /** Run start time (ISO 8601) */
+  startTime: string;
+  /** Overall execution statistics */
+  stats: {
+    /** Number of cached tasks (local + remote) */
+    cached: number;
+    /** Number of failed tasks */
+    failed: number;
+    /** Number of skipped tasks */
+    skipped: number;
+    /** Number of successful tasks */
+    succeeded: number;
+    /** Total number of tasks */
+    total: number;
+  };
+  /** The task graph used for this run */
+  taskGraph: {
+    dependencies: Record<string, string[]>;
+    roots: string[];
+  };
+  /** Summary of each task */
+  tasks: TaskSummary[];
+}
+/**
+* Generates a run summary from task results.
+*/
+declare const generateRunSummary: (results: TaskResults, taskGraph: TaskGraph, startTime: number) => RunSummary;
+/**
+* Writes the run summary to a JSON file in the `.task-runner/runs/` directory.
+* @param summary The run summary to write
+* @param workspaceRoot The workspace root directory
+* @returns The path to the written summary file
+*/
+declare const writeRunSummary: (summary: RunSummary, workspaceRoot: string) => Promise<string>;
+/**
+* Path where the most-recent run summary is persisted.
+* Consumers (e.g. CLIs exposing `--last-details`) read this file
+* to replay or render the previous run without re-executing.
+*/
+declare const getLastRunSummaryPath: (workspaceRoot: string) => string;
+/**
+* Persists `summary` as the most-recent run summary at
+* `.task-runner/last-summary.json`, overwriting any previous entry.
+*
+* This is the companion to {@link readLastRunSummary} and powers
+* CLI surfaces that display "last run" details without re-running tasks.
+* @returns The path to the written summary file
+*/
+declare const writeLastRunSummary: (summary: RunSummary, workspaceRoot: string) => Promise<string>;
+/**
+* Reads the most-recent run summary written by {@link writeLastRunSummary}.
+* Returns `undefined` when no previous run has been recorded or the file
+* cannot be parsed — callers should render an informational message
+* instead of treating this as an error.
+*/
+declare const readLastRunSummary: (workspaceRoot: string) => Promise<RunSummary | undefined>;
+/**
+* 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.
+*/
+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.
+*/
+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.
+*/
+declare const writeChromeTrace: (summary: RunSummary, outputPath: string) => Promise<void>;
+/**
+* Context for token interpolation.
+*
+* Currently the only first-class token group is `affected` (and its alias
+* `changed_files`). Pass `affected.files` (workspace-relative paths) and
+* the renderer will substitute it into command strings such as
+* `eslint ${affected.files}` or `prettier ${changed_files | flag '--file'}`.
+*
+* Optional `projectRoot` makes paths relative to a single project root,
+* stripping the leading prefix and the immediately following `/`. Files
+* outside the root are dropped — token interpolation only emits paths
+* the task can actually act on.
+*/
+interface TokenContext {
+  /** Affected/changed files, relative to workspace root. */
+  affectedFiles?: string[];
+  /**
+  * When set, paths are rewritten relative to this project root and
+  * files outside the root are filtered out.
+  */
+  projectRoot?: string;
+}
+/**
+* Expands token references in a single command string.
+*
+* Supported tokens:
+*   `${affected.files}`                       — space-joined, shell-quoted paths
+*   `${changed_files}`                        — alias of `affected.files`
+*   `${affected.files | flag '--file'}`       — `--file path1 --file path2 ...`
+*
+* Unknown tokens are left in place — they may be environment-variable
+* references the shell will expand at runtime, and silently dropping
+* them would mask bugs in user commands.
+*
+* Escape with a leading backslash (`\${affected.files}`) to emit the
+* literal token without expansion. Note: the regex consumes at most
+* one leading backslash, so `\\${...}` collapses to `\${...}` rather
+* than producing a literal backslash followed by the literal token.
+* Use a different surrounding quoting scheme if you need a real
+* backslash adjacent to a token.
+*/
+declare const expandTokensInString: (command: string, context: TokenContext) => string;
+/**
+* Pipeline-friendly variant of {@link expandTokensInString} that takes
+* and returns a `ConcurrentCommandConfig`. Plays the same role as
+* {@link import("./expand-arguments").expandArguments} so it can slot
+* into {@link import("./index").parseCommands} as a normal step.
+*/
+declare const expandTokens: (config: ConcurrentCommandConfig, context: TokenContext) => ConcurrentCommandConfig;
+/**
+* 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)
+*/
+declare const expandArguments: (config: ConcurrentCommandConfig, additionalArguments: string[]) => ConcurrentCommandConfig;
+/**
+* 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
+*/
+declare const expandShortcut: (config: ConcurrentCommandConfig) => ConcurrentCommandConfig;
+/**
+* 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.
+*/
+declare const expandWildcard: (config: ConcurrentCommandConfig) => ConcurrentCommandConfig | ConcurrentCommandConfig[];
+/**
+* Removes surrounding quotes from a command string.
+* Handles both single and double quotes.
+*/
+declare const stripQuotes: (config: ConcurrentCommandConfig) => ConcurrentCommandConfig;
+interface ParseCommandsOptions {
+  /** Additional arguments for placeholder expansion ({1}, {@}, {*}). */
+  additionalArguments?: string[];
+  /**
+  * Token interpolation context. When supplied, `${affected.files}`
+  * and `${changed_files | flag '--file'}` references in command
+  * strings are expanded before argument placeholder substitution.
+  */
+  tokens?: TokenContext;
+}
+/**
+* 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 token references (${affected.files}, ${changed_files | flag '...'})
+* 6. Expand argument placeholders ({1}, {@}, {*})
+*/
+declare const parseCommands: (inputs: ConcurrentCommandInput[], options?: ParseCommandsOptions) => ConcurrentCommandConfig[];
+/**
+* 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
+*/
+declare const runConcurrently: (commands: ConcurrentCommandInput[], options?: ConcurrentRunnerOptions) => Promise<ConcurrentRunResult>;
+/**
+* Run commands concurrently using pure JavaScript (child_process.spawn).
+* This is the fallback when the native Rust addon is unavailable.
+*/
+declare const runConcurrentFallback: (commands: ConcurrentCommandConfig[], options: ConcurrentRunnerOptions) => Promise<ConcurrentRunResult>;
+/**
+* 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>;
+/**
+* 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.
+*/
+declare const detectScriptShell: () => string | undefined;
+interface InputHandlerOptions {
+  /** Default command index to route unprefixed input to. Default: 0. */
+  defaultTarget?: number;
+  /** Stream to read input from. Default: process.stdin. */
+  inputStream?: Readable;
+  /** Whether to pause the input stream when all processes finish. Default: true. */
+  pauseOnFinish?: boolean;
+}
+interface CommandStdin {
+  index: number;
+  name?: string;
+  stdin: Writable;
+}
+/**
+* Creates an input handler that routes stdin to child processes.
+* @param commands Map of command index/name to their stdin streams
+* @param options Input handler configuration
+* @returns cleanup function to call when done
+*/
+declare const createInputHandler: (commands: CommandStdin[], options?: InputHandlerOptions) => (() => void);
+/**
+* Generate a timing summary table string from close events.
+* @param closeEvents Close events from the concurrent run (in completion order)
+* @returns Formatted table string
+*/
+declare const formatTimingTable: (closeEvents: ConcurrentCloseEvent[]) => string;
+/**
+* Print timing summary to a writable stream.
+* @param closeEvents Close events from the concurrent run
+* @param output Output stream (default: process.stdout)
+*/
+declare const logTimings: (closeEvents: ConcurrentCloseEvent[], output?: NodeJS.WritableStream) => void;
+interface RestartOptions {
+  /** Delay between restarts in milliseconds. "exponential" for 2^attempt * 1000ms. */
+  delay: number | "exponential";
+  /** Maximum number of restart attempts per command. 0 = no restarts. -1 = infinite. */
+  tries: number;
+}
+/**
+* Wraps a runner function to add restart-on-failure behavior.
+* @param runFn The underlying runner function (runConcurrently or runConcurrentFallback)
+* @param commands The original command configs
+* @param options Runner options
+* @param restartOptions Restart-specific options
+*/
+declare const withRestart: (runFunction: (commands: ConcurrentCommandConfig[], options: ConcurrentRunnerOptions) => Promise<ConcurrentRunResult>, commands: ConcurrentCommandConfig[], options: ConcurrentRunnerOptions, restartOptions: RestartOptions) => Promise<ConcurrentRunResult>;
+interface TeardownOptions {
+  /** Commands to run in sequence after all processes complete. */
+  commands: string[];
+  /** Working directory for teardown commands. */
+  cwd?: string;
+}
+/**
+* Run teardown commands sequentially.
+* Each command runs in the shell with inherited stdio.
+* If a command fails, subsequent commands are still attempted.
+* @returns Array of exit codes for each teardown command
+*/
+declare const runTeardown: (options: TeardownOptions) => Promise<number[]>;
+/**
+* Detected framework information.
+*/
+interface DetectedFramework {
+  /** The env var prefix(es) that should be included in task hashes */
+  envPrefixes: string[];
+  /** The framework name */
+  name: string;
+}
+/**
+* Detects frameworks used in a project by inspecting its package.json dependencies.
+* @param packageJsonPath Absolute path to the package.json file
+* @returns Array of detected frameworks with their env prefixes
+*/
+declare const detectFrameworks: (packageJsonPath: string) => Promise<DetectedFramework[]>;
+/**
+* Detects frameworks across all projects in a workspace and returns
+* the env var patterns that should be included in task hashes.
+* @param workspaceRoot The workspace root directory
+* @param projects Map of project name to project configuration with root paths
+* @returns Array of env var wildcard patterns (e.g., ["NEXT_PUBLIC_*", "VITE_*"])
+*/
+declare const inferFrameworkEnvPatterns: (workspaceRoot: string, projects: Record<string, {
+  root: string;
+}>) => Promise<string[]>;
+/**
+* For a specific project, detects frameworks and returns the matching
+* env vars from the current environment.
+* @param packageJsonPath Absolute path to the project's package.json
+* @param env The current environment variables
+* @returns Map of env var name to value for matching framework env vars
+*/
+declare const getFrameworkEnvVariables: (packageJsonPath: string, env?: Record<string, string | undefined>) => Promise<Record<string, string>>;
+/**
+* Graph visualization output formats.
+*/
+type GraphFormat = "dot" | "json" | "html" | "ascii";
+/**
+* Options for graph visualization.
+*/
+interface GraphVisualizerOptions {
+  /** Show only affected/filtered tasks (highlight subset) */
+  focusedTasks?: string[];
+  /** Group tasks by project (default: true) */
+  groupByProject?: boolean;
+  /** Show task status colors (requires results) */
+  taskStatuses?: Map<string, "success" | "failure" | "skipped" | "local-cache" | "local-cache-kept-existing" | "remote-cache" | "running" | "pending">;
+}
+/**
+* Exports a task graph in DOT format for Graphviz rendering.
+* @example
+* ```ts
+* const dot = toGraphvizDot(taskGraph);
+* // Render: dot -Tsvg -o graph.svg <<< "$dot"
+* ```
+*/
+declare const toGraphvizDot: (taskGraph: TaskGraph, options?: GraphVisualizerOptions) => string;
+/**
+* Exports the task graph as a JSON object suitable for visualization tools.
+*/
+interface GraphJson {
+  edges: {
+    source: string;
+    target: string;
+  }[];
+  nodes: {
+    configuration?: string;
+    id: string;
+    project: string;
+    status?: string;
+    target: string;
+  }[];
+  roots: string[];
+}
+declare const toGraphJson: (taskGraph: TaskGraph, taskStatuses?: Map<string, string>) => {
+  edges: GraphJson["edges"];
+  nodes: GraphJson["nodes"];
+  roots: string[];
+};
+/**
+* Generates a self-contained HTML file with an interactive task graph visualization.
+* Uses a simple force-directed layout with SVG rendering (no external dependencies).
+*/
+declare const toGraphHtml: (taskGraph: TaskGraph, options?: GraphVisualizerOptions) => string;
+/**
+* Renders the task graph as ASCII art for terminal display.
+* @example
+* ```
+* Task Graph (6 tasks, 5 dependencies)
+*
+* app:build
+* ├── lib-a:build
+* │   └── lib-core:build
+* └── lib-b:build
+*     └── lib-core:build (*)
+*
+* (*) = already shown above
+* ```
+*/
+declare const toGraphAscii: (taskGraph: TaskGraph, options?: GraphVisualizerOptions) => string;
+/**
+* Exports a project graph in DOT format.
+*/
+declare const projectGraphToDot: (projectGraph: ProjectGraph) => string;
+/**
+* Incremental file hasher that only re-hashes files that have changed
+* since the last run, based on mtime comparison.
+*
+* This is the key performance optimization used by Nx's daemon and
+* Turborepo's daemon — on subsequent runs, only files whose mtime
+* changed need to be re-read and re-hashed.
+*
+* The snapshot (path → { mtime, hash }) is kept in memory and can
+* optionally be persisted to disk for cross-process reuse.
+*/
+interface FileSnapshot {
+  /** xxh3-128 hash of file contents */
+  hash: string;
+  /** Last modification time in milliseconds */
+  mtimeMs: number;
+  /** File size in bytes (fast pre-check) */
+  size: number;
+}
+interface IncrementalHasherOptions {
+  /** Directories to skip (default: node_modules, .git, dist, coverage, .cache) */
+  ignoredDirs?: Set<string>;
+  /** File to persist the snapshot to (for cross-run reuse) */
+  snapshotPath?: string;
+  workspaceRoot: string;
+}
+declare class IncrementalFileHasher {
+  #private;
+  constructor(options: IncrementalHasherOptions);
+  /**
+  * Loads the snapshot from disk if available.
+  * Called automatically on first use.
+  */
+  load(): Promise<void>;
+  /**
+  * Persists the current snapshot to disk for cross-run reuse.
+  */
+  save(): Promise<void>;
+  /**
+  * Incrementally hashes all files in a directory.
+  *
+  * Only files whose mtime or size changed since the last snapshot
+  * are re-read and re-hashed. Unchanged files reuse the cached hash.
+  *
+  * Returns a map of relative paths → hashes.
+  */
+  hashDirectory(directoryPath: string): Promise<Record<string, string>>;
+  /**
+  * Returns how many files are in the snapshot (for diagnostics).
+  */
+  get snapshotSize(): number;
+  /**
+  * Clears the in-memory snapshot.
+  */
+  clear(): void;
+  /**
+  * Looks up the cached hash for `absolutePath` when its mtime and
+  * size match the snapshot; returns `undefined` otherwise. Callers
+  * that already have a `stat` result (e.g. `InProcessTaskHasher`)
+  * skip an extra syscall by passing it through directly.
+  *
+  * The snapshot is considered loaded on first call — lazy-load is
+  * synchronous-friendly here because the caller already performed
+  * an async `stat` before calling this method.
+  */
+  getSnapshotHash(absolutePath: string, mtimeMs: number, size: number): string | undefined;
+  /**
+  * Writes a fresh snapshot entry after the caller has computed the
+  * hash. Pairs with {@link IncrementalFileHasher.getSnapshotHash}
+  * — after a miss, the caller hashes the file and records the
+  * result here so the next run can reuse it.
+  */
+  recordSnapshot(absolutePath: string, hash: string, mtimeMs: number, size: number): void;
+}
+/**
+* Combines multiple lifecycle handlers into one.
+* Each event is forwarded to all registered handlers.
+*/
+declare class CompositeLifeCycle implements LifeCycleInterface {
+  #private;
+  constructor(lifeCycles: LifeCycleInterface[]);
+  startCommand(): void;
+  endCommand(): void;
+  scheduleTask(task: Task): void;
+  startTasks(tasks: Task[]): void;
+  endTasks(taskResults: TaskResult[]): void;
+  printTaskTerminalOutput(task: Task, status: TaskStatus, terminalOutput: string): void;
+  printCacheMiss(task: Task, reasons: string): void;
+  onTaskStdout(task: Task, chunk: string): void;
+  onTaskStderr(task: Task, chunk: string): void;
+}
+/**
+* A lifecycle handler that logs task progress to the console.
+*/
+declare class ConsoleLifeCycle implements LifeCycleInterface {
+  #private;
+  constructor(verbose?: boolean);
+  startCommand(): void;
+  endCommand(): void;
+  scheduleTask(task: Task): void;
+  startTasks(tasks: Task[]): void;
+  endTasks(taskResults: TaskResult[]): void;
+  printTaskTerminalOutput(_task: Task, _status: TaskStatus, terminalOutput: string): void;
+  printCacheMiss(task: Task, reasons: string): void;
+}
+/**
+* A no-op lifecycle handler. Useful as a default.
+*/
+declare class EmptyLifeCycle implements LifeCycleInterface {}
+/**
+* Resolved dependency entry from a lockfile.
+*/
+interface ResolvedDependency {
+  /** The package name */
+  name: string;
+  /** The resolved version */
+  version: string;
+}
+/**
+* Result of parsing a lockfile for a specific package.
+*/
+interface PackageLockfileHash {
+  /** The resolved dependencies that were included in the hash */
+  dependencies: ResolvedDependency[];
+  /** Hash of the resolved dependencies relevant to this package */
+  hash: string;
+}
+/**
+* Extracts a package name from a node_modules path.
+* E.g., "node_modules/@scope/name" -> "@scope/name",
+* "node_modules/name" -> "name",
+* "node_modules/.package-lock.json" -> undefined.
+*/
+declare const extractPackageName: (path: string) => string | undefined;
+/**
+* Parses package-lock.json (npm v2/v3 format) to extract resolved versions.
+* The v2/v3 format uses a flat "packages" map with paths like "node_modules/pkg-name".
+*/
+declare const parseNpmLockfile: (content: string) => Map<string, string>;
+/**
+* Parses pnpm-lock.yaml to extract resolved versions.
+* Uses a lightweight regex-based parser to avoid a YAML dependency.
+*/
+declare const parsePnpmLockfile: (content: string) => Map<string, string>;
+/**
+* Parses yarn.lock to extract resolved versions.
+* Works with both Yarn Classic (v1) and Berry (v2+) formats.
+*/
+declare const parseYarnLockfile: (content: string) => Map<string, string>;
+/**
+* Smart lockfile hasher that only hashes the resolved versions
+* of a package's actual dependencies, not the entire lockfile.
+*
+* This matches Turborepo's smart lockfile hashing behavior:
+* changing the lockfile only busts cache for affected packages.
+*
+* Supports:
+* - package-lock.json (npm v2/v3)
+* - pnpm-lock.yaml (pnpm)
+* - yarn.lock (Yarn Classic + Berry)
+*/
+declare class LockfileHasher {
+  #private;
+  constructor(workspaceRoot: string);
+  /**
+  * Computes a hash based only on the resolved dependency versions
+  * relevant to a specific package.
+  * @param packageJsonPath Path to the package.json (relative to workspace root)
+  * @returns Hash of the relevant lockfile entries, or undefined if no lockfile found
+  */
+  hashForPackage(packageJsonPath: string): Promise<PackageLockfileHash | undefined>;
+  /**
+  * Returns the type of lockfile detected, or undefined if none found.
+  */
+  get lockfileType(): "npm" | "pnpm" | "yarn" | undefined;
+  /**
+  * Clears the cached lockfile data.
+  */
+  clearCache(): void;
+}
+/**
+* Output formatting mode for task terminal output.
+*
+* - `interleaved` **(default)**: emit each task's buffered output as-is
+*   — lines from parallel tasks may intermix when streamed live.
+* - `labeled`: prefix every line with `[project#target]` so parallel
+*   tasks remain distinguishable.
+* - `grouped`: buffer each task's output and print it as a single block
+*   bracketed by `── project#target ──` header and blank-line footer.
+*
+* Matches the three modes exposed by vite-task's `--log` flag.
+*/
+type LogMode = "grouped" | "interleaved" | "labeled";
+/**
+* A lifecycle handler that renders task terminal output per {@link LogMode}.
+*
+* Operates on the buffered `printTaskTerminalOutput` signal the orchestrator
+* emits at task-completion. Line-by-line streaming is the consumer's
+* responsibility — a streaming reporter can wrap this one and emit buffered
+* output at the end of each task regardless of streaming choices.
+*/
+declare class LogReporter implements LifeCycleInterface {
+  #private;
+  constructor(mode: LogMode, write?: (chunk: string) => void);
+  printTaskTerminalOutput(task: Task, _status: TaskStatus, terminalOutput: string): void;
+  endTasks(_taskResults: TaskResult[]): void;
+}
+/**
+* Convenience factory matching vite-task's `createLogReporter(mode)` surface.
+* Consumers that already compose their own lifecycle handlers can instantiate
+* {@link LogReporter} directly.
+*/
+declare const createLogReporter: (mode: LogMode, write?: (chunk: string) => void) => LogReporter;
+interface NativeFileHash {
+  hash: string;
+  path: string;
+}
+interface NativeTaskHashDetails {
+  command: string;
+  implicit_deps?: string[][];
+  nodes: string[][];
+  runtime?: string[][];
+}
+interface NativeTaskGraph {
+  edges: string[][];
+  task_ids: string[];
+}
+interface NativeCycleResult {
+  cycle: string[];
+  has_cycle: boolean;
+}
+interface NativeConcurrentCommandConfig {
+  command: string;
+  cwd?: string;
+  env?: Record<string, string>;
+  name?: string;
+  shell?: boolean;
+  stdin?: string;
+}
+interface NativeConcurrentRunnerOptions {
+  killOthers?: string[];
+  killSignal?: string;
+  killTimeout?: number;
+  maxProcesses?: number;
+  shellPath?: string;
+  successCondition?: string;
+}
+interface NativeProcessEvent {
+  commandName?: string;
+  durationMs?: number;
+  exitCode?: number;
+  index: number;
+  killed?: boolean;
+  kind: string;
+  message?: string;
+  text?: string;
+}
+interface NativeConcurrentCloseEvent {
+  command: string;
+  durationMs: number;
+  exitCode: number;
+  index: number;
+  killed: boolean;
+  name?: string;
+}
+interface NativeConcurrentRunResult {
+  closeEvents: NativeConcurrentCloseEvent[];
+  success: boolean;
+}
+interface NativeBindings {
+  collectFiles: (directory: string) => string[];
+  computeTaskHash: (details: NativeTaskHashDetails) => string;
+  findAllCycles: (graph: NativeTaskGraph) => string[][];
+  findBackEdges: (graph: NativeTaskGraph) => string[][];
+  findCycle: (graph: NativeTaskGraph) => NativeCycleResult;
+  getDependentTasks: (graph: NativeTaskGraph, taskId: string) => string[];
+  getMainWorktreeRoot: (workspaceRoot: string) => string | undefined | null;
+  getTransitiveDeps: (graph: NativeTaskGraph, taskId: string) => string[];
+  hashCommand: (project: string, target: string, configuration: string | undefined, overridesJson: string) => string;
+  hashEnvVar: (name: string, value: string) => string;
+  hashFile: (filePath: string) => string;
+  hashFilesBatch: (filePaths: string[], workspaceRoot: string) => NativeFileHash[];
+  hashFilesInDirectory: (directory: string, workspaceRoot: string) => NativeFileHash[];
+  hashString: (input: string) => string;
+  hashStrings: (inputs: string[]) => string;
+  isLinkedWorktree: (workspaceRoot: string) => boolean;
+  resetWorktreeCache: () => void;
+  runConcurrent: (commands: NativeConcurrentCommandConfig[], options: NativeConcurrentRunnerOptions, onEvent: (event: NativeProcessEvent) => void) => Promise<NativeConcurrentRunResult>;
+  runConcurrentBatch: (commands: NativeConcurrentCommandConfig[], options: NativeConcurrentRunnerOptions) => Promise<NativeConcurrentRunResult>;
+  topologicalSort: (graph: NativeTaskGraph) => string[];
+}
+/**
+* Attempts to load the native addon. Returns undefined if unavailable.
+* The result is cached after the first attempt.
+*
+* napi v3 outputs the .node file to the package root as
+* `task-runner-native.&lt;platform>.node`. The napi-generated index.js
+* handles platform detection automatically.
+*
+* Uses createRequire because the napi-generated index.js is CJS.
+*/
+declare const loadNativeBindings: () => NativeBindings | undefined;
+/**
+* Returns true if the native addon is loaded and available.
+*/
+declare const isNativeAvailable: () => boolean;
+/**
+* Expands a task's `OutputSpec[]` into the concrete file list to
+* archive:
+*
+* - literal paths → kept as-is (the archiver recursively copies
+*   directories, so `"dist"` captures its whole tree);
+* - positive globs → expanded via `fs.glob`, filtered to files only;
+* - negatives (`!pattern`) → applied to the combined result;
+* - `{ auto: true }` → pulls in `autoWrites` entries that fall inside
+*   the workspace.
+*
+* Returns deduped, sorted workspace-relative paths so archives are
+* byte-reproducible across invocations.
+*
+* Silent degradation: missing literal paths, empty glob matches, and
+* `{ auto: true }` without tracked writes all contribute nothing
+* rather than throwing.
+*/
+declare const resolveOutputs: (workspaceRoot: string, outputs: OutputSpec[] | undefined, autoWrites?: ReadonlyArray<string>) => Promise<string[]>;
+/**
+* Enforces project dependency constraints on a project graph.
+* @param projectGraph The workspace project graph to validate.
+* @param constraints The constraint rules to enforce.
+* @returns Array of violations found. Empty means all constraints pass.
+*/
+declare const enforceProjectConstraints: (projectGraph: ProjectGraph, constraints: ConstraintsConfig) => ConstraintViolation[];
+/**
+* Compression algorithm used for artifact tarballs on the wire.
+* - `"gzip"` (default): tar+gzip, matches Turborepo's protocol format
+*   and stays interop-safe with existing remote cache servers.
+* - `"brotli"`: tar + Node brotli (BROTLI_MODE_TEXT, quality 4) — a
+*   solid ratio/speed trade-off for source-tree tarballs. Both upload
+*   and download sides must agree; switching invalidates existing
+*   remote entries (they will simply re-populate on next run).
+*/
+type RemoteCacheCompression = "brotli" | "gzip";
+/**
+* HMAC signing configuration for cache integrity.
+*
+* When set, every upload carries an `X-Artifact-Signature` header
+* containing the HMAC-SHA256 digest of `hash | body`. On download,
+* the client recomputes the HMAC and rejects any artifact whose
+* signature doesn't match using a constant-time comparison.
+*
+* Prevents cache poisoning in shared team environments where a
+* compromised cache server (or a MITM) could inject malicious
+* artifacts. Unsigned entries (written before signing was enabled)
+* are accepted only when `verifyOnDownload === false` — the default.
+*/
+interface RemoteCacheSigning {
+  /** Shared secret. Must be at least 16 characters. */
+  secret: string;
+  /**
+  * Reject downloads whose signature doesn't match or is missing.
+  * Set to `true` once every upload on your server is signed.
+  * @default false
+  */
+  verifyOnDownload?: boolean;
+}
+/**
+* Options for the remote cache.
+*/
+interface RemoteCacheOptions {
+  /**
+  * Compression format for artifact tarballs. Defaults to `"gzip"`
+  * for Turborepo protocol compatibility.
+  */
+  compression?: RemoteCacheCompression;
+  /**
+  * Called when a fire-and-forget upload fails.
+  * Since uploads are non-blocking, errors are silently swallowed by default.
+  * Provide this callback to log or report upload failures.
+  */
+  onUploadError?: (hash: string, error: unknown) => void;
+  /** Whether to enable remote cache reads */
+  read?: boolean;
+  /**
+  * HMAC-SHA256 signing for upload integrity. When set, every
+  * uploaded artifact carries an `X-Artifact-Signature` header;
+  * downloads with `verifyOnDownload: true` reject unsigned or
+  * tampered payloads.
+  */
+  signing?: RemoteCacheSigning;
+  /** Team ID or namespace for cache isolation */
+  teamId?: string;
+  /** Request timeout in milliseconds (default: 30000) */
+  timeout?: number;
+  /** Authentication token for the remote cache */
+  token?: string;
+  /** Remote cache server URL (e.g., "https://cache.example.com") */
+  url: string;
+  /** Whether to enable remote cache writes */
+  write?: boolean;
+}
+/**
+* HTTP-based remote cache compatible with the Turborepo remote cache protocol.
+*
+* Protocol:
+* - GET  /v8/artifacts/{hash}?teamId={team}  -> retrieve cached artifact (gzipped tar)
+* - PUT  /v8/artifacts/{hash}?teamId={team}  -> store artifact
+* - POST /v8/artifacts/events                -> analytics (optional)
+*
+* Authentication via `Authorization: Bearer {token}` header.
+*
+* The cache entry is a gzipped tarball containing the cache directory contents
+* (code, terminalOutput, fingerprint.json, outputs/, .commit).
+*/
+declare class RemoteCache {
+  #private;
+  constructor(options: RemoteCacheOptions);
+  /**
+  * Retrieves a cached artifact from the remote cache.
+  * Returns the local path to the extracted cache entry, or undefined if not found.
+  */
+  retrieve(hash: string, localCacheDirectory: string): Promise<boolean>;
+  /**
+  * Stores a cache entry in the remote cache.
+  */
+  store(hash: string, localCacheDirectory: string): Promise<boolean>;
+  /**
+  * Checks if an artifact exists in the remote cache without downloading it.
+  */
+  exists(hash: string): Promise<boolean>;
+}
+interface CreateTaskGraphOptions {
+  /** The project graph */
+  projectGraph: ProjectGraph;
+  /** Target default configurations */
+  targetDefaults?: Record<string, Partial<TargetConfiguration>>;
+  /** The workspace configuration */
+  workspace: WorkspaceConfiguration;
+}
+/**
+* Creates a unique task ID from a target.
+*/
+declare const getTaskId: (target: TaskTarget) => string;
+/**
+* Parses a task ID into its component parts.
+*/
+declare const parseTaskId: (taskId: string) => TaskTarget;
+/**
+* Creates a task graph from a list of tasks, resolving all dependencies.
+*/
+declare const createTaskGraph: (initialTasks: Task[], options: CreateTaskGraphOptions) => TaskGraph;
+/**
+* Finds a single cycle in the task graph, if one exists.
+* Returns the cycle as an array of task IDs, or null if no cycle exists.
+*/
+declare const findCycle: (taskGraph: TaskGraph) => string[] | undefined;
+/**
+* Finds all cycles in the task graph.
+*/
+declare const findCycles: (taskGraph: TaskGraph) => string[][];
+/**
+* Walks the task graph in topological order (dependencies before dependents),
+* calling the callback for each task.
+*
+* Note: If the graph contains cycles, tasks involved in cycles will not be visited.
+* Use `findCycle` to detect cycles before walking if complete traversal is required.
+*/
+declare const walkTaskGraph: (taskGraph: TaskGraph, callback: (taskId: string) => void) => void;
+/**
+* Returns a reversed copy of the task graph (edges point in the opposite direction).
+*/
+declare const reverseTaskGraph: (taskGraph: TaskGraph) => TaskGraph;
+/**
+* Returns the leaf tasks (tasks with no dependencies of their own).
+*/
+declare const getLeafTasks: (taskGraph: TaskGraph) => string[];
+/**
+* Removes edges that form cycles, making the graph acyclic.
+* Returns a new task graph without the cycle-forming edges.
+*/
+declare const makeAcyclic: (taskGraph: TaskGraph) => TaskGraph;
+/**
+* Gets all tasks that depend on the given task (directly or transitively).
+*/
+declare const getDependentTasks: (taskGraph: TaskGraph, taskId: string) => string[];
+/**
+* Gets all tasks that the given task depends on (directly or transitively).
+*/
+declare const getTransitiveDependencies: (taskGraph: TaskGraph, taskId: string) => string[];
+/**
+* Interface for task hashers.
+*/
+interface TaskHasher {
+  hashTask: (task: Task) => Promise<TaskHashDetails>;
+  /**
+  * Rehashes a single file bypassing any in-memory cache. Optional to keep
+  * external/custom hashers backward compatible; the orchestrator skips
+  * self-modifying-task detection when the implementation is absent.
+  */
+  rehashFile?: (filePath: string) => Promise<string | undefined>;
+}
+/**
+* Options for creating an InProcessTaskHasher.
+*/
+interface TaskHasherOptions {
+  /**
+  * When true, scan each task's resolved command for `$VAR`/`${VAR}`
+  * references and auto-fingerprint them. Catches the common case of
+  * a script reading `$VERCEL_URL` or `${NEXT_PUBLIC_API}` without
+  * the user remembering to declare it in `envVars`/`globalEnv`.
+  * @default false
+  */
+  autoEnvVars?: boolean;
+  /** Additional environment variables to include in hash */
+  envVars?: string[];
+  /**
+  * Enable framework environment variable inference.
+  * When true, auto-detects frameworks and includes their public
+  * env var prefixes in the task hash.
+  * @default false
+  */
+  frameworkInference?: boolean;
+  /**
+  * Global environment variables that invalidate all task hashes.
+  */
+  globalEnv?: string[];
+  /**
+  * Global input files that invalidate all task hashes when changed.
+  * These are workspace-root-relative paths (e.g., "pnpm-lock.yaml").
+  */
+  globalInputs?: string[];
+  /**
+  * Optional persistent mtime/size-indexed file snapshot. When set,
+  * `#hashFile` consults the snapshot first and only re-reads file
+  * contents when the file's mtime or size has changed since the
+  * previous run. Cuts cold-cache fingerprint time dramatically on
+  * large workspaces where most source files don't change run-to-run.
+  *
+  * The caller is responsible for `load()`ing the snapshot before
+  * using the hasher and `save()`ing it after the run completes.
+  */
+  incrementalHasher?: IncrementalFileHasher;
+  /** Named input definitions */
+  namedInputs?: NamedInputs;
+  /** Project configurations keyed by project name */
+  projects: Record<string, ProjectConfiguration>;
+  /**
+  * Enable smart lockfile hashing.
+  * When true, instead of hashing the entire lockfile, only the resolved
+  * versions of a package's actual dependencies are hashed.
+  * This means changing the lockfile only busts cache for affected packages.
+  *
+  * Matches Turborepo's smart lockfile hashing behavior.
+  * @default false
+  */
+  smartLockfileHashing?: boolean;
+  /** Target default configurations */
+  targetDefaults?: Record<string, Partial<TargetConfiguration>>;
+  /** The workspace root directory */
+  workspaceRoot: string;
+}
+/**
+* Computes hashes for tasks based on their inputs.
+* Used to determine if a cached result can be reused.
+*/
+declare class InProcessTaskHasher implements TaskHasher {
+  #private;
+  constructor(options: TaskHasherOptions);
+  hashTask(task: Task): Promise<TaskHashDetails>;
+  clearCache(): void;
+  /**
+  * Reads `filePath` fresh and returns its content hash, bypassing the
+  * in-memory cache used during the initial `hashTask` pass.
+  *
+  * Used to detect tasks that modify their own tracked inputs: compare
+  * a pre-execution hash (from `task.hashDetails.nodes`) against the
+  * post-execution result of this method.
+  * @param filePath Absolute path to the file.
+  * @returns The fresh xxh3 hash, or `undefined` if the file cannot be read.
+  */
+  rehashFile(filePath: string): Promise<string | undefined>;
+}
+/**
+* Computes the final hash for a task from its hash details.
+* Uses native Rust xxh3-128 when available, otherwise pure TS xxh3-ts.
+* Both produce identical xxh3-128 hashes, ensuring cache compatibility
+* regardless of whether the native addon is loaded.
+*/
+declare const computeTaskHash: (hashDetails: TaskHashDetails) => string;
+/**
+* Options for partitioning tasks across CI runners.
+*/
+interface PartitionOptions {
+  /** 1-based partition index (e.g., 1 for the first partition) */
+  index: number;
+  /** Total number of partitions */
+  total: number;
+}
+/**
+* Parses a partition string like "1/4" into PartitionOptions.
+* Also supports the VIS_PARTITION environment variable as fallback.
+*/
+declare const parsePartition: (value?: string) => PartitionOptions | undefined;
+/**
+* Manages the scheduling order of tasks based on dependencies,
+* parallelism constraints, and estimated execution times.
+*/
+declare class TaskScheduler {
+  #private;
+  /**
+  * Partitions a list of tasks for distributed CI execution.
+  * Tasks are sorted by ID for deterministic distribution, then split
+  * using ceiling division so partitions differ by at most one task.
+  * @param tasks The full list of tasks to partition
+  * @param partition The partition configuration (1-based index and total)
+  * @returns The subset of tasks assigned to this partition
+  */
+  static partitionTasks(tasks: Task[], partition: PartitionOptions): Task[];
+  constructor(taskGraph: TaskGraph, projectGraph: ProjectGraph, maxParallel?: number);
+  /**
+  * Returns the next batch of tasks that are ready to execute.
+  */
+  getNextBatch(): Task[];
+  startTask(taskId: string): void;
+  completeTask(taskId: string): void;
+  isComplete(): boolean;
+  get remainingCount(): number;
+  get runningCount(): number;
+}
+/**
+* Options for the TaskOrchestrator.
+*/
+interface TaskOrchestratorOptions {
+  /**
+  * Tasks marked `always: true` to run after the main task graph
+  * completes. Run sequentially, in declaration order, even if the
+  * main run failed or was aborted (SIGINT skips them — that's an
+  * explicit user request to stop). Skipped if their `when` clause
+  * doesn't match.
+  */
+  alwaysTasks?: Task[];
+  autoFingerprint?: boolean;
+  cache: Cache;
+  cacheDiagnostics?: boolean;
+  captureOutput?: boolean;
+  dryRun?: boolean;
+  fingerprintEnvPatterns?: string[];
+  lifeCycle: LifeCycleInterface;
+  remoteCache?: RemoteCache;
+  resolveCommand?: (task: Task) => string | undefined;
+  scheduler: TaskScheduler;
+  skipCache?: boolean;
+  summarize?: boolean;
+  taskExecutor: TaskExecutor;
+  taskGraph?: TaskGraph;
+  taskHasher: TaskHasher;
+  untrackedEnvVars?: string[];
+  /**
+  * Context used to evaluate per-task `when` conditions. Defaults
+  * to the live process state — `process.env`, `process.platform`,
+  * git branch read from `workspaceRoot`. Override in tests.
+  */
+  whenContext?: WhenContext;
+  workspaceRoot: string;
+}
+/**
+* Orchestrates the execution of tasks, handling caching,
+* scheduling, and lifecycle events.
+*/
+declare class TaskOrchestrator {
+  #private;
+  constructor(options: TaskOrchestratorOptions);
+  run(): Promise<TaskResults>;
+}
+/**
+* Minimal virtual terminal buffer that processes ANSI escape sequences
+* for cursor movement and line erasure. This allows PTY output from
+* interactive tools (inquirer, etc.) to render correctly by updating
+* lines in place rather than always appending.
+*
+* Supported sequences:
+* - \r       carriage return (cursor to column 0)
+* - \n       line feed (new line)
+* - \x1b[nA  cursor up n lines
+* - \x1b[nB  cursor down n lines
+* - \x1b[nC  cursor forward n columns
+* - \x1b[nD  cursor back n columns
+* - \x1b[nG  cursor to column n
+* - \x1b[r;cH cursor position
+* - \x1b[K   erase from cursor to end of line (0K, 1K, 2K)
+* - \x1b[J   erase from cursor to end of display (0J, 1J, 2J)
+* - \x1b[...m SGR (colors/styles) — passed through into output
+*/
+declare class TerminalBuffer {
+  #private;
+  constructor(maxBytes?: number);
+  /**
+  * Process raw PTY output data.
+  */
+  write(data: string): void;
+  /** Get the current buffer content as a string. */
+  toString(): string;
+}
+/**
+* Result of a tracked task execution.
+*/
+interface TrackedExecutionResult {
+  /** File accesses recorded during execution */
+  accesses: FileAccess[];
+  /** The command exit code */
+  code: number;
+  /** The command stdout + stderr output */
+  terminalOutput: string;
+}
+/**
+* A task executor that tracks file accesses during command execution.
+*
+* Tracking strategies (in priority order):
+* 1. **Linux**: strace-based syscall interception (most complete)
+* 2. **macOS/Windows**: Node.js preload script that patches `fs` module
+* (works for Node.js processes, not native binaries)
+* 3. **Fallback**: No tracking (accesses array will be empty)
+*/
+declare class TrackedTaskExecutor {
+  #private;
+  constructor(workspaceRoot: string);
+  /**
+  * Returns true if file access tracking is supported on the current platform.
+  * strace tracking (Linux) or preload script (any Node.js process).
+  */
+  get isTrackingSupported(): boolean;
+  /**
+  * Returns true if the platform supports full syscall-level tracking (strace).
+  */
+  get isStraceSupported(): boolean;
+  /**
+  * Executes a task command and tracks all file system accesses.
+  *
+  * On Linux, uses strace for comprehensive tracking.
+  * On other platforms, uses a Node.js preload script (for Node processes).
+  */
+  execute(task: Task, options: TaskExecutionOptions, command: string): Promise<TrackedExecutionResult>;
+  /**
+  * Kills all active child processes. Called on abort/signal to prevent orphans.
+  */
+  killAll(): void;
+}
+/**
+* Hashes a file's content using xxh3-128.
+* Returns undefined if the file cannot be read.
+*/
+declare const hashFile: (filePath: string) => Promise<string | undefined>;
+/**
+* Hashes one or more string values using xxh3-128.
+*/
+declare const hashStrings: (...values: string[]) => string;
+/**
+* Sorts an object's keys for deterministic serialization.
+*/
+declare const sortObjectKeys: (object: Record<string, unknown>) => Record<string, unknown>;
+/**
+* Recursively collects all file paths in a directory,
+* skipping directories in the ignored set.
+*
+* Tracks visited real paths to prevent infinite loops from symlink cycles.
+*/
+declare const collectFiles: (directory: string, ignoredDirectories: Set<string>, visitedRealPaths?: Set<string>) => Promise<string[]>;
+/**
+* Resolves the working directory for a task.
+*/
+declare const resolveTaskCwd: (workspaceRoot: string, task: Task) => string;
+/**
+* Creates a failure TaskResult from an error.
+*/
+declare const createFailureResult: (task: Task, error: unknown, startTime: number) => TaskResult;
+declare const readPackageDeps: (packageJsonPath: string, options?: {
+  optional?: boolean;
+  peer?: boolean;
+}) => Promise<Set<string> | undefined>;
+/**
+* Generates a unique ID for temporary files/directories.
+* Not cryptographically secure — for cache entry naming only.
+*/
+declare const uniqueId: () => string;
+export { type AffectedOptions, type AffectedResult, type AffectedScope, Cache, type CacheMissReason, type CacheOptions, type CachedResult, type ChromeTraceEvent, CompositeLifeCycle, type ConcurrentCloseEvent, type ConcurrentCommandConfig, type ConcurrentCommandInput, type ConcurrentRunResult, type ConcurrentRunnerOptions, ConsoleLifeCycle, type ConstraintViolation, type ConstraintsConfig, DEFAULT_CACHE_DIRECTORY_NAME, type DependencyKindRules, type DependencyType, type DetectedFramework, EmptyLifeCycle, type EnvMatcher, type EnvironmentInput, type ExternalDependencyInput, type FileAccess, FileAccessTracker, type FileSetBase, type FileSetInput, type FileSetPattern, type FileSnapshot, FingerprintManager, type GraphFormat, type GraphJson, type GraphVisualizerOptions, InProcessTaskHasher, IncrementalFileHasher, type IncrementalHasherOptions, type InputDefinition, type InputHandlerOptions, type LifeCycleInterface, LockfileHasher, type LogMode, LogReporter, type NamedInputs, type NodePlatform, type OutputSpec, type PackageLockfileHash, type ParseCommandsOptions, type PartitionOptions, type ProcessEvent, type ProjectConfiguration, type ProjectGraph, type ProjectGraphDependency, type ProjectGraphProjectNode, RemoteCache, type RemoteCacheCompression, type RemoteCacheOptions, type RemoteCacheSigning, type ResolvedDependency, type RestartOptions, type RunSummary, type RuntimeInput, type TagRelationships, type TargetConfiguration, type TargetDependencyConfig, type Task, type TaskExecutionOptions, type TaskExecutor, type TaskFingerprint, type TaskGraph, type TaskHashDetails, type TaskHasher, type TaskHasherOptions, TaskOrchestrator, type TaskOrchestratorOptions, type TaskPriority, type TaskResult, type TaskResults, type TaskRunnerContext, type TaskRunnerOptions, TaskScheduler, type TaskStatus, type TaskSummary, type TaskTarget, type TasksRunner, type TeardownOptions, TerminalBuffer, type TokenContext, type TrackedExecutionResult, TrackedTaskExecutor, type TrackingResult, type TypeBoundaries, type WhenCondition, type WhenContext, type WorkspaceConfiguration, buildForwardDependencyMap, buildReverseDependencyMap, collectFiles, computeTaskHash, createFailureResult, createInputHandler, createLogReporter, createTaskGraph, defaultTaskRunner, detectFrameworks, detectScriptShell, enforceProjectConstraints, evaluateWhen, expandAffected, expandArguments, expandShortcut, expandTokens, expandTokensInString, expandWildcard, explainWhen, extractPackageName, filterAffectedTasks, findCycle, findCycles, formatCacheSize, formatTimingTable, generatePreloadScript, generateRunSummary, getAffectedProjects, getChangedFiles, getCurrentBranch, getDependentTasks, getFrameworkEnvVariables, getLastRunSummaryPath, getLeafTasks, getTaskId, getTransitiveDependencies, hashFile, hashStrings, inferFrameworkEnvPatterns, isNativeAvailable, loadNativeBindings, logTimings, makeAcyclic, parseCacheSize, parseCommands, parseNpmLockfile, parsePartition, parsePnpmLockfile, parseTaskId, parseYarnLockfile, projectGraphToDot, readLastRunSummary, readPackageDeps, resetBranchCache, resolveOutputs, resolveTaskCwd, reverseTaskGraph, runConcurrentFallback, runConcurrently, runTeardown, sortObjectKeys, stripQuotes, toChromeTrace, toGraphAscii, toGraphHtml, toGraphJson, toGraphvizDot, uniqueId, walkTaskGraph, withRestart, writeChromeTrace, writeLastRunSummary, writeRunSummary };