@warlock.js/ai 4.2.11 → 4.4.0

package/esm/orchestrator/dispatch.mjs

@@ -0,0 +1,171 @@
+import { supervisor } from "../supervisor/supervisor.mjs";
+
+//#region ../@warlock.js/ai/src/orchestrator/dispatch.ts
+/**
+* Derive the deterministic supervisor `runId` for an `iterate: true`
+* turn (orchestrator.md §5 Phase 5 / §10.2 / §18.7):
+* `${sessionId}.${version ?? "unversioned"}.${turnIndex}`. No base64,
+* no hashing — the `sessionId` is the dev's responsibility to make
+* unique. Deploying a new `version` cleanly partitions in-flight runs
+* across deploys so old runIds never collide with new ones.
+*/
+function deriveRunId(sessionId, version, turnIndex) {
+	return `${sessionId}.${version ?? "unversioned"}.${turnIndex}`;
+}
+/**
+* Build the internal supervisor config by spreading the orchestrator's
+* supervisor-surface fields (orchestrator.md §1 / §5 Phase 5) and
+* seeding `state` from the session-state seed.
+*
+* `iterate: false` caps `maxIterations` at 1 — a single dispatch per
+* turn ("the supervisor's Phase A + Phase B once, no iteration loop" —
+* §5). `iterate: true` keeps the configured `maxIterations` (default
+* 10) and wires the `snapshotStore` for mid-turn resume.
+*
+* The orchestrator DELEGATES to the existing supervisor — it never
+* reimplements dispatch / route / evaluate / strip-merge logic.
+*/
+function buildSupervisorConfig(ctx, seedState, iterate, snapshotStore) {
+	const config = ctx.config;
+	return {
+		name: config.name,
+		version: config.version,
+		systemPrompt: config.systemPrompt,
+		intents: config.intents,
+		route: config.route,
+		router: config.router,
+		evaluate: config.evaluate,
+		state: seedState,
+		output: config.output,
+		initialAgent: config.initialAgent,
+		maxIterations: iterate ? config.maxIterations : 1,
+		historyWindow: config.historyWindow ? {
+			router: toNumber(config.historyWindow.router),
+			agents: toNumber(config.historyWindow.agents)
+		} : void 0,
+		snapshotStore: iterate ? snapshotStore : void 0
+	};
+}
+/**
+* The supervisor's `historyWindow` tiers accept only numbers; the
+* orchestrator's accept a number OR a slicer callback. The callback
+* form is already applied at the orchestrator level (Phase 4), so any
+* non-number here has already done its slicing — drop it for the
+* supervisor (which sees the pre-sliced history) by returning
+* `undefined`.
+*/
+function toNumber(value) {
+	return typeof value === "number" ? value : void 0;
+}
+/**
+* Build the forensic {@link TurnSnapshot} for the dispatched turn from
+* the supervisor's result. Mirrors the supervisor's `IterationSnapshot`
+* shape (§15.5) so a turn reads uniformly whether one agent ran
+* (`iterate: false`) or the internal supervisor iterated
+* (`iterate: true`). The terminal iteration's branch records and
+* decision are lifted onto the turn; the supervisor's full report tree
+* becomes the turn's `childReport`.
+*/
+function buildTurnSnapshot(input, turnIndex, result, state) {
+	const report = result.report;
+	const snapshots = report.snapshots;
+	const terminal = snapshots.length > 0 ? snapshots[snapshots.length - 1] : void 0;
+	const decisionSource = mapDecisionSource(terminal?.decision.source);
+	return Object.freeze({
+		turn: turnIndex,
+		input,
+		decision: {
+			source: decisionSource,
+			raw: terminal?.decision.next ?? null,
+			reasoning: terminal?.decision.reasoning
+		},
+		result: terminal?.result ?? {},
+		state,
+		evaluate: terminal?.evaluateVerdict,
+		startedAt: report.startedAt,
+		endedAt: report.endedAt,
+		duration: report.duration,
+		usage: report.usage,
+		childReport: report
+	});
+}
+/**
+* Map the supervisor's `DecisionSource` onto the narrower turn-snapshot
+* decision source (§15.5 — `"route" | "router" | "intent.next"`). The
+* supervisor's `initialAgent` / `classifier` first-turn sources collapse
+* to `"intent.next"` (a non-route/router origin) at the orchestrator
+* layer, which only distinguishes the three coarse decision origins.
+*/
+function mapDecisionSource(source) {
+	if (source === "route" || source === "router") return source;
+	return "intent.next";
+}
+/**
+* Phase 5 — dispatch turn (orchestrator.md §3 / §4 Phase 5).
+*
+* Constructs a fresh internal supervisor seeded from the session state,
+* then:
+*
+* - `iterate: false` — runs a single dispatch (`maxIterations: 1`).
+* - `iterate: true` — runs the full supervisor with a deterministic
+*   `runId`, resuming an in-flight run when the `SnapshotStore` already
+*   has one for that `runId` (§5 step 5).
+*
+* The supervisor's final state replaces the session state (§5 — replace
+* semantics). The supervisor is never kept alive across turns
+* (single-call lifecycle invariant — §18.8).
+*/
+async function dispatchTurn(params) {
+	const { ctx, sessionId, input, seedState, turnIndex, history, context, signal } = params;
+	const iterate = ctx.config.iterate === true;
+	const sup = supervisor(buildSupervisorConfig(ctx, seedState, iterate, ctx.snapshotStore));
+	let result;
+	if (iterate) {
+		const runId = deriveRunId(sessionId, ctx.config.version, turnIndex);
+		const inFlight = ctx.snapshotStore ? await ctx.snapshotStore.load(runId) : void 0;
+		if (inFlight && inFlight.status === "running") result = await sup.resume(runId, {
+			context,
+			signal,
+			history,
+			sessionId
+		});
+		else result = await sup.execute(input, {
+			runId,
+			context,
+			signal,
+			history,
+			sessionId
+		});
+	} else result = await sup.execute(input, {
+		context,
+		signal,
+		history,
+		sessionId
+	});
+	const state = deriveFinalState(result, seedState);
+	const turnSnapshot = buildTurnSnapshot(input, turnIndex, result, state);
+	return {
+		result,
+		state,
+		turnSnapshot
+	};
+}
+/**
+* Derive the post-turn session state from the supervisor result.
+* Prefers the terminal iteration's accumulated `state`; falls back to
+* the validated `data` (when an `output` schema reshaped it), then to
+* the seed when the run produced neither (e.g. it terminated before
+* dispatching anything). Replace semantics — the supervisor is the
+* authority on state evolution within its loop (§5).
+*/
+function deriveFinalState(result, seedState) {
+	const snapshots = result.report.snapshots;
+	const terminal = snapshots.length > 0 ? snapshots[snapshots.length - 1] : void 0;
+	if (terminal && terminal.state !== void 0) return terminal.state;
+	if (result.data !== void 0) return result.data;
+	return seedState;
+}
+
+//#endregion
+export { deriveRunId, dispatchTurn };
+//# sourceMappingURL=dispatch.mjs.map

