@pnpm/workspace.task-scheduler 1100.0.0

package/CHANGELOG.md

@@ -0,0 +1,27 @@
+# @pnpm/workspace.task-scheduler
+
+## 1100.0.0
+
+### Major Changes
+
+- Workspace install, rebuild, pack, publish, stage, and lifecycle work now starts as soon as its dependencies finish instead of waiting for an unrelated topological group.
+
+### Minor Changes
+
+- Persist completed recursive tasks so `--resume-from` skips exactly the work that passed during a matching interrupted or failed `pnpm -r run` / `pnpm -r exec` invocation. When no compatible state exists, pnpm retains its graph-based resume behavior.
+
+- Added per-task concurrency limits to workspace task orchestration. Set `tasks.<name>.concurrency` in `pnpm-workspace.yaml` to limit how many instances of that task may run across workspace projects at once:
+
+  ```yaml
+  tasks:
+    build:
+      concurrency: 2
+  ```
+
+### Patch Changes
+
+- Published the workspace task graph and scheduler as `@pnpm/workspace.task-scheduler` so other workspace commands can use the same dependency-aware scheduling as recursive run and exec.
+
+- Updated dependencies:
+  - @pnpm/deps.graph-sequencer@1101.0.0
+  - @pnpm/types@1102.1.0

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2016 Rico Sta. Cruz and other contributors
+Copyright (c) 2016-2026 Zoltan Kochan and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# @pnpm/workspace.task-scheduler
+
+> Builds and schedules workspace task graphs

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './taskGraph.js';
+export * from './taskScheduler.js';

package/lib/index.js

@@ -0,0 +1,3 @@
+export * from './taskGraph.js';
+export * from './taskScheduler.js';
+//# sourceMappingURL=index.js.map

package/lib/taskGraph.d.ts

