@nimbus-sh/worker 0.3.0 → 0.4.0

package/dist/npm/pre-bundle-facet.js

@@ -1,5 +1,5 @@
 /**
- * pre-bundle-facet.ts — LoaderPool entry for esbuild pre-bundling.
+ * pre-bundle-facet.ts — IsolatePool entry for esbuild pre-bundling.
  *
  * Why this exists
  * ───────────────
@@ -14,7 +14,7 @@
  * the previous isolate.
  *
  * The fix is to dispatch each per-specifier `esbuild.build` to a
- * LoaderPool isolate. Each facet has its own 128 MB budget and
+ * IsolatePool isolate. Each facet has its own 128 MB budget and
  * stable-slot reuse keeps the warm-up cost amortized across the 8
  * concurrent specs of a typical install. The install-batch facet uses
  * the same isolate boundary for tarball extraction.
@@ -181,7 +181,7 @@ export function externalsForSpecifier(specifier) {
 }
 // ── Facet function ──────────────────────────────────────────────────────
 //
-// `prebundleOne` runs inside a LoaderPool isolate. cloudflare-parallel
+// `prebundleOne` runs inside a IsolatePool isolate. cloudflare-parallel
 // serialises it via fn.toString(); the helpers it references at module
 // scope (ESBUILD_WASM_JS_FN_BODY, resolvePackageEntry) are NOT in the
 // facet's lexical scope at runtime. Instead they're injected by the
@@ -250,7 +250,7 @@ export const prebundleOne = async function prebundleOne(spec, _env) {
     //    runs that at module-load time (where eval is permitted) and
     //    stashes the result on the module-scope const __NIMBUS_ESBUILD_NS.
     //
-    //    The WASM module is shipped into the facet via LoaderPool's
+    //    The WASM module is shipped into the facet via IsolatePool's
     //    `wasmModules` option, registered in the LOADER's modules map as
     //    { wasm: ArrayBuffer }. Workerd compiles it during the worker's
     //    module-load phase (eval permitted there), and the pool's
@@ -285,7 +285,7 @@ export const prebundleOne = async function prebundleOne(spec, _env) {
     if (!initPromise) {
         initPromise = (async () => {
             // Read the WebAssembly.Module the pool registered. The key matches
-            // the name passed to LoaderPool's `wasmModules` option (see
+            // the name passed to IsolatePool's `wasmModules` option (see
             // src/npm-installer.ts:prebundleUsedModules dispatch site).
             const wasmRegistry = globalThis.__NIMBUS_WASM;
             const wasmModule = wasmRegistry && wasmRegistry['esbuild.wasm'];

package/dist/npm/r2-cache.d.ts

@@ -220,7 +220,7 @@ export declare function packumentKey(name: string): string;
  * proving the L2 layer is functional even when local-dev wall-clock
  * latency is too noisy to demonstrate 5×.
  *
- * Diag counters (src/observability/diag-counters.ts) bump for the
+ * Diag counters (@nimbus-sh/platform/diag-counters.js) bump for the
  * SupervisorRPC layer (RPC-perspective hit/miss). These per-instance
  * counters bump for the R2CacheClient call surface itself (L2 vs L3
  * vs miss), independent of who's calling.

package/dist/npm/resolve-facet.d.ts

@@ -1,7 +1,7 @@
 /**
  * resolve-facet.ts — shared wire types for the per-packument resolver facet.
  *
- * The npm resolver phase runs inside a LoaderPool isolate so the
+ * The npm resolver phase runs inside a IsolatePool isolate so the
  * supervisor DO heap stays flat while large packuments are decoded. The
  * per-packument task body lives in resolve-one-facet.ts; this module holds
  * the types exchanged between supervisor and facet over RPC.

package/dist/npm/resolve-facet.js

@@ -1,7 +1,7 @@
 /**
  * resolve-facet.ts — shared wire types for the per-packument resolver facet.
  *
- * The npm resolver phase runs inside a LoaderPool isolate so the
+ * The npm resolver phase runs inside a IsolatePool isolate so the
  * supervisor DO heap stays flat while large packuments are decoded. The
  * per-packument task body lives in resolve-one-facet.ts; this module holds
  * the types exchanged between supervisor and facet over RPC.

package/dist/npm/resolve-one-facet.d.ts

@@ -7,10 +7,10 @@
  * independent fanout tasks. This file is the per-task body: one packument
  * fetch, one version pick, and edge extraction.
  *
- * Each task runs inside a Worker Loader isolate (FanoutPool routes
+ * Each task runs inside a Worker Loader isolate (Fanout routes
  * automatically: <5 = in-DO, ≥5 = peer-DO). The isolate is short-lived;
  * task body has its own ~128 MiB envelope. Parallelism = layer width
- * (capped at 32 by FanoutPool's MAX_PEER_FANOUT).
+ * (capped at 32 by Fanout's MAX_PEER_FANOUT).
  *
  * Stability invariants (cloudflare-parallel serialises via fn.toString)
  * ───────────────────────────────────────────────────────────────────
@@ -180,13 +180,13 @@ export interface ResolveOneResult {
 }
 /**
  * Per-package fanout task body. Serialised via fn.toString() and
- * dispatched by FanoutPool.submitMany — see installer.ts
+ * dispatched by Fanout.submitMany — see installer.ts
  * resolveTreeViaFanout.
  *
- * Function signature MUST be `(spec, env)` so FanoutPool's
+ * Function signature MUST be `(spec, env)` so Fanout's
  * submitMany invocation `fn(item, env)` lines up.
  *
- * `env` is the loader-isolate env supplied by FanoutPool.
+ * `env` is the loader-isolate env supplied by Fanout.
  * `env.SUPERVISOR` is the supervisor-rpc binding (putRegistryEntries,
  * getPackument).
  */