package/esm/orchestrator/dispatch.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatch.mjs","names":["createSupervisor"],"sources":["../../../../../../../@warlock.js/ai/src/orchestrator/dispatch.ts"],"sourcesContent":["import type { Message } from \"../contracts/conversation-message.type\";\nimport type { SnapshotStore } from \"../contracts/orchestrator/snapshot-store.contract\";\nimport type { SupervisorResult } from \"../contracts/result/supervisor-result.type\";\nimport type { TurnSnapshot } from \"../contracts/result/orchestrator-result.type\";\nimport type { SupervisorConfig } from \"../contracts/supervisor/supervisor-config.type\";\nimport type { SupervisorInput } from \"../contracts/supervisor/supervisor-input.type\";\nimport type { SupervisorReport } from \"../contracts/result/supervisor-result.type\";\nimport type { OrchestratorEngineContext } from \"./engine-context.type\";\nimport { supervisor as createSupervisor } from \"../supervisor/supervisor\";\n\n/**\n * Derive the deterministic supervisor `runId` for an `iterate: true`\n * turn (orchestrator.md §5 Phase 5 / §10.2 / §18.7):\n * `${sessionId}.${version ?? \"unversioned\"}.${turnIndex}`. No base64,\n * no hashing — the `sessionId` is the dev's responsibility to make\n * unique. Deploying a new `version` cleanly partitions in-flight runs\n * across deploys so old runIds never collide with new ones.\n */\nexport function deriveRunId(\n  sessionId: string,\n  version: string | undefined,\n  turnIndex: number,\n): string {\n  return `${sessionId}.${version ?? \"unversioned\"}.${turnIndex}`;\n}\n\n/** Parameters for one Phase-5 dispatch. */\nexport type DispatchParams<TOutput, TState> = {\n  ctx: OrchestratorEngineContext<TOutput, TState>;\n  sessionId: string;\n  input: SupervisorInput;\n  /** The session-state seed assembled in Phase 1 + the per-call patch. */\n  seedState: TState;\n  turnIndex: number;\n  /** Agent-windowed history from Phase 4. */\n  history: Message[];\n  context?: Record<string, unknown>;\n  signal?: AbortSignal;\n};\n\n/** Outcome of Phase 5 — the supervisor result plus the turn's snapshot. */\nexport type DispatchOutcome<TOutput> = {\n  result: SupervisorResult<TOutput>;\n  /** Post-dispatch session state (replaces session state per §5). */\n  state: unknown;\n  turnSnapshot: TurnSnapshot;\n};\n\n/**\n * Build the internal supervisor config by spreading the orchestrator's\n * supervisor-surface fields (orchestrator.md §1 / §5 Phase 5) and\n * seeding `state` from the session-state seed.\n *\n * `iterate: false` caps `maxIterations` at 1 — a single dispatch per\n * turn (\"the supervisor's Phase A + Phase B once, no iteration loop\" —\n * §5). `iterate: true` keeps the configured `maxIterations` (default\n * 10) and wires the `snapshotStore` for mid-turn resume.\n *\n * The orchestrator DELEGATES to the existing supervisor — it never\n * reimplements dispatch / route / evaluate / strip-merge logic.\n */\nfunction buildSupervisorConfig<TOutput, TState>(\n  ctx: OrchestratorEngineContext<TOutput, TState>,\n  seedState: TState,\n  iterate: boolean,\n  snapshotStore: SnapshotStore | undefined,\n): SupervisorConfig<TOutput, TState> {\n  const config = ctx.config;\n\n  const supervisorConfig: SupervisorConfig<TOutput, TState> = {\n    name: config.name,\n    version: config.version,\n    systemPrompt: config.systemPrompt,\n    intents: config.intents,\n    route: config.route,\n    router: config.router,\n    evaluate: config.evaluate,\n    state: seedState,\n    output: config.output,\n    initialAgent: config.initialAgent,\n    maxIterations: iterate ? config.maxIterations : 1,\n    historyWindow: config.historyWindow\n      ? { router: toNumber(config.historyWindow.router), agents: toNumber(config.historyWindow.agents) }\n      : undefined,\n    snapshotStore: iterate ? snapshotStore : undefined,\n  };\n\n  return supervisorConfig;\n}\n\n/**\n * The supervisor's `historyWindow` tiers accept only numbers; the\n * orchestrator's accept a number OR a slicer callback. The callback\n * form is already applied at the orchestrator level (Phase 4), so any\n * non-number here has already done its slicing — drop it for the\n * supervisor (which sees the pre-sliced history) by returning\n * `undefined`.\n */\nfunction toNumber(\n  value: number | ((messages: Message[]) => Message[]) | undefined,\n): number | undefined {\n  return typeof value === \"number\" ? value : undefined;\n}\n\n/**\n * Build the forensic {@link TurnSnapshot} for the dispatched turn from\n * the supervisor's result. Mirrors the supervisor's `IterationSnapshot`\n * shape (§15.5) so a turn reads uniformly whether one agent ran\n * (`iterate: false`) or the internal supervisor iterated\n * (`iterate: true`). The terminal iteration's branch records and\n * decision are lifted onto the turn; the supervisor's full report tree\n * becomes the turn's `childReport`.\n */\nfunction buildTurnSnapshot(\n  input: SupervisorInput,\n  turnIndex: number,\n  result: SupervisorResult<unknown>,\n  state: unknown,\n): TurnSnapshot {\n  const report = result.report;\n  const snapshots = report.snapshots;\n  const terminal = snapshots.length > 0 ? snapshots[snapshots.length - 1] : undefined;\n\n  const decisionSource = mapDecisionSource(terminal?.decision.source);\n\n  return Object.freeze({\n    turn: turnIndex,\n    input,\n    decision: {\n      source: decisionSource,\n      raw: terminal?.decision.next ?? null,\n      reasoning: terminal?.decision.reasoning,\n    },\n    result: terminal?.result ?? {},\n    state,\n    evaluate: terminal?.evaluateVerdict,\n    startedAt: report.startedAt,\n    endedAt: report.endedAt,\n    duration: report.duration,\n    usage: report.usage,\n    childReport: report,\n  });\n}\n\n/**\n * Map the supervisor's `DecisionSource` onto the narrower turn-snapshot\n * decision source (§15.5 — `\"route\" | \"router\" | \"intent.next\"`). The\n * supervisor's `initialAgent` / `classifier` first-turn sources collapse\n * to `\"intent.next\"` (a non-route/router origin) at the orchestrator\n * layer, which only distinguishes the three coarse decision origins.\n */\nfunction mapDecisionSource(\n  source: \"route\" | \"router\" | \"initialAgent\" | \"classifier\" | undefined,\n): \"route\" | \"router\" | \"intent.next\" {\n  if (source === \"route\" || source === \"router\") {\n    return source;\n  }\n\n  return \"intent.next\";\n}\n\n/**\n * Phase 5 — dispatch turn (orchestrator.md §3 / §4 Phase 5).\n *\n * Constructs a fresh internal supervisor seeded from the session state,\n * then:\n *\n * - `iterate: false` — runs a single dispatch (`maxIterations: 1`).\n * - `iterate: true` — runs the full supervisor with a deterministic\n *   `runId`, resuming an in-flight run when the `SnapshotStore` already\n *   has one for that `runId` (§5 step 5).\n *\n * The supervisor's final state replaces the session state (§5 — replace\n * semantics). The supervisor is never kept alive across turns\n * (single-call lifecycle invariant — §18.8).\n */\nexport async function dispatchTurn<TOutput, TState>(\n  params: DispatchParams<TOutput, TState>,\n): Promise<DispatchOutcome<TOutput>> {\n  const { ctx, sessionId, input, seedState, turnIndex, history, context, signal } =\n    params;\n\n  const iterate = ctx.config.iterate === true;\n  const sup = createSupervisor<TOutput, TState>(\n    buildSupervisorConfig(ctx, seedState, iterate, ctx.snapshotStore),\n  );\n\n  let result: SupervisorResult<TOutput>;\n\n  if (iterate) {\n    const runId = deriveRunId(sessionId, ctx.config.version, turnIndex);\n    const inFlight = ctx.snapshotStore\n      ? await ctx.snapshotStore.load(runId)\n      : undefined;\n\n    if (inFlight && inFlight.status === \"running\") {\n      result = await sup.resume(runId, { context, signal, history, sessionId });\n    } else {\n      result = await sup.execute(input, { runId, context, signal, history, sessionId });\n    }\n  } else {\n    result = await sup.execute(input, { context, signal, history, sessionId });\n  }\n\n  const state = deriveFinalState(result, seedState);\n  const turnSnapshot = buildTurnSnapshot(input, turnIndex, result, state);\n\n  return { result, state, turnSnapshot };\n}\n\n/**\n * Derive the post-turn session state from the supervisor result.\n * Prefers the terminal iteration's accumulated `state`; falls back to\n * the validated `data` (when an `output` schema reshaped it), then to\n * the seed when the run produced neither (e.g. it terminated before\n * dispatching anything). Replace semantics — the supervisor is the\n * authority on state evolution within its loop (§5).\n */\nfunction deriveFinalState<TOutput, TState>(\n  result: SupervisorResult<TOutput>,\n  seedState: TState,\n): unknown {\n  const report: SupervisorReport = result.report;\n  const snapshots = report.snapshots;\n  const terminal = snapshots.length > 0 ? snapshots[snapshots.length - 1] : undefined;\n\n  if (terminal && terminal.state !== undefined) {\n    return terminal.state;\n  }\n\n  if (result.data !== undefined) {\n    return result.data;\n  }\n\n  return seedState;\n}\n"],"mappings":";;;;;;;;;;;AAkBA,SAAgB,YACd,WACA,SACA,WACQ;CACR,OAAO,GAAG,UAAU,GAAG,WAAW,cAAc,GAAG;AACrD;;;;;;;;;;;;;;AAqCA,SAAS,sBACP,KACA,WACA,SACA,eACmC;CACnC,MAAM,SAAS,IAAI;CAoBnB,OAAO;EAjBL,MAAM,OAAO;EACb,SAAS,OAAO;EAChB,cAAc,OAAO;EACrB,SAAS,OAAO;EAChB,OAAO,OAAO;EACd,QAAQ,OAAO;EACf,UAAU,OAAO;EACjB,OAAO;EACP,QAAQ,OAAO;EACf,cAAc,OAAO;EACrB,eAAe,UAAU,OAAO,gBAAgB;EAChD,eAAe,OAAO,gBAClB;GAAE,QAAQ,SAAS,OAAO,cAAc,MAAM;GAAG,QAAQ,SAAS,OAAO,cAAc,MAAM;EAAE,IAC/F;EACJ,eAAe,UAAU,gBAAgB;CAGrB;AACxB;;;;;;;;;AAUA,SAAS,SACP,OACoB;CACpB,OAAO,OAAO,UAAU,WAAW,QAAQ;AAC7C;;;;;;;;;;AAWA,SAAS,kBACP,OACA,WACA,QACA,OACc;CACd,MAAM,SAAS,OAAO;CACtB,MAAM,YAAY,OAAO;CACzB,MAAM,WAAW,UAAU,SAAS,IAAI,UAAU,UAAU,SAAS,KAAK;CAE1E,MAAM,iBAAiB,kBAAkB,UAAU,SAAS,MAAM;CAElE,OAAO,OAAO,OAAO;EACnB,MAAM;EACN;EACA,UAAU;GACR,QAAQ;GACR,KAAK,UAAU,SAAS,QAAQ;GAChC,WAAW,UAAU,SAAS;EAChC;EACA,QAAQ,UAAU,UAAU,CAAC;EAC7B;EACA,UAAU,UAAU;EACpB,WAAW,OAAO;EAClB,SAAS,OAAO;EAChB,UAAU,OAAO;EACjB,OAAO,OAAO;EACd,aAAa;CACf,CAAC;AACH;;;;;;;;AASA,SAAS,kBACP,QACoC;CACpC,IAAI,WAAW,WAAW,WAAW,UACnC,OAAO;CAGT,OAAO;AACT;;;;;;;;;;;;;;;;AAiBA,eAAsB,aACpB,QACmC;CACnC,MAAM,EAAE,KAAK,WAAW,OAAO,WAAW,WAAW,SAAS,SAAS,WACrE;CAEF,MAAM,UAAU,IAAI,OAAO,YAAY;CACvC,MAAM,MAAMA,WACV,sBAAsB,KAAK,WAAW,SAAS,IAAI,aAAa,CAClE;CAEA,IAAI;CAEJ,IAAI,SAAS;EACX,MAAM,QAAQ,YAAY,WAAW,IAAI,OAAO,SAAS,SAAS;EAClE,MAAM,WAAW,IAAI,gBACjB,MAAM,IAAI,cAAc,KAAK,KAAK,IAClC;EAEJ,IAAI,YAAY,SAAS,WAAW,WAClC,SAAS,MAAM,IAAI,OAAO,OAAO;GAAE;GAAS;GAAQ;GAAS;EAAU,CAAC;OAExE,SAAS,MAAM,IAAI,QAAQ,OAAO;GAAE;GAAO;GAAS;GAAQ;GAAS;EAAU,CAAC;CAEpF,OACE,SAAS,MAAM,IAAI,QAAQ,OAAO;EAAE;EAAS;EAAQ;EAAS;CAAU,CAAC;CAG3E,MAAM,QAAQ,iBAAiB,QAAQ,SAAS;CAChD,MAAM,eAAe,kBAAkB,OAAO,WAAW,QAAQ,KAAK;CAEtE,OAAO;EAAE;EAAQ;EAAO;CAAa;AACvC;;;;;;;;;AAUA,SAAS,iBACP,QACA,WACS;CAET,MAAM,YAD2B,OAAO,OACf;CACzB,MAAM,WAAW,UAAU,SAAS,IAAI,UAAU,UAAU,SAAS,KAAK;CAE1E,IAAI,YAAY,SAAS,UAAU,QACjC,OAAO,SAAS;CAGlB,IAAI,OAAO,SAAS,QAClB,OAAO,OAAO;CAGhB,OAAO;AACT"}