@@ -0,0 +1,115 @@
+import type { PackageScripts, ProjectRootDir, ProjectsGraph, WorkspaceTasks } from '@pnpm/types';
+/**
+ * A task is a `(project, task name)` pair; its key is the stable identifier
+ * used by the scheduler, summaries, and dry-run output.
+ */
+export type TaskKey = string;
+export interface TaskNode {
+    project: ProjectRootDir;
+    taskName: string;
+    concurrency?: number;
+    /**
+     * The scripts of the project that the task name selected — several when the
+     * task name is a RegExp selector. Empty when the project has no such
+     * script: the task is then a pass-through that runs nothing, completes as
+     * soon as its dependencies have, and is reported as skipped, so that a
+     * scriptless project does not sever a dependency chain.
+     */
+    scripts: string[];
+    /** Whether the invocation named this task, as opposed to `dependsOn` pulling it in. */
+    requested: boolean;
+    dependencies: TaskKey[];
+}
+export type TaskGraph = Map<TaskKey, TaskNode>;
+export interface BuildTaskGraphOptions {
+    /**
+     * The dependency edges among the selected projects, already resolved
+     * through the full workspace graph (`filteredProjectsDependencies`). Tasks
+     * are created only for these projects: `dependsOn` never runs anything in a
+     * project the filter did not select.
+     */
+    projectDependencies: Map<ProjectRootDir, ProjectRootDir[]>;
+    scriptsByProject: (project: ProjectRootDir) => PackageScripts;
+    selectScripts: (scripts: PackageScripts, taskName: string) => string[];
+    /** The script the invocation runs; every selected project gets a task named this. */
+    taskName: string;
+    tasks?: WorkspaceTasks;
+}
+/**
+ * Builds the graph of tasks the invocation runs: a task named `taskName` in
+ * every selected project, plus every task those transitively pull in through
+ * `dependsOn`. A task with no `tasks` entry behaves as
+ * `dependsOn: ['^<its own name>']`: plain topological order over the
+ * project graph.
+ */
+export declare function buildTaskGraph(opts: BuildTaskGraphOptions): TaskGraph;
+export declare function taskKey(project: ProjectRootDir, taskName: string): TaskKey;
+export interface SequenceTasksOptions {
+    workspaceDir: string;
+    /**
+     * The `ignoreWorkspaceCycles` setting: the workspace has declared its
+     * cycles deliberate, so a cyclic task graph is downgraded from an error
+     * to a warning, backward edges are dropped, and the members run in the
+     * graph sequencer's deterministic order.
+     */
+    ignoreCycles?: boolean;
+}
+/**
+ * Topologically orders the task graph, throwing when the tasks form a cycle
+ * unless `ignoreCycles` tolerates it and mutates the graph's edges acyclic.
+ * Detection is scoped to this graph: a cycle among tasks the filter did not
+ * select cannot fail the run.
+ */
+export declare function sequenceTasks(graph: TaskGraph, opts: SequenceTasksOptions): TaskKey[];
+export declare function formatTask(node: TaskNode, workspaceDir: string): string;
+/** The same graph with every edge turned around: dependents run before dependencies. */
+export declare function reverseTaskGraph(graph: TaskGraph): TaskGraph;
+export interface ResumeTaskGraphOptions {
+    resumeFrom: string;
+    selectedProjectsGraph: ProjectsGraph;
+    /** The task of the anchor project the invocation resolves to. */
+    taskName: string;
+    /** Tasks durably completed by the matching previous invocation. */
+    completedTasks?: ReadonlySet<TaskKey>;
+}
+/**
+ * When durable state is available, the graph without exactly those completed
+ * tasks. Otherwise, the graph without the anchor's transitive dependencies —
+ * the tasks inferred to have finished before a run would reach the anchor.
+ * The anchor itself and unfinished work stay, and edges into the dropped set
+ * are treated as satisfied.
+ */
+export declare function resumeTaskGraphFrom(graph: TaskGraph, opts: ResumeTaskGraphOptions): TaskGraph;
+/**
+ * Whether at most one script can ever be in flight, which is when output may
+ * stay inherited rather than piped: no task runs several scripts at once, and
+ * every script-running task lies on one dependency chain, so the graph forces
+ * them to run one after another.
+ *
+ * `sequencedTasks` is {@link sequenceTasks}'s result — the proof the graph is
+ * acyclic, and the evaluation order for the longest-chain scan.
+ */
+export declare function isSerialTaskGraph(graph: TaskGraph, sequencedTasks: TaskKey[]): boolean;
+export interface DryRunTaskDependency {
+    project: string;
+    script: string;
+}
+export interface DryRunTask extends DryRunTaskDependency {
+    missingScript: boolean;
+    dependsOn: DryRunTaskDependency[];
+}
+/**
+ * What `--dry-run --json` emits: nodes and edges rather than an order, since
+ * independent tasks have no required sequence. Identifiers are the
+ * workspace-relative project directory and the script name.
+ */
+export declare function taskGraphToJson(graph: TaskGraph, workspaceDir: string): {
+    tasks: DryRunTask[];
+};
+/**
+ * What plain `--dry-run` prints: one valid linearization of the graph — not
+ * the order the scheduler will follow. Ties among simultaneously runnable
+ * tasks are broken by project directory, so two dry runs of one workspace
+ * print the same thing and their diff is meaningful.
+ */
+export declare function renderTaskGraphDryRun(graph: TaskGraph, sequencedTasks: TaskKey[], workspaceDir: string): string;

package/lib/taskGraph.js

