fascicle 0.10.3 → 0.11.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/CHANGELOG.md CHANGED
@@ -1,5 +1,19 @@
1
1
  # Changelog
2
2
 
3
+ ## v0.11.0 — 2026-08-12
4
+
5
+ ### Changed
6
+
7
+ - **A tool's JSON Schema no longer requires the fields that carry a default.** Provider payloads were emitted through Standard JSON Schema's *output* direction, which describes a value that has already been parsed: defaults are filled in by then, so `z.object({ city: z.string(), units: z.string().default('celsius') })` reached the model as `required: ["city","units"]`. That asked the model to supply a value the schema itself supplies, and made a defaulted field indistinguishable from a mandatory one. Emission now uses the *input* direction, which describes what the model should produce, so the same tool arrives as `required: ["city"]`. The input direction on its own also drops `additionalProperties: false` — the guard that stops a model inventing keys, and a prerequisite of several providers' strict and constrained-decode modes — so it is composed with a pass that closes every object node the vendor left open. This is the same pairing `@ai-sdk/provider-utils` applies to every `kind: 'ai_sdk'` provider (all seven fascicle configures by default), so the native adapters and `claude_cli` now send what the AI SDK path was already sending rather than a second, stricter shape for the same tool. Two restraints keep the closing pass from asserting more than the vendor did: an existing `additionalProperties` is never overwritten, so `z.looseObject`, a `z.record`'s value schema, and a server that published `true` all stay open (the AI SDK overwrites these); and a node is closed only if it declares `properties`, so a bare `{ type: 'object' }` — how a freeform payload is advertised — is left alone instead of being narrowed to "no keys permitted". One capability comes with it: `.output()` throws on a schema carrying a transform (`Transforms cannot be represented in JSON Schema`), so a tool whose schema contained one could not reach a native provider at all; the input direction emits it. **Breaking** on the wire for any tool or structured-output schema with a `.default()` or `.catch()` field: that field moves out of `required`, at every depth, including inside arrays and unions. Schemas without one are byte-identical to before, key order included. A knock-on for MCP: v0.10.3 made an inbound server's advertised schema reach the provider verbatim, and closing objects narrows that — a server that declares `properties` but says nothing about `additionalProperties` now has `additionalProperties: false` added on the native transports. The AI SDK path already did this to those same schemas, so the effect is that MCP tools now behave the same across all transports rather than differing by the one in use.
8
+
9
+ - **`loop` no longer wraps its output in a result envelope.** It returned `Step<i, LoopResult<o>>` — `{ value, converged, rounds }` — so anything that wanted the projected value had to strip `.value` first, and every one of the six in-repo call sites did: `adversarial` and `consensus` each carried a whole `pipe` for it, `improve` had an `improve_unwrap` step, the researcher agent wrapped its loop in a second `step` that called `inner.run` by hand (skipping the loop's own span) purely to return `result.value`, and both example apps hopped through `.value` at the read site. The envelope was a second projection channel layered over the one `loop` already had: `finish` is where the final state becomes the output, and it was already handed a piece of loop metadata (`round: number`) that no call site used. It now receives all of it — `finish: (state, outcome: LoopOutcome) => o`, with `LoopOutcome` being `{ converged, rounds }` — and `loop` returns `Step<i, o>`: exactly what `finish` projects, nothing around it. Non-convergence is still data rather than error; it arrives as an argument instead of a wrapper, which is why this shape was chosen over an `unwrap: true` flag (that would have needed two return types on one function, and would have discarded `converged` silently — the datum the whole convention rests on). Nothing is lost by dropping the envelope, because `finish` and the `loop({...})` call site always have the same author: the old shape is `finish: (state, outcome) => ({ value: state, ...outcome })`, opt-in in one line. Trajectories are unaffected: a traced composer's span records `{ id }` only, so `converged` and `rounds` were never in the trace to begin with. **Breaking:** `LoopResult` is gone from the published surface, replaced by `LoopOutcome`; a `loop` step's output type is now `o`; and a `finish` that declared a second parameter now receives the outcome object where the round count used to be. `docs/composition.md`, `docs/api-reference.md`, and `docs/deliberation-as-composition.md` state the new shape. In `examples/pr-improve` the `LOOP_RESULT` scope key becomes `FINAL_STATE`, since what the loop stashes is now the carry-state itself — whose own `round` field counts the same rounds the envelope reported.
10
+
11
+ ### Internal
12
+
13
+ - **The two retry layers' different abort-rejection shapes are now recorded as deliberate, in the code and in `docs/concepts.md`.** The engine's retry always wraps an abort reason in `aborted_error`; core's propagates an `Error` reason verbatim and wraps anything else. Unifying them founders on a Node 24 fact now pinned by tests on both sides: a bare `controller.abort()` sets a `DOMException` reason, which *is* an `instanceof Error`, so adopting core's semantics in the engine would leak `DOMException` where callers expect `aborted_error`. Each retry module names its shape in a `to_abort_error` factory with the rationale attached.
14
+ - **The last un-hardened wire adapter is closed: the `ai_sdk` Anthropic adapter went from 66.1% to 100% mutation score.** Its config assembly (api key and base URL coercion, conditional `baseURL`) was covered only by a `toBeDefined()` against the real peer; a mock-the-peer test file now pins every field, and a redundant effort-guard clause was simplified away rather than annotated. Full-repo mutation score 88.4% → 89.0%.
15
+ - **The mutation break threshold ratchets 84 → 86**, sized from the measured flake surface (91 Timeout mutants of 10,677 scored = 0.85pt worst case) instead of the previous comment's ~5×-overstated guess.
16
+
3
17
  ## v0.10.3 — 2026-08-12
4
18
 
5
19
  ### Fixed
package/dist/agents.js CHANGED
@@ -1,4 +1,4 @@
1
- import { A as aborted_error, O as step } from "./core-DkuJqLwd.js";
1
+ import { A as aborted_error, O as step } from "./core-Ww6An4CS.js";
2
2
  import { readFileSync } from "node:fs";
3
3
  import { fileURLToPath } from "node:url";
4
4
  //#region src/agents/define_agent.ts
@@ -1522,6 +1522,17 @@ function next_id$5() {
1522
1522
  /**
1523
1523
  * Map an abort reason onto the error a retry rejects with, preserving an
1524
1524
  * `Error` reason verbatim rather than wrapping it in `aborted_error`.
1525
+ *
1526
+ * Core's convention, shared with `timeout`, `parallel`, `map`, the runner's
1527
+ * `throw_if_aborted`, and `bench`: this layer owns the signal chain, so the
1528
+ * cause set upstream has to survive it. Wrapping would turn `timeout`'s
1529
+ * `timeout_error` into an abort, and would flatten the runner's
1530
+ * `aborted_error('received SIGINT')` into a bare 'aborted' that
1531
+ * `runner.ts`'s catch cannot repair, since that repair only fires when the
1532
+ * escaping error is not already an `aborted_error`.
1533
+ *
1534
+ * The engine's retry deliberately does the opposite; `#policy`'s
1535
+ * `AbortErrorFactory` is where the two meet.
1525
1536
  */
1526
1537
  function to_abort_error(reason) {
1527
1538
  return reason instanceof Error ? reason : new aborted_error("aborted", { reason });
@@ -1715,11 +1726,14 @@ register_traced_kind("timeout");
1715
1726
  * `body` call, an optional `guard` step inspects (and may transform) the state
1716
1727
  * and decides whether to stop. When `guard.stop` is true, the loop exits
1717
1728
  * "converged"; otherwise it continues until `max_rounds`. `finish` projects
1718
- * the final state to the loop's output value.
1729
+ * the final state to the loop's output value, and is the loop's only output
1730
+ * channel: `loop` returns `Step<i, o>`, not an envelope around `o`.
1719
1731
  *
1720
- * Non-convergence is data, not error: when `max_rounds` is exhausted without
1721
- * `guard` returning stop, the loop returns `{ value, converged: false, rounds }`,
1722
- * the same convention `adversarial` and `consensus` use.
1732
+ * Non-convergence is data, not error, and `finish` is where that data arrives:
1733
+ * its second argument is the `LoopOutcome` (`{ converged, rounds }`), so a
1734
+ * projection can fold either field into its own result shape, the way
1735
+ * `adversarial` and `consensus` do. A projection that wants the whole outcome
1736
+ * verbatim writes `finish: (state, outcome) => ({ value: state, ...outcome })`.
1723
1737
  *
1724
1738
  * Cancellation: between rounds the parent `ctx.abort` is honored; a pending
1725
1739
  * abort short-circuits and propagates `ctx.abort.reason`. The body and guard
@@ -1739,8 +1753,9 @@ function next_id$2(name) {
1739
1753
  *
1740
1754
  * Threads `state` through up to `max_rounds` runs of `body`, lets the
1741
1755
  * optional `guard` stop early, then projects the final state through
1742
- * `finish`. Returns `{ value, converged, rounds }` so callers can tell a
1743
- * converged run from an exhausted one.
1756
+ * `finish`. `finish` also receives `{ converged, rounds }`, so a projection
1757
+ * can tell a converged run from an exhausted one without the loop wrapping
1758
+ * its output.
1744
1759
  */
1745
1760
  function loop(config) {
1746
1761
  const { init, body, guard, finish, name } = config;
@@ -1764,11 +1779,10 @@ function loop(config) {
1764
1779
  }
1765
1780
  }
1766
1781
  }
1767
- return {
1768
- value: finish(state, round),
1782
+ return finish(state, {
1769
1783
  converged,
1770
1784
  rounds: round
1771
- };
1785
+ });
1772
1786
  };
1773
1787
  const config_meta = { max_rounds: rounds_limit };
1774
1788
  if (name !== void 0) config_meta["display_name"] = name;
@@ -2238,4 +2252,4 @@ function parse_trajectory_event(value) {
2238
2252
  //#endregion
2239
2253
  export { aborted_error as A, map as C, describe as D, sequence as E, flow_schema_default as F, resume_validation_error as M, suspended_error as N, step as O, timeout_error as P, pipe as S, parallel as T, timeout as _, parse_trajectory_event as a, compute_backoff as b, scope as c, suspend as d, format_schema_issues as f, loop as g, compose as h, is_span_start_event as i, describe_cycle_error as j, run as k, stash as l, checkpoint as m, is_emit_event as n, STEP_KINDS as o, validate_schema as p, is_span_end_event as r, is_step_kind as s, is_custom_trajectory_event as t, use as u, fallback as v, branch as w, wait_with_abort as x, retry as y };
2240
2254
 
2241
- //# sourceMappingURL=core-DkuJqLwd.js.map
2255
+ //# sourceMappingURL=core-Ww6An4CS.js.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"core-Ww6An4CS.js","names":["is_step","is_step","next_id","is_step","next_id","next_id","next_id","next_id","is_step","next_id","next_id","next_id","next_id","next_id"],"sources":["../src/core/flow-schema.json","../src/core/cleanup.ts","../src/core/errors.ts","../src/core/streaming.ts","../src/core/runner.ts","../src/core/step.ts","../src/core/is_step.ts","../src/core/describe.ts","../src/core/sequence.ts","../src/core/parallel.ts","../src/core/branch.ts","../src/core/map.ts","../src/core/pipe.ts","../src/policy/backoff.ts","../src/core/retry.ts","../src/core/fallback.ts","../src/core/timeout.ts","../src/core/loop.ts","../src/core/compose.ts","../src/core/checkpoint.ts","../src/schema/validate.ts","../src/core/suspend.ts","../src/core/scope.ts","../src/core/step_kinds.ts","../src/core/trajectory.ts","../src/core/index.ts"],"sourcesContent":["","/**\n * Per-run cleanup registry.\n *\n * Handlers fire in LIFO (reverse registration) order on abort, on uncaught\n * error in the root, and on successful completion. Each handler has a\n * 5-second timeout; timeouts are recorded in the trajectory but do not block\n * other handlers. A handler that throws is recorded as `cleanup_error`;\n * subsequent handlers still execute.\n */\n\nimport type { CleanupFn, TrajectoryLogger } from './types.js'\n\nconst HANDLER_TIMEOUT_MS = 5_000\n\nexport type CleanupRegistry = {\n readonly register: (fn: CleanupFn) => void\n readonly run_all: () => Promise<void>\n}\n\n/**\n * Create the per-run cleanup registry.\n *\n * `register` collects handlers during the run; `run_all` fires them once in\n * LIFO order and is idempotent. A registration arriving after the flush is\n * not executed; it is recorded as `cleanup_registered_after_flush` so the\n * leak is visible in the trajectory instead of silently dropped.\n */\nexport function create_cleanup_registry(trajectory: TrajectoryLogger): CleanupRegistry {\n const handlers: CleanupFn[] = []\n let ran = false\n\n function register(fn: CleanupFn): void {\n if (ran) {\n trajectory.record({\n kind: 'cleanup_registered_after_flush',\n })\n return\n }\n handlers.push(fn)\n }\n\n async function run_all(): Promise<void> {\n if (ran) return\n ran = true\n for (let i = handlers.length - 1; i >= 0; i -= 1) {\n const fn = handlers[i]\n if (!fn) continue\n await run_one(fn, trajectory)\n }\n }\n\n return { register, run_all }\n}\n\n/**\n * Run a single cleanup handler, never letting it fail the run.\n *\n * Races the handler against a 5-second timer. Whichever loses the race only\n * results in a trajectory record (`cleanup_timeout` or `cleanup_error`); the\n * returned promise always resolves so the remaining handlers still execute.\n * A timed-out handler keeps running in the background; it is abandoned, not\n * killed.\n */\nasync function run_one(fn: CleanupFn, trajectory: TrajectoryLogger): Promise<void> {\n let timeout_id: ReturnType<typeof setTimeout> | null = null\n try {\n await new Promise<void>((resolve) => {\n timeout_id = setTimeout(() => {\n trajectory.record({ kind: 'cleanup_timeout', timeout_ms: HANDLER_TIMEOUT_MS })\n resolve()\n }, HANDLER_TIMEOUT_MS)\n \n Promise.resolve()\n .then(() => fn())\n .then(\n () => {\n if (timeout_id) clearTimeout(timeout_id)\n resolve()\n },\n (err: unknown) => {\n if (timeout_id) clearTimeout(timeout_id)\n trajectory.record({\n kind: 'cleanup_error',\n error: err instanceof Error ? err.message : String(err),\n })\n resolve()\n },\n )\n })\n } finally {\n if (timeout_id) clearTimeout(timeout_id)\n }\n}\n","/**\n * Typed errors for the composition layer.\n *\n * This is the only source file in the core layer that uses the `class`\n * keyword. `Error` is a built-in and `instanceof` branching is how composers\n * like `retry` and `fallback` distinguish failure modes.\n */\n\nimport type { SchemaIssue } from '#schema'\n\nexport class timeout_error extends Error {\n readonly kind = 'timeout_error' as const;\n readonly timeout_ms: number;\n constructor(message: string, timeout_ms: number) {\n super(message)\n this.name = 'timeout_error'\n this.timeout_ms = timeout_ms\n }\n}\n\nexport class suspended_error extends Error {\n readonly kind = 'suspended_error' as const;\n readonly suspend_id: string;\n readonly payload: unknown;\n constructor(suspend_id: string, payload: unknown, message?: string) {\n super(message ?? `suspended at ${suspend_id}`)\n this.name = 'suspended_error'\n this.suspend_id = suspend_id\n this.payload = payload\n }\n}\n\nexport class resume_validation_error extends Error {\n readonly kind = 'resume_validation_error' as const;\n readonly issues: ReadonlyArray<SchemaIssue>;\n constructor(message: string, issues: ReadonlyArray<SchemaIssue>) {\n super(message)\n this.name = 'resume_validation_error'\n this.issues = issues\n }\n}\n\nexport class describe_cycle_error extends Error {\n readonly kind = 'describe_cycle_error' as const;\n readonly step_id: string;\n constructor(step_id: string, message?: string) {\n super(message ?? `describe: cycle detected at step id: ${step_id}`)\n this.name = 'describe_cycle_error'\n this.step_id = step_id\n }\n}\n\nexport class aborted_error extends Error {\n readonly kind = 'aborted_error' as const;\n readonly reason?: unknown;\n readonly step_index: number;\n readonly tool_call_in_flight?: { id: string; name: string };\n constructor(\n message = 'aborted',\n metadata: {\n reason?: unknown\n step_index?: number\n tool_call_in_flight?: { id: string; name: string }\n } = {},\n ) {\n super(message)\n this.name = 'aborted_error'\n if (metadata.reason !== undefined) this.reason = metadata.reason\n this.step_index = metadata.step_index ?? 0\n if (metadata.tool_call_in_flight !== undefined) {\n this.tool_call_in_flight = metadata.tool_call_in_flight\n }\n }\n}\n\n/**\n * Control-flow signals are not application failures. `suspended_error` is a\n * human-approval gate pausing the run for later resume; `aborted_error` is\n * cancellation. Resilience composers (`retry`, `fallback`) must rethrow these\n * rather than retry past a suspend or run a backup under an aborted context.\n *\n * Kept internal to core: not re-exported by index.ts, so it does not\n * widen the public surface.\n */\nexport function is_control_flow_error(\n err: unknown,\n): err is suspended_error | aborted_error {\n return err instanceof suspended_error || err instanceof aborted_error\n}\n","/**\n * Streaming observation channel.\n *\n * `run.stream(flow, input)` is a secondary entry point returning\n * `{ events, result }`. Events are observed via an async iterable; the result\n * promise resolves once the flow completes. Streaming is purely\n * observational: composers do not know it exists, and `run` and `run.stream`\n * produce identical final results.\n *\n * The event buffer has a default high-water mark of 10,000. When the consumer\n * never iterates, emissions past the mark drop the oldest events and record a\n * single `events_dropped` marker. The `result` promise resolves regardless of\n * buffer pressure.\n */\n\nimport type { TrajectoryEvent, TrajectoryLogger } from './types.js'\n\nexport const STREAMING_HIGH_WATER_MARK = 10_000\n\nexport type StreamingChannel = {\n readonly logger: TrajectoryLogger\n readonly events: AsyncIterable<TrajectoryEvent>\n readonly close: () => void\n}\n\n/**\n * Build the logger/iterable pair backing `run.stream`.\n *\n * Wraps a base `TrajectoryLogger` so every recorded event is also enqueued\n * for the async iterable. A single pending `waiter` hands events straight to\n * a blocked consumer; otherwise events buffer up to `high_water_mark`, after\n * which the oldest are dropped and counted for the `events_dropped` marker\n * emitted at close.\n */\nexport function create_streaming_channel(\n base: TrajectoryLogger,\n high_water_mark = STREAMING_HIGH_WATER_MARK,\n): StreamingChannel {\n const buffer: TrajectoryEvent[] = []\n let dropped = 0\n let closed = false\n let marker_emitted = false\n let waiter: ((value: IteratorResult<TrajectoryEvent>) => void) | null = null\n\n function enqueue(event: TrajectoryEvent): void {\n if (closed) return\n if (waiter) {\n const resolve = waiter\n waiter = null\n resolve({ value: event, done: false })\n return\n }\n if (buffer.length >= high_water_mark) {\n buffer.shift()\n dropped += 1\n return\n }\n buffer.push(event)\n }\n\n function close(): void {\n if (closed) return\n closed = true\n if (dropped > 0 && !marker_emitted) {\n marker_emitted = true\n buffer.push({ kind: 'events_dropped', count: dropped })\n }\n if (waiter) {\n const resolve = waiter\n waiter = null\n resolve({ value: undefined, done: true })\n }\n }\n\n const logger: TrajectoryLogger = {\n record: (event) => {\n base.record(event)\n enqueue(event)\n },\n start_span: (name, meta) => {\n const id = base.start_span(name, meta)\n enqueue({ kind: 'span_start', span_id: id, name, ...meta })\n return id\n },\n end_span: (id, meta) => {\n base.end_span(id, meta)\n enqueue({ kind: 'span_end', span_id: id, ...meta })\n },\n }\n\n const events: AsyncIterable<TrajectoryEvent> = {\n [Symbol.asyncIterator]() {\n return {\n next(): Promise<IteratorResult<TrajectoryEvent>> {\n if (buffer.length > 0) {\n const next_event = buffer.shift()\n if (next_event !== undefined) {\n return Promise.resolve({ value: next_event, done: false })\n }\n }\n if (closed) {\n return Promise.resolve({ value: undefined, done: true })\n }\n return new Promise<IteratorResult<TrajectoryEvent>>((resolve) => {\n waiter = resolve\n })\n },\n return(): Promise<IteratorResult<TrajectoryEvent>> {\n close()\n return Promise.resolve({ value: undefined, done: true })\n },\n }\n },\n }\n\n return { logger, events, close }\n}\n","/**\n * Runner.\n *\n * Dispatches a step to its kind-specific handler. `runner.ts` contains no\n * composer-specific logic beyond a Map lookup on `step.kind`; each composer\n * file registers its handler at module load via `register_kind(...)`.\n *\n * `run(flow, input, options?)` constructs a fresh `RunContext` per top-level\n * call, installs process signal handlers (opt-out via options), forwards an\n * optional caller-supplied `AbortSignal` into the run, and guarantees cleanup\n * handlers execute in LIFO order on success, failure, or abort.\n *\n * `run.stream(flow, input, options?)` is a secondary entry point returning\n * `{ events, result }`. Streaming is purely observational; the step graph is\n * identical to `run(...)`.\n */\n\nimport { randomUUID } from 'node:crypto'\nimport { create_cleanup_registry } from './cleanup.js'\nimport { aborted_error } from './errors.js'\nimport { create_streaming_channel, STREAMING_HIGH_WATER_MARK } from './streaming.js'\nimport type {\n CheckpointStore,\n RunContext,\n Step,\n TrajectoryEvent,\n TrajectoryLogger,\n} from './types.js'\n\ntype Dispatcher = (\n flow: Step<unknown, unknown>,\n input: unknown,\n ctx: RunContext,\n) => Promise<unknown>\n\nconst dispatch = new Map<string, Dispatcher>()\n\n/**\n * Register the dispatch handler for a step kind.\n *\n * Composer files call this (directly or via `register_traced_kind`) at module\n * load, which is how the runner stays free of composer-specific logic.\n */\nexport function register_kind(kind: string, fn: Dispatcher): void {\n dispatch.set(kind, fn)\n}\n\n/**\n * Resolve the trajectory span label for a step. Prefers a non-empty\n * `display_name` from `flow.config`; otherwise falls back to the supplied\n * default (typically the step's `kind`).\n *\n * Dispatch handlers use this so that any composer carrying a user-supplied\n * `name` surfaces under that label in the trajectory, while unconfigured\n * composers retain their kind-based label.\n */\nexport function resolve_span_label(\n flow: Step<unknown, unknown>,\n fallback: string,\n): string {\n const display = flow.config?.['display_name']\n return typeof display === 'string' && display.length > 0 ? display : fallback\n}\n\n/**\n * Register the standard span-wrapping dispatch handler for a composer kind.\n *\n * Every composer wraps `flow.run` in a span identically; this centralizes that\n * boilerplate and threads span parentage: the span opens with the current\n * `ctx.parent_span_id` as its parent, and `flow.run` receives a child context\n * whose `parent_span_id` is this span. Children dispatched from within\n * (including concurrent ones under `parallel`/`map`, which spread the context)\n * therefore nest correctly instead of leaving `parent_span_id` unpopulated.\n */\nexport function register_traced_kind(kind: string): void {\n register_kind(kind, async (flow, input, ctx) => {\n const label = resolve_span_label(flow, kind)\n const span_meta: Record<string, unknown> = { id: flow.id }\n if (ctx.parent_span_id !== undefined) {\n span_meta['parent_span_id'] = ctx.parent_span_id\n }\n const span_id = ctx.trajectory.start_span(label, span_meta)\n const child_ctx: RunContext = { ...ctx, parent_span_id: span_id }\n try {\n const out = await flow.run(input, child_ctx)\n ctx.trajectory.end_span(span_id, { id: flow.id })\n return out\n } catch (err) {\n ctx.trajectory.end_span(span_id, {\n id: flow.id,\n error: err instanceof Error ? err.message : String(err),\n })\n throw err\n }\n })\n}\n\nexport type RunOptions = {\n readonly install_signal_handlers?: boolean\n readonly trajectory?: TrajectoryLogger\n readonly checkpoint_store?: CheckpointStore\n readonly resume_data?: Readonly<Record<string, unknown>>\n // A caller-owned cancellation source (HTTP request, queue shutdown, MCP\n // request, AbortSignal.timeout). When it fires the run aborts with its\n // reason, composing with the internal controller and the process signal\n // handlers rather than replacing them.\n readonly abort?: AbortSignal\n}\n\nexport type StreamingRunHandle<o> = {\n readonly events: AsyncIterable<TrajectoryEvent>\n readonly result: Promise<o>\n}\n\nconst active_runs = new Set<AbortController>()\nlet signal_handler_installed = false\nlet sigint_handler: (() => void) | null = null\nlet sigterm_handler: (() => void) | null = null\n\n/**\n * Install process-wide SIGINT/SIGTERM handlers once.\n *\n * The handlers abort every active run with an `aborted_error` naming the\n * signal, so a Ctrl-C tears down all in-flight flows through the normal\n * abort/cleanup path instead of killing the process mid-step.\n */\nfunction ensure_signal_handlers(): void {\n if (signal_handler_installed) return\n signal_handler_installed = true\n const abort_all = (signal_name: string) => () => {\n for (const controller of active_runs) {\n controller.abort(new aborted_error(`received ${signal_name}`, { reason: { signal: signal_name } }))\n }\n }\n sigint_handler = abort_all('SIGINT')\n sigterm_handler = abort_all('SIGTERM')\n process.on('SIGINT', sigint_handler)\n process.on('SIGTERM', sigterm_handler)\n}\n\n/**\n * Remove the process signal handlers once the last active run settles.\n *\n * Keeps a library embed from leaving stray `process.on` listeners behind\n * after all runs complete.\n */\nfunction release_signal_handlers(): void {\n if (!signal_handler_installed) return\n if (active_runs.size > 0) return\n signal_handler_installed = false\n if (sigint_handler) process.off('SIGINT', sigint_handler)\n if (sigterm_handler) process.off('SIGTERM', sigterm_handler)\n sigint_handler = null\n sigterm_handler = null\n}\n\nconst noop_logger: TrajectoryLogger = {\n record: () => {},\n start_span: (name) => `${name}:${randomUUID().slice(0, 8)}`,\n end_span: () => {},\n}\n\n/**\n * Wrap a logger so every emitted event automatically carries `run_id` and a\n * `ts` (epoch milliseconds) stamped at emission.\n *\n * Studios and other downstream consumers multiplex events across runs by\n * `run_id` and reconstruct real timing from `ts` instead of fabricating it at\n * ingest. Either field already present on an event or its meta is preserved;\n * we never overwrite a caller-supplied value.\n */\nfunction decorate_logger(inner: TrajectoryLogger, run_id: string): TrajectoryLogger {\n const stamp_meta = (\n meta: Record<string, unknown> | undefined,\n ): Record<string, unknown> => {\n const out: Record<string, unknown> = { ...meta }\n if (!('run_id' in out)) out['run_id'] = run_id\n if (!('ts' in out)) out['ts'] = Date.now()\n return out\n }\n return {\n record: (event) => {\n if ('run_id' in event && 'ts' in event) {\n inner.record(event)\n return\n }\n const extra: Record<string, unknown> = {}\n if (!('run_id' in event)) extra['run_id'] = run_id\n if (!('ts' in event)) extra['ts'] = Date.now()\n inner.record({ ...event, ...extra })\n },\n start_span: (name, meta) => inner.start_span(name, stamp_meta(meta)),\n end_span: (id, meta) => {\n inner.end_span(id, stamp_meta(meta))\n },\n }\n}\n\n/**\n * Route a step to its registered kind handler.\n *\n * This is the single entry point composers use to run children. On failure\n * the step's id is prepended to the error's `path`, so an error surfacing\n * from a deep tree carries the chain of step ids it crossed.\n */\nexport async function dispatch_step<i, o>(\n flow: Step<i, o>,\n input: i,\n ctx: RunContext,\n): Promise<o> {\n const handler = dispatch.get(flow.kind)\n if (!handler) {\n throw new Error(`unknown step kind: ${flow.kind} (step id: ${flow.id})`)\n }\n try {\n const result = await handler(flow, input, ctx)\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n return result as o\n } catch (err) {\n prepend_path(err, flow.id)\n throw err\n }\n}\n\n/**\n * Prepend a step id to the `path` array carried on an error object.\n *\n * Mutates the error in place so the path accumulates as the error bubbles up\n * through nested dispatches. Non-object errors are left untouched.\n */\nexport function prepend_path(err: unknown, id: string): void {\n if (err === null || typeof err !== 'object') return\n const existing = Reflect.get(err, 'path')\n const next: string[] = Array.isArray(existing)\n ? [id, ...existing.filter((v): v is string => typeof v === 'string')]\n : [id]\n Reflect.set(err, 'path', next)\n}\n\n/**\n * Throw the abort reason if the context has been cancelled. Composers that\n * iterate over children (`sequence`, `scope`, `loop`) call this between steps\n * so a pending abort is honored before the next child starts, not only when a\n * downstream dispatch happens to observe it.\n */\nexport function throw_if_aborted(ctx: RunContext): void {\n if (!ctx.abort.aborted) return\n const reason = ctx.abort.reason\n throw reason instanceof Error ? reason : new aborted_error('aborted', { reason })\n}\n\n/**\n * Forward a caller-owned AbortSignal into the run's internal controller and\n * return an unlink function. The reason is preserved so the original\n * cancellation cause propagates out of `run`. The listener is `once` and the\n * returned unlink is called when the run settles, so a long-lived host (an MCP\n * server, an HTTP worker) firing many short runs against one external signal\n * does not accumulate listeners.\n */\nfunction link_external_abort(\n controller: AbortController,\n external: AbortSignal | undefined,\n): () => void {\n if (external === undefined) return () => {}\n if (external.aborted) {\n controller.abort(external.reason)\n return () => {}\n }\n const on_abort = (): void => {\n controller.abort(external.reason)\n }\n external.addEventListener('abort', on_abort, { once: true })\n return () => {\n external.removeEventListener('abort', on_abort)\n }\n}\n\ntype StartResult<o> = {\n readonly events: AsyncIterable<TrajectoryEvent>\n readonly result: Promise<o>\n}\n\n/**\n * Construct a run context and execute a flow to settlement.\n *\n * Shared engine behind `run` and `run.stream`; `high_water_mark` selects the\n * mode (null means no streaming channel). Owns the full run lifecycle:\n * abort wiring, logger decoration, cleanup registration, signal handlers,\n * and the settle-time teardown ordering (cleanup handlers first, then\n * unlinking and stream close).\n */\nfunction start_run<i, o>(\n flow: Step<i, o>,\n input: i,\n options: RunOptions,\n high_water_mark: number | null,\n): StartResult<o> {\n const install_signal_handlers = options.install_signal_handlers !== false\n const base_logger = options.trajectory ?? noop_logger\n const streaming = high_water_mark !== null\n\n const controller = new AbortController()\n const unlink_abort = link_external_abort(controller, options.abort)\n const run_id = randomUUID()\n\n let stream_events: AsyncIterable<TrajectoryEvent> = empty_async_iterable()\n let close_stream: (() => void) | null = null\n let inner: TrajectoryLogger = base_logger\n\n if (streaming) {\n // Decorate must wrap the streaming channel, not the reverse: the channel\n // enqueues a copy of each event for `run.stream` consumers, so it has to\n // see the events after `decorate_logger` has stamped `ts` and `run_id`.\n const channel = create_streaming_channel(base_logger, high_water_mark)\n inner = channel.logger\n stream_events = channel.events\n close_stream = channel.close\n }\n\n const logger: TrajectoryLogger = decorate_logger(inner, run_id)\n\n const cleanup = create_cleanup_registry(logger)\n\n const ctx: RunContext = {\n run_id,\n trajectory: logger,\n state: new Map(),\n abort: controller.signal,\n emit: (event) => {\n logger.record({ ...event, kind: 'emit' })\n },\n on_cleanup: (fn) => {\n cleanup.register(fn)\n },\n checkpoint_store: options.checkpoint_store,\n resume_data: options.resume_data,\n streaming,\n }\n\n active_runs.add(controller)\n if (install_signal_handlers) {\n ensure_signal_handlers()\n }\n\n const result = (async (): Promise<o> => {\n try {\n // Honor an external signal that was already aborted at call time, so the\n // run rejects without dispatching even when the flow is a single leaf\n // step that never reaches a cooperative abort check.\n throw_if_aborted(ctx)\n return await dispatch_step(flow, input, ctx)\n } catch (err) {\n if (controller.signal.aborted && !(err instanceof aborted_error)) {\n const reason = controller.signal.reason\n if (reason instanceof aborted_error) throw reason\n }\n throw err\n } finally {\n try {\n await cleanup.run_all()\n } finally {\n unlink_abort()\n active_runs.delete(controller)\n release_signal_handlers()\n if (close_stream) close_stream()\n }\n }\n })()\n\n return { events: stream_events, result }\n}\n\n/**\n * Build an async iterable that is immediately done.\n *\n * Non-streaming runs hand this to callers so the `events` field always has\n * the same shape regardless of mode.\n */\nfunction empty_async_iterable(): AsyncIterable<TrajectoryEvent> {\n return {\n [Symbol.asyncIterator]() {\n return {\n next: (): Promise<IteratorResult<TrajectoryEvent>> =>\n Promise.resolve({ value: undefined, done: true } as IteratorResult<TrajectoryEvent>),\n }\n },\n }\n}\n\n/**\n * Execute a flow and resolve with its final output.\n */\nasync function run_impl<i, o>(\n flow: Step<i, o>,\n input: i,\n options: RunOptions = {},\n): Promise<o> {\n const { result } = start_run(flow, input, options, null)\n return result\n}\n\n/**\n * Execute a flow while exposing its trajectory events as an async iterable.\n */\nfunction run_stream<i, o>(\n flow: Step<i, o>,\n input: i,\n options: RunOptions = {},\n): StreamingRunHandle<o> {\n const { events, result } = start_run(flow, input, options, STREAMING_HIGH_WATER_MARK)\n return { events, result }\n}\n\n/**\n * The public entry point for executing a flow.\n *\n * Callable as `run(flow, input, options?)` for a plain result, or\n * `run.stream(flow, input, options?)` for `{ events, result }`. Both share\n * one implementation, so a streamed run and a plain run of the same flow\n * produce identical output.\n */\nexport const run: typeof run_impl & { stream: typeof run_stream } = Object.assign(run_impl, {\n stream: run_stream,\n})\n","/**\n * step() factory.\n *\n * Three forms:\n * step(id, fn): named step. id is rendered in trajectory spans and describe().\n * step(id, fn, meta): named step with optional human-readable metadata for studio,\n * codegen, and similar consumers. `meta` is purely descriptive\n * and never affects runtime semantics.\n * step(fn): anonymous step. id is `anon_<counter>`; cannot be checkpointed.\n *\n * Anonymous steps carry an internal `anonymous: true` flag so checkpoint can\n * reject them synchronously at flow construction time.\n */\n\nimport { register_traced_kind } from './runner.js'\nimport type { Step, StepFn, StepMetadata } from './types.js'\n\nlet anon_counter = 0\n\n/**\n * Generate a unique id of the form `anon_<n>` for anonymous steps.\n */\nfunction next_anon_id(): string {\n anon_counter += 1\n return `anon_${anon_counter}`\n}\n\n/**\n * Wrap a plain function as a `Step`, named or anonymous.\n *\n * The named form takes an explicit id (and optional descriptive `meta`); the\n * anonymous form generates an `anon_<n>` id and marks the step so checkpoint\n * rejects it at construction time.\n */\nexport function step<i, o>(id: string, fn: StepFn<i, o>, meta?: StepMetadata): Step<i, o>\nexport function step<i, o>(fn: StepFn<i, o>): Step<i, o>\nexport function step<i, o>(\n id_or_fn: string | StepFn<i, o>,\n maybe_fn?: StepFn<i, o>,\n meta?: StepMetadata,\n): Step<i, o> {\n if (typeof id_or_fn === 'function') {\n return {\n id: next_anon_id(),\n kind: 'step',\n run: id_or_fn,\n anonymous: true,\n }\n }\n if (typeof maybe_fn !== 'function') {\n throw new TypeError('step(id, fn): fn must be a function')\n }\n if (meta) {\n return {\n id: id_or_fn,\n kind: 'step',\n run: maybe_fn,\n meta,\n }\n }\n return {\n id: id_or_fn,\n kind: 'step',\n run: maybe_fn,\n }\n}\n\nregister_traced_kind('step')\n","/**\n * is_step: structural Step check.\n *\n * Steps are plain objects with no brand symbol, so runtime detection is\n * structural: string `id`, string `kind`, callable `run`. Used by describe()\n * to render Step references and by combinators to validate arguments at\n * construction time.\n */\n\nimport type { Step } from './types.js'\n\n/**\n * Check whether a value is structurally a `Step`.\n *\n * True when the value has a string `id`, a string `kind`, and a callable\n * `run`.\n */\nexport function is_step(value: unknown): value is Step<unknown, unknown> {\n if (typeof value !== 'object' || value === null) return false\n if (!('id' in value) || !('kind' in value) || !('run' in value)) return false\n const { id, kind, run } = value\n return typeof id === 'string' && typeof kind === 'string' && typeof run === 'function'\n}\n","/**\n * describe(step) and describe.json(step): composition introspection.\n *\n * `describe(step)` is the text-tree renderer. Multi-line string with\n * hierarchical indentation. Function values render as `<fn>` (or\n * `<fn:name>` when the function has a non-empty `name`); zod schemas\n * render as `<schema>`.\n *\n * `describe.json(step)` returns a `FlowNode` tree (kind, id, config, children)\n * for tooling (Studio UI, Mermaid renderers, diff tools). Function values\n * serialize as `{ kind: '<fn>', name? }` and schemas as `{ kind: '<schema>' }`.\n *\n * Both forms detect cycles. Under the default (loose) mode, back-references\n * render as `<cycle>(id)` in text and `{ kind: '<cycle>', id }` in JSON. Under\n * `{ strict: true }`, cycles throw `describe_cycle_error`.\n */\n\nimport { describe_cycle_error } from './errors.js'\nimport { is_step } from './is_step.js'\nimport type { Step, StepMetadata } from './types.js'\n\nconst INDENT = ' '\n\nexport type FlowValue =\n | string\n | number\n | boolean\n | null\n | ReadonlyArray<FlowValue>\n | Readonly<{ [key: string]: FlowValue }>\n | { readonly kind: '<fn>'; readonly name?: string }\n | { readonly kind: '<schema>' }\n | { readonly kind: string; readonly id: string }\n\nexport type FlowNode = {\n readonly kind: string\n readonly id: string\n readonly config?: Readonly<{ [key: string]: FlowValue }>\n readonly children?: ReadonlyArray<FlowNode>\n readonly meta?: StepMetadata\n}\n\nexport type DescribeOptions = {\n readonly strict?: boolean\n}\n\ntype Path = Set<Step<unknown, unknown>>\n\n/**\n * Render a step tree as an indented multi-line string.\n */\nfunction describe_text<i, o>(root: Step<i, o>, options?: DescribeOptions): string {\n const lines: string[] = []\n const strict = Boolean(options?.strict)\n render_text(root, 0, lines, new Set(), strict)\n return lines.join('\\n')\n}\n\n/**\n * Render a step tree as a serializable `FlowNode` tree.\n */\nfunction describe_json<i, o>(root: Step<i, o>, options?: DescribeOptions): FlowNode {\n const strict = Boolean(options?.strict)\n return render_json(root, new Set(), strict)\n}\n\n/**\n * Public entry point: `describe(step)` for text, `describe.json(step)` for\n * the `FlowNode` tree.\n */\nexport const describe: {\n <i, o>(root: Step<i, o>, options?: DescribeOptions): string\n json: <i, o>(root: Step<i, o>, options?: DescribeOptions) => FlowNode\n} = Object.assign(describe_text, { json: describe_json })\n\n/**\n * Append one node (label line, config lines, then children) to `lines`.\n *\n * `path` holds the steps on the current root-to-node path for cycle\n * detection; membership is added before recursing and removed in a `finally`\n * so shared (diamond) references are not misreported as cycles.\n */\nfunction render_text(\n node: Step<unknown, unknown>,\n depth: number,\n lines: string[],\n path: Path,\n strict: boolean,\n): void {\n const prefix = INDENT.repeat(depth)\n if (path.has(node)) {\n if (strict) throw new describe_cycle_error(node.id)\n lines.push(`${prefix}<cycle>(${node.id})`)\n return\n }\n path.add(node)\n try {\n const display = node.config?.['display_name']\n const label = typeof display === 'string' && display.length > 0 ? display : node.kind\n lines.push(`${prefix}${label}(${node.id})`)\n if (node.config) {\n for (const [key, value] of Object.entries(node.config)) {\n if (key === 'display_name') continue\n lines.push(`${prefix}${INDENT}${key}: ${render_value_text(value, path, strict)}`)\n }\n }\n if (node.children && node.children.length > 0) {\n for (const child of node.children) {\n render_text(child, depth + 1, lines, path, strict)\n }\n }\n } finally {\n path.delete(node)\n }\n}\n\n/**\n * Render a single config value for the text tree.\n *\n * Functions become `<fn>` or `<fn:name>`, zod schemas `<schema>`, and Step\n * references `kind(id)`; arrays and plain objects recurse. Strings are\n * JSON-quoted so empty and whitespace values stay visible.\n */\nfunction render_value_text(value: unknown, path: Path, strict: boolean): string {\n if (typeof value === 'function') {\n const name = typeof value.name === 'string' && value.name.length > 0 ? value.name : ''\n return name ? `<fn:${name}>` : '<fn>'\n }\n if (value === null) return 'null'\n if (value === undefined) return 'undefined'\n if (is_zod_schema(value)) return '<schema>'\n if (is_step(value)) {\n if (path.has(value)) {\n if (strict) throw new describe_cycle_error(value.id)\n return `<cycle>(${value.id})`\n }\n return `${value.kind}(${value.id})`\n }\n if (Array.isArray(value)) {\n return `[${value.map((item: unknown) => render_value_text(item, path, strict)).join(', ')}]`\n }\n if (typeof value === 'object') {\n const entries = Object.entries({ ...value }).map(\n ([k, v]: [string, unknown]) => `${k}: ${render_value_text(v, path, strict)}`,\n )\n return `{ ${entries.join(', ')} }`\n }\n if (typeof value === 'string') return JSON.stringify(value)\n if (typeof value === 'bigint') return `${value.toString()}n`\n if (typeof value === 'symbol') return value.toString()\n if (typeof value === 'number' || typeof value === 'boolean') return String(value)\n return JSON.stringify(value)\n}\n\n/**\n * Convert one step node to a `FlowNode`, recursing into config and children.\n *\n * Uses the same path-based cycle detection as `render_text`: back-references\n * become `{ kind: '<cycle>', id }` in loose mode and throw in strict mode.\n */\nfunction render_json(\n node: Step<unknown, unknown>,\n path: Path,\n strict: boolean,\n): FlowNode {\n if (path.has(node)) {\n if (strict) throw new describe_cycle_error(node.id)\n return { kind: '<cycle>', id: node.id }\n }\n path.add(node)\n try {\n const result: {\n kind: string\n id: string\n config?: { [key: string]: FlowValue }\n children?: FlowNode[]\n meta?: StepMetadata\n } = { kind: node.kind, id: node.id }\n if (node.config) {\n const config: { [key: string]: FlowValue } = {}\n for (const [key, value] of Object.entries(node.config)) {\n config[key] = render_value_json(value, path, strict)\n }\n result.config = config\n }\n if (node.children && node.children.length > 0) {\n result.children = node.children.map((child) => render_json(child, path, strict))\n }\n if (node.meta) {\n result.meta = node.meta\n }\n return result\n } finally {\n path.delete(node)\n }\n}\n\n/**\n * Convert a single config value to a JSON-safe `FlowValue`.\n *\n * Functions serialize as `{ kind: '<fn>', name? }`, schemas as\n * `{ kind: '<schema>' }`, Step references as `{ kind, id }`. `undefined`\n * maps to `null` and bigints/symbols to strings so the result survives\n * `JSON.stringify` without loss.\n */\nfunction render_value_json(value: unknown, path: Path, strict: boolean): FlowValue {\n if (typeof value === 'function') {\n const name = typeof value.name === 'string' && value.name.length > 0 ? value.name : ''\n return name ? { kind: '<fn>', name } : { kind: '<fn>' }\n }\n if (value === null) return null\n if (value === undefined) return null\n if (is_zod_schema(value)) return { kind: '<schema>' }\n if (is_step(value)) {\n if (path.has(value)) {\n if (strict) throw new describe_cycle_error(value.id)\n return { kind: '<cycle>', id: value.id }\n }\n return { kind: value.kind, id: value.id }\n }\n if (Array.isArray(value)) {\n return value.map((item: unknown) => render_value_json(item, path, strict))\n }\n if (typeof value === 'object') {\n const out: { [key: string]: FlowValue } = {}\n for (const [k, v] of Object.entries({ ...value })) {\n out[k] = render_value_json(v, path, strict)\n }\n return out\n }\n if (typeof value === 'string') return value\n if (typeof value === 'number' || typeof value === 'boolean') return value\n if (typeof value === 'bigint') return `${value.toString()}n`\n if (typeof value === 'symbol') return value.toString()\n return JSON.stringify(value)\n}\n\n/**\n * Detect a zod schema by its internal marker properties (`_zod` in zod 4,\n * `_def` in zod 3) without importing zod.\n */\nfunction is_zod_schema(value: unknown): boolean {\n if (typeof value !== 'object' || value === null) return false\n return '_zod' in value || '_def' in value\n}\n","/**\n * sequence: chain child outputs.\n *\n * `sequence([a, b, c])` runs a, b, c in declared order. The input to sequence\n * is passed to the first child; each subsequent child receives the previous\n * child's output. The composer returns the last child's output.\n */\n\nimport { is_step } from './is_step.js'\nimport { dispatch_step, register_traced_kind, throw_if_aborted } from './runner.js'\nimport type { RunContext, Step } from './types.js'\n\ntype AnyStep = Step<unknown, unknown>\n\ntype FirstInput<children> = children extends readonly [Step<infer i, unknown>, ...unknown[]]\n ? i\n : unknown\n\ntype LastOutput<children> = children extends readonly [...unknown[], Step<unknown, infer o>]\n ? o\n : children extends readonly [Step<unknown, infer o>]\n ? o\n : unknown\n\nlet sequence_counter = 0\n\n/**\n * Generate a unique step id of the form `sequence_<n>`.\n */\nfunction next_id(): string {\n sequence_counter += 1\n return `sequence_${sequence_counter}`\n}\n\nexport type SequenceOptions = {\n readonly name?: string\n}\n\n/**\n * Build a step that chains children, each feeding the next.\n *\n * Validates every element up front so a non-Step (usually a bare function)\n * fails at construction with a pointed message rather than at run time.\n * Checks `ctx.abort` before each child so aborts land on step boundaries.\n */\nexport function sequence<const children extends readonly AnyStep[]>(\n children: children,\n options?: SequenceOptions,\n): Step<FirstInput<children>, LastOutput<children>> {\n if (!Array.isArray(children)) {\n throw new TypeError(\n `sequence(children): children must be an array of Steps, got ${typeof children} — sequence takes a single array, e.g. sequence([a, b, c])`,\n )\n }\n children.forEach((child, index) => {\n if (is_step(child)) return\n const hint =\n typeof child === 'function'\n ? ' — wrap plain functions with step(fn), or use pipe(inner, fn) to transform output'\n : ''\n throw new TypeError(\n `sequence(children): children[${index}] is not a Step, got ${typeof child}${hint}`,\n )\n })\n\n const id = next_id()\n const children_ref = children\n const run_fn = async (input: unknown, ctx: RunContext): Promise<unknown> => {\n let acc: unknown = input\n for (const child of children_ref) {\n throw_if_aborted(ctx)\n acc = await dispatch_step(child, acc, ctx)\n }\n return acc\n }\n\n const config_meta: Record<string, unknown> | undefined =\n options?.name === undefined ? undefined : { display_name: options.name }\n\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n return {\n id,\n kind: 'sequence',\n children,\n ...(config_meta ? { config: config_meta } : {}),\n run: run_fn,\n } as Step<FirstInput<children>, LastOutput<children>>\n}\n\nregister_traced_kind('sequence')\n","/**\n * parallel: concurrent execution of named children.\n *\n * `parallel({ a, b })` runs a and b concurrently with the same input. Output\n * is an object keyed by the child name; all children must accept the same\n * input type.\n *\n * Cancellation: each child runs with a composed abort signal,\n * `AbortSignal.any([ctx.abort, child_local])`. On abort the composer awaits\n * all in-flight children (success, failure, or aborted) before rethrowing\n * `ctx.abort.reason`.\n *\n * When several children fail, a `suspended_error` is preferred over an\n * application error so a human-approval gate inside a branch stays resumable\n * rather than being masked by a sibling's failure. Otherwise the first error\n * in declared order propagates.\n */\n\nimport { aborted_error, suspended_error } from './errors.js'\nimport { dispatch_step, register_traced_kind } from './runner.js'\nimport type { RunContext, Step } from './types.js'\n\ntype AnyStep = Step<unknown, unknown>\n\ntype OutputOf<s> = s extends Step<unknown, infer o> ? o : unknown\n\ntype ParallelOutputs<children extends Record<string, AnyStep>> = {\n [k in keyof children]: OutputOf<children[k]>\n}\n\nlet parallel_counter = 0\n\n/**\n * Generate a unique step id of the form `parallel_<n>`.\n */\nfunction next_id(): string {\n parallel_counter += 1\n return `parallel_${parallel_counter}`\n}\n\nexport type ParallelOptions = {\n readonly name?: string\n}\n\n/**\n * Build a step that runs named children concurrently on the same input.\n *\n * Returns an object keyed by child name. All children settle before any\n * error propagates; a `suspended_error` wins over application errors so a\n * human-approval gate stays resumable instead of being masked by a sibling's\n * failure.\n */\nexport function parallel<i, children extends Record<string, Step<i, unknown>>>(\n members: children,\n options?: ParallelOptions,\n): Step<i, ParallelOutputs<children>> {\n const id = next_id()\n const entries: ReadonlyArray<readonly [string, AnyStep]> = Object.entries(members)\n const child_list: ReadonlyArray<AnyStep> = entries.map(([, s]) => s)\n const keys: ReadonlyArray<string> = entries.map(([k]) => k)\n\n const run_fn = async (input: i, ctx: RunContext): Promise<ParallelOutputs<children>> => {\n const controllers = entries.map(() => new AbortController())\n const on_parent_abort = (): void => {\n for (const c of controllers) c.abort(ctx.abort.reason)\n }\n if (ctx.abort.aborted) {\n on_parent_abort()\n } else {\n ctx.abort.addEventListener('abort', on_parent_abort, { once: true })\n }\n \n try {\n const settled = await Promise.all(\n entries.map(async ([key, child], idx) => {\n const local = controllers[idx]\n if (!local) throw new Error('parallel: missing controller')\n const composed = AbortSignal.any([ctx.abort, local.signal])\n const child_ctx: RunContext = { ...ctx, abort: composed }\n try {\n const value = await dispatch_step(child, input, child_ctx)\n return { status: 'ok' as const, key, value }\n } catch (err) {\n return { status: 'err' as const, key, err }\n }\n }),\n )\n \n if (ctx.abort.aborted) {\n const reason = ctx.abort.reason\n throw reason instanceof Error ? reason : new aborted_error('aborted', { reason })\n }\n\n let first_err: unknown\n let has_err = false\n let suspended: unknown\n let has_suspended = false\n for (const s of settled) {\n if (s.status !== 'err') continue\n if (!has_err) {\n first_err = s.err\n has_err = true\n }\n if (!has_suspended && s.err instanceof suspended_error) {\n suspended = s.err\n has_suspended = true\n }\n }\n if (has_suspended) throw suspended\n if (has_err) throw first_err\n \n const out: Record<string, unknown> = {}\n for (const s of settled) {\n if (s.status === 'ok') out[s.key] = s.value\n }\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n return out as ParallelOutputs<children>\n } finally {\n ctx.abort.removeEventListener('abort', on_parent_abort)\n }\n }\n\n const config_meta: Record<string, unknown> = { keys }\n if (options?.name !== undefined) config_meta['display_name'] = options.name\n\n return {\n id,\n kind: 'parallel',\n children: child_list,\n config: config_meta,\n run: run_fn,\n }\n}\n\nregister_traced_kind('parallel')\n","/**\n * branch: conditional routing.\n *\n * `branch({ when, then, otherwise })` evaluates `when(input)`; if truthy, runs\n * `then`, else runs `otherwise`. Both branches must return the same output\n * type.\n */\n\nimport { dispatch_step, register_traced_kind } from './runner.js'\nimport type { RunContext, Step } from './types.js'\n\nexport type BranchConfig<i, o> = {\n readonly name?: string\n readonly when: (input: i) => boolean | Promise<boolean>\n readonly then: Step<i, o>\n readonly otherwise: Step<i, o>\n}\n\nlet branch_counter = 0\n\n/**\n * Generate a unique step id of the form `branch_<n>`.\n */\nfunction next_id(): string {\n branch_counter += 1\n return `branch_${branch_counter}`\n}\n\n/**\n * Build a conditional-routing step.\n *\n * Evaluates `when(input)` at run time and dispatches to `then` or `otherwise`.\n * Both branches appear as children so `describe()` renders the full tree even\n * though only one branch runs.\n */\nexport function branch<i, o>(config: BranchConfig<i, o>): Step<i, o> {\n const id = next_id()\n const { when, then: then_step, otherwise: otherwise_step, name } = config\n\n const run_fn = async (input: i, ctx: RunContext): Promise<o> => {\n const cond = await when(input)\n const next_step = cond ? then_step : otherwise_step\n return dispatch_step(next_step, input, ctx)\n }\n\n const config_meta: Record<string, unknown> = { when, then: then_step, otherwise: otherwise_step }\n if (name !== undefined) config_meta['display_name'] = name\n\n return {\n id,\n kind: 'branch',\n children: [then_step, otherwise_step],\n config: config_meta,\n run: run_fn,\n }\n}\n\nregister_traced_kind('branch')\n","/**\n * map: per-item execution.\n *\n * `map({ items, do, concurrency? })` extracts an array via `items(input)`,\n * runs `do` once per element, returns an array in the same order as inputs.\n * `concurrency` caps simultaneous in-flight items; omitted means full\n * parallelism.\n *\n * Cancellation: each in-flight item runs with a composed abort signal via\n * `AbortSignal.any([ctx.abort, child_local])`.\n * On abort no new items start. The composer awaits all in-flight items before\n * rethrowing `ctx.abort.reason`.\n */\n\nimport { aborted_error } from './errors.js'\nimport { dispatch_step, register_traced_kind } from './runner.js'\nimport type { RunContext, Step } from './types.js'\n\nexport type MapConfig<input, item, result> = {\n readonly name?: string\n readonly items: (input: input) => ReadonlyArray<item> | Promise<ReadonlyArray<item>>\n readonly do: Step<item, result>\n readonly concurrency?: number\n}\n\nlet map_counter = 0\n\n/**\n * Generate a unique step id of the form `map_<n>`.\n */\nfunction next_id(): string {\n map_counter += 1\n return `map_${map_counter}`\n}\n\n/**\n * Build a per-item execution step.\n *\n * Extracts an array via `items(input)`, runs `do` once per element through a\n * bounded worker pool, and returns results in input order. The first item\n * failure stops new work and propagates after in-flight items settle.\n */\nexport function map<input, item, result>(\n config: MapConfig<input, item, result>,\n): Step<input, result[]> {\n const id = next_id()\n const { items, do: per_item, concurrency, name } = config\n\n const run_fn = async (input: input, ctx: RunContext): Promise<result[]> => {\n const list = await items(input)\n if (list.length === 0) return []\n const results: result[] = Array.from({ length: list.length })\n \n const limit = concurrency === undefined ? list.length : Math.max(1, concurrency)\n const controllers: AbortController[] = []\n \n const on_parent_abort = (): void => {\n for (const c of controllers) c.abort(ctx.abort.reason)\n }\n if (ctx.abort.aborted) {\n on_parent_abort()\n } else {\n ctx.abort.addEventListener('abort', on_parent_abort, { once: true })\n }\n \n let cursor = 0\n let worker_error: unknown = undefined\n \n const run_one = async (idx: number): Promise<void> => {\n const local = new AbortController()\n controllers.push(local)\n const composed = AbortSignal.any([ctx.abort, local.signal])\n const child_ctx: RunContext = { ...ctx, abort: composed }\n const item_value = list[idx]\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n const value = await dispatch_step(per_item, item_value as item, child_ctx)\n results[idx] = value\n }\n \n const worker = async (): Promise<void> => {\n while (true) {\n if (ctx.abort.aborted || worker_error !== undefined) return\n const idx = cursor\n cursor += 1\n if (idx >= list.length) return\n try {\n await run_one(idx)\n } catch (err) {\n if (worker_error === undefined) worker_error = err\n return\n }\n }\n }\n \n try {\n const worker_count = Math.min(limit, list.length)\n const workers: Promise<void>[] = []\n for (let w = 0; w < worker_count; w += 1) {\n workers.push(worker())\n }\n await Promise.all(workers)\n \n if (ctx.abort.aborted) {\n const reason = ctx.abort.reason\n throw reason instanceof Error ? reason : new aborted_error('aborted', { reason })\n }\n if (worker_error !== undefined) throw worker_error\n \n return results\n } finally {\n ctx.abort.removeEventListener('abort', on_parent_abort)\n }\n }\n\n const config_meta: Record<string, unknown> = { items }\n if (concurrency !== undefined) config_meta['concurrency'] = concurrency\n if (name !== undefined) config_meta['display_name'] = name\n\n return {\n id,\n kind: 'map',\n children: [per_item],\n config: config_meta,\n run: run_fn,\n }\n}\n\nregister_traced_kind('map')\n","/**\n * pipe: transform output.\n *\n * `pipe(inner, fn)` runs `inner`, passes its output to `fn`, returns `fn`'s\n * result. Use for shape adaptation when composing heterogeneous steps.\n */\n\nimport { is_step } from './is_step.js'\nimport { dispatch_step, register_traced_kind } from './runner.js'\nimport type { RunContext, Step } from './types.js'\n\nlet pipe_counter = 0\n\n/**\n * Generate a unique step id of the form `pipe_<n>`.\n */\nfunction next_id(): string {\n pipe_counter += 1\n return `pipe_${pipe_counter}`\n}\n\nexport type PipeOptions = {\n readonly name?: string\n}\n\n/**\n * Build an output-transforming step around `inner`.\n *\n * The argument checks reject Steps passed where functions belong: `pipe` is\n * not variadic, and the early `TypeError`s point misuse at `step(fn)` or\n * `sequence([...])` instead of failing obscurely at run time.\n */\nexport function pipe<i, a, b>(\n inner: Step<i, a>,\n fn: (value: a) => b | Promise<b>,\n options?: PipeOptions,\n): Step<i, b> {\n if (!is_step(inner)) {\n const hint = typeof inner === 'function' ? ' — wrap plain functions with step(fn)' : ''\n throw new TypeError(`pipe(inner, fn): inner must be a Step, got ${typeof inner}${hint}`)\n }\n if (typeof fn !== 'function') {\n if (is_step(fn)) {\n throw new TypeError(\n 'pipe(inner, fn): fn must be a function, got a Step — pipe is not variadic; to chain Steps use sequence([...])',\n )\n }\n throw new TypeError(`pipe(inner, fn): fn must be a function, got ${typeof fn}`)\n }\n if (is_step(options)) {\n throw new TypeError(\n 'pipe(inner, fn, options): got a Step as the third argument — pipe is not variadic; to chain Steps use sequence([...])',\n )\n }\n\n const id = next_id()\n\n const run_fn = async (input: i, ctx: RunContext): Promise<b> => {\n const intermediate = await dispatch_step(inner, input, ctx)\n return fn(intermediate)\n }\n\n const config_meta: Record<string, unknown> = { fn }\n if (options?.name !== undefined) config_meta['display_name'] = options.name\n\n return {\n id,\n kind: 'pipe',\n children: [inner],\n config: config_meta,\n run: run_fn,\n }\n}\n\nregister_traced_kind('pipe')\n","/**\n * The backoff algebra shared by the composition layer and the engine.\n *\n * Both retry layers schedule delays between attempts, and each used to carry\n * its own exponential arithmetic plus its own timer/abort-listener dance. The\n * two drifted: one jittered and capped, the other did neither. This module is\n * the single algebra both express their delays through.\n *\n * The zone sits at the bottom of the dependency DAG and imports nothing, which\n * is why `wait_with_abort` is handed the abort-error factory rather than\n * constructing one: the error taxonomy lives in core, and reaching for it from\n * here would close a cycle back through the callers.\n */\n\nexport type BackoffPolicy = {\n readonly initial_delay_ms: number\n readonly max_delay_ms: number\n readonly jitter: boolean\n}\n\n/**\n * Map an abort reason onto the error a wait rejects with.\n *\n * Each layer surfaces an abort as its own error, so the caller supplies the\n * mapping instead of this zone owning an error taxonomy it cannot import.\n *\n * The two callers pass genuinely different factories, and that is settled, not\n * pending: core propagates an `Error` reason verbatim so an upstream cause\n * survives, while the engine always wraps so its boundary can only ever throw\n * `aborted_error`. Both were weighed once both layers rode this algebra; see\n * the factories in `core/retry.ts` and `engine/retry.ts` for what each protects.\n * Collapsing them to one rule breaks one layer or the other.\n */\nexport type AbortErrorFactory = (reason: unknown) => Error\n\n/**\n * Compute the delay before retry attempt `attempt`, counted from zero.\n *\n * Exponential (`initial_delay_ms * 2^attempt`) plus up to one\n * `initial_delay_ms` of random jitter when `policy.jitter` is set, clamped to\n * `max_delay_ms`. The jitter spreads retries from concurrent callers apart so\n * they don't stampede in lockstep; a `max_delay_ms` of `Infinity` is uncapped.\n */\nexport function compute_backoff(policy: BackoffPolicy, attempt: number): number {\n const base = policy.initial_delay_ms * 2 ** attempt\n const jitter = policy.jitter ? Math.random() * policy.initial_delay_ms : 0\n return Math.min(base + jitter, policy.max_delay_ms)\n}\n\n/**\n * Sleep `ms`, rejecting the moment `signal` fires instead of serving out the\n * delay, so a pending abort never waits out a backoff.\n *\n * A non-positive `ms` resolves without arming a timer or consulting `signal`,\n * matching what both retry layers did before. The rejection value is\n * `to_error` applied to `signal.reason`.\n */\nexport function wait_with_abort(\n ms: number,\n signal: AbortSignal,\n to_error: AbortErrorFactory,\n): Promise<void> {\n if (ms <= 0) return Promise.resolve()\n return new Promise<void>((resolve, reject) => {\n if (signal.aborted) {\n reject(to_error(signal.reason))\n return\n }\n const timer = setTimeout(() => {\n signal.removeEventListener('abort', on_abort)\n resolve()\n }, ms)\n const on_abort = (): void => {\n clearTimeout(timer)\n reject(to_error(signal.reason))\n }\n signal.addEventListener('abort', on_abort, { once: true })\n })\n}\n","/**\n * retry: re-run on failure.\n *\n * `retry(inner, { max_attempts, backoff_ms?, max_delay_ms?, jitter?, on_error? })`\n * runs `inner`. If it throws an application error, retries up to\n * `max_attempts - 1` more times with exponential backoff\n * (`backoff_ms * 2^(attempt-1)`), jittered by up to one `backoff_ms` and\n * clamped to `max_delay_ms` (default 30s) through the shared `#policy`\n * algebra. `jitter` defaults on: un-jittered concurrent retries stampede in\n * lockstep. `on_error` is called on every such failure. The last error is\n * rethrown if all attempts fail.\n *\n * Control-flow signals (`suspended_error`, `aborted_error`) are not failures:\n * they propagate immediately without consuming an attempt, firing `on_error`,\n * or scheduling a backoff. A suspend's `on()` side effect therefore runs once\n * per run, not once per attempt.\n *\n * Cancellation / cleanup: cleanup handlers registered by the inner step\n * accumulate across attempts. The parent `ctx.abort` is honored between\n * attempts; a pending abort short-circuits the backoff and propagates.\n */\n\nimport { aborted_error, is_control_flow_error } from './errors.js'\nimport { dispatch_step, register_traced_kind } from './runner.js'\nimport type { RunContext, Step } from './types.js'\nimport { compute_backoff, wait_with_abort } from '#policy'\nimport type { BackoffPolicy } from '#policy'\n\nconst DEFAULT_BACKOFF_MS = 1_000\nconst DEFAULT_MAX_DELAY_MS = 30_000\n\nexport type RetryConfig = {\n readonly name?: string\n readonly max_attempts: number\n readonly backoff_ms?: number\n readonly max_delay_ms?: number\n readonly jitter?: boolean\n readonly on_error?: (err: unknown, attempt: number) => void\n}\n\nlet retry_counter = 0\n\n/**\n * Generate a unique step id of the form `retry_<n>`.\n */\nfunction next_id(): string {\n retry_counter += 1\n return `retry_${retry_counter}`\n}\n\n/**\n * Map an abort reason onto the error a retry rejects with, preserving an\n * `Error` reason verbatim rather than wrapping it in `aborted_error`.\n *\n * Core's convention, shared with `timeout`, `parallel`, `map`, the runner's\n * `throw_if_aborted`, and `bench`: this layer owns the signal chain, so the\n * cause set upstream has to survive it. Wrapping would turn `timeout`'s\n * `timeout_error` into an abort, and would flatten the runner's\n * `aborted_error('received SIGINT')` into a bare 'aborted' that\n * `runner.ts`'s catch cannot repair, since that repair only fires when the\n * escaping error is not already an `aborted_error`.\n *\n * The engine's retry deliberately does the opposite; `#policy`'s\n * `AbortErrorFactory` is where the two meet.\n */\nfunction to_abort_error(reason: unknown): Error {\n return reason instanceof Error ? reason : new aborted_error('aborted', { reason })\n}\n\n/**\n * Build a retrying step around `inner`.\n *\n * Runs `inner` up to `max_attempts` times with exponential backoff between\n * failures. Application errors consume an attempt and fire `on_error`;\n * control-flow signals propagate untouched.\n */\nexport function retry<i, o>(inner: Step<i, o>, config: RetryConfig): Step<i, o> {\n const id = next_id()\n const max_attempts = Math.max(1, Math.floor(config.max_attempts))\n const backoff_ms = config.backoff_ms ?? DEFAULT_BACKOFF_MS\n const max_delay_ms = config.max_delay_ms ?? DEFAULT_MAX_DELAY_MS\n const jitter = config.jitter ?? true\n const on_error = config.on_error\n const backoff_policy: BackoffPolicy = { initial_delay_ms: backoff_ms, max_delay_ms, jitter }\n\n const run_fn = async (input: i, ctx: RunContext): Promise<o> => {\n let last_err: unknown = undefined\n for (let attempt = 1; attempt <= max_attempts; attempt += 1) {\n if (ctx.abort.aborted) {\n throw to_abort_error(ctx.abort.reason)\n }\n try {\n return await dispatch_step(inner, input, ctx)\n } catch (err) {\n if (is_control_flow_error(err)) throw err\n last_err = err\n if (on_error) on_error(err, attempt)\n if (attempt >= max_attempts) break\n const delay = compute_backoff(backoff_policy, attempt - 1)\n await wait_with_abort(delay, ctx.abort, to_abort_error)\n }\n }\n throw last_err\n }\n\n const config_meta: Record<string, unknown> = { max_attempts, backoff_ms, max_delay_ms, jitter }\n if (on_error) config_meta['on_error'] = on_error\n if (config.name !== undefined) config_meta['display_name'] = config.name\n\n return {\n id,\n kind: 'retry',\n children: [inner],\n config: config_meta,\n run: run_fn,\n }\n}\n\nregister_traced_kind('retry')\n","/**\n * fallback: primary-or-backup.\n *\n * `fallback(primary, backup)` runs `primary`. If it throws an application\n * error, runs `backup` with the same input, or with `handoff(input, err)`\n * when the `handoff` option is set, so the backup can be told why it is\n * running. If `backup` also throws, the `backup` error propagates.\n * Control-flow signals (`suspended_error`, `aborted_error`) are not\n * failures: they propagate instead of triggering the backup, so a\n * human-approval gate is never silently bypassed and the backup never runs\n * under an aborted context. `handoff` is never called for them.\n */\n\nimport { is_control_flow_error } from './errors.js'\nimport { dispatch_step, register_traced_kind } from './runner.js'\nimport type { RunContext, Step } from './types.js'\n\nlet fallback_counter = 0\n\n/**\n * Generate a unique step id of the form `fallback_<n>`.\n */\nfunction next_id(): string {\n fallback_counter += 1\n return `fallback_${fallback_counter}`\n}\n\nexport type FallbackOptions<i = unknown> = {\n readonly name?: string\n readonly handoff?: (input: i, err: unknown) => i\n}\n\n/**\n * Build a primary-or-backup step.\n *\n * Runs `primary`; on an application error runs `backup` with the same input,\n * or with `handoff(input, err)` when the option is set. Control-flow signals\n * propagate without triggering the backup or the handoff.\n */\nexport function fallback<i, o>(\n primary: Step<i, o>,\n backup: Step<i, o>,\n options?: FallbackOptions<i>,\n): Step<i, o> {\n const id = next_id()\n const handoff = options?.handoff\n\n const run_fn = async (input: i, ctx: RunContext): Promise<o> => {\n try {\n return await dispatch_step(primary, input, ctx)\n } catch (err) {\n if (is_control_flow_error(err)) throw err\n const backup_input = handoff === undefined ? input : handoff(input, err)\n return dispatch_step(backup, backup_input, ctx)\n }\n }\n\n const config_meta: Record<string, unknown> | undefined =\n options?.name === undefined ? undefined : { display_name: options.name }\n\n return {\n id,\n kind: 'fallback',\n children: [primary, backup],\n ...(config_meta ? { config: config_meta } : {}),\n run: run_fn,\n }\n}\n\nregister_traced_kind('fallback')\n","/**\n * timeout: bound execution.\n *\n * `timeout(inner, ms)` runs `inner` with a composed `AbortSignal` that fires\n * at `ms` milliseconds. If the inner step does not complete in time, throws\n * `timeout_error`. The inner step is responsible for honoring `ctx.abort`;\n * a step that ignores the signal still triggers `timeout_error` on schedule\n * but continues running in the background.\n *\n * Cancellation: the inner step runs with\n * `AbortSignal.any([ctx.abort, timeout_local])`. On timer expiry, the local\n * controller aborts with a `timeout_error` as its reason; on parent abort\n * the parent reason flows through. The timer is always cleared in a finally\n * block so it does not leak across retries.\n */\n\nimport { aborted_error, timeout_error } from './errors.js'\nimport { dispatch_step, register_traced_kind } from './runner.js'\nimport type { RunContext, Step } from './types.js'\n\nlet timeout_counter = 0\n\n/**\n * Generate a unique step id of the form `timeout_<n>`.\n */\nfunction next_id(): string {\n timeout_counter += 1\n return `timeout_${timeout_counter}`\n}\n\nexport type TimeoutOptions = {\n readonly name?: string\n}\n\n/**\n * Build a deadline-bounded step around `inner`.\n *\n * Races the inner dispatch against a timer that aborts the composed signal\n * with `timeout_error`. The `timed_out` flag distinguishes timer expiry from\n * a parent abort so the right error propagates.\n */\nexport function timeout<i, o>(\n inner: Step<i, o>,\n ms: number,\n options?: TimeoutOptions,\n): Step<i, o> {\n const id = next_id()\n\n const run_fn = async (input: i, ctx: RunContext): Promise<o> => {\n const local = new AbortController()\n const composed = AbortSignal.any([ctx.abort, local.signal])\n const child_ctx: RunContext = { ...ctx, abort: composed }\n \n let timed_out = false\n const timer = setTimeout(() => {\n timed_out = true\n local.abort(new timeout_error(`timeout after ${ms}ms`, ms))\n }, ms)\n \n const deadline = new Promise<never>((_, reject) => {\n const on_local_abort = (): void => {\n if (timed_out) {\n reject(new timeout_error(`timeout after ${ms}ms`, ms))\n } else {\n const reason = ctx.abort.reason\n reject(reason instanceof Error ? reason : new aborted_error('aborted', { reason }))\n }\n }\n if (composed.aborted) {\n on_local_abort()\n return\n }\n composed.addEventListener('abort', on_local_abort, { once: true })\n })\n \n try {\n return await Promise.race([dispatch_step(inner, input, child_ctx), deadline])\n } finally {\n clearTimeout(timer)\n }\n }\n\n const config_meta: Record<string, unknown> = { ms }\n if (options?.name !== undefined) config_meta['display_name'] = options.name\n\n return {\n id,\n kind: 'timeout',\n children: [inner],\n config: config_meta,\n run: run_fn,\n }\n}\n\nregister_traced_kind('timeout')\n","/**\n * loop: bounded iteration with carry-state.\n *\n * `loop({ init, body, guard?, finish, max_rounds, name? })` runs `body` up to\n * `max_rounds` times, threading `state` through each iteration. After every\n * `body` call, an optional `guard` step inspects (and may transform) the state\n * and decides whether to stop. When `guard.stop` is true, the loop exits\n * \"converged\"; otherwise it continues until `max_rounds`. `finish` projects\n * the final state to the loop's output value, and is the loop's only output\n * channel: `loop` returns `Step<i, o>`, not an envelope around `o`.\n *\n * Non-convergence is data, not error, and `finish` is where that data arrives:\n * its second argument is the `LoopOutcome` (`{ converged, rounds }`), so a\n * projection can fold either field into its own result shape, the way\n * `adversarial` and `consensus` do. A projection that wants the whole outcome\n * verbatim writes `finish: (state, outcome) => ({ value: state, ...outcome })`.\n *\n * Cancellation: between rounds the parent `ctx.abort` is honored; a pending\n * abort short-circuits and propagates `ctx.abort.reason`. The body and guard\n * receive the parent context unchanged; their own dispatch routes already\n * thread cancellation per the runner contract.\n */\n\nimport { dispatch_step, register_traced_kind, throw_if_aborted } from './runner.js'\nimport type { RunContext, Step } from './types.js'\n\nexport type LoopGuardResult<state> = {\n readonly stop: boolean\n readonly state: state\n}\n\nexport type LoopOutcome = {\n readonly converged: boolean\n readonly rounds: number\n}\n\nexport type LoopConfig<i, state, o> = {\n readonly name?: string\n readonly init: (input: i) => state\n readonly body: Step<state, state>\n readonly guard?: Step<state, LoopGuardResult<state>>\n readonly finish: (state: state, outcome: LoopOutcome) => o\n readonly max_rounds: number\n}\n\nlet loop_counter = 0\n\n/**\n * Generate a unique step id, prefixed with the display name when one is set.\n */\nfunction next_id(name: string | undefined): string {\n loop_counter += 1\n return `${name ?? 'loop'}_${loop_counter}`\n}\n\n/**\n * Build a bounded iteration step with carry-state.\n *\n * Threads `state` through up to `max_rounds` runs of `body`, lets the\n * optional `guard` stop early, then projects the final state through\n * `finish`. `finish` also receives `{ converged, rounds }`, so a projection\n * can tell a converged run from an exhausted one without the loop wrapping\n * its output.\n */\nexport function loop<i, state, o>(config: LoopConfig<i, state, o>): Step<i, o> {\n const { init, body, guard, finish, name } = config\n const rounds_limit = Math.max(1, Math.floor(config.max_rounds))\n const id = next_id(name)\n\n const run_fn = async (input: i, ctx: RunContext): Promise<o> => {\n let state = init(input)\n let round = 0\n let converged = false\n \n while (round < rounds_limit) {\n throw_if_aborted(ctx)\n round += 1\n state = await dispatch_step(body, state, ctx)\n if (guard) {\n throw_if_aborted(ctx)\n const guard_out = await dispatch_step(guard, state, ctx)\n state = guard_out.state\n if (guard_out.stop) {\n converged = true\n break\n }\n }\n }\n \n return finish(state, { converged, rounds: round })\n }\n\n const config_meta: Record<string, unknown> = { max_rounds: rounds_limit }\n if (name !== undefined) config_meta['display_name'] = name\n const children: ReadonlyArray<Step<unknown, unknown>> = guard\n ? [body, guard]\n : [body]\n\n return {\n id,\n kind: 'loop',\n children,\n config: config_meta,\n run: run_fn,\n }\n}\n\nregister_traced_kind('loop')\n","/**\n * compose: name a composite step.\n *\n * `compose(name, inner)` wraps any step and labels its trajectory span with\n * `name`. The inner step's own span (e.g. a `sequence`) appears as a child of\n * the compose span: the implementation tree is preserved while the user's\n * intent (\"this whole thing is an ensemble\") is surfaced in observability.\n *\n * Used by the composites package to make built-in patterns appear under\n * their familiar names, and available to library consumers who want their own\n * named composites to show up in logs as first-class components.\n *\n * The primitive's `kind` is always `'compose'`; the user-supplied label lives\n * in `config.display_name` and is the span name the dispatcher opens.\n */\n\nimport { dispatch_step, register_traced_kind } from './runner.js'\nimport type { RunContext, Step } from './types.js'\n\nlet compose_counter = 0\n\n/**\n * Generate a unique step id of the form `<name>_<n>`, using the user-supplied\n * label so compose ids read naturally in traces.\n */\nfunction next_id(name: string): string {\n compose_counter += 1\n return `${name}_${compose_counter}`\n}\n\n/**\n * Wrap `inner` in a named composite step.\n *\n * The step's `kind` is always `'compose'`; `name` becomes the\n * `display_name` used as the span label. Throws a `TypeError` when `name`\n * is not a non-empty string, catching the mistake at construction time.\n */\nexport function compose<i, o>(name: string, inner: Step<i, o>): Step<i, o> {\n if (typeof name !== 'string' || name.length === 0) {\n throw new TypeError('compose(name, inner): name must be a non-empty string')\n }\n const id = next_id(name)\n\n const run_fn = (input: i, ctx: RunContext): Promise<o> | o => dispatch_step(inner, input, ctx)\n\n return {\n id,\n kind: 'compose',\n children: [inner],\n config: { display_name: name },\n run: run_fn,\n }\n}\n\nregister_traced_kind('compose')\n","/**\n * checkpoint: persist and resume.\n *\n * `checkpoint(inner, { key })` checks a persistent store for a completed\n * result at `key` before running `inner`. On a hit, returns the stored\n * value. On a miss, runs `inner`, persists its result at `key`, and returns\n * it. Corrupted reads (store throws on `get`) are treated as a miss.\n *\n * Wrapping an anonymous inner step throws synchronously at construction time\n * with the message `checkpoint requires a named step; got anonymous`, because\n * a cached result must map back to a stable, identifiable step.\n */\n\nimport { dispatch_step, register_traced_kind } from './runner.js'\nimport type { RunContext, Step } from './types.js'\n\nexport type CheckpointConfig<i> = {\n readonly name?: string\n readonly key: string | ((input: i) => string)\n}\n\nlet checkpoint_counter = 0\n\n/**\n * Generate a unique step id of the form `checkpoint_<n>`.\n */\nfunction next_id(): string {\n checkpoint_counter += 1\n return `checkpoint_${checkpoint_counter}`\n}\n\n/**\n * Wrap `inner` with persist-and-resume behavior keyed by `config.key`.\n *\n * `key` is a fixed string or a function of the input. Without a\n * `checkpoint_store` on the run context, the wrapper runs `inner` directly.\n * A stored `null` or `undefined` counts as a miss, so those values are\n * re-computed rather than replayed. Throws at construction time when `inner`\n * is anonymous.\n */\nexport function checkpoint<i, o>(inner: Step<i, o>, config: CheckpointConfig<i>): Step<i, o> {\n if (inner.anonymous === true) {\n throw new Error('checkpoint requires a named step; got anonymous')\n }\n\n const id = next_id()\n const key_spec = config.key\n\n const run_fn = async (input: i, ctx: RunContext): Promise<o> => {\n const key = typeof key_spec === 'function' ? key_spec(input) : key_spec\n const store = ctx.checkpoint_store\n \n if (store) {\n let cached: unknown = undefined\n let hit = false\n try {\n cached = await store.get(key)\n hit = cached !== null && cached !== undefined\n } catch {\n hit = false\n }\n if (hit) {\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n return cached as o\n }\n }\n \n const result = await dispatch_step(inner, input, ctx)\n \n if (store) {\n await store.set(key, result)\n }\n \n return result\n }\n\n const config_meta: Record<string, unknown> = { key: key_spec }\n if (config.name !== undefined) config_meta['display_name'] = config.name\n\n return {\n id,\n kind: 'checkpoint',\n children: [inner],\n config: config_meta,\n run: run_fn,\n }\n}\n\nregister_traced_kind('checkpoint')\n","/**\n * Validation against any Standard Schema implementation, and the one-line\n * rendering of its failures that repair prompts and error messages use.\n */\n\nimport type { StandardSchemaV1 } from '@standard-schema/spec'\nimport type { AnySchema, SchemaIssue, ValidateOutcome } from './types.js'\n\n/**\n * Validate `value` against `schema`, returning the typed value or the issues.\n *\n * Always async, even for a validator that answers synchronously: the spec\n * permits `validate` to return either a result or a promise of one, and\n * fascicle cannot know which a given vendor does. Awaiting a non-promise is\n * cheap; guessing wrong is a silent bug.\n */\nexport async function validate_schema<t>(\n schema: AnySchema<t>,\n value: unknown,\n): Promise<ValidateOutcome<t>> {\n const result = await schema['~standard'].validate(value)\n if (result.issues) return { ok: false, issues: result.issues.map(normalize_issue) }\n return { ok: true, value: result.value }\n}\n\n/**\n * Flatten one vendor issue into fascicle's shape.\n *\n * The spec allows a path segment to be a bare key or a `{ key }` wrapper, and\n * allows the path to be absent entirely. Normalizing here means no consumer has\n * to know which vendor produced the issue.\n */\nfunction normalize_issue(issue: StandardSchemaV1.Issue): SchemaIssue {\n if (issue.path === undefined) return { message: issue.message }\n const path = issue.path.map((segment) =>\n typeof segment === 'object' ? segment.key : segment,\n )\n return { message: issue.message, path }\n}\n\n/**\n * Render issues as the single line that goes into an error message or a repair\n * prompt fed back to the model.\n *\n * Paths are dotted (`address.city`, `items.0.name`) rather than bracketed for\n * indices: the model reads it as a hint about which field to fix, and one\n * consistent separator is easier to follow than two.\n */\nexport function format_schema_issues(issues: ReadonlyArray<SchemaIssue>): string {\n if (issues.length === 0) return 'unknown schema issue'\n return issues.map(format_issue).join('; ')\n}\n\n/**\n * Render one issue as `path: message`, or just the message when the vendor\n * reported no path (a failure about the value as a whole).\n */\nfunction format_issue(issue: SchemaIssue): string {\n const path = issue.path\n if (path === undefined || path.length === 0) return issue.message\n return `${path.map((segment) => String(segment)).join('.')}: ${issue.message}`\n}\n","/**\n * suspend: human-in-the-loop pause.\n *\n * `suspend({ id, on, resume_schema, combine })` pauses a flow waiting on\n * external input (a notification, an approval, an uploaded file). On first\n * encounter with no resume data, it calls `on(input, ctx)` (side effect) and\n * throws `suspended_error` carrying the run state. On resume (re-invocation\n * with `run_options.resume_data[id]` populated), the provided value is\n * validated against `resume_schema` and passed to `combine(input, resume,\n * ctx)`; the result is returned. Invalid resume data throws\n * `resume_validation_error` carrying the vendor-neutral issue list.\n */\n\nimport { validate_schema, type AnySchema } from '#schema'\nimport { resume_validation_error, suspended_error } from './errors.js'\nimport { dispatch_step, register_traced_kind } from './runner.js'\nimport type { RunContext, Step } from './types.js'\n\nexport type SuspendConfig<i, o, resume> = {\n readonly id: string\n readonly name?: string\n readonly on: (input: i, ctx: RunContext) => Promise<void> | void\n readonly resume_schema: AnySchema<resume>\n readonly combine: (\n input: i,\n resume: resume,\n ctx: RunContext,\n ) => Promise<o> | o | Step<unknown, o>\n}\n\n/**\n * Structurally detect a `Step` returned from `combine`.\n *\n * `combine` may return either a plain value or a Step to dispatch; this local\n * check distinguishes the two without importing the shared helper.\n */\nfunction is_step(value: unknown): value is Step<unknown, unknown> {\n if (typeof value !== 'object' || value === null) return false\n if (!('id' in value) || !('kind' in value) || !('run' in value)) return false\n const { id, kind, run } = value\n return typeof id === 'string' && typeof kind === 'string' && typeof run === 'function'\n}\n\n/**\n * Build a human-in-the-loop pause step.\n *\n * First run fires the `on` side effect and throws `suspended_error`; a resume\n * run validates `resume_data[id]` against `resume_schema` and feeds it to\n * `combine`. The step's id is the user-supplied suspend id so resume data can\n * be addressed to it.\n */\nexport function suspend<i, o, resume>(config: SuspendConfig<i, o, resume>): Step<i, o> {\n const suspend_id = config.id\n const on_fn = config.on\n const resume_schema = config.resume_schema\n const combine_fn = config.combine\n\n const run_fn = async (input: i, ctx: RunContext): Promise<o> => {\n const resume_value = ctx.resume_data?.[suspend_id]\n \n if (resume_value === undefined) {\n await on_fn(input, ctx)\n throw new suspended_error(suspend_id, { input })\n }\n \n const parsed = await validate_schema(resume_schema, resume_value)\n if (!parsed.ok) {\n throw new resume_validation_error(\n `resume data for ${suspend_id} failed validation`,\n parsed.issues,\n )\n }\n\n const result = await combine_fn(input, parsed.value, ctx)\n if (is_step(result)) {\n return dispatch_step(result, input, ctx)\n }\n return result\n }\n\n const config_meta: Record<string, unknown> = { id: suspend_id }\n if (config.name !== undefined) config_meta['display_name'] = config.name\n\n return {\n id: suspend_id,\n kind: 'suspend',\n config: config_meta,\n run: run_fn,\n }\n}\n\nregister_traced_kind('suspend')\n","/**\n * scope / stash / use: named state.\n *\n * `scope([...children])` introduces a scope-local `Map<string, unknown>` and\n * runs its children in order, chaining outputs like `sequence`. `stash(key,\n * source)` runs `source`, writes its output to the scope's state at `key`,\n * and passes the value through. `use(keys, fn)` reads the named values from\n * state and runs `fn` with the projection. Inner scopes inherit outer state;\n * writes only affect the inner map.\n *\n * Using `stash` or `use` outside a `scope` is a runtime error with a clear\n * message.\n */\n\nimport { dispatch_step, register_traced_kind, throw_if_aborted } from './runner.js'\nimport type { RunContext, Step } from './types.js'\n\ntype AnyStep = Step<unknown, unknown>\n\ntype LastOutput<children> = children extends readonly [...unknown[], Step<unknown, infer o>]\n ? o\n : children extends readonly [Step<unknown, infer o>]\n ? o\n : unknown\n\nconst scope_states = new WeakSet<ReadonlyMap<string, unknown>>()\n\n/**\n * Check whether a state map was created by `scope`.\n *\n * The root `RunContext.state` map is not registered in `scope_states`, which\n * is how `stash`/`use` detect they are running outside any scope.\n */\nfunction is_scope_state(state: ReadonlyMap<string, unknown>): boolean {\n return scope_states.has(state)\n}\n\nlet scope_counter = 0\nlet stash_counter = 0\nlet use_counter = 0\n\n/**\n * Generate a unique step id of the form `scope_<n>`.\n */\nfunction next_scope_id(): string {\n scope_counter += 1\n return `scope_${scope_counter}`\n}\n\n/**\n * Generate a unique step id of the form `stash_<n>`.\n */\nfunction next_stash_id(): string {\n stash_counter += 1\n return `stash_${stash_counter}`\n}\n\n/**\n * Generate a unique step id of the form `use_<n>`.\n */\nfunction next_use_id(): string {\n use_counter += 1\n return `use_${use_counter}`\n}\n\nexport type ScopeOptions = {\n readonly name?: string\n}\n\nexport type StashOptions = {\n readonly name?: string\n}\n\nexport type UseOptions = {\n readonly name?: string\n}\n\n/**\n * Build a step that runs children in sequence under a fresh state map.\n *\n * The local map is seeded from the parent state (inner scopes read outer\n * values) and registered so `stash`/`use` inside recognize it; writes stay\n * local to this scope. Outputs chain like `sequence`.\n */\nexport function scope<const children extends readonly AnyStep[]>(\n children: children,\n options?: ScopeOptions,\n): Step<unknown, LastOutput<children>> {\n const id = next_scope_id()\n const children_ref = children\n\n const run_fn = async (input: unknown, ctx: RunContext): Promise<unknown> => {\n const local = new Map<string, unknown>(ctx.state)\n scope_states.add(local)\n const scope_ctx: RunContext = { ...ctx, state: local }\n \n let acc: unknown = input\n for (const child of children_ref) {\n throw_if_aborted(scope_ctx)\n acc = await dispatch_step(child, acc, scope_ctx)\n }\n return acc\n }\n\n const config_meta: Record<string, unknown> | undefined =\n options?.name === undefined ? undefined : { display_name: options.name }\n\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n return {\n id,\n kind: 'scope',\n children,\n ...(config_meta ? { config: config_meta } : {}),\n run: run_fn,\n } as Step<unknown, LastOutput<children>>\n}\n\n/**\n * Build a step that stores its source's output in scope state at `key`.\n *\n * Passes the value through unchanged so it composes mid-chain. Throws when\n * run outside a `scope`.\n */\nexport function stash<i, v>(\n key: string,\n source: Step<i, v>,\n options?: StashOptions,\n): Step<i, v> {\n const id = next_stash_id()\n\n const run_fn = async (input: i, ctx: RunContext): Promise<v> => {\n if (!is_scope_state(ctx.state)) {\n throw new Error('stash() may only appear inside scope(); got: top-level')\n }\n const value = await dispatch_step(source, input, ctx)\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n const state = ctx.state as Map<string, unknown>\n state.set(key, value)\n return value\n }\n\n const config_meta: Record<string, unknown> = { key }\n if (options?.name !== undefined) config_meta['display_name'] = options.name\n\n return {\n id,\n kind: 'stash',\n children: [source],\n config: config_meta,\n run: run_fn,\n }\n}\n\n/**\n * Build a step that projects named scope values into a function call.\n *\n * Reads `keys` from scope state (missing keys project as `undefined`) and\n * invokes `fn(projection, input, ctx)`. Throws when run outside a `scope`.\n */\nexport function use<const keys extends readonly string[], i, o>(\n keys: keys,\n fn: (\n state: { [k in keys[number]]: unknown },\n input: i,\n ctx: RunContext,\n ) => Promise<o> | o,\n options?: UseOptions,\n): Step<i, o> {\n const id = next_use_id()\n\n const run_fn = async (input: i, ctx: RunContext): Promise<o> => {\n if (!is_scope_state(ctx.state)) {\n throw new Error('use() may only appear inside scope(); got: top-level')\n }\n const projection: Record<string, unknown> = {}\n for (const k of keys) {\n projection[k] = ctx.state.get(k)\n }\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n return fn(projection as { [k in keys[number]]: unknown }, input, ctx)\n }\n\n const config_meta: Record<string, unknown> = { keys: [...keys] }\n if (options?.name !== undefined) config_meta['display_name'] = options.name\n\n return {\n id,\n kind: 'use',\n config: config_meta,\n run: run_fn,\n }\n}\n\nregister_traced_kind('scope')\n\nregister_traced_kind('stash')\n\nregister_traced_kind('use')\n","/**\n * Closed registry of every `Step.kind` produced by the composition layer.\n *\n * Studio (and any other consumer that needs to enumerate primitives: palette,\n * docs, code generation) can rely on this being the exhaustive set. New\n * primitives must add their kind here. The `step_kinds_cover_runner` contract\n * test in `step_kinds.test.ts` asserts every dispatch handler corresponds to a\n * kind listed here.\n */\n\nexport const STEP_KINDS = [\n 'step',\n 'sequence',\n 'parallel',\n 'branch',\n 'map',\n 'pipe',\n 'retry',\n 'fallback',\n 'timeout',\n 'loop',\n 'compose',\n 'adversarial',\n 'ensemble',\n 'tournament',\n 'consensus',\n 'checkpoint',\n 'suspend',\n 'scope',\n 'stash',\n 'use',\n] as const\n\nexport type StepKind = (typeof STEP_KINDS)[number]\n\n/**\n * Check whether a value is one of the registered `Step.kind` strings.\n */\nexport function is_step_kind(value: unknown): value is StepKind {\n return typeof value === 'string' && (STEP_KINDS as readonly string[]).includes(value)\n}\n","/**\n * Wire-format guards for trajectory events.\n *\n * `TrajectoryEvent` (in `types.ts`) is the loose internal type — any code that\n * calls `trajectory.record(event)` or `start_span(name, meta)` produces values\n * conforming to it. This file defines the *narrower* shapes that the studio\n * (and any other downstream consumer) can recognize in the wire stream:\n *\n * span_start — composer span open\n * span_end — composer span close\n * emit — user-emitted event from inside a step (ctx.emit)\n * <other> — anything else, recognized by `is_custom_trajectory_event`,\n * which only requires a string `kind`\n *\n * `parse_trajectory_event` is the wire gate, and it is deliberately permissive:\n * a value is a trajectory event iff it is a non-array object carrying a string\n * `kind`. The well-known guards layered on top are *recognizers*, not gates — a\n * `{ kind: 'span_start' }` line missing its `span_id` is still a valid event on\n * the wire, just not a `SpanStartEvent`. Anything stricter would have a viewer\n * drop lines a newer producer emits, which is the opposite of what a\n * forward-compatible wire format is for. `is_custom_trajectory_event` therefore\n * answers `true` for well-known kinds too: it is the fallback shape, not a\n * fifth disjoint case.\n *\n * Extra fields (`run_id`, `id`, provider-specific metadata) are neither\n * required nor stripped: a successful parse hands the value straight back, so a\n * parse / re-serialize round trip is lossless.\n */\n\nexport type SpanStartEvent = {\n readonly kind: 'span_start'\n readonly span_id: string\n readonly name: string\n} & { readonly [key: string]: unknown }\n\nexport type SpanEndEvent = {\n readonly kind: 'span_end'\n readonly span_id: string\n} & { readonly [key: string]: unknown }\n\nexport type EmitEvent = {\n readonly kind: 'emit'\n} & { readonly [key: string]: unknown }\n\nexport type CustomTrajectoryEvent = {\n readonly kind: string\n} & { readonly [key: string]: unknown }\n\nexport type ParsedTrajectoryEvent =\n | SpanStartEvent\n | SpanEndEvent\n | EmitEvent\n | CustomTrajectoryEvent\n\nexport type TrajectoryParseResult =\n | { readonly success: true; readonly data: ParsedTrajectoryEvent }\n | { readonly success: false; readonly error: Error }\n\n/**\n * The wire gate: a non-array object carrying a string `kind`.\n *\n * True for every well-known kind as well, since `custom` is the fallback shape\n * rather than a disjoint case.\n */\nexport function is_custom_trajectory_event(value: unknown): value is CustomTrajectoryEvent {\n if (typeof value !== 'object' || value === null) return false\n if (Array.isArray(value)) return false\n return typeof (value as { kind?: unknown }).kind === 'string'\n}\n\n/** A composer span open: both `span_id` and `name` must be present as strings. */\nexport function is_span_start_event(value: unknown): value is SpanStartEvent {\n if (!is_custom_trajectory_event(value)) return false\n if (value.kind !== 'span_start') return false\n return typeof value['span_id'] === 'string' && typeof value['name'] === 'string'\n}\n\n/** A composer span close: `span_id` must be present as a string, `name` need not be. */\nexport function is_span_end_event(value: unknown): value is SpanEndEvent {\n if (!is_custom_trajectory_event(value)) return false\n return value.kind === 'span_end' && typeof value['span_id'] === 'string'\n}\n\n/** A `ctx.emit` event: the kind alone identifies it, the payload is the caller's. */\nexport function is_emit_event(value: unknown): value is EmitEvent {\n return is_custom_trajectory_event(value) && value.kind === 'emit'\n}\n\n/**\n * Parse one wire value into a trajectory event, `safeParse`-shaped.\n *\n * On success `data` is the value itself, not a copy, so nothing on the line is\n * dropped or reordered on the way through.\n */\nexport function parse_trajectory_event(value: unknown): TrajectoryParseResult {\n if (!is_custom_trajectory_event(value)) {\n return {\n success: false,\n error: new Error(\"not a trajectory event: expected an object with a string 'kind'\"),\n }\n }\n return { success: true, data: value }\n}\n","/**\n * Public surface for core.\n *\n * Side-effect imports ensure every composer registers itself with the runner\n * at module load. Importing anything from `core` populates the\n * dispatch table with the core primitives. Built-in composites\n * (adversarial, ensemble, tournament, consensus) live in composites\n * and surface through the umbrella package.\n */\n\nimport flow_schema_data from './flow-schema.json' with { type: 'json' }\n\nexport { run } from './runner.js'\nexport { step } from './step.js'\nexport { describe } from './describe.js'\nexport type { DescribeOptions, FlowNode, FlowValue } from './describe.js'\nexport { sequence } from './sequence.js'\nexport { parallel } from './parallel.js'\nexport { branch } from './branch.js'\nexport { map } from './map.js'\nexport { pipe } from './pipe.js'\nexport { retry } from './retry.js'\nexport { fallback } from './fallback.js'\nexport { timeout } from './timeout.js'\nexport { loop } from './loop.js'\nexport type { LoopConfig, LoopGuardResult, LoopOutcome } from './loop.js'\nexport { compose } from './compose.js'\nexport { checkpoint } from './checkpoint.js'\nexport { suspend } from './suspend.js'\nexport { scope, stash, use } from './scope.js'\n\nexport {\n aborted_error,\n describe_cycle_error,\n resume_validation_error,\n suspended_error,\n timeout_error,\n} from './errors.js'\n\nexport type {\n CheckpointStore,\n RunContext,\n Step,\n StepMetadata,\n TrajectoryEvent,\n TrajectoryLogger,\n} from './types.js'\n\nexport { is_step_kind, STEP_KINDS } from './step_kinds.js'\nexport type { StepKind } from './step_kinds.js'\n\nexport {\n is_custom_trajectory_event,\n is_emit_event,\n is_span_end_event,\n is_span_start_event,\n parse_trajectory_event,\n} from './trajectory.js'\nexport type {\n CustomTrajectoryEvent,\n EmitEvent,\n ParsedTrajectoryEvent,\n SpanEndEvent,\n SpanStartEvent,\n TrajectoryParseResult,\n} from './trajectory.js'\n\nexport { flow_schema_data as flow_schema }\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACYA,MAAM,qBAAqB;;;;;;;;;AAe3B,SAAgB,wBAAwB,YAA+C;CACrF,MAAM,WAAwB,CAAC;CAC/B,IAAI,MAAM;CAEV,SAAS,SAAS,IAAqB;EACrC,IAAI,KAAK;GACP,WAAW,OAAO,EAChB,MAAM,iCACR,CAAC;GACD;EACF;EACA,SAAS,KAAK,EAAE;CAClB;CAEA,eAAe,UAAyB;EACtC,IAAI,KAAK;EACT,MAAM;EACN,KAAK,IAAI,IAAI,SAAS,SAAS,GAAG,KAAK,GAAG,KAAK,GAAG;GAChD,MAAM,KAAK,SAAS;GACpB,IAAI,CAAC,IAAI;GACT,MAAM,QAAQ,IAAI,UAAU;EAC9B;CACF;CAEA,OAAO;EAAE;EAAU;CAAQ;AAC7B;;;;;;;;;;AAWA,eAAe,QAAQ,IAAe,YAA6C;CACjF,IAAI,aAAmD;CACvD,IAAI;EACF,MAAM,IAAI,SAAe,YAAY;GACnC,aAAa,iBAAiB;IAC5B,WAAW,OAAO;KAAE,MAAM;KAAmB,YAAY;IAAmB,CAAC;IAC7E,QAAQ;GACV,GAAG,kBAAkB;GAErB,QAAQ,QAAQ,CAAC,CACd,WAAW,GAAG,CAAC,CAAC,CAChB,WACO;IACJ,IAAI,YAAY,aAAa,UAAU;IACvC,QAAQ;GACV,IACC,QAAiB;IAChB,IAAI,YAAY,aAAa,UAAU;IACvC,WAAW,OAAO;KAChB,MAAM;KACN,OAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;IACxD,CAAC;IACD,QAAQ;GACV,CACF;EACJ,CAAC;CACH,UAAU;EACR,IAAI,YAAY,aAAa,UAAU;CACzC;AACF;;;AClFA,IAAa,gBAAb,cAAmC,MAAM;CACvC,OAAgB;CAChB;CACA,YAAY,SAAiB,YAAoB;EAC/C,MAAM,OAAO;EACb,KAAK,OAAO;EACZ,KAAK,aAAa;CACpB;AACF;AAEA,IAAa,kBAAb,cAAqC,MAAM;CACzC,OAAgB;CAChB;CACA;CACA,YAAY,YAAoB,SAAkB,SAAkB;EAClE,MAAM,WAAW,gBAAgB,YAAY;EAC7C,KAAK,OAAO;EACZ,KAAK,aAAa;EAClB,KAAK,UAAU;CACjB;AACF;AAEA,IAAa,0BAAb,cAA6C,MAAM;CACjD,OAAgB;CAChB;CACA,YAAY,SAAiB,QAAoC;EAC/D,MAAM,OAAO;EACb,KAAK,OAAO;EACZ,KAAK,SAAS;CAChB;AACF;AAEA,IAAa,uBAAb,cAA0C,MAAM;CAC9C,OAAgB;CAChB;CACA,YAAY,SAAiB,SAAkB;EAC7C,MAAM,WAAW,wCAAwC,SAAS;EAClE,KAAK,OAAO;EACZ,KAAK,UAAU;CACjB;AACF;AAEA,IAAa,gBAAb,cAAmC,MAAM;CACvC,OAAgB;CAChB;CACA;CACA;CACA,YACE,UAAU,WACV,WAII,CAAC,GACL;EACA,MAAM,OAAO;EACb,KAAK,OAAO;EACZ,IAAI,SAAS,WAAW,KAAA,GAAW,KAAK,SAAS,SAAS;EAC1D,KAAK,aAAa,SAAS,cAAc;EACzC,IAAI,SAAS,wBAAwB,KAAA,GACnC,KAAK,sBAAsB,SAAS;CAExC;AACF;;;;;;;;;;AAWA,SAAgB,sBACd,KACwC;CACxC,OAAO,eAAe,mBAAmB,eAAe;AAC1D;;;ACvEA,MAAa,4BAA4B;;;;;;;;;;AAiBzC,SAAgB,yBACd,MACA,kBAAkB,2BACA;CAClB,MAAM,SAA4B,CAAC;CACnC,IAAI,UAAU;CACd,IAAI,SAAS;CACb,IAAI,iBAAiB;CACrB,IAAI,SAAoE;CAExE,SAAS,QAAQ,OAA8B;EAC7C,IAAI,QAAQ;EACZ,IAAI,QAAQ;GACV,MAAM,UAAU;GAChB,SAAS;GACT,QAAQ;IAAE,OAAO;IAAO,MAAM;GAAM,CAAC;GACrC;EACF;EACA,IAAI,OAAO,UAAU,iBAAiB;GACpC,OAAO,MAAM;GACb,WAAW;GACX;EACF;EACA,OAAO,KAAK,KAAK;CACnB;CAEA,SAAS,QAAc;EACrB,IAAI,QAAQ;EACZ,SAAS;EACT,IAAI,UAAU,KAAK,CAAC,gBAAgB;GAClC,iBAAiB;GACjB,OAAO,KAAK;IAAE,MAAM;IAAkB,OAAO;GAAQ,CAAC;EACxD;EACA,IAAI,QAAQ;GACV,MAAM,UAAU;GAChB,SAAS;GACT,QAAQ;IAAE,OAAO,KAAA;IAAW,MAAM;GAAK,CAAC;EAC1C;CACF;CA2CA,OAAO;EAAE,QAAA;GAxCP,SAAS,UAAU;IACjB,KAAK,OAAO,KAAK;IACjB,QAAQ,KAAK;GACf;GACA,aAAa,MAAM,SAAS;IAC1B,MAAM,KAAK,KAAK,WAAW,MAAM,IAAI;IACrC,QAAQ;KAAE,MAAM;KAAc,SAAS;KAAI;KAAM,GAAG;IAAK,CAAC;IAC1D,OAAO;GACT;GACA,WAAW,IAAI,SAAS;IACtB,KAAK,SAAS,IAAI,IAAI;IACtB,QAAQ;KAAE,MAAM;KAAY,SAAS;KAAI,GAAG;IAAK,CAAC;GACpD;EA4BY;EAAG,QAAA,EAxBf,CAAC,OAAO,iBAAiB;GACvB,OAAO;IACL,OAAiD;KAC/C,IAAI,OAAO,SAAS,GAAG;MACrB,MAAM,aAAa,OAAO,MAAM;MAChC,IAAI,eAAe,KAAA,GACjB,OAAO,QAAQ,QAAQ;OAAE,OAAO;OAAY,MAAM;MAAM,CAAC;KAE7D;KACA,IAAI,QACF,OAAO,QAAQ,QAAQ;MAAE,OAAO,KAAA;MAAW,MAAM;KAAK,CAAC;KAEzD,OAAO,IAAI,SAA0C,YAAY;MAC/D,SAAS;KACX,CAAC;IACH;IACA,SAAmD;KACjD,MAAM;KACN,OAAO,QAAQ,QAAQ;MAAE,OAAO,KAAA;MAAW,MAAM;KAAK,CAAC;IACzD;GACF;EACF,EAGoB;EAAG;CAAM;AACjC;;;;;;;;;;;;;;;;;;;ACjFA,MAAM,2BAAW,IAAI,IAAwB;;;;;;;AAQ7C,SAAgB,cAAc,MAAc,IAAsB;CAChE,SAAS,IAAI,MAAM,EAAE;AACvB;;;;;;;;;;AAWA,SAAgB,mBACd,MACA,UACQ;CACR,MAAM,UAAU,KAAK,SAAS;CAC9B,OAAO,OAAO,YAAY,YAAY,QAAQ,SAAS,IAAI,UAAU;AACvE;;;;;;;;;;;AAYA,SAAgB,qBAAqB,MAAoB;CACvD,cAAc,MAAM,OAAO,MAAM,OAAO,QAAQ;EAC9C,MAAM,QAAQ,mBAAmB,MAAM,IAAI;EAC3C,MAAM,YAAqC,EAAE,IAAI,KAAK,GAAG;EACzD,IAAI,IAAI,mBAAmB,KAAA,GACzB,UAAU,oBAAoB,IAAI;EAEpC,MAAM,UAAU,IAAI,WAAW,WAAW,OAAO,SAAS;EAC1D,MAAM,YAAwB;GAAE,GAAG;GAAK,gBAAgB;EAAQ;EAChE,IAAI;GACF,MAAM,MAAM,MAAM,KAAK,IAAI,OAAO,SAAS;GAC3C,IAAI,WAAW,SAAS,SAAS,EAAE,IAAI,KAAK,GAAG,CAAC;GAChD,OAAO;EACT,SAAS,KAAK;GACZ,IAAI,WAAW,SAAS,SAAS;IAC/B,IAAI,KAAK;IACT,OAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;GACxD,CAAC;GACD,MAAM;EACR;CACF,CAAC;AACH;AAmBA,MAAM,8BAAc,IAAI,IAAqB;AAC7C,IAAI,2BAA2B;AAC/B,IAAI,iBAAsC;AAC1C,IAAI,kBAAuC;;;;;;;;AAS3C,SAAS,yBAA+B;CACtC,IAAI,0BAA0B;CAC9B,2BAA2B;CAC3B,MAAM,aAAa,sBAA8B;EAC/C,KAAK,MAAM,cAAc,aACvB,WAAW,MAAM,IAAI,cAAc,YAAY,eAAe,EAAE,QAAQ,EAAE,QAAQ,YAAY,EAAE,CAAC,CAAC;CAEtG;CACA,iBAAiB,UAAU,QAAQ;CACnC,kBAAkB,UAAU,SAAS;CACrC,QAAQ,GAAG,UAAU,cAAc;CACnC,QAAQ,GAAG,WAAW,eAAe;AACvC;;;;;;;AAQA,SAAS,0BAAgC;CACvC,IAAI,CAAC,0BAA0B;CAC/B,IAAI,YAAY,OAAO,GAAG;CAC1B,2BAA2B;CAC3B,IAAI,gBAAgB,QAAQ,IAAI,UAAU,cAAc;CACxD,IAAI,iBAAiB,QAAQ,IAAI,WAAW,eAAe;CAC3D,iBAAiB;CACjB,kBAAkB;AACpB;AAEA,MAAM,cAAgC;CACpC,cAAc,CAAC;CACf,aAAa,SAAS,GAAG,KAAK,GAAG,WAAW,CAAC,CAAC,MAAM,GAAG,CAAC;CACxD,gBAAgB,CAAC;AACnB;;;;;;;;;;AAWA,SAAS,gBAAgB,OAAyB,QAAkC;CAClF,MAAM,cACJ,SAC4B;EAC5B,MAAM,MAA+B,EAAE,GAAG,KAAK;EAC/C,IAAI,EAAE,YAAY,MAAM,IAAI,YAAY;EACxC,IAAI,EAAE,QAAQ,MAAM,IAAI,QAAQ,KAAK,IAAI;EACzC,OAAO;CACT;CACA,OAAO;EACL,SAAS,UAAU;GACjB,IAAI,YAAY,SAAS,QAAQ,OAAO;IACtC,MAAM,OAAO,KAAK;IAClB;GACF;GACA,MAAM,QAAiC,CAAC;GACxC,IAAI,EAAE,YAAY,QAAQ,MAAM,YAAY;GAC5C,IAAI,EAAE,QAAQ,QAAQ,MAAM,QAAQ,KAAK,IAAI;GAC7C,MAAM,OAAO;IAAE,GAAG;IAAO,GAAG;GAAM,CAAC;EACrC;EACA,aAAa,MAAM,SAAS,MAAM,WAAW,MAAM,WAAW,IAAI,CAAC;EACnE,WAAW,IAAI,SAAS;GACtB,MAAM,SAAS,IAAI,WAAW,IAAI,CAAC;EACrC;CACF;AACF;;;;;;;;AASA,eAAsB,cACpB,MACA,OACA,KACY;CACZ,MAAM,UAAU,SAAS,IAAI,KAAK,IAAI;CACtC,IAAI,CAAC,SACH,MAAM,IAAI,MAAM,sBAAsB,KAAK,KAAK,aAAa,KAAK,GAAG,EAAE;CAEzE,IAAI;EAGF,OAAO,MAFc,QAAQ,MAAM,OAAO,GAAG;CAG/C,SAAS,KAAK;EACZ,aAAa,KAAK,KAAK,EAAE;EACzB,MAAM;CACR;AACF;;;;;;;AAQA,SAAgB,aAAa,KAAc,IAAkB;CAC3D,IAAI,QAAQ,QAAQ,OAAO,QAAQ,UAAU;CAC7C,MAAM,WAAW,QAAQ,IAAI,KAAK,MAAM;CACxC,MAAM,OAAiB,MAAM,QAAQ,QAAQ,IACzC,CAAC,IAAI,GAAG,SAAS,QAAQ,MAAmB,OAAO,MAAM,QAAQ,CAAC,IAClE,CAAC,EAAE;CACP,QAAQ,IAAI,KAAK,QAAQ,IAAI;AAC/B;;;;;;;AAQA,SAAgB,iBAAiB,KAAuB;CACtD,IAAI,CAAC,IAAI,MAAM,SAAS;CACxB,MAAM,SAAS,IAAI,MAAM;CACzB,MAAM,kBAAkB,QAAQ,SAAS,IAAI,cAAc,WAAW,EAAE,OAAO,CAAC;AAClF;;;;;;;;;AAUA,SAAS,oBACP,YACA,UACY;CACZ,IAAI,aAAa,KAAA,GAAW,aAAa,CAAC;CAC1C,IAAI,SAAS,SAAS;EACpB,WAAW,MAAM,SAAS,MAAM;EAChC,aAAa,CAAC;CAChB;CACA,MAAM,iBAAuB;EAC3B,WAAW,MAAM,SAAS,MAAM;CAClC;CACA,SAAS,iBAAiB,SAAS,UAAU,EAAE,MAAM,KAAK,CAAC;CAC3D,aAAa;EACX,SAAS,oBAAoB,SAAS,QAAQ;CAChD;AACF;;;;;;;;;;AAgBA,SAAS,UACP,MACA,OACA,SACA,iBACgB;CAChB,MAAM,0BAA0B,QAAQ,4BAA4B;CACpE,MAAM,cAAc,QAAQ,cAAc;CAC1C,MAAM,YAAY,oBAAoB;CAEtC,MAAM,aAAa,IAAI,gBAAgB;CACvC,MAAM,eAAe,oBAAoB,YAAY,QAAQ,KAAK;CAClE,MAAM,SAAS,WAAW;CAE1B,IAAI,gBAAgD,qBAAqB;CACzE,IAAI,eAAoC;CACxC,IAAI,QAA0B;CAE9B,IAAI,WAAW;EAIb,MAAM,UAAU,yBAAyB,aAAa,eAAe;EACrE,QAAQ,QAAQ;EAChB,gBAAgB,QAAQ;EACxB,eAAe,QAAQ;CACzB;CAEA,MAAM,SAA2B,gBAAgB,OAAO,MAAM;CAE9D,MAAM,UAAU,wBAAwB,MAAM;CAE9C,MAAM,MAAkB;EACtB;EACA,YAAY;EACZ,uBAAO,IAAI,IAAI;EACf,OAAO,WAAW;EAClB,OAAO,UAAU;GACf,OAAO,OAAO;IAAE,GAAG;IAAO,MAAM;GAAO,CAAC;EAC1C;EACA,aAAa,OAAO;GAClB,QAAQ,SAAS,EAAE;EACrB;EACA,kBAAkB,QAAQ;EAC1B,aAAa,QAAQ;EACrB;CACF;CAEA,YAAY,IAAI,UAAU;CAC1B,IAAI,yBACF,uBAAuB;CAGzB,MAAM,UAAU,YAAwB;EACtC,IAAI;GAIF,iBAAiB,GAAG;GACpB,OAAO,MAAM,cAAc,MAAM,OAAO,GAAG;EAC7C,SAAS,KAAK;GACZ,IAAI,WAAW,OAAO,WAAW,EAAE,eAAe,gBAAgB;IAChE,MAAM,SAAS,WAAW,OAAO;IACjC,IAAI,kBAAkB,eAAe,MAAM;GAC7C;GACA,MAAM;EACR,UAAU;GACR,IAAI;IACF,MAAM,QAAQ,QAAQ;GACxB,UAAU;IACR,aAAa;IACb,YAAY,OAAO,UAAU;IAC7B,wBAAwB;IACxB,IAAI,cAAc,aAAa;GACjC;EACF;CACF,EAAA,CAAG;CAEH,OAAO;EAAE,QAAQ;EAAe;CAAO;AACzC;;;;;;;AAQA,SAAS,uBAAuD;CAC9D,OAAO,EACL,CAAC,OAAO,iBAAiB;EACvB,OAAO,EACL,YACE,QAAQ,QAAQ;GAAE,OAAO,KAAA;GAAW,MAAM;EAAK,CAAoC,EACvF;CACF,EACF;AACF;;;;AAKA,eAAe,SACb,MACA,OACA,UAAsB,CAAC,GACX;CACZ,MAAM,EAAE,WAAW,UAAU,MAAM,OAAO,SAAS,IAAI;CACvD,OAAO;AACT;;;;AAKA,SAAS,WACP,MACA,OACA,UAAsB,CAAC,GACA;CACvB,MAAM,EAAE,QAAQ,WAAW,UAAU,MAAM,OAAO,SAAS,yBAAyB;CACpF,OAAO;EAAE;EAAQ;CAAO;AAC1B;;;;;;;;;AAUA,MAAa,MAAuD,OAAO,OAAO,UAAU,EAC1F,QAAQ,WACV,CAAC;;;;;;;;;;;;;;;;ACtZD,IAAI,eAAe;;;;AAKnB,SAAS,eAAuB;CAC9B,gBAAgB;CAChB,OAAO,QAAQ;AACjB;AAWA,SAAgB,KACd,UACA,UACA,MACY;CACZ,IAAI,OAAO,aAAa,YACtB,OAAO;EACL,IAAI,aAAa;EACjB,MAAM;EACN,KAAK;EACL,WAAW;CACb;CAEF,IAAI,OAAO,aAAa,YACtB,MAAM,IAAI,UAAU,qCAAqC;CAE3D,IAAI,MACF,OAAO;EACL,IAAI;EACJ,MAAM;EACN,KAAK;EACL;CACF;CAEF,OAAO;EACL,IAAI;EACJ,MAAM;EACN,KAAK;CACP;AACF;AAEA,qBAAqB,MAAM;;;;;;;;;AClD3B,SAAgBA,UAAQ,OAAiD;CACvE,IAAI,OAAO,UAAU,YAAY,UAAU,MAAM,OAAO;CACxD,IAAI,EAAE,QAAQ,UAAU,EAAE,UAAU,UAAU,EAAE,SAAS,QAAQ,OAAO;CACxE,MAAM,EAAE,IAAI,MAAM,QAAQ;CAC1B,OAAO,OAAO,OAAO,YAAY,OAAO,SAAS,YAAY,OAAO,QAAQ;AAC9E;;;;;;;;;;;;;;;;;;;ACDA,MAAM,SAAS;;;;AA8Bf,SAAS,cAAoB,MAAkB,SAAmC;CAChF,MAAM,QAAkB,CAAC;CACzB,MAAM,SAAS,QAAQ,SAAS,MAAM;CACtC,YAAY,MAAM,GAAG,uBAAO,IAAI,IAAI,GAAG,MAAM;CAC7C,OAAO,MAAM,KAAK,IAAI;AACxB;;;;AAKA,SAAS,cAAoB,MAAkB,SAAqC;CAClF,MAAM,SAAS,QAAQ,SAAS,MAAM;CACtC,OAAO,YAAY,sBAAM,IAAI,IAAI,GAAG,MAAM;AAC5C;;;;;AAMA,MAAa,WAGT,OAAO,OAAO,eAAe,EAAE,MAAM,cAAc,CAAC;;;;;;;;AASxD,SAAS,YACP,MACA,OACA,OACA,MACA,QACM;CACN,MAAM,SAAS,OAAO,OAAO,KAAK;CAClC,IAAI,KAAK,IAAI,IAAI,GAAG;EAClB,IAAI,QAAQ,MAAM,IAAI,qBAAqB,KAAK,EAAE;EAClD,MAAM,KAAK,GAAG,OAAO,UAAU,KAAK,GAAG,EAAE;EACzC;CACF;CACA,KAAK,IAAI,IAAI;CACb,IAAI;EACF,MAAM,UAAU,KAAK,SAAS;EAC9B,MAAM,QAAQ,OAAO,YAAY,YAAY,QAAQ,SAAS,IAAI,UAAU,KAAK;EACjF,MAAM,KAAK,GAAG,SAAS,MAAM,GAAG,KAAK,GAAG,EAAE;EAC1C,IAAI,KAAK,QACP,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,KAAK,MAAM,GAAG;GACtD,IAAI,QAAQ,gBAAgB;GAC5B,MAAM,KAAK,GAAG,SAAS,SAAS,IAAI,IAAI,kBAAkB,OAAO,MAAM,MAAM,GAAG;EAClF;EAEF,IAAI,KAAK,YAAY,KAAK,SAAS,SAAS,GAC1C,KAAK,MAAM,SAAS,KAAK,UACvB,YAAY,OAAO,QAAQ,GAAG,OAAO,MAAM,MAAM;CAGvD,UAAU;EACR,KAAK,OAAO,IAAI;CAClB;AACF;;;;;;;;AASA,SAAS,kBAAkB,OAAgB,MAAY,QAAyB;CAC9E,IAAI,OAAO,UAAU,YAAY;EAC/B,MAAM,OAAO,OAAO,MAAM,SAAS,YAAY,MAAM,KAAK,SAAS,IAAI,MAAM,OAAO;EACpF,OAAO,OAAO,OAAO,KAAK,KAAK;CACjC;CACA,IAAI,UAAU,MAAM,OAAO;CAC3B,IAAI,UAAU,KAAA,GAAW,OAAO;CAChC,IAAI,cAAc,KAAK,GAAG,OAAO;CACjC,IAAIC,UAAQ,KAAK,GAAG;EAClB,IAAI,KAAK,IAAI,KAAK,GAAG;GACnB,IAAI,QAAQ,MAAM,IAAI,qBAAqB,MAAM,EAAE;GACnD,OAAO,WAAW,MAAM,GAAG;EAC7B;EACA,OAAO,GAAG,MAAM,KAAK,GAAG,MAAM,GAAG;CACnC;CACA,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO,IAAI,MAAM,KAAK,SAAkB,kBAAkB,MAAM,MAAM,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE;CAE5F,IAAI,OAAO,UAAU,UAInB,OAAO,KAHS,OAAO,QAAQ,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,KAC1C,CAAC,GAAG,OAA0B,GAAG,EAAE,IAAI,kBAAkB,GAAG,MAAM,MAAM,GAEzD,CAAC,CAAC,KAAK,IAAI,EAAE;CAEjC,IAAI,OAAO,UAAU,UAAU,OAAO,KAAK,UAAU,KAAK;CAC1D,IAAI,OAAO,UAAU,UAAU,OAAO,GAAG,MAAM,SAAS,EAAE;CAC1D,IAAI,OAAO,UAAU,UAAU,OAAO,MAAM,SAAS;CACrD,IAAI,OAAO,UAAU,YAAY,OAAO,UAAU,WAAW,OAAO,OAAO,KAAK;CAChF,OAAO,KAAK,UAAU,KAAK;AAC7B;;;;;;;AAQA,SAAS,YACP,MACA,MACA,QACU;CACV,IAAI,KAAK,IAAI,IAAI,GAAG;EAClB,IAAI,QAAQ,MAAM,IAAI,qBAAqB,KAAK,EAAE;EAClD,OAAO;GAAE,MAAM;GAAW,IAAI,KAAK;EAAG;CACxC;CACA,KAAK,IAAI,IAAI;CACb,IAAI;EACF,MAAM,SAMF;GAAE,MAAM,KAAK;GAAM,IAAI,KAAK;EAAG;EACnC,IAAI,KAAK,QAAQ;GACf,MAAM,SAAuC,CAAC;GAC9C,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,KAAK,MAAM,GACnD,OAAO,OAAO,kBAAkB,OAAO,MAAM,MAAM;GAErD,OAAO,SAAS;EAClB;EACA,IAAI,KAAK,YAAY,KAAK,SAAS,SAAS,GAC1C,OAAO,WAAW,KAAK,SAAS,KAAK,UAAU,YAAY,OAAO,MAAM,MAAM,CAAC;EAEjF,IAAI,KAAK,MACP,OAAO,OAAO,KAAK;EAErB,OAAO;CACT,UAAU;EACR,KAAK,OAAO,IAAI;CAClB;AACF;;;;;;;;;AAUA,SAAS,kBAAkB,OAAgB,MAAY,QAA4B;CACjF,IAAI,OAAO,UAAU,YAAY;EAC/B,MAAM,OAAO,OAAO,MAAM,SAAS,YAAY,MAAM,KAAK,SAAS,IAAI,MAAM,OAAO;EACpF,OAAO,OAAO;GAAE,MAAM;GAAQ;EAAK,IAAI,EAAE,MAAM,OAAO;CACxD;CACA,IAAI,UAAU,MAAM,OAAO;CAC3B,IAAI,UAAU,KAAA,GAAW,OAAO;CAChC,IAAI,cAAc,KAAK,GAAG,OAAO,EAAE,MAAM,WAAW;CACpD,IAAIA,UAAQ,KAAK,GAAG;EAClB,IAAI,KAAK,IAAI,KAAK,GAAG;GACnB,IAAI,QAAQ,MAAM,IAAI,qBAAqB,MAAM,EAAE;GACnD,OAAO;IAAE,MAAM;IAAW,IAAI,MAAM;GAAG;EACzC;EACA,OAAO;GAAE,MAAM,MAAM;GAAM,IAAI,MAAM;EAAG;CAC1C;CACA,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO,MAAM,KAAK,SAAkB,kBAAkB,MAAM,MAAM,MAAM,CAAC;CAE3E,IAAI,OAAO,UAAU,UAAU;EAC7B,MAAM,MAAoC,CAAC;EAC3C,KAAK,MAAM,CAAC,GAAG,MAAM,OAAO,QAAQ,EAAE,GAAG,MAAM,CAAC,GAC9C,IAAI,KAAK,kBAAkB,GAAG,MAAM,MAAM;EAE5C,OAAO;CACT;CACA,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,OAAO,UAAU,YAAY,OAAO,UAAU,WAAW,OAAO;CACpE,IAAI,OAAO,UAAU,UAAU,OAAO,GAAG,MAAM,SAAS,EAAE;CAC1D,IAAI,OAAO,UAAU,UAAU,OAAO,MAAM,SAAS;CACrD,OAAO,KAAK,UAAU,KAAK;AAC7B;;;;;AAMA,SAAS,cAAc,OAAyB;CAC9C,IAAI,OAAO,UAAU,YAAY,UAAU,MAAM,OAAO;CACxD,OAAO,UAAU,SAAS,UAAU;AACtC;;;;;;;;;;AC5NA,IAAI,mBAAmB;;;;AAKvB,SAASC,aAAkB;CACzB,oBAAoB;CACpB,OAAO,YAAY;AACrB;;;;;;;;AAaA,SAAgB,SACd,UACA,SACkD;CAClD,IAAI,CAAC,MAAM,QAAQ,QAAQ,GACzB,MAAM,IAAI,UACR,+DAA+D,OAAO,SAAS,2DACjF;CAEF,SAAS,SAAS,OAAO,UAAU;EACjC,IAAIC,UAAQ,KAAK,GAAG;EAKpB,MAAM,IAAI,UACR,gCAAgC,MAAM,uBAAuB,OAAO,QAJpE,OAAO,UAAU,aACb,sFACA,IAGN;CACF,CAAC;CAED,MAAM,KAAKD,WAAQ;CACnB,MAAM,eAAe;CACrB,MAAM,SAAS,OAAO,OAAgB,QAAsC;EAC1E,IAAI,MAAe;EACnB,KAAK,MAAM,SAAS,cAAc;GAChC,iBAAiB,GAAG;GACpB,MAAM,MAAM,cAAc,OAAO,KAAK,GAAG;EAC3C;EACA,OAAO;CACT;CAEA,MAAM,cACJ,SAAS,SAAS,KAAA,IAAY,KAAA,IAAY,EAAE,cAAc,QAAQ,KAAK;CAGzE,OAAO;EACL;EACA,MAAM;EACN;EACA,GAAI,cAAc,EAAE,QAAQ,YAAY,IAAI,CAAC;EAC7C,KAAK;CACP;AACF;AAEA,qBAAqB,UAAU;;;;;;;;;;;;;;;;;;;;AC3D/B,IAAI,mBAAmB;;;;AAKvB,SAASE,YAAkB;CACzB,oBAAoB;CACpB,OAAO,YAAY;AACrB;;;;;;;;;AAcA,SAAgB,SACd,SACA,SACoC;CACpC,MAAM,KAAKA,UAAQ;CACnB,MAAM,UAAqD,OAAO,QAAQ,OAAO;CACjF,MAAM,aAAqC,QAAQ,KAAK,GAAG,OAAO,CAAC;CACnE,MAAM,OAA8B,QAAQ,KAAK,CAAC,OAAO,CAAC;CAE1D,MAAM,SAAS,OAAO,OAAU,QAAwD;EACtF,MAAM,cAAc,QAAQ,UAAU,IAAI,gBAAgB,CAAC;EAC3D,MAAM,wBAA8B;GAClC,KAAK,MAAM,KAAK,aAAa,EAAE,MAAM,IAAI,MAAM,MAAM;EACvD;EACA,IAAI,IAAI,MAAM,SACZ,gBAAgB;OAEhB,IAAI,MAAM,iBAAiB,SAAS,iBAAiB,EAAE,MAAM,KAAK,CAAC;EAGrE,IAAI;GACF,MAAM,UAAU,MAAM,QAAQ,IAC5B,QAAQ,IAAI,OAAO,CAAC,KAAK,QAAQ,QAAQ;IACvC,MAAM,QAAQ,YAAY;IAC1B,IAAI,CAAC,OAAO,MAAM,IAAI,MAAM,8BAA8B;IAC1D,MAAM,WAAW,YAAY,IAAI,CAAC,IAAI,OAAO,MAAM,MAAM,CAAC;IAC1D,MAAM,YAAwB;KAAE,GAAG;KAAK,OAAO;IAAS;IACxD,IAAI;KAEF,OAAO;MAAE,QAAQ;MAAe;MAAK,OAAA,MADjB,cAAc,OAAO,OAAO,SAAS;KACd;IAC7C,SAAS,KAAK;KACZ,OAAO;MAAE,QAAQ;MAAgB;MAAK;KAAI;IAC5C;GACF,CAAC,CACH;GAEA,IAAI,IAAI,MAAM,SAAS;IACrB,MAAM,SAAS,IAAI,MAAM;IACzB,MAAM,kBAAkB,QAAQ,SAAS,IAAI,cAAc,WAAW,EAAE,OAAO,CAAC;GAClF;GAEA,IAAI;GACJ,IAAI,UAAU;GACd,IAAI;GACJ,IAAI,gBAAgB;GACpB,KAAK,MAAM,KAAK,SAAS;IACvB,IAAI,EAAE,WAAW,OAAO;IACxB,IAAI,CAAC,SAAS;KACZ,YAAY,EAAE;KACd,UAAU;IACZ;IACA,IAAI,CAAC,iBAAiB,EAAE,eAAe,iBAAiB;KACtD,YAAY,EAAE;KACd,gBAAgB;IAClB;GACF;GACA,IAAI,eAAe,MAAM;GACzB,IAAI,SAAS,MAAM;GAEnB,MAAM,MAA+B,CAAC;GACtC,KAAK,MAAM,KAAK,SACd,IAAI,EAAE,WAAW,MAAM,IAAI,EAAE,OAAO,EAAE;GAGxC,OAAO;EACT,UAAU;GACR,IAAI,MAAM,oBAAoB,SAAS,eAAe;EACxD;CACF;CAEA,MAAM,cAAuC,EAAE,KAAK;CACpD,IAAI,SAAS,SAAS,KAAA,GAAW,YAAY,kBAAkB,QAAQ;CAEvE,OAAO;EACL;EACA,MAAM;EACN,UAAU;EACV,QAAQ;EACR,KAAK;CACP;AACF;AAEA,qBAAqB,UAAU;;;;;;;;;;ACpH/B,IAAI,iBAAiB;;;;AAKrB,SAASC,YAAkB;CACzB,kBAAkB;CAClB,OAAO,UAAU;AACnB;;;;;;;;AASA,SAAgB,OAAa,QAAwC;CACnE,MAAM,KAAKA,UAAQ;CACnB,MAAM,EAAE,MAAM,MAAM,WAAW,WAAW,gBAAgB,SAAS;CAEnE,MAAM,SAAS,OAAO,OAAU,QAAgC;EAG9D,OAAO,cADW,MADC,KAAK,KAAK,IACJ,YAAY,gBACL,OAAO,GAAG;CAC5C;CAEA,MAAM,cAAuC;EAAE;EAAM,MAAM;EAAW,WAAW;CAAe;CAChG,IAAI,SAAS,KAAA,GAAW,YAAY,kBAAkB;CAEtD,OAAO;EACL;EACA,MAAM;EACN,UAAU,CAAC,WAAW,cAAc;EACpC,QAAQ;EACR,KAAK;CACP;AACF;AAEA,qBAAqB,QAAQ;;;;;;;;;;;;;;;;AChC7B,IAAI,cAAc;;;;AAKlB,SAASC,YAAkB;CACzB,eAAe;CACf,OAAO,OAAO;AAChB;;;;;;;;AASA,SAAgB,IACd,QACuB;CACvB,MAAM,KAAKA,UAAQ;CACnB,MAAM,EAAE,OAAO,IAAI,UAAU,aAAa,SAAS;CAEnD,MAAM,SAAS,OAAO,OAAc,QAAuC;EACzE,MAAM,OAAO,MAAM,MAAM,KAAK;EAC9B,IAAI,KAAK,WAAW,GAAG,OAAO,CAAC;EAC/B,MAAM,UAAoB,MAAM,KAAK,EAAE,QAAQ,KAAK,OAAO,CAAC;EAE5D,MAAM,QAAQ,gBAAgB,KAAA,IAAY,KAAK,SAAS,KAAK,IAAI,GAAG,WAAW;EAC/E,MAAM,cAAiC,CAAC;EAExC,MAAM,wBAA8B;GAClC,KAAK,MAAM,KAAK,aAAa,EAAE,MAAM,IAAI,MAAM,MAAM;EACvD;EACA,IAAI,IAAI,MAAM,SACZ,gBAAgB;OAEhB,IAAI,MAAM,iBAAiB,SAAS,iBAAiB,EAAE,MAAM,KAAK,CAAC;EAGrE,IAAI,SAAS;EACb,IAAI,eAAwB,KAAA;EAE5B,MAAM,UAAU,OAAO,QAA+B;GACpD,MAAM,QAAQ,IAAI,gBAAgB;GAClC,YAAY,KAAK,KAAK;GACtB,MAAM,WAAW,YAAY,IAAI,CAAC,IAAI,OAAO,MAAM,MAAM,CAAC;GAC1D,MAAM,YAAwB;IAAE,GAAG;IAAK,OAAO;GAAS;GACxD,MAAM,aAAa,KAAK;GAExB,MAAM,QAAQ,MAAM,cAAc,UAAU,YAAoB,SAAS;GACzE,QAAQ,OAAO;EACjB;EAEA,MAAM,SAAS,YAA2B;GACxC,OAAO,MAAM;IACX,IAAI,IAAI,MAAM,WAAW,iBAAiB,KAAA,GAAW;IACrD,MAAM,MAAM;IACZ,UAAU;IACV,IAAI,OAAO,KAAK,QAAQ;IACxB,IAAI;KACF,MAAM,QAAQ,GAAG;IACnB,SAAS,KAAK;KACZ,IAAI,iBAAiB,KAAA,GAAW,eAAe;KAC/C;IACF;GACF;EACF;EAEA,IAAI;GACF,MAAM,eAAe,KAAK,IAAI,OAAO,KAAK,MAAM;GAChD,MAAM,UAA2B,CAAC;GAClC,KAAK,IAAI,IAAI,GAAG,IAAI,cAAc,KAAK,GACrC,QAAQ,KAAK,OAAO,CAAC;GAEvB,MAAM,QAAQ,IAAI,OAAO;GAEzB,IAAI,IAAI,MAAM,SAAS;IACrB,MAAM,SAAS,IAAI,MAAM;IACzB,MAAM,kBAAkB,QAAQ,SAAS,IAAI,cAAc,WAAW,EAAE,OAAO,CAAC;GAClF;GACA,IAAI,iBAAiB,KAAA,GAAW,MAAM;GAEtC,OAAO;EACT,UAAU;GACR,IAAI,MAAM,oBAAoB,SAAS,eAAe;EACxD;CACF;CAEA,MAAM,cAAuC,EAAE,MAAM;CACrD,IAAI,gBAAgB,KAAA,GAAW,YAAY,iBAAiB;CAC5D,IAAI,SAAS,KAAA,GAAW,YAAY,kBAAkB;CAEtD,OAAO;EACL;EACA,MAAM;EACN,UAAU,CAAC,QAAQ;EACnB,QAAQ;EACR,KAAK;CACP;AACF;AAEA,qBAAqB,KAAK;;;;;;;;;ACpH1B,IAAI,eAAe;;;;AAKnB,SAASC,YAAkB;CACzB,gBAAgB;CAChB,OAAO,QAAQ;AACjB;;;;;;;;AAaA,SAAgB,KACd,OACA,IACA,SACY;CACZ,IAAI,CAACC,UAAQ,KAAK,GAEhB,MAAM,IAAI,UAAU,8CAA8C,OAAO,QAD5D,OAAO,UAAU,aAAa,0CAA0C,IACE;CAEzF,IAAI,OAAO,OAAO,YAAY;EAC5B,IAAIA,UAAQ,EAAE,GACZ,MAAM,IAAI,UACR,+GACF;EAEF,MAAM,IAAI,UAAU,+CAA+C,OAAO,IAAI;CAChF;CACA,IAAIA,UAAQ,OAAO,GACjB,MAAM,IAAI,UACR,uHACF;CAGF,MAAM,KAAKD,UAAQ;CAEnB,MAAM,SAAS,OAAO,OAAU,QAAgC;EAE9D,OAAO,GAAG,MADiB,cAAc,OAAO,OAAO,GAAG,CACpC;CACxB;CAEA,MAAM,cAAuC,EAAE,GAAG;CAClD,IAAI,SAAS,SAAS,KAAA,GAAW,YAAY,kBAAkB,QAAQ;CAEvE,OAAO;EACL;EACA,MAAM;EACN,UAAU,CAAC,KAAK;EAChB,QAAQ;EACR,KAAK;CACP;AACF;AAEA,qBAAqB,MAAM;;;;;;;;;;;AC/B3B,SAAgB,gBAAgB,QAAuB,SAAyB;CAC9E,MAAM,OAAO,OAAO,mBAAmB,KAAK;CAC5C,MAAM,SAAS,OAAO,SAAS,KAAK,OAAO,IAAI,OAAO,mBAAmB;CACzE,OAAO,KAAK,IAAI,OAAO,QAAQ,OAAO,YAAY;AACpD;;;;;;;;;AAUA,SAAgB,gBACd,IACA,QACA,UACe;CACf,IAAI,MAAM,GAAG,OAAO,QAAQ,QAAQ;CACpC,OAAO,IAAI,SAAe,SAAS,WAAW;EAC5C,IAAI,OAAO,SAAS;GAClB,OAAO,SAAS,OAAO,MAAM,CAAC;GAC9B;EACF;EACA,MAAM,QAAQ,iBAAiB;GAC7B,OAAO,oBAAoB,SAAS,QAAQ;GAC5C,QAAQ;EACV,GAAG,EAAE;EACL,MAAM,iBAAuB;GAC3B,aAAa,KAAK;GAClB,OAAO,SAAS,OAAO,MAAM,CAAC;EAChC;EACA,OAAO,iBAAiB,SAAS,UAAU,EAAE,MAAM,KAAK,CAAC;CAC3D,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;;;AClDA,MAAM,qBAAqB;AAC3B,MAAM,uBAAuB;AAW7B,IAAI,gBAAgB;;;;AAKpB,SAASE,YAAkB;CACzB,iBAAiB;CACjB,OAAO,SAAS;AAClB;;;;;;;;;;;;;;;;AAiBA,SAAS,eAAe,QAAwB;CAC9C,OAAO,kBAAkB,QAAQ,SAAS,IAAI,cAAc,WAAW,EAAE,OAAO,CAAC;AACnF;;;;;;;;AASA,SAAgB,MAAY,OAAmB,QAAiC;CAC9E,MAAM,KAAKA,UAAQ;CACnB,MAAM,eAAe,KAAK,IAAI,GAAG,KAAK,MAAM,OAAO,YAAY,CAAC;CAChE,MAAM,aAAa,OAAO,cAAc;CACxC,MAAM,eAAe,OAAO,gBAAgB;CAC5C,MAAM,SAAS,OAAO,UAAU;CAChC,MAAM,WAAW,OAAO;CACxB,MAAM,iBAAgC;EAAE,kBAAkB;EAAY;EAAc;CAAO;CAE3F,MAAM,SAAS,OAAO,OAAU,QAAgC;EAC9D,IAAI,WAAoB,KAAA;EACxB,KAAK,IAAI,UAAU,GAAG,WAAW,cAAc,WAAW,GAAG;GAC3D,IAAI,IAAI,MAAM,SACZ,MAAM,eAAe,IAAI,MAAM,MAAM;GAEvC,IAAI;IACF,OAAO,MAAM,cAAc,OAAO,OAAO,GAAG;GAC9C,SAAS,KAAK;IACZ,IAAI,sBAAsB,GAAG,GAAG,MAAM;IACtC,WAAW;IACX,IAAI,UAAU,SAAS,KAAK,OAAO;IACnC,IAAI,WAAW,cAAc;IAE7B,MAAM,gBADQ,gBAAgB,gBAAgB,UAAU,CAC9B,GAAG,IAAI,OAAO,cAAc;GACxD;EACF;EACA,MAAM;CACR;CAEA,MAAM,cAAuC;EAAE;EAAc;EAAY;EAAc;CAAO;CAC9F,IAAI,UAAU,YAAY,cAAc;CACxC,IAAI,OAAO,SAAS,KAAA,GAAW,YAAY,kBAAkB,OAAO;CAEpE,OAAO;EACL;EACA,MAAM;EACN,UAAU,CAAC,KAAK;EAChB,QAAQ;EACR,KAAK;CACP;AACF;AAEA,qBAAqB,OAAO;;;;;;;;;;;;;;;ACrG5B,IAAI,mBAAmB;;;;AAKvB,SAASC,YAAkB;CACzB,oBAAoB;CACpB,OAAO,YAAY;AACrB;;;;;;;;AAcA,SAAgB,SACd,SACA,QACA,SACY;CACZ,MAAM,KAAKA,UAAQ;CACnB,MAAM,UAAU,SAAS;CAEzB,MAAM,SAAS,OAAO,OAAU,QAAgC;EAC9D,IAAI;GACF,OAAO,MAAM,cAAc,SAAS,OAAO,GAAG;EAChD,SAAS,KAAK;GACZ,IAAI,sBAAsB,GAAG,GAAG,MAAM;GAEtC,OAAO,cAAc,QADA,YAAY,KAAA,IAAY,QAAQ,QAAQ,OAAO,GAAG,GAC5B,GAAG;EAChD;CACF;CAEA,MAAM,cACJ,SAAS,SAAS,KAAA,IAAY,KAAA,IAAY,EAAE,cAAc,QAAQ,KAAK;CAEzE,OAAO;EACL;EACA,MAAM;EACN,UAAU,CAAC,SAAS,MAAM;EAC1B,GAAI,cAAc,EAAE,QAAQ,YAAY,IAAI,CAAC;EAC7C,KAAK;CACP;AACF;AAEA,qBAAqB,UAAU;;;;;;;;;;;;;;;;;;ACjD/B,IAAI,kBAAkB;;;;AAKtB,SAASC,YAAkB;CACzB,mBAAmB;CACnB,OAAO,WAAW;AACpB;;;;;;;;AAaA,SAAgB,QACd,OACA,IACA,SACY;CACZ,MAAM,KAAKA,UAAQ;CAEnB,MAAM,SAAS,OAAO,OAAU,QAAgC;EAC9D,MAAM,QAAQ,IAAI,gBAAgB;EAClC,MAAM,WAAW,YAAY,IAAI,CAAC,IAAI,OAAO,MAAM,MAAM,CAAC;EAC1D,MAAM,YAAwB;GAAE,GAAG;GAAK,OAAO;EAAS;EAExD,IAAI,YAAY;EAChB,MAAM,QAAQ,iBAAiB;GAC7B,YAAY;GACZ,MAAM,MAAM,IAAI,cAAc,iBAAiB,GAAG,KAAK,EAAE,CAAC;EAC5D,GAAG,EAAE;EAEL,MAAM,WAAW,IAAI,SAAgB,GAAG,WAAW;GACjD,MAAM,uBAA6B;IACjC,IAAI,WACF,OAAO,IAAI,cAAc,iBAAiB,GAAG,KAAK,EAAE,CAAC;SAChD;KACL,MAAM,SAAS,IAAI,MAAM;KACzB,OAAO,kBAAkB,QAAQ,SAAS,IAAI,cAAc,WAAW,EAAE,OAAO,CAAC,CAAC;IACpF;GACF;GACA,IAAI,SAAS,SAAS;IACpB,eAAe;IACf;GACF;GACA,SAAS,iBAAiB,SAAS,gBAAgB,EAAE,MAAM,KAAK,CAAC;EACnE,CAAC;EAED,IAAI;GACF,OAAO,MAAM,QAAQ,KAAK,CAAC,cAAc,OAAO,OAAO,SAAS,GAAG,QAAQ,CAAC;EAC9E,UAAU;GACR,aAAa,KAAK;EACpB;CACF;CAEA,MAAM,cAAuC,EAAE,GAAG;CAClD,IAAI,SAAS,SAAS,KAAA,GAAW,YAAY,kBAAkB,QAAQ;CAEvE,OAAO;EACL;EACA,MAAM;EACN,UAAU,CAAC,KAAK;EAChB,QAAQ;EACR,KAAK;CACP;AACF;AAEA,qBAAqB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;ACjD9B,IAAI,eAAe;;;;AAKnB,SAASC,UAAQ,MAAkC;CACjD,gBAAgB;CAChB,OAAO,GAAG,QAAQ,OAAO,GAAG;AAC9B;;;;;;;;;;AAWA,SAAgB,KAAkB,QAA6C;CAC7E,MAAM,EAAE,MAAM,MAAM,OAAO,QAAQ,SAAS;CAC5C,MAAM,eAAe,KAAK,IAAI,GAAG,KAAK,MAAM,OAAO,UAAU,CAAC;CAC9D,MAAM,KAAKA,UAAQ,IAAI;CAEvB,MAAM,SAAS,OAAO,OAAU,QAAgC;EAC9D,IAAI,QAAQ,KAAK,KAAK;EACtB,IAAI,QAAQ;EACZ,IAAI,YAAY;EAEhB,OAAO,QAAQ,cAAc;GAC3B,iBAAiB,GAAG;GACpB,SAAS;GACT,QAAQ,MAAM,cAAc,MAAM,OAAO,GAAG;GAC5C,IAAI,OAAO;IACT,iBAAiB,GAAG;IACpB,MAAM,YAAY,MAAM,cAAc,OAAO,OAAO,GAAG;IACvD,QAAQ,UAAU;IAClB,IAAI,UAAU,MAAM;KAClB,YAAY;KACZ;IACF;GACF;EACF;EAEA,OAAO,OAAO,OAAO;GAAE;GAAW,QAAQ;EAAM,CAAC;CACnD;CAEA,MAAM,cAAuC,EAAE,YAAY,aAAa;CACxE,IAAI,SAAS,KAAA,GAAW,YAAY,kBAAkB;CAKtD,OAAO;EACL;EACA,MAAM;EACN,UAPsD,QACpD,CAAC,MAAM,KAAK,IACZ,CAAC,IAAI;EAMP,QAAQ;EACR,KAAK;CACP;AACF;AAEA,qBAAqB,MAAM;;;;;;;;;;;;;;;;;;ACxF3B,IAAI,kBAAkB;;;;;AAMtB,SAASC,UAAQ,MAAsB;CACrC,mBAAmB;CACnB,OAAO,GAAG,KAAK,GAAG;AACpB;;;;;;;;AASA,SAAgB,QAAc,MAAc,OAA+B;CACzE,IAAI,OAAO,SAAS,YAAY,KAAK,WAAW,GAC9C,MAAM,IAAI,UAAU,uDAAuD;CAE7E,MAAM,KAAKA,UAAQ,IAAI;CAEvB,MAAM,UAAU,OAAU,QAAoC,cAAc,OAAO,OAAO,GAAG;CAE7F,OAAO;EACL;EACA,MAAM;EACN,UAAU,CAAC,KAAK;EAChB,QAAQ,EAAE,cAAc,KAAK;EAC7B,KAAK;CACP;AACF;AAEA,qBAAqB,SAAS;;;;;;;;;;;;;;;ACjC9B,IAAI,qBAAqB;;;;AAKzB,SAAS,UAAkB;CACzB,sBAAsB;CACtB,OAAO,cAAc;AACvB;;;;;;;;;;AAWA,SAAgB,WAAiB,OAAmB,QAAyC;CAC3F,IAAI,MAAM,cAAc,MACtB,MAAM,IAAI,MAAM,iDAAiD;CAGnE,MAAM,KAAK,QAAQ;CACnB,MAAM,WAAW,OAAO;CAExB,MAAM,SAAS,OAAO,OAAU,QAAgC;EAC9D,MAAM,MAAM,OAAO,aAAa,aAAa,SAAS,KAAK,IAAI;EAC/D,MAAM,QAAQ,IAAI;EAElB,IAAI,OAAO;GACT,IAAI,SAAkB,KAAA;GACtB,IAAI,MAAM;GACV,IAAI;IACF,SAAS,MAAM,MAAM,IAAI,GAAG;IAC5B,MAAM,WAAW,QAAQ,WAAW,KAAA;GACtC,QAAQ;IACN,MAAM;GACR;GACA,IAAI,KAEF,OAAO;EAEX;EAEA,MAAM,SAAS,MAAM,cAAc,OAAO,OAAO,GAAG;EAEpD,IAAI,OACF,MAAM,MAAM,IAAI,KAAK,MAAM;EAG7B,OAAO;CACT;CAEA,MAAM,cAAuC,EAAE,KAAK,SAAS;CAC7D,IAAI,OAAO,SAAS,KAAA,GAAW,YAAY,kBAAkB,OAAO;CAEpE,OAAO;EACL;EACA,MAAM;EACN,UAAU,CAAC,KAAK;EAChB,QAAQ;EACR,KAAK;CACP;AACF;AAEA,qBAAqB,YAAY;;;;;;;;;;;ACxEjC,eAAsB,gBACpB,QACA,OAC6B;CAC7B,MAAM,SAAS,MAAM,OAAO,YAAY,CAAC,SAAS,KAAK;CACvD,IAAI,OAAO,QAAQ,OAAO;EAAE,IAAI;EAAO,QAAQ,OAAO,OAAO,IAAI,eAAe;CAAE;CAClF,OAAO;EAAE,IAAI;EAAM,OAAO,OAAO;CAAM;AACzC;;;;;;;;AASA,SAAS,gBAAgB,OAA4C;CACnE,IAAI,MAAM,SAAS,KAAA,GAAW,OAAO,EAAE,SAAS,MAAM,QAAQ;CAC9D,MAAM,OAAO,MAAM,KAAK,KAAK,YAC3B,OAAO,YAAY,WAAW,QAAQ,MAAM,OAC9C;CACA,OAAO;EAAE,SAAS,MAAM;EAAS;CAAK;AACxC;;;;;;;;;AAUA,SAAgB,qBAAqB,QAA4C;CAC/E,IAAI,OAAO,WAAW,GAAG,OAAO;CAChC,OAAO,OAAO,IAAI,YAAY,CAAC,CAAC,KAAK,IAAI;AAC3C;;;;;AAMA,SAAS,aAAa,OAA4B;CAChD,MAAM,OAAO,MAAM;CACnB,IAAI,SAAS,KAAA,KAAa,KAAK,WAAW,GAAG,OAAO,MAAM;CAC1D,OAAO,GAAG,KAAK,KAAK,YAAY,OAAO,OAAO,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,IAAI,MAAM;AACvE;;;;;;;;;;;;;;;;;;;;;ACzBA,SAAS,QAAQ,OAAiD;CAChE,IAAI,OAAO,UAAU,YAAY,UAAU,MAAM,OAAO;CACxD,IAAI,EAAE,QAAQ,UAAU,EAAE,UAAU,UAAU,EAAE,SAAS,QAAQ,OAAO;CACxE,MAAM,EAAE,IAAI,MAAM,QAAQ;CAC1B,OAAO,OAAO,OAAO,YAAY,OAAO,SAAS,YAAY,OAAO,QAAQ;AAC9E;;;;;;;;;AAUA,SAAgB,QAAsB,QAAiD;CACrF,MAAM,aAAa,OAAO;CAC1B,MAAM,QAAQ,OAAO;CACrB,MAAM,gBAAgB,OAAO;CAC7B,MAAM,aAAa,OAAO;CAE1B,MAAM,SAAS,OAAO,OAAU,QAAgC;EAC9D,MAAM,eAAe,IAAI,cAAc;EAEvC,IAAI,iBAAiB,KAAA,GAAW;GAC9B,MAAM,MAAM,OAAO,GAAG;GACtB,MAAM,IAAI,gBAAgB,YAAY,EAAE,MAAM,CAAC;EACjD;EAEA,MAAM,SAAS,MAAM,gBAAgB,eAAe,YAAY;EAChE,IAAI,CAAC,OAAO,IACV,MAAM,IAAI,wBACR,mBAAmB,WAAW,qBAC9B,OAAO,MACT;EAGF,MAAM,SAAS,MAAM,WAAW,OAAO,OAAO,OAAO,GAAG;EACxD,IAAI,QAAQ,MAAM,GAChB,OAAO,cAAc,QAAQ,OAAO,GAAG;EAEzC,OAAO;CACT;CAEA,MAAM,cAAuC,EAAE,IAAI,WAAW;CAC9D,IAAI,OAAO,SAAS,KAAA,GAAW,YAAY,kBAAkB,OAAO;CAEpE,OAAO;EACL,IAAI;EACJ,MAAM;EACN,QAAQ;EACR,KAAK;CACP;AACF;AAEA,qBAAqB,SAAS;;;;;;;;;;;;;;;;AClE9B,MAAM,+BAAe,IAAI,QAAsC;;;;;;;AAQ/D,SAAS,eAAe,OAA8C;CACpE,OAAO,aAAa,IAAI,KAAK;AAC/B;AAEA,IAAI,gBAAgB;AACpB,IAAI,gBAAgB;AACpB,IAAI,cAAc;;;;AAKlB,SAAS,gBAAwB;CAC/B,iBAAiB;CACjB,OAAO,SAAS;AAClB;;;;AAKA,SAAS,gBAAwB;CAC/B,iBAAiB;CACjB,OAAO,SAAS;AAClB;;;;AAKA,SAAS,cAAsB;CAC7B,eAAe;CACf,OAAO,OAAO;AAChB;;;;;;;;AAqBA,SAAgB,MACd,UACA,SACqC;CACrC,MAAM,KAAK,cAAc;CACzB,MAAM,eAAe;CAErB,MAAM,SAAS,OAAO,OAAgB,QAAsC;EAC1E,MAAM,QAAQ,IAAI,IAAqB,IAAI,KAAK;EAChD,aAAa,IAAI,KAAK;EACtB,MAAM,YAAwB;GAAE,GAAG;GAAK,OAAO;EAAM;EAErD,IAAI,MAAe;EACnB,KAAK,MAAM,SAAS,cAAc;GAChC,iBAAiB,SAAS;GAC1B,MAAM,MAAM,cAAc,OAAO,KAAK,SAAS;EACjD;EACA,OAAO;CACT;CAEA,MAAM,cACJ,SAAS,SAAS,KAAA,IAAY,KAAA,IAAY,EAAE,cAAc,QAAQ,KAAK;CAGzE,OAAO;EACL;EACA,MAAM;EACN;EACA,GAAI,cAAc,EAAE,QAAQ,YAAY,IAAI,CAAC;EAC7C,KAAK;CACP;AACF;;;;;;;AAQA,SAAgB,MACd,KACA,QACA,SACY;CACZ,MAAM,KAAK,cAAc;CAEzB,MAAM,SAAS,OAAO,OAAU,QAAgC;EAC9D,IAAI,CAAC,eAAe,IAAI,KAAK,GAC3B,MAAM,IAAI,MAAM,wDAAwD;EAE1E,MAAM,QAAQ,MAAM,cAAc,QAAQ,OAAO,GAAG;EAGpD,IADkB,MACZ,IAAI,KAAK,KAAK;EACpB,OAAO;CACT;CAEA,MAAM,cAAuC,EAAE,IAAI;CACnD,IAAI,SAAS,SAAS,KAAA,GAAW,YAAY,kBAAkB,QAAQ;CAEvE,OAAO;EACL;EACA,MAAM;EACN,UAAU,CAAC,MAAM;EACjB,QAAQ;EACR,KAAK;CACP;AACF;;;;;;;AAQA,SAAgB,IACd,MACA,IAKA,SACY;CACZ,MAAM,KAAK,YAAY;CAEvB,MAAM,SAAS,OAAO,OAAU,QAAgC;EAC9D,IAAI,CAAC,eAAe,IAAI,KAAK,GAC3B,MAAM,IAAI,MAAM,sDAAsD;EAExE,MAAM,aAAsC,CAAC;EAC7C,KAAK,MAAM,KAAK,MACd,WAAW,KAAK,IAAI,MAAM,IAAI,CAAC;EAGjC,OAAO,GAAG,YAAgD,OAAO,GAAG;CACtE;CAEA,MAAM,cAAuC,EAAE,MAAM,CAAC,GAAG,IAAI,EAAE;CAC/D,IAAI,SAAS,SAAS,KAAA,GAAW,YAAY,kBAAkB,QAAQ;CAEvE,OAAO;EACL;EACA,MAAM;EACN,QAAQ;EACR,KAAK;CACP;AACF;AAEA,qBAAqB,OAAO;AAE5B,qBAAqB,OAAO;AAE5B,qBAAqB,KAAK;;;;;;;;;;;;AC3L1B,MAAa,aAAa;CACxB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;AAOA,SAAgB,aAAa,OAAmC;CAC9D,OAAO,OAAO,UAAU,YAAa,WAAiC,SAAS,KAAK;AACtF;;;;;;;;;ACwBA,SAAgB,2BAA2B,OAAgD;CACzF,IAAI,OAAO,UAAU,YAAY,UAAU,MAAM,OAAO;CACxD,IAAI,MAAM,QAAQ,KAAK,GAAG,OAAO;CACjC,OAAO,OAAQ,MAA6B,SAAS;AACvD;;AAGA,SAAgB,oBAAoB,OAAyC;CAC3E,IAAI,CAAC,2BAA2B,KAAK,GAAG,OAAO;CAC/C,IAAI,MAAM,SAAS,cAAc,OAAO;CACxC,OAAO,OAAO,MAAM,eAAe,YAAY,OAAO,MAAM,YAAY;AAC1E;;AAGA,SAAgB,kBAAkB,OAAuC;CACvE,IAAI,CAAC,2BAA2B,KAAK,GAAG,OAAO;CAC/C,OAAO,MAAM,SAAS,cAAc,OAAO,MAAM,eAAe;AAClE;;AAGA,SAAgB,cAAc,OAAoC;CAChE,OAAO,2BAA2B,KAAK,KAAK,MAAM,SAAS;AAC7D;;;;;;;AAQA,SAAgB,uBAAuB,OAAuC;CAC5E,IAAI,CAAC,2BAA2B,KAAK,GACnC,OAAO;EACL,SAAS;EACT,uBAAO,IAAI,MAAM,iEAAiE;CACpF;CAEF,OAAO;EAAE,SAAS;EAAM,MAAM;CAAM;AACtC"}
package/dist/index.d.ts CHANGED
@@ -732,28 +732,28 @@ type LoopGuardResult<state> = {
732
732
  readonly stop: boolean;
733
733
  readonly state: state;
734
734
  };
735
+ type LoopOutcome = {
736
+ readonly converged: boolean;
737
+ readonly rounds: number;
738
+ };
735
739
  type LoopConfig<i, state, o> = {
736
740
  readonly name?: string;
737
741
  readonly init: (input: i) => state;
738
742
  readonly body: Step<state, state>;
739
743
  readonly guard?: Step<state, LoopGuardResult<state>>;
740
- readonly finish: (state: state, round: number) => o;
744
+ readonly finish: (state: state, outcome: LoopOutcome) => o;
741
745
  readonly max_rounds: number;
742
746
  };
743
- type LoopResult<o> = {
744
- readonly value: o;
745
- readonly converged: boolean;
746
- readonly rounds: number;
747
- };
748
747
  /**
749
748
  * Build a bounded iteration step with carry-state.
750
749
  *
751
750
  * Threads `state` through up to `max_rounds` runs of `body`, lets the
752
751
  * optional `guard` stop early, then projects the final state through
753
- * `finish`. Returns `{ value, converged, rounds }` so callers can tell a
754
- * converged run from an exhausted one.
752
+ * `finish`. `finish` also receives `{ converged, rounds }`, so a projection
753
+ * can tell a converged run from an exhausted one without the loop wrapping
754
+ * its output.
755
755
  */
756
- declare function loop<i, state, o>(config: LoopConfig<i, state, o>): Step<i, LoopResult<o>>;
756
+ declare function loop<i, state, o>(config: LoopConfig<i, state, o>): Step<i, o>;
757
757
  //#endregion
758
758
  //#region src/core/compose.d.ts
759
759
  /**
@@ -1651,5 +1651,5 @@ declare function start_viewer(options?: StartViewerOptions): Promise<ViewerHandl
1651
1651
  */
1652
1652
  declare function run_viewer_cli(argv: readonly string[]): Promise<void>;
1653
1653
  //#endregion
1654
- export { type AdversarialBuildInput, type AdversarialConfig, type AdversarialCritiqueResult, type AdversarialResult, type AiSdkProviderAdapter, type AiSdkTelemetrySettings, type AssistantContentPart, type BenchCase, type BenchOptions, type BenchReport, type BenchSummary, type BracketRecord, type Candidate, type CaseResult, type CheckpointStore, type ConsensusConfig, type ConsensusResult, type CostBreakdown, type CustomTrajectoryEvent, type DescribeOptions, type EffortLevel, type EffortTranslation, type EmitEvent, type Engine, type EngineConfig, type EngineDefaults, type EnsembleConfig, type EnsembleResult, type EnsembleStepConfig, type EnsembleStepResult, type ExternalAgentAdapter, type FinishReason, type FlowNode, type FlowValue, type GenerateOptions, type GenerateResult, type HistoryEntry, type ImproveBudget, type ImproveConfig, type ImproveResult, type ImproveRoundInput, type Improvement, type Judge, type JudgeArgs, type JudgeLlmConfig, type JudgeWithFn, type LearnConfig, type LearnInput, type LearnResult, type Lesson, type LoopConfig, type LoopGuardResult, type LoopResult, type Message, type ModelCallConfig, type ModelCallInput, type NativeProviderAdapter, type ParsedTrajectoryEvent, type PerCaseDelta, type PrepareStepContext, type PrepareStepHook, type PrepareStepResult, type Pricing, type PricingTable, type ProviderAdapter, type ProviderCapability, type ProviderConfigMap, type ProviderFactory, type ProviderInit, type ProviderTransport, type RawProviderUsage, type RegressionCompareOptions, type RegressionDelta, type RegressionReport, type ResolvedModel, type RetryFailureKind, type RetryPolicy, type RunContext, STEP_KINDS, type Score, type ScoredCandidate, type SpanEndEvent, type SpanStartEvent, type StartViewerOptions, type Step, type StepKind, type StepMetadata, type StepRecord, type StreamChunk, type Tool, type ToolApprovalHandler, type ToolApprovalRequest, type ToolCallRecord, type ToolExecContext, type TournamentConfig, type TournamentResult, type TrajectoryEvent, type TrajectoryLogger, type TrajectoryParseResult, type TrajectorySource, type TurnRequest, type TurnResult, type UsageTotals, type UserContentPart, type ViewerHandle, aborted_error, adversarial, bench, bench_suspend_error, branch, checkpoint, claude_cli_error, compose, consensus, create_engine, default_normalize_usage, describe, describe_cycle_error, engine_config_error, engine_disposed_error, ensemble, ensemble_step, fallback, __json_default_export as flow_schema, forward_standard_env, improve, incomplete_generation_error, is_custom_trajectory_event, is_emit_event, is_span_end_event, is_span_start_event, is_step_kind, judge_equals, judge_llm, judge_with, learn, loop, map, model_call, model_required_error, normalize_score, on_chunk_error, parallel, parse_trajectory_event, pipe, provider_auth_error, provider_capability_error, provider_error, provider_not_configured_error, rate_limit_error, read_baseline, regression_compare, resume_validation_error, retry, run, run_viewer_cli, schema_validation_error, scope, sequence, start_viewer, stash, step, suspend, suspended_error, timeout, timeout_error, tool_approval_denied_error, tool_error, tournament, use, write_baseline };
1654
+ export { type AdversarialBuildInput, type AdversarialConfig, type AdversarialCritiqueResult, type AdversarialResult, type AiSdkProviderAdapter, type AiSdkTelemetrySettings, type AssistantContentPart, type BenchCase, type BenchOptions, type BenchReport, type BenchSummary, type BracketRecord, type Candidate, type CaseResult, type CheckpointStore, type ConsensusConfig, type ConsensusResult, type CostBreakdown, type CustomTrajectoryEvent, type DescribeOptions, type EffortLevel, type EffortTranslation, type EmitEvent, type Engine, type EngineConfig, type EngineDefaults, type EnsembleConfig, type EnsembleResult, type EnsembleStepConfig, type EnsembleStepResult, type ExternalAgentAdapter, type FinishReason, type FlowNode, type FlowValue, type GenerateOptions, type GenerateResult, type HistoryEntry, type ImproveBudget, type ImproveConfig, type ImproveResult, type ImproveRoundInput, type Improvement, type Judge, type JudgeArgs, type JudgeLlmConfig, type JudgeWithFn, type LearnConfig, type LearnInput, type LearnResult, type Lesson, type LoopConfig, type LoopGuardResult, type LoopOutcome, type Message, type ModelCallConfig, type ModelCallInput, type NativeProviderAdapter, type ParsedTrajectoryEvent, type PerCaseDelta, type PrepareStepContext, type PrepareStepHook, type PrepareStepResult, type Pricing, type PricingTable, type ProviderAdapter, type ProviderCapability, type ProviderConfigMap, type ProviderFactory, type ProviderInit, type ProviderTransport, type RawProviderUsage, type RegressionCompareOptions, type RegressionDelta, type RegressionReport, type ResolvedModel, type RetryFailureKind, type RetryPolicy, type RunContext, STEP_KINDS, type Score, type ScoredCandidate, type SpanEndEvent, type SpanStartEvent, type StartViewerOptions, type Step, type StepKind, type StepMetadata, type StepRecord, type StreamChunk, type Tool, type ToolApprovalHandler, type ToolApprovalRequest, type ToolCallRecord, type ToolExecContext, type TournamentConfig, type TournamentResult, type TrajectoryEvent, type TrajectoryLogger, type TrajectoryParseResult, type TrajectorySource, type TurnRequest, type TurnResult, type UsageTotals, type UserContentPart, type ViewerHandle, aborted_error, adversarial, bench, bench_suspend_error, branch, checkpoint, claude_cli_error, compose, consensus, create_engine, default_normalize_usage, describe, describe_cycle_error, engine_config_error, engine_disposed_error, ensemble, ensemble_step, fallback, __json_default_export as flow_schema, forward_standard_env, improve, incomplete_generation_error, is_custom_trajectory_event, is_emit_event, is_span_end_event, is_span_start_event, is_step_kind, judge_equals, judge_llm, judge_with, learn, loop, map, model_call, model_required_error, normalize_score, on_chunk_error, parallel, parse_trajectory_event, pipe, provider_auth_error, provider_capability_error, provider_error, provider_not_configured_error, rate_limit_error, read_baseline, regression_compare, resume_validation_error, retry, run, run_viewer_cli, schema_validation_error, scope, sequence, start_viewer, stash, step, suspend, suspended_error, timeout, timeout_error, tool_approval_denied_error, tool_error, tournament, use, write_baseline };
1655
1655
  //# sourceMappingURL=index.d.ts.map