@warlock.js/ai 4.2.11 → 4.4.0

package/esm/contracts/middleware/middleware.contract.d.mts

@@ -1,8 +1,9 @@
 import { AIError } from "../../errors/ai-error.mjs";
 import { AgentResult } from "../result/agent-result.type.mjs";
+import { SupervisorResult } from "../result/supervisor-result.type.mjs";
 import { ToolInvokeResult } from "../../tool/tool.mjs";
-import { MiddlewareExecuteContext, MiddlewareToolContext, MiddlewareTripContext } from "./middleware-context.type.mjs";
 import { ModelResponse } from "../model.contract.mjs";
+import { MiddlewareExecuteContext, MiddlewareSupervisorContext, MiddlewareToolContext, MiddlewareTripContext } from "./middleware-context.type.mjs";
 
 //#region ../@warlock.js/ai/src/contracts/middleware/middleware.contract.d.ts
 /**
@@ -59,6 +60,38 @@ type AgentMiddlewareToolHooks = {
   after?(ctx: MiddlewareToolContext, result: ToolInvokeResult<unknown>): void | ToolInvokeResult<unknown> | Promise<void | ToolInvokeResult<unknown>>;
   onError?(ctx: MiddlewareToolContext, error: AIError): void | ToolInvokeResult<unknown> | Promise<void | ToolInvokeResult<unknown>>;
 };
+/**
+ * `supervisor`-level hook map. Wraps the entire `supervisor.execute()`
+ * / `.stream()` / `.resume()` run — the supervisor-level peer of
+ * `AgentMiddlewareExecuteHooks`. Fires once per run, around the whole
+ * iteration loop and final result assembly.
+ *
+ * - `before` — fires once at the start of the run, before the first
+ *   routing decision. Throw to abort the whole supervisor run before
+ *   any iteration executes (cross-run budget pre-check, hard deny on
+ *   a ctx flag). Return a `SupervisorResult` to short-circuit the run
+ *   entirely with that result (run-level cache hit, fixture replay).
+ * - `after`  — fires once at the end of a successful run with the
+ *   final `SupervisorResult`. Optional return value replaces the
+ *   result. Does not fire when the run threw before producing a
+ *   result — use `onError` for that path. (A run that completed with
+ *   `result.error` populated is still a "successful" return here, the
+ *   same as agent-level `execute.after`.)
+ * - `onError`— fires once when the run threw before a result could be
+ *   assembled. Optional `SupervisorResult` return recovers: the engine
+ *   treats it as the real outcome and clears the error. `void` /
+ *   omitted rethrow.
+ *
+ * **Type independence.** Like every other level, supervisor hooks are
+ * never generic over the supervisor's `TOutput` — a budget or audit
+ * middleware must be reusable across every supervisor in the app, so
+ * hooks see `SupervisorResult<unknown>`.
+ */
+type AgentMiddlewareSupervisorHooks = {
+  before?(ctx: MiddlewareSupervisorContext): void | SupervisorResult<unknown> | Promise<void | SupervisorResult<unknown>>;
+  after?(ctx: MiddlewareSupervisorContext, result: SupervisorResult<unknown>): void | SupervisorResult<unknown> | Promise<void | SupervisorResult<unknown>>;
+  onError?(ctx: MiddlewareSupervisorContext, error: AIError): void | SupervisorResult<unknown> | Promise<void | SupervisorResult<unknown>>;
+};
 /**
  * Agent-level middleware — a composable interceptor that wraps agent
  * execution at one or more of three granularities: the whole
@@ -134,7 +167,18 @@ type AgentMiddleware = {
   execute?: AgentMiddlewareExecuteHooks;
   trip?: AgentMiddlewareTripHooks;
   tool?: AgentMiddlewareToolHooks;
+  /**
+   * Optional `supervisor`-level hook map — wraps an entire
+   * `supervisor.execute()` run, the supervisor-level peer of
+   * `execute`. Only fires when the middleware is registered on a
+   * supervisor (`ai.supervisor({ middleware: [...] })`); it is inert on
+   * a plain agent, exactly as `execute` / `trip` / `tool` are inert on
+   * a supervisor that never reaches the agent pipeline. A single
+   * middleware object may declare both `execute` and `supervisor` to
+   * cover both authoring surfaces.
+   */
+  supervisor?: AgentMiddlewareSupervisorHooks;
 };
 //#endregion
-export { AgentMiddleware, AgentMiddlewareExecuteHooks, AgentMiddlewareToolHooks, AgentMiddlewareTripHooks };
+export { AgentMiddleware, AgentMiddlewareExecuteHooks, AgentMiddlewareSupervisorHooks, AgentMiddlewareToolHooks, AgentMiddlewareTripHooks };
 //# sourceMappingURL=middleware.contract.d.mts.map

