@plitzi/sdk-server 0.37.2 → 0.37.4

package/dist/core/server/fleet/channel.js

@@ -0,0 +1,191 @@
+//#region src/core/server/fleet/channel.ts
+var isRecord = (value) => typeof value === "object" && value !== null;
+/** The channel is shared with `node:cluster` and anything else the deployment sends: only these are ours. */
+var isFleetMessage = (value) => {
+	if (!isRecord(value)) return false;
+	if (value.sdkFleet === "call") return typeof value.id === "number" && typeof value.store === "string" && typeof value.method === "string" && Array.isArray(value.args);
+	if (value.sdkFleet === "reply") return typeof value.id === "number" && typeof value.ok === "boolean";
+	if (value.sdkFleet === "broadcast") return typeof value.channel === "string";
+	return false;
+};
+var hostable = (create, methods) => ({
+	create,
+	methods: new Set(Object.keys(methods))
+});
+/**
+* The primary's side: the stores it keeps for its workers, answering their calls.
+*
+* A worker names a store `<kind>#<n>` — the n-th of that kind its code built, the same in every worker since they
+* all run the same code — and the primary makes it from the catalogue the first time it is asked. Nothing is made
+* that no worker uses. A call names a method the kind was registered with and nothing else: the channel is not a way
+* to reach whatever the object happens to carry.
+*/
+var createStoreHost = (catalogue) => {
+	const instances = /* @__PURE__ */ new Map();
+	const storeFor = (key) => {
+		const existing = instances.get(key);
+		if (existing) return existing;
+		const kind = key.slice(0, key.lastIndexOf("#"));
+		if (!Object.hasOwn(catalogue, kind)) return;
+		const { create, methods } = catalogue[kind];
+		const made = {
+			instance: create(),
+			methods
+		};
+		instances.set(key, made);
+		return made;
+	};
+	const answer = async (call) => {
+		const store = storeFor(call.store);
+		const method = store?.methods.has(call.method) ? Reflect.get(store.instance, call.method) : void 0;
+		if (!store || typeof method !== "function") return {
+			sdkFleet: "reply",
+			id: call.id,
+			ok: false,
+			error: `the primary holds no store "${call.store}" with a method "${call.method}"`
+		};
+		try {
+			const value = await Reflect.apply(method, store.instance, call.args);
+			return {
+				sdkFleet: "reply",
+				id: call.id,
+				ok: true,
+				value
+			};
+		} catch (error) {
+			return {
+				sdkFleet: "reply",
+				id: call.id,
+				ok: false,
+				error: error instanceof Error ? error.message : String(error)
+			};
+		}
+	};
+	return { answer };
+};
+/** Who in this process hears a broadcast, by channel. A listener that throws is the caller's to report. */
+var createListeners = (onError) => {
+	const listeners = /* @__PURE__ */ new Map();
+	const listen = (channel, listener) => {
+		const set = listeners.get(channel) ?? /* @__PURE__ */ new Set();
+		set.add(listener);
+		listeners.set(channel, set);
+		return () => set.delete(listener);
+	};
+	const deliver = (channel, payload) => {
+		listeners.get(channel)?.forEach((listener) => {
+			try {
+				listener(payload);
+			} catch (error) {
+				onError(channel, error);
+			}
+		});
+	};
+	return {
+		listen,
+		deliver
+	};
+};
+/**
+* A worker's side: calls to the primary's stores, and broadcasts both ways.
+*
+* `send` may throw — a value that cannot cross the channel, a primary already gone — and the call then fails
+* rather than waiting for an answer that will not come. The same when the channel closes with calls in flight.
+*/
+var createFleetClient = (send, deliver) => {
+	const pending = /* @__PURE__ */ new Map();
+	let nextId = 0;
+	let closed = false;
+	const call = (store, method, args) => {
+		if (closed) return Promise.reject(/* @__PURE__ */ new Error(`[fleet] ${store}.${method}: the primary is gone`));
+		nextId += 1;
+		const id = nextId;
+		return new Promise((resolve, reject) => {
+			pending.set(id, {
+				resolve,
+				reject
+			});
+			try {
+				send({
+					sdkFleet: "call",
+					id,
+					store,
+					method,
+					args
+				});
+			} catch (error) {
+				pending.delete(id);
+				reject(new Error(`[fleet] ${store}.${method} could not be sent to the primary`, { cause: error }));
+			}
+		});
+	};
+	/** Every method of the store, each a call to the copy the primary keeps. */
+	const remote = (store, methods) => Object.fromEntries(Object.keys(methods).map((method) => [method, (...args) => call(store, method, args)]));
+	const broadcast = (channel, payload) => {
+		if (!closed) send({
+			sdkFleet: "broadcast",
+			channel,
+			payload
+		});
+	};
+	const receive = (message) => {
+		if (message.sdkFleet === "reply") {
+			const waiting = pending.get(message.id);
+			pending.delete(message.id);
+			if (message.ok) waiting?.resolve(message.value);
+			else waiting?.reject(/* @__PURE__ */ new Error(`[fleet] ${message.error}`));
+			return;
+		}
+		if (message.sdkFleet === "broadcast") deliver(message.channel, message.payload);
+	};
+	const close = () => {
+		closed = true;
+		const waiting = [...pending.values()];
+		pending.clear();
+		waiting.forEach((entry) => entry.reject(/* @__PURE__ */ new Error("[fleet] the primary is gone")));
+	};
+	return {
+		call,
+		remote,
+		broadcast,
+		receive,
+		close
+	};
+};
+/**
+* The primary's side of the channel: it answers its workers' calls from the stores it holds, and passes each
+* broadcast on to every process that did not send it — itself included, so a server in the primary hears it too.
+*
+* A peer that went away between a call and its answer is simply not answered: it is not waiting any more.
+*/
+var createFleetHub = ({ host, deliver, peers }) => {
+	const sendTo = (peer, message) => {
+		try {
+			peer?.send(message);
+		} catch {}
+	};
+	const broadcast = (channel, payload, except) => {
+		peers().filter((peer) => peer.id !== except).forEach((peer) => sendTo(peer, {
+			sdkFleet: "broadcast",
+			channel,
+			payload
+		}));
+	};
+	const receive = async (from, message) => {
+		if (message.sdkFleet === "call") {
+			const reply = await host.answer(message);
+			sendTo(peers().find((peer) => peer.id === from), reply);
+			return;
+		}
+		if (message.sdkFleet === "broadcast") {
+			deliver(message.channel, message.payload);
+			broadcast(message.channel, message.payload, from);
+		}
+	};
+	return {
+		receive,
+		broadcast
+	};
+};
+//#endregion
+export { createFleetClient, createFleetHub, createListeners, createStoreHost, hostable, isFleetMessage };

