@glubean/sdk 0.2.0 → 0.2.2

package/dist/plugin.js

@@ -1,57 +1,70 @@
 /**
- * Plugin definition helper for Glubean SDK.
+ * Plugin authoring helpers.
  *
- * Plugin authors use `definePlugin()` to create plugin factories that
- * integrate with `configure({ plugins: { ... } })`. This is the recommended
- * way to define plugins — it handles the `PluginFactory` phantom type trick
- * so plugin authors don't need to understand it.
+ * Two APIs live here, one per concept:
  *
- * @example
- * ```ts
- * import { definePlugin } from "@glubean/sdk";
+ * 1. **`definePlugin(manifest)`** — declare a plugin manifest for global
+ *    registration (matchers, protocol adapters, one-time setup). Consumed by
+ *    {@link installPlugin} in `./install-plugin.js`. This is the primary API
+ *    for plugin packages like `@glubean/graphql` and `@glubean/grpc`.
  *
- * export const myPlugin = (opts: MyOptions) =>
- *   definePlugin((runtime) => {
- *     const baseUrl = runtime.requireVar(opts.baseUrlKey);
- *     return new MyClient(baseUrl);
- *   });
- * ```
+ * 2. **`defineClientFactory(create)`** — declare a lazy client factory for
+ *    per-file injection via `configure({ plugins })`. This is what the
+ *    legacy `definePlugin((runtime) => T)` signature used to do; the name
+ *    has been corrected to describe what it actually is (a client factory,
+ *    not a plugin).
+ *
+ * The legacy `definePlugin((runtime) => T)` overload was removed in Phase 3.
+ * Migrate call sites to `defineClientFactory((runtime) => T)` for the same
+ * behavior and better naming.
  *
  * @module plugin
  */
 /**
- * Create a plugin factory. This is the recommended way to define plugins.
+ * Declare a lazy client factory.
  *
- * The factory function receives a `GlubeanRuntime` with access to vars,
- * secrets, HTTP client, and template resolution. It is called lazily on
+ * The factory function receives a `GlubeanRuntime` (vars / secrets / http /
+ * template resolution) and returns a client instance. It is invoked lazily on
  * first property access during test execution, not at module load time.
  *
- * @param create Factory function that receives the runtime and returns the plugin instance
- * @returns A `PluginFactory<T>` suitable for use in `configure({ plugins: { ... } })`
+ * Output is consumed by `configure({ plugins: { name: factory } })` for
+ * per-file client injection.
+ *
+ * @param create Factory function receiving the runtime; returns the client.
+ * @returns A `ClientFactory<T>` suitable for `configure({ plugins })`.
  *
- * @example Simple plugin
+ * @example Simple client
  * ```ts
- * export const myPlugin = (opts: { baseUrlKey: string }) =>
- *   definePlugin((runtime) => {
+ * export const myClient = (opts: { baseUrlKey: string }) =>
+ *   defineClientFactory((runtime) => {
  *     const baseUrl = runtime.requireVar(opts.baseUrlKey);
  *     return new MyClient(baseUrl);
  *   });
  * ```
+ */
+export function defineClientFactory(create) {
+    return { __type: undefined, create };
+}
+/**
+ * Declare a plugin manifest for global registration.
  *
- * @example Plugin with auth headers
+ * The returned manifest is consumed by `installPlugin(...manifests)` at
+ * bootstrap time. A manifest can declare custom matchers, protocol adapters,
+ * and a one-time `setup()` hook. See {@link PluginManifest}.
+ *
+ * @example Plugin manifest
  * ```ts
- * export const graphql = (opts: { endpoint: string; headers?: Record<string, string> }) =>
- *   definePlugin((runtime) => {
- *     const url = runtime.requireVar(opts.endpoint);
- *     const headers: Record<string, string> = {};
- *     for (const [k, v] of Object.entries(opts.headers ?? {})) {
- *       headers[k] = runtime.resolveTemplate(v);
- *     }
- *     return createGraphQLClient(runtime.http, { endpoint: url, headers });
- *   });
+ * export default definePlugin({
+ *   name: "@glubean/graphql",
+ *   matchers: { toHaveGraphqlData, toHaveGraphqlErrorCode },
+ *   contracts: { graphql: graphqlAdapter },
+ *   setup() {
+ *     // Optional one-time registration work
+ *   },
+ * });
  * ```
  */
