@copilotkit/runtime 1.62.1 → 1.62.2-canary.1783457132

package/dist/v2/runtime/runner/in-memory.d.cts

@@ -1,9 +1,65 @@
 
 import { AgentRunner, AgentRunnerConnectRequest, AgentRunnerIsRunningRequest, AgentRunnerRunRequest, AgentRunnerStopRequest } from "./agent-runner.cjs";
-import { Observable } from "rxjs";
-import { BaseEvent, Message } from "@ag-ui/client";
+import { Observable, ReplaySubject } from "rxjs";
+import { AbstractAgent, BaseEvent, Message } from "@ag-ui/client";
 
 //#region src/v2/runtime/runner/in-memory.d.ts
+interface InMemoryLimits {
+  /** LRU cap on distinct threads. */
+  maxThreads?: number;
+  /** FIFO cap on runs kept per thread. `Infinity` or `0` disables the cap. */
+  maxRunsPerThread?: number;
+  /**
+   * Approximate byte ceiling on RETAINED thread/run history. Enforced at run
+   * completion (in `appendRun`), where LRU non-running threads are evicted to
+   * keep the total under this limit.
+   *
+   * Limitation: this bounds only history that has already been committed. A
+   * single in-flight run's buffered events (`currentRunEvents` and the two
+   * `ReplaySubject<BaseEvent>(Infinity)` buffers in `run()`) are NOT counted
+   * until that run completes, so `maxBytes` does not bound a single runaway
+   * run mid-stream.
+   *
+   * Limitation: byte eviction drops only other LRU non-running threads and
+   * never self-evicts the active/just-appended thread, so a single dominant
+   * thread's own retained history is not byte-trimmed (bounded only by
+   * `maxRunsPerThread`). `maxBytes` is thus a cross-thread ceiling enforced by
+   * evicting OTHER threads, not a per-thread cap.
+   */
+  maxBytes?: number;
+}
+declare const ɵINMEMORY_DEFAULTS: Required<InMemoryLimits>;
+/**
+ * Best-effort approximate byte size of a value, via serialized length.
+ * Never throws — returns 0 when the value cannot be serialized. This is an
+ * approximation (UTF-16 length, not exact heap bytes), used only for relative
+ * accounting against `maxBytes`.
+ */
+declare function ɵestimateBytes(value: unknown): number;
+interface HistoricRun {
+  threadId: string;
+  runId: string;
+  /** ID of the agent that executed this run. */
+  agentId: string;
+  parentRunId: string | null;
+  events: BaseEvent[];
+  /**
+   * Snapshot of all messages (input + generated) at the end of this run, as
+   * passed in by the caller. NOTE: `BoundedThreadStore.appendRun` moves this
+   * snapshot to the THREAD level (`InMemoryEventStore.messagesSnapshot`) and
+   * clears this field to `[]`, so a stored HistoricRun never carries messages.
+   * The thread-messages fallback reads the thread-level snapshot, not this.
+   */
+  messages: Message[];
+  createdAt: number;
+  /** Approximate retained byte size of `events`; set by BoundedThreadStore at append. */
+  approxEventBytes?: number;
+  /**
+   * Legacy field retained for shape compatibility. `appendRun` always zeroes it
+   * because message bytes are accounted at the thread level, not per run.
+   */
+  approxMessageBytes?: number;
+}
 /**
  * Lightweight thread summary returned by {@link InMemoryAgentRunner.listThreads}.
  * Shape matches the Intelligence platform's ThreadRecord so the same HTTP
@@ -19,8 +75,113 @@ interface InMemoryThread {
   createdAt: string;
   updatedAt: string;
 }
+declare class InMemoryEventStore {
+  threadId: string;
+  constructor(threadId: string);
+  /** The subject that current consumers subscribe to. */
+  subject: ReplaySubject<BaseEvent> | null;
+  /** True while a run is actively producing events. */
+  isRunning: boolean;
+  /** Current run ID */
+  currentRunId: string | null;
+  /** Historic completed runs */
+  historicRuns: HistoricRun[];
+  /** Currently running agent instance (if any). */
+  agent: AbstractAgent | null;
+  /** Subject returned from run() while the run is active. */
+  runSubject: ReplaySubject<BaseEvent> | null;
+  /** True once stop() has been requested but the run has not yet finalized. */
+  stopRequested: boolean;
+  /** Reference to the events emitted in the current run. */
+  currentEvents: BaseEvent[] | null;
+  /**
+   * The thread's single latest NON-EMPTY message snapshot, held at the THREAD
+   * level (independent of `historicRuns` lifecycle). Decoupling the snapshot
+   * from per-run storage means run-cap FIFO eviction and interleaved
+   * empty-snapshot runs can never drop or pin the thread's message history.
+   */
+  messagesSnapshot: Message[];
+  /** Approximate retained byte size of `messagesSnapshot`. */
+  approxMessagesSnapshotBytes: number;
+}
+declare class ɵBoundedThreadStore {
+  private limits;
+  private readonly map;
+  private totalBytes;
+  private warned;
+  /** True once limits have been EXPLICITLY set (via setLimits), not just the constructor default. */
+  private limitsExplicitlySet;
+  /** Warn-once latch for the clobber warning, kept distinct from the eviction `warned` latch. */
+  private clobberWarned;
+  constructor(limits: Required<InMemoryLimits>);
+  get byteTotal(): number;
+  /**
+   * Reconfigure the process-global store's bounds. Called by the
+   * {@link InMemoryAgentRunner} constructor when limits are passed. Because the
+   * store is a per-process singleton, this replaces the bounds for ALL in-memory
+   * threads. Emits {@link LIMITS_CLOBBER_GUIDANCE} at most ONCE per store when a
+   * SECOND (or later) explicit set arrives whose resolved values differ from the
+   * prior explicit set — i.e. a genuine clobber of an already-customized config.
+   * The first explicit customization (defaults → custom) is the intended
+   * override and never warns; identical re-sets never warn.
+   */
+  setLimits(limits: Required<InMemoryLimits>): void;
+  get size(): number;
+  /** Re-insert at the tail so Map iteration order stays LRU-first. */
+  private touchOrder;
+  getOrCreate(threadId: string): InMemoryEventStore;
+  get(threadId: string, opts: {
+    touch: boolean;
+  }): InMemoryEventStore | undefined;
+  peek(threadId: string): InMemoryEventStore | undefined;
+  /**
+   * Evict the least-recently-used thread that is neither running NOR
+   * mid-finalization. Returns false if none evictable. The `protect` thread
+   * (typically the one just created) is never evicted, so a fresh thread is not
+   * immediately dropped when it is the only non-running candidate.
+   *
+   * A thread is skipped while `isRunning` OR `stopRequested` is set.
+   * `stop()` flips `isRunning` to false the moment it aborts the agent, but the
+   * run keeps finalizing asynchronously (the abort trips the `catch` in
+   * `runAgent`, which later calls `appendRun`). During that window
+   * `stopRequested` stays true; evicting the thread then would make the pending
+   * `appendRun` hit `if (!store) return` and silently drop the aborted run's
+   * history. Guarding on `stopRequested` keeps the thread alive until
+   * finalization completes.
+   */
+  private evictOneLru;
+  appendRun(threadId: string, run: HistoricRun): void;
+  private enforceRunCap;
+  /**
+   * Trim the store back under the byte ceiling by evicting LRU non-running
+   * threads. `protect` (the just-appended thread) is never self-evicted, so a
+   * fresh run pushes OTHER threads out rather than dropping itself.
+   */
+  private evictByBytesIfNeeded;
+  private removeThread;
+  private evictThreadsIfNeeded;
+  private noteEviction;
+  listThreads(): InMemoryThread[];
+  clear(): void;
+}
+/**
+ * Process-wide singleton backing every {@link InMemoryAgentRunner}. Exported
+ * (with the `ɵ` internal-API prefix) so tests can inspect the exact store the
+ * runner writes to; not part of the public API.
+ */
+declare const ɵGLOBAL_STORE: ɵBoundedThreadStore;
 declare class InMemoryAgentRunner extends AgentRunner {
   readonly ɵsupportsLocalThreadEndpoints = true;
+  /**
+   * @param limits Optional bounds for the process-global in-memory store. Omit
+   * for safe defaults ({@link ɵINMEMORY_DEFAULTS}). When multiple runners are
+   * constructed with differing limits, the last-constructed wins — in practice
+   * the OSS/SSE default construction passes nothing. If a second (or later)
+   * runner is constructed with limits that DIFFER from an already-customized
+   * store, a one-time `console.warn` is emitted to signal that the shared store's
+   * bounds are being clobbered for ALL in-memory threads.
+   */
+  constructor(limits?: InMemoryLimits);
   run(request: AgentRunnerRunRequest): Observable<BaseEvent>;
   connect(request: AgentRunnerConnectRequest): Observable<BaseEvent>;
   isRunning(request: AgentRunnerIsRunningRequest): Promise<boolean>;
@@ -75,5 +236,5 @@ declare class InMemoryAgentRunner extends AgentRunner {
   clearThreads(): void;
 }
 //#endregion
-export { InMemoryAgentRunner, InMemoryThread };
+export { InMemoryAgentRunner, InMemoryLimits, InMemoryThread, ɵBoundedThreadStore, ɵGLOBAL_STORE, ɵINMEMORY_DEFAULTS, ɵestimateBytes };
 //# sourceMappingURL=in-memory.d.cts.map

package/dist/v2/runtime/runner/in-memory.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"in-memory.d.cts","names":[],"sources":["../../../../src/v2/runtime/runner/in-memory.ts"],"mappings":";;;;;;AAuCA;;;;;AAAA,UAAiB,cAAA;EACf,EAAA;EACA,IAAA;EACA,OAAA;EACA,cAAA;EACA,WAAA;EACA,QAAA;EACA,SAAA;EACA,SAAA;AAAA;AAAA,cAiCW,mBAAA,SAA4B,WAAA;EAAA,SAC9B,6BAAA;EAET,GAAA,CAAI,OAAA,EAAS,qBAAA,GAAwB,UAAA,CAAW,SAAA;EAoMhD,OAAA,CAAQ,OAAA,EAAS,yBAAA,GAA4B,UAAA,CAAW,SAAA;EAqDxD,SAAA,CAAU,OAAA,EAAS,2BAAA,GAA8B,OAAA;EAKjD,IAAA,CAAK,OAAA,EAAS,sBAAA,GAAyB,OAAA;EA1DiB;;;;;;;EA+FxD,WAAA,CAAA,GAAe,cAAA;EAgDoB;;;;;;;;;EAfnC,iBAAA,CAAkB,QAAA,WAAmB,OAAA;EApUA;;;;;;;;EAmVrC,eAAA,CAAgB,QAAA,WAAmB,SAAA;EA1FzB;;;;;;;;;;EA4GV,cAAA,CAAe,QAAA,WAAmB,MAAA;EAlBlC;;;;;;;;;EA2CA,YAAA,CAAA;AAAA"}
+{"version":3,"file":"in-memory.d.cts","names":[],"sources":["../../../../src/v2/runtime/runner/in-memory.ts"],"mappings":";;;;;;UAmBiB,cAAA;;EAEf,UAAA;EAAA;EAEA,gBAAA;EAkBA;;;AAGF;;;;;AAwBA;;;;;AAMC;;;;EAjCC,QAAA;AAAA;AAAA,cAGW,kBAAA,EAAoB,QAAA,CAAS,cAAA;;;;;;;iBAwB1B,cAAA,CAAe,KAAA;AAAA,UAQrB,WAAA;EACR,QAAA;EACA,KAAA;EA4Be;EA1Bf,OAAA;EACA,WAAA;EACA,MAAA,EAAQ,SAAA;EAyBR;;;;;;;EAjBA,QAAA,EAAU,OAAA;EACV,SAAA;EAuBS;EArBT,gBAAA;EAwBsB;;;;EAnBtB,kBAAA;AAAA;;;;;;UAQe,cAAA;EACf,EAAA;EACA,IAAA;EACA,OAAA;EACA,cAAA;EACA,WAAA;EACA,QAAA;EACA,SAAA;EACA,SAAA;AAAA;AAAA,cAGI,kBAAA;EACe,QAAA;cAAA,QAAA;EAkBnB;EAfA,OAAA,EAAS,aAAA,CAAc,SAAA;EAeG;EAZ1B,SAAA;EAkBA;EAfA,YAAA;EAuBA;EApBA,YAAA,EAAc,WAAA;EAuBd;EApBA,KAAA,EAAO,aAAA;EAoBoB;EAjB3B,UAAA,EAAY,aAAA,CAAc,SAAA;EAoBI;EAjB9B,aAAA;EA0BqC;EAvBrC,aAAA,EAAe,SAAA;EAuCY;;;;;;EA/B3B,gBAAA,EAAkB,OAAA;EA6MW;EA1M7B,2BAAA;AAAA;AAAA,cAGW,mBAAA;EAAA,QASS,MAAA;EAAA,iBARH,GAAA;EAAA,QACT,UAAA;EAAA,QACA,MAAA;;UAEA,mBAAA;EAI6B;EAAA,QAF7B,aAAA;cAEY,MAAA,EAAQ,QAAA,CAAS,cAAA;EAAA,IAEjC,SAAA,CAAA;EAcc;;;;;;;;;;EAAlB,SAAA,CAAU,MAAA,EAAQ,QAAA,CAAS,cAAA;EAAA,IAmBvB,IAAA,CAAA;EAyBD;EAAA,QApBK,UAAA;EAKR,WAAA,CAAY,QAAA,WAAmB,kBAAA;EAY/B,GAAA,CACE,QAAA,UACA,IAAA;IAAQ,KAAA;EAAA,IACP,kBAAA;EAMH,IAAA,CAAK,QAAA,WAAmB,kBAAA;EA+BS;;;;;;;;;;;;AAgInC;;;EAhImC,QAZzB,WAAA;EAYR,SAAA,CAAU,QAAA,UAAkB,GAAA,EAAK,WAAA;EAAA,QA6CzB,aAAA;EAsFuB;;;;;EAAA,QAtEvB,oBAAA;EAAA,QAMA,YAAA;EAAA,QAUA,oBAAA;EAAA,QAMA,YAAA;EAUR,WAAA,CAAA,GAAe,cAAA;EAuBf,KAAA,CAAA;AAAA;;;;;;cAYW,aAAA,EAAa,mBAAA;AAAA,cAGb,mBAAA,SAA4B,WAAA;EAAA,SAC9B,6BAAA;EAD8B;;;;;;;;;cAY3B,MAAA,GAAS,cAAA;EAOrB,GAAA,CAAI,OAAA,EAAS,qBAAA,GAAwB,UAAA,CAAW,SAAA;EA2MhD,OAAA,CAAQ,OAAA,EAAS,yBAAA,GAA4B,UAAA,CAAW,SAAA;EAqDxD,SAAA,CAAU,OAAA,EAAS,2BAAA,GAA8B,OAAA;EAKjD,IAAA,CAAK,OAAA,EAAS,sBAAA,GAAyB,OAAA;EA1DiB;;;;;;;EA+FxD,WAAA,CAAA,GAAe,cAAA;EArCwB;;;;;;;;;EAkDvC,iBAAA,CAAkB,QAAA,WAAmB,OAAA;EA6CtB;;;;;;;;EAlBf,eAAA,CAAgB,QAAA,WAAmB,SAAA;;;;;;;;;;;EAkBnC,cAAA,CAAe,QAAA,WAAmB,MAAA;;;;;;;;;;EAmClC,YAAA,CAAA;AAAA"}