package/esm/orchestrator/emitter-port.type.d.mts

@@ -0,0 +1,31 @@
+import { OrchestratorEventHandlers, OrchestratorEventMap } from "../contracts/orchestrator/orchestrator-event.type.mjs";
+
+//#region ../@warlock.js/ai/src/orchestrator/emitter-port.type.d.ts
+/**
+ * Minimal structural surface the C2 engine needs from the orchestrator
+ * emitter (owned by C1's `emitter.ts`). Declared as a port so the
+ * engine depends only on the shape it calls, never on C1's concrete
+ * emitter class — keeping the two components decoupled.
+ *
+ * The engine emits one event per lifecycle phase (orchestrator.md
+ * §14.1) and registers the per-call `options.on` handlers (tier 3) for
+ * the duration of a single turn. `emit` injects run `EventIdentity`
+ * centrally inside the emitter, so the engine passes only the typed
+ * payload.
+ */
+type OrchestratorEmitterLike = {
+  /**
+   * Fire an event to all three tiers (definition → instance →
+   * per-call) in order. Identity is injected by the emitter.
+   */
+  emit<K extends keyof OrchestratorEventMap>(event: K, payload: OrchestratorEventMap[K]): void;
+  /**
+   * Register the per-call handler bag (tier 3) for the scope of one
+   * turn. Returns a disposer the engine calls in a `finally` to unwind
+   * the per-call subscriptions when the turn settles.
+   */
+  bindPerCall(handlers: OrchestratorEventHandlers | undefined): () => void;
+};
+//#endregion
+export { OrchestratorEmitterLike };
+//# sourceMappingURL=emitter-port.type.d.mts.map