package/esm/contracts/middleware/middleware.contract.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.contract.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/contracts/middleware/middleware.contract.ts"],"mappings":";;;;;;;;;;AAuBA;;;;;;;;;;KAAY,2BAAA;EACV,MAAA,EAAQ,GAAA,EAAK,wBAAA,UAAkC,OAAA;EAC/C,KAAA,EACE,GAAA,EAAK,wBAAA,EACL,MAAA,EAAQ,WAAA,mBACA,WAAA,YAAuB,OAAA,QAAe,WAAA;EAChD,OAAA,EACE,GAAA,EAAK,wBAAA,EACL,KAAA,EAAO,OAAA,UACC,WAAA,YAAuB,OAAA,QAAe,WAAA;AAAA;;;;;;;;;;;;;;KAgBtC,wBAAA;EACV,MAAA,EACE,GAAA,EAAK,qBAAA,UACG,aAAA,GAAgB,OAAA,QAAe,aAAA;EACzC,KAAA,EACE,GAAA,EAAK,qBAAA,EACL,QAAA,EAAU,aAAA,UACF,aAAA,GAAgB,OAAA,QAAe,aAAA;EACzC,OAAA,EACE,GAAA,EAAK,qBAAA,EACL,KAAA,EAAO,OAAA,UACC,aAAA,GAAgB,OAAA,QAAe,aAAA;AAAA;;;;;;AA3BkB;AAgB7D;;;;;;;KA2BY,wBAAA;EACV,MAAA,EACE,GAAA,EAAK,qBAAA,UAGH,gBAAA,YACA,OAAA,QAAe,gBAAA;EACnB,KAAA,EACE,GAAA,EAAK,qBAAA,EACL,MAAA,EAAQ,gBAAA,mBAGN,gBAAA,YACA,OAAA,QAAe,gBAAA;EACnB,OAAA,EACE,GAAA,EAAK,qBAAA,EACL,KAAA,EAAO,OAAA,UAGL,gBAAA,YACA,OAAA,QAAe,gBAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AApCmC;AAgBxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAkFY,eAAA;EAzER;;;;;EA+EF,IAAA;EAzEE;;;;;EA+EF,GAAA;EACA,OAAA,GAAU,2BAAA;EACV,IAAA,GAAO,wBAAA;EACP,IAAA,GAAO,wBAAA;AAAA"}
+{"version":3,"file":"middleware.contract.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/contracts/middleware/middleware.contract.ts"],"mappings":";;;;;;;;;;;AAyBA;;;;;;;;;;KAAY,2BAAA;EACV,MAAA,EAAQ,GAAA,EAAK,wBAAA,UAAkC,OAAA;EAC/C,KAAA,EACE,GAAA,EAAK,wBAAA,EACL,MAAA,EAAQ,WAAA,mBACA,WAAA,YAAuB,OAAA,QAAe,WAAA;EAChD,OAAA,EACE,GAAA,EAAK,wBAAA,EACL,KAAA,EAAO,OAAA,UACC,WAAA,YAAuB,OAAA,QAAe,WAAA;AAAA;;;;;;;;;;;;;;KAgBtC,wBAAA;EACV,MAAA,EACE,GAAA,EAAK,qBAAA,UACG,aAAA,GAAgB,OAAA,QAAe,aAAA;EACzC,KAAA,EACE,GAAA,EAAK,qBAAA,EACL,QAAA,EAAU,aAAA,UACF,aAAA,GAAgB,OAAA,QAAe,aAAA;EACzC,OAAA,EACE,GAAA,EAAK,qBAAA,EACL,KAAA,EAAO,OAAA,UACC,aAAA,GAAgB,OAAA,QAAe,aAAA;AAAA;;;;;;AA3BkB;AAgB7D;;;;;;;KA2BY,wBAAA;EACV,MAAA,EACE,GAAA,EAAK,qBAAA,UAGH,gBAAA,YACA,OAAA,QAAe,gBAAA;EACnB,KAAA,EACE,GAAA,EAAK,qBAAA,EACL,MAAA,EAAQ,gBAAA,mBAGN,gBAAA,YACA,OAAA,QAAe,gBAAA;EACnB,OAAA,EACE,GAAA,EAAK,qBAAA,EACL,KAAA,EAAO,OAAA,UAGL,gBAAA,YACA,OAAA,QAAe,gBAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8BT,8BAAA;EACV,MAAA,EACE,GAAA,EAAK,2BAAA,UACG,gBAAA,YAA4B,OAAA,QAAe,gBAAA;EACrD,KAAA,EACE,GAAA,EAAK,2BAAA,EACL,MAAA,EAAQ,gBAAA,mBACA,gBAAA,YAA4B,OAAA,QAAe,gBAAA;EACrD,OAAA,EACE,GAAA,EAAK,2BAAA,EACL,KAAA,EAAO,OAAA,UACC,gBAAA,YAA4B,OAAA,QAAe,gBAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAzClB;AA8BrC;;;;;;;;;;;;;;;;;KAyEY,eAAA;EA9DmC;;;;;EAoE7C,IAAA;EA5EqD;;;;;EAkFrD,GAAA;EACA,OAAA,GAAU,2BAAA;EACV,IAAA,GAAO,wBAAA;EACP,IAAA,GAAO,wBAAA;EAhFP;;;;;;;;;AAGqE;EAwFrE,UAAA,GAAa,8BAAA;AAAA"}

package/esm/contracts/model.contract.d.mts

@@ -39,9 +39,43 @@ type ModelCallOptions = {
    * `signal.aborted` flips. Adapters without support may ignore it;
    * the agent still honors the signal at trip boundaries regardless.
    */
-  signal?: AbortSignal; /** Additional provider-specific options */
+  signal?: AbortSignal;
+  /**
+   * Reasoning / thinking-effort control for reasoning-capable models.
+   * `effort` maps to OpenAI `reasoning_effort`; `maxTokens` caps the
+   * Anthropic extended-thinking budget. Adapters whose
+   * `capabilities.reasoning` is absent/false ignore this rather than
+   * forwarding unsupported params. Absent = provider default.
+   *
+   * @example
+   * await model.complete(messages, { reasoning: { effort: "high" } });
+   */
+  reasoning?: {
+    effort?: ReasoningEffort;
+    maxTokens?: number;
+  };
+  /**
+   * Vendor-neutral prompt-cache WRITE breakpoint hint. Adapters with
+   * `capabilities.promptCaching` translate `breakpoints` into provider
+   * cache markers (Anthropic `cache_control`); others ignore it.
+   * Read-side accounting (`Usage.cachedTokens`) works without this — it
+   * only controls WRITE placement. Absent = provider default (no
+   * explicit breakpoints).
+   *
+   * @example
+   * await model.complete(messages, { cacheControl: { breakpoints: 1 } });
+   */
+  cacheControl?: {
+    breakpoints?: number;
+  }; /** Additional provider-specific options */
   [key: string]: unknown;
 };
+/**
+ * Reasoning/thinking-effort levels for reasoning-capable models. Maps to
+ * the provider-native control (OpenAI `reasoning_effort`); adapters
+ * without reasoning support ignore it.
+ */
+type ReasoningEffort = "low" | "medium" | "high";
 /**
  * Declarative feature flags a `ModelContract` may expose so the agent can
  * short-circuit redundant work when the provider already enforces a
@@ -68,6 +102,33 @@ type ModelCapabilities = {
    * dropping them at the wire layer.
    */
   vision?: boolean;