package/dist/core/server/fleet/channel.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/server/fleet/fixtures/fleetServer.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/server/fleet/fleet.integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/server/fleet/link.d.ts

@@ -0,0 +1,23 @@
+import { HostedStore, Remote, StoreMethods } from './channel';
+/**
+ * This process's end of the fleet channel (`channel.ts`), over `node:cluster` — for a `primary` or a `worker`
+ * (`role.ts`). A single server never reaches past `fleetStore`, which answers it nothing.
+ */
+/** The stores a single process keeps in memory by default, which the workers of a fleet share (see `stores.ts`). */
+export type FleetStoreName = 'actions.kv' | 'realtime.grants' | 'actions.jobs' | 'ssr.drafts' | 'auth.rateLimit';
+/**
+ * The primary's hub: it answers its workers from the stores in `catalogue`, made when first asked for, and passes
+ * broadcasts on. Started before the first fork, so no worker can ask before anyone is answering.
+ */
+export declare const startHub: (catalogue: Readonly<Record<FleetStoreName, HostedStore>>) => void;
+/**
+ * In a worker, the primary's copy of a store a single server keeps in memory, reached over the channel. Anywhere
+ * else, nothing — so a call site reads `deployment's ?? fleetStore(…) ?? what a single server has always made`.
+ */
+export declare const fleetStore: <T extends object>(name: FleetStoreName, methods: StoreMethods<T>) => Remote<T> | undefined;
+/** A name for one server's broadcasts, the same in the primary and in each of its workers. */
+export declare const channelName: (label: string) => string;
+/** Tells every other process of the fleet. */
+export declare const broadcast: (channel: string, payload: unknown) => void;
+/** Hears what another process of the fleet broadcast on `channel`. */
+export declare const onBroadcast: (channel: string, listener: (payload: unknown) => void) => (() => void);

package/dist/core/server/fleet/link.js

