@cleocode/core 2026.10.4 → 2026.10.5

package/dist/tasks/tool-semaphore.d.ts

@@ -1,69 +1,58 @@
 /**
- * Cross-process global concurrency limit for evidence-tool runs (T1534 / ADR-061).
+ * Machine-wide admission for evidence-tool runs (T1534 / ADR-061, T13133).
  *
  * The cache layer ({@link runToolCached}) coalesces *identical* parallel runs
- * via a per-key file lock — when 10 sibling tasks against the same git HEAD
- * call `tool:test`, only one spawns. But orchestrator-spawned worktree
- * agents each operate on a *different* HEAD (one branch per worktree per
- * ADR-055), so their cache keys differ and the per-key lock does NOT
- * coalesce them. Without an additional bound, N worktree agents would each
- * spawn the full toolchain, multiplying CPU and resident memory by N.
- *
- * This module bounds *total* concurrent runs of a canonical tool across
- * the whole machine — independent of which project, worktree, or PID
- * issues the call. It uses a slot directory under
- * `~/.local/share/cleo/locks/tool-<canonical>/` with `slot-0.lock` …
- * `slot-(N-1).lock` files; each slot is held by `proper-lockfile` so a
- * crashed process auto-releases via the standard stale-lock recovery.
- *
- * Defaults (configurable via env):
- *
- *   | Tool            | Default                                      | Binding constraint          |
- *   |-----------------|----------------------------------------------|-----------------------------|
- *   | test, build     | min(RAM/24GiB, cpus/4), min 1                | MEMORY (each run forks)     |
- *   | typecheck, lint | min(RAM/2 ÷ (heap + 2GiB), cpus/2), min 1    | MEMORY (one TS program)     |
- *   | audit           | max(2, cpus/2)                               | network-bound, small RAM    |
- *   | security-scan   | max(2, cpus/2)                               | network-bound, small RAM    |
- *
- * On darwin `test`/`build` default to ONE slot machine-wide (T12963), and
- * `typecheck`/`lint` to at most {@link DARWIN_MEMORY_BOUND_SLOTS} (T13123):
- * concurrent agents on a laptop are the common case there. Memory-bound runs
- * shrink under pressure ({@link pressureScaleSlots}). Heavy runs additionally
- * take a slot of the matching {@link ResourceGovernor} class (`test` →
- * `test-run`, `build` → `scoped-build`), so evidence runs and other governed
- * heavy work share one machine-wide budget. `typecheck`/`lint` take no governor
- * class of their own: cross-surface admission belongs to the single
- * footprint-based scheduler (T13132), not to one more class.
- *
- * T12091: `test`/`build` were `max(1, cpus/4)` — 6 slots on a 24-core box. Since
- * each `pnpm run test` is itself allowed 6 vitest forks × 4 GiB, the two bounds
- * composed to 144 GiB of permitted heap on 62 GiB of RAM. Neither layer was
- * individually violated, which is exactly why the machine froze without any
- * guard firing. Heavy tools are now bounded by the dimension that actually
- * limits them — see {@link defaultMaxConcurrent}.
- *
- * Override via `CLEO_TOOL_CONCURRENCY_<CANONICAL>` (e.g.
- * `CLEO_TOOL_CONCURRENCY_TEST=2`). Set to `0` or a negative number to
- * disable the limit for that tool — which also disables the RAM bound, so it is
- * the one setting that can still oversubscribe the machine.
+ * via a per-key file lock. Orchestrator-spawned worktree agents each operate
+ * on a *different* HEAD, so their cache keys differ and the per-key lock does
+ * not coalesce them; without a machine-wide bound, N worktree agents would
+ * each spawn the full toolchain, multiplying CPU and resident memory by N.
+ *
+ * Since T13133 that bound is the admission ledger (`resources/admission-ledger.ts`):
+ * one budget in bytes and one FIFO queue shared by every evidence run, every
+ * `cleo run` job and the vitest project probe, machine-wide. An evidence run
+ * asks for its footprint (`footprintForTool`: a heavy test/build run is
+ * charged its worker count × 6 GiB, typecheck and lint their planned heap plus
+ * 2 GiB, audit and scans 1 GiB),
+ * waits its turn, and exports the grant's `CLEO_ADMISSION` token to the tool
+ * it spawns, so a `cleo verify` or `cleo run` the tool starts rides the grant
+ * instead of waiting for the budget its own ancestor holds.
+ *
+ * What it replaced: per-tool slot directories under `<cleoHome>/locks/tool-*`,
+ * core- and RAM-derived slot counts (`defaultMaxConcurrent`), PSI slot scaling
+ * (`pressureScaleSlots`), the darwin one-slot rule (T12963) and a second,
+ * separate governor slot taken after the tool slot, the order that could
+ * deadlock against `cleo run` (T13133). Memory pressure now narrows the one
+ * budget, and the memory gate (T13127) refuses heavy work outright while
+ * memory is short; a waiting run says so on stderr with the readings.
+ *
+ * `CLEO_TOOL_CONCURRENCY_<TOOL>` no longer counts runs: `0` (or below) still
+ * bypasses admission for that tool, any other value is ignored, and either
+ * prints one deprecation line per process on stderr. `CLEO_RESOURCES_MODE=off`
+ * is the supported switch.
  *
  * @task T1534
  * @task T12091
  * @task T12963
  * @task T13123
+ * @task T13127
+ * @task T13133
  * @adr ADR-061
  */