+  /**
+   * True when the adapter exposes provider reasoning / extended-thinking
+   * and forwards `ModelCallOptions.reasoning`. When false/absent the
+   * agent ignores reasoning options rather than sending unsupported
+   * params to the provider.
+   */
+  reasoning?: boolean;
+  /**
+   * True when the adapter honors `ModelCallOptions.cacheControl` write
+   * breakpoints and reports `Usage.cachedTokens` / `Usage.cacheWriteTokens`.
+   * When false/absent the agent skips emitting cache breakpoints.
+   */
+  promptCaching?: boolean;
+  /**
+   * True when the adapter accepts audio `ContentPart` input. When
+   * false/absent and the caller passes audio attachments, the agent
+   * throws upfront rather than dropping them at the wire layer (mirrors
+   * `vision`).
+   */
+  audio?: boolean;
+  /**
+   * True when the adapter accepts PDF / document `ContentPart` input.
+   * When false/absent and the caller passes PDF attachments, the agent
+   * throws upfront rather than dropping them at the wire layer (mirrors
+   * `vision`).
+   */
+  pdf?: boolean;
 };
 /**
  * Full response from a non-streaming model call.
@@ -160,5 +221,5 @@ interface ModelContract {
   stream(messages: Message[], options?: ModelCallOptions): AsyncIterable<ModelStreamChunk>;
 }
 //#endregion
-export { ModelCallOptions, ModelCapabilities, ModelContract, ModelResponse, ModelStreamChunk };
+export { ModelCallOptions, ModelCapabilities, ModelContract, ModelResponse, ModelStreamChunk, ReasoningEffort };
 //# sourceMappingURL=model.contract.d.mts.map

package/esm/contracts/model.contract.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"model.contract.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/contracts/model.contract.ts"],"mappings":";;;;;;;;;;AAqBA;;;;;;;;;;;;KAAY,gBAAA;EACV,WAAA;EACA,SAAA,WAkBS;EAhBT,KAAA,GAAQ,UAAA;EAkBI;AAAA;AAad;;;;AAeQ;AAaR;EAlDE,cAAA,GAAiB,MAAA;;;;;;;EAOjB,MAAA,GAAS,WAAA,EA6CT;EAAA,CA3CC,GAAA;AAAA;;;;;AA8C+B;AAYlC;;;;;KA7CY,iBAAA;EA4DgD;;;;;;EArD1D,gBAAA;EA4CI;;;;;;;EApCJ,MAAM;AAAA;AA6CoD;AAgB5D;;;;;;;;;AAhB4D,KAhChD,aAAA;EACV,OAAA;EACA,YAAA,EAAc,YAAA;EACd,KAAA,EAAO,KAAA,EA6E+D;EA3EtE,SAAA,GAAY,oBAAA;AAAA;;;;;;;;;;KAYF,gBAAA;EACN,IAAA;EAAe,OAAA;AAAA;EAEf,IAAA;EACA,EAAA;EACA,IAAA;EACA,KAAA;EAyDqD;;;AAA8B;;;EAlDnF,gBAAA,GAAmB,MAAA;AAAA;EAEnB,IAAA;EAAc,YAAA,EAAc,YAAA;EAAc,KAAA,EAAO,KAAA;AAAA;;;;;;;;;;;;;;;UAgBtC,aAAA;;WAEN,IAAA;;WAEA,QAAA;;;;;;WAMA,YAAA,GAAe,iBAAA;;;;;;;;;;;WAYf,OAAA,GAAU,YAAA;;;;EAKnB,QAAA,CAAS,QAAA,EAAU,OAAA,IAAW,OAAA,GAAU,gBAAA,GAAmB,OAAA,CAAQ,aAAA;;;;EAKnE,MAAA,CAAO,QAAA,EAAU,OAAA,IAAW,OAAA,GAAU,gBAAA,GAAmB,aAAA,CAAc,gBAAA;AAAA"}
+{"version":3,"file":"model.contract.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/contracts/model.contract.ts"],"mappings":";;;;;;;;;;AAqBA;;;;;;;;;;;;KAAY,gBAAA;EACV,WAAA;EACA,SAAA,WAkBA;EAhBA,KAAA,GAAQ,UAAA;EA2BR;;;;;;;;EAlBA,cAAA,GAAiB,MAAA;EA6CP;;;;AAAe;AAY3B;EAlDE,MAAA,GAAS,WAAA;;;;;;;;;;AA4FN;EAjFH,SAAA;IACE,MAAA,GAAS,eAAA;IACT,SAAA;EAAA;EA+FK;;;;;;;;;;;EAlFP,YAAA;IACE,WAAA;EAAA,GA+FwB;EAAA,CA5FzB,GAAA;AAAA;;;;;;KAQS,eAAA;;;;;;;;;;;KAYA,iBAAA;EAuFgD;AAAA;AAgB5D;;;;EAhGE,gBAAA;EA2HmB;;;;;;;EAnHnB,MAAA;EAwHsE;;;;;;EAjHtE,SAAA;EAuGmB;;;;;EAjGnB,aAAA;EAsG2D;;;;;;EA/F3D,KAAA;EAoGyD;;;AAA8B;;;EA7FvF,GAAA;AAAA;;;;;;;;;;;KAaU,aAAA;EACV,OAAA;EACA,YAAA,EAAc,YAAA;EACd,KAAA,EAAO,KAAA;EAEP,SAAA,GAAY,oBAAA;AAAA;;;;;;;;;;KAYF,gBAAA;EACN,IAAA;EAAe,OAAA;AAAA;EAEf,IAAA;EACA,EAAA;EACA,IAAA;EACA,KAAA;;;;;;;EAOA,gBAAA,GAAmB,MAAA;AAAA;EAEnB,IAAA;EAAc,YAAA,EAAc,YAAA;EAAc,KAAA,EAAO,KAAA;AAAA;;;;;;;;;;;;;;;UAgBtC,aAAA;;WAEN,IAAA;;WAEA,QAAA;;;;;;WAMA,YAAA,GAAe,iBAAA;;;;;;;;;;;WAYf,OAAA,GAAU,YAAA;;;;EAKnB,QAAA,CAAS,QAAA,EAAU,OAAA,IAAW,OAAA,GAAU,gBAAA,GAAmB,OAAA,CAAQ,aAAA;;;;EAKnE,MAAA,CAAO,QAAA,EAAU,OAAA,IAAW,OAAA,GAAU,gBAAA,GAAmB,aAAA,CAAc,gBAAA;AAAA"}

package/esm/contracts/orchestrator/checkpoint-store.contract.d.mts

@@ -0,0 +1,91 @@
+//#region ../@warlock.js/ai/src/contracts/orchestrator/checkpoint-store.contract.d.ts
+/**
+ * A single persisted orchestrator session checkpoint. One row is
+ * written per settled turn — the primary key is
+ * `(orchestrator_name, session_id, turn_index)`, append-only from v1
+ * (orchestrator.md §8.2 / §8.6). The latest row (highest
+ * `turn_index`) is the live session state.
+ *
+ * All fields are JSON-serializable. `state` is `unknown` because its
+ * shape is the orchestrator's `TState`, validated upstream — the store
+ * only round-trips it.
+ *
+ * Naming follows the on-disk DDL columns verbatim (snake_case) so the
+ * record maps 1:1 onto the reference table in orchestrator.md §8.6 and
+ * the pg driver can read/write it without a field-rename layer.
+ */
+type CheckpointRecord = {
+  /** Orchestrator definition name — first PK segment, partitions sessions across orchestrators. */orchestrator_name: string; /** Caller-owned session identifier — second PK segment. */
+  session_id: string; /** Monotonic turn counter — third PK segment; the row with the highest value is live. */
+  turn_index: number; /** Post-merge session accumulator. JSON-serializable; shape is the orchestrator's `TState`. */
+  state: unknown; /** Summary of the turn's dispatch decision — a single intent, a fan-out list, or `null` on a turn that routed nowhere. */
+  last_route: string | string[] | null; /** Structural fingerprint of the orchestrator definition at write time; compared on load for drift detection. */
+  signature: string; /** Informational `config.version` tag, or `null` when unset. Metadata only — never drives behavior. */
+  version: string | null; /** Exclusive turn index through which compaction has been applied, or `null` when no compaction has landed. */
+  summarized_through: number | null; /** ISO timestamp when a compaction lock was taken, or `null` when no lock is held. */
+  lock_acquired_at: string | null; /** ISO timestamp when the compaction lock expires, or `null` when no lock is held. */
+  lock_expires_at: string | null; /** ISO timestamp written server-side when the row was persisted. */
+  saved_at: string;
+};
+/**
+ * Durable store for orchestrator session state (orchestrator.md §8.2).
+ *
+ * Owns the checkpoint rows that let `ai.orchestrator()` rehydrate a
+ * session across calls: `state`, `turn_index`, drift `signature`,
+ * `version`, `last_route`, compaction progress, and lock metadata.
+ * Distinct from {@link import("./snapshot-store.contract").SnapshotStore},
+ * which persists the per-turn internal supervisor run for
+ * `iterate: true` mid-turn resume.
+ *
+ * Implementations: `ai.checkpoint.{memory,pg,redis}()`. The memory
+ * impl ships in v1; pg/redis follow. Schema is never auto-migrated —
+ * {@link CheckpointStore.schema} returns a DDL string the dev runs
+ * through their own migration tool (§8.5).
+ */
+interface CheckpointStore {
+  /**
+   * Load the latest checkpoint (highest `turn_index`) for a session,
+   * or `undefined` for a brand-new session the store has never seen.
+   */
+  load(orchestratorName: string, sessionId: string): Promise<CheckpointRecord | undefined>;
+  /**
+   * Persist a fresh checkpoint row. Append-only — never overwrites a
+   * prior `turn_index`. The key is derived from
+   * `(orchestrator_name, session_id, turn_index)` on the record.
+   */
+  save(record: CheckpointRecord): Promise<void>;
+  /**
+   * Delete every checkpoint row for a session, ending it.
+   */
+  delete(orchestratorName: string, sessionId: string): Promise<void>;
+  /**
+   * List the session ids known for an orchestrator, optionally
+   * filtered by a session-id prefix. Used by the production boot-drain
+   * loop (§9.3). Optional — stores that can't enumerate omit it.
+   */
+  list?(orchestratorName: string, prefix?: string): Promise<string[]>;
+  /**
+   * Drop every row for a session whose `turn_index` is strictly below
+   * `keepBeforeTurnIndex`, honoring `keepSnapshots` retention (§4 Phase
+   * 6, Q20). Called after each settled turn's save. Optional — stores
+   * that prune in their own dialect (or never prune) omit it; the engine
+   * skips pruning when it is absent.
+   */
+  prune?(orchestratorName: string, sessionId: string, keepBeforeTurnIndex: number): Promise<void>;
+  /**
+   * Return the DDL string for this store's backing table. The dev runs
+   * it through their migration tool; the framework never auto-migrates
+   * (§8.5).
+   */
+  schema(): string;
+  /**
+   * Optional idle-TTL knob. Stores that support row expiry honor it;
+   * others may no-op.
+   */
+  setOptions?(options: {
+    ttl?: number;
+  }): void;
+}
+//#endregion
+export { CheckpointRecord, CheckpointStore };
+//# sourceMappingURL=checkpoint-store.contract.d.mts.map

