agentfootprint 7.18.0 → 7.19.0

package/dist/types/hosting/durability.d.ts

@@ -0,0 +1,93 @@
+/**
+ * hosting/durability — how often a run's progress becomes crash-survivable.
+ *
+ * A standing agent that only writes at the end of a turn is one restart away
+ * from losing everything the turn had done: the tool calls it made, the results
+ * it read, the iterations it spent. This is the dial that decides how much of
+ * that survives, and what it costs.
+ *
+ * ── Where a mid-run write can honestly come from ─────────────────────────────
+ * From the COMMIT boundary, and nowhere else. footprintjs commits a stage's
+ * writes after the stage function returns, and committed state is
+ * immutable-after-swap — so `ScopeRecorder.onCommit` is the one moment where
+ * "what the run has agreed on so far" is a real, complete, consistent thing.
+ * Reading the agent's live state at any other moment would be reading a stage's
+ * work in progress.
+ *
+ * There is no mid-run engine checkpoint to store: footprintjs builds a
+ * `FlowchartCheckpoint` only at a pause (`getCheckpoint()` is documented as "the
+ * most recent PAUSED execution"). So what a mid-run write can carry is a
+ * CONVERSATION — the same `AgentRunCheckpoint` every finished turn stores — and
+ * that is exactly enough, because that is what the next turn resumes from.
+ *
+ * ── Why it writes on SOME commits and not all of them ────────────────────────
+ * A two-iteration turn commits about forty times. Exactly two of those commits
+ * change the conversation: `Initialize` (the user's message lands) and
+ * `ToolCalls` (an iteration's assistant turn and its tool results land). Every
+ * other commit would store bytes identical to the last write. So the trigger is
+ * "this commit wrote `history`", which is not an optimisation but the honest
+ * reading of the question: the conversation moved iff `history` moved.
+ *
+ * ── What a commit boundary actually guarantees, and what it does not ─────────
+ * It guarantees the whole stage. The agent dispatches ALL of one iteration's
+ * tool calls inside one stage body, so a crash part-way through that body stores
+ * nothing from it and a replay re-runs that iteration's tools. That is the
+ * shipped idempotency requirement, unchanged — mutating tools must be
+ * idempotent, keyed on stable call content rather than `ctx.toolCallId`. What
+ * `'sync'` adds is a BOUND on it: iteration N's tools do not start until
+ * iteration N-1's write has landed, so the replay is the current iteration and
+ * never an earlier one.
+ *
+ * Pattern: an observer (`CombinedRecorder`) for the snapshot, a serialiser for
+ * the writes, and — for `'sync'` only — a barrier the tool dispatch waits on.
+ * Role: internal to `standingAgent`. Deliberately not exported: it is how the
+ * composer keeps its promise, not a second way to write to a store.
+ */
+import type { CombinedRecorder } from 'footprintjs';
+import type { AgentRunCheckpoint } from '../core/runCheckpoint.js';
+import type { DurabilityMode } from './types.js';
+/** What the writer needs from the composer around it. */
+export interface DurableWriterOptions {
+    /** `'async'` or `'sync'`. `'exit'` never builds a writer at all. */
+    readonly mode: Exclude<DurabilityMode, 'exit'>;
+    /**
+     * The session this run belongs to, asked at every commit. `undefined` means
+     * "nothing to write to" — an anonymous request, or no run of ours in flight —
+     * and the commit is ignored.
+     */
+    readonly session: () => string | undefined;
+    /** The run id to stamp on the conversation, for correlating back to the run. */
+    readonly runId: () => string | undefined;
+    /** Where the conversation goes. */
+    readonly write: (sessionId: string, conversation: AgentRunCheckpoint) => Promise<void>;
+}
+/** The composer's handle on its own durability. */
+export interface DurableWriter {
+    /** Attach this to the agent to start observing commits. */
+    readonly recorder: CombinedRecorder;
+    /** Install the tool-dispatch barrier. Returns the uninstall function. */
+    install(agent: object): () => void;
+    /**
+     * Everything outstanding has landed.
+     *
+     * The composer awaits this before writing a run's FINAL envelope, and that
+     * ordering is load-bearing rather than tidy: an `'async'` conversation write
+     * still in flight would otherwise land AFTER the terminal envelope and
+     * overwrite it — turning a stored pause back into a plain conversation and
+     * losing the question a person was asked.
+     *
+     * **Rejects when the newest write did not land.** Fail-closed on purpose: a
+     * store that refused the run's progress has not made it durable, and both
+     * things waiting on this — the next tool call under `'sync'`, and the reply —
+     * would otherwise proceed on a promise nobody kept.
+     */
+    settle(): Promise<void>;
+}
+/**
+ * Build the writer.
+ *
+ * Under `'sync'` it also answers the tool-dispatch barrier, which is what turns
+ * "we write often" into a bound on how much can re-run.
+ */
+export declare function durableWriter(options: DurableWriterOptions): DurableWriter;
+//# sourceMappingURL=durability.d.ts.map

