@workflow/core 4.5.0 → 4.6.0

package/dist/symbols.js

@@ -6,6 +6,7 @@ export const WORKFLOW_GET_STREAM_ID = Symbol.for('WORKFLOW_GET_STREAM_ID');
 export const STABLE_ULID = Symbol.for('WORKFLOW_STABLE_ULID');
 export const STREAM_NAME_SYMBOL = Symbol.for('WORKFLOW_STREAM_NAME');
 export const STREAM_TYPE_SYMBOL = Symbol.for('WORKFLOW_STREAM_TYPE');
+export const STREAM_FRAMING_SYMBOL = Symbol.for('WORKFLOW_STREAM_FRAMING');
 /**
  * Stamped on a real `WritableStream` (the user-visible `serialize.writable`
  * returned from a step-side reviver or step-context `getWritable()`) to
@@ -35,4 +36,4 @@ export const WEBHOOK_RESPONSE_WRITABLE = Symbol.for('WEBHOOK_RESPONSE_WRITABLE')
  * This allows the deserializer to find classes by classId in the VM context.
  */
 export const WORKFLOW_CLASS_REGISTRY = Symbol.for('workflow-class-registry');
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "4.5.0";
+export declare const version = "4.6.0";
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -1,3 +1,3 @@
 // Generated by genversion.
-export const version = '4.5.0';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDJCQUEyQjtBQUMzQixNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsT0FBTyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLy8gR2VuZXJhdGVkIGJ5IGdlbnZlcnNpb24uXG5leHBvcnQgY29uc3QgdmVyc2lvbiA9ICc0LjUuMCdcbiJdfQ==
+export const version = '4.6.0';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDJCQUEyQjtBQUMzQixNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsT0FBTyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLy8gR2VuZXJhdGVkIGJ5IGdlbnZlcnNpb24uXG5leHBvcnQgY29uc3QgdmVyc2lvbiA9ICc0LjYuMCdcbiJdfQ==

package/dist/vm/script-cache.d.ts

@@ -0,0 +1,28 @@
+import { type Context, Script } from 'node:vm';
+/**
+ * Returns a compiled `vm.Script` for the given workflow bundle code and
+ * filename, compiling and caching it on first use. Subsequent calls with the
+ * same `(code, filename)` return the cached `Script`.
+ *
+ * The returned `Script` is not yet bound to any context; the caller runs it
+ * against a specific VM context via `script.runInContext(context)`. This is
+ * equivalent to `vm.runInContext(code, context, { filename })` but skips the
+ * recompile.
+ */
+export declare function getCachedWorkflowScript(code: string, filename: string): Script;
+/**
+ * Runs the cached workflow-bundle `Script` against `context`. Compiles and
+ * caches the `Script` on first use for the given `(code, filename)`.
+ */
+export declare function runCachedWorkflowScript(code: string, filename: string, context: Context): unknown;
+/**
+ * Clears the compiled-script cache. Intended for tests that want to assert
+ * compile-vs-cache behaviour in isolation; not used on the hot path.
+ */
+export declare function clearWorkflowScriptCache(): void;
+/**
+ * Number of distinct bundle (`code`) versions currently retained. Exposed for
+ * tests asserting the LRU bound; not used on the hot path.
+ */
+export declare function workflowScriptCacheSize(): number;
+//# sourceMappingURL=script-cache.d.ts.map

package/dist/vm/script-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"script-cache.d.ts","sourceRoot":"","sources":["../../src/vm/script-cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AA0F/C;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GACf,MAAM,CAqBR;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,OAAO,GACf,OAAO,CAET;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,MAAM,CAEhD"}

package/dist/vm/script-cache.js

