@zukhruf/pool 0.0.0-stage → 0.3.43

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ezzabuzaid
+
+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

@@ -1,3 +1,46 @@
-# Temporary Holding Version
+# @zukhruf/pool
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Lends long-lived workers to jobs, one job for each worker at a time. A worker is costly to start: a native helper that loads a model, or a command-line agent that keeps a session. The pool starts workers, lends them, replaces a worker that exits, and stops all of them when you dispose it. You choose two things from standard classes: when the workers start (a startup) and how many run (a sizing).
+
+The words in these documents have one meaning each. See the glossary in [CONTEXT.md](./CONTEXT.md).
+
+## Lend a worker to a job
+
+```ts
+import { Fixed, Parallel, Pool } from '@zukhruf/pool';
+
+await using pool = new Pool({
+  size: new Fixed(2),
+  startup: new Parallel(),
+  create: () => new VisionWorker('/path/to/vision-worker'),
+});
+const text = await pool.use((worker) => worker.read('/tmp/receipt.png'));
+```
+
+A worker gives `exited()`, `kill()`, `close()`, and optionally `ready()`. A `Coprocess` of `@zukhruf/coprocess` has all of them. When a signal aborts a job that runs, the pool kills its worker. When a signal aborts a job whose worker still warms up, the warm-up continues for the next job.
+
+## Choose when the workers start
+
+| Startup        | Starts                                                                                                                                                     |
+| -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `OnDemand`     | a worker only when a job needs one                                                                                                                         |
+| `Parallel`     | every worker when you build the pool, all together                                                                                                         |
+| `OrderedReady` | every worker when you build the pool, one after the other, as Kubernetes starts an `OrderedReady` StatefulSet                                              |
+| `LeaderFirst`  | the first worker alone, and the others together when it is ready. Use it when the first worker fills a cache that the others read, such as compiled models |
+
+## Choose how many workers run
+
+| Sizing                              | Runs                                                                                                                   |
+| ----------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
+| `Fixed(n)`                          | n workers                                                                                                              |
+| `Resources({ memoryPerWorker })`    | one for each CPU, while each finds its memory free                                                                     |
+| `HillClimbing({ memoryPerWorker })` | two first, and one more while the last one added at least a tenth more jobs a second (as the .NET thread pool)         |
+| `Gradient({ memoryPerWorker })`     | two first, and one more while a job takes at most half again the time it took with two (as Netflix concurrency-limits) |
+
+The two sizings that learn measure only while jobs wait and every worker is ready, in windows of at least 20 jobs and 2 seconds. They learn once, and never pass what the computer can give. See [ADR 0002](./docs/adr/0002-a-sizing-that-learns-compares-one-more-worker-between-two-windows.md).
+
+## Decisions
+
+- [ADR 0001](./docs/adr/0001-startups-and-sizings-are-classes-that-a-caller-chooses.md): startups and sizings are classes that a caller chooses.
+- [ADR 0002](./docs/adr/0002-a-sizing-that-learns-compares-one-more-worker-between-two-windows.md): a sizing that learns compares one more worker between two windows.
+- [ADR 0003](./docs/adr/0003-the-pool-learns-that-a-worker-ended-from-its-exit.md): the pool learns that a worker ended from its exit.

package/dist/capacity.d.ts

@@ -0,0 +1,2 @@
+export declare function capacity(memoryPerWorker: number): number;
+//# sourceMappingURL=capacity.d.ts.map

package/dist/capacity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"capacity.d.ts","sourceRoot":"","sources":["../src/capacity.ts"],"names":[],"mappings":"AAIA,wBAAgB,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAQxD"}

package/dist/capacity.js

@@ -0,0 +1,7 @@
+import { availableParallelism } from 'node:os';
+// The workers this Mac affords: one per CPU, as long as each still finds its
+// memory free.
+export function capacity(memoryPerWorker) {
+    return Math.max(1, Math.min(availableParallelism(), Math.floor(process.availableMemory() / memoryPerWorker)));
+}
+//# sourceMappingURL=capacity.js.map

package/dist/capacity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capacity.js","sourceRoot":"","sources":["../src/capacity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAE/C,6EAA6E;AAC7E,eAAe;AACf,MAAM,UAAU,QAAQ,CAAC,eAAuB;IAC9C,OAAO,IAAI,CAAC,GAAG,CACb,CAAC,EACD,IAAI,CAAC,GAAG,CACN,oBAAoB,EAAE,EACtB,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,eAAe,EAAE,GAAG,eAAe,CAAC,CACxD,CACF,CAAC;AACJ,CAAC"}

