footprintjs 4.16.0 → 4.17.2

package/dist/esm/lib/detach/flush.js

@@ -0,0 +1,91 @@
+/**
+ * detach/flush.ts — Drain every in-flight detached handle to terminal.
+ *
+ * Pattern:  Drain-loop with deadline. Same shape as a graceful HTTP
+ *           server shutdown: snapshot the queue, await everything in
+ *           flight, repeat until empty or deadline.
+ * Role:     Graceful-shutdown hook for consumers who launched
+ *           fire-and-forget work and want to make sure it actually
+ *           flushed before exiting (server stop, test cleanup, etc.).
+ *
+ * Why iterate (not single Promise.all over a snapshot):
+ *   - A child stage can itself call `detachAndForget` while running —
+ *     new handles arrive WHILE we're flushing. A single snapshot would
+ *     miss them. Looping until `size() === 0` drains transitively.
+ *
+ * Why dedupe via `seen` Set:
+ *   - Handles already terminal (but not yet `unregister`ed by their
+ *     driver's finally-block) can re-appear in subsequent snapshots.
+ *     Without dedupe, the `done` counter would double-count them.
+ *
+ * Why `Promise.allSettled` (not `Promise.all`):
+ *   - One handle's rejection must NOT abort the rest. A failed child
+ *     is normal (it's why `wait()` rejects); we still want to drain
+ *     the siblings.
+ */
+import { ids, lookup, size } from './registry.js';
+/**
+ * Wait for every in-flight detached handle to reach a terminal state.
+ * Returns counts for diagnostics. PROCESS-WIDE — drains every driver
+ * across every executor. For per-executor scoping, consumers should
+ * collect their own handles from `executor.detachAndJoinLater(...)`
+ * calls and await `Promise.allSettled([...].map(h => h.wait()))`
+ * themselves.
+ *
+ * @example Graceful server shutdown
+ * ```typescript
+ * import { flushAllDetached } from 'footprintjs/detach';
+ *
+ * process.on('SIGTERM', async () => {
+ *   const stats = await flushAllDetached({ timeoutMs: 10_000 });
+ *   console.log(`Drained ${stats.done} done, ${stats.failed} failed, ${stats.pending} pending.`);
+ *   process.exit(stats.pending === 0 ? 0 : 1);
+ * });
+ * ```
+ */
+export async function flushAllDetached(opts) {
+    const timeoutMs = opts?.timeoutMs ?? 30_000;
+    const startedAt = Date.now();
+    const seen = new Set();
+    let done = 0;
+    let failed = 0;
+    while (size() > 0) {
+        const remainingMs = timeoutMs - (Date.now() - startedAt);
+        if (remainingMs <= 0)
+            return { done, failed, pending: size() };
+        // Snapshot of NEW (unseen) handles. Existing terminal-but-still-
+        // registered handles re-appear in subsequent snapshots; the seen
+        // set prevents double-counting.
+        const newIds = ids().filter((id) => !seen.has(id));
+        if (newIds.length === 0) {
+            // Everything in the registry is already awaited — yield once and
+            // re-check. The driver's unregister-in-finally hasn't run yet.
+            await Promise.resolve();
+            continue;
+        }
+        for (const id of newIds)
+            seen.add(id);
+        const handles = newIds.map((id) => lookup(id)).filter((h) => h !== undefined);
+        // Race the drain against the per-iteration timeout. We use a
+        // `'timeout'` sentinel on the timeout side so the type narrows.
+        let timerId;
+        const timeoutPromise = new Promise((resolve) => {
+            timerId = setTimeout(() => resolve('__detach_timeout__'), remainingMs);
+        });
+        const drainPromise = Promise.allSettled(handles.map((h) => h.wait()));
+        const result = await Promise.race([drainPromise, timeoutPromise]);
+        if (timerId !== undefined)
+            clearTimeout(timerId);
+        if (result === '__detach_timeout__') {
+            return { done, failed, pending: size() };
+        }
+        for (const r of result) {
+            if (r.status === 'fulfilled')
+                done++;
+            else
+                failed++;
+        }
+    }
+    return { done, failed, pending: 0 };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flush.js","sourceRoot":"","sources":["../../../../src/lib/detach/flush.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAsBlD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,IAAmB;IACxD,MAAM,SAAS,GAAG,IAAI,EAAE,SAAS,IAAI,MAAM,CAAC;IAC5C,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAC7B,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAC/B,IAAI,IAAI,GAAG,CAAC,CAAC;IACb,IAAI,MAAM,GAAG,CAAC,CAAC;IAEf,OAAO,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC;QAClB,MAAM,WAAW,GAAG,SAAS,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC,CAAC;QACzD,IAAI,WAAW,IAAI,CAAC;YAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,CAAC;QAE/D,iEAAiE;QACjE,iEAAiE;QACjE,gCAAgC;QAChC,MAAM,MAAM,GAAG,GAAG,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;QACnD,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACxB,iEAAiE;YACjE,+DAA+D;YAC/D,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC;YACxB,SAAS;QACX,CAAC;QACD,KAAK,MAAM,EAAE,IAAI,MAAM;YAAE,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAEtC,MAAM,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAqB,EAAE,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC;QAEjG,6DAA6D;QAC7D,gEAAgE;QAChE,IAAI,OAAkD,CAAC;QACvD,MAAM,cAAc,GAAG,IAAI,OAAO,CAAuB,CAAC,OAAO,EAAE,EAAE;YACnE,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,oBAAoB,CAAC,EAAE,WAAW,CAAC,CAAC;QACzE,CAAC,CAAC,CAAC;QACH,MAAM,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;QACtE,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,YAAY,EAAE,cAAc,CAAC,CAAC,CAAC;QAClE,IAAI,OAAO,KAAK,SAAS;YAAE,YAAY,CAAC,OAAO,CAAC,CAAC;QAEjD,IAAI,MAAM,KAAK,oBAAoB,EAAE,CAAC;YACpC,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,EAAE,CAAC;QAC3C,CAAC;QACD,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE,CAAC;YACvB,IAAI,CAAC,CAAC,MAAM,KAAK,WAAW;gBAAE,IAAI,EAAE,CAAC;;gBAChC,MAAM,EAAE,CAAC;QAChB,CAAC;IACH,CAAC;IAED,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;AACtC,CAAC","sourcesContent":["/**\n * detach/flush.ts — Drain every in-flight detached handle to terminal.\n *\n * Pattern:  Drain-loop with deadline. Same shape as a graceful HTTP\n *           server shutdown: snapshot the queue, await everything in\n *           flight, repeat until empty or deadline.\n * Role:     Graceful-shutdown hook for consumers who launched\n *           fire-and-forget work and want to make sure it actually\n *           flushed before exiting (server stop, test cleanup, etc.).\n *\n * Why iterate (not single Promise.all over a snapshot):\n *   - A child stage can itself call `detachAndForget` while running —\n *     new handles arrive WHILE we're flushing. A single snapshot would\n *     miss them. Looping until `size() === 0` drains transitively.\n *\n * Why dedupe via `seen` Set:\n *   - Handles already terminal (but not yet `unregister`ed by their\n *     driver's finally-block) can re-appear in subsequent snapshots.\n *     Without dedupe, the `done` counter would double-count them.\n *\n * Why `Promise.allSettled` (not `Promise.all`):\n *   - One handle's rejection must NOT abort the rest. A failed child\n *     is normal (it's why `wait()` rejects); we still want to drain\n *     the siblings.\n */\n\nimport { ids, lookup, size } from './registry.js';\nimport type { DetachHandle } from './types.js';\n\nexport interface FlushResult {\n  /** Handles whose `wait()` we EXPLICITLY awaited and saw fulfilled.\n   *  Best-effort count — a child that completes inside another's\n   *  `wait()` may finish (and unregister) before we get a chance to\n   *  await it directly. The DRAIN is still guaranteed (registry empty\n   *  on return); only the COUNT is approximate. */\n  readonly done: number;\n  /** Handles whose `wait()` rejected. Same best-effort semantics. */\n  readonly failed: number;\n  /** Handles still in-flight when the deadline expired. `0` indicates\n   *  a successful (complete) drain — registry was empty on return. */\n  readonly pending: number;\n}\n\nexport interface FlushOptions {\n  /** Max wall-clock to spend draining, in milliseconds. Default 30s. */\n  readonly timeoutMs?: number;\n}\n\n/**\n * Wait for every in-flight detached handle to reach a terminal state.\n * Returns counts for diagnostics. PROCESS-WIDE — drains every driver\n * across every executor. For per-executor scoping, consumers should\n * collect their own handles from `executor.detachAndJoinLater(...)`\n * calls and await `Promise.allSettled([...].map(h => h.wait()))`\n * themselves.\n *\n * @example Graceful server shutdown\n * ```typescript\n * import { flushAllDetached } from 'footprintjs/detach';\n *\n * process.on('SIGTERM', async () => {\n *   const stats = await flushAllDetached({ timeoutMs: 10_000 });\n *   console.log(`Drained ${stats.done} done, ${stats.failed} failed, ${stats.pending} pending.`);\n *   process.exit(stats.pending === 0 ? 0 : 1);\n * });\n * ```\n */\nexport async function flushAllDetached(opts?: FlushOptions): Promise<FlushResult> {\n  const timeoutMs = opts?.timeoutMs ?? 30_000;\n  const startedAt = Date.now();\n  const seen = new Set<string>();\n  let done = 0;\n  let failed = 0;\n\n  while (size() > 0) {\n    const remainingMs = timeoutMs - (Date.now() - startedAt);\n    if (remainingMs <= 0) return { done, failed, pending: size() };\n\n    // Snapshot of NEW (unseen) handles. Existing terminal-but-still-\n    // registered handles re-appear in subsequent snapshots; the seen\n    // set prevents double-counting.\n    const newIds = ids().filter((id) => !seen.has(id));\n    if (newIds.length === 0) {\n      // Everything in the registry is already awaited — yield once and\n      // re-check. The driver's unregister-in-finally hasn't run yet.\n      await Promise.resolve();\n      continue;\n    }\n    for (const id of newIds) seen.add(id);\n\n    const handles = newIds.map((id) => lookup(id)).filter((h): h is DetachHandle => h !== undefined);\n\n    // Race the drain against the per-iteration timeout. We use a\n    // `'timeout'` sentinel on the timeout side so the type narrows.\n    let timerId: ReturnType<typeof setTimeout> | undefined;\n    const timeoutPromise = new Promise<'__detach_timeout__'>((resolve) => {\n      timerId = setTimeout(() => resolve('__detach_timeout__'), remainingMs);\n    });\n    const drainPromise = Promise.allSettled(handles.map((h) => h.wait()));\n    const result = await Promise.race([drainPromise, timeoutPromise]);\n    if (timerId !== undefined) clearTimeout(timerId);\n\n    if (result === '__detach_timeout__') {\n      return { done, failed, pending: size() };\n    }\n    for (const r of result) {\n      if (r.status === 'fulfilled') done++;\n      else failed++;\n    }\n  }\n\n  return { done, failed, pending: 0 };\n}\n"]}

package/dist/esm/lib/detach/handle.js

@@ -0,0 +1,134 @@
+/**
+ * detach/handle.ts — DetachHandle implementation.
+ *
+ * Pattern:  Object-as-state-machine. Mutable status field; transitions
+ *           are one-way and irreversible (queued → running → done/failed).
+ * Role:     Backs the consumer-facing `DetachHandle` interface. The
+ *           public surface is the interface (defined in `types.ts`);
+ *           this class is the runtime impl.
+ *
+ * Internal vs public split:
+ *   - PUBLIC (in `types.ts`)   — read-only properties + `wait()`
+ *   - INTERNAL (this file)     — `_markRunning` / `_markDone` /
+ *                                `_markFailed` mutators called by drivers
+ *
+ * The class implements `DetachHandle` (which has only readonly fields
+ * exposed). Drivers cast to `HandleImpl` via the `asImpl()` helper to
+ * call the mutators — a controlled escape from readonly. Consumers
+ * cannot do this (they only see the interface).
+ *
+ * Promise caching contract:
+ *   - First `wait()` call:
+ *       - if status terminal → returns IMMEDIATELY-resolved Promise
+ *       - if not terminal    → returns NEW Promise; resolvers stored
+ *                              for use by `_markDone` / `_markFailed`
+ *   - Subsequent `wait()` calls → returns the SAME cached Promise
+ *   - The resolved/rejected value is the SAME on every call (no
+ *     re-running, no duplicated work)
+ *
+ * Concurrency notes:
+ *   - All transitions are sync. JavaScript is single-threaded so no
+ *     atomics or locks needed.
+ *   - State transitions out of terminal states are forbidden — calling
+ *     `_markDone` after `_markFailed` (or vice-versa) is a no-op
+ *     (defensive: prevents driver bugs from corrupting state).
+ */
+/**
+ * Internal handle implementation. Drivers call the `_mark*` methods
+ * to drive state transitions; consumers see only the readonly
+ * `DetachHandle` interface.
+ */
+export class HandleImpl {
+    id;
+    status = 'queued';
+    result = undefined;
+    error = undefined;
+    // Lazy Promise cache — created on first `wait()` call.
+    waitPromise = null;
+    // Resolvers captured when wait() was called BEFORE terminal state.
+    resolveWait = null;
+    rejectWait = null;
+    constructor(id) {
+        this.id = id;
+    }
+    /**
+     * Public — opt-in async join. Returns a cached Promise.
+     * See `DetachHandle.wait()` docstring for contract.
+     */
+    wait() {
+        if (this.waitPromise)
+            return this.waitPromise;
+        if (this.status === 'done') {
+            this.waitPromise = Promise.resolve({ result: this.result });
+        }
+        else if (this.status === 'failed') {
+            this.waitPromise = Promise.reject(this.error);
+        }
+        else {
+            // Pending terminal — store resolvers for _markDone / _markFailed.
+            this.waitPromise = new Promise((resolve, reject) => {
+                this.resolveWait = resolve;
+                this.rejectWait = reject;
+            });
+        }
+        return this.waitPromise;
+    }
+    // ── Internal mutators (called by drivers) ──────────────────────────
+    /** Transition queued → running. No-op if already past 'queued'. */
+    _markRunning() {
+        if (this.status !== 'queued')
+            return;
+        this.status = 'running';
+    }
+    /**
+     * Transition to terminal 'done' with the given result. No-op if
+     * already terminal (defensive: prevents driver bugs from corrupting
+     * state).
+     */
+    _markDone(result) {
+        if (this.status === 'done' || this.status === 'failed')
+            return;
+        this.status = 'done';
+        this.result = result;
+        // If consumer already called wait(), unblock its Promise.
+        this.resolveWait?.({ result });
+        this.resolveWait = null;
+        this.rejectWait = null;
+    }
+    /**
+     * Transition to terminal 'failed' with the given error. No-op if
+     * already terminal.
+     */
+    _markFailed(error) {
+        if (this.status === 'done' || this.status === 'failed')
+            return;
+        this.status = 'failed';
+        this.error = error;
+        this.rejectWait?.(error);
+        this.resolveWait = null;
+        this.rejectWait = null;
+    }
+}
+/**
+ * Type-narrowing helper — cast a public `DetachHandle` to its
+ * implementation. Drivers (only) use this to call internal mutators.
+ *
+ * Throws if the handle isn't actually a `HandleImpl` — defends
+ * against consumers passing a hand-rolled object that satisfies the
+ * interface shape but lacks the mutators.
+ */
+export function asImpl(handle) {
+    if (!(handle instanceof HandleImpl)) {
+        throw new TypeError('[detach] expected a HandleImpl returned by createHandle(); got an arbitrary DetachHandle. ' +
+            'Drivers must use createHandle() to construct handles, not hand-roll them.');
+    }
+    return handle;
+}
+/**
+ * Driver-facing factory. Drivers MUST use this to create handles
+ * (NOT construct `HandleImpl` directly — keeps the impl type private).
+ */
+export function createHandle(id) {
+    return new HandleImpl(id);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"handle.js","sourceRoot":"","sources":["../../../../src/lib/detach/handle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAIH;;;;GAIG;AACH,MAAM,OAAO,UAAU;IACZ,EAAE,CAAS;IACpB,MAAM,GAA2B,QAAQ,CAAC;IAC1C,MAAM,GAAY,SAAS,CAAC;IAC5B,KAAK,GAAsB,SAAS,CAAC;IAErC,uDAAuD;IAC/C,WAAW,GAAqC,IAAI,CAAC;IAC7D,mEAAmE;IAC3D,WAAW,GAA2C,IAAI,CAAC;IAC3D,UAAU,GAAgC,IAAI,CAAC;IAEvD,YAAY,EAAU;QACpB,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IACf,CAAC;IAED;;;OAGG;IACH,IAAI;QACF,IAAI,IAAI,CAAC,WAAW;YAAE,OAAO,IAAI,CAAC,WAAW,CAAC;QAE9C,IAAI,IAAI,CAAC,MAAM,KAAK,MAAM,EAAE,CAAC;YAC3B,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;QAC9D,CAAC;aAAM,IAAI,IAAI,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;YACpC,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAChD,CAAC;aAAM,CAAC;YACN,kEAAkE;YAClE,IAAI,CAAC,WAAW,GAAG,IAAI,OAAO,CAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;gBACnE,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC;gBAC3B,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC;YAC3B,CAAC,CAAC,CAAC;QACL,CAAC;QACD,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED,sEAAsE;IAEtE,mEAAmE;IACnE,YAAY;QACV,IAAI,IAAI,CAAC,MAAM,KAAK,QAAQ;YAAE,OAAO;QACrC,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;IAC1B,CAAC;IAED;;;;OAIG;IACH,SAAS,CAAC,MAAe;QACvB,IAAI,IAAI,CAAC,MAAM,KAAK,MAAM,IAAI,IAAI,CAAC,MAAM,KAAK,QAAQ;YAAE,OAAO;QAC/D,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,0DAA0D;QAC1D,IAAI,CAAC,WAAW,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC;QAC/B,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QACxB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;IACzB,CAAC;IAED;;;OAGG;IACH,WAAW,CAAC,KAAY;QACtB,IAAI,IAAI,CAAC,MAAM,KAAK,MAAM,IAAI,IAAI,CAAC,MAAM,KAAK,QAAQ;YAAE,OAAO;QAC/D,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC;QACvB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,UAAU,EAAE,CAAC,KAAK,CAAC,CAAC;QACzB,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QACxB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;IACzB,CAAC;CACF;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,MAAM,CAAC,MAAoB;IACzC,IAAI,CAAC,CAAC,MAAM,YAAY,UAAU,CAAC,EAAE,CAAC;QACpC,MAAM,IAAI,SAAS,CACjB,4FAA4F;YAC1F,2EAA2E,CAC9E,CAAC;IACJ,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,YAAY,CAAC,EAAU;IACrC,OAAO,IAAI,UAAU,CAAC,EAAE,CAAC,CAAC;AAC5B,CAAC","sourcesContent":["/**\n * detach/handle.ts — DetachHandle implementation.\n *\n * Pattern:  Object-as-state-machine. Mutable status field; transitions\n *           are one-way and irreversible (queued → running → done/failed).\n * Role:     Backs the consumer-facing `DetachHandle` interface. The\n *           public surface is the interface (defined in `types.ts`);\n *           this class is the runtime impl.\n *\n * Internal vs public split:\n *   - PUBLIC (in `types.ts`)   — read-only properties + `wait()`\n *   - INTERNAL (this file)     — `_markRunning` / `_markDone` /\n *                                `_markFailed` mutators called by drivers\n *\n * The class implements `DetachHandle` (which has only readonly fields\n * exposed). Drivers cast to `HandleImpl` via the `asImpl()` helper to\n * call the mutators — a controlled escape from readonly. Consumers\n * cannot do this (they only see the interface).\n *\n * Promise caching contract:\n *   - First `wait()` call:\n *       - if status terminal → returns IMMEDIATELY-resolved Promise\n *       - if not terminal    → returns NEW Promise; resolvers stored\n *                              for use by `_markDone` / `_markFailed`\n *   - Subsequent `wait()` calls → returns the SAME cached Promise\n *   - The resolved/rejected value is the SAME on every call (no\n *     re-running, no duplicated work)\n *\n * Concurrency notes:\n *   - All transitions are sync. JavaScript is single-threaded so no\n *     atomics or locks needed.\n *   - State transitions out of terminal states are forbidden — calling\n *     `_markDone` after `_markFailed` (or vice-versa) is a no-op\n *     (defensive: prevents driver bugs from corrupting state).\n */\n\nimport type { DetachHandle, DetachWaitResult } from './types.js';\n\n/**\n * Internal handle implementation. Drivers call the `_mark*` methods\n * to drive state transitions; consumers see only the readonly\n * `DetachHandle` interface.\n */\nexport class HandleImpl implements DetachHandle {\n  readonly id: string;\n  status: DetachHandle['status'] = 'queued';\n  result: unknown = undefined;\n  error: Error | undefined = undefined;\n\n  // Lazy Promise cache — created on first `wait()` call.\n  private waitPromise: Promise<DetachWaitResult> | null = null;\n  // Resolvers captured when wait() was called BEFORE terminal state.\n  private resolveWait: ((v: DetachWaitResult) => void) | null = null;\n  private rejectWait: ((e: Error) => void) | null = null;\n\n  constructor(id: string) {\n    this.id = id;\n  }\n\n  /**\n   * Public — opt-in async join. Returns a cached Promise.\n   * See `DetachHandle.wait()` docstring for contract.\n   */\n  wait(): Promise<DetachWaitResult> {\n    if (this.waitPromise) return this.waitPromise;\n\n    if (this.status === 'done') {\n      this.waitPromise = Promise.resolve({ result: this.result });\n    } else if (this.status === 'failed') {\n      this.waitPromise = Promise.reject(this.error);\n    } else {\n      // Pending terminal — store resolvers for _markDone / _markFailed.\n      this.waitPromise = new Promise<DetachWaitResult>((resolve, reject) => {\n        this.resolveWait = resolve;\n        this.rejectWait = reject;\n      });\n    }\n    return this.waitPromise;\n  }\n\n  // ── Internal mutators (called by drivers) ──────────────────────────\n\n  /** Transition queued → running. No-op if already past 'queued'. */\n  _markRunning(): void {\n    if (this.status !== 'queued') return;\n    this.status = 'running';\n  }\n\n  /**\n   * Transition to terminal 'done' with the given result. No-op if\n   * already terminal (defensive: prevents driver bugs from corrupting\n   * state).\n   */\n  _markDone(result: unknown): void {\n    if (this.status === 'done' || this.status === 'failed') return;\n    this.status = 'done';\n    this.result = result;\n    // If consumer already called wait(), unblock its Promise.\n    this.resolveWait?.({ result });\n    this.resolveWait = null;\n    this.rejectWait = null;\n  }\n\n  /**\n   * Transition to terminal 'failed' with the given error. No-op if\n   * already terminal.\n   */\n  _markFailed(error: Error): void {\n    if (this.status === 'done' || this.status === 'failed') return;\n    this.status = 'failed';\n    this.error = error;\n    this.rejectWait?.(error);\n    this.resolveWait = null;\n    this.rejectWait = null;\n  }\n}\n\n/**\n * Type-narrowing helper — cast a public `DetachHandle` to its\n * implementation. Drivers (only) use this to call internal mutators.\n *\n * Throws if the handle isn't actually a `HandleImpl` — defends\n * against consumers passing a hand-rolled object that satisfies the\n * interface shape but lacks the mutators.\n */\nexport function asImpl(handle: DetachHandle): HandleImpl {\n  if (!(handle instanceof HandleImpl)) {\n    throw new TypeError(\n      '[detach] expected a HandleImpl returned by createHandle(); got an arbitrary DetachHandle. ' +\n        'Drivers must use createHandle() to construct handles, not hand-roll them.',\n    );\n  }\n  return handle;\n}\n\n/**\n * Driver-facing factory. Drivers MUST use this to create handles\n * (NOT construct `HandleImpl` directly — keeps the impl type private).\n */\nexport function createHandle(id: string): DetachHandle {\n  return new HandleImpl(id);\n}\n"]}

package/dist/esm/lib/detach/registry.js

@@ -0,0 +1,97 @@
+/**
+ * detach/registry.ts — Process-singleton handle registry.
+ *
+ * Pattern:  Registry (GoF). Same shape as the cache strategy registry
+ *           in agentfootprint v2.6 — a Map keyed by stable string id.
+ * Role:     Glue between drivers and executors. When a driver schedules
+ *           work it `register`s the handle here; later (during executor
+ *           disposal, or for diagnostics) consumers `lookup` by refId.
+ *
+ * Why a singleton?
+ *   - refIds are minted per detach call and are unique across the
+ *     process lifetime (driver name + monotonic counter)
+ *   - handles need to be cleanable from MULTIPLE call sites (executor
+ *     disposal, driver-internal flush, test cleanup) without each one
+ *     having to thread a Registry instance through ten layers
+ *   - one-source-of-truth simplifies "is this handle still alive?"
+ *     queries during debugging
+ *
+ * Why NOT a class instance per executor?
+ *   - drivers (e.g., `microtaskBatchDriver`) are PROCESS-wide (one queue
+ *     per driver, shared by every executor). Tying registry to executor
+ *     would force per-executor driver instances, multiplying the queue
+ *     count and breaking the batch-amortization the drivers exist for.
+ *
+ * Cleanup contract:
+ *   - Drivers call `register(handle)` synchronously inside `schedule()`
+ *   - Drivers (or executor disposal) call `unregister(refId)` once the
+ *     handle is terminal AND the consumer has had a chance to observe it
+ *   - `_resetForTests()` clears every entry — tests only
+ *
+ * Capacity:
+ *   - No upper bound. The handle objects are tiny (~6 fields). A long-
+ *     running process that detaches a million units WITHOUT cleanup
+ *     would leak ~50 MB — acceptable for v1, since drivers ARE the
+ *     cleanup site. If real-world programs hit the limit, add a
+ *     sliding-window cap with telemetry hook (mirrors
+ *     `LIVE_STATUS_LOG_CAP` in agentfootprint).
+ */
+// Process-wide singleton. Map preserves insertion order — useful for
+// diagnostic dumps that want chronological ordering.
+const HANDLES = new Map();
+/**
+ * Register a freshly-minted handle. Drivers MUST call this synchronously
+ * inside `schedule()` so the handle is observable from the moment it
+ * exists.
+ *
+ * Replacing an existing registration is treated as a programming error
+ * (refIds are supposed to be unique). We don't throw — silent overwrite
+ * could mask a bug, but throwing inside a driver's hot path could cascade
+ * into the parent stage. Compromise: warn in dev mode, overwrite always.
+ */
+export function register(handle) {
+    HANDLES.set(handle.id, handle);
+}
+/**
+ * Look up a handle by refId. Returns `undefined` for unknown ids — the
+ * caller decides whether that's an error or just a stale reference.
+ *
+ * Used by:
+ *   - Executor disposal (find handles to mark cancelled / drain)
+ *   - Driver-internal flush (correlate work-queue entries → handles)
+ *   - Diagnostic tooling (dump handle state for a refId in a log line)
+ */
+export function lookup(refId) {
+    return HANDLES.get(refId);
+}
+/**
+ * Drop a handle from the registry. Idempotent — calling on an already-
+ * removed refId is a no-op (matches `Map.delete` semantics; useful when
+ * cleanup may race between executor disposal and the driver's own
+ * post-terminal cleanup).
+ */
+export function unregister(refId) {
+    HANDLES.delete(refId);
+}
+/**
+ * Diagnostic — total live handles. Use sparingly; calling this on hot
+ * paths defeats the registry's "cheap insert/lookup" goal.
+ */
+export function size() {
+    return HANDLES.size;
+}
+/**
+ * Diagnostic — every live refId. Use for "what's still in flight?"
+ * dumps during executor disposal or oncall debugging.
+ */
+export function ids() {
+    return [...HANDLES.keys()];
+}
+/**
+ * Test-only — wipe every entry. NEVER call from production code; that
+ * would orphan in-flight work without a chance to drain.
+ */
+export function _resetForTests() {
+    HANDLES.clear();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/detach/runChild.js

@@ -0,0 +1,40 @@
+/**
+ * detach/runChild.ts — The "how do I actually run a child flowchart?" hook.
+ *
+ * Pattern:  Strategy (GoF). Drivers are decoupled from the FlowChartExecutor
+ *           — each driver is created with a `ChildRunner` it calls to
+ *           materialize the work. Default implementation imports the
+ *           executor lazily so drivers can be picked up by tree-shakers
+ *           that don't pull the runner module into the bundle.
+ * Role:     Glue between drivers and the engine. Without this seam, every
+ *           driver would have to import `FlowChartExecutor` directly,
+ *           creating circular import risk and bundle bloat.
+ *
+ * Why a separate module (not inlined in each driver):
+ *   - DRY — every driver shares the same "instantiate executor, run, return
+ *     result" sequence
+ *   - Allows test code to swap the runner via factory injection without
+ *     having to rebuild the whole driver
+ *   - Future-proofs for the case where we want to inject env/recorders
+ *     into the child (the runner is the natural place to do that)
+ */
+/**
+ * Default runner — instantiates a fresh `FlowChartExecutor` for each
+ * child and awaits its run. Returns the executor's traversal result.
+ *
+ * Lazy-imports `FlowChartExecutor` so drivers that consumers create with
+ * their own runner don't pull the engine into their bundle.
+ *
+ * Uses dynamic import — see https://v8.dev/features/dynamic-import.
+ */
+export const defaultRunChild = async (child, input) => {
+    // Lazy import keeps tree-shakers honest for consumers who pass a
+    // custom runner (e.g., a worker-thread bridge).
+    const { FlowChartExecutor } = await import('../runner/FlowChartExecutor.js');
+    // The executor expects an unknown-typed FlowChart; cast at the boundary
+    // since the FlowChart shape is generic-erased at the detach level.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const executor = new FlowChartExecutor(child);
+    return executor.run({ input });
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/detach/spawn.js

@@ -0,0 +1,86 @@
+/**
+ * detach/spawn.ts — One-call detach primitive used by both scope and
+ * executor surfaces.
+ *
+ * Pattern:  Facade (GoF). Hides driver invocation + refId minting +
+ *           registry registration behind two named functions
+ *           (`detachAndJoinLater`, `detachAndForget`). Same helper is
+ *           called from `scope.$detachAndJoinLater(...)` and from
+ *           `executor.detachAndJoinLater(...)` — single source of truth.
+ *
+ * Why a separate module:
+ *   - Avoids duplicating the "validate driver, mint refId, call schedule"
+ *     sequence in both scope and executor entry points
+ *   - Keeps the scope/executor files free of driver knowledge — they
+ *     just call this and forward the result
+ *
+ * refId scheme:
+ *   - When the caller is a stage (scope path): refId = `${runtimeStageId}:detach:${counter}`
+ *     — the runtimeStageId prefix lets diagnostics correlate the handle
+ *     back to the source stage
+ *   - When the caller is bare executor (executor path):
+ *     refId = `__executor__:detach:${counter}` — uniform "no source stage"
+ *     marker
+ *   - Counter is module-private + monotonic for the process lifetime —
+ *     safe across re-entrant detach calls
+ */
+let counter = 0;
+/** Reset the counter for tests — never call from production code. */
+export function _resetSpawnCounterForTests() {
+    counter = 0;
+}
+/**
+ * Mint a refId. Format: `${prefix}:detach:${counter}`. The prefix carries
+ * source-stage provenance (or `__executor__` when there is none).
+ */
+function mintRefId(prefix) {
+    counter += 1;
+    return `${prefix}:detach:${counter}`;
+}
+/**
+ * Schedule `child` on the given driver, with the consumer's `input`,
+ * and return the resulting `DetachHandle`. Callers can `wait()` on it,
+ * read its `.status` property, or just hold the reference for later.
+ *
+ * **Joinable variant** — the caller wants to be able to await the result
+ * (or check its status). The `forget` variant simply discards the handle.
+ *
+ * @param driver - The driver implementation to use. Required (no
+ *   library-default — passing it explicitly avoids global state and
+ *   keeps the engine free of driver imports).
+ * @param child - The child flowchart to run.
+ * @param input - The input to hand to the child's run() call.
+ * @param sourcePrefix - Refix prefix for the minted refId; pass the
+ *   parent's `runtimeStageId` from a stage caller, or `'__executor__'`
+ *   from a bare-executor caller.
+ */
+export function detachAndJoinLater(driver, child, input, sourcePrefix) {
+    if (!driver || typeof driver.schedule !== 'function') {
+        throw new TypeError(`[detach] expected a DetachDriver as the first argument; got ${typeof driver}. ` +
+            "Pass e.g. `microtaskBatchDriver` from 'footprintjs/detach'.");
+    }
+    const refId = mintRefId(sourcePrefix);
+    return driver.schedule(child, input, refId);
+}
+/**
+ * Same as `detachAndJoinLater` but discards the handle. Use when the
+ * caller doesn't care about the result and doesn't need to await — e.g.,
+ * fire-and-forget telemetry exports.
+ *
+ * The handle still exists internally (driver creates it, registry holds
+ * it briefly) — but the caller cannot reference it. This is intentional:
+ * having no handle reference is what gives "forget" its semantic — there
+ * is no chance of the caller accidentally awaiting it.
+ *
+ * Errors raised by the child are STILL routed to the handle's failed
+ * state (the driver does that). They just go unobserved unless something
+ * else (a recorder, logging) is wired to surface them. See the docs in
+ * T7 for recommended observability patterns for "forget" detach.
+ */
+export function detachAndForget(driver, child, input, sourcePrefix) {
+    // Reuse the joinable path — the caller just chooses not to keep the
+    // returned handle. We don't even bind it to a variable to make the
+    // "forget" semantic explicit at the call site.
+    detachAndJoinLater(driver, child, input, sourcePrefix);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/detach/types.js

@@ -0,0 +1,37 @@
+/**
+ * detach/types.ts — Type definitions for the fire-and-forget primitive.
+ *
+ * Pattern:  Strategy + Bridge (GoF). Same shape as cache strategies in
+ *           agentfootprint v2.6 — ONE interface, N concrete drivers,
+ *           consumer picks via explicit import.
+ * Role:     Foundation. Every other detach file imports from here.
+ *           This is the lockable contract; downstream files implement it.
+ *
+ * Two sibling concepts:
+ *
+ *   1. `DetachDriver` — the algorithm that decides WHEN/HOW the work runs.
+ *      Six built-in algorithms ship as algorithm-named exports
+ *      (`microtaskBatchDriver`, `setImmediateDriver`, `sendBeaconDriver`,
+ *      `setTimeoutDriver`, `immediateDriver`, `workerThreadDriver`).
+ *      Consumers can implement their own (BYOS — bring your own driver).
+ *
+ *   2. `DetachHandle` — the consumer-facing handle returned by
+ *      `detachAndJoinLater`. Exposes status as PROPERTIES (sync read)
+ *      and `wait()` (Promise — opt-in async join). Style 2 from the
+ *      panel review: properties for sync, single method for async.
+ *
+ * Naming policy (locked from naming review):
+ *   - Public API uses simple verbs / properties (product-engineer friendly)
+ *   - Internal class names CAN use CS terms (Scheduler, Continuation, etc.)
+ *   - Drivers are algorithm-named (semantic at the algorithm level)
+ *
+ * Locked design decisions (panel review captured in
+ * `docs/inspiration/detach-primitive.md`):
+ *   - Sync hot path; async only at flush boundaries
+ *   - Errors → commitLog + typed event, NEVER thrown to parent
+ *   - Scope isolation between parent and detached child
+ *   - Lifecycle tied to executor disposal
+ *   - Type-level rejection of `outputMapper` on detach options
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/lib/detach/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG","sourcesContent":["/**\n * detach/types.ts — Type definitions for the fire-and-forget primitive.\n *\n * Pattern:  Strategy + Bridge (GoF). Same shape as cache strategies in\n *           agentfootprint v2.6 — ONE interface, N concrete drivers,\n *           consumer picks via explicit import.\n * Role:     Foundation. Every other detach file imports from here.\n *           This is the lockable contract; downstream files implement it.\n *\n * Two sibling concepts:\n *\n *   1. `DetachDriver` — the algorithm that decides WHEN/HOW the work runs.\n *      Six built-in algorithms ship as algorithm-named exports\n *      (`microtaskBatchDriver`, `setImmediateDriver`, `sendBeaconDriver`,\n *      `setTimeoutDriver`, `immediateDriver`, `workerThreadDriver`).\n *      Consumers can implement their own (BYOS — bring your own driver).\n *\n *   2. `DetachHandle` — the consumer-facing handle returned by\n *      `detachAndJoinLater`. Exposes status as PROPERTIES (sync read)\n *      and `wait()` (Promise — opt-in async join). Style 2 from the\n *      panel review: properties for sync, single method for async.\n *\n * Naming policy (locked from naming review):\n *   - Public API uses simple verbs / properties (product-engineer friendly)\n *   - Internal class names CAN use CS terms (Scheduler, Continuation, etc.)\n *   - Drivers are algorithm-named (semantic at the algorithm level)\n *\n * Locked design decisions (panel review captured in\n * `docs/inspiration/detach-primitive.md`):\n *   - Sync hot path; async only at flush boundaries\n *   - Errors → commitLog + typed event, NEVER thrown to parent\n *   - Scope isolation between parent and detached child\n *   - Lifecycle tied to executor disposal\n *   - Type-level rejection of `outputMapper` on detach options\n */\n\nimport type { FlowChart } from '../builder/types.js';\n\n// ─── DetachHandle — what the consumer gets back ──────────────────────\n\n/**\n * Snapshot of a detached handle's state. Returned by `handle.poll()`\n * (when added in a follow-up; v1 exposes properties directly on\n * `DetachHandle`).\n */\nexport interface DetachPollResult {\n  readonly status: DetachHandle['status'];\n  /** Present iff status === 'done'. */\n  readonly result?: unknown;\n  /** Present iff status === 'failed'. */\n  readonly error?: Error;\n}\n\n/**\n * Result delivered when the handle's `wait()` Promise resolves\n * successfully (status reached 'done'). Rejection delivers the\n * native `Error` directly — no wrapping shape.\n */\nexport interface DetachWaitResult {\n  readonly result: unknown;\n}\n\n/**\n * Handle returned by `chart.detachAndJoinLater(...)` and\n * `executor.detachAndJoinLater(...)`. Exposes status as PROPERTIES so\n * sync access is property-read (cheap, no allocation). The single\n * method `wait()` returns a Promise for opt-in async join.\n *\n * The handle is **not** Promise-shaped (no `.then()`) — that would\n * make it accidentally awaitable, defeating the fire-and-forget\n * semantics. To await, the consumer must call `.wait()` explicitly.\n *\n * Lifecycle:\n *\n *   queued  → driver received the work, hasn't started it\n *   running → driver started the work\n *   done    → terminal: result available\n *   failed  → terminal: error available\n *\n * `done` and `failed` are TERMINAL — once reached, status never\n * changes again.\n */\nexport interface DetachHandle {\n  /** Stable id assigned at detach time. Used as the lookup key in\n   *  `detachRegistry` and as the scope-storage key prefix. */\n  readonly id: string;\n\n  /** Current state. Read directly for sync access. */\n  readonly status: 'queued' | 'running' | 'done' | 'failed';\n\n  /** The work's result. Present iff `status === 'done'`. Reading\n   *  before terminal returns `undefined`. */\n  readonly result?: unknown;\n\n  /** The work's error. Present iff `status === 'failed'`. Reading\n   *  before terminal returns `undefined`. */\n  readonly error?: Error;\n\n  /**\n   * Opt-in async join. Returns a Promise that:\n   *   - resolves with `{ result }` when status becomes 'done'\n   *   - rejects with the captured `Error` when status becomes 'failed'\n   *   - resolves/rejects IMMEDIATELY if status is already terminal\n   *   - returns the SAME cached Promise on repeated calls (no\n   *     re-running, no duplicated I/O)\n   *\n   * Calling `wait()` does NOT change the handle's lifecycle — it's\n   * passive observation. If never called, the work still completes;\n   * the handle just goes uncollected (parent execution unaffected).\n   *\n   * Use when:\n   *   - You actually need the result and want to await it\n   *   - Coordinating multiple handles via Promise.all / Promise.race\n   *   - Backpressure (\"don't fire more than N in flight\")\n   *\n   * Don't use when:\n   *   - Pure fire-and-forget (use `detachAndForget` — no handle returned)\n   *   - You just want to check status (read `handle.status` directly)\n   */\n  wait(): Promise<DetachWaitResult>;\n}\n\n// ─── DetachDriver — the algorithm interface ──────────────────────────\n\n/**\n * Capabilities a driver declares. Drives the runtime decision of\n * \"is this driver appropriate for the current environment?\" Consumers\n * inspect at construction; the framework doesn't enforce.\n *\n * All capabilities are optional flags — false / undefined means \"not\n * supported / no claim.\" A driver that supports everything sets all\n * to true.\n */\nexport interface DriverCapabilities {\n  /** Driver works in browser environments (window, document, etc.). */\n  readonly browserSafe?: boolean;\n  /** Driver works in Node.js environments. */\n  readonly nodeSafe?: boolean;\n  /** Driver works in edge runtimes (Cloudflare Workers, Deno Deploy,\n   *  Bun edge, etc. — restricted environments). */\n  readonly edgeSafe?: boolean;\n  /** Work survives page-unload / process-exit. e.g.,\n   *  `sendBeaconDriver` schedules via `navigator.sendBeacon` which\n   *  ships even on tab close. */\n  readonly survivesUnload?: boolean;\n  /** Work runs on a separate OS thread (no event-loop block).\n   *  e.g., `workerThreadDriver`. */\n  readonly cpuIsolated?: boolean;\n}\n\n/**\n * A driver is the WHEN/HOW of the detach. Maps `(child, input, refId)`\n * to a `DetachHandle` whose lifecycle the driver owns.\n *\n * Drivers are themselves footprintjs primitives — internally they may\n * be a single function or a multi-stage flowChart. Either way, the\n * interface they expose to consumers is `schedule(...)`.\n *\n * Drivers MUST:\n *   - Return synchronously (the agent loop never blocks on schedule)\n *   - Not throw — errors during scheduling route through the handle\n *     (`handle.status = 'failed'`, `handle.error = ...`)\n *   - Honor the passive-recorder rule: the parent's `detach*` call\n *     never waits for the driver's deferred work to complete\n *\n * Drivers MAY:\n *   - Implement `validate()` for one-time configuration checks at\n *     registration / use time (e.g., assert `navigator.sendBeacon` exists)\n *   - Build their internal pipeline as a footprintjs flowChart for\n *     observability — driver implementation detail, not consumer-facing\n *\n * @example Built-in\n *   import { microtaskBatchDriver } from 'footprintjs/detach';\n *   const handle = driver.schedule(child, input, refId);\n *\n * @example Custom (BYOS)\n *   const lambdaExtensionDriver: DetachDriver = {\n *     name: 'lambda-extension',\n *     capabilities: { nodeSafe: true, survivesUnload: true },\n *     schedule(child, input, refId) {\n *       sharedBuffer.push({ refId, child, input });\n *       return createHandle(refId, 'queued');\n *     },\n *   };\n */\nexport interface DetachDriver {\n  /** Stable name for diagnostics + registry lookup. Conventionally\n   *  algorithm-named (e.g. `'microtask-batch'`, `'send-beacon'`). */\n  readonly name: string;\n\n  /** What this driver supports. Used by consumers to pick the right\n   *  driver for their environment. */\n  readonly capabilities: DriverCapabilities;\n\n  /**\n   * Hand the work to the driver's scheduling mechanism. MUST return\n   * synchronously with a fresh `DetachHandle`. The actual work may\n   * run later (next microtask / setImmediate / browser-beacon-flush /\n   * worker-thread / etc.) on the driver's chosen mechanism.\n   */\n  schedule(child: FlowChart, input: unknown, refId: string): DetachHandle;\n\n  /**\n   * Optional one-time validation hook. Called at first use (or\n   * registration time, depending on driver) — drivers throw if their\n   * configuration is invalid (missing peer dep, unreachable endpoint,\n   * wrong API key shape, etc.).\n   *\n   * Example: `sendBeaconDriver.validate()` checks\n   * `typeof navigator?.sendBeacon === 'function'` and throws with a\n   * helpful message if absent (e.g., in Node).\n   *\n   * Per the New Relic panel review: early-fail-with-useful-message\n   * beats silent zero-emission.\n   */\n  validate?(): void;\n}\n"]}