@@ -0,0 +1,140 @@
+import { Script } from 'node:vm';
+/**
+ * Module-level cache of compiled workflow-bundle `vm.Script` objects.
+ *
+ * Why this exists
+ * ---------------
+ * Replaying a workflow re-evaluates the workflow bundle against a fresh VM
+ * context on every iteration of the inline replay loop (see
+ * `runWorkflow` in `../workflow.ts`). The bundle is a single string that
+ * contains every workflow function in the app and registers them on
+ * `globalThis.__private_workflows`. Previously each replay called
+ * `vm.runInContext(workflowCode, context, { filename })`, which RE-PARSES and
+ * RE-COMPILES the entire bundle every time — O(N) full re-parses for a
+ * sequential workflow of N steps, plus the same parse cost repeated across
+ * every invocation in the process.
+ *
+ * Compilation is a pure function of `(code, filename)`: a `vm.Script` carries
+ * no realm/context state — it is only bound to a context at `runInContext`
+ * time. So a single compiled `Script` can be reused across replays AND across
+ * workflow invocations in the same process without affecting determinism: the
+ * produced workflow function is identical to the previous re-parse-every-time
+ * behaviour, with identical `filename` source attribution (see the precise
+ * claim — and its one caveat — in `runWorkflow`).
+ *
+ * Keying
+ * ------
+ * Keyed by `code` then `filename`. The `filename` is part of the key on
+ * purpose, NOT as a dedupe key: it is baked into the compiled script's source
+ * attribution and surfaces in stack traces, where `remapErrorStack` keys on it
+ * to map frames back to the user's source. Two workflows in the same bundle
+ * share the same `code` but have different `filename`s, so they intentionally
+ * compile to distinct `Script`s — collapsing them onto a single shared `Script`
+ * would misattribute one workflow's stack frames to another file. The cost of
+ * keeping them distinct is that the whole bundle is compiled once per distinct
+ * `filename` (not once per bundle); in practice that is bounded by the number
+ * of source files that define a workflow, and because V8 lazily compiles
+ * function bodies the duplicated work is the (cheap) top-level parse, not full
+ * per-workflow codegen.
+ *
+ * We use a nested Map (code -> filename -> Script) so that evicting a bundle
+ * (e.g. a new deployment/hot-reload producing a different `code`) drops the old
+ * code string and all of its per-filename scripts together.
+ *
+ * Bounding
+ * --------
+ * The top-level (`code`-keyed) map is an insertion-ordered LRU capped at
+ * `MAX_BUNDLES` entries. In production this bound is never reached: a
+ * deployment is its own process serving exactly one build-time bundle literal
+ * (skew protection runs old versions as separate processes), so there is a
+ * single `code` key for the process lifetime. The bound exists for dev/watch
+ * mode, where the dev route re-reads `workflowCode` from disk and re-invokes
+ * the entrypoint on every edit — each edit produces a NEW bundle string, which
+ * without a bound would pin every historical version forever (~0.8MB per edit,
+ * growing monotonically with edit count). The dev path only ever needs the
+ * latest bundle, so an LRU that keeps the few most-recent bundles and evicts
+ * the rest preserves the pre-cache GC behaviour while still serving the
+ * steady-state single-bundle case for free. The per-`filename` inner map is not
+ * separately bounded: it is naturally bounded by the (small) number of workflow
+ * source files in a bundle and is dropped wholesale when its parent `code`
+ * entry is evicted.
+ */
+const scriptCache = new Map();
+/**
+ * Max number of distinct bundle (`code`) versions to retain. One is enough for
+ * production; a handful covers pathological dev hot-reload / repeated-rebuild
+ * churn within a single long-lived process (e.g. a watch session or a test
+ * file) without unbounded growth. Kept deliberately small — there is no value
+ * in retaining stale bundles, only a memory cost.
+ */
+const MAX_BUNDLES = 8;
+/**
+ * Looks up the per-filename map for `code`, marking it most-recently-used.
+ * Relies on `Map` preserving insertion order: deleting and re-inserting an
+ * existing key moves it to the end (newest), so the first key is always the
+ * least-recently-used eviction candidate.
+ */
+function touchBundle(code) {
+    const byFilename = scriptCache.get(code);
+    if (byFilename === undefined) {
+        return undefined;
+    }
+    // Move to the most-recently-used position (end of insertion order).
+    scriptCache.delete(code);
+    scriptCache.set(code, byFilename);
+    return byFilename;
+}
+/**
+ * Returns a compiled `vm.Script` for the given workflow bundle code and
+ * filename, compiling and caching it on first use. Subsequent calls with the
+ * same `(code, filename)` return the cached `Script`.
+ *
+ * The returned `Script` is not yet bound to any context; the caller runs it
+ * against a specific VM context via `script.runInContext(context)`. This is
+ * equivalent to `vm.runInContext(code, context, { filename })` but skips the
+ * recompile.
+ */
+export function getCachedWorkflowScript(code, filename) {
+    let byFilename = touchBundle(code);
+    if (byFilename === undefined) {
+        byFilename = new Map();
+        scriptCache.set(code, byFilename);
+        // Evict the least-recently-used bundle(s) when over the cap. New bundles
+        // are appended at the end, so the oldest live at the front.
+        while (scriptCache.size > MAX_BUNDLES) {
+            const oldest = scriptCache.keys().next().value;
+            if (oldest === undefined) {
+                break;
+            }
+            scriptCache.delete(oldest);
+        }
+    }
+    let script = byFilename.get(filename);
+    if (script === undefined) {
+        script = new Script(code, { filename });
+        byFilename.set(filename, script);
+    }
+    return script;
+}
+/**
+ * Runs the cached workflow-bundle `Script` against `context`. Compiles and
+ * caches the `Script` on first use for the given `(code, filename)`.
+ */
+export function runCachedWorkflowScript(code, filename, context) {
+    return getCachedWorkflowScript(code, filename).runInContext(context);
+}
+/**
+ * Clears the compiled-script cache. Intended for tests that want to assert
+ * compile-vs-cache behaviour in isolation; not used on the hot path.
+ */
+export function clearWorkflowScriptCache() {
+    scriptCache.clear();
+}
+/**
+ * Number of distinct bundle (`code`) versions currently retained. Exposed for
+ * tests asserting the LRU bound; not used on the hot path.
+ */
+export function workflowScriptCacheSize() {
+    return scriptCache.size;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"script-cache.js","sourceRoot":"","sources":["../../src/vm/script-cache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,MAAM,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH,MAAM,WAAW,GAAG,IAAI,GAAG,EAA+B,CAAC;AAE3D;;;;;;GAMG;AACH,MAAM,WAAW,GAAG,CAAC,CAAC;AAEtB;;;;;GAKG;AACH,SAAS,WAAW,CAAC,IAAY;IAC/B,MAAM,UAAU,GAAG,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACzC,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;QAC7B,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,oEAAoE;IACpE,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACzB,WAAW,CAAC,GAAG,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IAClC,OAAO,UAAU,CAAC;AACpB,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,uBAAuB,CACrC,IAAY,EACZ,QAAgB;IAEhB,IAAI,UAAU,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC;IACnC,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;QAC7B,UAAU,GAAG,IAAI,GAAG,EAAkB,CAAC;QACvC,WAAW,CAAC,GAAG,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;QAClC,yEAAyE;QACzE,4DAA4D;QAC5D,OAAO,WAAW,CAAC,IAAI,GAAG,WAAW,EAAE,CAAC;YACtC,MAAM,MAAM,GAAG,WAAW,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC;YAC/C,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;gBACzB,MAAM;YACR,CAAC;YACD,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC7B,CAAC;IACH,CAAC;IACD,IAAI,MAAM,GAAG,UAAU,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACtC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC;QACxC,UAAU,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IACnC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,uBAAuB,CACrC,IAAY,EACZ,QAAgB,EAChB,OAAgB;IAEhB,OAAO,uBAAuB,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;AACvE,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,wBAAwB;IACtC,WAAW,CAAC,KAAK,EAAE,CAAC;AACtB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,uBAAuB;IACrC,OAAO,WAAW,CAAC,IAAI,CAAC;AAC1B,CAAC","sourcesContent":["import { type Context, Script } from 'node:vm';\n\n/**\n * Module-level cache of compiled workflow-bundle `vm.Script` objects.\n *\n * Why this exists\n * ---------------\n * Replaying a workflow re-evaluates the workflow bundle against a fresh VM\n * context on every iteration of the inline replay loop (see\n * `runWorkflow` in `../workflow.ts`). The bundle is a single string that\n * contains every workflow function in the app and registers them on\n * `globalThis.__private_workflows`. Previously each replay called\n * `vm.runInContext(workflowCode, context, { filename })`, which RE-PARSES and\n * RE-COMPILES the entire bundle every time — O(N) full re-parses for a\n * sequential workflow of N steps, plus the same parse cost repeated across\n * every invocation in the process.\n *\n * Compilation is a pure function of `(code, filename)`: a `vm.Script` carries\n * no realm/context state — it is only bound to a context at `runInContext`\n * time. So a single compiled `Script` can be reused across replays AND across\n * workflow invocations in the same process without affecting determinism: the\n * produced workflow function is identical to the previous re-parse-every-time\n * behaviour, with identical `filename` source attribution (see the precise\n * claim — and its one caveat — in `runWorkflow`).\n *\n * Keying\n * ------\n * Keyed by `code` then `filename`. The `filename` is part of the key on\n * purpose, NOT as a dedupe key: it is baked into the compiled script's source\n * attribution and surfaces in stack traces, where `remapErrorStack` keys on it\n * to map frames back to the user's source. Two workflows in the same bundle\n * share the same `code` but have different `filename`s, so they intentionally\n * compile to distinct `Script`s — collapsing them onto a single shared `Script`\n * would misattribute one workflow's stack frames to another file. The cost of\n * keeping them distinct is that the whole bundle is compiled once per distinct\n * `filename` (not once per bundle); in practice that is bounded by the number\n * of source files that define a workflow, and because V8 lazily compiles\n * function bodies the duplicated work is the (cheap) top-level parse, not full\n * per-workflow codegen.\n *\n * We use a nested Map (code -> filename -> Script) so that evicting a bundle\n * (e.g. a new deployment/hot-reload producing a different `code`) drops the old\n * code string and all of its per-filename scripts together.\n *\n * Bounding\n * --------\n * The top-level (`code`-keyed) map is an insertion-ordered LRU capped at\n * `MAX_BUNDLES` entries. In production this bound is never reached: a\n * deployment is its own process serving exactly one build-time bundle literal\n * (skew protection runs old versions as separate processes), so there is a\n * single `code` key for the process lifetime. The bound exists for dev/watch\n * mode, where the dev route re-reads `workflowCode` from disk and re-invokes\n * the entrypoint on every edit — each edit produces a NEW bundle string, which\n * without a bound would pin every historical version forever (~0.8MB per edit,\n * growing monotonically with edit count). The dev path only ever needs the\n * latest bundle, so an LRU that keeps the few most-recent bundles and evicts\n * the rest preserves the pre-cache GC behaviour while still serving the\n * steady-state single-bundle case for free. The per-`filename` inner map is not\n * separately bounded: it is naturally bounded by the (small) number of workflow\n * source files in a bundle and is dropped wholesale when its parent `code`\n * entry is evicted.\n */\nconst scriptCache = new Map<string, Map<string, Script>>();\n\n/**\n * Max number of distinct bundle (`code`) versions to retain. One is enough for\n * production; a handful covers pathological dev hot-reload / repeated-rebuild\n * churn within a single long-lived process (e.g. a watch session or a test\n * file) without unbounded growth. Kept deliberately small — there is no value\n * in retaining stale bundles, only a memory cost.\n */\nconst MAX_BUNDLES = 8;\n\n/**\n * Looks up the per-filename map for `code`, marking it most-recently-used.\n * Relies on `Map` preserving insertion order: deleting and re-inserting an\n * existing key moves it to the end (newest), so the first key is always the\n * least-recently-used eviction candidate.\n */\nfunction touchBundle(code: string): Map<string, Script> | undefined {\n  const byFilename = scriptCache.get(code);\n  if (byFilename === undefined) {\n    return undefined;\n  }\n  // Move to the most-recently-used position (end of insertion order).\n  scriptCache.delete(code);\n  scriptCache.set(code, byFilename);\n  return byFilename;\n}\n\n/**\n * Returns a compiled `vm.Script` for the given workflow bundle code and\n * filename, compiling and caching it on first use. Subsequent calls with the\n * same `(code, filename)` return the cached `Script`.\n *\n * The returned `Script` is not yet bound to any context; the caller runs it\n * against a specific VM context via `script.runInContext(context)`. This is\n * equivalent to `vm.runInContext(code, context, { filename })` but skips the\n * recompile.\n */\nexport function getCachedWorkflowScript(\n  code: string,\n  filename: string\n): Script {\n  let byFilename = touchBundle(code);\n  if (byFilename === undefined) {\n    byFilename = new Map<string, Script>();\n    scriptCache.set(code, byFilename);\n    // Evict the least-recently-used bundle(s) when over the cap. New bundles\n    // are appended at the end, so the oldest live at the front.\n    while (scriptCache.size > MAX_BUNDLES) {\n      const oldest = scriptCache.keys().next().value;\n      if (oldest === undefined) {\n        break;\n      }\n      scriptCache.delete(oldest);\n    }\n  }\n  let script = byFilename.get(filename);\n  if (script === undefined) {\n    script = new Script(code, { filename });\n    byFilename.set(filename, script);\n  }\n  return script;\n}\n\n/**\n * Runs the cached workflow-bundle `Script` against `context`. Compiles and\n * caches the `Script` on first use for the given `(code, filename)`.\n */\nexport function runCachedWorkflowScript(\n  code: string,\n  filename: string,\n  context: Context\n): unknown {\n  return getCachedWorkflowScript(code, filename).runInContext(context);\n}\n\n/**\n * Clears the compiled-script cache. Intended for tests that want to assert\n * compile-vs-cache behaviour in isolation; not used on the hot path.\n */\nexport function clearWorkflowScriptCache(): void {\n  scriptCache.clear();\n}\n\n/**\n * Number of distinct bundle (`code`) versions currently retained. Exposed for\n * tests asserting the LRU bound; not used on the hot path.\n */\nexport function workflowScriptCacheSize(): number {\n  return scriptCache.size;\n}\n"]}

package/dist/workflow.d.ts

@@ -1,4 +1,13 @@
 import type { Event, WorkflowRun } from '@workflow/world';
 import type { CryptoKey } from './encryption.js';
-export declare function runWorkflow(workflowCode: string, workflowRun: WorkflowRun, events: Event[], encryptionKey: CryptoKey | undefined): Promise<Uint8Array | unknown>;
+import type { StepHydrationCache } from './step-hydration-cache.js';
+export declare function runWorkflow(workflowCode: string, workflowRun: WorkflowRun, events: Event[], encryptionKey: CryptoKey | undefined, 
+/**
+ * Optional per-run cache for hydrated step return values, owned by the inline
+ * replay loop so it survives across the loop's iterations (each of which
+ * creates a fresh context). Memoizes the decrypt + devalue-parse of completed
+ * step results to turn O(N²) replay hydration into O(N). Omitted by callers
+ * that replay only once (then there is nothing to reuse).
+ */
+stepHydrationCache?: StepHydrationCache): Promise<Uint8Array | unknown>;
 //# sourceMappingURL=workflow.d.ts.map

package/dist/workflow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../src/workflow.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAG1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAkEjD,wBAAsB,WAAW,CAC/B,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,KAAK,EAAE,EACf,aAAa,EAAE,SAAS,GAAG,SAAS,GACnC,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CA8qB/B"}
+{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../src/workflow.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAG1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAYjD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAyDpE,wBAAsB,WAAW,CAC/B,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,KAAK,EAAE,EACf,aAAa,EAAE,SAAS,GAAG,SAAS;AACpC;;;;;;GAMG;AACH,kBAAkB,CAAC,EAAE,kBAAkB,GACtC,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CAqsB/B"}