package/dist/climbing.d.ts

@@ -0,0 +1,19 @@
+import type { Sample, Sizing } from './sizing.ts';
+export interface Window {
+    readonly jobs: number;
+    readonly span: number;
+    readonly busy: number;
+}
+export declare abstract class Climbing implements Sizing {
+    #private;
+    readonly ceiling: number;
+    constructor(options: {
+        memoryPerWorker: number;
+    });
+    get current(): number;
+    get kept(): number;
+    record({ started, finished, measurable }: Sample): void;
+    protected abstract measure(window: Window): number;
+    protected abstract pays(ratio: number): boolean;
+}
+//# sourceMappingURL=climbing.d.ts.map

package/dist/climbing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"climbing.d.ts","sourceRoot":"","sources":["../src/climbing.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAQlD,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAUD,8BAAsB,QAAS,YAAW,MAAM;;IAC9C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;gBASb,OAAO,EAAE;QAAE,eAAe,EAAE,MAAM,CAAA;KAAE;IAMhD,IAAI,OAAO,IAAI,MAAM,CAEpB;IAID,IAAI,IAAI,IAAI,MAAM,CAIjB;IAED,MAAM,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,EAAE,MAAM,GAAG,IAAI;IAkCvD,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAIlD,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;CAChD"}

package/dist/climbing.js