-export function definePlugin(create) {
-    return { __type: undefined, create };
+export function definePlugin(manifest) {
+    return manifest;
 }
 //# sourceMappingURL=plugin.js.map

package/dist/plugin.js.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAIH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,UAAU,YAAY,CAC1B,MAAsC;IAEtC,OAAO,EAAE,MAAM,EAAE,SAAyB,EAAE,MAAM,EAAE,CAAC;AACvD,CAAC"}
+{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAQH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,mBAAmB,CACjC,MAAsC;IAEtC,OAAO,EAAE,MAAM,EAAE,SAAyB,EAAE,MAAM,EAAE,CAAC;AACvD,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,YAAY,CAAC,QAAwB;IACnD,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/runtime-carrier.d.ts

@@ -0,0 +1,142 @@
+/**
+ * RuntimeCarrier — internal abstraction over how the SDK reaches the current
+ * per-test runtime context (vars / secrets / session / http / trace hooks).
+ *
+ * **Public API is zero-change.** All user-facing surfaces (`ctx.http`,
+ * `ctx.vars`, `ctx.secrets`, `ctx.session`) continue to work exactly as
+ * before.
+ *
+ * ## Default impl
+ *
+ * {@link createAlsCarrier} — `AsyncLocalStorage`-backed with a closure-level
+ * module slot fallback. Concurrent `runWithRuntime()` callers are isolated
+ * (each sees their own runtime across async boundaries). All first-party
+ * packages (`runner` harness, `browser` plugin) read/write the carrier via
+ * `@glubean/sdk/internal`, never through `globalThis`.
+ *
+ * ## Retained alternate: {@link createGlobalThisCarrier}
+ *
+ * Historical R1 impl backed by `globalThis.__glubeanRuntime`. Not the default
+ * any longer — kept in source as a revert target and test fixture. Can be
+ * reinstalled via {@link installCarrier} if an ALS regression ever needs a
+ * one-line rollback.
+ *
+ * ## Audience
+ *
+ * Exported via `@glubean/sdk/internal`. Consumed by:
+ * - `@glubean/runner` (harness) — sets the runtime before user code runs.
+ * - `@glubean/browser`, other first-party plugins — read test metadata.
+ *
+ * User test code must **not** import from this module.
+ *
+ * @internal
+ */
+import type { GlubeanAction, GlubeanEvent, GlubeanRuntime as PublicGlubeanRuntime, HttpClient, Trace } from "./types.js";
+/**
+ * Shape of the runtime context injected by the harness before test execution.
+ *
+ * This is the **internal** shape — the public `GlubeanRuntime` exported from
+ * the top-level SDK adds helper methods (`requireVar`, `requireSecret`,
+ * `resolveTemplate`) for plugin authors. The carrier transports this internal
+ * shape; `configure()` augments it before handing to plugins.
+ *
+ * @internal
+ */
+export interface InternalRuntime {
+    vars: Record<string, string>;
+    secrets: Record<string, string>;
+    /** Session key-value store. Set during session setup, available to all tests. */
+    session: Record<string, unknown>;
+    http: HttpClient;
+    test?: PublicGlubeanRuntime["test"];
+    trace?(t: Trace): void;
+    action?(a: GlubeanAction): void;
+    event?(ev: GlubeanEvent): void;
+    log?(message: string, data?: unknown): void;
+}
+/**
+ * Abstraction over where the current runtime lives.
+ *
+ * Implementations:
+ * - {@link createAlsCarrier} — current default. Concurrent isolation via
+ *   AsyncLocalStorage.
+ * - {@link createGlobalThisCarrier} — retained revert target.
+ *
+ * @internal
+ */
+export interface RuntimeCarrier {
+    get(): InternalRuntime | undefined;
+    set(rt: InternalRuntime | undefined): void;
+    /**
+     * Run `fn` with `rt` as the active runtime, restoring the previous value
+     * afterwards.
+     *
+     * **Async contract:** if `fn()` returns a `Promise`, the previous runtime
+     * is restored only after that Promise settles (resolve or reject). Code
+     * after `await` points inside `fn` therefore observes `rt`, not the
+     * restored value.
+     *
+     * **Concurrency:**
+     * - ALS impl (default): true isolation — concurrent `runWith()` callers
+     *   each see their own `rt` via AsyncLocalStorage across all async
+     *   boundaries.
+     * - globalThis impl: single shared slot — two *concurrent* `runWith()`
+     *   calls race the slot. Sequential / single-in-flight safe.
+     */
+    runWith<T>(rt: InternalRuntime, fn: () => T): T;
+}
+/**
+ * globalThis-backed carrier. **Not the default** — retained in source as a
+ * revert target and test fixture. Uses `globalThis.__glubeanRuntime` as the
+ * single shared slot.
+ *
+ * @internal
+ */
+export declare function createGlobalThisCarrier(): RuntimeCarrier;
+/**
+ * Default carrier: AsyncLocalStorage-backed with a closure module slot.
+ *
+ * Storage:
+ * - **ALS store** — authoritative for code running inside a
+ *   {@link RuntimeCarrier.runWith} scope. Propagates across all async
+ *   boundaries. Concurrent callers are fully isolated.
+ * - **Module slot** — closure-scoped variable set by {@link RuntimeCarrier.set}
+ *   for code running outside any `runWith()` scope (e.g. harness code after
+ *   a subprocess-level `setRuntime()` but before any `runWith()` wrap).
+ *
+ * `get()` reads ALS first, falls back to the module slot. No `globalThis`
+ * access — external plugins must migrate to `@glubean/sdk/internal.getRuntime`.
+ *
+ * @internal
+ */
+export declare function createAlsCarrier(): RuntimeCarrier;
+/**
+ * Replace the active carrier. Used by tests and by the future R2 opt-in path.
+ *
+ * @internal
+ */
+export declare function installCarrier(c: RuntimeCarrier): void;
+/**
+ * Read the current runtime context. Returns `undefined` when called outside
+ * of test execution (e.g. at module load / scanner time). Callers that need
+ * the throw-on-missing contract should wrap with their own `requireRuntime()`.
+ *
+ * @internal
+ */
+export declare function getRuntime(): InternalRuntime | undefined;
+/**
+ * Install a runtime into the carrier. The harness calls this once per test
+ * subprocess before the user module is imported.
+ *
+ * @internal
+ */
+export declare function setRuntime(rt: InternalRuntime | undefined): void;
+/**
+ * Run `fn` with `rt` as the active runtime, restoring the previous value on
+ * exit. In R1 this is a synchronous swap of the globalThis slot; in R2 it
+ * becomes an ALS-scoped execution. Call sites do not change between rounds.
+ *
+ * @internal
+ */
+export declare function runWithRuntime<T>(rt: InternalRuntime, fn: () => T): T;
+//# sourceMappingURL=runtime-carrier.d.ts.map

package/dist/runtime-carrier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-carrier.d.ts","sourceRoot":"","sources":["../src/runtime-carrier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAGH,OAAO,KAAK,EACV,aAAa,EACb,YAAY,EACZ,cAAc,IAAI,oBAAoB,EACtC,UAAU,EACV,KAAK,EACN,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;GASG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,iFAAiF;IACjF,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,CAAC,EAAE,oBAAoB,CAAC,MAAM,CAAC,CAAC;IACpC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;IACvB,MAAM,CAAC,CAAC,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IAChC,KAAK,CAAC,CAAC,EAAE,EAAE,YAAY,GAAG,IAAI,CAAC;IAC/B,GAAG,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CAC7C;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,cAAc;IAC7B,GAAG,IAAI,eAAe,GAAG,SAAS,CAAC;IACnC,GAAG,CAAC,EAAE,EAAE,eAAe,GAAG,SAAS,GAAG,IAAI,CAAC;IAC3C;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;CACjD;AAID;;;;;;GAMG;AACH,wBAAgB,uBAAuB,IAAI,cAAc,CA8BxD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,IAAI,cAAc,CAkBjD;AAID;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,cAAc,GAAG,IAAI,CAEtD;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,IAAI,eAAe,GAAG,SAAS,CAExD;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,eAAe,GAAG,SAAS,GAAG,IAAI,CAEhE;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAErE"}

package/dist/runtime-carrier.js

@@ -0,0 +1,148 @@
+/**
+ * RuntimeCarrier — internal abstraction over how the SDK reaches the current
+ * per-test runtime context (vars / secrets / session / http / trace hooks).
+ *
+ * **Public API is zero-change.** All user-facing surfaces (`ctx.http`,
+ * `ctx.vars`, `ctx.secrets`, `ctx.session`) continue to work exactly as
+ * before.
+ *
+ * ## Default impl
+ *
+ * {@link createAlsCarrier} — `AsyncLocalStorage`-backed with a closure-level
+ * module slot fallback. Concurrent `runWithRuntime()` callers are isolated
+ * (each sees their own runtime across async boundaries). All first-party
+ * packages (`runner` harness, `browser` plugin) read/write the carrier via
+ * `@glubean/sdk/internal`, never through `globalThis`.
+ *
+ * ## Retained alternate: {@link createGlobalThisCarrier}
+ *
+ * Historical R1 impl backed by `globalThis.__glubeanRuntime`. Not the default
+ * any longer — kept in source as a revert target and test fixture. Can be
+ * reinstalled via {@link installCarrier} if an ALS regression ever needs a
+ * one-line rollback.
+ *
+ * ## Audience
+ *
+ * Exported via `@glubean/sdk/internal`. Consumed by:
+ * - `@glubean/runner` (harness) — sets the runtime before user code runs.
+ * - `@glubean/browser`, other first-party plugins — read test metadata.
+ *
+ * User test code must **not** import from this module.
+ *
+ * @internal
+ */
+import { AsyncLocalStorage } from "node:async_hooks";
+const GLOBAL_SLOT = "__glubeanRuntime";
+/**
+ * globalThis-backed carrier. **Not the default** — retained in source as a
+ * revert target and test fixture. Uses `globalThis.__glubeanRuntime` as the
+ * single shared slot.
+ *
+ * @internal
+ */
+export function createGlobalThisCarrier() {
+    return {
+        get() {
+            return globalThis[GLOBAL_SLOT];
+        },
+        set(rt) {
+            globalThis[GLOBAL_SLOT] = rt;
+        },
+        runWith(rt, fn) {
+            const prev = globalThis[GLOBAL_SLOT];
+            globalThis[GLOBAL_SLOT] = rt;
+            let result;
+            try {
+                result = fn();
+            }
+            catch (err) {
+                globalThis[GLOBAL_SLOT] = prev;
+                throw err;
+            }
+            // Async path: defer restore until the promise settles so that
+            // continuations inside `fn` after `await` still observe `rt`.
+            if (result !== null && typeof result === "object" && typeof result.then === "function") {
+                return (Promise.resolve(result).finally(() => {
+                    globalThis[GLOBAL_SLOT] = prev;
+                }));
+            }
+            // Sync path: restore immediately.
+            globalThis[GLOBAL_SLOT] = prev;
+            return result;
+        },
+    };
+}
+/**
+ * Default carrier: AsyncLocalStorage-backed with a closure module slot.
+ *
+ * Storage:
+ * - **ALS store** — authoritative for code running inside a
+ *   {@link RuntimeCarrier.runWith} scope. Propagates across all async
+ *   boundaries. Concurrent callers are fully isolated.
+ * - **Module slot** — closure-scoped variable set by {@link RuntimeCarrier.set}
+ *   for code running outside any `runWith()` scope (e.g. harness code after
+ *   a subprocess-level `setRuntime()` but before any `runWith()` wrap).
+ *
+ * `get()` reads ALS first, falls back to the module slot. No `globalThis`
+ * access — external plugins must migrate to `@glubean/sdk/internal.getRuntime`.
+ *
+ * @internal
+ */
+export function createAlsCarrier() {
+    const als = new AsyncLocalStorage();
+    let moduleSlot;
+    return {
+        get() {
+            return als.getStore() ?? moduleSlot;
+        },
+        set(rt) {
+            moduleSlot = rt;
+        },
+        runWith(rt, fn) {
+            // ALS natively propagates `rt` across await boundaries — no manual
+            // save/restore of the module slot is needed. `als.run(rt, fn)` binds
+            // `rt` for the duration of `fn`'s continuation chain and unbinds
+            // automatically when the returned promise settles.
+            return als.run(rt, fn);
+        },
+    };
+}
+let _carrier = createAlsCarrier();
+/**
+ * Replace the active carrier. Used by tests and by the future R2 opt-in path.
+ *
+ * @internal
+ */
+export function installCarrier(c) {
+    _carrier = c;
+}
+/**
+ * Read the current runtime context. Returns `undefined` when called outside
+ * of test execution (e.g. at module load / scanner time). Callers that need
+ * the throw-on-missing contract should wrap with their own `requireRuntime()`.
+ *
+ * @internal
+ */
+export function getRuntime() {
+    return _carrier.get();
+}
+/**
+ * Install a runtime into the carrier. The harness calls this once per test
+ * subprocess before the user module is imported.
+ *
+ * @internal
+ */
+export function setRuntime(rt) {
+    _carrier.set(rt);
+}
+/**
+ * Run `fn` with `rt` as the active runtime, restoring the previous value on
+ * exit. In R1 this is a synchronous swap of the globalThis slot; in R2 it
+ * becomes an ALS-scoped execution. Call sites do not change between rounds.
+ *
+ * @internal
+ */
+export function runWithRuntime(rt, fn) {
+    return _carrier.runWith(rt, fn);
+}
+//# sourceMappingURL=runtime-carrier.js.map

package/dist/runtime-carrier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-carrier.js","sourceRoot":"","sources":["../src/runtime-carrier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAgErD,MAAM,WAAW,GAAG,kBAAkB,CAAC;AAEvC;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB;IACrC,OAAO;QACL,GAAG;YACD,OAAQ,UAAkB,CAAC,WAAW,CAAgC,CAAC;QACzE,CAAC;QACD,GAAG,CAAC,EAAE;YACH,UAAkB,CAAC,WAAW,CAAC,GAAG,EAAE,CAAC;QACxC,CAAC;QACD,OAAO,CAAC,EAAE,EAAE,EAAE;YACZ,MAAM,IAAI,GAAI,UAAkB,CAAC,WAAW,CAAC,CAAC;YAC7C,UAAkB,CAAC,WAAW,CAAC,GAAG,EAAE,CAAC;YACtC,IAAI,MAAe,CAAC;YACpB,IAAI,CAAC;gBACH,MAAM,GAAG,EAAE,EAAE,CAAC;YAChB,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACZ,UAAkB,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC;gBACxC,MAAM,GAAG,CAAC;YACZ,CAAC;YACD,8DAA8D;YAC9D,8DAA8D;YAC9D,IAAI,MAAM,KAAK,IAAI,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,OAAQ,MAA+B,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;gBACjH,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,MAA0B,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE;oBAC9D,UAAkB,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC;gBAC1C,CAAC,CAAC,CAA0B,CAAC;YAC/B,CAAC;YACD,kCAAkC;YACjC,UAAkB,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC;YACxC,OAAO,MAA+B,CAAC;QACzC,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,gBAAgB;IAC9B,MAAM,GAAG,GAAG,IAAI,iBAAiB,EAAmB,CAAC;IACrD,IAAI,UAAuC,CAAC;IAC5C,OAAO;QACL,GAAG;YACD,OAAO,GAAG,CAAC,QAAQ,EAAE,IAAI,UAAU,CAAC;QACtC,CAAC;QACD,GAAG,CAAC,EAAE;YACJ,UAAU,GAAG,EAAE,CAAC;QAClB,CAAC;QACD,OAAO,CAAC,EAAE,EAAE,EAAE;YACZ,mEAAmE;YACnE,qEAAqE;YACrE,iEAAiE;YACjE,mDAAmD;YACnD,OAAO,GAAG,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;QACzB,CAAC;KACF,CAAC;AACJ,CAAC;AAED,IAAI,QAAQ,GAAmB,gBAAgB,EAAE,CAAC;AAElD;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,CAAiB;IAC9C,QAAQ,GAAG,CAAC,CAAC;AACf,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,UAAU;IACxB,OAAO,QAAQ,CAAC,GAAG,EAAE,CAAC;AACxB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,UAAU,CAAC,EAA+B;IACxD,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;AACnB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAI,EAAmB,EAAE,EAAW;IAChE,OAAO,QAAQ,CAAC,OAAO,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;AAClC,CAAC"}

package/dist/session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,iBAAiB,GAAG,iBAAiB,CAEvE;AAkBD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,OAAO;IAClB,yDAAyD;mBACrD,CAAC,iBAAiB,MAAM,KAAG,CAAC,GAAG,SAAS;IAI5C,8CAA8C;uBACtC,CAAC,iBAAiB,MAAM,KAAG,CAAC;IAYpC;;;;;;OAMG;wBACM,MAAM,SAAS,OAAO,KAAG,IAAI;IAItC,kCAAkC;wBACzB,MAAM,KAAG,OAAO;IAIzB,yDAAyD;4BAC9C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAG1B,CAAC"}
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAGpD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,iBAAiB,GAAG,iBAAiB,CAEvE;AAkBD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,OAAO;IAClB,yDAAyD;mBACrD,CAAC,iBAAiB,MAAM,KAAG,CAAC,GAAG,SAAS;IAI5C,8CAA8C;uBACtC,CAAC,iBAAiB,MAAM,KAAG,CAAC;IAYpC;;;;;;OAMG;wBACM,MAAM,SAAS,OAAO,KAAG,IAAI;IAItC,kCAAkC;wBACzB,MAAM,KAAG,OAAO;IAIzB,yDAAyD;4BAC9C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAG1B,CAAC"}

package/dist/session.js

@@ -1,3 +1,4 @@
+import { getRuntime } from "./runtime-carrier.js";
 /**
  * Define a session setup/teardown lifecycle for cross-file state sharing.
  *
@@ -31,7 +32,7 @@ export function defineSession(def) {
 // Global session accessor — read-only, lazy, for use outside test functions
 // =============================================================================
 function getRuntimeSession() {
-    const runtime = globalThis.__glubeanRuntime;
+    const runtime = getRuntime();
     if (!runtime) {
         throw new Error("session can only be accessed during test execution. " +
             "Did you try to read a session value at module load time? " +

package/dist/session.js.map

@@ -1 +1 @@
-{"version":3,"file":"session.js","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,aAAa,CAAC,GAAsB;IAClD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,gFAAgF;AAChF,4EAA4E;AAC5E,gFAAgF;AAEhF,SAAS,iBAAiB;IACxB,MAAM,OAAO,GAAI,UAAkB,CAAC,gBAAgB,CAAC;IACrD,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CACb,sDAAsD;YACpD,2DAA2D;YAC3D,oEAAoE,CACvE,CAAC;IACJ,CAAC;IACD,OAAO,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC;AAC/B,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,yDAAyD;IACzD,GAAG,CAAc,GAAW;QAC1B,OAAO,iBAAiB,EAAE,CAAC,GAAG,CAAkB,CAAC;IACnD,CAAC;IAED,8CAA8C;IAC9C,OAAO,CAAc,GAAW;QAC9B,MAAM,IAAI,GAAG,iBAAiB,EAAE,CAAC;QACjC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;QACxB,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,MAAM,IAAI,KAAK,CACb,kCAAkC,GAAG,KAAK;gBACxC,mEAAmE,CACtE,CAAC;QACJ,CAAC;QACD,OAAO,KAAU,CAAC;IACpB,CAAC;IAED;;;;;;OAMG;IACH,GAAG,CAAC,GAAW,EAAE,KAAc;QAC7B,iBAAiB,EAAE,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;IACnC,CAAC;IAED,kCAAkC;IAClC,GAAG,CAAC,GAAW;QACb,OAAO,GAAG,IAAI,iBAAiB,EAAE,CAAC;IACpC,CAAC;IAED,yDAAyD;IACzD,OAAO;QACL,OAAO,EAAE,GAAG,iBAAiB,EAAE,EAAE,CAAC;IACpC,CAAC;CACO,CAAC"}
+{"version":3,"file":"session.js","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,aAAa,CAAC,GAAsB;IAClD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,gFAAgF;AAChF,4EAA4E;AAC5E,gFAAgF;AAEhF,SAAS,iBAAiB;IACxB,MAAM,OAAO,GAAG,UAAU,EAAE,CAAC;IAC7B,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,MAAM,IAAI,KAAK,CACb,sDAAsD;YACpD,2DAA2D;YAC3D,oEAAoE,CACvE,CAAC;IACJ,CAAC;IACD,OAAO,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC;AAC/B,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG;IACrB,yDAAyD;IACzD,GAAG,CAAc,GAAW;QAC1B,OAAO,iBAAiB,EAAE,CAAC,GAAG,CAAkB,CAAC;IACnD,CAAC;IAED,8CAA8C;IAC9C,OAAO,CAAc,GAAW;QAC9B,MAAM,IAAI,GAAG,iBAAiB,EAAE,CAAC;QACjC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC;QACxB,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,MAAM,IAAI,KAAK,CACb,kCAAkC,GAAG,KAAK;gBACxC,mEAAmE,CACtE,CAAC;QACJ,CAAC;QACD,OAAO,KAAU,CAAC;IACpB,CAAC;IAED;;;;;;OAMG;IACH,GAAG,CAAC,GAAW,EAAE,KAAc;QAC7B,iBAAiB,EAAE,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;IACnC,CAAC;IAED,kCAAkC;IAClC,GAAG,CAAC,GAAW;QACb,OAAO,GAAG,IAAI,iBAAiB,EAAE,CAAC;IACpC,CAAC;IAED,yDAAyD;IACzD,OAAO;QACL,OAAO,EAAE,GAAG,iBAAiB,EAAE,EAAE,CAAC;IACpC,CAAC;CACO,CAAC"}