@@ -0,0 +1,245 @@
+import path from 'node:path';
+import { graphSequencer } from '@pnpm/deps.graph-sequencer';
+import { PnpmError } from '@pnpm/error';
+import { globalWarn } from '@pnpm/logger';
+import { lexCompare } from '@pnpm/text.ordinal-comparator';
+/**
+ * Builds the graph of tasks the invocation runs: a task named `taskName` in
+ * every selected project, plus every task those transitively pull in through
+ * `dependsOn`. A task with no `tasks` entry behaves as
+ * `dependsOn: ['^<its own name>']`: plain topological order over the
+ * project graph.
+ */
+export function buildTaskGraph(opts) {
+    const graph = new Map();
+    const queue = [];
+    for (const project of opts.projectDependencies.keys()) {
+        queue.push({ project, taskName: opts.taskName, requested: true });
+    }
+    // Drained by index: shift() moves every remaining element, which is
+    // quadratic over a workspace-sized queue.
+    let head = 0;
+    while (head < queue.length) {
+        const { project, taskName, requested } = queue[head++];
+        const key = taskKey(project, taskName);
+        const existing = graph.get(key);
+        if (existing != null) {
+            existing.requested ||= requested;
+            continue;
+        }
+        const dependencies = new Set();
+        for (const entry of taskDependsOn(opts.tasks, taskName)) {
+            if (entry.startsWith('^')) {
+                const dependencyTaskName = entry.slice(1);
+                for (const dependencyProject of opts.projectDependencies.get(project) ?? []) {
+                    dependencies.add(taskKey(dependencyProject, dependencyTaskName));
+                    queue.push({ project: dependencyProject, taskName: dependencyTaskName, requested: false });
+                }
+            }
+            else {
+                dependencies.add(taskKey(project, entry));
+                queue.push({ project, taskName: entry, requested: false });
+            }
+        }
+        graph.set(key, {
+            project,
+            taskName,
+            concurrency: taskConcurrency(opts.tasks, taskName),
+            scripts: opts.selectScripts(opts.scriptsByProject(project), taskName),
+            requested,
+            dependencies: [...dependencies],
+        });
+    }
+    return graph;
+}
+function taskConcurrency(tasks, taskName) {
+    return tasks != null && Object.hasOwn(tasks, taskName)
+        ? tasks[taskName].concurrency
+        : undefined;
+}
+export function taskKey(project, taskName) {
+    return `${project}\0${taskName}`;
+}
+/**
+ * The `dependsOn` entries of `taskName`. An own-property check, not a plain
+ * lookup: a script named like an `Object.prototype` member (`constructor`,
+ * `toString`, ...) must get the default rather than resolve an inherited
+ * value.
+ */
+function taskDependsOn(tasks, taskName) {
+    if (tasks != null && Object.hasOwn(tasks, taskName)) {
+        return tasks[taskName].dependsOn ?? [];
+    }
+    return [`^${taskName}`];
+}
+/**
+ * Topologically orders the task graph, throwing when the tasks form a cycle
+ * unless `ignoreCycles` tolerates it and mutates the graph's edges acyclic.
+ * Detection is scoped to this graph: a cycle among tasks the filter did not
+ * select cannot fail the run.
+ */
+export function sequenceTasks(graph, opts) {
+    const edges = new Map();
+    for (const [key, node] of graph) {
+        edges.set(key, node.dependencies);
+    }
+    const result = graphSequencer(edges, [...graph.keys()]);
+    if (result.cycles.length > 0) {
+        const cycles = result.cycles.map((cycle) => [...cycle, cycle[0]].map((key) => formatTask(graph.get(key), opts.workspaceDir)).join(' → ')).join('; ');
+        if (!opts.ignoreCycles) {
+            throw new PnpmError('TASK_CYCLE', `The tasks form a dependency cycle: ${cycles}`, {
+                hint: 'If the cycles are deliberate, set ignoreWorkspaceCycles to true to run their tasks in an arbitrary order.',
+            });
+        }
+        globalWarn(`The tasks form a dependency cycle and run in an arbitrary order relative to each other because ignoreWorkspaceCycles is set: ${cycles}`);
+        dropCyclicDependencies(graph, result.order);
+    }
+    return result.order;
+}
+/**
+ * Keeps only dependencies that point backward in the sequencer's order,
+ * making an ignored cyclic graph deterministic and runnable.
+ */
+function dropCyclicDependencies(graph, order) {
+    const orderIndex = new Map(order.map((key, index) => [key, index]));
+    for (const [key, node] of graph) {
+        node.dependencies = node.dependencies.filter((dependency) => orderIndex.get(dependency) < orderIndex.get(key));
+    }
+}
+export function formatTask(node, workspaceDir) {
+    return `${relativeProjectDir(node.project, workspaceDir)}#${node.taskName}`;
+}
+function relativeProjectDir(project, workspaceDir) {
+    const relative = path.relative(workspaceDir, project);
+    return relative === '' ? '.' : relative.replaceAll(path.sep, '/');
+}
+/** The same graph with every edge turned around: dependents run before dependencies. */
+export function reverseTaskGraph(graph) {
+    const reversed = new Map();
+    for (const [key, node] of graph) {
+        reversed.set(key, { ...node, dependencies: [] });
+    }
+    for (const [key, node] of graph) {
+        for (const dependency of node.dependencies) {
+            reversed.get(dependency).dependencies.push(key);
+        }
+    }
+    return reversed;
+}
+/**
+ * When durable state is available, the graph without exactly those completed
+ * tasks. Otherwise, the graph without the anchor's transitive dependencies —
+ * the tasks inferred to have finished before a run would reach the anchor.
+ * The anchor itself and unfinished work stay, and edges into the dropped set
+ * are treated as satisfied.
+ */
+export function resumeTaskGraphFrom(graph, opts) {
+    const anchorProject = Object.keys(opts.selectedProjectsGraph)
+        .find((project) => opts.selectedProjectsGraph[project]?.package.manifest.name === opts.resumeFrom);
+    if (!anchorProject) {
+        throw new PnpmError('RESUME_FROM_NOT_FOUND', `Cannot find package ${opts.resumeFrom}. Could not determine where to resume from.`);
+    }
+    const anchor = graph.get(taskKey(anchorProject, opts.taskName));
+    if (anchor == null) {
+        // The anchor exists but its task is not in this graph (e.g. a
+        // non-recursive invocation): there is nothing to skip.
+        return graph;
+    }
+    const anchorKey = taskKey(anchorProject, opts.taskName);
+    const dropped = opts.completedTasks == null
+        ? transitiveDependencies(graph, anchor)
+        : new Set([...opts.completedTasks].filter((key) => key !== anchorKey && graph.has(key)));
+    const resumed = new Map();
+    for (const [key, node] of graph) {
+        if (dropped.has(key))
+            continue;
+        resumed.set(key, { ...node, dependencies: node.dependencies.filter((dependency) => !dropped.has(dependency)) });
+    }
+    return resumed;
+}
+function transitiveDependencies(graph, anchor) {
+    const dependencies = new Set();
+    const stack = [...anchor.dependencies];
+    while (stack.length > 0) {
+        const key = stack.pop();
+        if (dependencies.has(key))
+            continue;
+        dependencies.add(key);
+        stack.push(...graph.get(key).dependencies);
+    }
+    return dependencies;
+}
+/**
+ * Whether at most one script can ever be in flight, which is when output may
+ * stay inherited rather than piped: no task runs several scripts at once, and
+ * every script-running task lies on one dependency chain, so the graph forces
+ * them to run one after another.
+ *
+ * `sequencedTasks` is {@link sequenceTasks}'s result — the proof the graph is
+ * acyclic, and the evaluation order for the longest-chain scan.
+ */
+export function isSerialTaskGraph(graph, sequencedTasks) {
+    let scriptTaskCount = 0;
+    for (const node of graph.values()) {
+        if (node.scripts.length > 1)
+            return false;
+        scriptTaskCount += node.scripts.length;
+    }
+    if (scriptTaskCount <= 1)
+        return true;
+    const chainLength = new Map();
+    let longestChain = 0;
+    for (const key of sequencedTasks) {
+        const node = graph.get(key);
+        let viaDependencies = 0;
+        for (const dependency of node.dependencies) {
+            viaDependencies = Math.max(viaDependencies, chainLength.get(dependency) ?? 0);
+        }
+        const length = viaDependencies + node.scripts.length;
+        chainLength.set(key, length);
+        longestChain = Math.max(longestChain, length);
+    }
+    return longestChain === scriptTaskCount;
+}
+/**
+ * What `--dry-run --json` emits: nodes and edges rather than an order, since
+ * independent tasks have no required sequence. Identifiers are the
+ * workspace-relative project directory and the script name.
+ */
+export function taskGraphToJson(graph, workspaceDir) {
+    const tasks = [...graph.values()]
+        .map((node) => ({
+        project: relativeProjectDir(node.project, workspaceDir),
+        script: node.taskName,
+        missingScript: node.scripts.length === 0,
+        dependsOn: node.dependencies
+            .map((dependency) => {
+            const dependencyNode = graph.get(dependency);
+            return {
+                project: relativeProjectDir(dependencyNode.project, workspaceDir),
+                script: dependencyNode.taskName,
+            };
+        })
+            .sort(compareTaskIds),
+    }))
+        .sort(compareTaskIds);
+    return { tasks };
+}
+function compareTaskIds(left, right) {
+    return lexCompare(left.project, right.project) || lexCompare(left.script, right.script);
+}
+/**
+ * What plain `--dry-run` prints: one valid linearization of the graph — not
+ * the order the scheduler will follow. Ties among simultaneously runnable
+ * tasks are broken by project directory, so two dry runs of one workspace
+ * print the same thing and their diff is meaningful.
+ */
+export function renderTaskGraphDryRun(graph, sequencedTasks, workspaceDir) {
+    return sequencedTasks.map((key) => {
+        const node = graph.get(key);
+        return node.scripts.length === 0
+            ? `${formatTask(node, workspaceDir)} (skipped: no such script)`
+            : formatTask(node, workspaceDir);
+    }).join('\n');
+}
+//# sourceMappingURL=taskGraph.js.map