package/dist/types/hosting/durability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"durability.d.ts","sourceRoot":"","sources":["../../../src/hosting/durability.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAe,MAAM,aAAa,CAAC;AAIjE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,yDAAyD;AACzD,MAAM,WAAW,oBAAoB;IACnC,oEAAoE;IACpE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,cAAc,EAAE,MAAM,CAAC,CAAC;IAC/C;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IAC3C,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,MAAM,MAAM,GAAG,SAAS,CAAC;IACzC,mCAAmC;IACnC,QAAQ,CAAC,KAAK,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,kBAAkB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACxF;AAED,mDAAmD;AACnD,MAAM,WAAW,aAAa;IAC5B,2DAA2D;IAC3D,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IACpC,yEAAyE;IACzE,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,IAAI,CAAC;IACnC;;;;;;;;;;;;;OAaG;IACH,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,aAAa,CAgI1E"}

package/dist/types/hosting/envelope.d.ts

@@ -1,17 +1,27 @@
 /**
- * hosting/envelope — pack a conversation for storage, and refuse to unpack one
- * you cannot read.
- *
- * Two functions and one rule: **an unknown format is refused by name, never
- * guessed at.** A store outlives the code that wrote to it. Somebody will
- * deploy a newer runtime, it will write a newer format, and an older instance
- * still running will read it. The only honest thing that older instance can do
- * is say which format it found, which ones it knows, and stop — because
- * "restore what I can and hope" means an agent answering from a conversation
- * that is missing whatever the older reader did not understand.
+ * hosting/envelope — pack a session for storage, and refuse to unpack one you
+ * cannot read.
+ *
+ * One rule, and everything here is a consequence of it: **an envelope this
+ * runtime cannot read is refused BY NAME, never guessed at.** A store outlives
+ * the code that wrote to it. Somebody will deploy a newer runtime, it will write
+ * a newer format, and an older instance still running will read it. The only
+ * honest thing that older instance can do is say which format it found, which
+ * ones it knows, and stop — because "restore what I can and hope" means an agent
+ * answering from a session that is missing whatever the older reader did not
+ * understand.
+ *
+ * ── Two formats, two readers, and why they refuse each other ─────────────────
+ * `readEnvelope` unpacks a CONVERSATION; `readPausedRun` unpacks a PAUSED RUN.
+ * Each refuses the other's format by name and points at its sibling. That looks
+ * fussy until you notice the alternative: one reader that quietly returned the
+ * conversation inside a paused run would hand back a session that LOOKS finished
+ * while a person is still waiting on a question nobody mentioned. That is a
+ * half-restore wearing a happy path, which is the exact failure the format field
+ * exists to prevent.
  */
 import { type AgentRunCheckpoint } from '../core/runCheckpoint.js';
-import type { CheckpointEnvelope } from './types.js';
+import type { CheckpointEnvelope, ConversationEnvelope, PausedRun, PausedRunEnvelope } from './types.js';
 /**
  * Pack a conversation checkpoint for storage.
  *
@@ -19,7 +29,28 @@ import type { CheckpointEnvelope } from './types.js';
  *   const conversation = agent.checkpoint();
  *   if (conversation) await sessions.persist(sessionId, toEnvelope(conversation));
  */