package/esm/contracts/orchestrator/checkpoint-store.contract.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint-store.contract.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/contracts/orchestrator/checkpoint-store.contract.ts"],"mappings":";;AAeA;;;;;;;;;;;;;;KAAY,gBAAA;EAsBF,iGApBR,iBAAA,UAsCe;EApCf,UAAA;EAEA,UAAA,UA0CG;EAxCH,KAAA,WA+CgC;EA7ChC,UAAA,4BAyDkD;EAvDlD,SAAA,UAoEU;EAlEV,OAAA,iBA+BA;EA7BA,kBAAA,iBA+BE;EA7BF,gBAAA,iBA8BW;EA5BX,eAAA,iBAmCa;EAjCb,QAAA;AAAA;;;;;;;;;;;;;;;;UAkBe,eAAA;EAqDH;;AAAyB;;EAhDrC,IAAA,CACE,gBAAA,UACA,SAAA,WACC,OAAA,CAAQ,gBAAA;;;;;;EAOX,IAAA,CAAK,MAAA,EAAQ,gBAAA,GAAmB,OAAA;;;;EAKhC,MAAA,CAAO,gBAAA,UAA0B,SAAA,WAAoB,OAAA;;;;;;EAOrD,IAAA,EAAM,gBAAA,UAA0B,MAAA,YAAkB,OAAA;;;;;;;;EASlD,KAAA,EACE,gBAAA,UACA,SAAA,UACA,mBAAA,WACC,OAAA;;;;;;EAOH,MAAA;;;;;EAMA,UAAA,EAAY,OAAA;IAAW,GAAA;EAAA;AAAA"}