package/lib/taskScheduler.d.ts

@@ -0,0 +1,57 @@
+import type { TaskGraph, TaskKey, TaskNode } from './taskGraph.js';
+export type DependencyGraph<Node> = Map<Node, Node[]>;
+export type TaskCompletion = 'passed' | 'failed'
+/**
+ * The task's work errored before it could run — an infrastructure
+ * failure, not a script failure. Stops dispatch like a bail; the caller
+ * holds the error and rethrows it after the scheduler settles.
+ */
+ | 'aborted';
+export interface ScheduleTasksOptions {
+    /** When `true`, the first failure stops the run: nothing further is dispatched and the scheduler settles at once. */
+    bail: boolean;
+    /**
+     * Runs one task's work and resolves with how it ended. Never rejects:
+     * the caller records its own failure details. Not called for
+     * pass-through tasks (no scripts to run).
+     */
+    runTask: (node: TaskNode, key: TaskKey) => Promise<TaskCompletion>;
+    /**
+     * A task that runs nothing: a pass-through with no such script, or —
+     * without `--bail` — a task some dependency of which did not pass. Both are
+     * reported as skipped.
+     */
+    onTaskSkipped: (node: TaskNode, key: TaskKey) => void;
+}
+export interface ScheduleGraphOptions<Node> {
+    /** When `true`, the first failure stops the run: nothing further is dispatched and the scheduler settles at once. */
+    bail: boolean;
+    /** Maximum number of graph nodes whose work may be in flight. */
+    concurrency?: number;
+    /** Let dependents run after a failed node. Used by legacy `--no-bail` command loops. */
+    continueOnFailure?: boolean;
+    /** Wait for already-dispatched nodes after dispatch stops. Defaults to `true`. */
+    finishInFlight?: boolean;
+    runNode: (node: Node) => Promise<TaskCompletion>;
+    onNodeSkipped: (node: Node) => void;
+}
+/**
+ * Dispatches every task whose dependencies have all completed successfully,
+ * in dependency order and nothing else, with concurrency among ready tasks
+ * limited by the scheduler. Resolves once all tasks settled, or as
+ * soon as a bailed failure or an abort stops the run: in-flight work is then
+ * abandoned to the caller, whose exit path terminates the running commands.
+ * Tasks never dispatched are left untouched, so their caller-side status
+ * stays whatever "queued" is.
+ *
+ * The graph must be acyclic ({@link sequenceTasks} proves it); a cycle would
+ * hang this scheduler.
+ */
+export declare function scheduleTasks(graph: TaskGraph, opts: ScheduleTasksOptions): Promise<void>;
+/**
+ * Dispatches graph nodes as soon as all of their dependencies settle under the
+ * configured failure policy. Independent branches do not wait for a shared
+ * topological-group barrier. Backward edges in a cycle are dropped according
+ * to the graph sequencer's deterministic order.
+ */
+export declare function scheduleGraph<Node>(graph: DependencyGraph<Node>, opts: ScheduleGraphOptions<Node>): Promise<void>;