@@ -0,0 +1,70 @@
+import { serverLog } from "../../../helpers/serverLog.js";
+import { createFleetClient, createFleetHub, createListeners, createStoreHost, isFleetMessage } from "./channel.js";
+import { isFleetWorker } from "./role.js";
+import cluster from "node:cluster";
+//#region src/core/server/fleet/link.ts
+var listeners = createListeners((channel, error) => serverLog.error("fleet", `a broadcast on "${channel}" failed here`, error));
+var client;
+var hub;
+var workerClient = () => {
+	if (client) return client;
+	const created = createFleetClient((message) => {
+		if (!process.send) throw new Error("this worker has no channel to its primary");
+		process.send(message);
+	}, listeners.deliver);
+	process.on("message", (message) => {
+		if (isFleetMessage(message)) created.receive(message);
+	});
+	process.once("disconnect", () => created.close());
+	client = created;
+	return created;
+};
+/**
+* The primary's hub: it answers its workers from the stores in `catalogue`, made when first asked for, and passes
+* broadcasts on. Started before the first fork, so no worker can ask before anyone is answering.
+*/
+var startHub = (catalogue) => {
+	if (hub) return;
+	const created = createFleetHub({
+		host: createStoreHost(catalogue),
+		deliver: listeners.deliver,
+		peers: () => Object.values(cluster.workers ?? {}).flatMap((worker) => worker?.isConnected() ? [{
+			id: worker.id,
+			send: (message) => worker.send(message)
+		}] : [])
+	});
+	cluster.on("message", (worker, message) => {
+		if (isFleetMessage(message)) created.receive(worker.id, message);
+	});
+	hub = created;
+};
+/** The n-th of a name this process asked for: the same code asks in the same order in every process of a fleet, so
+*  the n-th one is the same one everywhere. Counted only in a fleet — a single server never asks. */
+var seen = /* @__PURE__ */ new Map();
+var nextKey = (name) => {
+	const count = seen.get(name) ?? 0;
+	seen.set(name, count + 1);
+	return `${name}#${count}`;
+};
+/**
+* In a worker, the primary's copy of a store a single server keeps in memory, reached over the channel. Anywhere
+* else, nothing — so a call site reads `deployment's ?? fleetStore(…) ?? what a single server has always made`.
+*/
+var fleetStore = (name, methods) => isFleetWorker() ? workerClient().remote(nextKey(name), methods) : void 0;
+/** A name for one server's broadcasts, the same in the primary and in each of its workers. */
+var channelName = (label) => nextKey(label);
+/** Tells every other process of the fleet. */
+var broadcast = (channel, payload) => {
+	if (isFleetWorker()) {
+		workerClient().broadcast(channel, payload);
+		return;
+	}
+	hub?.broadcast(channel, payload);
+};
+/** Hears what another process of the fleet broadcast on `channel`. */
+var onBroadcast = (channel, listener) => {
+	if (isFleetWorker()) workerClient();
+	return listeners.listen(channel, listener);
+};
+//#endregion
+export { broadcast, channelName, fleetStore, onBroadcast, startHub };

package/dist/core/server/fleet/relay.d.ts

@@ -0,0 +1,11 @@
+import { CacheManager, PluginRegistry } from '@plitzi/sdk-shared';
+/** `invalidate` answers, and `size` counts, this process's entries: the others answer nothing back. */
+export declare const relayCache: (cache: CacheManager, channel: string) => CacheManager;
+/**
+ * A plugin registered or invalidated in one process is registered or forgotten in all of them. The files are
+ * shared — the process that invalidated removed them — so the others only drop what they remember (`forget`).
+ *
+ * A plugin registered with a `component` cannot be sent: a function does not cross between processes. It is
+ * registered where it was called, and said so, rather than silently missing from the other workers.
+ */
+export declare const relayPlugins: (plugins: PluginRegistry, forget: (name?: string, version?: string) => void, channel: string, label: string) => PluginRegistry;

package/dist/core/server/fleet/relay.js