-import type { ResourceClass } from '@cleocode/contracts';
+import { type AdmissionRefusal, type AdmissionScope } from '../resources/admission-ledger.js';
 import type { ResourceSample } from '../resources/backend.js';
-import { type SlotHolderIdentity } from '../resources/slot-holder.js';
 import type { CanonicalTool } from './tool-resolver.js';
 /**
- * Function returned by {@link acquireGlobalSlot} that must be called to
- * release the held slot. Always-callable; idempotent against re-entry.
+ * Function returned by {@link acquireGlobalSlot} that must be called to give
+ * the admission back. Always-callable; idempotent against re-entry. `admission`
+ * is the `CLEO_ADMISSION` value to export to the tool's environment (empty
+ * when the run was not admitted through the ledger).
  *
  * @task T1534
+ * @task T13133
  */
-export type ReleaseSlotFn = () => Promise<void>;
+export type ReleaseSlotFn = (() => Promise<void>) & {
+    readonly admission?: string;
+};
 /**
  * Options for {@link acquireGlobalSlot}.
  *
@@ -71,352 +60,124 @@ export type ReleaseSlotFn = () => Promise<void>;
  */
 export interface AcquireSlotOptions {
     /**
-     * Maximum wall-clock time to wait for a free slot before throwing. The
-     * default — 60 minutes — covers a long-running monorepo test suite that
-     * can leave the semaphore held for a while.
+     * Maximum wall-clock time to wait for admission before throwing. The
+     * default — 60 minutes — covers a long-running monorepo test suite ahead in
+     * the queue.
      *
      * @defaultValue `3_600_000` (60 min)
      */
     timeoutMs?: number;
     /**
-     * Sleep between acquire attempts when all slots are busy. Smaller values
-     * burn more CPU on the polling loop; larger values delay the next worker.
+     * How often a waiting run re-reads the ledger.
      *
-     * @defaultValue `100`
+     * @defaultValue `250`
      */
     pollMs?: number;
     /**
-     * Stale-lock window passed to `proper-lockfile`. A slot held by a
-     * process that exited without releasing is reaped after this many
-     * milliseconds.
+     * Override `os.totalmem()` (in GiB) for the budget and the footprint, so a
+     * test resolves the same budget on every host.
      *
-     * @defaultValue `600_000` (10 min)
+     * @internal
      */
-    staleMs?: number;
+    totalRamGib?: number;
     /**
-     * Override `os.availableParallelism()` for tests.
+     * A fixed memory-pressure sample for every admission decision (tests). When
+     * omitted, a live sample is taken; `null` disables pressure (no signal).
      *
      * @internal
      */
-    cpuCount?: number;
+    pressureSample?: ResourceSample | null;
     /**
-     * Override `os.totalmem()` (in GiB) for tests.
-     *
-     * T12091 made the heavy-tool budget RAM-derived, which would otherwise make
-     * the slot count depend on whatever host the suite runs on — a 16 GiB CI
-     * runner and a 62 GiB workstation resolve different budgets for identical
-     * inputs. Injecting it keeps semaphore behaviour deterministic.
-     *
-     * @internal
+     * Bytes to ask for instead of the tool's default footprint: a vitest config
+     * probe asks for 1 GiB, not a whole test run's.
      */
-    totalRamGib?: number;
+    footprintBytes?: number;
     /**
-     * Memory-pressure sample used to scale the effective slot count for the
-     * pressure-sensitive `test`/`build` tools (T12001, Epic T11992). When
-     * omitted, a best-effort live sample is taken (fail-open to the static slot
-     * count on any error). Pass `null` to disable pressure scaling explicitly.
-     * Tests inject a synthetic sample for determinism.
+     * The heap ceiling the run is spawned with, in MiB (the plan's `heapMb`,
+     * T13122). A `typecheck`/`lint` run is charged that heap plus the process
+     * overhead, so a run planned with a larger heap takes more of the budget.
      *
-     * @internal
+     * @defaultValue the machine's default single-process heap
      */
-    pressureSample?: ResourceSample | null;
+    heapMb?: number;
     /**
-     * Override `process.platform` for tests. On `darwin` the heavy `test`/`build`
-     * budget defaults to one slot (T12963).
+     * Skip admission altogether (tests that exercise only the cache layer).
      *
      * @internal
      */
-    platform?: NodeJS.Platform;
+    skipAdmission?: boolean;
     /**
-     * Skip the {@link ResourceGovernor} admission a heavy run takes after its
-     * tool slot (T12963). Tests that exercise only slot files set this.
+     * Where a progress line goes while the run waits ("waiting: memory pressure
+     * …", the holder report after a minute), T13127/T13133.
      *
-     * @internal
+     * @defaultValue one `[cleo] <line>` per notice on stderr (stdout carries the envelope)
      */
-    skipGovernor?: boolean;
+    notice?: (line: string) => void;
     /**
-     * The heap ceiling the run is spawned with, in MiB (the plan's `heapMb`,
-     * T13122). A `typecheck`/`lint` slot is sized from it, so a run planned with
-     * a larger inherited heap counts against more of the budget (T13123).
-     *
-     * @defaultValue {@link defaultSingleProcessHeapMb} for the machine's RAM
+     * How much of the project the run covers (`full` for a whole-suite run),
+     * shown in status and holder reports (T13132).
      */
-    heapMb?: number;
+    scope?: AdmissionScope;
+    /** The CLEO task the run is evidence for, shown in status (T13132). */
+    task?: string;
 }
 /**
- * Worst-case resident footprint of ONE `tool:test` / `tool:build` invocation,
- * in GiB.
- *
- * This is not a guess. The heavy-tool overlay permits at most
- * `MAX_HEAVY_WORKERS` (6) workers × `HEAVY_TOOL_HEAP_MB` (4096) — the largest
- * run budget (T13122) — so a single `pnpm run test` may legitimately hold
- * ~24 GiB before any guard fires. Derived from those constants since T13123,
- * so the two can no longer drift apart.
- *
- * @task T12091
- */
-export declare const HEAVY_TOOL_FOOTPRINT_GIB: number;
-/**
- * Share of total RAM all concurrent `typecheck`/`lint` runs together may hold
- * (T13123). The other half is for the test/build budget, the OS and whatever
- * the operator is running.
- */
-export declare const MEMORY_BOUND_RAM_FRACTION = 0.5;
-/**
- * Resident memory one Node process holds beyond its V8 heap ceiling, in MiB:
- * code, native allocations, buffers. The same allowance the heavy worker count
- * makes (`GIB_PER_WORKER` minus the heap).
- */
-export declare const PROCESS_OVERHEAD_MB: number;
-/**
- * Most concurrent `typecheck`/`lint` runs on darwin, however large the Mac
- * (T13123). A small fixed number, like the single darwin test slot (T12963).
- */
-export declare const DARWIN_MEMORY_BOUND_SLOTS = 2;
-/**
- * Compute the default max-concurrency for a canonical tool.
- *
- * ## Why this is RAM-derived, not core-derived (T12091)
- *
- * This returned `floor(cpus / 4)` for `test`/`build`, which on a 24-core box is
- * **6 concurrent full test suites**. Each of those is itself allowed 6 vitest
- * forks × a 4 GiB heap cap, so the composed permission was
- *
- *     6 runs × 6 forks × 4 GiB = 144 GiB
- *
- * on a 62 GiB machine. Both layers were individually "bounded" and their
- * composition was 2.3× the hardware — which is precisely how this box froze
- * repeatedly: no single guard was violated. The per-invocation cap (T12087) and
- * this cross-invocation cap were written independently and never multiplied out.
- *
- * The dimensional error is the root of it: what limits a test run is MEMORY, and
- * core count says nothing about memory. A 24-core/16 GiB VM got the same 6 slots
- * as a 24-core/256 GiB server. So heavy tools now divide TOTAL RAM by
- * {@link HEAVY_TOOL_FOOTPRINT_GIB} and are additionally capped by cores, never
- * exceeding what the machine can actually hold.
- *
- * Reactive pressure scaling ({@link pressureScaleSlots}) is not a substitute:
- * PSI `some avg10` is a ten-second average, and a fork fleet can exhaust RAM
- * faster than that window can report it. Admission has to be right up front.
- *
- * `typecheck` and `lint` are single processes but not light ones (T13123): one
- * TypeScript program on a large monorepo holds 2–5 GB, and the half-of-cores
- * budget they had was nine slots on an 18-core box — 45 GB of `tsc`. They are
- * RAM-derived now too ({@link MEMORY_BOUND_RAM_FRACTION} of RAM at the run's
- * heap plus {@link PROCESS_OVERHEAD_MB} each), capped by half the cores. Only
- * `audit` and `security-scan` keep the core-derived budget.
- *
- * ## Why darwin gets one heavy slot (T12963)
- *
- * Linux shrinks the heavy budget under memory pressure through PSI
- * ({@link pressureScaleSlots}). macOS exposes no PSI, so that reactive layer
- * never fires there, and a 64 GiB Mac would admit two full suites with nothing
- * to back them off. Concurrent agents on a laptop are the common case, so the
- * default is one heavy run at a time; `CLEO_TOOL_CONCURRENCY_TEST` /
- * `_BUILD` still raise it.
- *
- * @param canonical - the canonical tool class.
- * @param cpuCount  - logical cores available.
- * @param totalRamGib - total machine RAM in GiB; defaults to a live reading.
- * @param platform - OS platform; defaults to `process.platform`.
- * @param heapMb - heap ceiling of the run, for `typecheck`/`lint`; defaults to
- *   {@link defaultSingleProcessHeapMb} for `totalRamGib`.
- * @returns the machine-wide slot count, always ≥ 1.
- *
- * @example
- * ```ts
- * // 24 cores, 62 GiB → floor(62/24) = 2 (was 6, permitting 144 GiB of heap)
- * defaultMaxConcurrent('test', 24, 62); // → 2
- * // 24 cores, 16 GiB → 1: one suite is already more than this box can hold
- * defaultMaxConcurrent('test', 24, 16); // → 1
- * // macOS: no PSI to back off with, so one heavy run at a time
- * defaultMaxConcurrent('test', 12, 64, 'darwin'); // → 1
- * // 18 cores, 48 GiB: ⌊24576 / (4096 + 2048)⌋ = 4 typechecks (was 9); 2 on darwin
- * defaultMaxConcurrent('typecheck', 18, 48, 'linux');  // → 4
- * defaultMaxConcurrent('typecheck', 18, 48, 'darwin'); // → 2
- * // 4 cores, 8 GiB: one at a time
- * defaultMaxConcurrent('typecheck', 4, 8, 'linux'); // → 1
- * ```
- *
- * @task T1534
- * @task T12091
- * @task T12963
- * @task T13123
- */
-export declare function defaultMaxConcurrent(canonical: CanonicalTool, cpuCount: number, totalRamGib?: number, platform?: NodeJS.Platform, heapMb?: number): number;
-/**
- * Resolve the active per-tool concurrency limit, honouring the
- * `CLEO_TOOL_CONCURRENCY_<CANONICAL>` env override when set. A value of
- * `0` (or any non-positive number) disables the bound and returns
- * `Number.POSITIVE_INFINITY`, in which case {@link acquireGlobalSlot}
- * returns a no-op release.
- *
- * @task T1534
- * @task T12963
- * @task T13123
- */
-export declare function resolveMaxConcurrent(canonical: CanonicalTool, cpuCount?: number, totalRamGib?: number, platform?: NodeJS.Platform, heapMb?: number): number;
-/**
- * Scale a static slot budget down under memory pressure (T12001 · choke-point
- * #6). Mirrors the governor's `test-run` budget: halve when `some avg10` exceeds
- * the hold threshold, floor to 1 when it exceeds the backoff/floor threshold.
- * Recovers automatically as pressure clears. `full-build` is not represented as
- * a canonical tool here; the dedicated `full-build` governor class (T11999)
- * pins that to one machine-wide slot.
+ * The deprecated `CLEO_TOOL_CONCURRENCY_<TOOL>` override: `bypass` for `0` or
+ * below, `ignored` for any other number, `null` when unset. Prints one
+ * deprecation line per tool per process on stderr, never on stdout.
  *
- * @task T12001
- */
-export declare function pressureScaleSlots(canonical: CanonicalTool, staticMax: number, sample: ResourceSample, thresholds?: {
-    holdSomeAvg10?: number;
-    floorSomeAvg10?: number;
-}): number;
-/**
- * The {@link ResourceGovernor} class a heavy tool run is admitted under, or
- * `null` for the rest. `test` and `build` are the classes the governor
- * budgets as `test-run` / `scoped-build` (T12963).
- */
-export declare function governorClassFor(canonical: CanonicalTool): ResourceClass | null;
-/**
- * Path to the global slot directory for a canonical tool. Sits under
- * `getCleoHome()/locks/tool-<canonical>/` so all CLEO-driven processes
- * on a machine share the same semaphore — across projects, worktrees,
- * and PIDs.
+ * @param canonical - the canonical tool.
+ * @param notice - where the line goes.
+ * @returns what the override does now.
  *
- * @task T1534
+ * @task T13133
  */