package/dist/npm/resolve-one-facet.js

@@ -7,10 +7,10 @@
  * independent fanout tasks. This file is the per-task body: one packument
  * fetch, one version pick, and edge extraction.
  *
- * Each task runs inside a Worker Loader isolate (FanoutPool routes
+ * Each task runs inside a Worker Loader isolate (Fanout routes
  * automatically: <5 = in-DO, ≥5 = peer-DO). The isolate is short-lived;
  * task body has its own ~128 MiB envelope. Parallelism = layer width
- * (capped at 32 by FanoutPool's MAX_PEER_FANOUT).
+ * (capped at 32 by Fanout's MAX_PEER_FANOUT).
  *
  * Stability invariants (cloudflare-parallel serialises via fn.toString)
  * ───────────────────────────────────────────────────────────────────
@@ -61,13 +61,13 @@
  */
 /**
  * Per-package fanout task body. Serialised via fn.toString() and
- * dispatched by FanoutPool.submitMany — see installer.ts
+ * dispatched by Fanout.submitMany — see installer.ts
  * resolveTreeViaFanout.
  *
- * Function signature MUST be `(spec, env)` so FanoutPool's
+ * Function signature MUST be `(spec, env)` so Fanout's
  * submitMany invocation `fn(item, env)` lines up.
  *
- * `env` is the loader-isolate env supplied by FanoutPool.
+ * `env` is the loader-isolate env supplied by Fanout.
  * `env.SUPERVISOR` is the supervisor-rpc binding (putRegistryEntries,
  * getPackument).
  */

package/dist/router/index.js

@@ -35,7 +35,7 @@ import { generateSessionId, isValidSessionId, } from '../_shared/session-id.js';
 import { buildPreviewHost, isPreviewHostSafeSid, parsePreviewHost, readPreviewHostSuffix, } from '../_shared/preview-host.js';
 import { parseSessionRoute, forwardToSession, renderInvalidSessionHtml, SESSION_ROUTE_PREFIX, LEGACY_PUBLIC_DO_SEGMENT, } from '../_shared/session-router.js';
 import { issueNimbusToken, verifyNimbusToken, verifyRequestToken, requireScopes, requireSessionPin, authErrorResponse, setNimbusTokenCookie, NIMBUS_TOKEN_QUERY, NimbusAuthError, NimbusBootstrapConsumedError, NimbusTokenClaimsError, DEFAULT_TOKEN_TTL_MS, ATTACH_BOOTSTRAP_TTL_MS, } from '../auth/index.js';
-import { setCtxExports } from '@nimbus-sh/fabric/ctx-exports.js';
+import { adoptCtxExports } from '@nimbus-sh/fabric/composition.js';
 import { handleNimbusRemoteApi, } from './remote-api.js';
 import { parseAgentOAuthStateParam } from '../session/agent.js';
 /**
@@ -82,7 +82,7 @@ export function createNimbusHandler(options = {}) {
     async function route(request, env, ctx) {
         // Capture ctx.exports on first call (loopback bindings for facets).
         if (ctx?.exports)
-            setCtxExports(ctx.exports);
+            adoptCtxExports(ctx.exports);
         const url = new URL(request.url);
         const previewSuffix = readPreviewHostSuffix(env);
         // ── <port>--<sid>.<suffix> — port preview ───────────────────────

package/dist/router/remote-api.js

@@ -1,7 +1,7 @@
 import { LEGACY_PUBLIC_DO_SEGMENT, } from '../_shared/session-router.js';
 import { z } from 'zod/v4';
 import { requireScopes, requireSessionPin, verifyRequestToken, NimbusAuthError, isNimbusIdComponent, } from '../auth/index.js';
-import { useRpcResource } from '@nimbus-sh/core/_shared/rpc-dispose.js';
+import { useRpcResource } from '@nimbus-sh/platform/rpc-dispose.js';
 const DEFAULT_REMOTE_BASE_PATH = '/api/nimbus/v1';
 const RemoteRpcBodySchema = z.object({
     profile: z.string().optional(),

package/dist/runtime/bun-repl.d.ts

@@ -7,7 +7,7 @@
  * functions / imports persist.
  *
  * Design:
- *   - One child-facet per REPL session (LoaderPool with
+ *   - One child-facet per REPL session (IsolatePool with
  *     concurrency=1, omitSupervisor=true).
  *   - Facet-side: globalThis.__nimbus_bun_ctx caches a vm.createContext()
  *     dict; each push() runs vm.runInContext(line, ctx) and returns

package/dist/runtime/bun-repl.js

@@ -7,7 +7,7 @@
  * functions / imports persist.
  *
  * Design:
- *   - One child-facet per REPL session (LoaderPool with
+ *   - One child-facet per REPL session (IsolatePool with
  *     concurrency=1, omitSupervisor=true).
  *   - Facet-side: globalThis.__nimbus_bun_ctx caches a vm.createContext()
  *     dict; each push() runs vm.runInContext(line, ctx) and returns
@@ -125,8 +125,8 @@ class BunReplAdapter {
         // Preamble: install the Bun shim global at facet startup so the
         // REPL context has Bun.* available like real Bun does.
         const preamble = BUN_SHIM_PREAMBLE;
-        const { LoaderPool } = await import('@nimbus-sh/fabric/loader-pool.js');
-        this.pool = new LoaderPool(env, ctx, {
+        const { IsolatePool } = await import('@nimbus-sh/fabric/isolate-pool.js');
+        this.pool = new IsolatePool(env, ctx, {
             tag: 'bun-repl',
             concurrency: 1,
             omitSupervisor: true,

package/dist/runtime/esbuild-wasm-bytes.js

@@ -43,7 +43,7 @@
  */
 import { ESBUILD_VERSION } from '@nimbus-sh/core/constants.js';
 import { ESBUILD_WASM_SHA256 } from '../esbuild-wasm-bundle.generated.js';
-import { disposeRpcResource } from '@nimbus-sh/core/_shared/rpc-dispose.js';
+import { disposeRpcResource } from '@nimbus-sh/platform/rpc-dispose.js';
 import { sha256Hex } from '@nimbus-sh/core/_shared/crypto.js';
 /**
  * Path inside env.ASSETS where the esbuild-wasm binary lives.

package/dist/runtime/facet-loader-host.d.ts

@@ -1,7 +1,7 @@
 /**
  * The workerd {@link FacetHost}: a facet is a dynamic worker.
  *
- * The whole adapter is the option renames below, because `LoaderPool`
+ * The whole adapter is the option renames below, because `IsolatePool`
  * already IS the port's shape — `submit` and `dispose`, with the same meanings.
  * The one thing it spells differently is the supervisor capability, which it
  * takes as a pid plus a separate flag saying whether to bind one at all; the
@@ -13,7 +13,7 @@ import type { FacetHost } from '@nimbus-sh/core/runtime/facet-host.js';
 import type { FacetManager } from '../facets/manager.js';
 export declare function loaderFacetHost(env: unknown, ctx: DurableObjectState): FacetHost;
 /**
- * The two objects a LoaderPool needs from a FacetManager, via the manager's
+ * The two objects a IsolatePool needs from a FacetManager, via the manager's
  * own `loaderHost()` accessor. The runtime guard stays: harnesses build
  * FacetManagers on mock contexts, and one built on something other than a
  * DurableObjectState should fail with a sentence instead of at the first RPC.

package/dist/runtime/facet-loader-host.js

@@ -1,5 +1,5 @@
 import { manifestVfs } from '@nimbus-sh/core/runtime/vfs-manifest.js';
-import { LoaderPool } from '@nimbus-sh/fabric/loader-pool.js';
+import { IsolatePool } from '@nimbus-sh/fabric/isolate-pool.js';
 export function loaderFacetHost(env, ctx) {
     return {
         // workerd suspends a guest through JSPI, which is what lets a syscall reach
@@ -14,7 +14,7 @@ export function loaderFacetHost(env, ctx) {
             return manifestVfs(vfs, root, options);
         },
         open(spec) {
-            return new LoaderPool(env, ctx, {
+            return new IsolatePool(env, ctx, {
                 tag: spec.tag,
                 concurrency: spec.concurrency,
                 preamble: spec.preamble,
@@ -27,7 +27,7 @@ export function loaderFacetHost(env, ctx) {
     };
 }
 /**
- * The two objects a LoaderPool needs from a FacetManager, via the manager's
+ * The two objects a IsolatePool needs from a FacetManager, via the manager's
  * own `loaderHost()` accessor. The runtime guard stays: harnesses build
  * FacetManagers on mock contexts, and one built on something other than a
  * DurableObjectState should fail with a sentence instead of at the first RPC.

package/dist/runtime/node-repl.js

@@ -113,8 +113,8 @@ class NodeReplAdapter {
         const { facetMgr } = this.deps;
         const env = facetMgr.env;
         const ctx = facetMgr.ctx;
-        const { LoaderPool } = await import('@nimbus-sh/fabric/loader-pool.js');
-        this.pool = new LoaderPool(env, ctx, {
+        const { IsolatePool } = await import('@nimbus-sh/fabric/isolate-pool.js');
+        this.pool = new IsolatePool(env, ctx, {
             tag: 'node-repl',
             concurrency: 1,
             omitSupervisor: true,

package/dist/runtime/node-shims-artifact.js

@@ -16,7 +16,7 @@
  * facet with no node-compat layer.
  */
 import { NODE_SHIMS_BUILD_ID, NODE_SHIMS_ENTRY, NODE_SHIMS_SHA256, } from '../node-shims-artifact.generated.js';
-import { disposeRpcResource } from '@nimbus-sh/core/_shared/rpc-dispose.js';
+import { disposeRpcResource } from '@nimbus-sh/platform/rpc-dispose.js';
 import { sha256Hex } from '@nimbus-sh/core/_shared/crypto.js';
 const L2_KEY = `https://nimbus-cache.invalid${NODE_SHIMS_ENTRY}?build=${NODE_SHIMS_BUILD_ID}`;
 const ASSET_URL = `https://nimbus-internal.invalid${NODE_SHIMS_ENTRY}`;

package/dist/runtime/node-shims.js

@@ -41,7 +41,8 @@ import { generateUndiciShimCode } from '@nimbus-sh/core/runtime/undici-shim.js';
 import { getExportsResolverJS } from '@nimbus-sh/core/_shared/exports-resolver.js';
 import { getTypescriptSpecifiersJS } from '@nimbus-sh/core/_shared/typescript-specifiers.js';
 import { NIMBUS_AI_CREDENTIAL_HEADERS, NIMBUS_AI_TOKEN_ENV } from '@nimbus-sh/core/_shared/ai-egress.js';
-import { FACET_PROVIDED_PACKAGES, FS_READ_BATCH_PATH_LIMIT, FS_READ_BATCH_REQUEST_BYTES, MAX_RPC_SAFE_PAYLOAD_BYTES, NIMBUS_AI_GATEWAY_PORT, NODE_VERSION, NODE_VERSIONS, } from '@nimbus-sh/core/constants.js';
+import { MAX_RPC_SAFE_PAYLOAD_BYTES } from '@nimbus-sh/platform/limits.js';
+import { FACET_PROVIDED_PACKAGES, FS_READ_BATCH_PATH_LIMIT, FS_READ_BATCH_REQUEST_BYTES, NIMBUS_AI_GATEWAY_PORT, NODE_VERSION, NODE_VERSIONS, } from '@nimbus-sh/core/constants.js';
 const STREAMS_CODE = generateStreamsCode();
 const SQLITE_SHIM_CODE = generateSqliteShimCode();
 const UNDICI_SHIM_CODE = generateUndiciShimCode();

package/dist/runtime/opencode-artifact.js

@@ -20,7 +20,7 @@
  * (see OPENCODE_TREE_SITTER_WASMS and FacetManager.treeSitterModuleEntries).
  */
 import { OPENCODE_ARTIFACT_BUILD_ID, OPENCODE_ARTIFACT_DIGESTS, OPENCODE_ARTIFACT_PRESENT, OPENCODE_ARTIFACT_VERSION, } from '../opencode-artifact.generated.js';
-import { disposeRpcResource } from '@nimbus-sh/core/_shared/rpc-dispose.js';
+import { disposeRpcResource } from '@nimbus-sh/platform/rpc-dispose.js';
 import { sha256Hex } from '@nimbus-sh/core/_shared/crypto.js';
 /** Base asset path of the staged opencode bundle directory. */
 const OPENCODE_ASSET_BASE = `/_assets/opencode/${OPENCODE_ARTIFACT_VERSION}`;

package/dist/runtime/opentui-wasm-bytes.js

@@ -16,7 +16,7 @@
  * the backend.
  */
 import { OPENTUI_WASM_BUILD_ID, OPENTUI_WASM_ENTRY, OPENTUI_WASM_SHA256, } from '../opentui-wasm-artifact.generated.js';
-import { disposeRpcResource } from '@nimbus-sh/core/_shared/rpc-dispose.js';
+import { disposeRpcResource } from '@nimbus-sh/platform/rpc-dispose.js';
 import { sha256Hex } from '@nimbus-sh/core/_shared/crypto.js';
 /**
  * Synthetic L2 cache key for the OpenTUI wasm asset. Build-id-pinned so a

package/dist/runtime/python-repl.js

@@ -207,7 +207,7 @@ class PythonReplAdapter {
         snapshot.files[stdlibPath.replace(/^\/+/, '')] = btoa(bin);
         this.fsSnapshot = snapshot;
         this.pythonHome = `/${installRoot.replace(/^\/+/, '')}`;
-        const { LoaderPool } = await import('@nimbus-sh/fabric/loader-pool.js');
+        const { IsolatePool } = await import('@nimbus-sh/fabric/isolate-pool.js');
         const host = getFacetManagerLoaderHost(facetMgr);
         // A prompt where `open(path, "w")` silently does nothing is worse than one
         // that refuses to start, so the pid decides which pool this is. Written as
@@ -225,11 +225,11 @@ class PythonReplAdapter {
         };
         const pid = this.deps.pid;
         this.pool = (typeof pid === 'number' && pid > 0
-            ? new LoaderPool(host.env, host.ctx, { ...base, supervisorPid: pid })
+            ? new IsolatePool(host.env, host.ctx, { ...base, supervisorPid: pid })
             // The install-time warm-up has no invoking process. It boots the
             // interpreter and never touches a file, so it asks for no supervisor
             // rather than binding one it cannot authenticate to.
-            : new LoaderPool(host.env, host.ctx, { ...base, omitSupervisor: true }));
+            : new IsolatePool(host.env, host.ctx, { ...base, omitSupervisor: true }));
     }
     async submit(userCode) {
         const result = await this.pool.submit(pythonReplStepFacetFn, {

package/dist/runtime/ruby-repl.js

@@ -156,10 +156,10 @@ class RubyReplAdapter {
         // drifted (it lacked the language-prelude const __rubyRun requires, so
         // every REPL eval died on boot) — compose it in exactly one place.
         const preamble = buildRubyPreamble();
-        const { LoaderPool } = await import('@nimbus-sh/fabric/loader-pool.js');
+        const { IsolatePool } = await import('@nimbus-sh/fabric/isolate-pool.js');
         const env = facetMgr.env;
         const ctx = facetMgr.ctx;
-        this.pool = new LoaderPool(env, ctx, {
+        this.pool = new IsolatePool(env, ctx, {
             tag: 'ruby-repl',
             concurrency: 1,
             omitSupervisor: true,

package/dist/runtime/sqlite-wasm-bytes.js

@@ -17,7 +17,7 @@
  */
 import { SQLJS_VERSION } from '@nimbus-sh/core/constants.js';
 import { SQLITE_WASM_SHA256 } from '../sqlite-wasm-bundle.generated.js';
-import { disposeRpcResource } from '@nimbus-sh/core/_shared/rpc-dispose.js';
+import { disposeRpcResource } from '@nimbus-sh/platform/rpc-dispose.js';
 import { sha256Hex } from '@nimbus-sh/core/_shared/crypto.js';
 /**
  * Path inside env.ASSETS where the sql.js wasm binary lives. Versioned so

package/dist/session/diag.js

@@ -16,7 +16,7 @@
  *
  * Per DEFECT-D1: ctx is taken as a separate explicit arg.
  */
-import { rehydrateFromStorage, snapshotForStorage, getFailures, } from '@nimbus-sh/core/observability/oom-discriminator.js';
+import { rehydrateFromStorage, snapshotForStorage, getFailures, } from '@nimbus-sh/platform/oom-discriminator.js';
 import { W5_RING_STORAGE_KEY } from './keys.js';
 export function readNodeMem() {
     try {

package/dist/session/hibernation.d.ts

@@ -22,10 +22,10 @@
  *     reason dispatcher with this session's handlers registered.
  *   - flushOnClose(host) — synchronous flush on ws close.
  *
- * The alarm multiplexer itself (reason map, scheduleAlarm, the per-instance
- * chain) and maybeBumpIsolateGen are fabric machinery —
- * `@nimbus-sh/fabric/alarms.js`; this module registers the session's reasons
- * ('w9-flush' | 'log-janitor' | 'resident-launch') on top of it.
+ * The timer multiplexer itself (reason map, schedule, the per-instance
+ * chain) is fabric machinery — `@nimbus-sh/fabric/timers.js`; this module
+ * registers the session's reasons ('w9-flush' | 'log-janitor' |
+ * 'resident-launch') on top of it.
  *
  * **`ctx` taken as a separate arg from `host`** because the parent
  * `CloudflareDurableObject` class declares `ctx` as `protected`, which
@@ -40,7 +40,7 @@
  */
 import type { SessionProcessSupervisor } from '@nimbus-sh/core/runtime/session-process-supervisor.js';
 import { type WsHibernationConfigResult } from '@nimbus-sh/fabric/ws-hibernation-config.js';
-import { type AlarmHost, type IsolateGenHost } from '@nimbus-sh/fabric/alarms.js';
+import { type TimerHost } from '@nimbus-sh/fabric/timers.js';
 export type { WsHibernationConfigResult };
 /**
  * Minimal host shape. `_w9*` fields drop `private` on the class so
@@ -49,7 +49,7 @@ export type { WsHibernationConfigResult };
  *
  * `ctx` is NOT in this interface — passed as a separate arg.
  */
-export interface HibHost extends AlarmHost, IsolateGenHost {
+export interface HibHost extends TimerHost {
     processes: SessionProcessSupervisor;
     _w9SchemaInit: boolean;
     _w9PersistWired: boolean;
@@ -114,7 +114,7 @@ export type AlarmReason = 'w9-flush' | 'log-janitor' | 'resident-launch';
 /**
  * W9: ensure the alarm is set for the next flush window. Cheap to
  * call repeatedly — we only schedule the in-isolate flush timer if
- * it isn't already set. The persistent alarm goes through scheduleAlarm
+ * it isn't already set. The persistent alarm goes through timers.schedule
  * so it coordinates with W1's log-janitor sweep.
  */
 export declare function scheduleHibFlush(host: HibHost, ctx: any): void;
@@ -130,7 +130,7 @@ export declare function scheduleHibFlush(host: HibHost, ctx: any): void;
  * caller (typically `(pid) => !host.processes.get(pid)`). Decoupled
  * so HibHost doesn't need to import ProcessTable.
  */
-export declare function dispatchAlarm(host: HibHost, ctx: any, janitorOrphanCheck?: (pid: number) => boolean, pumpResidentLaunches?: () => Promise<void>): Promise<void>;
+export declare function dispatchAlarm(host: HibHost, ctx: any, janitorOrphanCheck?: (pid: number) => boolean, pumpResidentLaunches?: () => Promise<void>, alarmInfo?: AlarmInvocationInfo): Promise<void>;
 /**
  * W9: synchronous flush of the process-log ring on session close.
  * Wraps `processes.flushLogs()` in a try/catch so a flush failure

package/dist/session/hibernation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hibernation.d.ts","sourceRoot":"","sources":["../../src/session/hibernation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAGH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uDAAuD,CAAC;AACtG,OAAO,EAA0B,KAAK,yBAAyB,EAAE,MAAM,4CAA4C,CAAC;AACpH,OAAO,EAGL,KAAK,SAAS,EACd,KAAK,cAAc,EACpB,MAAM,6BAA6B,CAAC;AAGrC,YAAY,EAAE,yBAAyB,EAAE,CAAC;AAE1C;;;;;;GAMG;AACH,MAAM,WAAW,OAAQ,SAAQ,SAAS,EAAE,cAAc;IACxD,SAAS,EAAE,wBAAwB,CAAC;IACpC,aAAa,EAAE,OAAO,CAAC;IACvB,eAAe,EAAE,OAAO,CAAC;IACzB,aAAa,EAAE,GAAG,CAAC;IACnB,4EAA4E;IAC5E,eAAe,EAAE,OAAO,CAAC;IACzB,uEAAuE;IACvE,mBAAmB,EAAE,OAAO,CAAC;CAC9B;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,GAAG,GAAG,yBAAyB,CAY9E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CA6GnE;AAED;;;;;;;;;;GAUG;AACH;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CAMrE;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CAc9D;AAED,2CAA2C;AAC3C,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CAqB7D;AAED;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,aAAa,GAAG,iBAAiB,CAAC;AAEzE;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CAqB9D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,OAAO,EACb,GAAG,EAAE,GAAG,EACR,kBAAkB,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,EAC7C,oBAAoB,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GACzC,OAAO,CAAC,IAAI,CAAC,CAuCf;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAMhD"}
+{"version":3,"file":"hibernation.d.ts","sourceRoot":"","sources":["../../src/session/hibernation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAGH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uDAAuD,CAAC;AACtG,OAAO,EAA0B,KAAK,yBAAyB,EAAE,MAAM,4CAA4C,CAAC;AACpH,OAAO,EAAU,KAAK,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAGrE,YAAY,EAAE,yBAAyB,EAAE,CAAC;AAE1C;;;;;;GAMG;AACH,MAAM,WAAW,OAAQ,SAAQ,SAAS;IACxC,SAAS,EAAE,wBAAwB,CAAC;IACpC,aAAa,EAAE,OAAO,CAAC;IACvB,eAAe,EAAE,OAAO,CAAC;IACzB,aAAa,EAAE,GAAG,CAAC;IACnB,4EAA4E;IAC5E,eAAe,EAAE,OAAO,CAAC;IACzB,uEAAuE;IACvE,mBAAmB,EAAE,OAAO,CAAC;CAC9B;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,GAAG,GAAG,yBAAyB,CAY9E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CA6GnE;AAED;;;;;;;;;;GAUG;AACH;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CAMrE;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CAc9D;AAED,2CAA2C;AAC3C,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CAqB7D;AAED;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,aAAa,GAAG,iBAAiB,CAAC;AAEzE;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CAqB9D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,OAAO,EACb,GAAG,EAAE,GAAG,EACR,kBAAkB,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,EAC7C,oBAAoB,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EAC1C,SAAS,CAAC,EAAE,mBAAmB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAuCf;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAMhD"}

package/dist/session/hibernation.js

@@ -22,10 +22,10 @@
  *     reason dispatcher with this session's handlers registered.
  *   - flushOnClose(host) — synchronous flush on ws close.
  *
- * The alarm multiplexer itself (reason map, scheduleAlarm, the per-instance
- * chain) and maybeBumpIsolateGen are fabric machinery —
- * `@nimbus-sh/fabric/alarms.js`; this module registers the session's reasons
- * ('w9-flush' | 'log-janitor' | 'resident-launch') on top of it.
+ * The timer multiplexer itself (reason map, schedule, the per-instance
+ * chain) is fabric machinery — `@nimbus-sh/fabric/timers.js`; this module
+ * registers the session's reasons ('w9-flush' | 'log-janitor' |
+ * 'resident-launch') on top of it.
  *
  * **`ctx` taken as a separate arg from `host`** because the parent
  * `CloudflareDurableObject` class declares `ctx` as `protected`, which
@@ -39,7 +39,7 @@
  * wireProcessLogPersist again.
  */
 import { configureWsHibernation } from '@nimbus-sh/fabric/ws-hibernation-config.js';
-import { dispatchAlarm as dispatchAlarmReasons, scheduleAlarm, } from '@nimbus-sh/fabric/alarms.js';
+import { timers } from '@nimbus-sh/fabric/timers.js';
 import { SESSION_DESTROYED_KEY, W9_FLUSH_DEBOUNCE_MS } from './keys.js';
 /**
  * Run at DO ctor time. Returns the result for the class to assign to
@@ -216,11 +216,11 @@ export function ensureLogJanitor(host, ctx) {
     if (host._w1SessionDestroyed)
         return;
     // Optimistic flag (dedupes same-tick appends), CONFIRMED by the schedule
-    // outcome: scheduleAlarm swallows storage errors, and a failure with the
+    // outcome: timers.schedule swallows storage errors, and a failure with the
     // flag left set would mean no alarm AND nothing ever re-arming until the
     // instance recycles.
     host._w1JanitorArmed = true;
-    void scheduleAlarm(host, ctx, 'log-janitor', Date.now() + 60_000).then((ok) => {
+    void timers(host, ctx).schedule('log-janitor', Date.now() + 60_000).then((ok) => {
         if (!ok)
             host._w1JanitorArmed = false;
     });
@@ -249,7 +249,7 @@ export function ensureHibSchema(host, ctx) {
 /**
  * W9: ensure the alarm is set for the next flush window. Cheap to
  * call repeatedly — we only schedule the in-isolate flush timer if
- * it isn't already set. The persistent alarm goes through scheduleAlarm
+ * it isn't already set. The persistent alarm goes through timers.schedule
  * so it coordinates with W1's log-janitor sweep.
  */
 export function scheduleHibFlush(host, ctx) {
@@ -271,10 +271,10 @@ export function scheduleHibFlush(host, ctx) {
     }, W9_FLUSH_DEBOUNCE_MS);
     // Persistent alarm: fires post-hibernation if the in-isolate timer
     // didn't get a chance to run (DO evicted under memory pressure
-    // before the 250ms debounce expired). Coordinated via scheduleAlarm
+    // before the 250ms debounce expired). Coordinated via timers.schedule
     // so W1's log-janitor doesn't clobber it (or vice-versa).
-    // Fire-and-forget — scheduleAlarm is fail-soft.
-    void scheduleAlarm(host, ctx, 'w9-flush', Date.now() + W9_FLUSH_DEBOUNCE_MS * 4);
+    // Fire-and-forget — timers.schedule is fail-soft.
+    void timers(host, ctx).schedule('w9-flush', Date.now() + W9_FLUSH_DEBOUNCE_MS * 4);
 }
 /**
  * W1: this session's alarm() handler body — the fabric's multi-reason
@@ -288,8 +288,8 @@ export function scheduleHibFlush(host, ctx) {
  * caller (typically `(pid) => !host.processes.get(pid)`). Decoupled
  * so HibHost doesn't need to import ProcessTable.
  */
-export function dispatchAlarm(host, ctx, janitorOrphanCheck, pumpResidentLaunches) {
-    return dispatchAlarmReasons(host, ctx, {
+export function dispatchAlarm(host, ctx, janitorOrphanCheck, pumpResidentLaunches, alarmInfo) {
+    return timers(host, ctx).dispatch({
         'w9-flush': () => {
             host.processes.flushLogs();
         },
@@ -322,14 +322,14 @@ export function dispatchAlarm(host, ctx, janitorOrphanCheck, pumpResidentLaunche
         // Legacy path: pre-W1 deploys had no map. dispatchAlarm was called
         // with no map and unconditionally ran the log flush. Preserve
         // that on a missing map (one-time post-deploy, then the map is
-        // populated by the next scheduleHibFlush / scheduleAlarm call).
+        // populated by the next scheduleHibFlush / timers.schedule call).
         try {
             host.processes.flushLogs();
         }
         catch (e) {
             console.warn('[nimbus/W9] legacy flush threw:', e?.message);
         }
-    });
+    }, alarmInfo);
 }
 /**
  * W9: synchronous flush of the process-log ring on session close.

package/dist/session/init-phases.d.ts

@@ -32,7 +32,7 @@
  * preserved — old probes still see it. New phase entries are
  * additional ring entries, not replacements.
  */
-import { type SessionState } from '@nimbus-sh/core/observability/oom-discriminator.js';
+import { type SessionState } from '@nimbus-sh/platform/oom-discriminator.js';
 /**
  * Set the current phase + record a transition. Fail-soft on the
  * observability call; the phase update on `self` is direct and
@@ -40,7 +40,7 @@ import { type SessionState } from '@nimbus-sh/core/observability/oom-discriminat
  */
 export declare function setPhase(self: {
     _b4Phase: SessionState | null;
-    _isolateGen?: number;
+    ctx?: unknown;
 }, toState: SessionState, trigger: string): void;
 /**
  * [B'.5] Identify the original phase-based warm-rejoin case. The /ws
@@ -93,7 +93,6 @@ export declare function joinExistingSession(self: {
         write(s: string): void;
     };
     _b4Phase: SessionState | null;
-    _isolateGen?: number;
     _b4WarmJoinCount: number;
 }, ws: WebSocket, appendScrollback: (ctx: any, data: string, atMs: number) => void, loadScrollback: (ctx: any) => string): void;
 export {};

package/dist/session/init-phases.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init-phases.d.ts","sourceRoot":"","sources":["../../src/session/init-phases.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAuB,KAAK,YAAY,EAAE,MAAM,oDAAoD,CAAC;AAE5G;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE;IAAE,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,EAC7D,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,MAAM,GACd,IAAI,CAcN;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE;IACjC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IAC9B,KAAK,EAAE,GAAG,CAAC;IAAC,QAAQ,EAAE,GAAG,CAAC;IAAC,MAAM,EAAE,GAAG,CAAC;CACxC,GAAG,OAAO,CAKV;AAED,KAAK,iBAAiB,GAAG,WAAW,GAAG,UAAU,GAAG,MAAM,CAAC;AAE3D;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACtC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IAC9B,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;CACjB,EAAE,OAAO,EAAE,SAAS,SAAS,EAAE,GAAG,iBAAiB,CAmBnD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE;IACJ,GAAG,EAAE,GAAG,CAAC;IACT,QAAQ,EAAE;QAAE,MAAM,CAAC,EAAE,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAAC;QAAC,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;IACpG,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;CAC1B,EACD,EAAE,EAAE,SAAS,EACb,gBAAgB,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,EAChE,cAAc,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,GACnC,IAAI,CAsCN"}
+{"version":3,"file":"init-phases.d.ts","sourceRoot":"","sources":["../../src/session/init-phases.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAuB,KAAK,YAAY,EAAE,MAAM,0CAA0C,CAAC;AAGlG;;;;GAIG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE;IAAE,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IAAC,GAAG,CAAC,EAAE,OAAO,CAAA;CAAE,EACtD,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,MAAM,GACd,IAAI,CAcN;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE;IACjC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IAC9B,KAAK,EAAE,GAAG,CAAC;IAAC,QAAQ,EAAE,GAAG,CAAC;IAAC,MAAM,EAAE,GAAG,CAAC;CACxC,GAAG,OAAO,CAKV;AAED,KAAK,iBAAiB,GAAG,WAAW,GAAG,UAAU,GAAG,MAAM,CAAC;AAE3D;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE;IACtC,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IAC9B,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;CACjB,EAAE,OAAO,EAAE,SAAS,SAAS,EAAE,GAAG,iBAAiB,CAmBnD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE;IACJ,GAAG,EAAE,GAAG,CAAC;IACT,QAAQ,EAAE;QAAE,MAAM,CAAC,EAAE,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAAC;QAAC,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC;IACpG,QAAQ,EAAE,YAAY,GAAG,IAAI,CAAC;IAC9B,gBAAgB,EAAE,MAAM,CAAC;CAC1B,EACD,EAAE,EAAE,SAAS,EACb,gBAAgB,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,EAChE,cAAc,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,MAAM,GACnC,IAAI,CAsCN"}

package/dist/session/init-phases.js

@@ -32,7 +32,8 @@
  * preserved — old probes still see it. New phase entries are
  * additional ring entries, not replacements.
  */
-import { recordRecoveryEvent } from '@nimbus-sh/core/observability/oom-discriminator.js';
+import { recordRecoveryEvent } from '@nimbus-sh/platform/oom-discriminator.js';
+import { generation } from '@nimbus-sh/fabric/generation.js';
 /**
  * Set the current phase + record a transition. Fail-soft on the
  * observability call; the phase update on `self` is direct and
@@ -47,7 +48,7 @@ export function setPhase(self, toState, trigger) {
             fromState,
             toState,
             trigger,
-            isolateGen: self._isolateGen ?? 0,
+            isolateGen: generation(self.ctx),
             dataLoss: false,
             snapshotKeysRehydrated: 0,
         });

package/dist/session/init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/session/init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AA8EH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD;;;;;;;;GAQG;AACH,KAAK,QAAQ,GAAG,eAAe,GAAG;IAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAA;CAAE,CAAC;AAa3E,wBAAsB,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAosF9E"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/session/init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AA+EH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD;;;;;;;;GAQG;AACH,KAAK,QAAQ,GAAG,eAAe,GAAG;IAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;IAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAA;CAAE,CAAC;AAa3E,wBAAsB,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAosF9E"}

package/dist/session/init.js

@@ -68,10 +68,11 @@ import { listInstalledRuntimes, rehydrateInstalledRuntimes, registerRunnerFactor
 // one-time Worker Startup Time paid on every fresh-isolate cold run.
 import { hasSeededProject, SEED_PROJECT_DIR } from '@nimbus-sh/core/vfs/seed-project.js';
 import { notifyTerminalEvent } from '../runtime/process-logs-api.js';
+import { generation } from '@nimbus-sh/fabric/generation.js';
 import { stripAnsi } from '@nimbus-sh/core/runtime/process-logs.js';
 import { DEFAULT_MOUNT_POINTS, NODE_VERSION, } from '@nimbus-sh/core/constants.js';
 import { ensureSessionStateSchema, loadShellState, stampHydratedAt, countSessionStateKeys, loadKernelMounts, persistKernelMounts, appendScrollback, loadScrollback, } from './state-store.js';
-import { recordRecoveryEvent } from '@nimbus-sh/core/observability/oom-discriminator.js';
+import { recordRecoveryEvent } from '@nimbus-sh/platform/oom-discriminator.js';
 import { sessionAiEnv } from './ai.js';
 import { routeSessionLoopback } from './loopback.js';
 import { setPhase } from './init-phases.js';
@@ -166,7 +167,7 @@ export async function initSession(self, ws) {
             + 'running was lost with the old one — re-run it if it had not finished.\x1b[0m\r\n');
     }
     // A reset that killed a resident launch left its journal row behind
-    // (fabric's ResidentLaunchJournal.recoverInterrupted). The alarm the dying
+    // (fabric's FencedWork.recoverInterrupted). The alarm the dying
     // instance was using for launch turns is NOT a trigger recovery can rely
     // on — measured live, a launch killed early in its first chunks rolls the
     // alarm-map put back with the rest of the dying turn, so the replacement
@@ -481,7 +482,7 @@ export async function initSession(self, ws) {
     registerRunnerFactory('cpython-runner', (manifest, installRoot, binName, binKind) => async function pythonReplOrOneShot(ctx) {
         const argv = ctx.args || [];
         // No args at all → REPL session. Hand off to runPythonRepl
-        // which builds its own LoaderPool (separate from the
+        // which builds its own IsolatePool (separate from the
         // one-shot dispatch's pool) and drives a ReplSession.
         if (argv.length === 0 && self.terminal) {
             const { runPythonRepl } = await import('../runtime/python-repl.js');
@@ -2705,7 +2706,7 @@ export async function initSession(self, ws) {
                 fromState: fromState,
                 toState: 'hydrated',
                 trigger: 'init-session',
-                isolateGen: self._isolateGen,
+                isolateGen: generation(self.ctx),
                 dataLoss: false,
                 snapshotKeysRehydrated: snapshotKeys,
             });

package/dist/session/keys.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../../src/session/keys.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAMH;2EAC2E;AAC3E,eAAO,MAAM,oBAAoB,MAAM,CAAC;AAExC;;yDAEyD;AACzD,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AAEpD;0DAC0D;AAC1D,eAAO,MAAM,qBAAqB,sBAAsB,CAAC;AAEzD;;uBAEuB;AACvB,eAAO,MAAM,eAAe,gBAAgB,CAAC;AAE7C;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,sBAAsB,CAAC;AAEzD;;;4EAG4E;AAC5E,eAAO,MAAM,+BAA+B,0BAA0B,CAAC;AAEvE;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,+BAA+B,CAAC;AAEvE;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,+BAA+B,CAAC"}
+{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../../src/session/keys.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAOH;2EAC2E;AAC3E,eAAO,MAAM,oBAAoB,MAAM,CAAC;AAExC;;yDAEyD;AACzD,eAAO,MAAM,mBAAmB,mBAAmB,CAAC;AAEpD;0DAC0D;AAC1D,eAAO,MAAM,qBAAqB,sBAAsB,CAAC;AAEzD;;uBAEuB;AACvB,eAAO,MAAM,eAAe,gBAAgB,CAAC;AAE7C;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,sBAAsB,CAAC;AAEzD;;;4EAG4E;AAC5E,eAAO,MAAM,+BAA+B,0BAA0B,CAAC;AAEvE;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,+BAA+B,CAAC;AAEvE;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,+BAA+B,CAAC"}