@dimina-kit/devkit 0.1.2-dev.20260703101348 → 0.1.2

package/dist/compile-worker-standby-hardening.test.js

@@ -0,0 +1,212 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { createCompileWorkerStandby, } from './compile-worker-standby.js';
+/**
+ * Hardening contracts for the warm-standby manager (see
+ * `compile-worker-standby.test.ts` for the base ensure/adopt/dispose
+ * contract and the ping/prewarm protocol fixtures speak).
+ *
+ * Group A: adopt() must only ever hand over a spare whose prewarm has
+ * actually completed — a spare still warming is not safe to use, and a
+ * spare that is handed over must not be silently orphaned by whatever
+ * outcome its still-in-flight prewarm eventually reports.
+ *
+ * Group B: dispose() must not leave a spare alive forever just because it
+ * traps SIGTERM — it escalates to SIGKILL after `disposeGraceMs`.
+ *
+ * These are real-fork tests: fixtures are scripted child entry scripts, and
+ * every "the spare died" / "the spare is still alive" check is a real OS
+ * PID check (`process.kill(pid, 0)`), not a spy on intent.
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function waitForPidDeath(pid, timeoutMs = 8000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!pidAlive(pid))
+            return true;
+        await sleep(100);
+    }
+    return !pidAlive(pid);
+}
+async function pollUntil(fn, timeoutMs, intervalMs = 50) {
+    const deadline = Date.now() + timeoutMs;
+    let last = fn();
+    while (!last && Date.now() < deadline) {
+        await sleep(intervalMs);
+        last = fn();
+    }
+    return last;
+}
+async function waitForState(standby, target, timeoutMs = 5000) {
+    await pollUntil(() => standby.state === target, timeoutMs);
+    return standby.state;
+}
+/** Answers ping normally; prewarm succeeds only after a delay, to give tests a window while state is still 'warming'. */
+const FIXTURE_DELAYED_PREWARM_OK = `
+process.on('message', (msg) => {
+	if (!msg) return
+	if (msg.cmd === 'ping') process.send({ type: 'pong', id: msg.id })
+	else if (msg.cmd === 'prewarm') {
+		setTimeout(() => process.send({ type: 'prewarm-result', id: msg.id, ok: true }), 1000)
+	}
+})
+`;
+/** Answers ping normally; prewarm reports failure only after a delay, to exercise the death path once already adopt()-attempted while warming. */
+const FIXTURE_DELAYED_PREWARM_FAIL = `
+process.on('message', (msg) => {
+	if (!msg) return
+	if (msg.cmd === 'ping') process.send({ type: 'pong', id: msg.id })
+	else if (msg.cmd === 'prewarm') {
+		setTimeout(() => process.send({ type: 'prewarm-result', id: msg.id, ok: false, error: 'delayed toolchain failure (scripted)' }), 800)
+	}
+})
+`;
+/** Answers both ping and prewarm immediately — the happy-path spare. */
+const FIXTURE_HAPPY = `
+process.on('message', (msg) => {
+	if (!msg) return
+	if (msg.cmd === 'ping') process.send({ type: 'pong', id: msg.id })
+	else if (msg.cmd === 'prewarm') process.send({ type: 'prewarm-result', id: msg.id, ok: true })
+})
+`;
+/** Traps SIGTERM and swallows it forever while still answering ping/prewarm normally — a spare that will not exit gracefully. */
+const FIXTURE_TRAP_SIGTERM = `
+process.on('SIGTERM', () => {})
+process.on('message', (msg) => {
+	if (!msg) return
+	if (msg.cmd === 'ping') process.send({ type: 'pong', id: msg.id })
+	else if (msg.cmd === 'prewarm') process.send({ type: 'prewarm-result', id: msg.id, ok: true })
+})
+`;
+const cleanupDirs = [];
+const doomedPids = [];
+const openStandbys = [];
+function mkTmp() {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'devkit-standby-hardening-'));
+    cleanupDirs.push(dir);
+    return dir;
+}
+function writeFixture(dir, body) {
+    const file = path.join(dir, 'entry.mjs');
+    fs.writeFileSync(file, body);
+    return file;
+}
+afterEach(async () => {
+    for (const standby of openStandbys.splice(0)) {
+        try {
+            await standby.dispose();
+        }
+        catch {
+            // best-effort teardown
+        }
+    }
+    for (const pid of doomedPids.splice(0)) {
+        if (pidAlive(pid)) {
+            try {
+                process.kill(pid, 'SIGKILL');
+            }
+            catch {
+                // already gone
+            }
+        }
+    }
+    for (const dir of cleanupDirs.splice(0)) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe('createCompileWorkerStandby — adopt() only hands over a spare whose prewarm has completed', () => {
+    it('adopt() during warming returns null and leaves the spare running untouched; the same spare is handed over once ready', async () => {
+        const dir = mkTmp();
+        const entry = writeFixture(dir, FIXTURE_DELAYED_PREWARM_OK);
+        const events = [];
+        const standby = createCompileWorkerStandby({ entry, onEvent: (ev) => events.push(ev) });
+        openStandbys.push(standby);
+        standby.ensure();
+        await sleep(200);
+        expect(standby.state, 'prewarm is scripted to take ~1s, so it must still be in flight').toBe('warming');
+        const duringWarming = await standby.adopt();
+        expect(duringWarming, 'adopt() must not hand over a spare whose prewarm has not completed').toBeNull();
+        const pid = events.find(ev => ev.type === 'spawned').pid;
+        expect(pidAlive(pid), 'the spare must keep running untouched while adopt() defers to a null result').toBe(true);
+        expect(events.some(ev => ev.type === 'adopted')).toBe(false);
+        expect(events.some(ev => ev.type === 'health-check-failed')).toBe(false);
+        expect(standby.state).toBe('warming');
+        const readyState = await waitForState(standby, 'ready', 3000);
+        expect(readyState).toBe('ready');
+        const adopted = await standby.adopt();
+        expect(adopted, 'once ready, the same spare must be handed over').not.toBeNull();
+        expect(adopted.pid).toBe(pid);
+        process.kill(pid, 'SIGKILL');
+        await waitForPidDeath(pid);
+    }, 10_000);
+    it('a null adopt() during warming does not orphan the spare — a later prewarm failure still kills it via the died path', async () => {
+        const dir = mkTmp();
+        const entry = writeFixture(dir, FIXTURE_DELAYED_PREWARM_FAIL);
+        const events = [];
+        const standby = createCompileWorkerStandby({ entry, onEvent: (ev) => events.push(ev) });
+        openStandbys.push(standby);
+        standby.ensure();
+        await sleep(200);
+        const duringWarming = await standby.adopt();
+        expect(duringWarming).toBeNull();
+        const pid = events.find(ev => ev.type === 'spawned').pid;
+        doomedPids.push(pid);
+        const diedFired = await pollUntil(() => events.some(ev => ev.type === 'died'), 3000);
+        expect(diedFired, 'a spare whose prewarm later fails must still be torn down by the manager, not left unmonitored by the earlier null adopt()').toBe(true);
+        expect(await waitForPidDeath(pid, 3000), 'a spare orphaned by an earlier null adopt() and a failed prewarm must actually die, not leak as a live process').toBe(true);
+    }, 10_000);
+    it('adopt() called right after an unexpected death, before the refill fork completes, still fails its health check', async () => {
+        const dir = mkTmp();
+        const entry = writeFixture(dir, FIXTURE_HAPPY);
+        const events = [];
+        const standby = createCompileWorkerStandby({ entry, onEvent: (ev) => events.push(ev) });
+        openStandbys.push(standby);
+        standby.ensure();
+        await waitForState(standby, 'ready', 8000);
+        const pid = events.find(ev => ev.type === 'spawned').pid;
+        process.kill(pid, 'SIGKILL');
+        const diedFired = await pollUntil(() => events.some(ev => ev.type === 'died'), 5000);
+        expect(diedFired).toBe(true);
+        const adopted = await standby.adopt();
+        expect(adopted).toBeNull();
+        const failure = events.find(ev => ev.type === 'health-check-failed');
+        expect(failure, 'adopt() in the dead-but-not-yet-refilled window must fail its health check').toBeTruthy();
+        expect(String(failure?.reason)).toContain('died before adoption');
+    }, 10_000);
+});
+describe('createCompileWorkerStandby — dispose() escalates past a spare that ignores SIGTERM', () => {
+    it('a spare trapping SIGTERM is still killed within disposeGraceMs, and dispose() resolves promptly rather than hanging', async () => {
+        const dir = mkTmp();
+        const entry = writeFixture(dir, FIXTURE_TRAP_SIGTERM);
+        const events = [];
+        // `disposeGraceMs` is passed through a variable (not an inline object
+        // literal) so this test compiles against today's narrower option type
+        // while still exercising the new option once implemented.
+        const opts = { entry, onEvent: (ev) => events.push(ev), disposeGraceMs: 300 };
+        const standby = createCompileWorkerStandby(opts);
+        openStandbys.push(standby);
+        standby.ensure();
+        await waitForState(standby, 'ready', 8000);
+        const pid = events.find(ev => ev.type === 'spawned').pid;
+        doomedPids.push(pid);
+        const disposeOutcome = await Promise.race([
+            standby.dispose().then(() => 'resolved'),
+            sleep(3000).then(() => 'timed-out'),
+        ]);
+        expect(disposeOutcome, 'dispose() must resolve within a bounded time even when the spare ignores SIGTERM, not hang forever waiting for a graceful exit').toBe('resolved');
+        expect(await waitForPidDeath(pid, 2000), 'a spare that traps SIGTERM must still end up dead — dispose() must escalate to SIGKILL after disposeGraceMs').toBe(true);
+    }, 10_000);
+});

package/dist/compile-worker-standby-integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=compile-worker-standby-integration.test.d.ts.map

package/dist/compile-worker-standby-integration.test.d.ts.map

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

package/dist/compile-worker-standby-integration.test.js

@@ -0,0 +1,243 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import * as devkit from './index.js';
+function getEnable() {
+    const fn = devkit.enableCompileWorkerStandby;
+    expect(typeof fn, 'devkit must export enableCompileWorkerStandby(opts?) — the one switch that turns the warm-standby accelerator on').toBe('function');
+    return fn;
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function waitForPidDeath(pid, timeoutMs = 8000) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!pidAlive(pid))
+            return true;
+        await sleep(100);
+    }
+    return !pidAlive(pid);
+}
+async function pollUntil(fn, timeoutMs, intervalMs = 100) {
+    const deadline = Date.now() + timeoutMs;
+    let last = fn();
+    while (!last && Date.now() < deadline) {
+        await sleep(intervalMs);
+        last = fn();
+    }
+    return last;
+}
+/** Direct compile-worker-entry children of THIS test process (real PID scan). */
+function findCompileWorkerPids() {
+    const out = execFileSync('ps', ['-axo', 'pid=,ppid=,command='], { encoding: 'utf8' });
+    const pids = [];
+    for (const line of out.split('\n')) {
+        const match = line.trim().match(/^(\d+)\s+(\d+)\s+(.*)$/);
+        if (!match)
+            continue;
+        const [, pid, ppid, command] = match;
+        if (Number(ppid) !== process.pid)
+            continue;
+        if (!command.includes('compile-worker-entry'))
+            continue;
+        pids.push(Number(pid));
+    }
+    return pids;
+}
+const openSessions = [];
+const activeManagers = [];
+const cleanupRoots = [];
+afterEach(async () => {
+    for (const session of openSessions.splice(0)) {
+        try {
+            await session.close();
+        }
+        catch {
+            // best-effort teardown
+        }
+    }
+    for (const manager of activeManagers.splice(0)) {
+        try {
+            await manager.dispose();
+        }
+        catch {
+            // best-effort teardown
+        }
+    }
+    // Hard sweep: nothing this suite forks may outlive its test.
+    for (const pid of findCompileWorkerPids()) {
+        try {
+            process.kill(pid, 'SIGKILL');
+        }
+        catch {
+            // already gone
+        }
+    }
+    for (const root of cleanupRoots.splice(0)) {
+        fs.rmSync(root, { recursive: true, force: true });
+    }
+});
+function makeFixture() {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'devkit-standby-integ-'));
+    cleanupRoots.push(root);
+    const write = (rel, content) => {
+        const target = path.join(root, rel);
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.writeFileSync(target, content);
+    };
+    write('project.config.json', JSON.stringify({ appid: 'fixture_app_001', projectname: 'fixture-app' }));
+    write('app.json', JSON.stringify({ pages: ['pages/index/index'] }));
+    write('app.js', 'App({})\n');
+    write('app.wxss', 'page { font-size: 14px; }\n');
+    write('pages/index/index.json', '{}\n');
+    write('pages/index/index.js', 'Page({ data: { msg: "hi" } })\n');
+    write('pages/index/index.wxml', '<view>{{msg}}</view>\n');
+    write('pages/index/index.wxss', '.x { color: red; }\n');
+    return root;
+}
+/**
+ * A projectPath that does not exist on disk: the worker-side
+ * chdir(projectPath) throws ENOENT, the build settles as a failure, and
+ * openProject rejects — AFTER the compile worker (the adopted spare) was
+ * already consumed. A merely-miscompiling project is NOT enough here:
+ * dmcc swallows compile errors (resolves undefined) and openProject's appId
+ * fallback tolerates even an unparsable project.config.json, so a broken-
+ * content fixture opens "successfully" in degraded form.
+ */
+function makeBrokenFixture() {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), 'devkit-standby-integ-broken-'));
+    fs.rmSync(root, { recursive: true, force: true });
+    return root;
+}
+function spawnedPids(events) {
+    return events.filter(ev => ev.type === 'spawned').map(ev => ev.pid);
+}
+async function enableAndAwaitReady(events) {
+    const enable = getEnable();
+    const manager = enable({ onEvent: (ev) => events.push(ev) });
+    activeManagers.push(manager);
+    const ready = await pollUntil(() => manager.state === 'ready', 30_000);
+    expect(ready, `standby never reached ready (stuck at ${manager.state}) — the REAL entry must prewarm end to end`).toBe(true);
+    return manager;
+}
+describe('enableCompileWorkerStandby — enable-time warm-up and idempotence', () => {
+    it('enabling immediately warms ONE real spare to ready; repeated calls return the SAME instance without a second fork; after dispose() a new enable builds a fresh manager that warms again', async () => {
+        const events = [];
+        const manager = await enableAndAwaitReady(events);
+        const again = getEnable()();
+        expect(again, 'enableCompileWorkerStandby while the manager lives must return the SAME instance — two live managers would each own a spare').toBe(manager);
+        await sleep(300);
+        expect(spawnedPids(events), 'the repeated enable must not fork a second spare').toHaveLength(1);
+        const firstPid = spawnedPids(events)[0];
+        expect(findCompileWorkerPids()).toEqual([firstPid]);
+        await manager.dispose();
+        expect(manager.state).toBe('disposed');
+        expect(await waitForPidDeath(firstPid), 'dispose() must leave the spare actually dead').toBe(true);
+        const rebornEvents = [];
+        const reborn = await enableAndAwaitReady(rebornEvents);
+        expect(reborn, 'enable after dispose() must build a FRESH manager — the disposed one is terminal').not.toBe(manager);
+        const secondPid = spawnedPids(rebornEvents)[0];
+        expect(secondPid).not.toBe(firstPid);
+        expect(pidAlive(secondPid)).toBe(true);
+    }, 90_000);
+});
+describe('enableCompileWorkerStandby — openProject adopts the spare, close() refills it', () => {
+    it('openProject with a ready spare reuses THAT process for its first compile (no fresh fork), and after session.close() the manager refills a new, different-pid spare back to ready', async () => {
+        const events = [];
+        const manager = await enableAndAwaitReady(events);
+        const standbyPid = spawnedPids(events)[0];
+        expect(findCompileWorkerPids(), 'precondition: exactly the spare is alive before open').toEqual([standbyPid]);
+        const root = makeFixture();
+        const session = await devkit.openProject({
+            projectPath: root,
+            watch: false,
+            outputDir: path.join(root, '.out'),
+        });
+        openSessions.push(session);
+        expect(session.appInfo.appId, 'the adopted spare must produce a real, correct compile').toBe('fixture_app_001');
+        expect(findCompileWorkerPids(), 'after open, the ONLY live compile-worker-entry child must be the pre-warmed spare — adoption, not a fresh fork next to an idle spare').toEqual([standbyPid]);
+        await session.close();
+        expect(await waitForPidDeath(standbyPid), 'the adopted worker must die with its session — adoption transfers ownership, not immortality').toBe(true);
+        const refilled = await pollUntil(() => manager.state === 'ready', 30_000);
+        expect(refilled, `after close() the manager must refill a new spare on its own (stuck at ${manager.state})`).toBe(true);
+        const pids = spawnedPids(events);
+        expect(pids.length, 'the refill must be a NEW spawn').toBeGreaterThanOrEqual(2);
+        const refillPid = pids.at(-1);
+        expect(refillPid).not.toBe(standbyPid);
+        expect(pidAlive(refillPid)).toBe(true);
+    }, 120_000);
+    it('a FAILED openProject also consumes the spare cleanly: the adopted worker is dead afterwards and the manager refills back to ready on a new pid', async () => {
+        const events = [];
+        const manager = await enableAndAwaitReady(events);
+        const standbyPid = spawnedPids(events)[0];
+        expect(findCompileWorkerPids(), 'precondition: exactly the spare is alive before open').toEqual([standbyPid]);
+        const root = makeBrokenFixture();
+        // The outputDir must live OUTSIDE the nonexistent root: openProject
+        // creates the outputDir recursively, and an outputDir nested under the
+        // root would re-create the root as a side effect — turning the intended
+        // hard failure into a degraded-but-successful open of an empty project.
+        const outputDir = fs.mkdtempSync(path.join(os.tmpdir(), 'devkit-standby-integ-out-'));
+        cleanupRoots.push(outputDir);
+        let rejected = false;
+        try {
+            const session = await devkit.openProject({
+                projectPath: root,
+                watch: false,
+                outputDir,
+            });
+            openSessions.push(session);
+        }
+        catch {
+            rejected = true;
+        }
+        expect(rejected, 'precondition: a nonexistent projectPath must make openProject reject (worker-side chdir ENOENT)').toBe(true);
+        // The failure path must not leak the consumed spare: it was adopted
+        // into the failed open, and the failed open's cleanup must kill it.
+        expect(await waitForPidDeath(standbyPid, 10_000), 'the spare consumed by a FAILED open must be dead afterwards — failure cleanup owns the adopted worker exactly like session.close() does').toBe(true);
+        const refilled = await pollUntil(() => manager.state === 'ready', 30_000);
+        expect(refilled, `a failed open must refill the standby just like a successful open+close does (stuck at ${manager.state})`).toBe(true);
+        const pids = spawnedPids(events);
+        expect(pids.length).toBeGreaterThanOrEqual(2);
+        const refillPid = pids.at(-1);
+        expect(refillPid).not.toBe(standbyPid);
+        expect(pidAlive(refillPid)).toBe(true);
+    }, 120_000);
+});
+describe('enableCompileWorkerStandby — dispose() restores the pure cold path', () => {
+    it('after manager.dispose(), openProject still succeeds via a fresh cold fork, and after close() NO spare ever appears again (quiet window)', async () => {
+        const events = [];
+        const manager = await enableAndAwaitReady(events);
+        const oldStandbyPid = spawnedPids(events)[0];
+        await manager.dispose();
+        expect(await waitForPidDeath(oldStandbyPid)).toBe(true);
+        const root = makeFixture();
+        const session = await devkit.openProject({
+            projectPath: root,
+            watch: false,
+            outputDir: path.join(root, '.out'),
+        });
+        openSessions.push(session);
+        expect(session.appInfo.appId, 'a disposed standby must not break opening — cold path is the structural fallback').toBe('fixture_app_001');
+        const coldPids = findCompileWorkerPids();
+        expect(coldPids, 'the cold path forks exactly one fresh worker').toHaveLength(1);
+        expect(coldPids[0]).not.toBe(oldStandbyPid);
+        await session.close();
+        expect(await waitForPidDeath(coldPids[0])).toBe(true);
+        // Quiet window: a disposed manager must never refill — no new
+        // compile-worker-entry child may appear after the session closed.
+        await sleep(2000);
+        expect(findCompileWorkerPids(), 'a disposed standby manager must NEVER fork again — a post-dispose refill is an untracked orphan factory').toHaveLength(0);
+    }, 120_000);
+});