-export declare function semaphoreDir(canonical: CanonicalTool): string;
+export declare function legacyConcurrencyOverride(canonical: CanonicalTool, notice?: (line: string) => void): 'bypass' | 'ignored' | null;
+/** Forget which deprecation notices were printed. Tests only. @internal */
+export declare function _resetToolSemaphoreForTest(): void;
 /**
- * Identity of the process currently holding a semaphore slot.
- *
- * `proper-lockfile` decides staleness from the lock's **mtime**, which it
- * refreshes on a timer while the holder lives. That makes a slot held by a
- * process which died without releasing indistinguishable from one held by a
- * legitimately long-running suite: both simply wait out `staleMs` (10 min by
- * default). On a box where evidence runs are frequent, one orphan therefore
- * blocks every later verify for ten minutes with `E_EVIDENCE_TOOL_BUSY` and
- * no indication of who is holding it (gh#1222).
+ * {@link acquireGlobalSlot} gave up: the run was not admitted within its
+ * timeout. `refusal` says why (memory pressure, or the budget in use) and who
+ * holds the budget.
  *
- * Recording the holder turns that into a decidable question: a slot whose
- * owner is a dead pid on this host is orphaned NOW, not in ten minutes, and
- * the operator can be told which process to look at.
- *
- * Since T12963 the record also carries the holder's process start time, the
- * lock directory it describes and the process groups of the tools it started
- * ({@link SlotHolderIdentity}): a slot is orphaned only when the holder pid
- * AND those tool groups are gone, because a tool spawned detached keeps
- * running after a SIGKILLed cleo.
- *
- * @task T12113 (gh#1222)
- * @task T12963
+ * @task T13133
  */