@@ -0,0 +1,77 @@
+import { capacity } from "./capacity.js";
+// A window of jobs ends after both, so the sizes of the files it held do not
+// decide alone.
+const jobs = 20;
+const span = 2_000;
+// Finds how many workers pay by trying one more. Work that changes while it
+// is measured, as when files arrive grouped by kind, would decide a plain
+// before and after, so each step measures in the order A, B, A: a window at
+// the size that pays so far, one at a size larger, and one back at the first
+// size. The larger size pays when its window compared to the mean of both
+// first windows passes the variant's test. Pools start with two workers,
+// learn once, and never pass the Mac's capacity. Variants say what a window
+// measures and what passes.
+export class Climbing {
+    ceiling;
+    #size;
+    #step;
+    #before = 0;
+    #more = 0;
+    #first = 0;
+    #count = 0;
+    #busy = 0;
+    constructor(options) {
+        this.ceiling = capacity(options.memoryPerWorker);
+        this.#size = Math.min(2, this.ceiling);
+        this.#step = this.#size < this.ceiling ? 'before' : 'settled';
+    }
+    get current() {
+        return this.#step === 'more' ? this.#size + 1 : this.#size;
+    }
+    // The worker the step tries stays alive while the step measures the size
+    // before it again.
+    get kept() {
+        return this.#step === 'more' || this.#step === 'after'
+            ? this.#size + 1
+            : this.#size;
+    }
+    record({ started, finished, measurable }) {
+        if (this.#step === 'settled')
+            return;
+        if (!measurable) {
+            this.#restart();
+            return;
+        }
+        if (this.#count === 0)
+            this.#first = finished;
+        this.#count++;
+        this.#busy += finished - started;
+        if (this.#count < jobs || finished - this.#first < span)
+            return;
+        const value = this.measure({
+            jobs: this.#count,
+            span: finished - this.#first,
+            busy: this.#busy,
+        });
+        this.#restart();
+        if (this.#step === 'before') {
+            this.#before = value;
+            this.#step = 'more';
+        }
+        else if (this.#step === 'more') {
+            this.#more = value;
+            this.#step = 'after';
+        }
+        else if (this.pays(this.#more / ((this.#before + value) / 2))) {
+            this.#size++;
+            this.#step = this.#size < this.ceiling ? 'before' : 'settled';
+        }
+        else
+            this.#step = 'settled';
+    }
+    #restart() {
+        this.#count = 0;
+        this.#busy = 0;
+    }
+}
+//# sourceMappingURL=climbing.js.map

package/dist/climbing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"climbing.js","sourceRoot":"","sources":["../src/climbing.ts"],"names":[],"mappings":"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"}

package/dist/fixed.d.ts

@@ -0,0 +1,9 @@
+import type { Sizing } from './sizing.ts';
+export declare class Fixed implements Sizing {
+    readonly ceiling: number;
+    readonly current: number;
+    readonly kept: number;
+    constructor(workers: number);
+    record(): void;
+}
+//# sourceMappingURL=fixed.d.ts.map

package/dist/fixed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixed.d.ts","sourceRoot":"","sources":["../src/fixed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAI1C,qBAAa,KAAM,YAAW,MAAM;IAClC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAEV,OAAO,EAAE,MAAM;IAM3B,MAAM,IAAI,IAAI;CACf"}

package/dist/fixed.js

@@ -0,0 +1,14 @@
+// Runs exactly the given number of workers, as Kubernetes runs a fixed number
+// of replicas.
+export class Fixed {
+    ceiling;
+    current;
+    kept;
+    constructor(workers) {
+        this.ceiling = workers;
+        this.current = workers;
+        this.kept = workers;
+    }
+    record() { }
+}
+//# sourceMappingURL=fixed.js.map

package/dist/fixed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixed.js","sourceRoot":"","sources":["../src/fixed.ts"],"names":[],"mappings":"AAEA,8EAA8E;AAC9E,eAAe;AACf,MAAM,OAAO,KAAK;IACP,OAAO,CAAS;IAChB,OAAO,CAAS;IAChB,IAAI,CAAS;IAEtB,YAAY,OAAe;QACzB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC;IACtB,CAAC;IAED,MAAM,KAAU,CAAC;CAClB"}

package/dist/gradient.d.ts

@@ -0,0 +1,7 @@
+import { Climbing, type Window } from './climbing.ts';
+export declare class Gradient extends Climbing {
+    #private;
+    protected measure({ jobs, busy }: Window): number;
+    protected pays(ratio: number): boolean;
+}
+//# sourceMappingURL=gradient.d.ts.map

package/dist/gradient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gradient.d.ts","sourceRoot":"","sources":["../src/gradient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAMtD,qBAAa,QAAS,SAAQ,QAAQ;;IAGpC,SAAS,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,MAAM,GAAG,MAAM;IAIjD,SAAS,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;CAKvC"}

package/dist/gradient.js

@@ -0,0 +1,18 @@
+import { Climbing } from "./climbing.js";
+// Finds how many workers pay by the time a job takes, as Netflix's
+// concurrency-limits Gradient does: one more worker pays while a job takes at
+// most half again the time it took with two. Past that, the workers queue for
+// something they share.
+export class Gradient extends Climbing {
+    #slowdown = 1;
+    measure({ jobs, busy }) {
+        return busy / jobs;
+    }
+    pays(ratio) {
+        if (this.#slowdown * ratio > 1.5)
+            return false;
+        this.#slowdown *= ratio;
+        return true;
+    }
+}
+//# sourceMappingURL=gradient.js.map

package/dist/gradient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gradient.js","sourceRoot":"","sources":["../src/gradient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAe,MAAM,eAAe,CAAC;AAEtD,mEAAmE;AACnE,8EAA8E;AAC9E,8EAA8E;AAC9E,wBAAwB;AACxB,MAAM,OAAO,QAAS,SAAQ,QAAQ;IACpC,SAAS,GAAG,CAAC,CAAC;IAEJ,OAAO,CAAC,EAAE,IAAI,EAAE,IAAI,EAAU;QACtC,OAAO,IAAI,GAAG,IAAI,CAAC;IACrB,CAAC;IAES,IAAI,CAAC,KAAa;QAC1B,IAAI,IAAI,CAAC,SAAS,GAAG,KAAK,GAAG,GAAG;YAAE,OAAO,KAAK,CAAC;QAC/C,IAAI,CAAC,SAAS,IAAI,KAAK,CAAC;QACxB,OAAO,IAAI,CAAC;IACd,CAAC;CACF"}

package/dist/hill-climbing.d.ts

@@ -0,0 +1,6 @@
+import { Climbing, type Window } from './climbing.ts';
+export declare class HillClimbing extends Climbing {
+    protected measure({ jobs, span }: Window): number;
+    protected pays(ratio: number): boolean;
+}
+//# sourceMappingURL=hill-climbing.d.ts.map

package/dist/hill-climbing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hill-climbing.d.ts","sourceRoot":"","sources":["../src/hill-climbing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAKtD,qBAAa,YAAa,SAAQ,QAAQ;IACxC,SAAS,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,MAAM,GAAG,MAAM;IAIjD,SAAS,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;CAGvC"}

package/dist/hill-climbing.js

@@ -0,0 +1,13 @@
+import { Climbing } from "./climbing.js";
+// Finds how many workers pay by their throughput, as the .NET thread pool
+// does (Hellerstein, Morrison and Eilebrecht, 2008): one more worker pays
+// while it adds at least a tenth more jobs a second.
+export class HillClimbing extends Climbing {
+    measure({ jobs, span }) {
+        return jobs / span;
+    }
+    pays(ratio) {
+        return ratio >= 1.1;
+    }
+}
+//# sourceMappingURL=hill-climbing.js.map

package/dist/hill-climbing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hill-climbing.js","sourceRoot":"","sources":["../src/hill-climbing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAe,MAAM,eAAe,CAAC;AAEtD,0EAA0E;AAC1E,0EAA0E;AAC1E,qDAAqD;AACrD,MAAM,OAAO,YAAa,SAAQ,QAAQ;IAC9B,OAAO,CAAC,EAAE,IAAI,EAAE,IAAI,EAAU;QACtC,OAAO,IAAI,GAAG,IAAI,CAAC;IACrB,CAAC;IAES,IAAI,CAAC,KAAa;QAC1B,OAAO,KAAK,IAAI,GAAG,CAAC;IACtB,CAAC;CACF"}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { Fixed } from './fixed.ts';
+export { Gradient } from './gradient.ts';
+export { HillClimbing } from './hill-climbing.ts';
+export { LeaderFirst } from './leader-first.ts';
+export { OnDemand } from './on-demand.ts';
+export { OrderedReady } from './ordered-ready.ts';
+export { Parallel } from './parallel.ts';
+export { Pool } from './pool.ts';
+export { Resources } from './resources.ts';
+export type { Sample, Sizing } from './sizing.ts';
+export type { Startup } from './startup.ts';
+export type { Worker } from './worker.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAClD,YAAY,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,YAAY,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,10 @@
+export { Fixed } from "./fixed.js";
+export { Gradient } from "./gradient.js";
+export { HillClimbing } from "./hill-climbing.js";
+export { LeaderFirst } from "./leader-first.js";
+export { OnDemand } from "./on-demand.js";
+export { OrderedReady } from "./ordered-ready.js";
+export { Parallel } from "./parallel.js";
+export { Pool } from "./pool.js";
+export { Resources } from "./resources.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/leader-first.d.ts

@@ -0,0 +1,7 @@
+import type { Startup } from './startup.ts';
+export declare class LeaderFirst implements Startup {
+    #private;
+    readonly eager = true;
+    turn(settled: Promise<void>): Promise<void>;
+}
+//# sourceMappingURL=leader-first.d.ts.map

package/dist/leader-first.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"leader-first.d.ts","sourceRoot":"","sources":["../src/leader-first.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAM5C,qBAAa,WAAY,YAAW,OAAO;;IACzC,QAAQ,CAAC,KAAK,QAAQ;IAStB,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;CAG5C"}

package/dist/leader-first.js

@@ -0,0 +1,19 @@
+import { Latch } from '@zukhruf/async';
+// Starts every worker when the pool is constructed. The first starts alone and
+// the others start together once it settles, as when the first worker fills a
+// cache that the others then read instead of rebuilding it. A replacement
+// after a crash starts at once, since the first creation has settled.
+export class LeaderFirst {
+    eager = true;
+    #leader = new Latch();
+    // The first creation leads; every later one waits for it.
+    #turn = (settled) => {
+        void settled.then(() => this.#leader.open());
+        this.#turn = () => this.#leader.wait();
+        return Promise.resolve();
+    };
+    turn(settled) {
+        return this.#turn(settled);
+    }
+}
+//# sourceMappingURL=leader-first.js.map

package/dist/leader-first.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"leader-first.js","sourceRoot":"","sources":["../src/leader-first.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAIvC,+EAA+E;AAC/E,8EAA8E;AAC9E,0EAA0E;AAC1E,sEAAsE;AACtE,MAAM,OAAO,WAAW;IACb,KAAK,GAAG,IAAI,CAAC;IACb,OAAO,GAAG,IAAI,KAAK,EAAE,CAAC;IAC/B,0DAA0D;IAC1D,KAAK,GAAG,CAAC,OAAsB,EAAiB,EAAE;QAChD,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;QAC7C,IAAI,CAAC,KAAK,GAAG,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;QACvC,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC,CAAC;IAEF,IAAI,CAAC,OAAsB;QACzB,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAC7B,CAAC;CACF"}

package/dist/on-demand.d.ts

@@ -0,0 +1,6 @@
+import type { Startup } from './startup.ts';
+export declare class OnDemand implements Startup {
+    readonly eager = false;
+    turn(): Promise<void>;
+}
+//# sourceMappingURL=on-demand.d.ts.map

package/dist/on-demand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"on-demand.d.ts","sourceRoot":"","sources":["../src/on-demand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAI5C,qBAAa,QAAS,YAAW,OAAO;IACtC,QAAQ,CAAC,KAAK,SAAS;IAEvB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAGtB"}

package/dist/on-demand.js

@@ -0,0 +1,9 @@
+// Starts a worker only when a job needs one, so a pool nobody uses costs
+// nothing.
+export class OnDemand {
+    eager = false;
+    turn() {
+        return Promise.resolve();
+    }
+}
+//# sourceMappingURL=on-demand.js.map

package/dist/on-demand.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"on-demand.js","sourceRoot":"","sources":["../src/on-demand.ts"],"names":[],"mappings":"AAEA,yEAAyE;AACzE,WAAW;AACX,MAAM,OAAO,QAAQ;IACV,KAAK,GAAG,KAAK,CAAC;IAEvB,IAAI;QACF,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;CACF"}

package/dist/ordered-ready.d.ts

@@ -0,0 +1,7 @@
+import type { Startup } from './startup.ts';
+export declare class OrderedReady implements Startup {
+    #private;
+    readonly eager = true;
+    turn(settled: Promise<void>): Promise<void>;
+}
+//# sourceMappingURL=ordered-ready.d.ts.map

package/dist/ordered-ready.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ordered-ready.d.ts","sourceRoot":"","sources":["../src/ordered-ready.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAK5C,qBAAa,YAAa,YAAW,OAAO;;IAC1C,QAAQ,CAAC,KAAK,QAAQ;IAGtB,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;CAQ5C"}

package/dist/ordered-ready.js

@@ -0,0 +1,17 @@
+import PQueue from 'p-queue';
+// Starts every worker when the pool is constructed, one at a time: each
+// creation waits until the previous one settles, as Kubernetes starts the
+// pods of an OrderedReady StatefulSet.
+export class OrderedReady {
+    eager = true;
+    #queue = new PQueue({ concurrency: 1 });
+    turn(settled) {
+        const turn = Promise.withResolvers();
+        void this.#queue.add(() => {
+            turn.resolve();
+            return settled;
+        });
+        return turn.promise;
+    }
+}
+//# sourceMappingURL=ordered-ready.js.map