package/esm/contracts/orchestrator/index.d.mts

@@ -0,0 +1,8 @@
+import { PgClientLike, RedisClientLike, SnapshotStore } from "./snapshot-store.contract.mjs";
+import { CheckpointRecord, CheckpointStore } from "./checkpoint-store.contract.mjs";
+import { OrchestratorCommands } from "./orchestrator-commands.type.mjs";
+import { OrchestratorEvent, OrchestratorEventHandler, OrchestratorEventHandlers, OrchestratorEventMap, OrchestratorEventName } from "./orchestrator-event.type.mjs";
+import { OrchestratorExecuteOptions, OrchestratorResumeOptions } from "./orchestrator-execute-options.type.mjs";
+import { OrchestratorAsToolOptions, OrchestratorContract, OrchestratorSessionScope, SessionContextOverrides } from "./orchestrator.contract.mjs";
+import { OrchestratorConfig, OrchestratorMemoryConfig, SummarizeCallback, SummarizeConfig } from "./orchestrator-config.type.mjs";
+import { SessionContract } from "./session.contract.mjs";

package/esm/contracts/orchestrator/orchestrator-commands.type.d.mts

@@ -0,0 +1,43 @@
+import { Message } from "../conversation-message.type.mjs";
+
+//#region ../@warlock.js/ai/src/contracts/orchestrator/orchestrator-commands.type.d.ts
+/**
+ * Typed command surface for `orchestrator.command(name, args)` (design
+ * §11). Each key is a command name; its value declares the command's
+ * `args` and `result` shapes so the contract's `command<K>` method is
+ * fully typed against the map.
+ *
+ * v1 ships exactly one built-in command, `compact`. v2 user commands
+ * attach via module augmentation of this type — declaring additional
+ * keys in a consumer's own `.d.ts` widens the map without a framework
+ * release.
+ *
+ * @example
+ * const result = await orchestrator.command("compact", {
+ *   sessionId,
+ *   history,
+ * });
+ * // result: { summary, replacesFromIndex, replacesToIndex }
+ */
+type OrchestratorCommands = {
+  /**
+   * Force a manual compaction of the supplied session history outside
+   * the automatic post-turn trigger. `result` is structurally
+   * identical to `CompactionResult` (kept per the literal §11 shape).
+   */
+  compact: {
+    args: {
+      sessionId: string;
+      history: Message[];
+      signal?: AbortSignal;
+    };
+    result: {
+      summary: Message;
+      replacesFromIndex: number;
+      replacesToIndex: number;
+    };
+  };
+};
+//#endregion
+export { OrchestratorCommands };
+//# sourceMappingURL=orchestrator-commands.type.d.mts.map

package/esm/contracts/orchestrator/orchestrator-commands.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator-commands.type.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/contracts/orchestrator/orchestrator-commands.type.ts"],"mappings":";;;;;AAoBA;;;;;;;;;;;;;;;;KAAY,oBAAA;EASG;;;;AAEM;EALnB,OAAA;IACE,IAAA;MAAQ,SAAA;MAAmB,OAAA,EAAS,OAAA;MAAW,MAAA,GAAS,WAAA;IAAA;IACxD,MAAA;MACE,OAAA,EAAS,OAAA;MACT,iBAAA;MACA,eAAA;IAAA;EAAA;AAAA"}

package/esm/contracts/orchestrator/orchestrator-config.type.d.mts