-export interface SlotHolder extends SlotHolderIdentity {
-    /** OS process id of the holder. */
-    pid: number;
-    /** Host that pid is meaningful on. Liveness is only decided on a match. */
-    host: string;
-    /** ISO 8601 timestamp of acquisition — lets the operator judge "stuck vs slow". */
-    acquiredAt: string;
-    /** Canonical tool the slot belongs to. */
-    canonical: string;
-    /** Slot file this holder record describes. */
-    slot: string;
+export declare class AdmissionTimeoutError extends Error {
+    /** Why the run was not admitted, with the holders. */
+    readonly refusal: AdmissionRefusal;
+    /**
+     * @param canonical - the tool whose run waited.
+     * @param refusal - the ledger's refusal.
+     */
+    constructor(canonical: CanonicalTool, refusal: AdmissionRefusal);
 }
 /**
- * Read a slot's holder record. Returns `null` when absent or unparseable —
- * both mean "we cannot say who holds this", which is treated as alive.
- *
- * @internal
- * @task T12113 (gh#1222)
- */
-export declare function readHolder(slotPath: string): SlotHolder | null;
-/**
- * Is a slot's recorded holder still running?
- *
- * Fails SAFE: an unknown holder, a holder on another host, or any error is
- * reported as ALIVE. Reaping a live holder's slot would let two heavy suites
- * run against one bound — the exact oversubscription the semaphore exists to
- * prevent — so uncertainty must never authorise a reap. A holder whose pid is
- * gone but whose tool group still has a member is ALIVE (T12963).
- *
- * @param holder - Holder record, or `null` when none could be read.
- * @param slotPath - The slot the record belongs to. With it, a record that
- *   does not describe the slot's current lock (or one written before T12963,
- *   which names no lock) is alive, and a recycled pid is dead.
- * @returns `true` when the slot must be treated as legitimately held.
- *
- * @task T12113 (gh#1222)
- * @task T12963
- */
-export declare function isHolderAlive(holder: SlotHolder | null, slotPath?: string): boolean;
-/**
- * Release a slot whose recorded holder is gone.
- *
- * Removes `proper-lockfile`'s lock directory directly — the same thing its own
- * stale recovery does, but decided by process liveness instead of by a 10
- * minute mtime timeout. Since T12963 the holder's tool groups must be gone
- * too, the record must describe the current lock, and the reap runs under a
- * per-slot guard ({@link reapSlotIfHolderDead}).
- *
- * @param slotPath - Slot lock file path.
- * @param staleMs - The slot's `proper-lockfile` stale threshold.
- * @returns `true` when an orphaned slot was actually reaped.
- *
- * @task T12113 (gh#1222)
- * @task T12963
- */
-export declare function reapSlotIfOrphaned(slotPath: string, staleMs?: number): boolean;
-/**
- * Enumerate every slot of a canonical tool with its holder and liveness.
- *
- * Backs the operator-facing lock inspection surface requested in gh#1222 —
- * "who is holding this, and is it even alive?" — which previously required
- * reading `~/.local/share/cleo/locks/` by hand.
- *
- * @param canonical - Canonical tool name.
- * @returns One row per existing slot file.
- *
- * @task T12113 (gh#1222)
- */
-export declare function listSlotHolders(canonical: CanonicalTool): Array<{
-    slot: string;
-    held: boolean;
-    holder: SlotHolder | null;
-    alive: boolean;
-}>;
-/**
- * Reap every orphaned slot of a canonical tool.
- *
- * @param canonical - Canonical tool name.
- * @returns Paths of the slots actually reaped.
- *
- * @task T12113 (gh#1222)
- */
-export declare function reapOrphanedSlots(canonical: CanonicalTool): string[];
-/**
- * Acquire one slot from the global semaphore for a canonical tool. Blocks
- * until a slot becomes free or `timeoutMs` elapses.
+ * Wait for admission of one evidence run of a canonical tool, machine-wide.
+ * Blocks until the ledger admits it or `timeoutMs` elapses.
  *
- * Implementation detail: tries each slot file in turn with `retries: 0`
- * (proper-lockfile non-blocking acquire). When all are busy, sleeps for
- * `pollMs` and retries. This avoids the thundering-herd cost of having
- * many retriers wake at the exact same moment.
+ * Re-entrant: inside an admitted run's process tree (a `cleo verify` that a
+ * `cleo run` job or another evidence run started) it is admitted at once on
+ * that grant. While it waits on memory pressure it says so through
+ * {@link AcquireSlotOptions.notice}, and after a minute it names the holders.
  *
  * @param canonical - Canonical tool name from the resolver.
  * @param opts - Acquisition options.
- * @returns A release function. Idempotent.
- * @throws When `timeoutMs` elapses without acquiring a slot.
+ * @returns A release function carrying the `CLEO_ADMISSION` token. Idempotent.
+ * @throws When `timeoutMs` elapses without admission, naming the reason and
+ *   the holders.
  *
  * @example
  * ```ts
  * const release = await acquireGlobalSlot('test');
  * try {
- *   await runTheTool();
+ *   await runTheTool({ env: { CLEO_ADMISSION: release.admission } });
  * } finally {
  *   await release();
  * }
  * ```
  *
  * @task T1534
+ * @task T13133
  */
 export declare function acquireGlobalSlot(canonical: CanonicalTool, opts?: AcquireSlotOptions): Promise<ReleaseSlotFn>;
 //# sourceMappingURL=tool-semaphore.d.ts.map

package/dist/tasks/tool-semaphore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-semaphore.d.ts","sourceRoot":"","sources":["../../src/tasks/tool-semaphore.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"tool-semaphore.d.ts","sourceRoot":"","sources":["../../src/tasks/tool-semaphore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,cAAc,EAKpB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAE9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAMxD;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG;IAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpF;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,cAAc,GAAG,IAAI,CAAC;IACvC;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAChC;;;OAGG;IACH,KAAK,CAAC,EAAE,cAAc,CAAC;IACvB,uEAAuE;IACvE,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAUD;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CACvC,SAAS,EAAE,aAAa,EACxB,MAAM,GAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAmB,GAC5C,QAAQ,GAAG,SAAS,GAAG,IAAI,CAgB7B;AAED,2EAA2E;AAC3E,wBAAgB,0BAA0B,IAAI,IAAI,CAEjD;AAED;;;;;;GAMG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,sDAAsD;IACtD,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;IAEnC;;;OAGG;gBACS,SAAS,EAAE,aAAa,EAAE,OAAO,EAAE,gBAAgB;CAShE;AAUD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,aAAa,EACxB,IAAI,GAAE,kBAAuB,GAC5B,OAAO,CAAC,aAAa,CAAC,CA+CxB"}