package/esm/orchestrator/emitter-port.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitter-port.type.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/orchestrator/emitter-port.type.ts"],"mappings":";;;;;AAiBA;;;;;;;;;;KAAY,uBAAA;EAKL;;;;EAAL,IAAA,iBAAqB,oBAAA,EACnB,KAAA,EAAO,CAAA,EACP,OAAA,EAAS,oBAAA,CAAqB,CAAA;EAAA;;;;;EAQhC,WAAA,CAAY,QAAA,EAAU,yBAAA;AAAA"}

package/esm/orchestrator/emitter.d.mts

@@ -0,0 +1,56 @@
+import { EventIdentity, WithoutIdentity } from "../contracts/events/event-identity.type.mjs";
+import { OrchestratorEventHandler, OrchestratorEventHandlers, OrchestratorEventMap, OrchestratorEventName } from "../contracts/orchestrator/orchestrator-event.type.mjs";
+
+//#region ../@warlock.js/ai/src/orchestrator/emitter.d.ts
+/** Full identity-stamped payload an orchestrator handler receives. */
+type EventPayload<K extends OrchestratorEventName> = OrchestratorEventMap[K] & EventIdentity;
+/**
+ * Three-tier orchestrator event emitter — definition (factory) →
+ * instance → per-call — for the `orchestrator.*` namespace (design
+ * §14.3). Mirrors {@link import("../supervisor/emitter").SupervisorEmitter}
+ * structurally; the differences are the event map and a central
+ * identity-injection chokepoint (`emit` accepts an identity-less
+ * payload and stamps {@link EventIdentity} once so all three tiers, and
+ * any mirror like the stream, see the same value).
+ *
+ * Owns: the instance-handler registry and the fan-out order. Does NOT
+ * own: child `supervisor.*` / `agent.*` events — those bubble up
+ * unmodified under their own identity (§14.2) and never pass through
+ * this emitter. All matching handlers fire in tier order; a handler
+ * throwing never derails the turn.
+ *
+ * @example
+ * const emitter = new OrchestratorEmitter(config.on);
+ * const off = emitter.on("orchestrator.turn.completed", (event) => log(event));
+ * emitter.emit(
+ *   "orchestrator.turn.starting",
+ *   { sessionId, turnIndex },
+ *   { runId, rootRunId },
+ *   perCallHandlers,
+ * );
+ */
+declare class OrchestratorEmitter {
+  private readonly factoryHandlers?;
+  private readonly instanceHandlers;
+  constructor(factoryHandlers?: OrchestratorEventHandlers);
+  /**
+   * Subscribe an instance-level handler (tier 2). Returns an
+   * unsubscribe function equivalent to `off(event, handler)`.
+   */
+  on<K extends OrchestratorEventName>(event: K, handler: OrchestratorEventHandler<K>): () => void;
+  /**
+   * Remove a previously-subscribed instance handler. No-op when the
+   * handler was never registered or already removed.
+   */
+  off<K extends OrchestratorEventName>(event: K, handler: OrchestratorEventHandler<K>): void;
+  /**
+   * Stamp run identity onto the payload, then fan out through all three
+   * tiers in order: definition → instance → per-call. Returns the full
+   * identity-stamped payload so the caller can mirror the same value
+   * into the stream controller (keeping `.on()` and iteration in lockstep).
+   */
+  emit<K extends OrchestratorEventName>(event: K, payload: WithoutIdentity<OrchestratorEventMap[K]>, identity: EventIdentity, perCallHandlers?: OrchestratorEventHandlers): EventPayload<K>;
+}
+//#endregion
+export { OrchestratorEmitter };
+//# sourceMappingURL=emitter.d.mts.map