@@ -0,0 +1,170 @@
+import { Message } from "../conversation-message.type.mjs";
+import { AgentContract } from "../agent/agent.contract.mjs";
+import { SnapshotStore } from "./snapshot-store.contract.mjs";
+import { ModelContract } from "../model.contract.mjs";
+import { SystemPromptContract } from "../system-prompt.contract.mjs";
+import { RouteContext } from "../supervisor/route-context.type.mjs";
+import { SupervisorIntentValue } from "../supervisor/intent-entry.type.mjs";
+import { Next } from "../supervisor/next.type.mjs";
+import { RouterEntry } from "../supervisor/router-entry.type.mjs";
+import { EvaluateContext, EvaluateResult } from "../supervisor/evaluate-context.type.mjs";
+import { CompactionResult } from "../result/orchestrator-result.type.mjs";
+import { MemoryTier } from "../memory/memory-item.type.mjs";
+import { MemoryContract } from "../memory/memory.contract.mjs";
+import { CheckpointStore } from "./checkpoint-store.contract.mjs";
+import { OrchestratorEventHandlers } from "./orchestrator-event.type.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region ../@warlock.js/ai/src/contracts/orchestrator/orchestrator-config.type.d.ts
+/**
+ * Object form of `OrchestratorConfig.summarize` (design §12.4) — the
+ * automatic post-turn compaction policy. Fires after `afterTurns`,
+ * keeps the most recent `keep` messages, and summarizes the rest with
+ * `summarizer`. `onCompact` lets the dev apply the produced summary to
+ * their own message store; `lock` bounds how long a turn waits on the
+ * compaction lock before failing open.
+ */
+type SummarizeConfig = {
+  /** Trigger compaction once the turn count crosses this threshold. */afterTurns?: number; /** Number of most-recent messages to keep verbatim (not summarized). Default 8. */
+  keep?: number; /** Model used to produce the summary. Defaults to the orchestrator's own model. */
+  summarizer?: ModelContract;
+  /**
+   * Applies the produced compaction to the dev's message store. When
+   * supplied the orchestrator does not surface `result.compaction` for
+   * the dev to apply manually.
+   */
+  onCompact?: (compaction: CompactionResult, ctx: {
+    sessionId: string;
+  }) => Promise<void> | void; /** Compaction-lock tuning. `maxWait` caps the per-turn wait in ms. */
+  lock?: {
+    maxWait?: number;
+  };
+};
+/**
+ * Callback form of `OrchestratorConfig.summarize` (design §12.4). Full
+ * control: receives the session history, returns the compaction result
+ * directly. Use when the built-in `SummarizeConfig` policy is too
+ * coarse.
+ */
+type SummarizeCallback = (history: Message[]) => Promise<CompactionResult> | CompactionResult;
+/**
+ * Per-turn memory wiring for `OrchestratorConfig.memory` (memory core
+ * M2). The `store` is the {@link MemoryContract} the orchestrator
+ * recalls from before each dispatch and remembers into after each turn
+ * settles. `recall` tunes the pre-dispatch recall (how many memories,
+ * the similarity floor, an optional single-tier restriction); `remember`
+ * toggles whether the turn outcome is written back. When `recall.k` is 0
+ * the orchestrator skips recall entirely (write-only memory); when
+ * `remember` is `false` it recalls but never writes (read-only memory).
+ *
+ * The recalled memories are injected into the request-scoped `context`
+ * bag under the `injectKey` (default `"memories"`) so every route /
+ * router / evaluate / dispatch callback reads them at
+ * `ctx.context[injectKey]` — memory never mutates the prompt itself, the
+ * surfacing point stays explicit (the same contract `MemoryContract`
+ * documents).
+ */
+type OrchestratorMemoryConfig = {
+  /** The memory store recalled-from before dispatch and remembered-into after. */store: MemoryContract;
+  /**
+   * Pre-dispatch recall tuning. `k` caps the injected count (0 disables
+   * recall — write-only memory); `threshold` raises the semantic
+   * similarity floor; `tier` restricts recall to a single tier. Omit for
+   * the memory's own configured defaults.
+   */
+  recall?: {
+    k?: number;
+    threshold?: number;
+    tier?: MemoryTier;
+  };
+  /**
+   * Write the settled turn outcome back into memory after a clean turn.
+   * Default `true`. Set `false` for a read-only memory that recalls but
+   * never accumulates. Cancelled / failed turns never remember (they
+   * revert — §17), regardless of this flag.
+   */
+  remember?: boolean;
+  /**
+   * Tier the remembered turn outcome lands in. Omit to use the memory's
+   * own `defaultTier`. Pass `"semantic"` to durably accumulate turns for
+   * later cross-session recall.
+   */
+  rememberTier?: MemoryTier;
+  /**
+   * Key the recalled memories are injected under inside the per-turn
+   * `context` bag. Callbacks read them at `ctx.context[injectKey]` as a
+   * `RecalledMemory[]`. Default `"memories"`.
+   */
+  injectKey?: string;
+};
+/**
+ * Factory config for `ai.orchestrator(config)` (design §15.2).
+ *
+ * The "what runs" fields (`intents`, `route` / `router`, `evaluate`,
+ * `state`, `output`, `initialAgent`, `maxIterations`) are the
+ * supervisor's surface spread directly — the orchestrator builds the
+ * supervisor lazily per turn and delegates to it. The remaining fields
+ * are orchestrator-specific: session-scoped history windowing,
+ * compaction, snapshot retention, and the two durable stores.
+ *
+ * `TState` defaults to `TOutput` for the common case where the working
+ * session state IS the output shape. `TIntents` captures the literal
+ * intent map so `ctx.intents.<TAB>` autocompletes against real keys.
+ *
+ * @example
+ * const supportBot = ai.orchestrator<SessionState>({
+ *   name: "refund-support",
+ *   intents: { classify, lookup, process, compose },
+ *   route: (ctx) => (ctx.iteration === 0 ? "classify" : END),
+ *   iterate: true,
+ *   historyWindow: { router: 5, agents: 20 },
+ *   checkpointStore: ai.checkpoint.pg({ client: pg }),
+ *   snapshotStore: ai.snapshot.pg({ client: pg }),
+ * });
+ */
+type OrchestratorConfig<TOutput, TState = TOutput, TIntents extends Record<string, SupervisorIntentValue> = Record<string, SupervisorIntentValue>> = {
+  /** Stable identifier — used in logs, events, checkpoints, signature. */name: string; /** Dev-curated version string. Metadata only (§10.2) — never parsed. */
+  version?: string; /** Prepended to the router agent's system prompt (router mode only). */
+  systemPrompt?: SystemPromptContract | string; /** Dispatchable units keyed by intent name (supervisor surface). */
+  intents: TIntents; /** Deterministic per-turn dispatch. Mutually exclusive with `router`. */
+  route?: (ctx: RouteContext<TState>) => Next | Promise<Next>; /** LLM-driven dispatch. Mutually exclusive with `route`. */
+  router?: AgentContract<unknown> | RouterEntry<TState>; /** Retrospective per-turn verdict callback. */
+  evaluate?: (ctx: EvaluateContext<TState>) => EvaluateResult | Promise<EvaluateResult>; /** Initial seed for the session-state accumulator. */
+  state?: TState; /** Final-state schema; validated before populating `result.data`. */
+  output?: StandardSchemaV1<TOutput>; /** Dispatch this intent on turn 0, skipping the first route/router call. */
+  initialAgent?: string; /** Hard cap on in-turn iterations — only consulted when `iterate: true`. Default 10. */
+  maxIterations?: number;
+  /**
+   * Delegate each turn to a real internal supervisor for in-turn
+   * iteration. Default `false` — single dispatch per turn. Requires
+   * `snapshotStore` (or `ai.config({ defaultSnapshotStore })`) when set.
+   */
+  iterate?: boolean;
+  /**
+   * Per-role history windowing applied to the dev-supplied history
+   * before each turn. A number keeps the last N messages; a callback
+   * takes full control of the slice.
+   */
+  historyWindow?: {
+    router?: number | ((messages: Message[]) => Message[]);
+    agents?: number | ((messages: Message[]) => Message[]);
+  }; /** Automatic post-turn compaction policy (§12). */
+  summarize?: SummarizeConfig | SummarizeCallback; /** Number of turn snapshots to retain per session. Default 100. */
+  keepSnapshots?: number | "all"; /** Durable session-state store. Falls back to `ai.config({ defaultCheckpointStore })`. */
+  checkpointStore?: CheckpointStore; /** Internal-supervisor snapshot store. Required when `iterate: true`. */
+  snapshotStore?: SnapshotStore;
+  /**
+   * Optional per-turn memory (memory core M2). When set, the
+   * orchestrator recalls relevant memories for the turn input and injects
+   * them into the dispatch context (`ctx.context[injectKey]`) before
+   * routing, then remembers the settled turn outcome afterward. Omit for
+   * the existing behavior — orchestrators without memory are unchanged.
+   * Accepts a bare {@link MemoryContract} (recall + remember with
+   * defaults) or an {@link OrchestratorMemoryConfig} for finer control.
+   */
+  memory?: MemoryContract | OrchestratorMemoryConfig; /** Definition-level event handlers — tier 1 of the 3-tier model. */
+  on?: OrchestratorEventHandlers;
+};
+//#endregion
+export { OrchestratorConfig, OrchestratorMemoryConfig, SummarizeCallback, SummarizeConfig };
+//# sourceMappingURL=orchestrator-config.type.d.mts.map