package/dist/ordered-ready.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ordered-ready.js","sourceRoot":"","sources":["../src/ordered-ready.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,SAAS,CAAC;AAI7B,wEAAwE;AACxE,0EAA0E;AAC1E,uCAAuC;AACvC,MAAM,OAAO,YAAY;IACd,KAAK,GAAG,IAAI,CAAC;IACb,MAAM,GAAG,IAAI,MAAM,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC,CAAC;IAEjD,IAAI,CAAC,OAAsB;QACzB,MAAM,IAAI,GAAG,OAAO,CAAC,aAAa,EAAQ,CAAC;QAC3C,KAAK,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE;YACxB,IAAI,CAAC,OAAO,EAAE,CAAC;YACf,OAAO,OAAO,CAAC;QACjB,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;CACF"}

package/dist/parallel.d.ts

@@ -0,0 +1,6 @@
+import type { Startup } from './startup.ts';
+export declare class Parallel implements Startup {
+    readonly eager = true;
+    turn(): Promise<void>;
+}
+//# sourceMappingURL=parallel.d.ts.map

package/dist/parallel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallel.d.ts","sourceRoot":"","sources":["../src/parallel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAG5C,qBAAa,QAAS,YAAW,OAAO;IACtC,QAAQ,CAAC,KAAK,QAAQ;IAEtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAGtB"}