package/esm/orchestrator/emitter.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitter.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/orchestrator/emitter.ts"],"mappings":";;;;;KAYK,YAAA,WAAuB,qBAAA,IAAyB,oBAAA,CAAqB,CAAA,IACxE,aAAA;AAJyD;;;;;;;;;;;;;;;AAI5C;AAoCf;;;;;;;;;AAxC2D,cAwC9C,mBAAA;EAAA,iBACM,eAAA;EAAA,iBACA,gBAAA;cAKE,eAAA,GAAkB,yBAAA;EA0C5B;;;;EAlCF,EAAA,WAAa,qBAAA,EAClB,KAAA,EAAO,CAAA,EACP,OAAA,EAAS,wBAAA,CAAyB,CAAA;EAmChB;;;;EAjBb,GAAA,WAAc,qBAAA,EACnB,KAAA,EAAO,CAAA,EACP,OAAA,EAAS,wBAAA,CAAyB,CAAA;EApCnB;;;;;;EA+CV,IAAA,WAAe,qBAAA,EACpB,KAAA,EAAO,CAAA,EACP,OAAA,EAAS,eAAA,CAAgB,oBAAA,CAAqB,CAAA,IAC9C,QAAA,EAAU,aAAA,EACV,eAAA,GAAkB,yBAAA,GACjB,YAAA,CAAa,CAAA;AAAA"}

package/esm/orchestrator/emitter.mjs

@@ -0,0 +1,85 @@
+//#region ../@warlock.js/ai/src/orchestrator/emitter.ts
+/**
+* Three-tier orchestrator event emitter — definition (factory) →
+* instance → per-call — for the `orchestrator.*` namespace (design
+* §14.3). Mirrors {@link import("../supervisor/emitter").SupervisorEmitter}
+* structurally; the differences are the event map and a central
+* identity-injection chokepoint (`emit` accepts an identity-less
+* payload and stamps {@link EventIdentity} once so all three tiers, and
+* any mirror like the stream, see the same value).
+*
+* Owns: the instance-handler registry and the fan-out order. Does NOT
+* own: child `supervisor.*` / `agent.*` events — those bubble up
+* unmodified under their own identity (§14.2) and never pass through
+* this emitter. All matching handlers fire in tier order; a handler
+* throwing never derails the turn.
+*
+* @example
+* const emitter = new OrchestratorEmitter(config.on);
+* const off = emitter.on("orchestrator.turn.completed", (event) => log(event));
+* emitter.emit(
+*   "orchestrator.turn.starting",
+*   { sessionId, turnIndex },
+*   { runId, rootRunId },
+*   perCallHandlers,
+* );
+*/
+var OrchestratorEmitter = class {
+	constructor(factoryHandlers) {
+		this.instanceHandlers = /* @__PURE__ */ new Map();
+		this.factoryHandlers = factoryHandlers;
+	}
+	/**
+	* Subscribe an instance-level handler (tier 2). Returns an
+	* unsubscribe function equivalent to `off(event, handler)`.
+	*/
+	on(event, handler) {
+		let bucket = this.instanceHandlers.get(event);
+		if (!bucket) {
+			bucket = /* @__PURE__ */ new Set();
+			this.instanceHandlers.set(event, bucket);
+		}
+		bucket.add(handler);
+		return () => this.off(event, handler);
+	}
+	/**
+	* Remove a previously-subscribed instance handler. No-op when the
+	* handler was never registered or already removed.
+	*/
+	off(event, handler) {
+		this.instanceHandlers.get(event)?.delete(handler);
+	}
+	/**
+	* Stamp run identity onto the payload, then fan out through all three
+	* tiers in order: definition → instance → per-call. Returns the full
+	* identity-stamped payload so the caller can mirror the same value
+	* into the stream controller (keeping `.on()` and iteration in lockstep).
+	*/
+	emit(event, payload, identity, perCallHandlers) {
+		const fullPayload = {
+			...payload,
+			...identity
+		};
+		invoke(this.factoryHandlers?.[event], fullPayload);
+		const bucket = this.instanceHandlers.get(event);
+		if (bucket) for (const handler of bucket) invoke(handler, fullPayload);
+		invoke(perCallHandlers?.[event], fullPayload);
+		return fullPayload;
+	}
+};
+/**
+* Invoke a single handler, swallowing any throw. A listener bug must
+* never derail the orchestrator turn. Typed structurally (a plain
+* `(payload) => void`) so the identity-stamped payload flows in without
+* fighting the contravariant `OrchestratorEventHandler<K>` union.
+*/
+function invoke(handler, payload) {
+	if (typeof handler !== "function") return;
+	try {
+		handler(payload);
+	} catch {}
+}
+
+//#endregion
+export { OrchestratorEmitter };
+//# sourceMappingURL=emitter.mjs.map