@@ -0,0 +1,104 @@
+import { serverLog } from "../../../helpers/serverLog.js";
+import { broadcast, onBroadcast } from "./link.js";
+//#region src/core/server/fleet/relay.ts
+/**
+* `server.cache` and `server.plugins` in a fleet, whose workers each keep their own: what one process is told, every
+* other hears. A single server's are handed back unwrapped (`baseServer.ts`). The call that matters is the one that lands on a random worker — a publish webhook, a
+* `/revalidate` endpoint — and without this it would clear one worker's pages and leave the rest serving the old
+* ones until their TTL ran out.
+*
+* Code that runs in every process (a pub/sub subscription made where the server is created) is told N times; what
+* is relayed is safe to apply again, and cheap: it only drops entries from memory.
+*/
+var isRecord = (value) => typeof value === "object" && value !== null;
+var PLUGIN_ACTIONS = [
+	"copy",
+	"compile",
+	"download",
+	"cdn"
+];
+var isPluginAction = (value) => PLUGIN_ACTIONS.some((action) => action === value);
+var cacheFilterOf = (value) => {
+	if (!isRecord(value)) return {};
+	return {
+		...typeof value.spaceId === "number" ? { spaceId: value.spaceId } : {},
+		...typeof value.environment === "string" ? { environment: value.environment } : {},
+		...typeof value.hostname === "string" ? { hostname: value.hostname } : {}
+	};
+};
+/** `invalidate` answers, and `size` counts, this process's entries: the others answer nothing back. */
+var relayCache = (cache, channel) => {
+	onBroadcast(channel, (payload) => {
+		if (!isRecord(payload)) return;
+		if (payload.op === "clear") cache.clear();
+		else if (payload.op === "invalidate") cache.invalidate(cacheFilterOf(payload.filter));
+	});
+	return {
+		invalidate: (filter) => {
+			const count = cache.invalidate(filter);
+			broadcast(channel, {
+				op: "invalidate",
+				filter: filter ?? {}
+			});
+			return count;
+		},
+		clear: () => {
+			cache.clear();
+			broadcast(channel, { op: "clear" });
+		},
+		get size() {
+			return cache.size;
+		}
+	};
+};
+var pluginSourceOf = (value) => {
+	if (!isRecord(value) || typeof value.js !== "string") return;
+	return {
+		js: value.js,
+		...typeof value.css === "string" ? { css: value.css } : {},
+		...typeof value.version === "string" ? { version: value.version } : {},
+		...isPluginAction(value.action) ? { action: value.action } : {},
+		...isRecord(value.props) ? { props: value.props } : {}
+	};
+};
+var optionalString = (value) => typeof value === "string" ? value : void 0;
+/**
+* A plugin registered or invalidated in one process is registered or forgotten in all of them. The files are
+* shared — the process that invalidated removed them — so the others only drop what they remember (`forget`).
+*
+* A plugin registered with a `component` cannot be sent: a function does not cross between processes. It is
+* registered where it was called, and said so, rather than silently missing from the other workers.
+*/
+var relayPlugins = (plugins, forget, channel, label) => {
+	onBroadcast(channel, (payload) => {
+		if (!isRecord(payload)) return;
+		if (payload.op === "register" && typeof payload.name === "string") {
+			const source = pluginSourceOf(payload.source);
+			if (source) plugins.register(payload.name, source);
+		} else if (payload.op === "forget") forget(optionalString(payload.name), optionalString(payload.version));
+	});
+	return {
+		register: (name, source) => {
+			plugins.register(name, source);
+			if ("component" in source) {
+				serverLog.warn(label, `plugin "${name}" is a component: only this process has it. Register component plugins where the server is created, so every worker does.`);
+				return;
+			}
+			broadcast(channel, {
+				op: "register",
+				name,
+				source
+			});
+		},
+		invalidate: async (name, version) => {
+			await plugins.invalidate(name, version);
+			broadcast(channel, {
+				op: "forget",
+				name,
+				version
+			});
+		}
+	};
+};
+//#endregion
+export { relayCache, relayPlugins };

