@intelligems/sst 2.49.6-ig.9 → 2.49.8-ig.2

package/runtime/mono-build-config.js

@@ -10,23 +10,47 @@ import { Logger } from "../logger.js";
  * instead of building each handler individually. This significantly speeds up dev mode
  * by sharing compilation work across all handlers.
  *
- * Detection happens once at startup and the result is cached for the session.
+ * Detection latches on: the first check that finds the bundle enables mono
+ * build for the rest of the session. It deliberately does NOT latch off, so a
+ * caller arriving before the bundle has been written cannot disable it.
  */
 export const useMonoBuildConfig = lazy(() => {
     const project = useProject();
     const monoBundleDir = path.join(project.paths.root, ".mono-build");
     const monoBundlePath = path.join(monoBundleDir, "index.mjs");
-    // Check once at startup if mono build exists
-    const enabled = fsSync.existsSync(monoBundlePath);
-    if (enabled) {
-        Logger.debug("Mono build mode enabled:", monoBundlePath);
-    }
+    /**
+     * Latches on true, never on false.
+     *
+     * This was a single `existsSync` at first call, cached for the session by
+     * `lazy`. Dev start deletes `.mono-build/index.mjs` and then rebuilds it, so
+     * any caller landing in that window — typically an invocation that beat the
+     * bundle to disk — pinned this to false for the whole session. Every handler
+     * then took the per-function esbuild path, which does not carry the mono
+     * build's `external` list, and failed to resolve packages the mono bundle
+     * never opens. The bundle finishing changed nothing, because the flag had
+     * already been decided, so the session stayed broken until restarted.
+     *
+     * Re-checking until it is found costs one `existsSync` per call for the few
+     * seconds before the bundle lands, and nothing afterwards.
+     */
+    let enabled = false;
+    const isEnabled = () => {
+        if (!enabled && fsSync.existsSync(monoBundlePath)) {
+            enabled = true;
+            Logger.debug("Mono build mode enabled:", monoBundlePath);
+        }
+        return enabled;
+    };
+    isEnabled();
     return {
         /**
-         * Whether mono build mode is enabled (detected at startup).
+         * Whether mono build mode is enabled. Re-checked until the bundle is
+         * found, so a check made before it was written does not stick.
          * When true, all Node.js handlers use the shared .mono-build bundle.
          */
-        enabled,
+        get enabled() {
+            return isEnabled();
+        },
         /**
          * The mono bundle directory (.mono-build)
          */
@@ -44,7 +68,7 @@ export const useMonoBuildConfig = lazy(() => {
          * This is useful when you have a build result and need to determine its type.
          */
         isMonoBuildPath(buildOut) {
-            return enabled && buildOut.includes(".mono-build");
+            return isEnabled() && buildOut.includes(".mono-build");
         },
         /**
          * Get the pool key for a function based on mono build status.
@@ -52,7 +76,7 @@ export const useMonoBuildConfig = lazy(() => {
          * For non-mono build: per-function key
          */
         getPoolKey(functionID, runtime, buildOut) {
-            if (enabled && buildOut.includes(".mono-build")) {
+            if (isEnabled() && buildOut.includes(".mono-build")) {
                 return { key: `${runtime}:mono-build`, isShared: true };
             }
             return { key: `${runtime}:${functionID}`, isShared: false };

package/runtime/server.js

@@ -24,6 +24,8 @@ export const useRuntimeServer = lazy(async () => {
     const app = express();
     const workers = await useRuntimeWorkers();
     const cfg = await useRuntimeServerConfig();
+    // A worker running several invocations at once has several /next calls
+    // outstanding, so each worker keeps a list of waiting resolvers.
     const workersWaiting = new Map();
     const invocationsQueued = new Map();
     function next(workerID) {
@@ -31,17 +33,21 @@ export const useRuntimeServer = lazy(async () => {
         const value = queue?.shift();
         if (value)
             return value;
-        return new Promise((resolve, reject) => {
-            workersWaiting.set(workerID, resolve);
+        return new Promise((resolve) => {
+            let waiting = workersWaiting.get(workerID);
+            if (!waiting) {
+                waiting = [];
+                workersWaiting.set(workerID, waiting);
+            }
+            waiting.push(resolve);
         });
     }
     // Route an invocation to a specific workerID (used by workers.ts for pooled workers)
     function routeInvocation(targetWorkerID, invocation) {
         const requestPath = getRequestPath(invocation.event);
         const requestID = invocation.requestID;
-        const waiting = workersWaiting.get(targetWorkerID);
+        const waiting = workersWaiting.get(targetWorkerID)?.shift();
         if (waiting) {
-            workersWaiting.delete(targetWorkerID);
             logServer(`path=${requestPath} reqId=${requestID.slice(0, 8)} Worker ${targetWorkerID.slice(0, 8)} was waiting, delivering immediately`);
             waiting(invocation);
             return;
@@ -55,10 +61,10 @@ export const useRuntimeServer = lazy(async () => {
         logServer(`path=${requestPath} reqId=${requestID.slice(0, 8)} Worker ${targetWorkerID.slice(0, 8)} not waiting, QUEUED (queueSize=${arr.length})`);
     }
     workers.subscribe("worker.exited", async (evt) => {
-        const waiting = workersWaiting.get(evt.properties.workerID);
-        if (!waiting)
-            return;
-        workersWaiting.delete(evt.properties.workerID);
+        // Pooled workers are keyed by their pooled id here, not the AWS worker id
+        const id = evt.properties.pooledWorkerID ?? evt.properties.workerID;
+        workersWaiting.delete(id);
+        invocationsQueued.delete(id);
     });
     // Note: function.invoked routing is handled by workers.ts via routeInvocation()
     // This ensures correct routing for both pooled and non-pooled workers
@@ -68,31 +74,26 @@ export const useRuntimeServer = lazy(async () => {
         limit: "10mb",
     }), async (req, res) => {
         const pooledWorkerID = req.params.workerID;
-        const worker = workers.fromID(pooledWorkerID);
-        if (!worker) {
+        const requestID = workers.getCurrentRequestID(pooledWorkerID);
+        const target = workers.resolveRequest(pooledWorkerID, requestID);
+        if (!target) {
             res.status(404).send();
             return;
         }
-        // Get AWS workerID for IoT routing (if pooled)
-        const awsWorkerID = workers.isPooled(pooledWorkerID)
-            ? workers.getAwsWorkerID(pooledWorkerID) || pooledWorkerID
-            : pooledWorkerID;
-        const requestID = workers.getCurrentRequestID(pooledWorkerID);
         logEventTrace("WORKER_END", {
             requestID: requestID || "unknown",
-            functionID: worker.functionID,
+            functionID: target.functionID,
             workerID: pooledWorkerID,
             status: "error",
             errorType: req.body?.errorType || "init_error",
         });
         bus.publish("function.error", {
             requestID,
-            workerID: awsWorkerID,
-            functionID: worker.functionID,
+            workerID: target.awsWorkerID,
+            functionID: target.functionID,
             ...req.body,
         });
-        // Return pooled worker to pool
-        workers.onResponse(pooledWorkerID);
+        workers.onResponse(pooledWorkerID, requestID);
         res.json("ok");
     });
     app.get(`/:workerID/${cfg.API_VERSION}/runtime/invocation/next`, async (req, res) => {
@@ -141,31 +142,26 @@ export const useRuntimeServer = lazy(async () => {
         const requestID = req.params.awsRequestId;
         logServer(`reqId=${requestID.slice(0, 8)} Worker ${pooledWorkerID.slice(0, 8)} posting /response`);
         Logger.debug("Worker", pooledWorkerID, "got response", req.body);
-        const worker = workers.fromID(pooledWorkerID);
-        if (!worker) {
+        const target = workers.resolveRequest(pooledWorkerID, requestID);
+        if (!target) {
             logServer(`reqId=${requestID.slice(0, 8)} ERROR: Worker ${pooledWorkerID.slice(0, 8)} not found`);
             res.status(404).send();
             return;
         }
-        // Get AWS workerID for IoT routing (if pooled)
-        const awsWorkerID = workers.isPooled(pooledWorkerID)
-            ? workers.getAwsWorkerID(pooledWorkerID) || pooledWorkerID
-            : pooledWorkerID;
-        logServer(`reqId=${requestID.slice(0, 8)} Publishing function.success awsWorkerID=${awsWorkerID.slice(0, 8)}`);
+        logServer(`reqId=${requestID.slice(0, 8)} Publishing function.success awsWorkerID=${target.awsWorkerID.slice(0, 8)}`);
         logEventTrace("WORKER_END", {
             requestID,
-            functionID: worker.functionID,
+            functionID: target.functionID,
             workerID: pooledWorkerID,
             status: "success",
         });
         bus.publish("function.success", {
-            workerID: awsWorkerID,
-            functionID: worker.functionID,
+            workerID: target.awsWorkerID,
+            functionID: target.functionID,
             requestID: requestID,
             body: req.body,
         });
-        // Return pooled worker to pool
-        workers.onResponse(pooledWorkerID);
+        workers.onResponse(pooledWorkerID, requestID);
         res.status(202).send();
     });
     app.all(`/proxy*`, express.raw({
@@ -207,33 +203,28 @@ export const useRuntimeServer = lazy(async () => {
         limit: "10mb",
     }), (req, res) => {
         const pooledWorkerID = req.params.workerID;
-        const worker = workers.fromID(pooledWorkerID);
-        if (!worker) {
+        const requestID = req.params.awsRequestId;
+        const target = workers.resolveRequest(pooledWorkerID, requestID);
+        if (!target) {
             res.status(404).send();
             return;
         }
-        // Get AWS workerID for IoT routing (if pooled)
-        const awsWorkerID = workers.isPooled(pooledWorkerID)
-            ? workers.getAwsWorkerID(pooledWorkerID) || pooledWorkerID
-            : pooledWorkerID;
-        const requestID = req.params.awsRequestId;
         logEventTrace("WORKER_END", {
             requestID,
-            functionID: worker.functionID,
+            functionID: target.functionID,
             workerID: pooledWorkerID,
             status: "error",
             errorType: req.body.errorType,
         });
         bus.publish("function.error", {
-            workerID: awsWorkerID,
-            functionID: worker.functionID,
+            workerID: target.awsWorkerID,
+            functionID: target.functionID,
             errorType: req.body.errorType,
             errorMessage: req.body.errorMessage,
             requestID,
             trace: req.body.trace,
         });
-        // Return pooled worker to pool
-        workers.onResponse(pooledWorkerID);
+        workers.onResponse(pooledWorkerID, requestID);
         res.status(202).send();
     });
     app.listen(cfg.port);

package/runtime/stdout-attribution.d.ts

@@ -0,0 +1,18 @@
+/**
+ * When one worker runs several invocations at once, its stdout is a single
+ * stream. The worker runtime prefixes each console line with the request it
+ * belongs to, and the parent splits the stream back out here.
+ *
+ * Shared by `support/nodejs-runtime` (writer) and `runtime/workers.ts` (reader).
+ */
+export declare function tagLine(requestID: string, line: string): string;
+export interface AttributedChunk {
+    requestID?: string;
+    text: string;
+}
+/**
+ * Split a stdout chunk into runs of consecutive lines that belong to the same
+ * request. Lines without a tag get `requestID: undefined` so the caller can
+ * fall back to whatever it knows about the worker.
+ */
+export declare function splitAttributed(chunk: string): AttributedChunk[];

package/runtime/stdout-attribution.js

@@ -0,0 +1,43 @@
+/**
+ * When one worker runs several invocations at once, its stdout is a single
+ * stream. The worker runtime prefixes each console line with the request it
+ * belongs to, and the parent splits the stream back out here.
+ *
+ * Shared by `support/nodejs-runtime` (writer) and `runtime/workers.ts` (reader).
+ */
+const MARK = "\u001e"; // ASCII record separator, never appears in normal logs
+export function tagLine(requestID, line) {
+    return `${MARK}${requestID}${MARK}${line}`;
+}
+/**
+ * Split a stdout chunk into runs of consecutive lines that belong to the same
+ * request. Lines without a tag get `requestID: undefined` so the caller can
+ * fall back to whatever it knows about the worker.
+ */
+export function splitAttributed(chunk) {
+    const out = [];
+    const lines = chunk.split("\n");
+    // A trailing newline yields an empty last element; drop it so we do not
+    // emit an empty untagged chunk.
+    if (lines.length > 1 && lines[lines.length - 1] === "")
+        lines.pop();
+    for (const raw of lines) {
+        let requestID;
+        let text = raw;
+        if (raw.startsWith(MARK)) {
+            const end = raw.indexOf(MARK, 1);
+            if (end > 1) {
+                requestID = raw.slice(1, end);
+                text = raw.slice(end + 1);
+            }
+        }
+        const last = out[out.length - 1];
+        if (last && last.requestID === requestID) {
+            last.text += "\n" + text;
+        }
+        else {
+            out.push({ requestID, text });
+        }
+    }
+    return out;
+}

package/runtime/worker-config.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Dev-mode worker knobs. Every value is overridable through the environment;
+ * the defaults are sized so a laptop running `sst dev` stays responsive.
+ */
+/** Max live workers per pool key (one key for all mono-build Node functions). */
+export declare const POOL_SIZE: number;
+/** How long an idle worker is kept before it is terminated. */
+export declare const IDLE_TIMEOUT: number;
+/** Invocations one Node worker may run at the same time. */
+export declare const WORKER_CONCURRENCY: number;
+/** Warm pings sent at dev start. 0 disables warmup. Capped at POOL_SIZE. */
+export declare const WARMUP_COUNT: number;
+/** V8 old-space cap for each Node worker thread, in MB. 0 leaves it unbounded. */
+export declare const WORKER_MAX_HEAP_MB: number;
+/** Run Node workers with --enable-source-maps (costs memory per worker). */
+export declare const SOURCE_MAPS: boolean;
+/** Sample process and worker memory to .sst/memory.log. */
+export declare const DEBUG_MEMORY: boolean;
+export declare const BUILD_CONCURRENCY: number;

package/runtime/worker-config.js

@@ -0,0 +1,26 @@
+/**
+ * Dev-mode worker knobs. Every value is overridable through the environment;
+ * the defaults are sized so a laptop running `sst dev` stays responsive.
+ */
+function int(name, fallback) {
+    const raw = process.env[name];
+    if (raw === undefined || raw === "")
+        return fallback;
+    const value = parseInt(raw, 10);
+    return Number.isFinite(value) ? value : fallback;
+}
+/** Max live workers per pool key (one key for all mono-build Node functions). */
+export const POOL_SIZE = int("SST_WORKER_POOL_SIZE", 4);
+/** How long an idle worker is kept before it is terminated. */
+export const IDLE_TIMEOUT = int("SST_WORKER_IDLE_TIMEOUT", 5 * 60 * 1000);
+/** Invocations one Node worker may run at the same time. */
+export const WORKER_CONCURRENCY = Math.max(1, int("SST_WORKER_CONCURRENCY", 5));
+/** Warm pings sent at dev start. 0 disables warmup. Capped at POOL_SIZE. */
+export const WARMUP_COUNT = Math.min(POOL_SIZE, Math.max(0, int("SST_WARMUP_COUNT", POOL_SIZE)));
+/** V8 old-space cap for each Node worker thread, in MB. 0 leaves it unbounded. */
+export const WORKER_MAX_HEAP_MB = int("SST_WORKER_MAX_HEAP_MB", 1024);
+/** Run Node workers with --enable-source-maps (costs memory per worker). */
+export const SOURCE_MAPS = process.env.SST_SOURCE_MAPS === "true";
+/** Sample process and worker memory to .sst/memory.log. */
+export const DEBUG_MEMORY = process.env.SST_DEBUG_MEMORY === "true";
+export const BUILD_CONCURRENCY = int("SST_BUILD_CONCURRENCY", 4);

package/runtime/worker-pool-logging.d.ts

@@ -1,5 +1,5 @@
-export declare const POOL_SIZE: number;
-export declare const IDLE_TIMEOUT: number;
+import { IDLE_TIMEOUT, POOL_SIZE } from "./worker-config.js";
+export { POOL_SIZE, IDLE_TIMEOUT };
 /**
  * Set the function name resolver callback
  * Called by workers.ts to provide access to useFunctions()

package/runtime/worker-pool-logging.js

@@ -1,8 +1,7 @@
 import { createDebugFileLogger } from "./debug-file-logger.js";
-// Configuration
-const SST_BUILD_CONCURRENCY = parseInt(process.env.SST_BUILD_CONCURRENCY || "4", 10);
-export const POOL_SIZE = parseInt(process.env.SST_WORKER_POOL_SIZE || "10", 10);
-export const IDLE_TIMEOUT = parseInt(process.env.SST_WORKER_IDLE_TIMEOUT || "60000", 10);
+import { BUILD_CONCURRENCY as SST_BUILD_CONCURRENCY, IDLE_TIMEOUT, POOL_SIZE, WORKER_CONCURRENCY, } from "./worker-config.js";
+import { memorySummary } from "./memory-logging.js";
+export { POOL_SIZE, IDLE_TIMEOUT };
 const DEBUG_POOL = process.env.SST_DEBUG_POOL === "true";
 const DEBUG_POOL_FILE = process.env.SST_DEBUG_POOL_FILE || ".sst/worker-pool.log";
 const INVOKE_TRACE_FILE = ".sst/invoke-trace.log";
@@ -24,7 +23,7 @@ function getPoolLogger() {
         poolLogger = createDebugFileLogger({
             filePath: DEBUG_POOL_FILE,
             sessionName: "POOL",
-            sessionHeader: `POOL_SIZE=${POOL_SIZE} IDLE_TIMEOUT=${IDLE_TIMEOUT}ms BUILD_CONCURRENCY=${SST_BUILD_CONCURRENCY}`,
+            sessionHeader: `POOL_SIZE=${POOL_SIZE} IDLE_TIMEOUT=${IDLE_TIMEOUT}ms CONCURRENCY=${WORKER_CONCURRENCY} BUILD_CONCURRENCY=${SST_BUILD_CONCURRENCY}`,
             width: 100,
         });
     }
@@ -158,6 +157,7 @@ export function writeSessionEndSummary() {
         const funcName = getFunctionName(funcID);
         summary += `  ${funcName.padEnd(25)} total=${total} poolHits=${hits} coldStarts=${cold} peakConcurrent=${peak} hitRate=${hitRate}%\n`;
     }
+    summary += memorySummary();
     logger.close(summary);
 }
 // Invocation trace logging - uses the abstract logger

package/runtime/worker-pool.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Bookkeeping for pooled dev workers.
+ *
+ * A pool key groups workers that can serve the same invocations: one key per
+ * function normally, one shared key for every Node function in mono-build
+ * mode. Each worker may hold up to `maxConcurrency` invocations at once, and a
+ * key never holds more than `maxWorkers` live (non-stale) workers, so the
+ * memory a key can consume is bounded by `maxWorkers` isolates.
+ *
+ * This module decides *which* worker serves a request and when a worker is
+ * retired. It never starts or stops threads itself: `onTerminate` is the hook
+ * the owner uses to actually stop the worker.
+ */
+/// <reference types="node" resolution-mode="require"/>
+export interface PoolWorker {
+    id: string;
+    poolKey: string;
+    /** Function of the most recent invocation (shared pools serve many). */
+    functionID: string;
+    runtime: string;
+    inFlight: number;
+    maxConcurrency: number;
+    /** A stale worker finishes what it holds, then terminates. */
+    stale: boolean;
+    createdAt: number;
+    bundlePath: string;
+    bundleMtime?: number;
+    isSharedPool: boolean;
+    idleTimer?: NodeJS.Timeout;
+}
+export type TerminateReason = "idle_timeout" | "stale_mtime" | "rebuild" | "mono-rebuild" | "stale";
+export interface WorkerPoolOptions {
+    maxWorkers: number;
+    idleTimeoutMs: number;
+    onTerminate: (worker: PoolWorker, reason: TerminateReason) => void;
+}
+export interface PoolStats {
+    workers: number;
+    idle: number;
+    inFlight: number;
+}
+export declare class WorkerPool {
+    private readonly opts;
+    private readonly pools;
+    private readonly byID;
+    constructor(opts: WorkerPoolOptions);
+    add(worker: PoolWorker): void;
+    get(id: string): PoolWorker | undefined;
+    workersFor(poolKey: string): readonly PoolWorker[];
+    all(): PoolWorker[];
+    /** Live workers count toward the cap; stale ones are on their way out. */
+    liveCount(poolKey: string): number;
+    canCreate(poolKey: string): boolean;
+    /**
+     * Least-loaded live worker with spare capacity, or undefined. Workers whose
+     * bundle is older than `currentMtime` are retired on the way: idle ones now,
+     * busy ones once they drain.
+     */
+    pick(poolKey: string, currentMtime?: number): PoolWorker | undefined;
+    /** Hand an invocation to a worker. */
+    checkout(worker: PoolWorker, functionID: string): void;
+    /**
+     * An invocation finished. Returns what became of the worker: it is gone
+     * (stale and drained), idle (timer armed), or still busy.
+     */
+    checkin(worker: PoolWorker): "terminated" | "idle" | "busy";
+    /**
+     * The code behind `poolKey` changed. Idle workers go now; busy ones are
+     * marked stale and go when they drain. Returns the ids of workers that
+     * were only marked.
+     */
+    invalidate(poolKey: string, reason: "rebuild" | "mono-rebuild"): string[];
+    /** Forget a worker that exited on its own (crash, OOM, self-timeout). */
+    remove(worker: PoolWorker): void;
+    stats(): PoolStats;
+    private retire;
+}

package/runtime/worker-pool.js

@@ -0,0 +1,162 @@
+/**
+ * Bookkeeping for pooled dev workers.
+ *
+ * A pool key groups workers that can serve the same invocations: one key per
+ * function normally, one shared key for every Node function in mono-build
+ * mode. Each worker may hold up to `maxConcurrency` invocations at once, and a
+ * key never holds more than `maxWorkers` live (non-stale) workers, so the
+ * memory a key can consume is bounded by `maxWorkers` isolates.
+ *
+ * This module decides *which* worker serves a request and when a worker is
+ * retired. It never starts or stops threads itself: `onTerminate` is the hook
+ * the owner uses to actually stop the worker.
+ */
+export class WorkerPool {
+    opts;
+    pools = new Map();
+    byID = new Map();
+    constructor(opts) {
+        this.opts = opts;
+    }
+    add(worker) {
+        let pool = this.pools.get(worker.poolKey);
+        if (!pool) {
+            pool = [];
+            this.pools.set(worker.poolKey, pool);
+        }
+        pool.push(worker);
+        this.byID.set(worker.id, worker);
+    }
+    get(id) {
+        return this.byID.get(id);
+    }
+    workersFor(poolKey) {
+        return this.pools.get(poolKey) ?? [];
+    }
+    all() {
+        return [...this.byID.values()];
+    }
+    /** Live workers count toward the cap; stale ones are on their way out. */
+    liveCount(poolKey) {
+        return this.workersFor(poolKey).filter((w) => !w.stale).length;
+    }
+    canCreate(poolKey) {
+        return this.liveCount(poolKey) < this.opts.maxWorkers;
+    }
+    /**
+     * Least-loaded live worker with spare capacity, or undefined. Workers whose
+     * bundle is older than `currentMtime` are retired on the way: idle ones now,
+     * busy ones once they drain.
+     */
+    pick(poolKey, currentMtime) {
+        const pool = this.pools.get(poolKey);
+        if (!pool || pool.length === 0)
+            return undefined;
+        for (const worker of [...pool]) {
+            if (currentMtime &&
+                worker.bundleMtime &&
+                currentMtime > worker.bundleMtime &&
+                !worker.stale) {
+                this.retire(worker, "stale_mtime");
+            }
+        }
+        let best;
+        for (const worker of pool) {
+            if (worker.stale)
+                continue;
+            if (worker.inFlight >= worker.maxConcurrency)
+                continue;
+            if (!best || worker.inFlight < best.inFlight)
+                best = worker;
+        }
+        return best;
+    }
+    /** Hand an invocation to a worker. */
+    checkout(worker, functionID) {
+        if (worker.idleTimer) {
+            clearTimeout(worker.idleTimer);
+            worker.idleTimer = undefined;
+        }
+        worker.inFlight += 1;
+        worker.functionID = functionID;
+    }
+    /**
+     * An invocation finished. Returns what became of the worker: it is gone
+     * (stale and drained), idle (timer armed), or still busy.
+     */
+    checkin(worker) {
+        if (worker.inFlight > 0)
+            worker.inFlight -= 1;
+        if (worker.inFlight > 0)
+            return "busy";
+        if (worker.stale) {
+            this.remove(worker);
+            this.opts.onTerminate(worker, "stale");
+            return "terminated";
+        }
+        worker.idleTimer = setTimeout(() => {
+            worker.idleTimer = undefined;
+            if (worker.inFlight > 0)
+                return;
+            if (!this.byID.has(worker.id))
+                return;
+            this.remove(worker);
+            this.opts.onTerminate(worker, "idle_timeout");
+        }, this.opts.idleTimeoutMs);
+        return "idle";
+    }
+    /**
+     * The code behind `poolKey` changed. Idle workers go now; busy ones are
+     * marked stale and go when they drain. Returns the ids of workers that
+     * were only marked.
+     */
+    invalidate(poolKey, reason) {
+        const marked = [];
+        for (const worker of [...this.workersFor(poolKey)]) {
+            if (worker.inFlight === 0) {
+                this.remove(worker);
+                this.opts.onTerminate(worker, reason);
+            }
+            else {
+                worker.stale = true;
+                marked.push(worker.id);
+            }
+        }
+        return marked;
+    }
+    /** Forget a worker that exited on its own (crash, OOM, self-timeout). */
+    remove(worker) {
+        if (worker.idleTimer) {
+            clearTimeout(worker.idleTimer);
+            worker.idleTimer = undefined;
+        }
+        this.byID.delete(worker.id);
+        const pool = this.pools.get(worker.poolKey);
+        if (!pool)
+            return;
+        const idx = pool.indexOf(worker);
+        if (idx >= 0)
+            pool.splice(idx, 1);
+        if (pool.length === 0)
+            this.pools.delete(worker.poolKey);
+    }
+    stats() {
+        let idle = 0;
+        let inFlight = 0;
+        for (const worker of this.byID.values()) {
+            if (worker.inFlight === 0)
+                idle += 1;
+            inFlight += worker.inFlight;
+        }
+        return { workers: this.byID.size, idle, inFlight };
+    }
+    retire(worker, reason) {
+        if (worker.inFlight === 0) {
+            this.remove(worker);
+            this.opts.onTerminate(worker, reason);
+        }
+        else {
+            worker.stale = true;
+        }
+    }
+}