package/esm/contracts/orchestrator/orchestrator-config.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator-config.type.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/contracts/orchestrator/orchestrator-config.type.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;AAyBA;;;;;;KAAY,eAAA;EAeE,qEAbZ,UAAA,WAEA;EAAA,IAAA,WAEa;EAAb,UAAA,GAAa,aAAA;EAOC;;;;;EADd,SAAA,IACE,UAAA,EAAY,gBAAA,EACZ,GAAA;IAAO,SAAA;EAAA,MACJ,OAAA,eAEW;EAAhB,IAAA;IAAS,OAAA;EAAA;AAAA;;;;;;;KASC,iBAAA,IACV,OAAA,EAAS,OAAA,OACN,OAAA,CAAQ,gBAAA,IAAoB,gBAAA;;;;;AAAgB;AAmBjD;;;;;;;;;;;;KAAY,wBAAA;EAYR,gFAVF,KAAA,EAAO,cAAA;EAkBP;;;;;AAYS;EAvBT,MAAA;IACE,CAAA;IACA,SAAA;IACA,IAAA,GAAO,UAAA;EAAA;EAmDQ;;;;;;EA3CjB,QAAA;EA0DuC;;;;;EApDvC,YAAA,GAAe,UAAA;EAyDQ;;;;;EAnDvB,SAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;KA4BU,kBAAA,mBAED,OAAA,mBACQ,MAAA,SAAe,qBAAA,IAAyB,MAAA,SAEvD,qBAAA;EAWF,wEAPA,IAAA,UASA;EAPA,OAAA,WAO2B;EAL3B,YAAA,GAAe,oBAAA,WAKwB;EAFvC,OAAA,EAAS,QAAA,EAE6C;EAAtD,KAAA,IAAS,GAAA,EAAK,YAAA,CAAa,MAAA,MAAY,IAAA,GAAO,OAAA,CAAQ,IAAA,GAE7C;EAAT,MAAA,GAAS,aAAA,YAAyB,WAAA,CAAY,MAAA,GAAA;EAE9C,QAAA,IACE,GAAA,EAAK,eAAA,CAAgB,MAAA,MAClB,cAAA,GAAiB,OAAA,CAAQ,cAAA,GADvB;EAGP,KAAA,GAAQ,MAAA,EAHN;EAKF,MAAA,GAAS,gBAAA,CAAiB,OAAA,GAJJ;EAMtB,YAAA,WAJA;EAMA,aAAA;EAJA;;;;;EAWA,OAAA;EAMA;;;;;EAAA,aAAA;IACE,MAAA,cAAoB,QAAA,EAAU,OAAA,OAAc,OAAA;IAC5C,MAAA,cAAoB,QAAA,EAAU,OAAA,OAAc,OAAA;EAAA,GAG9C;EAAA,SAAA,GAAY,eAAA,GAAkB,iBAAA,EAAA;EAE9B,aAAA,mBAGA;EAAA,eAAA,GAAkB,eAAA,EAElB;EAAA,aAAA,GAAgB,aAAA;EAUhB;;;;;;AAG8B;;;EAH9B,MAAA,GAAS,cAAA,GAAiB,wBAAA;EAG1B,EAAA,GAAK,yBAAA;AAAA"}

package/esm/contracts/orchestrator/orchestrator-event.type.d.mts