package/lib/taskScheduler.js

@@ -0,0 +1,221 @@
+import { graphSequencer } from '@pnpm/deps.graph-sequencer';
+/**
+ * Dispatches every task whose dependencies have all completed successfully,
+ * in dependency order and nothing else, with concurrency among ready tasks
+ * limited by the scheduler. Resolves once all tasks settled, or as
+ * soon as a bailed failure or an abort stops the run: in-flight work is then
+ * abandoned to the caller, whose exit path terminates the running commands.
+ * Tasks never dispatched are left untouched, so their caller-side status
+ * stays whatever "queued" is.
+ *
+ * The graph must be acyclic ({@link sequenceTasks} proves it); a cycle would
+ * hang this scheduler.
+ */
+export async function scheduleTasks(graph, opts) {
+    const dependencies = new Map();
+    for (const [key, node] of graph) {
+        dependencies.set(key, node.dependencies);
+    }
+    await scheduleGraphWithConcurrencyLimits(dependencies, {
+        bail: opts.bail,
+        finishInFlight: false,
+        runNode: async (key) => {
+            const node = graph.get(key);
+            if (node.scripts.length === 0) {
+                opts.onTaskSkipped(node, key);
+                return 'passed';
+            }
+            return opts.runTask(node, key);
+        },
+        onNodeSkipped: (key) => opts.onTaskSkipped(graph.get(key), key),
+    }, (key) => {
+        const node = graph.get(key);
+        return node.concurrency == null || node.scripts.length === 0
+            ? undefined
+            : { group: node.taskName, limit: normalizeConcurrency(node.concurrency) };
+    });
+}
+/**
+ * Dispatches graph nodes as soon as all of their dependencies settle under the
+ * configured failure policy. Independent branches do not wait for a shared
+ * topological-group barrier. Backward edges in a cycle are dropped according
+ * to the graph sequencer's deterministic order.
+ */
+export async function scheduleGraph(graph, opts) {
+    await scheduleGraphWithConcurrencyLimits(graph, opts);
+}
+async function scheduleGraphWithConcurrencyLimits(graph, opts, concurrencyLimit) {
+    // A rejection violates runTask's contract; held here so the run still
+    // fails with it rather than silently resolving. First error wins: a
+    // rejection landing only after something else already stopped the run is
+    // abandoned along with the rest of the in-flight work, exactly as a
+    // second script failure after a bail is.
+    let contractViolation;
+    let rejected = false;
+    const concurrency = normalizeConcurrency(opts.concurrency);
+    const pendingDependencyCount = new Map();
+    const dependents = new Map();
+    const ready = [];
+    const nodeConcurrencyGroups = new Map();
+    const concurrencyGroups = new Map();
+    const order = graphSequencer(graph).order;
+    const orderIndex = new Map(order.map((node, index) => [node, index]));
+    for (const [node, dependencies] of graph) {
+        const orderedDependencies = dependencies.filter((dependency) => orderIndex.get(dependency) < orderIndex.get(node));
+        pendingDependencyCount.set(node, orderedDependencies.length);
+        for (const dependency of orderedDependencies) {
+            let list = dependents.get(dependency);
+            if (list == null) {
+                dependents.set(dependency, list = []);
+            }
+            list.push(node);
+        }
+    }
+    const blocked = new Set();
+    let stopDispatch = false;
+    let unsettled = graph.size;
+    const makeReady = (node) => {
+        const concurrency = concurrencyLimit?.(node);
+        if (concurrency == null) {
+            ready.push(node);
+            return;
+        }
+        nodeConcurrencyGroups.set(node, concurrency.group);
+        let group = concurrencyGroups.get(concurrency.group);
+        if (group == null) {
+            concurrencyGroups.set(concurrency.group, group = {
+                limit: concurrency.limit,
+                reserved: 0,
+                waiting: [],
+                waitingHead: 0,
+            });
+        }
+        if (group.reserved < group.limit) {
+            group.reserved++;
+            ready.push(node);
+        }
+        else {
+            group.waiting.push(node);
+        }
+    };
+    const releaseConcurrency = (node) => {
+        const groupName = nodeConcurrencyGroups.get(node);
+        if (groupName == null)
+            return;
+        const group = concurrencyGroups.get(groupName);
+        group.reserved--;
+        if (group.waitingHead < group.waiting.length) {
+            group.reserved++;
+            ready.push(group.waiting[group.waitingHead++]);
+        }
+    };
+    for (const [node, count] of pendingDependencyCount) {
+        if (count === 0)
+            makeReady(node);
+    }
+    await new Promise((resolve) => {
+        const settleIfDone = () => {
+            // Task runs may opt out because a watch-style script never finishes.
+            // Command pipelines retain their prior Promise.all behavior by waiting
+            // for work that was already dispatched.
+            if (unsettled === 0 || (stopDispatch && (opts.finishInFlight === false || active === 0))) {
+                resolve();
+            }
+        };
+        const complete = (node) => {
+            unsettled--;
+            for (const dependent of dependents.get(node) ?? []) {
+                const remaining = pendingDependencyCount.get(dependent) - 1;
+                pendingDependencyCount.set(dependent, remaining);
+                if (remaining === 0 && !blocked.has(dependent)) {
+                    makeReady(dependent);
+                }
+            }
+        };
+        // A failed task's transitive dependents can never become ready (their
+        // dependency count never reaches zero), so they are settled here as
+        // skipped instead.
+        const block = (node) => {
+            const stack = [node];
+            while (stack.length > 0) {
+                for (const dependent of dependents.get(stack.pop()) ?? []) {
+                    if (blocked.has(dependent))
+                        continue;
+                    blocked.add(dependent);
+                    unsettled--;
+                    opts.onNodeSkipped(dependent);
+                    stack.push(dependent);
+                }
+            }
+        };
+        const settle = (node, completion) => {
+            switch (completion) {
+                case 'passed':
+                    complete(node);
+                    break;
+                case 'failed':
+                    if (opts.bail) {
+                        unsettled--;
+                        stopDispatch = true;
+                    }
+                    else if (opts.continueOnFailure === true) {
+                        complete(node);
+                    }
+                    else {
+                        unsettled--;
+                        block(node);
+                    }
+                    break;
+                case 'aborted':
+                    unsettled--;
+                    stopDispatch = true;
+                    break;
+            }
+        };
+        // An explicit queue rather than recursion: a workspace-long chain of
+        // pass-through tasks completes synchronously, and call depth must not
+        // grow with chain length. Drained by index: shift() moves every
+        // remaining element, which is quadratic over a workspace-sized queue.
+        let head = 0;
+        let active = 0;
+        let pumping = false;
+        const pump = () => {
+            if (pumping)
+                return;
+            pumping = true;
+            while (!stopDispatch && active < concurrency && head < ready.length) {
+                const node = ready[head++];
+                active++;
+                opts.runNode(node).then((completion) => {
+                    active--;
+                    releaseConcurrency(node);
+                    settle(node, completion);
+                    pump();
+                }, (error) => {
+                    active--;
+                    releaseConcurrency(node);
+                    // runTask's contract is to never reject; treated as an abort, and
+                    // the error resurfaces once the scheduler settles.
+                    if (!rejected) {
+                        rejected = true;
+                        contractViolation = error;
+                    }
+                    settle(node, 'aborted');
+                    pump();
+                });
+            }
+            pumping = false;
+            settleIfDone();
+        };
+        pump();
+    });
+    if (rejected) {
+        throw contractViolation;
+    }
+}
+function normalizeConcurrency(concurrency) {
+    if (concurrency === Infinity || concurrency == null)
+        return Infinity;
+    return Number.isInteger(concurrency) && concurrency > 0 ? concurrency : 1;
+}
+//# sourceMappingURL=taskScheduler.js.map

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@pnpm/workspace.task-scheduler",
+  "version": "1100.0.0",
+  "description": "Builds and schedules workspace task graphs",
+  "keywords": [
+    "pnpm",
+    "pnpm11",
+    "tasks",
+    "workspace"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pnpm/pnpm/tree/main/pnpm11/workspace/task-scheduler"
+  },
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/pnpm11/workspace/task-scheduler#readme",
+  "bugs": {
+    "url": "https://github.com/pnpm/pnpm/issues"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib",
+    "!*.map"
+  ],
+  "dependencies": {
+    "@pnpm/deps.graph-sequencer": "1101.0.0",
+    "@pnpm/error": "1100.1.3",
+    "@pnpm/text.ordinal-comparator": "1100.0.0",
+    "@pnpm/types": "1102.1.0"
+  },
+  "peerDependencies": {
+    "@pnpm/logger": "^1100.0.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "30.4.1",
+    "@pnpm/logger": "1100.0.0",
+    "@pnpm/workspace.task-scheduler": "1100.0.0"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "jest": {
+    "preset": "@pnpm/jest-config"
+  },
+  "scripts": {
+    "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
+    "test": "pn compile && pn .test",
+    "compile": "tsgo --build && pn lint --fix",
+    ".test": "cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules --disable-warning=ExperimentalWarning --disable-warning=DEP0169\" jest"
+  }
+}