@workflow/core 5.0.0-beta.3 → 5.0.0-beta.31

package/dist/runtime/get-port-lazy.js

@@ -0,0 +1,92 @@
+/**
+ * Lazy loader for getPort that prevents bundlers (Turbopack, esbuild)
+ * from statically tracing @workflow/utils/get-port and its filesystem
+ * operations (readdir, readFile, readlink) into the flow route bundle.
+ *
+ * Uses createRequire with a dynamically constructed specifier so the
+ * dependency is invisible to bundler static analysis.
+ */
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+let _getPort;
+// Per-process cache of the resolved port. The workflow dev server listens on a
+// stable port for the lifetime of the process, but `getPort()` rediscovers it
+// on every call by querying the OS for the process's listening sockets — on
+// macOS that shells out to `lsof` (~60ms), which the runtime pays on EVERY
+// workflow replay (the non-Vercel branch of `runWorkflow`). Since the port does
+// not change within a process, resolve it once and reuse it. `_inFlight`
+// dedupes concurrent first calls so discovery never runs more than once.
+//
+// The first concrete port is pinned for the lifetime of the process — there is
+// no per-call re-resolution. This is safe because the runtime only runs inside
+// the already-listening dev-server process, and `getPort()` -> `getAllPorts()`
+// returns a deterministic order, so repeated calls would resolve the same port
+// anyway.
+let _cachedPort;
+let _inFlight;
+export async function getPortLazy() {
+    // Fast path: already resolved a concrete port for this process.
+    if (_cachedPort !== undefined) {
+        return _cachedPort;
+    }
+    // A discovery is already running — share it rather than starting a second.
+    if (_inFlight) {
+        return _inFlight;
+    }
+    if (!_getPort) {
+        try {
+            // Construct specifier at runtime to defeat bundler static analysis.
+            const spec = ['@workflow/utils', 'get-port'].join('/');
+            // Use process.cwd()-based createRequire for CJS/ESM compatibility.
+            // import.meta.url is unavailable in CJS re-bundled outputs.
+            const _require = createRequire(pathToFileURL(process.cwd() + '/package.json').href);
+            const mod = _require(spec);
+            _getPort = mod.getPort;
+        }
+        catch {
+            // Module not available (e.g., in a browser or minimal bundle)
+            _getPort = async () => undefined;
+        }
+    }
+    // `_getPort` is always assigned by the block above; the fallback keeps the
+    // type non-nullable without a non-null assertion.
+    const resolver = _getPort ?? (async () => undefined);
+    _inFlight = resolver()
+        .then((port) => {
+        // Only cache a concrete port. A transient `undefined` (e.g. the server is
+        // not listening yet on the very first replay) must not poison the cache —
+        // leaving it unset lets the next call retry discovery.
+        if (typeof port === 'number') {
+            _cachedPort = port;
+        }
+        return port;
+    })
+        .finally(() => {
+        _inFlight = undefined;
+    });
+    return _inFlight;
+}
+/**
+ * Resets the per-process port cache. Intended for tests; not used on the hot
+ * path. Callers must let any in-flight lookup settle (await the pending
+ * `getPortLazy()` call) before resetting: clearing `_inFlight` here does not
+ * cancel an already-scheduled resolution, so a late `.then` could otherwise
+ * repopulate `_cachedPort` after the reset and bleed into the next test.
+ */
+export function resetPortCacheForTesting() {
+    _getPort = undefined;
+    _cachedPort = undefined;
+    _inFlight = undefined;
+}
+/**
+ * Installs a fake port resolver and clears the cache. Test-only seam: the real
+ * resolver is loaded via `createRequire` with a runtime-built specifier (to
+ * hide it from bundlers), which also defeats module mocking, so injection is
+ * the only deterministic way to exercise the caching contract.
+ */
+export function setPortResolverForTesting(fn) {
+    _getPort = fn;
+    _cachedPort = undefined;
+    _inFlight = undefined;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/runtime/get-world-lazy.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Lazy accessor for the World singleton via globalThis symbols.
+ *
+ * This module exists to break the static import chain from step-side
+ * modules (serialization, run, helpers, start) to world.ts. Without it,
+ * esbuild bundles world.ts (and its transitive deps: world-local,
+ * world-vercel, process.cwd(), etc.) into the step registrations bundle,
+ * which triggers Turbopack NFT tracing errors in the V2 combined flow route.
+ *
+ * Resolution order, in priority:
+ *
+ * 1. `globalThis[WorldCacheKey]` — populated by a successful prior
+ *    `getWorld()` call. This is the steady-state hot path.
+ * 2. `globalThis[GetWorldFnKey]` — populated by the module-load side
+ *    effect at the bottom of `./world.ts`. Fires on every server bundle
+ *    that reaches this file via `workflow` or `workflow/api` (which import
+ *    `./world-init.ts` for its side effect; see that file for the full
+ *    rationale). This is the cold-start path for routes that consume host
+ *    helpers without any prior workflow run.
+ */
+import type { World } from '@workflow/world';
+export declare function getWorldLazy(): Promise<World>;
+//# sourceMappingURL=get-world-lazy.d.ts.map

package/dist/runtime/get-world-lazy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-world-lazy.d.ts","sourceRoot":"","sources":["../../src/runtime/get-world-lazy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAa7C,wBAAsB,YAAY,IAAI,OAAO,CAAC,KAAK,CAAC,CAsBnD"}

package/dist/runtime/get-world-lazy.js

@@ -0,0 +1,46 @@
+/**
+ * Lazy accessor for the World singleton via globalThis symbols.
+ *
+ * This module exists to break the static import chain from step-side
+ * modules (serialization, run, helpers, start) to world.ts. Without it,
+ * esbuild bundles world.ts (and its transitive deps: world-local,
+ * world-vercel, process.cwd(), etc.) into the step registrations bundle,
+ * which triggers Turbopack NFT tracing errors in the V2 combined flow route.
+ *
+ * Resolution order, in priority:
+ *
+ * 1. `globalThis[WorldCacheKey]` — populated by a successful prior
+ *    `getWorld()` call. This is the steady-state hot path.
+ * 2. `globalThis[GetWorldFnKey]` — populated by the module-load side
+ *    effect at the bottom of `./world.ts`. Fires on every server bundle
+ *    that reaches this file via `workflow` or `workflow/api` (which import
+ *    `./world-init.ts` for its side effect; see that file for the full
+ *    rationale). This is the cold-start path for routes that consume host
+ *    helpers without any prior workflow run.
+ */
+import { assertWorldSupportsRuntimeProtocol } from './world-compatibility.js';
+const WorldCacheKey = Symbol.for('@workflow/world//cache');
+const WorldCachePromiseKey = Symbol.for('@workflow/world//cachePromise');
+const GetWorldFnKey = Symbol.for('@workflow/world//getWorldFn');
+export async function getWorldLazy() {
+    const g = globalThis;
+    if (g[WorldCacheKey]) {
+        assertWorldSupportsRuntimeProtocol(g[WorldCacheKey]);
+        return g[WorldCacheKey];
+    }
+    if (g[WorldCachePromiseKey]) {
+        g[WorldCacheKey] = await g[WorldCachePromiseKey];
+        assertWorldSupportsRuntimeProtocol(g[WorldCacheKey]);
+        return g[WorldCacheKey];
+    }
+    // world-init statically imports world.ts in host bundles, which registers
+    // getWorld on globalThis at module load.
+    const getWorldFn = g[GetWorldFnKey];
+    if (getWorldFn) {
+        const world = await getWorldFn();
+        assertWorldSupportsRuntimeProtocol(world);
+        return world;
+    }
+    throw new Error('Workflow world runtime was not initialized. Import from the host workflow entrypoints (`workflow`, `workflow/api`, or `workflow/runtime`) so @workflow/core/runtime/world-init can register getWorld before getWorldLazy() is used.');
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LXdvcmxkLWxhenkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcnVudGltZS9nZXQtd29ybGQtbGF6eS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7Ozs7OztHQW1CRztBQUdILE9BQU8sRUFBRSxrQ0FBa0MsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBRTlFLE1BQU0sYUFBYSxHQUFHLE1BQU0sQ0FBQyxHQUFHLENBQUMsd0JBQXdCLENBQUMsQ0FBQztBQUMzRCxNQUFNLG9CQUFvQixHQUFHLE1BQU0sQ0FBQyxHQUFHLENBQUMsK0JBQStCLENBQUMsQ0FBQztBQUN6RSxNQUFNLGFBQWEsR0FBRyxNQUFNLENBQUMsR0FBRyxDQUFDLDZCQUE2QixDQUFDLENBQUM7QUFRaEUsTUFBTSxDQUFDLEtBQUssVUFBVSxZQUFZO0lBQ2hDLE1BQU0sQ0FBQyxHQUFHLFVBQThCLENBQUM7SUFDekMsSUFBSSxDQUFDLENBQUMsYUFBYSxDQUFDLEVBQUUsQ0FBQztRQUNyQixrQ0FBa0MsQ0FBQyxDQUFDLENBQUMsYUFBYSxDQUFDLENBQUMsQ0FBQztRQUNyRCxPQUFPLENBQUMsQ0FBQyxhQUFhLENBQUMsQ0FBQztJQUMxQixDQUFDO0lBQ0QsSUFBSSxDQUFDLENBQUMsb0JBQW9CLENBQUMsRUFBRSxDQUFDO1FBQzVCLENBQUMsQ0FBQyxhQUFhLENBQUMsR0FBRyxNQUFNLENBQUMsQ0FBQyxvQkFBb0IsQ0FBQyxDQUFDO1FBQ2pELGtDQUFrQyxDQUFDLENBQUMsQ0FBQyxhQUFhLENBQUMsQ0FBQyxDQUFDO1FBQ3JELE9BQU8sQ0FBQyxDQUFDLGFBQWEsQ0FBQyxDQUFDO0lBQzFCLENBQUM7SUFDRCwwRUFBMEU7SUFDMUUseUNBQXlDO0lBQ3pDLE1BQU0sVUFBVSxHQUFHLENBQUMsQ0FBQyxhQUFhLENBQUMsQ0FBQztJQUNwQyxJQUFJLFVBQVUsRUFBRSxDQUFDO1FBQ2YsTUFBTSxLQUFLLEdBQUcsTUFBTSxVQUFVLEVBQUUsQ0FBQztRQUNqQyxrQ0FBa0MsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUMxQyxPQUFPLEtBQUssQ0FBQztJQUNmLENBQUM7SUFDRCxNQUFNLElBQUksS0FBSyxDQUNiLHFPQUFxTyxDQUN0TyxDQUFDO0FBQ0osQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogTGF6eSBhY2Nlc3NvciBmb3IgdGhlIFdvcmxkIHNpbmdsZXRvbiB2aWEgZ2xvYmFsVGhpcyBzeW1ib2xzLlxuICpcbiAqIFRoaXMgbW9kdWxlIGV4aXN0cyB0byBicmVhayB0aGUgc3RhdGljIGltcG9ydCBjaGFpbiBmcm9tIHN0ZXAtc2lkZVxuICogbW9kdWxlcyAoc2VyaWFsaXphdGlvbiwgcnVuLCBoZWxwZXJzLCBzdGFydCkgdG8gd29ybGQudHMuIFdpdGhvdXQgaXQsXG4gKiBlc2J1aWxkIGJ1bmRsZXMgd29ybGQudHMgKGFuZCBpdHMgdHJhbnNpdGl2ZSBkZXBzOiB3b3JsZC1sb2NhbCxcbiAqIHdvcmxkLXZlcmNlbCwgcHJvY2Vzcy5jd2QoKSwgZXRjLikgaW50byB0aGUgc3RlcCByZWdpc3RyYXRpb25zIGJ1bmRsZSxcbiAqIHdoaWNoIHRyaWdnZXJzIFR1cmJvcGFjayBORlQgdHJhY2luZyBlcnJvcnMgaW4gdGhlIFYyIGNvbWJpbmVkIGZsb3cgcm91dGUuXG4gKlxuICogUmVzb2x1dGlvbiBvcmRlciwgaW4gcHJpb3JpdHk6XG4gKlxuICogMS4gYGdsb2JhbFRoaXNbV29ybGRDYWNoZUtleV1gIOKAlCBwb3B1bGF0ZWQgYnkgYSBzdWNjZXNzZnVsIHByaW9yXG4gKiAgICBgZ2V0V29ybGQoKWAgY2FsbC4gVGhpcyBpcyB0aGUgc3RlYWR5LXN0YXRlIGhvdCBwYXRoLlxuICogMi4gYGdsb2JhbFRoaXNbR2V0V29ybGRGbktleV1gIOKAlCBwb3B1bGF0ZWQgYnkgdGhlIG1vZHVsZS1sb2FkIHNpZGVcbiAqICAgIGVmZmVjdCBhdCB0aGUgYm90dG9tIG9mIGAuL3dvcmxkLnRzYC4gRmlyZXMgb24gZXZlcnkgc2VydmVyIGJ1bmRsZVxuICogICAgdGhhdCByZWFjaGVzIHRoaXMgZmlsZSB2aWEgYHdvcmtmbG93YCBvciBgd29ya2Zsb3cvYXBpYCAod2hpY2ggaW1wb3J0XG4gKiAgICBgLi93b3JsZC1pbml0LnRzYCBmb3IgaXRzIHNpZGUgZWZmZWN0OyBzZWUgdGhhdCBmaWxlIGZvciB0aGUgZnVsbFxuICogICAgcmF0aW9uYWxlKS4gVGhpcyBpcyB0aGUgY29sZC1zdGFydCBwYXRoIGZvciByb3V0ZXMgdGhhdCBjb25zdW1lIGhvc3RcbiAqICAgIGhlbHBlcnMgd2l0aG91dCBhbnkgcHJpb3Igd29ya2Zsb3cgcnVuLlxuICovXG5cbmltcG9ydCB0eXBlIHsgV29ybGQgfSBmcm9tICdAd29ya2Zsb3cvd29ybGQnO1xuaW1wb3J0IHsgYXNzZXJ0V29ybGRTdXBwb3J0c1J1bnRpbWVQcm90b2NvbCB9IGZyb20gJy4vd29ybGQtY29tcGF0aWJpbGl0eS5qcyc7XG5cbmNvbnN0IFdvcmxkQ2FjaGVLZXkgPSBTeW1ib2wuZm9yKCdAd29ya2Zsb3cvd29ybGQvL2NhY2hlJyk7XG5jb25zdCBXb3JsZENhY2hlUHJvbWlzZUtleSA9IFN5bWJvbC5mb3IoJ0B3b3JrZmxvdy93b3JsZC8vY2FjaGVQcm9taXNlJyk7XG5jb25zdCBHZXRXb3JsZEZuS2V5ID0gU3ltYm9sLmZvcignQHdvcmtmbG93L3dvcmxkLy9nZXRXb3JsZEZuJyk7XG5cbnR5cGUgR2xvYmFsV29ybGRDYWNoZSA9IHR5cGVvZiBnbG9iYWxUaGlzICYge1xuICBbV29ybGRDYWNoZUtleV0/OiBXb3JsZDtcbiAgW1dvcmxkQ2FjaGVQcm9taXNlS2V5XT86IFByb21pc2U8V29ybGQ+O1xuICBbR2V0V29ybGRGbktleV0/OiAoKSA9PiBQcm9taXNlPFdvcmxkPjtcbn07XG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBnZXRXb3JsZExhenkoKTogUHJvbWlzZTxXb3JsZD4ge1xuICBjb25zdCBnID0gZ2xvYmFsVGhpcyBhcyBHbG9iYWxXb3JsZENhY2hlO1xuICBpZiAoZ1tXb3JsZENhY2hlS2V5XSkge1xuICAgIGFzc2VydFdvcmxkU3VwcG9ydHNSdW50aW1lUHJvdG9jb2woZ1tXb3JsZENhY2hlS2V5XSk7XG4gICAgcmV0dXJuIGdbV29ybGRDYWNoZUtleV07XG4gIH1cbiAgaWYgKGdbV29ybGRDYWNoZVByb21pc2VLZXldKSB7XG4gICAgZ1tXb3JsZENhY2hlS2V5XSA9IGF3YWl0IGdbV29ybGRDYWNoZVByb21pc2VLZXldO1xuICAgIGFzc2VydFdvcmxkU3VwcG9ydHNSdW50aW1lUHJvdG9jb2woZ1tXb3JsZENhY2hlS2V5XSk7XG4gICAgcmV0dXJuIGdbV29ybGRDYWNoZUtleV07XG4gIH1cbiAgLy8gd29ybGQtaW5pdCBzdGF0aWNhbGx5IGltcG9ydHMgd29ybGQudHMgaW4gaG9zdCBidW5kbGVzLCB3aGljaCByZWdpc3RlcnNcbiAgLy8gZ2V0V29ybGQgb24gZ2xvYmFsVGhpcyBhdCBtb2R1bGUgbG9hZC5cbiAgY29uc3QgZ2V0V29ybGRGbiA9IGdbR2V0V29ybGRGbktleV07XG4gIGlmIChnZXRXb3JsZEZuKSB7XG4gICAgY29uc3Qgd29ybGQgPSBhd2FpdCBnZXRXb3JsZEZuKCk7XG4gICAgYXNzZXJ0V29ybGRTdXBwb3J0c1J1bnRpbWVQcm90b2NvbCh3b3JsZCk7XG4gICAgcmV0dXJuIHdvcmxkO1xuICB9XG4gIHRocm93IG5ldyBFcnJvcihcbiAgICAnV29ya2Zsb3cgd29ybGQgcnVudGltZSB3YXMgbm90IGluaXRpYWxpemVkLiBJbXBvcnQgZnJvbSB0aGUgaG9zdCB3b3JrZmxvdyBlbnRyeXBvaW50cyAoYHdvcmtmbG93YCwgYHdvcmtmbG93L2FwaWAsIG9yIGB3b3JrZmxvdy9ydW50aW1lYCkgc28gQHdvcmtmbG93L2NvcmUvcnVudGltZS93b3JsZC1pbml0IGNhbiByZWdpc3RlciBnZXRXb3JsZCBiZWZvcmUgZ2V0V29ybGRMYXp5KCkgaXMgdXNlZC4nXG4gICk7XG59XG4iXX0=

package/dist/runtime/helpers.d.ts

@@ -1,10 +1,11 @@
-import type { Event, HealthCheckPayload, ValidQueueName, World } from '@workflow/world';
+import type { Event, HealthCheckPayload, ValidQueueName, WorkflowRun, World } from '@workflow/world';
+import { type CryptoKey } from '../encryption.js';
 /**
  * Validates a workflow name and returns the corresponding queue name.
  * Ensures the workflow name only contains safe characters before
  * interpolating it into the queue name string.
  */
-export declare function getWorkflowQueueName(workflowName: string): ValidQueueName;
+export declare function getWorkflowQueueName(workflowName: string, namespace?: string): ValidQueueName;
 /**
  * Result of a health check operation.
  */
@@ -16,6 +17,14 @@ export interface HealthCheckResult {
     latencyMs?: number;
     /** Spec version of the responding deployment */
     specVersion?: number;
+    /**
+     * `@workflow/core` version of the responding deployment, used for
+     * capability detection (see `getRunCapabilities`). Omitted when the
+     * responding deployment did not provide the field as a string —
+     * for example, an older `@workflow/core` that predates this field,
+     * or a non-JSON plain-text health response.
+     */
+    workflowCoreVersion?: string;
 }
 /**
  * Checks if the given message is a health check payload.
@@ -36,14 +45,33 @@ export interface HealthCheckOptions {
     timeout?: number;
     /** Deployment ID to send the health check to. Falls back to process.env.VERCEL_DEPLOYMENT_ID. */
     deploymentId?: string;
+    /**
+     * Queue namespace of the target deployment (e.g. `'eve'` for topics like
+     * `__eve_wkf_workflow_*`). Falls back to `WORKFLOW_QUEUE_NAMESPACE` in the
+     * calling process. Cross-context callers (e.g. the observability
+     * dashboard) must pass the target deployment's namespace explicitly —
+     * the env fallback resolves in the caller's process, and a message
+     * published to a mismatched topic has no consumer, so the check would
+     * always time out.
+     */
+    namespace?: string;
 }
 export declare function healthCheck(world: World, endpoint: HealthCheckEndpoint, options?: HealthCheckOptions): Promise<HealthCheckResult>;
 /**
- * Loads all workflow run events by iterating through all pages of paginated results.
- * This ensures that *all* events are loaded into memory before running the workflow.
- * Events must be in chronological order (ascending) for proper workflow replay.
+ * Loads workflow run events by iterating through all pages of paginated
+ * results. Events are returned in chronological (ascending) order for
+ * deterministic workflow replay.
+ *
+ * @param runId - The workflow run ID.
+ * @param afterCursor - If provided, only events after this cursor are
+ *   returned (incremental load). If omitted, all events are returned.
+ *   The returned cursor can be passed back in on a subsequent call for
+ *   incremental loading.
  */
-export declare function getAllWorkflowRunEvents(runId: string): Promise<Event[]>;
+export declare function loadWorkflowRunEvents(runId: string, afterCursor?: string): Promise<{
+    events: Event[];
+    cursor: string | null;
+}>;
 /**
  * Wraps a request/response handler and adds a health check "mode"
  * based on the presence of a `__health` query parameter.
@@ -61,4 +89,27 @@ export declare function getQueueOverhead(message: {
 }): {
     [k: string]: number;
 } | undefined;
+/**
+ * Returns a memoized accessor for the per-run AES-256 encryption key.
+ *
+ * The first call resolves the key via `world.getEncryptionKeyForRun` (which
+ * may do HKDF derivation locally on Vercel, or a network fetch from
+ * external contexts) and imports it as a `CryptoKey`; subsequent calls
+ * await the same cached promise. If the world doesn't support encryption
+ * or the run has no key configured, the cached value is `undefined`.
+ *
+ * Used by step / workflow handlers to defer the (potentially expensive)
+ * key fetch until the first code path that actually needs it — typically
+ * input hydration on the success path, or error dehydration on a failure
+ * path. Both paths can race-call the accessor without triggering duplicate
+ * fetches.
+ *
+ * Errors thrown by `getEncryptionKeyForRun` propagate to every caller
+ * (the cached promise rejects). This is intentional: when encryption is
+ * configured, we never want to silently fall back to plaintext
+ * serialization. A propagated error in an event-emission path leaves the
+ * outer try/catch to log and surface the issue; the queue's redelivery
+ * semantics will retry the key fetch on the next attempt.
+ */
+export declare function memoizeEncryptionKey(world: World, runOrId: WorkflowRun | string): () => Promise<CryptoKey | undefined>;
 //# sourceMappingURL=helpers.d.ts.map

package/dist/runtime/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/runtime/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,KAAK,EACL,kBAAkB,EAClB,cAAc,EACd,KAAK,EACN,MAAM,iBAAiB,CAAC;AAwBzB;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,cAAc,CAOzE;AAWD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,2CAA2C;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iDAAiD;IACjD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gDAAgD;IAChD,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,OAAO,GACf,kBAAkB,GAAG,SAAS,CAMhC;AAYD;;;;;;GAMG;AACH,wBAAsB,wBAAwB,CAC5C,WAAW,EAAE,kBAAkB,EAC/B,QAAQ,EAAE,UAAU,GAAG,MAAM,EAC7B,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,IAAI,CAAC,CAgBf;AAED,MAAM,MAAM,mBAAmB,GAAG,UAAU,GAAG,MAAM,CAAC;AAEtD,MAAM,WAAW,kBAAkB;IACjC,sFAAsF;IACtF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iGAAiG;IACjG,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAoGD,wBAAsB,WAAW,CAC/B,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,mBAAmB,EAC7B,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,iBAAiB,CAAC,CA2E5B;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC,CAuD7E;AAYD;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,EAC5C,gBAAgB,CAAC,EAAE,MAAM,GACxB,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CA8BrC;AAED;;GAEG;AACH,wBAAsB,YAAY,CAChC,KAAK,EAAE,KAAK,EACZ,GAAG,IAAI,EAAE,UAAU,CAAC,OAAO,KAAK,CAAC,KAAK,CAAC,iBA0BxC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE;IAAE,WAAW,CAAC,EAAE,IAAI,CAAA;CAAE;;cAS/D"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/runtime/helpers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,KAAK,EACL,kBAAkB,EAClB,cAAc,EACd,WAAW,EACX,KAAK,EACN,MAAM,iBAAiB,CAAC;AAUzB,OAAO,EAAE,KAAK,SAAS,EAAa,MAAM,kBAAkB,CAAC;AAiB7D;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,MAAM,EACpB,SAAS,CAAC,EAAE,MAAM,GACjB,cAAc,CAWhB;AAWD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,2CAA2C;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iDAAiD;IACjD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gDAAgD;IAChD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;OAMG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,OAAO,GACf,kBAAkB,GAAG,SAAS,CAMhC;AAYD;;;;;;GAMG;AACH,wBAAsB,wBAAwB,CAC5C,WAAW,EAAE,kBAAkB,EAC/B,QAAQ,EAAE,UAAU,GAAG,MAAM,EAC7B,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC,IAAI,CAAC,CAgBf;AAED,MAAM,MAAM,mBAAmB,GAAG,UAAU,GAAG,MAAM,CAAC;AAEtD,MAAM,WAAW,kBAAkB;IACjC,sFAAsF;IACtF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iGAAiG;IACjG,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAmID,wBAAsB,WAAW,CAC/B,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,mBAAmB,EAC7B,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,iBAAiB,CAAC,CA6E5B;AAwED;;;;;;;;;;GAUG;AACH,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,MAAM,EACb,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC;IAAE,MAAM,EAAE,KAAK,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAwGrD;AAYD;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,EAC5C,gBAAgB,CAAC,EAAE,MAAM,GACxB,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CA8BrC;AAED;;GAEG;AACH,wBAAsB,YAAY,CAChC,KAAK,EAAE,KAAK,EACZ,GAAG,IAAI,EAAE,UAAU,CAAC,OAAO,KAAK,CAAC,KAAK,CAAC,iBA0BxC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE;IAAE,WAAW,CAAC,EAAE,IAAI,CAAA;CAAE;;cAS/D;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,WAAW,GAAG,MAAM,GAC5B,MAAM,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAiBtC"}