package/dist/compile-worker-standby.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Warm-standby manager for the forked compile worker.
+ *
+ * A host (devtools) keeps ONE project-agnostic spare compile worker forked and
+ * prewarmed while no project is open; `openProject` adopts it so the first
+ * compile skips fork + compiler import + toolchain load. The spare never
+ * chdirs and never builds (see compile-worker-entry's prewarm contract), so it
+ * can be handed to ANY next-opened project.
+ *
+ * The manager is a PURE ACCELERATOR — every failure mode degrades to "no
+ * spare" and the caller's normal cold-fork path:
+ *  - adopt() health-checks the spare (ping/pong with a timeout) and kills a
+ *    wedged one rather than handing it over.
+ *  - an unexpected spare death auto-refills, but through a circuit breaker:
+ *    `breakerMaxDeaths` deaths inside `breakerWindowMs` trip the manager into
+ *    'degraded' — permanently cold, no fork storm on a broken install.
+ *  - dispose() (host quit) kills the spare and is terminal; ensure()/adopt()
+ *    afterwards are no-ops, so a teardown racing a refill cannot leak a fork.
+ *
+ * State machine: empty → (ensure) warming → ready → (adopt) empty; an
+ * unexpected death keeps the refill obligation ('warming' with the respawn
+ * scheduled after a short delay); 'degraded' and 'disposed' are terminal.
+ */
+import { type ChildProcess } from 'node:child_process';
+export type StandbyState = 'empty' | 'warming' | 'ready' | 'degraded' | 'disposed';
+export interface StandbyEvent {
+    type: 'spawned' | 'prewarmed' | 'adopted' | 'health-check-failed' | 'died' | 'degraded';
+    pid?: number;
+    reason?: string;
+}
+export interface CompileWorkerStandby {
+    /** Fork + prewarm a spare if none exists. No-op while warming/ready/degraded/disposed. */
+    ensure: () => void;
+    /**
+     * Health-check the spare and hand it over (the caller owns it afterwards;
+     * pass it to `createCompileWorker({ adopt })`). Only a fully-prewarmed
+     * ('ready') spare is ever handed over. Returns null — never throws, never
+     * hangs — when there is no healthy prewarmed spare to give.
+     */
+    adopt: () => Promise<ChildProcess | null>;
+    /** Kill the spare (waiting for real death) and shut the manager down for good. */
+    dispose: () => Promise<void>;
+    readonly state: StandbyState;
+}
+export interface CompileWorkerStandbyOptions {
+    /** Lifecycle telemetry (diagnostics bus, logs). Errors thrown here are swallowed. */
+    onEvent?: (ev: StandbyEvent) => void;
+    /** Sliding window for the crash-loop circuit breaker. Default 30000. */
+    breakerWindowMs?: number;
+    /** Spare deaths within the window that trip 'degraded'. Default 3. */
+    breakerMaxDeaths?: number;
+    /** ping→pong deadline for adopt()'s health check. Default 1000. */
+    healthCheckTimeoutMs?: number;
+    /** dispose()'s grace period between the polite kill and a SIGKILL escalation. Default 5000. */
+    disposeGraceMs?: number;
+    /** Fork target override (tests script the spare's behavior). Default: the real compile-worker-entry. */
+    entry?: string;
+}
+export declare function createCompileWorkerStandby(opts?: CompileWorkerStandbyOptions): CompileWorkerStandby;
+//# sourceMappingURL=compile-worker-standby.d.ts.map

package/dist/compile-worker-standby.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile-worker-standby.d.ts","sourceRoot":"","sources":["../src/compile-worker-standby.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,EAAQ,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAG5D,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,UAAU,GAAG,UAAU,CAAA;AAElF,MAAM,WAAW,YAAY;IAC5B,IAAI,EAAE,SAAS,GAAG,WAAW,GAAG,SAAS,GAAG,qBAAqB,GAAG,MAAM,GAAG,UAAU,CAAA;IACvF,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,MAAM,CAAC,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,oBAAoB;IACpC,0FAA0F;IAC1F,MAAM,EAAE,MAAM,IAAI,CAAA;IAClB;;;;;OAKG;IACH,KAAK,EAAE,MAAM,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAA;IACzC,kFAAkF;IAClF,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC5B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAA;CAC5B;AAED,MAAM,WAAW,2BAA2B;IAC3C,qFAAqF;IACrF,OAAO,CAAC,EAAE,CAAC,EAAE,EAAE,YAAY,KAAK,IAAI,CAAA;IACpC,wEAAwE;IACxE,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,sEAAsE;IACtE,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,mEAAmE;IACnE,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B,+FAA+F;IAC/F,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,wGAAwG;IACxG,KAAK,CAAC,EAAE,MAAM,CAAA;CACd;AAQD,wBAAgB,0BAA0B,CACzC,IAAI,GAAE,2BAAgC,GACpC,oBAAoB,CAoQtB"}