@@ -0,0 +1,118 @@
+import { EventIdentity } from "../events/event-identity.type.mjs";
+import { CompactionResult } from "../result/orchestrator-result.type.mjs";
+
+//#region ../@warlock.js/ai/src/contracts/orchestrator/orchestrator-event.type.d.ts
+/**
+ * Per-turn lifecycle event payloads emitted under the `orchestrator.*`
+ * namespace (design §14). Three-tier subscription — definition,
+ * instance, per-call — fires in that order on every emission, mirroring
+ * the supervisor + workflow model.
+ *
+ * Child events (`supervisor.*` / `agent.*`) bubble up UNMODIFIED under
+ * their own identity (§14.2) and are intentionally NOT folded into this
+ * map — subscribers filter the bubbled stream by namespace. This map
+ * carries only the orchestrator's own session-scoped events.
+ *
+ * Until the shared `contracts/events` taxonomy grows an
+ * `orchestrator.*` slice, this local map is the source of truth for the
+ * orchestrator `on`/`off`/`stream` surface; it is structured to be
+ * promoted into `contracts/events/event-map.type.ts` later without a
+ * shape change (Q14 event taxonomy is a v1 design item; see §14).
+ */
+type OrchestratorEventMap = {
+  /** Turn N begins (before phase 1). */"orchestrator.turn.starting": {
+    sessionId: string;
+    turnIndex: number;
+  }; /** Phase 1 — checkpoint loaded (or seeded empty on first call). */
+  "orchestrator.session.loaded": {
+    sessionId: string;
+    turnIndex: number;
+    found: boolean;
+  }; /** Phase 2 — drift signature compared against the loaded checkpoint. */
+  "orchestrator.drift.checked": {
+    sessionId: string;
+    signature: string;
+    drifted: boolean;
+  }; /** Phase 3 — waiting on the compaction lock (only when locked). */
+  "orchestrator.lock.waiting": {
+    sessionId: string;
+    waitedMs: number;
+  }; /** Phase 4 — history windowed for router + agents. */
+  "orchestrator.history.windowed": {
+    sessionId: string;
+    messageCount: number;
+  }; /** Phase 5 — route/router produced a dispatch decision. */
+  "orchestrator.turn.routed": {
+    sessionId: string;
+    turnIndex: number;
+    source: "route" | "router" | "intent.next";
+    raw: unknown;
+  }; /** Per-token streaming during the dispatched primitive's run. */
+  "orchestrator.turn.streaming": {
+    sessionId: string;
+    delta: string;
+  }; /** Phase 6 — checkpoint row written for the settled turn. */
+  "orchestrator.checkpoint.persisted": {
+    sessionId: string;
+    turnIndex: number;
+  }; /** Phase 7 — compaction trigger fired (only when triggered). */
+  "orchestrator.compaction.suggested": {
+    sessionId: string;
+    compaction: CompactionResult;
+  }; /** Phase 7 — `onCompact` ran successfully and the summary applied. */
+  "orchestrator.compaction.applied": {
+    sessionId: string;
+    compaction: CompactionResult;
+  };
+  /**
+   * Phase 7 — the summarizer or `onCompact` threw; compaction was skipped
+   * for this turn and the session keeps running with unchanged history
+   * (§4 Phase 7 skip-and-log). `phase` distinguishes which step failed.
+   */
+  "orchestrator.compaction.failed": {
+    sessionId: string;
+    phase: "summarize" | "onCompact";
+    error: unknown;
+  }; /** Terminal — turn ran to a usable result. */
+  "orchestrator.turn.completed": {
+    sessionId: string;
+    turnIndex: number;
+  }; /** Terminal — turn failed; the typed cause rides on the result. */
+  "orchestrator.turn.failed": {
+    sessionId: string;
+    turnIndex: number;
+  }; /** Terminal — caller aborted the turn via `AbortSignal`. */
+  "orchestrator.turn.cancelled": {
+    sessionId: string;
+    turnIndex: number;
+  }; /** Non-terminal — session paused waiting for the next user turn (§15.6). */
+  "orchestrator.turn.awaiting-input": {
+    sessionId: string;
+    turnIndex: number;
+  };
+};
+/**
+ * Discriminated union of every orchestrator event, each tagged with a
+ * `type` literal and carrying its payload plus run `EventIdentity`.
+ * This is the `TEvent` parameter for `orchestrator.stream()`.
+ */
+type OrchestratorEvent = { [K in keyof OrchestratorEventMap]: {
+  type: K;
+} & OrchestratorEventMap[K] & EventIdentity }[keyof OrchestratorEventMap];
+/** Every legal orchestrator event name. */
+type OrchestratorEventName = keyof OrchestratorEventMap;
+/**
+ * Handler for a single orchestrator event. Receives the event's typed
+ * payload (identity-injected centrally by the orchestrator's `emit`);
+ * return value is ignored.
+ */
+type OrchestratorEventHandler<K extends OrchestratorEventName> = (payload: OrchestratorEventMap[K] & EventIdentity) => void;
+/**
+ * Definition / instance / per-call handler bag — tier surface accepted
+ * by `OrchestratorConfig.on` and the per-call `options.on`. Mirrors
+ * `SupervisorEventHandlers`.
+ */
+type OrchestratorEventHandlers = Partial<{ [K in OrchestratorEventName]: OrchestratorEventHandler<K> }>;
+//#endregion
+export { OrchestratorEvent, OrchestratorEventHandler, OrchestratorEventHandlers, OrchestratorEventMap, OrchestratorEventName };
+//# sourceMappingURL=orchestrator-event.type.d.mts.map

package/esm/contracts/orchestrator/orchestrator-event.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator-event.type.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/contracts/orchestrator/orchestrator-event.type.ts"],"mappings":";;;;;;AAoBA;;;;;;;;;;;;;;;KAAY,oBAAA;EAgBqB,sCAd/B,4BAAA;IAAgC,SAAA;IAAmB,SAAA;EAAA,GAkBnD;EAhBA,6BAAA;IACE,SAAA;IACA,SAAA;IACA,KAAA;EAAA,GAoB+B;EAjBjC,4BAAA;IACE,SAAA;IACA,SAAA;IACA,OAAA;EAAA,GAsBA;EAnBF,2BAAA;IAA+B,SAAA;IAAmB,QAAA;EAAA,GAyBhD;EAvBF,+BAAA;IAAmC,SAAA;IAAmB,YAAA;EAAA,GAiCpD;EA/BF,0BAAA;IACE,SAAA;IACA,SAAA;IACA,MAAA;IACA,GAAA;EAAA,GAkCF;EA/BA,6BAAA;IAAiC,SAAA;IAAmB,KAAA;EAAA,GAmClD;EAjCF,mCAAA;IACE,SAAA;IACA,SAAA;EAAA;EAGF,mCAAA;IACE,SAAA;IACA,UAAA,EAAY,gBAAA;EAAA,GAuCZ;EApCF,iCAAA;IACE,SAAA;IACA,UAAA,EAAY,gBAAgB;EAAA;EA+BlB;;;;;EAxBZ,gCAAA;IACE,SAAA;IACA,KAAA;IACA,KAAA;EAAA,GA4B6B;EAzB/B,6BAAA;IAAiC,SAAA;IAAmB,SAAA;EAAA,GAgClB;EA9BlC,0BAAA;IAA8B,SAAA;IAAmB,SAAA;EAAA,GA+Bd;EA7BnC,6BAAA;IAAiC,SAAA;IAAmB,SAAA;EAAA,GA6B3C;EA3BT,kCAAA;IACE,SAAA;IACA,SAAA;EAAA;AAAA;AAiCJ;;;;;AAAA,KAxBY,iBAAA,iBACE,oBAAA;EACV,IAAA,EAAM,CAAA;AAAA,IACJ,oBAAA,CAAqB,CAAA,IACvB,aAAA,SACI,oBAAA;;KAGI,qBAAA,SAA8B,oBAAoB;;;;AAiBJ;;KAV9C,wBAAA,WAAmC,qBAAA,KAC7C,OAAA,EAAS,oBAAA,CAAqB,CAAA,IAAK,aAAA;;;;;;KAQzB,yBAAA,GAA4B,OAAA,SAChC,qBAAA,GAAwB,wBAAA,CAAyB,CAAA"}