-export declare function toEnvelope(checkpoint: AgentRunCheckpoint): CheckpointEnvelope;
+export declare function toEnvelope(checkpoint: AgentRunCheckpoint): ConversationEnvelope;
+/**
+ * Pack a paused run for storage — the engine checkpoint, the conversation as of
+ * the pause, and the question it is waiting on.
+ *
+ * Store it anywhere that speaks JSON. Note what JSON does and does not preserve
+ * here: `agent.resume()` reads `checkpoint.sharedState`, which round-trips
+ * unchanged; the engine's diagnostic halves lose their explicitly-`undefined`
+ * properties, because that is what `JSON.stringify` does to them. See
+ * {@link PausedRun}.
+ *
+ * @example
+ *   const outcome = await agent.run({ message });
+ *   if (isPaused(outcome)) {
+ *     await sessions.persist(sessionId, toPausedEnvelope({
+ *       checkpoint: outcome.checkpoint,
+ *       conversation: agent.checkpoint()!,
+ *       pending: { pauseData: outcome.pauseData },
+ *     }));
+ *   }
+ */
+export declare function toPausedEnvelope(paused: PausedRun): PausedRunEnvelope;
 /**
  * Unpack a stored envelope back into a conversation checkpoint.
  *
@@ -27,8 +58,38 @@ export declare function toEnvelope(checkpoint: AgentRunCheckpoint): CheckpointEn
  * else wrote, in a format this runtime may not know, and typing the parameter
  * as the happy shape would be assuming the very thing that needs checking.
  *
- * @throws TypeError naming the format when it is one this runtime cannot read,
- *   and naming the missing field when the conversation inside is malformed.
+ * @throws TypeError naming the format when it is one this runtime cannot read;
+ *   naming the missing field when the conversation inside is malformed; and
+ *   pointing at {@link readPausedRun} when the envelope holds a paused run,
+ *   which is a session with a question outstanding rather than a conversation.
  */
 export declare function readEnvelope(envelope: unknown): AgentRunCheckpoint;
+/**
+ * Unpack a stored envelope back into a paused run.
+ *
+ * @throws TypeError naming the format when it is one this runtime cannot read;
+ *   pointing at {@link readEnvelope} when the envelope holds a plain
+ *   conversation; and naming the missing field when the paused run inside is
+ *   malformed.
+ */
+export declare function readPausedRun(envelope: unknown): PausedRun;
+/**
+ * Check that an envelope is one this runtime can read, and hand it back
+ * unchanged — without committing to which half you wanted.
+ *
+ * This is what a STORE wants. A store's job is to notice that the bytes it is
+ * about to hand over are unreadable, so the refusal names the store that
+ * produced them rather than whoever read them next; it has no business caring
+ * whether the session inside is mid-conversation or mid-question.
+ *
+ * @throws TypeError naming the format when this runtime cannot read it, or the
+ *   missing field when the payload is malformed.
+ *
+ * @example
+ *   async hydrate(sessionId) {
+ *     const stored = await myStore.get(sessionId);
+ *     return stored === undefined ? undefined : checkEnvelope(stored);
+ *   }
+ */
+export declare function checkEnvelope(envelope: unknown): CheckpointEnvelope;
 //# sourceMappingURL=envelope.d.ts.map