package/esm/orchestrator/emitter.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"emitter.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai/src/orchestrator/emitter.ts"],"sourcesContent":["import type {\n  EventIdentity,\n  WithoutIdentity,\n} from \"../contracts/events/event-identity.type\";\nimport type {\n  OrchestratorEventHandler,\n  OrchestratorEventHandlers,\n  OrchestratorEventMap,\n  OrchestratorEventName,\n} from \"../contracts/orchestrator/orchestrator-event.type\";\n\n/** Full identity-stamped payload an orchestrator handler receives. */\ntype EventPayload<K extends OrchestratorEventName> = OrchestratorEventMap[K] &\n  EventIdentity;\n\n/**\n * Erased handler shape for the instance registry. Per-event handlers\n * are contravariant in their payload, so the registry stores them under\n * a single structural `(payload) => void` and re-narrows at the call\n * site — the `on` / `off` public surface keeps the precise per-event\n * typing.\n */\ntype AnyHandler = (payload: EventPayload<OrchestratorEventName>) => void;\n\n/**\n * Three-tier orchestrator event emitter — definition (factory) →\n * instance → per-call — for the `orchestrator.*` namespace (design\n * §14.3). Mirrors {@link import(\"../supervisor/emitter\").SupervisorEmitter}\n * structurally; the differences are the event map and a central\n * identity-injection chokepoint (`emit` accepts an identity-less\n * payload and stamps {@link EventIdentity} once so all three tiers, and\n * any mirror like the stream, see the same value).\n *\n * Owns: the instance-handler registry and the fan-out order. Does NOT\n * own: child `supervisor.*` / `agent.*` events — those bubble up\n * unmodified under their own identity (§14.2) and never pass through\n * this emitter. All matching handlers fire in tier order; a handler\n * throwing never derails the turn.\n *\n * @example\n * const emitter = new OrchestratorEmitter(config.on);\n * const off = emitter.on(\"orchestrator.turn.completed\", (event) => log(event));\n * emitter.emit(\n *   \"orchestrator.turn.starting\",\n *   { sessionId, turnIndex },\n *   { runId, rootRunId },\n *   perCallHandlers,\n * );\n */\nexport class OrchestratorEmitter {\n  private readonly factoryHandlers?: OrchestratorEventHandlers;\n  private readonly instanceHandlers = new Map<\n    OrchestratorEventName,\n    Set<AnyHandler>\n  >();\n\n  public constructor(factoryHandlers?: OrchestratorEventHandlers) {\n    this.factoryHandlers = factoryHandlers;\n  }\n\n  /**\n   * Subscribe an instance-level handler (tier 2). Returns an\n   * unsubscribe function equivalent to `off(event, handler)`.\n   */\n  public on<K extends OrchestratorEventName>(\n    event: K,\n    handler: OrchestratorEventHandler<K>,\n  ): () => void {\n    let bucket = this.instanceHandlers.get(event);\n\n    if (!bucket) {\n      bucket = new Set();\n      this.instanceHandlers.set(event, bucket);\n    }\n\n    bucket.add(handler as unknown as AnyHandler);\n\n    return () => this.off(event, handler);\n  }\n\n  /**\n   * Remove a previously-subscribed instance handler. No-op when the\n   * handler was never registered or already removed.\n   */\n  public off<K extends OrchestratorEventName>(\n    event: K,\n    handler: OrchestratorEventHandler<K>,\n  ): void {\n    this.instanceHandlers.get(event)?.delete(handler as unknown as AnyHandler);\n  }\n\n  /**\n   * Stamp run identity onto the payload, then fan out through all three\n   * tiers in order: definition → instance → per-call. Returns the full\n   * identity-stamped payload so the caller can mirror the same value\n   * into the stream controller (keeping `.on()` and iteration in lockstep).\n   */\n  public emit<K extends OrchestratorEventName>(\n    event: K,\n    payload: WithoutIdentity<OrchestratorEventMap[K]>,\n    identity: EventIdentity,\n    perCallHandlers?: OrchestratorEventHandlers,\n  ): EventPayload<K> {\n    const fullPayload = { ...payload, ...identity } as EventPayload<K>;\n\n    invoke(this.factoryHandlers?.[event], fullPayload);\n\n    const bucket = this.instanceHandlers.get(event);\n\n    if (bucket) {\n      for (const handler of bucket) {\n        invoke(handler as unknown as (payload: EventPayload<K>) => void, fullPayload);\n      }\n    }\n\n    invoke(perCallHandlers?.[event], fullPayload);\n\n    return fullPayload;\n  }\n}\n\n/**\n * Invoke a single handler, swallowing any throw. A listener bug must\n * never derail the orchestrator turn. Typed structurally (a plain\n * `(payload) => void`) so the identity-stamped payload flows in without\n * fighting the contravariant `OrchestratorEventHandler<K>` union.\n */\nfunction invoke<K extends OrchestratorEventName>(\n  handler: ((payload: EventPayload<K>) => void) | undefined,\n  payload: EventPayload<K>,\n): void {\n  if (typeof handler !== \"function\") {\n    return;\n  }\n\n  try {\n    handler(payload);\n  } catch {\n    // Listener bugs must not derail the orchestrator.\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,IAAa,sBAAb,MAAiC;CAO/B,AAAO,YAAY,iBAA6C;0CAL5B,IAAI,IAGtC;EAGA,KAAK,kBAAkB;CACzB;;;;;CAMA,AAAO,GACL,OACA,SACY;EACZ,IAAI,SAAS,KAAK,iBAAiB,IAAI,KAAK;EAE5C,IAAI,CAAC,QAAQ;GACX,yBAAS,IAAI,IAAI;GACjB,KAAK,iBAAiB,IAAI,OAAO,MAAM;EACzC;EAEA,OAAO,IAAI,OAAgC;EAE3C,aAAa,KAAK,IAAI,OAAO,OAAO;CACtC;;;;;CAMA,AAAO,IACL,OACA,SACM;EACN,KAAK,iBAAiB,IAAI,KAAK,CAAC,EAAE,OAAO,OAAgC;CAC3E;;;;;;;CAQA,AAAO,KACL,OACA,SACA,UACA,iBACiB;EACjB,MAAM,cAAc;GAAE,GAAG;GAAS,GAAG;EAAS;EAE9C,OAAO,KAAK,kBAAkB,QAAQ,WAAW;EAEjD,MAAM,SAAS,KAAK,iBAAiB,IAAI,KAAK;EAE9C,IAAI,QACF,KAAK,MAAM,WAAW,QACpB,OAAO,SAA0D,WAAW;EAIhF,OAAO,kBAAkB,QAAQ,WAAW;EAE5C,OAAO;CACT;AACF;;;;;;;AAQA,SAAS,OACP,SACA,SACM;CACN,IAAI,OAAO,YAAY,YACrB;CAGF,IAAI;EACF,QAAQ,OAAO;CACjB,QAAQ,CAER;AACF"}

package/esm/orchestrator/engine-context.type.d.mts

