@nimbus-sh/worker 0.2.3 → 0.3.0

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 NimbusLoaderPool isolate so the
+ * The npm resolver phase runs inside a LoaderPool 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 NimbusLoaderPool isolate so the
+ * The npm resolver phase runs inside a LoaderPool 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 (NimbusFanoutPool routes
+ * Each task runs inside a Worker Loader isolate (FanoutPool 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 NimbusFanoutPool's MAX_PEER_FANOUT).
+ * (capped at 32 by FanoutPool'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 NimbusFanoutPool.submitMany — see installer.ts
+ * dispatched by FanoutPool.submitMany — see installer.ts
  * resolveTreeViaFanout.
  *
- * Function signature MUST be `(spec, env)` so NimbusFanoutPool's
+ * Function signature MUST be `(spec, env)` so FanoutPool's
  * submitMany invocation `fn(item, env)` lines up.
  *
- * `env` is the loader-isolate env supplied by NimbusFanoutPool.
+ * `env` is the loader-isolate env supplied by FanoutPool.
  * `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 (NimbusFanoutPool routes
+ * Each task runs inside a Worker Loader isolate (FanoutPool 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 NimbusFanoutPool's MAX_PEER_FANOUT).
+ * (capped at 32 by FanoutPool'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 NimbusFanoutPool.submitMany — see installer.ts
+ * dispatched by FanoutPool.submitMany — see installer.ts
  * resolveTreeViaFanout.
  *
- * Function signature MUST be `(spec, env)` so NimbusFanoutPool's
+ * Function signature MUST be `(spec, env)` so FanoutPool's
  * submitMany invocation `fn(item, env)` lines up.
  *
- * `env` is the loader-isolate env supplied by NimbusFanoutPool.
+ * `env` is the loader-isolate env supplied by FanoutPool.
  * `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 '../session/ctx-exports.js';
+import { setCtxExports } from '@nimbus-sh/fabric/ctx-exports.js';
 import { handleNimbusRemoteApi, } from './remote-api.js';
 import { parseAgentOAuthStateParam } from '../session/agent.js';
 /**

package/dist/router/remote-api.js

@@ -242,6 +242,14 @@ function requireAnyScope(ctx, scopes) {
 }
 function execOptions(ctx, value) {
     const options = objectArg(value);
+    // The remote boundary authenticates a SESSION, not a user inside it, so a
+    // token holder does not get to name the uid its command runs as. Refused
+    // rather than dropped: silently running as somebody other than the caller
+    // asked for is worse than an error. A colocated embedder holds the DO stub
+    // and is trusted with `cred` the same way it is trusted with kernel writes.
+    if (options.cred !== undefined) {
+        throw apiError('cred is not accepted over the remote API', 'E_ARG_SHAPE', 400);
+    }
     return {
         ...options,
         cwd: typeof options.cwd === 'string' ? options.cwd : ctx.root,

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

@@ -7,7 +7,7 @@
  * functions / imports persist.
  *
  * Design:
- *   - One child-facet per REPL session (NimbusLoaderPool with
+ *   - One child-facet per REPL session (LoaderPool 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 (NimbusLoaderPool with
+ *   - One child-facet per REPL session (LoaderPool 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 { NimbusLoaderPool } = await import('../loaders/loader-pool.js');
-        this.pool = new NimbusLoaderPool(env, ctx, {
+        const { LoaderPool } = await import('@nimbus-sh/fabric/loader-pool.js');
+        this.pool = new LoaderPool(env, ctx, {
             tag: 'bun-repl',
             concurrency: 1,
             omitSupervisor: true,

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 `NimbusLoaderPool`
+ * The whole adapter is the option renames below, because `LoaderPool`
  * 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,13 +13,10 @@ 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 NimbusLoaderPool needs from a FacetManager.
- *
- * FacetManager does not expose its `env` and `ctx` in its type, but a loader
- * pool is constructed from exactly those, so every runtime that spawns facets
- * needs the same reach-through. Reflect.get rather than a cast: the shape is
- * checked here once, and a FacetManager built on something other than a
- * DurableObjectState fails with a sentence instead of at the first RPC.
+ * The two objects a LoaderPool 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.
  */
 export declare function getFacetManagerLoaderHost(facetMgr: FacetManager): {
     env: unknown;

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

@@ -1 +1 @@
-{"version":3,"file":"facet-loader-host.d.ts","sourceRoot":"","sources":["../../src/runtime/facet-loader-host.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAIV,SAAS,EAEV,MAAM,uCAAuC,CAAC;AAG/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGzD,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,kBAAkB,GAAG,SAAS,CA6BhF;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,YAAY,GACrB;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,kBAAkB,CAAA;CAAE,CAO3C;AAED,uEAAuE;AACvE,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,YAAY,GAAG,SAAS,CAGrE"}
+{"version":3,"file":"facet-loader-host.d.ts","sourceRoot":"","sources":["../../src/runtime/facet-loader-host.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAIV,SAAS,EAEV,MAAM,uCAAuC,CAAC;AAG/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGzD,wBAAgB,eAAe,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,kBAAkB,GAAG,SAAS,CA6BhF;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,YAAY,GACrB;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,kBAAkB,CAAA;CAAE,CAM3C;AAED,uEAAuE;AACvE,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,YAAY,GAAG,SAAS,CAGrE"}

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

@@ -1,5 +1,5 @@
 import { manifestVfs } from '@nimbus-sh/core/runtime/vfs-manifest.js';
-import { NimbusLoaderPool } from '../loaders/loader-pool.js';
+import { LoaderPool } from '@nimbus-sh/fabric/loader-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 NimbusLoaderPool(env, ctx, {
+            return new LoaderPool(env, ctx, {
                 tag: spec.tag,
                 concurrency: spec.concurrency,
                 preamble: spec.preamble,
@@ -27,17 +27,13 @@ export function loaderFacetHost(env, ctx) {
     };
 }
 /**
- * The two objects a NimbusLoaderPool needs from a FacetManager.
- *
- * FacetManager does not expose its `env` and `ctx` in its type, but a loader
- * pool is constructed from exactly those, so every runtime that spawns facets
- * needs the same reach-through. Reflect.get rather than a cast: the shape is
- * checked here once, and a FacetManager built on something other than a
- * DurableObjectState fails with a sentence instead of at the first RPC.
+ * The two objects a LoaderPool 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.
  */
 export function getFacetManagerLoaderHost(facetMgr) {
-    const env = Reflect.get(facetMgr, 'env');
-    const ctx = Reflect.get(facetMgr, 'ctx');
+    const { env, ctx } = facetMgr.loaderHost();
     if (!isDurableObjectState(ctx)) {
         throw new Error('a loader-backed runtime requires a FacetManager with DurableObjectState context');
     }

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 { NimbusLoaderPool } = await import('../loaders/loader-pool.js');
-        this.pool = new NimbusLoaderPool(env, ctx, {
+        const { LoaderPool } = await import('@nimbus-sh/fabric/loader-pool.js');
+        this.pool = new LoaderPool(env, ctx, {
             tag: 'node-repl',
             concurrency: 1,
             omitSupervisor: true,

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 { NimbusLoaderPool } = await import('../loaders/loader-pool.js');
+        const { LoaderPool } = await import('@nimbus-sh/fabric/loader-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 NimbusLoaderPool(host.env, host.ctx, { ...base, supervisorPid: pid })
+            ? new LoaderPool(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 NimbusLoaderPool(host.env, host.ctx, { ...base, omitSupervisor: true }));
+            : new LoaderPool(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 { NimbusLoaderPool } = await import('../loaders/loader-pool.js');
+        const { LoaderPool } = await import('@nimbus-sh/fabric/loader-pool.js');
         const env = facetMgr.env;
         const ctx = facetMgr.ctx;
-        this.pool = new NimbusLoaderPool(env, ctx, {
+        this.pool = new LoaderPool(env, ctx, {
             tag: 'ruby-repl',
             concurrency: 1,
             omitSupervisor: true,

package/dist/runtime/ruby-resident.js

@@ -48,7 +48,7 @@ export function rubyResidentStart(facetMgr) {
         }
         const boot = parsed.data;
         if (boot.state === 'listening' && typeof boot.port === 'number' && boot.port > 0) {
-            facetMgr.registerPort(spawned.pid, Number(boot.port));
+            await facetMgr.registerPort(spawned.pid, Number(boot.port));
             const routeablePorts = await facetMgr.waitForRouteablePorts(spawned.pid);
             const routeablePort = routeablePorts.includes(Number(boot.port)) ? Number(boot.port) : routeablePorts[0];
             if (!routeablePort) {

package/dist/session/hibernation.d.ts

@@ -18,11 +18,15 @@
  *     w9_proc_logs + w9_proc_exits.
  *   - scheduleHibFlush(host, ctx) — debounced setTimeout + best-effort
  *     setAlarm for post-hibernation drain.
- *   - dispatchAlarm(host) — alarm() handler body.
- *   - maybeBumpIsolateGen(host, ctx) — increment + persist isolate-gen
- *     counter once per fresh isolate.
+ *   - dispatchAlarm(host) — alarm() handler body: the fabric's generic
+ *     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.
+ *
  * **`ctx` taken as a separate arg from `host`** because the parent
  * `CloudflareDurableObject` class declares `ctx` as `protected`, which
  * is nominal-typed in TS and cannot appear on a public interface
@@ -35,7 +39,8 @@
  * wireProcessLogPersist again.
  */
 import type { SessionProcessSupervisor } from '@nimbus-sh/core/runtime/session-process-supervisor.js';
-import { type WsHibernationConfigResult } from './ws-hibernation-config.js';
+import { type WsHibernationConfigResult } from '@nimbus-sh/fabric/ws-hibernation-config.js';
+import { type AlarmHost, type IsolateGenHost } from '@nimbus-sh/fabric/alarms.js';
 export type { WsHibernationConfigResult };
 /**
  * Minimal host shape. `_w9*` fields drop `private` on the class so
@@ -44,10 +49,8 @@ export type { WsHibernationConfigResult };
  *
  * `ctx` is NOT in this interface — passed as a separate arg.
  */
-export interface HibHost {
+export interface HibHost extends AlarmHost, IsolateGenHost {
     processes: SessionProcessSupervisor;
-    _w9IsolateGen: number;
-    _w9IsolateGenPersisted: boolean;
     _w9SchemaInit: boolean;
     _w9PersistWired: boolean;
     _w9FlushTimer: any;
@@ -55,8 +58,6 @@ export interface HibHost {
     _w1JanitorArmed: boolean;
     /** W1: destroyed-session tombstone — never re-arm alarms while set. */
     _w1SessionDestroyed: boolean;
-    /** W1: serializes every alarm-map read-modify-write (see scheduleAlarm). */
-    _w1AlarmChain?: Promise<unknown>;
 }
 /**
  * Run at DO ctor time. Returns the result for the class to assign to
@@ -104,35 +105,12 @@ export declare function ensureLogJanitor(host: HibHost, ctx: any): void;
 /** W9: idempotent SQL schema bootstrap. */
 export declare function ensureHibSchema(host: HibHost, ctx: any): void;
 /**
- * W1: canonical alarm-reason strings. Stored in the
- * `W1_NEXT_ALARM_REASONS_KEY` map. Forward-compat: dispatcher silently
- * drops unknown reasons so a rollback from a future deploy that added
- * new reasons doesn't leave the alarm stuck.
+ * W1: this session's canonical alarm-reason strings, registered on the
+ * fabric's reason map. Forward-compat: the dispatcher silently drops unknown
+ * reasons so a rollback from a future deploy that added new reasons doesn't
+ * leave the alarm stuck.
  */
 export type AlarmReason = 'w9-flush' | 'log-janitor' | 'resident-launch';
-/**
- * W1: schedule (or re-schedule) an alarm reason. Coordinated via a
- * single map in DO storage so multiple subsystems (W9 debounced flush +
- * W1 log-janitor sweep) don't clobber each other's `setAlarm()` calls.
- *
- * Semantics:
- *   - Reads the existing reasons map.
- *   - Sets `map[reason] = whenMs` IF `whenMs` is sooner than the
- *     currently-pending deadline for that reason (or no entry exists).
- *     Later-than-pending requests are silently ignored — the existing
- *     alarm will fire and re-arm anyway.
- *   - Writes the map back and calls `ctx.storage.setAlarm(min(deadlines))`.
- *
- * Cost: 1 storage read + 1 storage write + 1 setAlarm per call. setAlarm
- * itself is billed as 1 row written per DO pricing. At W1's 60s
- * cadence, this is ~$0.05/mo/session at scale — dwarfed by the
- * hibernation duration savings.
- *
- * Fail-soft: any throw is swallowed with a warn. On older runtimes /
- * wrangler-dev where setAlarm is unavailable, this is a no-op (the
- * subsystem's in-isolate setTimeout fallback continues to work).
- */
-export declare function scheduleAlarm(host: HibHost, ctx: any, reason: AlarmReason, whenMs: number): Promise<boolean>;
 /**
  * W9: ensure the alarm is set for the next flush window. Cheap to
  * call repeatedly — we only schedule the in-isolate flush timer if
@@ -141,29 +119,18 @@ export declare function scheduleAlarm(host: HibHost, ctx: any, reason: AlarmReas
  */
 export declare function scheduleHibFlush(host: HibHost, ctx: any): void;
 /**
- * W1: multi-reason alarm dispatcher. Called from the DO's `alarm()`
- * handler.
- *
- * For each pending reason whose deadline has passed, run its handler.
- * Reasons supported today:
+ * W1: this session's alarm() handler body — the fabric's multi-reason
+ * dispatcher with this session's handlers registered:
  *   - `'w9-flush'` → processes.flushLogs()
+ *   - `'resident-launch'` → pumpResidentLaunches()
  *   - `'log-janitor'` → processes.dropLogsOlderThan(orphanCheck); re-arm
- *     for next 60s cycle.
+ *     for next 60s cycle while the session still has anything to sweep.
  *
  * `janitorOrphanCheck` is the orphan-pid predicate provided by the
  * caller (typically `(pid) => !host.processes.get(pid)`). Decoupled
  * so HibHost doesn't need to import ProcessTable.
- *
- * After running fireable reasons, re-arms `ctx.storage.setAlarm` at the
- * earliest remaining deadline. If no reasons remain, deletes the map
- * key and does NOT call setAlarm — the DO becomes hibernation-eligible
- * after the 10s idle window.
- *
- * Forward/back-compat: unknown reasons silently dropped.
  */
 export declare function dispatchAlarm(host: HibHost, ctx: any, janitorOrphanCheck?: (pid: number) => boolean, pumpResidentLaunches?: () => Promise<void>): Promise<void>;
-/** W9: increment + persist isolate-gen counter once per fresh isolate. */
-export declare function maybeBumpIsolateGen(host: HibHost, ctx: any): 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAGH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uDAAuD,CAAC;AACtG,OAAO,EAA0B,KAAK,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAGpG,YAAY,EAAE,yBAAyB,EAAE,CAAC;AAE1C;;;;;;GAMG;AACH,MAAM,WAAW,OAAO;IACtB,SAAS,EAAE,wBAAwB,CAAC;IACpC,aAAa,EAAE,MAAM,CAAC;IACtB,sBAAsB,EAAE,OAAO,CAAC;IAChC,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;IAC7B,4EAA4E;IAC5E,aAAa,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;CAClC;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;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,OAAO,EACb,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,OAAO,CAAC,CA8BlB;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CAqB9D;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;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,CASf;AAoFD,0EAA0E;AAC1E,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAyBhF;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,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"}