package/dist/core/server/fleet/relay.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/server/fleet/role.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Where a server decides whether it runs as one process or as several — the one fork between the two modes.
+ *
+ * - `single`: workers off, one asked for, or one core to run on. Everything is what it always was: the stores are
+ *   this process's own, `server.cache` is its own, nothing listens on a channel and nothing is forked.
+ * - `primary`: the process that was started, asked for more than one. It serves nothing: it forks the workers,
+ *   restarts the ones that die (`supervisor.ts`) and keeps, for all of them, the stores a single process keeps
+ *   in memory (`stores.ts`).
+ * - `worker`: forked by a primary. It serves, and reaches those stores — and tells the other workers what they must
+ *   hear — over the channel to its primary (`link.ts`).
+ *
+ * Every other file in this folder serves the last two; the rest of the server asks only `fleetRole`,
+ * `runsFleetJobs` and, for a store, `fleetStore` (which answers nothing outside a worker).
+ */
+export type WorkersOption = boolean | number | 'auto';
+export type WorkersPlan = {
+    /** The processes that will serve. */
+    count: number;
+    /** What was asked for, when it was more than the cores there are — and so was lowered to them. */
+    requested?: number;
+};
+/**
+ * How many processes serve the port.
+ *
+ * On by default in production — one per core the process may use, which `availableParallelism` reads from the
+ * container's CPU quota too, so a quarter-core container gets one. Off by default anywhere else: a development server
+ * under `--watch` or a debugger, and a test runner that starts servers in its own process, must stay one process.
+ * The config wins over `SDK_SERVER_WORKERS`, which wins over the default.
+ *
+ * A number is a ceiling, not a demand: more processes than cores only take turns on the same cores, each with its
+ * own memory, so it is lowered to the cores there are and the plan says it was.
+ */
+export declare const resolveWorkers: (option: WorkersOption | undefined, environment?: NodeJS.ProcessEnv, cores?: number) => WorkersPlan;
+/** The environment the primary gives a worker it forks — and the one worker that carries the fleet's jobs. */
+export declare const fleetWorkerEnv: (runsJobs: boolean) => Record<string, string>;
+export declare const isFleetWorker: () => boolean;
+export type FleetRole = 'single' | 'primary' | 'worker';
+export declare const fleetRole: (plan: WorkersPlan) => FleetRole;
+/**
+ * Whether this process runs the scheduler and the job consumers.
+ *
+ * A single server, yes, as it always did. Of a fleet, one worker only: its workers are one replica, and a replica's
+ * `jobs` settings — how many run at once, whether it schedules at all — are for the replica, not for each of its
+ * processes. The primary hands the role to the replacement of the worker that carried it.
+ */
+export declare const runsFleetJobs: () => boolean;

package/dist/core/server/fleet/role.js

@@ -0,0 +1,59 @@
+import cluster from "node:cluster";
+import { availableParallelism } from "node:os";
+//#region src/core/server/fleet/role.ts
+/** What the deployment's environment says, when its code says nothing: `SDK_SERVER_WORKERS=1`, `=auto`, `=false`. */
+var fromEnvironment = (raw) => {
+	if (raw === void 0 || raw.trim() === "") return;
+	const value = raw.trim().toLowerCase();
+	if (value === "auto" || value === "true") return "auto";
+	if (value === "false" || value === "off") return false;
+	return Number(value);
+};
+/**
+* How many processes serve the port.
+*
+* On by default in production — one per core the process may use, which `availableParallelism` reads from the
+* container's CPU quota too, so a quarter-core container gets one. Off by default anywhere else: a development server
+* under `--watch` or a debugger, and a test runner that starts servers in its own process, must stay one process.
+* The config wins over `SDK_SERVER_WORKERS`, which wins over the default.
+*
+* A number is a ceiling, not a demand: more processes than cores only take turns on the same cores, each with its
+* own memory, so it is lowered to the cores there are and the plan says it was.
+*/
+var resolveWorkers = (option, environment = process.env, cores = availableParallelism()) => {
+	const available = Math.max(1, cores);
+	const chosen = option ?? fromEnvironment(environment.SDK_SERVER_WORKERS) ?? (environment.NODE_ENV === "production" ? "auto" : false);
+	if (chosen === false) return { count: 1 };
+	if (chosen === true || chosen === "auto") return { count: available };
+	if (!Number.isInteger(chosen) || chosen < 1) throw new Error(`workers must be true, false, 'auto' or a whole number from 1 — got ${String(chosen)}`);
+	return chosen > available ? {
+		count: available,
+		requested: chosen
+	} : { count: chosen };
+};
+/**
+* Only a worker a primary of ours forked carries this: a process that is a cluster worker of something else —
+* PM2's cluster mode, a deployment's own `cluster.fork` — is a single server, with nobody to answer its calls.
+*/
+var FLEET_ENV = "SDK_SERVER_FLEET";
+var JOBS_ENV = "SDK_SERVER_FLEET_JOBS";
+/** The environment the primary gives a worker it forks — and the one worker that carries the fleet's jobs. */
+var fleetWorkerEnv = (runsJobs) => ({
+	[FLEET_ENV]: "1",
+	[JOBS_ENV]: runsJobs ? "1" : "0"
+});
+var isFleetWorker = () => cluster.isWorker && process.env[FLEET_ENV] === "1";
+var fleetRole = (plan) => {
+	if (isFleetWorker()) return "worker";
+	return plan.count > 1 && cluster.isPrimary ? "primary" : "single";
+};
+/**
+* Whether this process runs the scheduler and the job consumers.
+*
+* A single server, yes, as it always did. Of a fleet, one worker only: its workers are one replica, and a replica's
+* `jobs` settings — how many run at once, whether it schedules at all — are for the replica, not for each of its
+* processes. The primary hands the role to the replacement of the worker that carried it.
+*/
+var runsFleetJobs = () => !isFleetWorker() || process.env[JOBS_ENV] === "1";
+//#endregion
+export { fleetRole, fleetWorkerEnv, isFleetWorker, resolveWorkers, runsFleetJobs };