@@ -0,0 +1,56 @@
+import { SnapshotStore } from "../contracts/orchestrator/snapshot-store.contract.mjs";
+import { SupervisorIntentValue } from "../contracts/supervisor/intent-entry.type.mjs";
+import { CheckpointStore } from "../contracts/orchestrator/checkpoint-store.contract.mjs";
+import { OrchestratorConfig } from "../contracts/orchestrator/orchestrator-config.type.mjs";
+import { ResolvedOrchestratorMemory } from "./memory.mjs";
+import { OrchestratorEmitterLike } from "./emitter-port.type.mjs";
+
+//#region ../@warlock.js/ai/src/orchestrator/engine-context.type.d.ts
+/**
+ * Everything the C2 engine needs to run a turn, assembled once by the
+ * C1 factory at construction and passed into every engine entry point
+ * (`runTurn` / `streamTurn` / `runResume` / `runCommand`).
+ *
+ * The factory owns construction, author-time validation, and signature
+ * computation; the engine owns the 7-phase lifecycle (orchestrator.md
+ * §3). Splitting the config from the resolved stores keeps the engine
+ * agnostic to how the factory resolved its `checkpointStore` /
+ * `snapshotStore` (own field vs `ai.config` default vs throw).
+ *
+ * `TState` flows through so the engine's state seed/patch merge is
+ * typed against the orchestrator's session state shape.
+ */
+type OrchestratorEngineContext<TOutput = unknown, TState = TOutput, TIntents extends Record<string, SupervisorIntentValue> = Record<string, SupervisorIntentValue>> = {
+  /** The validated factory config (C1 has already run author-time checks). */config: OrchestratorConfig<TOutput, TState, TIntents>; /** Structural drift fingerprint computed by C1's `signature.ts`. */
+  signature: string;
+  /**
+   * Resolved durable session store (own field → `ai.config`
+   * default). C1 guarantees this is present — it throws
+   * `OrchestratorConfigError` at construction when none resolves.
+   */
+  checkpointStore: CheckpointStore;
+  /**
+   * Resolved internal-supervisor snapshot store, or `undefined` when
+   * `iterate: false`. C1 guarantees it is present whenever
+   * `iterate: true`.
+   */
+  snapshotStore: SnapshotStore | undefined;
+  /**
+   * The orchestrator-scope event emitter (3-tier: definition →
+   * instance → per-call). Owned by C1; the engine calls `emit` per
+   * phase. Kept structurally minimal so the engine never depends on
+   * C1's concrete emitter class.
+   */
+  emitter: OrchestratorEmitterLike;
+  /**
+   * Resolved per-turn memory wiring (memory core M2), or `undefined`
+   * when the config declared no `memory`. Resolved once by the engine
+   * at construction from the bare-store / config form so the lifecycle
+   * reads one flat shape. When present, Phase 5 recalls + injects before
+   * dispatch and remembers the outcome after a clean turn.
+   */
+  memory?: ResolvedOrchestratorMemory;
+};
+//#endregion
+export { OrchestratorEngineContext };
+//# sourceMappingURL=engine-context.type.d.mts.map

package/esm/orchestrator/engine-context.type.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-context.type.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/orchestrator/engine-context.type.ts"],"mappings":";;;;;;;;;;AAqBA;;;;;;;;;;;;KAAY,yBAAA,6BAED,OAAA,mBACQ,MAAA,SAAe,qBAAA,IAAyB,MAAA,SAEvD,qBAAA;EAkBa,4EAdf,MAAA,EAAQ,kBAAA,CAAmB,OAAA,EAAS,MAAA,EAAQ,QAAA,GA6BnC;EA3BT,SAAA;EA2BmC;;;;;EArBnC,eAAA,EAAiB,eAAA;EAde;;;;;EAoBhC,aAAA,EAAe,aAAA;EAdqB;;;;;;EAqBpC,OAAA,EAAS,uBAAA;EAAT;;;;;AAQmC;;EAAnC,MAAA,GAAS,0BAAA;AAAA"}

package/esm/orchestrator/execution.d.mts