package/dist/types/hosting/envelope.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"envelope.d.ts","sourceRoot":"","sources":["../../../src/hosting/envelope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAsB,KAAK,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACvF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAKrD;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,UAAU,EAAE,kBAAkB,GAAG,kBAAkB,CAE7E;AAED;;;;;;;;;GASG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,OAAO,GAAG,kBAAkB,CAkBlE"}
+{"version":3,"file":"envelope.d.ts","sourceRoot":"","sources":["../../../src/hosting/envelope.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAsB,KAAK,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACvF,OAAO,KAAK,EACV,kBAAkB,EAClB,oBAAoB,EACpB,SAAS,EACT,iBAAiB,EAClB,MAAM,YAAY,CAAC;AAKpB;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,UAAU,EAAE,kBAAkB,GAAG,oBAAoB,CAE/E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,SAAS,GAAG,iBAAiB,CAErE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,OAAO,GAAG,kBAAkB,CAUlE;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,OAAO,GAAG,SAAS,CAQ1D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,OAAO,GAAG,kBAAkB,CAOnE"}

package/dist/types/hosting/errors.d.ts

@@ -3,17 +3,21 @@
  * same words.
  *
  * A refusal that varies by adapter is a refusal nobody can write a test or a
- * runbook against. These three carry a stable `code`, name WHO refused, and say
+ * runbook against. These five carry a stable `code`, name WHO refused, and say
  * what the caller should do instead. Adapters map the codes onto whatever their
  * transport uses to say "no" — that mapping is the adapter's business and lives
  * in the adapter, never here.
  *
- * `requireCapability` is the fourth refusal and the only one that is a
+ * Note what is NOT here: a run that paused. That is unfinished work rather than
+ * a refusal, and it leaves through `reply.awaiting(...)` — its own terminal —
+ * not through an error dressed up as one.
+ *
+ * `requireCapability` is the last refusal and the only one that is a
  * programming mistake rather than a runtime condition, so it throws a plain
  * `Error`: nothing branches on "I forgot to feature-detect", it just needs to
  * say so loudly and name the adapter it is talking about.
  */
-import type { AgentHost, HostCapability } from './types.js';
+import type { AgentHost, HostCapability, PendingAsk } from './types.js';
 /**
  * Thrown when a request arrives at a host that is shutting down or shut down.
  *
@@ -44,22 +48,67 @@ export declare class ConcurrentRunError extends Error {
     constructor(sessionId: string, activeRunId?: string);
 }
 /**
- * Raised when a run paused to ask a person something and the reply cannot carry
- * a pause.
+ * Raised when a run paused to ask a person something and there is **nowhere to
+ * keep it**.
  *
  * **The run did not fail.** A pause is unfinished work: the agent stopped to ask
- * and is waiting for an answer. What cannot happen here is storing it — the
- * `'conversation-v1'` envelope holds a conversation, and a paused run is a
- * conversation plus an engine checkpoint. So nothing is written, and the
- * session keeps exactly the conversation it had before this request.
+ * and is waiting for an answer. Since 7.19 a paused run is stored as
+ * `'flowchart-v1'` and continued by a later request carrying a decision — so the
+ * one case left where a pause genuinely cannot be carried is a request with no
+ * session id. There is no session to store it under, and therefore no later
+ * request that could ever answer it.
+ *
+ * The other half of the old meaning — "the reply cannot carry a pause" — is
+ * gone: {@link HostReply.awaiting} carries it now. An adapter that has not
+ * implemented that terminal still gets its pause STORED (the store is not the
+ * transport's business) and this refusal on the wire, naming the session it can
+ * be answered on.
  */
 export declare class PauseNotCarriedError extends Error {
     readonly code: "ERR_PAUSE_NOT_CARRIED";
     /** The tool that asked, when the run recorded which one it was. */
     readonly toolName?: string;
-    /** The session whose stored conversation was left untouched. */
+    /** The session the paused run was stored under, when there was one. */
     readonly sessionId?: string;
-    constructor(toolName?: string, sessionId?: string);
+    /** Whether the paused run was stored. `false` means it is gone. */
+    readonly stored: boolean;
+    constructor(toolName?: string, sessionId?: string, stored?: boolean);
+}
+/**
+ * Thrown when a new message arrives for a session whose run is waiting on a
+ * person's decision.
+ *
+ * The message is NOT run and the pause is NOT discarded — those are the two ways
+ * this could have gone wrong. Answering the message would step over an
+ * outstanding consent gate; dropping the paused run to make room for the message
+ * would throw away work a person was asked about. So the request is refused, the
+ * pending question is named, and the session sits exactly where it was.
+ *
+ * Answer it by sending the same session a request carrying
+ * {@link HostRequest.decision}.
+ */
+export declare class AwaitingDecisionError extends Error {
+    readonly code: "ERR_AWAITING_DECISION";
+    /** The session that is waiting. */
+    readonly sessionId: string;
+    /** What it is waiting on — the same payload `reply.awaiting()` delivered. */
+    readonly pending: PendingAsk;
+    constructor(sessionId: string, pending: PendingAsk);
+}
+/**
+ * Thrown when a request carries a decision for a session that is not waiting on
+ * one.
+ *
+ * Usually a duplicate delivery: the run was already continued, or already
+ * answered, and the same decision arrived twice. Running it as an ordinary
+ * message would put a raw approval into the conversation as if the user had
+ * typed it, so it is refused by name instead.
+ */
+export declare class NoPendingAskError extends Error {
+    readonly code: "ERR_NO_PENDING_ASK";
+    /** The session the decision was addressed to. */
+    readonly sessionId: string;
+    constructor(sessionId: string);
 }
 /**
  * Assert that a host can do something, and throw a corrective error naming the

package/dist/types/hosting/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/hosting/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5D;;;;;GAKG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,IAAI,oBAA8B;IAC3C,6BAA6B;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;gBAEd,QAAQ,EAAE,MAAM;CAS7B;AAED;;;;;;;;GAQG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,IAAI,uBAAiC;IAC9C,gDAAgD;IAChD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,mEAAmE;IACnE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;gBAElB,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM;CAapD;AAED;;;;;;;;;GASG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,IAAI,0BAAoC;IACjD,mEAAmE;IACnE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,gEAAgE;IAChE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;gBAEhB,QAAQ,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM;CAiBlD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,cAAc,GAAG,IAAI,CASnF"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/hosting/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExE;;;;;GAKG;AACH,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,IAAI,oBAA8B;IAC3C,6BAA6B;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;gBAEd,QAAQ,EAAE,MAAM;CAS7B;AAED;;;;;;;;GAQG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,IAAI,uBAAiC;IAC9C,gDAAgD;IAChD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,mEAAmE;IACnE,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;gBAElB,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM;CAapD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,IAAI,0BAAoC;IACjD,mEAAmE;IACnE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,uEAAuE;IACvE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,mEAAmE;IACnE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;gBAEb,QAAQ,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,MAAM,UAAQ;CAsBlE;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,IAAI,0BAAoC;IACjD,mCAAmC;IACnC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,6EAA6E;IAC7E,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;gBAEjB,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU;CAgBnD;AAED;;;;;;;;GAQG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAC1C,QAAQ,CAAC,IAAI,uBAAiC;IAC9C,iDAAiD;IACjD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;gBAEf,SAAS,EAAE,MAAM;CAW9B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,cAAc,GAAG,IAAI,CASnF"}

package/dist/types/hosting/httpHost.d.ts

@@ -28,7 +28,7 @@
  * Pattern: Template method via configuration (Strategy on the wire format).
  * Everything HTTP lives here and in the wires; `types.ts` knows none of it.
  */
-import type { AgentHost, HostCapability, HostHandle, HostHandler } from './types.js';
+import type { AgentHost, HostCapability, HostHandle, HostHandler, PendingAsk } from './types.js';
 /** Everything a {@link HttpWire} may read when pulling a request apart. */
 export interface HttpRequestFacts {
     /** The parsed JSON body, or `{}` for an empty one. */
@@ -57,6 +57,12 @@ export interface HttpWire {
     readRequest(facts: HttpRequestFacts): {
         readonly input: string;
         readonly sessionId?: string;
+        /**
+         * A person's answer to an outstanding question, when this request carries
+         * one. Its presence is what makes a request a RESUME rather than a new
+         * message, so a wire that never returns it can only ever start new turns.
+         */
+        readonly decision?: unknown;
     };
     /** Body for a health probe. `uptimeMs` is how long this host has been serving. */
     health(uptimeMs: number): unknown;
@@ -66,6 +72,16 @@ export interface HttpWire {
     failure(message: string, code?: string): unknown;
     /** Body for one streamed piece, when the caller asked for Server-Sent Events. */
     chunk(text: string): unknown;
+    /**
+     * Body for a reply that is WAITING on a person — the run paused, it is stored,
+     * and a later request carrying a decision continues it.
+     *
+     * Optional so a wire written before this terminal existed keeps compiling and
+     * keeps working. A host whose wire has no `awaiting` cannot describe the
+     * question, so it reports the named refusal instead — the run is still stored
+     * either way.
+     */
+    awaiting?(pending: PendingAsk): unknown;
 }
 /** Options for {@link httpHost}. */
 export interface HttpHostOptions {

package/dist/types/hosting/httpHost.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"httpHost.d.ts","sourceRoot":"","sources":["../../../src/hosting/httpHost.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAMH,OAAO,KAAK,EAAE,SAAS,EAAE,cAAc,EAAE,UAAU,EAAE,WAAW,EAAa,MAAM,YAAY,CAAC;AAEhG,2EAA2E;AAC3E,MAAM,WAAW,gBAAgB;IAC/B,sDAAsD;IACtD,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACjD,oFAAoF;IACpF,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACnD,wCAAwC;IACxC,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;CACjC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,QAAQ;IACvB;;;;;;OAMG;IACH,WAAW,CAAC,KAAK,EAAE,gBAAgB,GAAG;QAAE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC9F,kFAAkF;IAClF,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IAClC,uCAAuC;IACvC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IAChC,0FAA0F;IAC1F,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACjD,iFAAiF;IACjF,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;CAC9B;AAED,oCAAoC;AACpC,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,yCAAyC;IACzC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,uEAAuE;IACvE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,oEAAoE;IACpE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,6EAA6E;IAC7E,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;CACnD;AAED,2DAA2D;AAC3D,MAAM,WAAW,cAAe,SAAQ,UAAU;IAChD,qEAAqE;IACrE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,oDAAoD;AACpD,MAAM,WAAW,QAAS,SAAQ,SAAS;IACzC,KAAK,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;CACtD;AAmBD;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,QAAQ,CAsE3D;AA+HD;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,gBAAgB,EACvB,IAAI,EAAE,MAAM,EACZ,GAAG,SAAS,EAAE,MAAM,EAAE,GACrB,MAAM,GAAG,SAAS,CAMpB"}
+{"version":3,"file":"httpHost.d.ts","sourceRoot":"","sources":["../../../src/hosting/httpHost.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAMH,OAAO,KAAK,EACV,SAAS,EACT,cAAc,EACd,UAAU,EACV,WAAW,EAEX,UAAU,EACX,MAAM,YAAY,CAAC;AAEpB,2EAA2E;AAC3E,MAAM,WAAW,gBAAgB;IAC/B,sDAAsD;IACtD,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACjD,oFAAoF;IACpF,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACnD,wCAAwC;IACxC,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;CACjC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,QAAQ;IACvB;;;;;;OAMG;IACH,WAAW,CAAC,KAAK,EAAE,gBAAgB,GAAG;QACpC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAC5B;;;;WAIG;QACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;KAC7B,CAAC;IACF,kFAAkF;IAClF,MAAM,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;IAClC,uCAAuC;IACvC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;IAChC,0FAA0F;IAC1F,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IACjD,iFAAiF;IACjF,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAC7B;;;;;;;;OAQG;IACH,QAAQ,CAAC,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC;CACzC;AAED,oCAAoC;AACpC,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,yCAAyC;IACzC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,uEAAuE;IACvE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,oEAAoE;IACpE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,6EAA6E;IAC7E,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,cAAc,EAAE,CAAC;CACnD;AAED,2DAA2D;AAC3D,MAAM,WAAW,cAAe,SAAQ,UAAU;IAChD,qEAAqE;IACrE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,oDAAoD;AACpD,MAAM,WAAW,QAAS,SAAQ,SAAS;IACzC,KAAK,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;CACtD;AA8BD;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,QAAQ,CAsE3D;AAyJD;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,gBAAgB,EACvB,IAAI,EAAE,MAAM,EACZ,GAAG,SAAS,EAAE,MAAM,EAAE,GACrB,MAAM,GAAG,SAAS,CAMpB"}

package/dist/types/hosting/index.d.ts

@@ -33,9 +33,12 @@
  *     another. Two paths and five body shapes are all a second HTTP adapter
  *     re-decides.
  *   • `memorySessions()` — conversations in a Map, for tests and local dev.
- *   • `standingAgent({ agent, sessions, host })` — the composer.
+ *   • `standingAgent({ agent, sessions, host, durability? })` — the composer.
  *   • `toEnvelope` / `readEnvelope` — pack a conversation, and refuse by name to
  *     unpack a format this runtime does not know.
+ *   • `toPausedEnvelope` / `readPausedRun` — the same for a run that stopped to
+ *     ask a person something (`'flowchart-v1'`). `checkEnvelope` validates
+ *     either without committing to which half you wanted — what a STORE wants.
  *   • `requireCapability` — feature-detection with teeth.
  *
  * @example  An agent that stays up and remembers
@@ -54,8 +57,8 @@ export type { NodeHost, NodeHostHandle, NodeHostOptions } from './nodeHost.js';
 export { httpHost, headerValue } from './httpHost.js';
 export type { HttpHost, HttpHostHandle, HttpHostOptions, HttpRequestFacts, HttpWire, } from './httpHost.js';
 export { memorySessions } from './memorySessions.js';
-export { toEnvelope, readEnvelope } from './envelope.js';
+export { toEnvelope, toPausedEnvelope, readEnvelope, readPausedRun, checkEnvelope, } from './envelope.js';
 export { standingAgent } from './standingAgent.js';
-export { requireCapability, HostClosedError, ConcurrentRunError, PauseNotCarriedError, } from './errors.js';
-export type { AgentHost, CheckpointEnvelope, ConcurrentInvokePolicy, HostCapability, HostHandle, HostHandler, HostReply, HostRequest, SessionLifecycle, StandingAgentOptions, WakeReason, } from './types.js';
+export { requireCapability, HostClosedError, ConcurrentRunError, PauseNotCarriedError, AwaitingDecisionError, NoPendingAskError, } from './errors.js';
+export type { AgentHost, CheckpointEnvelope, ConcurrentInvokePolicy, ConversationEnvelope, DurabilityMode, HostCapability, HostHandle, HostHandler, HostReply, HostRequest, PausedRun, PausedRunEnvelope, PendingAsk, SessionLifecycle, StandingAgentOptions, WakeReason, } from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/hosting/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hosting/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,YAAY,EAAE,QAAQ,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAE/E,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACtD,YAAY,EACV,QAAQ,EACR,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,QAAQ,GACT,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,aAAa,CAAC;AAErB,YAAY,EACV,SAAS,EACT,kBAAkB,EAClB,sBAAsB,EACtB,cAAc,EACd,UAAU,EACV,WAAW,EACX,SAAS,EACT,WAAW,EACX,gBAAgB,EAChB,oBAAoB,EACpB,UAAU,GACX,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/hosting/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AAEH,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACnD,YAAY,EAAE,QAAQ,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAE/E,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACtD,YAAY,EACV,QAAQ,EACR,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,QAAQ,GACT,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EACL,UAAU,EACV,gBAAgB,EAChB,YAAY,EACZ,aAAa,EACb,aAAa,GACd,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD,OAAO,EACL,iBAAiB,EACjB,eAAe,EACf,kBAAkB,EAClB,oBAAoB,EACpB,qBAAqB,EACrB,iBAAiB,GAClB,MAAM,aAAa,CAAC;AAErB,YAAY,EACV,SAAS,EACT,kBAAkB,EAClB,sBAAsB,EACtB,oBAAoB,EACpB,cAAc,EACd,cAAc,EACd,UAAU,EACV,WAAW,EACX,SAAS,EACT,WAAW,EACX,SAAS,EACT,iBAAiB,EACjB,UAAU,EACV,gBAAgB,EAChB,oBAAoB,EACpB,UAAU,GACX,MAAM,YAAY,CAAC"}

package/dist/types/hosting/nodeHost.d.ts

@@ -7,8 +7,10 @@
  *     reply.complete(await answer(request.input));
  *   });
  *
- * Two routes: `POST /invoke` takes `{ input, sessionId? }` and answers
- * `{ output }`; `GET /health` answers `{ status: 'ok' }`. Both paths are
+ * Two routes: `POST /invoke` takes `{ input, sessionId?, decision? }` and
+ * answers `{ output }` — or `{ awaiting }` with a **202** when the run stopped
+ * to ask a person something, which a later `POST` carrying `decision` continues;
+ * `GET /health` answers `{ status: 'ok' }`. Both paths are
  * options, because the paths are the part most likely to be dictated to you by
  * whatever is in front of the process — a load balancer, a container contract,
  * a colleague's convention. A path is a deployment detail, so it is a knob

package/dist/types/hosting/nodeHost.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nodeHost.d.ts","sourceRoot":"","sources":["../../../src/hosting/nodeHost.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAAY,KAAK,QAAQ,EAAE,KAAK,cAAc,EAAE,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE5F,oCAAoC;AACpC,MAAM,WAAW,eAAe;IAC9B,oEAAoE;IACpE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,sDAAsD;IACtD,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,6DAA6D;IAC7D,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,cAAc,CAAC;AAE5C,qDAAqD;AACrD,MAAM,MAAM,QAAQ,GAAG,QAAQ,CAAC;AAIhC;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,EAAE,QAatB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,OAAO,GAAE,eAAoB,GAAG,QAAQ,CAWhE"}
+{"version":3,"file":"nodeHost.d.ts","sourceRoot":"","sources":["../../../src/hosting/nodeHost.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EAAY,KAAK,QAAQ,EAAE,KAAK,cAAc,EAAE,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE5F,oCAAoC;AACpC,MAAM,WAAW,eAAe;IAC9B,oEAAoE;IACpE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,sDAAsD;IACtD,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,6DAA6D;IAC7D,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,cAAc,CAAC;AAE5C,qDAAqD;AACrD,MAAM,MAAM,QAAQ,GAAG,QAAQ,CAAC;AAIhC;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,EAAE,QAsBtB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,OAAO,GAAE,eAAoB,GAAG,QAAQ,CAWhE"}

package/dist/types/hosting/standingAgent.d.ts

@@ -5,17 +5,26 @@
  *     agent,
  *     sessions: memorySessions(),
  *     host: nodeHost({ port: 8080 }),
+ *     durability: 'sync',          // optional; 'exit' is the default
  *   });
  *
  * One request at a time it does four things: wake and hydrate the session,
- * resume that conversation or start a fresh one, persist what the run leaves
+ * continue that session or start a fresh one, persist what the run leaves
  * behind, then reply. Everything else is somebody else's job — the host carries
  * bytes, the store keeps them, the agent thinks.
  *
- * ── Resuming is a REPLAY, and that has a cost you must know about ────────────
- * A stored conversation is restored through `agent.resumeOnError(...)`, and
- * this is its caveat, stated here in the words the Agent states it in, because
- * a composition that hides the caveat of the thing it composes is worse than no
+ * ── A run has three ends, and this composer honours all three ────────────────
+ * It answered, it asked a person something, or it failed. An answer completes
+ * the reply and stores a conversation. A QUESTION stores the paused run as
+ * `'flowchart-v1'` and leaves through `reply.awaiting(...)` — its own terminal,
+ * never `fail`, because a pause is unfinished work and reporting it as a failure
+ * tells every dashboard downstream something untrue. A later request for that
+ * session carrying `decision` continues the run from exactly where it stopped.
+ *
+ * ── Resuming a CONVERSATION is a REPLAY, and that has a cost ─────────────────
+ * A stored conversation is restored through `agent.resumeOnError(...)`, and this
+ * is its caveat, stated here in the words the Agent states it in, because a
+ * composition that hides the caveat of the thing it composes is worse than no
  * composition at all:
  *
  *   > **Tool re-execution / idempotency**: tool side effects from the FAILED
@@ -25,6 +34,10 @@
  *   > emails, DB writes) must be idempotent — key on stable call content, not
  *   > `ctx.toolCallId` (a re-issued call gets a new id).
  *
+ * `durability` is the dial that bounds how much of that a crash can cost you.
+ * Resuming a PAUSED run is different in kind: it is not a replay at all — the
+ * engine continues from its own checkpoint, and no earlier tool call re-runs.
+ *
  * ── Why one run at a time ───────────────────────────────────────────────────
  * An Agent instance holds per-run state on itself, and this composer shares ONE
  * instance across every session. Two runs overlapping on it do not crash —
@@ -47,8 +60,9 @@ import type { HostHandle, StandingAgentOptions } from './types.js';
  * Serve one agent, with per-session conversation memory, on any
  * {@link AgentHost}.
  *
- * Resolves once the host is live. Closing the returned handle closes the host
- * and detaches the listeners this composer added to the agent.
+ * Resolves once the host is live. Closing the returned handle closes the host,
+ * detaches the listeners this composer added to the agent, and removes its
+ * durability wiring.
  *
  * @example
  *   const handle = await standingAgent({
@@ -56,6 +70,7 @@ import type { HostHandle, StandingAgentOptions } from './types.js';
  *     sessions: memorySessions(),
  *     host: nodeHost({ port: 0 }),
  *     onConcurrentInvoke: 'enqueue',
+ *     durability: 'sync',
  *   });
  *   process.on('SIGTERM', () => void handle.close());
  */

package/dist/types/hosting/standingAgent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"standingAgent.d.ts","sourceRoot":"","sources":["../../../src/hosting/standingAgent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AAMH,OAAO,KAAK,EACV,UAAU,EAGV,oBAAoB,EAErB,MAAM,YAAY,CAAC;AAGpB;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,aAAa,CAAC,EAAE,SAAS,UAAU,EACvD,OAAO,EAAE,oBAAoB,CAAC,EAAE,CAAC,GAChC,OAAO,CAAC,EAAE,CAAC,CAuHb"}
+{"version":3,"file":"standingAgent.d.ts","sourceRoot":"","sources":["../../../src/hosting/standingAgent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AAYH,OAAO,KAAK,EACV,UAAU,EAKV,oBAAoB,EAErB,MAAM,YAAY,CAAC;AAGpB;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,aAAa,CAAC,EAAE,SAAS,UAAU,EACvD,OAAO,EAAE,oBAAoB,CAAC,EAAE,CAAC,GAChC,OAAO,CAAC,EAAE,CAAC,CAuNb"}