package/dist/v2/runtime/runner/in-memory.d.mts

@@ -1,9 +1,65 @@
 import "reflect-metadata";
 import { AgentRunner, AgentRunnerConnectRequest, AgentRunnerIsRunningRequest, AgentRunnerRunRequest, AgentRunnerStopRequest } from "./agent-runner.mjs";
-import { Observable } from "rxjs";
-import { BaseEvent, Message } from "@ag-ui/client";
+import { Observable, ReplaySubject } from "rxjs";
+import { AbstractAgent, BaseEvent, Message } from "@ag-ui/client";
 
 //#region src/v2/runtime/runner/in-memory.d.ts
+interface InMemoryLimits {
+  /** LRU cap on distinct threads. */
+  maxThreads?: number;
+  /** FIFO cap on runs kept per thread. `Infinity` or `0` disables the cap. */
+  maxRunsPerThread?: number;
+  /**
+   * Approximate byte ceiling on RETAINED thread/run history. Enforced at run
+   * completion (in `appendRun`), where LRU non-running threads are evicted to
+   * keep the total under this limit.
+   *
+   * Limitation: this bounds only history that has already been committed. A
+   * single in-flight run's buffered events (`currentRunEvents` and the two
+   * `ReplaySubject<BaseEvent>(Infinity)` buffers in `run()`) are NOT counted
+   * until that run completes, so `maxBytes` does not bound a single runaway
+   * run mid-stream.
+   *
+   * Limitation: byte eviction drops only other LRU non-running threads and
+   * never self-evicts the active/just-appended thread, so a single dominant
+   * thread's own retained history is not byte-trimmed (bounded only by
+   * `maxRunsPerThread`). `maxBytes` is thus a cross-thread ceiling enforced by
+   * evicting OTHER threads, not a per-thread cap.
+   */
+  maxBytes?: number;
+}
+declare const ɵINMEMORY_DEFAULTS: Required<InMemoryLimits>;
+/**
+ * Best-effort approximate byte size of a value, via serialized length.
+ * Never throws — returns 0 when the value cannot be serialized. This is an
+ * approximation (UTF-16 length, not exact heap bytes), used only for relative
+ * accounting against `maxBytes`.
+ */
+declare function ɵestimateBytes(value: unknown): number;
+interface HistoricRun {
+  threadId: string;
+  runId: string;
+  /** ID of the agent that executed this run. */
+  agentId: string;
+  parentRunId: string | null;
+  events: BaseEvent[];
+  /**
+   * Snapshot of all messages (input + generated) at the end of this run, as
+   * passed in by the caller. NOTE: `BoundedThreadStore.appendRun` moves this
+   * snapshot to the THREAD level (`InMemoryEventStore.messagesSnapshot`) and
+   * clears this field to `[]`, so a stored HistoricRun never carries messages.
+   * The thread-messages fallback reads the thread-level snapshot, not this.
+   */
+  messages: Message[];
+  createdAt: number;
+  /** Approximate retained byte size of `events`; set by BoundedThreadStore at append. */
+  approxEventBytes?: number;
+  /**
+   * Legacy field retained for shape compatibility. `appendRun` always zeroes it
+   * because message bytes are accounted at the thread level, not per run.
+   */
+  approxMessageBytes?: number;
+}
 /**
  * Lightweight thread summary returned by {@link InMemoryAgentRunner.listThreads}.
  * Shape matches the Intelligence platform's ThreadRecord so the same HTTP
@@ -19,8 +75,113 @@ interface InMemoryThread {
   createdAt: string;
   updatedAt: string;
 }
+declare class InMemoryEventStore {
+  threadId: string;
+  constructor(threadId: string);
+  /** The subject that current consumers subscribe to. */
+  subject: ReplaySubject<BaseEvent> | null;
+  /** True while a run is actively producing events. */
+  isRunning: boolean;
+  /** Current run ID */
+  currentRunId: string | null;
+  /** Historic completed runs */
+  historicRuns: HistoricRun[];
+  /** Currently running agent instance (if any). */
+  agent: AbstractAgent | null;
+  /** Subject returned from run() while the run is active. */
+  runSubject: ReplaySubject<BaseEvent> | null;
+  /** True once stop() has been requested but the run has not yet finalized. */
+  stopRequested: boolean;
+  /** Reference to the events emitted in the current run. */
+  currentEvents: BaseEvent[] | null;
+  /**
+   * The thread's single latest NON-EMPTY message snapshot, held at the THREAD
+   * level (independent of `historicRuns` lifecycle). Decoupling the snapshot
+   * from per-run storage means run-cap FIFO eviction and interleaved
+   * empty-snapshot runs can never drop or pin the thread's message history.
+   */
+  messagesSnapshot: Message[];
+  /** Approximate retained byte size of `messagesSnapshot`. */
+  approxMessagesSnapshotBytes: number;
+}
+declare class ɵBoundedThreadStore {
+  private limits;
+  private readonly map;
+  private totalBytes;
+  private warned;
+  /** True once limits have been EXPLICITLY set (via setLimits), not just the constructor default. */
+  private limitsExplicitlySet;
+  /** Warn-once latch for the clobber warning, kept distinct from the eviction `warned` latch. */
+  private clobberWarned;
+  constructor(limits: Required<InMemoryLimits>);
+  get byteTotal(): number;
+  /**
+   * Reconfigure the process-global store's bounds. Called by the
+   * {@link InMemoryAgentRunner} constructor when limits are passed. Because the
+   * store is a per-process singleton, this replaces the bounds for ALL in-memory
+   * threads. Emits {@link LIMITS_CLOBBER_GUIDANCE} at most ONCE per store when a
+   * SECOND (or later) explicit set arrives whose resolved values differ from the
+   * prior explicit set — i.e. a genuine clobber of an already-customized config.
+   * The first explicit customization (defaults → custom) is the intended
+   * override and never warns; identical re-sets never warn.
+   */
+  setLimits(limits: Required<InMemoryLimits>): void;
+  get size(): number;
+  /** Re-insert at the tail so Map iteration order stays LRU-first. */
+  private touchOrder;
+  getOrCreate(threadId: string): InMemoryEventStore;
+  get(threadId: string, opts: {
+    touch: boolean;
+  }): InMemoryEventStore | undefined;
+  peek(threadId: string): InMemoryEventStore | undefined;
+  /**
+   * Evict the least-recently-used thread that is neither running NOR
+   * mid-finalization. Returns false if none evictable. The `protect` thread
+   * (typically the one just created) is never evicted, so a fresh thread is not
+   * immediately dropped when it is the only non-running candidate.
+   *
+   * A thread is skipped while `isRunning` OR `stopRequested` is set.
+   * `stop()` flips `isRunning` to false the moment it aborts the agent, but the
+   * run keeps finalizing asynchronously (the abort trips the `catch` in
+   * `runAgent`, which later calls `appendRun`). During that window
+   * `stopRequested` stays true; evicting the thread then would make the pending
+   * `appendRun` hit `if (!store) return` and silently drop the aborted run's
+   * history. Guarding on `stopRequested` keeps the thread alive until
+   * finalization completes.
+   */
+  private evictOneLru;
+  appendRun(threadId: string, run: HistoricRun): void;
+  private enforceRunCap;
+  /**
+   * Trim the store back under the byte ceiling by evicting LRU non-running
+   * threads. `protect` (the just-appended thread) is never self-evicted, so a
+   * fresh run pushes OTHER threads out rather than dropping itself.
+   */
+  private evictByBytesIfNeeded;
+  private removeThread;
+  private evictThreadsIfNeeded;
+  private noteEviction;
+  listThreads(): InMemoryThread[];
+  clear(): void;
+}
+/**
+ * Process-wide singleton backing every {@link InMemoryAgentRunner}. Exported
+ * (with the `ɵ` internal-API prefix) so tests can inspect the exact store the
+ * runner writes to; not part of the public API.
+ */
+declare const ɵGLOBAL_STORE: ɵBoundedThreadStore;
 declare class InMemoryAgentRunner extends AgentRunner {
   readonly ɵsupportsLocalThreadEndpoints = true;
+  /**
+   * @param limits Optional bounds for the process-global in-memory store. Omit
+   * for safe defaults ({@link ɵINMEMORY_DEFAULTS}). When multiple runners are
+   * constructed with differing limits, the last-constructed wins — in practice
+   * the OSS/SSE default construction passes nothing. If a second (or later)
+   * runner is constructed with limits that DIFFER from an already-customized
+   * store, a one-time `console.warn` is emitted to signal that the shared store's
+   * bounds are being clobbered for ALL in-memory threads.
+   */
+  constructor(limits?: InMemoryLimits);
   run(request: AgentRunnerRunRequest): Observable<BaseEvent>;
   connect(request: AgentRunnerConnectRequest): Observable<BaseEvent>;
   isRunning(request: AgentRunnerIsRunningRequest): Promise<boolean>;
@@ -75,5 +236,5 @@ declare class InMemoryAgentRunner extends AgentRunner {
   clearThreads(): void;
 }
 //#endregion
-export { InMemoryAgentRunner, InMemoryThread };
+export { InMemoryAgentRunner, InMemoryLimits, InMemoryThread, ɵBoundedThreadStore, ɵGLOBAL_STORE, ɵINMEMORY_DEFAULTS, ɵestimateBytes };
 //# sourceMappingURL=in-memory.d.mts.map

package/dist/v2/runtime/runner/in-memory.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"in-memory.d.mts","names":[],"sources":["../../../../src/v2/runtime/runner/in-memory.ts"],"mappings":";;;;;;AAuCA;;;;;AAAA,UAAiB,cAAA;EACf,EAAA;EACA,IAAA;EACA,OAAA;EACA,cAAA;EACA,WAAA;EACA,QAAA;EACA,SAAA;EACA,SAAA;AAAA;AAAA,cAiCW,mBAAA,SAA4B,WAAA;EAAA,SAC9B,6BAAA;EAET,GAAA,CAAI,OAAA,EAAS,qBAAA,GAAwB,UAAA,CAAW,SAAA;EAoMhD,OAAA,CAAQ,OAAA,EAAS,yBAAA,GAA4B,UAAA,CAAW,SAAA;EAqDxD,SAAA,CAAU,OAAA,EAAS,2BAAA,GAA8B,OAAA;EAKjD,IAAA,CAAK,OAAA,EAAS,sBAAA,GAAyB,OAAA;EA1DiB;;;;;;;EA+FxD,WAAA,CAAA,GAAe,cAAA;EAgDoB;;;;;;;;;EAfnC,iBAAA,CAAkB,QAAA,WAAmB,OAAA;EApUA;;;;;;;;EAmVrC,eAAA,CAAgB,QAAA,WAAmB,SAAA;EA1FzB;;;;;;;;;;EA4GV,cAAA,CAAe,QAAA,WAAmB,MAAA;EAlBlC;;;;;;;;;EA2CA,YAAA,CAAA;AAAA"}
+{"version":3,"file":"in-memory.d.mts","names":[],"sources":["../../../../src/v2/runtime/runner/in-memory.ts"],"mappings":";;;;;;UAmBiB,cAAA;;EAEf,UAAA;EAAA;EAEA,gBAAA;EAkBA;;;AAGF;;;;;AAwBA;;;;;AAMC;;;;EAjCC,QAAA;AAAA;AAAA,cAGW,kBAAA,EAAoB,QAAA,CAAS,cAAA;;;;;;;iBAwB1B,cAAA,CAAe,KAAA;AAAA,UAQrB,WAAA;EACR,QAAA;EACA,KAAA;EA4Be;EA1Bf,OAAA;EACA,WAAA;EACA,MAAA,EAAQ,SAAA;EAyBR;;;;;;;EAjBA,QAAA,EAAU,OAAA;EACV,SAAA;EAuBS;EArBT,gBAAA;EAwBsB;;;;EAnBtB,kBAAA;AAAA;;;;;;UAQe,cAAA;EACf,EAAA;EACA,IAAA;EACA,OAAA;EACA,cAAA;EACA,WAAA;EACA,QAAA;EACA,SAAA;EACA,SAAA;AAAA;AAAA,cAGI,kBAAA;EACe,QAAA;cAAA,QAAA;EAkBnB;EAfA,OAAA,EAAS,aAAA,CAAc,SAAA;EAeG;EAZ1B,SAAA;EAkBA;EAfA,YAAA;EAuBA;EApBA,YAAA,EAAc,WAAA;EAuBd;EApBA,KAAA,EAAO,aAAA;EAoBoB;EAjB3B,UAAA,EAAY,aAAA,CAAc,SAAA;EAoBI;EAjB9B,aAAA;EA0BqC;EAvBrC,aAAA,EAAe,SAAA;EAuCY;;;;;;EA/B3B,gBAAA,EAAkB,OAAA;EA6MW;EA1M7B,2BAAA;AAAA;AAAA,cAGW,mBAAA;EAAA,QASS,MAAA;EAAA,iBARH,GAAA;EAAA,QACT,UAAA;EAAA,QACA,MAAA;;UAEA,mBAAA;EAI6B;EAAA,QAF7B,aAAA;cAEY,MAAA,EAAQ,QAAA,CAAS,cAAA;EAAA,IAEjC,SAAA,CAAA;EAcc;;;;;;;;;;EAAlB,SAAA,CAAU,MAAA,EAAQ,QAAA,CAAS,cAAA;EAAA,IAmBvB,IAAA,CAAA;EAyBD;EAAA,QApBK,UAAA;EAKR,WAAA,CAAY,QAAA,WAAmB,kBAAA;EAY/B,GAAA,CACE,QAAA,UACA,IAAA;IAAQ,KAAA;EAAA,IACP,kBAAA;EAMH,IAAA,CAAK,QAAA,WAAmB,kBAAA;EA+BS;;;;;;;;;;;;AAgInC;;;EAhImC,QAZzB,WAAA;EAYR,SAAA,CAAU,QAAA,UAAkB,GAAA,EAAK,WAAA;EAAA,QA6CzB,aAAA;EAsFuB;;;;;EAAA,QAtEvB,oBAAA;EAAA,QAMA,YAAA;EAAA,QAUA,oBAAA;EAAA,QAMA,YAAA;EAUR,WAAA,CAAA,GAAe,cAAA;EAuBf,KAAA,CAAA;AAAA;;;;;;cAYW,aAAA,EAAa,mBAAA;AAAA,cAGb,mBAAA,SAA4B,WAAA;EAAA,SAC9B,6BAAA;EAD8B;;;;;;;;;cAY3B,MAAA,GAAS,cAAA;EAOrB,GAAA,CAAI,OAAA,EAAS,qBAAA,GAAwB,UAAA,CAAW,SAAA;EA2MhD,OAAA,CAAQ,OAAA,EAAS,yBAAA,GAA4B,UAAA,CAAW,SAAA;EAqDxD,SAAA,CAAU,OAAA,EAAS,2BAAA,GAA8B,OAAA;EAKjD,IAAA,CAAK,OAAA,EAAS,sBAAA,GAAyB,OAAA;EA1DiB;;;;;;;EA+FxD,WAAA,CAAA,GAAe,cAAA;EArCwB;;;;;;;;;EAkDvC,iBAAA,CAAkB,QAAA,WAAmB,OAAA;EA6CtB;;;;;;;;EAlBf,eAAA,CAAgB,QAAA,WAAmB,SAAA;;;;;;;;;;;EAkBnC,cAAA,CAAe,QAAA,WAAmB,MAAA;;;;;;;;;;EAmClC,YAAA,CAAA;AAAA"}