@@ -0,0 +1,116 @@
+import { Message } from "../contracts/conversation-message.type.mjs";
+import { SupervisorInput } from "../contracts/supervisor/supervisor-input.type.mjs";
+import { OrchestratorResult } from "../contracts/result/orchestrator-result.type.mjs";
+import { OrchestratorCommands } from "../contracts/orchestrator/orchestrator-commands.type.mjs";
+import { OrchestratorExecuteOptions, OrchestratorResumeOptions } from "../contracts/orchestrator/orchestrator-execute-options.type.mjs";
+import { OrchestratorConfig } from "../contracts/orchestrator/orchestrator-config.type.mjs";
+import { OrchestratorEmitter } from "./emitter.mjs";
+import { ResolvedIntentEntry } from "../supervisor/entries.mjs";
+import { OrchestratorEngineContext } from "./engine-context.type.mjs";
+import { OrchestratorStreamController } from "./orchestrator-stream.mjs";
+
+//#region ../@warlock.js/ai/src/orchestrator/execution.d.ts
+/**
+ * Constructor params the C1 factory passes when building an
+ * {@link OrchestratorExecution} per call. The factory owns author-time
+ * validation, intent-entry resolution, and signature computation; it
+ * hands the engine the validated `config`, the resolved `entries`, the
+ * computed `signature`, and the shared three-tier `emitter`. The
+ * per-call inputs vary by entry point:
+ *
+ * - `execute` / `stream` — `input` + `options` (and `streamController`
+ *   for `stream`).
+ * - `resume` — `resumeSessionId` + `resumeOptions`.
+ * - `command("compact")` — neither; `compact(args)` carries its own.
+ */
+type OrchestratorExecutionParams<TOutput, TState> = {
+  config: OrchestratorConfig<TOutput, TState>; /** Resolved intent entries (validated by C1; the engine delegates dispatch to the supervisor). */
+  entries?: Map<string, ResolvedIntentEntry>;
+  signature: string;
+  emitter: OrchestratorEmitter;
+  input?: SupervisorInput;
+  options?: OrchestratorExecuteOptions<TState>;
+  streamController?: OrchestratorStreamController<OrchestratorResult<TOutput>>;
+  resumeSessionId?: string;
+  resumeOptions?: OrchestratorResumeOptions;
+};
+/**
+ * Per-call lifecycle engine — the single object the C1 factory
+ * constructs and drives. Owns the 7-phase lifecycle (orchestrator.md §3:
+ * load → drift → lock → window → dispatch → persist → compaction),
+ * resolving the durable stores (own config field → `ai.config` default)
+ * and adapting C1's three-tier {@link OrchestratorEmitter} to the
+ * {@link OrchestratorEmitterLike} port the phase modules call.
+ *
+ * The factory creates a fresh instance per `execute` / `stream` /
+ * `resume` / `command` call (single-call lifecycle invariant — §18.8);
+ * the heavy lifting lives in the standalone phase functions
+ * ({@link runTurn} / {@link runResume}) which this class delegates to.
+ *
+ * @example
+ * const execution = new OrchestratorExecution({
+ *   config, entries, signature, emitter, input, options,
+ * });
+ * const result = await execution.run();
+ */
+declare class OrchestratorExecution<TOutput, TState> {
+  private readonly params;
+  private readonly ctx;
+  private readonly streamController?;
+  constructor(params: OrchestratorExecutionParams<TOutput, TState>);
+  /**
+   * `execute()` / `stream()` entry — run one turn through the 7-phase
+   * lifecycle. When a `streamController` was supplied, the adapter mirrors
+   * every emitted event into the stream and the controller is settled
+   * (`end` / `fail`) once the result resolves.
+   */
+  run(): Promise<OrchestratorResult<TOutput>>;
+  /**
+   * `resume()` entry — drain an interrupted `iterate: true` turn (§9).
+   * Returns `null` when nothing is in flight.
+   */
+  resume(): Promise<OrchestratorResult<TOutput> | null>;
+  /**
+   * `command("compact")` entry — run a manual compaction on demand (§11 /
+   * §12.1). Reuses the post-turn compaction code path against the
+   * caller-supplied history and returns the raw {@link CompactionResult}.
+   */
+  compact(args: OrchestratorCommands["compact"]["args"]): Promise<OrchestratorCommands["compact"]["result"]>;
+}
+/**
+ * Run one turn end-to-end through the 7-phase lifecycle (orchestrator
+ * .md §3). The single entry the C1 factory's `execute()` delegates to.
+ *
+ * Phase order is the diagram's contract: load → drift → lock → window
+ * → dispatch → persist → compaction. Drift / config misuse throw;
+ * every other failure surfaces on `result.error` (the contract: the
+ * orchestrator never throws on runtime failure). Cancellation and
+ * failure do NOT persist a fresh checkpoint (§17 — state reverts to the
+ * pre-turn checkpoint).
+ */
+declare function runTurn<TOutput, TState>(ctx: OrchestratorEngineContext<TOutput, TState>, input: SupervisorInput, options: OrchestratorExecuteOptions<TState>): Promise<OrchestratorResult<TOutput>>;
+/**
+ * §9 resume protocol entry the C1 factory's `resume()` delegates to.
+ * Returns `null` when no in-flight `iterate: true` turn is detected;
+ * otherwise drains the interrupted supervisor run, persists a fresh
+ * checkpoint for the resumed turn, and returns the completed result.
+ *
+ * Runs the same Phase 2 drift check as `runTurn` (§9.4). The heavy
+ * lifting lives in `resume.ts`; this wrapper threads the engine
+ * context.
+ */
+declare function runResume<TOutput, TState>(ctx: OrchestratorEngineContext<TOutput, TState>, sessionId: string, options?: OrchestratorResumeOptions): Promise<OrchestratorResult<TOutput> | null>;
+/**
+ * The `stream()` entry. The orchestrator's streaming surface bubbles
+ * child agent/supervisor events under their own namespace (§14.2); the
+ * C1 stream controller owns the `StreamContract` wiring. This engine
+ * entry runs the same lifecycle as `runTurn` — the C1 factory passes a
+ * per-call `on` bag wired to the stream controller, so the engine needs
+ * no streaming-specific branch. Exposed as a distinct name for the
+ * factory to call, returning the same `OrchestratorResult` the stream's
+ * `.result` resolves to.
+ */
+declare function streamTurn<TOutput, TState>(ctx: OrchestratorEngineContext<TOutput, TState>, input: SupervisorInput, options: OrchestratorExecuteOptions<TState>): Promise<OrchestratorResult<TOutput>>;
+//#endregion
+export { OrchestratorExecution, OrchestratorExecutionParams, runResume, runTurn, streamTurn };
+//# sourceMappingURL=execution.d.mts.map

package/esm/orchestrator/execution.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/orchestrator/execution.ts"],"mappings":";;;;;;;;;;;;;;AAmEA;;;;;;;;;;;KAAY,2BAAA;EACV,MAAA,EAAQ,kBAAA,CAAmB,OAAA,EAAS,MAAA,GAOY;EALhD,OAAA,GAAU,GAAA,SAAY,mBAAA;EACtB,SAAA;EACA,OAAA,EAAS,mBAAA;EACT,KAAA,GAAQ,eAAA;EACR,OAAA,GAAU,0BAAA,CAA2B,MAAA;EACrC,gBAAA,GAAmB,4BAAA,CAA6B,kBAAA,CAAmB,OAAA;EACnE,eAAA;EACA,aAAA,GAAgB,yBAAA;AAAA;;;;;;;;;;;;;;;;;;;;cAsBL,qBAAA;EAAA,iBACM,MAAA;EAAA,iBACA,GAAA;EAAA,iBACA,gBAAA;cAIE,MAAA,EAAQ,2BAAA,CAA4B,OAAA,EAAS,MAAA;EAAT;;;;;;EAyB1C,GAAA,IAAO,OAAA,CAAQ,kBAAA,CAAmB,OAAA;EA4BhB;;;;EAAlB,MAAA,IAAU,OAAA,CAAQ,kBAAA,CAAmB,OAAA;EAiBxC;;;;;EAFG,OAAA,CACX,IAAA,EAAM,oBAAA,sBACL,OAAA,CAAQ,oBAAA;AAAA;;;;;;;;;;;;iBAkPS,OAAA,kBACpB,GAAA,EAAK,yBAAA,CAA0B,OAAA,EAAS,MAAA,GACxC,KAAA,EAAO,eAAA,EACP,OAAA,EAAS,0BAAA,CAA2B,MAAA,IACnC,OAAA,CAAQ,kBAAA,CAAmB,OAAA;;;;;;;;AAtPG;AAkPjC;;iBA2MsB,SAAA,kBACpB,GAAA,EAAK,yBAAA,CAA0B,OAAA,EAAS,MAAA,GACxC,SAAA,UACA,OAAA,GAAU,yBAAA,GACT,OAAA,CAAQ,kBAAA,CAAmB,OAAA;;;;;;;;;;;iBAiDR,UAAA,kBACpB,GAAA,EAAK,yBAAA,CAA0B,OAAA,EAAS,MAAA,GACxC,KAAA,EAAO,eAAA,EACP,OAAA,EAAS,0BAAA,CAA2B,MAAA,IACnC,OAAA,CAAQ,kBAAA,CAAmB,OAAA"}