package/dist/parallel.js

@@ -0,0 +1,8 @@
+// Starts every worker when the pool is constructed, all at the same time.
+export class Parallel {
+    eager = true;
+    turn() {
+        return Promise.resolve();
+    }
+}
+//# sourceMappingURL=parallel.js.map

package/dist/parallel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallel.js","sourceRoot":"","sources":["../src/parallel.ts"],"names":[],"mappings":"AAEA,0EAA0E;AAC1E,MAAM,OAAO,QAAQ;IACV,KAAK,GAAG,IAAI,CAAC;IAEtB,IAAI;QACF,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;CACF"}

package/dist/pool.d.ts

@@ -0,0 +1,15 @@
+import type { Sizing } from './sizing.ts';
+import type { Startup } from './startup.ts';
+import type { Worker } from './worker.ts';
+export declare class Pool<T extends Worker> implements AsyncDisposable {
+    #private;
+    constructor(options: {
+        size: Sizing;
+        startup: Startup;
+        create: () => T;
+    });
+    ready(): Promise<void>;
+    use<R>(job: (worker: T) => Promise<R>, signal?: AbortSignal): Promise<R>;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+//# sourceMappingURL=pool.d.ts.map

package/dist/pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool.d.ts","sourceRoot":"","sources":["../src/pool.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAuB1C,qBAAa,IAAI,CAAC,CAAC,SAAS,MAAM,CAAE,YAAW,eAAe;;gBAahD,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE;IAoBlE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAO5B,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC,CAAC;IAwKlE,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC;CAM7C"}

package/dist/pool.js

@@ -0,0 +1,217 @@
+import PQueue from 'p-queue';
+import { Latch, untilAborted } from '@zukhruf/async';
+// Lends workers to jobs, one job per worker at a time. The sizing decides how
+// many workers run and the startup when they start. A worker that exits is
+// replaced: at once when the startup is eager and the worker was idle,
+// otherwise when a job next needs its slot. The owner disposes the pool,
+// which stops every worker.
+export class Pool {
+    #create;
+    #startup;
+    #sizing;
+    #queue;
+    #slots;
+    #lent = new Set();
+    #workers = new Set();
+    #stopped = new AbortController();
+    #started = new Latch();
+    // When the pool last changed how many workers it runs.
+    #resized = performance.now();
+    constructor(options) {
+        this.#create = options.create;
+        this.#startup = options.startup;
+        this.#sizing = options.size;
+        this.#queue = new PQueue({ concurrency: this.#sizing.current });
+        this.#slots = Array.from({ length: this.#sizing.ceiling }, (_, index) => ({
+            index,
+            state: { kind: 'empty' },
+        }));
+        const outcomes = options.startup.eager
+            ? this.#running().map((slot) => this.#spawn(slot))
+            : [];
+        Promise.all(outcomes.map((outcome) => settled(outcome))).then(() => this.#started.open({ status: 'fulfilled', value: undefined }), (reason) => this.#started.open({ status: 'rejected', reason }));
+    }
+    // Settles when the workers the startup starts with the pool are ready, and
+    // rejects when one of them fails to start.
+    async ready() {
+        const outcome = await this.#started.wait();
+        if (outcome.status === 'rejected')
+            throw outcome.reason;
+    }
+    // A job aborted while it runs kills its worker. A job aborted while its
+    // worker warms up leaves the warm-up running for the jobs after it.
+    use(job, signal) {
+        const stop = signal === undefined
+            ? this.#stopped.signal
+            : AbortSignal.any([this.#stopped.signal, signal]);
+        if (stop.aborted)
+            return Promise.reject(stop.reason);
+        // The queue does not take the signal: on abort it would free the slot
+        // while the job still holds its worker.
+        return this.#queue.add(async () => {
+            stop.throwIfAborted();
+            const slot = this.#running().find((free) => !this.#lent.has(free));
+            this.#lent.add(slot);
+            try {
+                const worker = await untilAborted(this.#borrow(slot), stop);
+                const kill = () => {
+                    worker.kill();
+                    this.#lose(slot, worker);
+                };
+                stop.addEventListener('abort', kill, { once: true });
+                const started = performance.now();
+                try {
+                    const result = await job(worker);
+                    stop.throwIfAborted();
+                    return result;
+                }
+                catch (error) {
+                    stop.throwIfAborted();
+                    throw error;
+                }
+                finally {
+                    stop.removeEventListener('abort', kill);
+                    if (!stop.aborted)
+                        this.#record(started);
+                }
+            }
+            finally {
+                this.#lent.delete(slot);
+                if (slot.index >= this.#sizing.kept)
+                    this.#retire(slot);
+            }
+        });
+    }
+    #running() {
+        return this.#slots.slice(0, this.#sizing.current);
+    }
+    async #borrow(slot) {
+        const state = slot.state;
+        if (state.kind === 'ready')
+            return state.worker;
+        if (state.kind === 'lost') {
+            slot.state = { kind: 'empty' };
+            void this.#close(state.worker);
+        }
+        const worker = await settled(state.kind === 'starting' ? state.outcome : this.#spawn(slot));
+        const now = slot.state;
+        if (now.kind === 'ready' && now.worker === worker)
+            return worker;
+        // The worker exited between its start and this borrow.
+        return this.#borrow(slot);
+    }
+    // A job measures how many workers pay only if, since it started, the pool
+    // ran the same number of workers and each was ready, and another job waited
+    // when it finished.
+    #record(started) {
+        const steady = this.#steady();
+        this.#sizing.record({
+            started,
+            finished: performance.now(),
+            measurable: steady !== undefined && started >= steady && this.#queue.size > 0,
+        });
+        for (const slot of this.#slots.slice(this.#sizing.kept))
+            this.#retire(slot);
+        if (this.#sizing.current === this.#queue.concurrency)
+            return;
+        this.#queue.concurrency = this.#sizing.current;
+        this.#resized = performance.now();
+        for (const slot of this.#running())
+            if (slot.state.kind === 'empty')
+                this.#spawn(slot);
+    }
+    // Since when every slot the pool runs has had a ready worker, if they have.
+    #steady() {
+        let since = this.#resized;
+        for (const { state } of this.#running()) {
+            if (state.kind !== 'ready')
+                return undefined;
+            since = Math.max(since, state.since);
+        }
+        return since;
+    }
+    #spawn(slot) {
+        const outcome = new Latch();
+        slot.state = { kind: 'starting', outcome };
+        const turn = Promise.withResolvers();
+        this.#startup
+            .turn(turn.promise)
+            .then(async () => {
+            this.#stopped.signal.throwIfAborted();
+            const worker = this.#create();
+            this.#workers.add(worker);
+            try {
+                await worker.ready?.();
+                return worker;
+            }
+            catch (error) {
+                worker.kill();
+                await this.#close(worker);
+                throw error;
+            }
+        })
+            .then((worker) => {
+            if (slot.state.kind === 'starting' && slot.state.outcome === outcome)
+                slot.state = { kind: 'ready', worker, since: performance.now() };
+            outcome.open({ status: 'fulfilled', value: worker });
+            turn.resolve();
+            void worker.exited().then(() => this.#ended(slot, worker));
+        }, (reason) => {
+            if (slot.state.kind === 'starting' && slot.state.outcome === outcome)
+                slot.state = { kind: 'empty' };
+            outcome.open({ status: 'rejected', reason });
+            turn.resolve();
+        });
+        return outcome;
+    }
+    // The pool killed the worker of a slot: no job may borrow it any more.
+    #lose(slot, worker) {
+        if (slot.state.kind === 'ready' && slot.state.worker === worker)
+            slot.state = { kind: 'lost', worker };
+    }
+    #ended(slot, worker) {
+        const state = slot.state;
+        if ((state.kind !== 'ready' && state.kind !== 'lost') ||
+            state.worker !== worker)
+            return;
+        slot.state = { kind: 'lost', worker };
+        if (this.#lent.has(slot) ||
+            this.#stopped.signal.aborted ||
+            !this.#startup.eager)
+            return;
+        slot.state = { kind: 'empty' };
+        void this.#close(worker);
+        if (slot.index < this.#sizing.current)
+            this.#spawn(slot);
+    }
+    // Closes the worker of a slot the pool no longer keeps, once its job ends.
+    #retire(slot) {
+        if (this.#lent.has(slot))
+            return;
+        const state = slot.state;
+        slot.state = { kind: 'empty' };
+        if (state.kind === 'ready' || state.kind === 'lost')
+            void this.#close(state.worker);
+        else if (state.kind === 'starting')
+            void settled(state.outcome).then((worker) => this.#close(worker), () => undefined);
+    }
+    async #close(worker) {
+        await worker.close();
+        this.#workers.delete(worker);
+    }
+    async [Symbol.asyncDispose]() {
+        this.#stopped.abort();
+        for (const worker of this.#workers)
+            worker.kill();
+        await Promise.all([...this.#workers].map((worker) => worker.close()));
+        await this.#queue.onIdle();
+    }
+}
+// The worker a creation gave, or its failure.
+async function settled(outcome) {
+    const result = await outcome.wait();
+    if (result.status === 'rejected')
+        throw result.reason;
+    return result.value;
+}
+//# sourceMappingURL=pool.js.map

package/dist/pool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool.js","sourceRoot":"","sources":["../src/pool.ts"],"names":[],"mappings":"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"}

package/dist/resources.d.ts

@@ -0,0 +1,11 @@
+import type { Sizing } from './sizing.ts';
+export declare class Resources implements Sizing {
+    readonly ceiling: number;
+    readonly current: number;
+    readonly kept: number;
+    constructor(options: {
+        memoryPerWorker: number;
+    });
+    record(): void;
+}
+//# sourceMappingURL=resources.d.ts.map

package/dist/resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resources.d.ts","sourceRoot":"","sources":["../src/resources.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAI1C,qBAAa,SAAU,YAAW,MAAM;IACtC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;gBAEV,OAAO,EAAE;QAAE,eAAe,EAAE,MAAM,CAAA;KAAE;IAMhD,MAAM,IAAI,IAAI;CACf"}

package/dist/resources.js

@@ -0,0 +1,15 @@
+import { capacity } from "./capacity.js";
+// Runs as many workers as the Mac affords when the pool is built: one per
+// CPU, while each finds memoryPerWorker free.
+export class Resources {
+    ceiling;
+    current;
+    kept;
+    constructor(options) {
+        this.ceiling = capacity(options.memoryPerWorker);
+        this.current = this.ceiling;
+        this.kept = this.ceiling;
+    }
+    record() { }
+}
+//# sourceMappingURL=resources.js.map

package/dist/resources.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resources.js","sourceRoot":"","sources":["../src/resources.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAGzC,0EAA0E;AAC1E,8CAA8C;AAC9C,MAAM,OAAO,SAAS;IACX,OAAO,CAAS;IAChB,OAAO,CAAS;IAChB,IAAI,CAAS;IAEtB,YAAY,OAAoC;QAC9C,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;QACjD,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAC5B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC;IAC3B,CAAC;IAED,MAAM,KAAU,CAAC;CAClB"}

package/dist/sizing.d.ts

@@ -0,0 +1,12 @@
+export interface Sample {
+    readonly started: number;
+    readonly finished: number;
+    readonly measurable: boolean;
+}
+export interface Sizing {
+    readonly ceiling: number;
+    readonly current: number;
+    readonly kept: number;
+    record(sample: Sample): void;
+}
+//# sourceMappingURL=sizing.d.ts.map

package/dist/sizing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sizing.d.ts","sourceRoot":"","sources":["../src/sizing.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;CAC9B;AAQD,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B"}

package/dist/sizing.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sizing.js.map

package/dist/sizing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sizing.js","sourceRoot":"","sources":["../src/sizing.ts"],"names":[],"mappings":""}

package/dist/startup.d.ts

@@ -0,0 +1,5 @@
+export interface Startup {
+    readonly eager: boolean;
+    turn(settled: Promise<void>): Promise<void>;
+}
+//# sourceMappingURL=startup.d.ts.map

package/dist/startup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"startup.d.ts","sourceRoot":"","sources":["../src/startup.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IAGxB,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7C"}

package/dist/startup.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=startup.js.map

package/dist/startup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"startup.js","sourceRoot":"","sources":["../src/startup.ts"],"names":[],"mappings":""}

package/dist/worker.d.ts

@@ -0,0 +1,7 @@
+export interface Worker {
+    ready?(): Promise<unknown>;
+    exited(): Promise<unknown>;
+    kill(): void;
+    close(): Promise<void>;
+}
+//# sourceMappingURL=worker.d.ts.map

package/dist/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../src/worker.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,MAAM;IACrB,KAAK,CAAC,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3B,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3B,IAAI,IAAI,IAAI,CAAC;IACb,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB"}

package/dist/worker.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=worker.js.map

package/dist/worker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.js","sourceRoot":"","sources":["../src/worker.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,47 @@
 {
   "name": "@zukhruf/pool",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.43",
+  "description": "Lend long-lived workers, such as native helper processes, to one job at a time: startups that decide when workers start, sizings that decide how many run, and replacement of a worker that exits.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/JanuaryLabs/zukhruf",
+    "directory": "packages/pool"
+  },
+  "bugs": {
+    "url": "https://github.com/JanuaryLabs/zukhruf/issues"
+  },
+  "homepage": "https://github.com/JanuaryLabs/zukhruf/tree/main/packages/pool#readme",
+  "keywords": [
+    "pool",
+    "worker-pool",
+    "resource-pool",
+    "concurrency",
+    "hill-climbing",
+    "capacity",
+    "child-process"
+  ],
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@zukhruf/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/spec/**",
+    "!**/*.tsbuildinfo",
+    "!**/*.test.*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@zukhruf/async": "^0.3.43",
+    "p-queue": "10.0.0"
+  }
+}