package/dist/core/server/fleet/role.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/core/server/fleet/stores.d.ts

@@ -0,0 +1,7 @@
+import { HostedStore } from './channel';
+import { FleetStoreName } from './link';
+/**
+ * What the primary keeps for its workers: the same in-memory defaults a single server makes for itself, made here
+ * once — when a worker first asks — so the fleet has one of each rather than one per worker.
+ */
+export declare const FLEET_STORES: Readonly<Record<FleetStoreName, HostedStore>>;

package/dist/core/server/fleet/stores.js

@@ -0,0 +1,19 @@
+import { JOB_QUEUE_METHODS, createMemoryJobQueue } from "../../../modules/actions/jobs/memoryQueue.js";
+import { hostable } from "./channel.js";
+import { KV_METHODS, createMemoryKv } from "../../../modules/actions/runtime/memoryKv.js";
+import { DRAFT_STORE_METHODS, createMemoryDraftStore } from "../../../modules/ssr/preview.js";
+import { RATE_LIMIT_METHODS, createMemoryRateLimit } from "../../auth/throttle.js";
+//#region src/core/server/fleet/stores.ts
+/**
+* What the primary keeps for its workers: the same in-memory defaults a single server makes for itself, made here
+* once — when a worker first asks — so the fleet has one of each rather than one per worker.
+*/
+var FLEET_STORES = {
+	"actions.kv": hostable(createMemoryKv, KV_METHODS),
+	"realtime.grants": hostable(createMemoryKv, KV_METHODS),
+	"actions.jobs": hostable(() => createMemoryJobQueue(), JOB_QUEUE_METHODS),
+	"ssr.drafts": hostable(createMemoryDraftStore, DRAFT_STORE_METHODS),
+	"auth.rateLimit": hostable(() => ({ check: createMemoryRateLimit() }), RATE_LIMIT_METHODS)
+};
+//#endregion
+export { FLEET_STORES };

package/dist/core/server/fleet/supervisor.d.ts

@@ -0,0 +1,26 @@
+export type Fleet = {
+    stop: () => Promise<void>;
+};
+/**
+ * How long the replacement for a dead worker waits, given how many have died in the last minute. As many deaths as
+ * there are workers — each of them crashing once — are replaced at once; past that it doubles from half a second, up
+ * to thirty.
+ */
+export declare const restartDelay: (deathsInWindow: number, count: number) => number;
+/**
+ * Starts `count` workers from this primary, each running the process's own entry point — so each builds and binds
+ * its own server on the shared port, and the connections are spread between them.
+ *
+ * A worker that dies is replaced, crash or kill alike, and the replacement takes over whatever the dead one carried
+ * (the jobs). Past one death per worker a minute the replacements wait, longer each time (`restartDelay`), so a
+ * request that crashes whichever worker takes it cannot turn the primary into a fork loop.
+ *
+ * Until the fleet has served at all, a death is not retried: a worker that dies before any has listened would die
+ * the same way again — a port in use, a broken build — so the fleet stops and the process exits non-zero for
+ * whatever supervises it. Once it has served, a replacement that fails to start is retried like any other death:
+ * the workers still serving keep serving through a passing failure (a database that is briefly down).
+ *
+ * `stop` asks every worker to finish with SIGTERM (what `closeOnSignals` answers) and waits for all of them. A
+ * primary that dies without stopping them takes them with it: a worker exits when its channel to the primary closes.
+ */
+export declare const startFleet: (count: number, label: string, exit?: (code: number) => void) => Fleet;