fascicle 0.12.11 → 0.12.13
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 +31 -0
- package/dist/adapters.d.ts +1 -1
- package/dist/agents.d.ts +2 -2
- package/dist/agents.js +1 -1
- package/dist/bin/fascicle-diagram.js +9 -0
- package/dist/{core-BClsJ3h0.js → core-BVCVUMmH.js} +332 -65
- package/dist/core-BVCVUMmH.js.map +1 -0
- package/dist/diagram_bin.d.ts +25 -0
- package/dist/diagram_bin.js +239 -0
- package/dist/diagram_bin.js.map +1 -0
- package/dist/{engine-Djq7EH9x.js → engine-Ct4LBzb9.js} +4 -4
- package/dist/{engine-Djq7EH9x.js.map → engine-Ct4LBzb9.js.map} +1 -1
- package/dist/index.d.ts +56 -32
- package/dist/index.js +48 -53
- package/dist/index.js.map +1 -1
- package/dist/{invoke-dc5DdrrJ.js → invoke-BcPDqE5C.js} +3 -3
- package/dist/{invoke-dc5DdrrJ.js.map → invoke-BcPDqE5C.js.map} +1 -1
- package/dist/{leading_system-B6hsYN90.js → leading_system-CfOIc5fi.js} +2 -2
- package/dist/{leading_system-B6hsYN90.js.map → leading_system-CfOIc5fi.js.map} +1 -1
- package/dist/mcp.d.ts +2 -2
- package/dist/mcp.js +1 -1
- package/dist/otel.d.ts +1 -1
- package/dist/stdio.d.ts +1 -1
- package/dist/stdio.js +1 -1
- package/dist/testing.d.ts +1 -1
- package/dist/testing.js +3 -3
- package/dist/{types-DBpU27sQ.d.ts → types-BasW4Wwb.d.ts} +43 -2
- package/dist/{types-DcNpT0Hl.d.ts → types-bEpfDrys.d.ts} +2 -2
- package/dist/ui.d.ts +1 -1
- package/dist/viewer.js +1 -1
- package/package.json +4 -2
- package/dist/core-BClsJ3h0.js.map +0 -1
|
@@ -1 +0,0 @@
|
|
|
1
|
-
{"version":3,"file":"core-BClsJ3h0.js","names":["next_id","next_id","next_id","next_id","next_id","next_id","next_id","next_id","next_id","next_id"],"sources":["../src/core/cleanup.ts","../src/core/errors.ts","../src/core/is_step.ts","../src/core/display_name.ts","../src/core/describe.ts","../src/core/streaming.ts","../src/core/runner.ts","../src/core/step_id.ts","../src/core/step.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/chain.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 * Every class declares an optional `path`: the chain of step ids the error\n * crossed while bubbling through dispatch. The runner attaches it via\n * Reflect.set (`prepend_path` in runner.ts), so the `declare` modifier types\n * what arrives without emitting a field; construction never sets it.\n */\n\nimport type { SchemaIssue } from '#schema'\n\nexport class timeout_error extends Error {\n readonly kind = 'timeout_error' as const;\n declare readonly path?: ReadonlyArray<string>;\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 declare readonly path?: ReadonlyArray<string>;\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 declare readonly path?: ReadonlyArray<string>;\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 declare readonly path?: ReadonlyArray<string>;\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 declare readonly path?: ReadonlyArray<string>;\n readonly reason?: unknown;\n // An engine tool-loop position, meaningful only when the abort interrupted a\n // model turn. Core-origin aborts (signals, caller AbortSignals) leave it\n // undefined rather than fabricating index 0.\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 if (metadata.step_index !== undefined) this.step_index = metadata.step_index\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/**\n * Read the step-id path off any error that crossed the runner's dispatch.\n *\n * The runner attaches `path` to whatever escapes a step, including\n * user-thrown errors the declared class fields cannot type, so a catch block\n * needs a narrowing read rather than a cast. Returns the ids only when the\n * property is present and well-formed (an all-string array); anything else,\n * including non-object inputs, is `undefined`.\n */\nexport function error_path(err: unknown): ReadonlyArray<string> | undefined {\n if (err === null || typeof err !== 'object') return undefined\n const path: unknown = Reflect.get(err, 'path')\n if (!Array.isArray(path)) return undefined\n const entries: ReadonlyArray<unknown> = path\n const ids = entries.filter((v): v is string => typeof v === 'string')\n return ids.length === entries.length ? ids : undefined\n}\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 { AnyStep } 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 AnyStep {\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 * Display-name resolution.\n *\n * Every consumer that renders a step for human eyes (the runner's span\n * labels, `describe`, bench reports) resolves the same way, so the order\n * lives here rather than in three copies: `config.display_name` first (what\n * composers write from their `name` option), then `meta.name` (what\n * `step(id, fn, { name })` writes), then the caller's fallback.\n *\n * Identity deliberately never participates. A step's `id` is rendered\n * separately by the consumers that want it, so renaming a step for\n * readability cannot move a checkpoint key, a resume address, or a\n * trajectory id.\n */\n\nimport type { AnyStep } from './types.js'\n\n/**\n * Resolve the human-readable label for `node`, falling back to `fallback`\n * (typically the step's kind) when neither display channel is populated.\n */\nexport function resolve_display_name(node: AnyStep, fallback: string): string {\n const display = node.config?.['display_name']\n if (typeof display === 'string' && display.length > 0) return display\n const name = node.meta?.name\n if (typeof name === 'string' && name.length > 0) return name\n return fallback\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 { resolve_display_name } from './display_name.js'\nimport type { AnyStep, 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<AnyStep>\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: AnyStep,\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 lines.push(`${prefix}${resolve_display_name(node, node.kind)}(${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 *\n * Steps, arrays, and renderable objects each own a branch; everything else\n * (functions, the empty markers, schemas, primitives) resolves through\n * `render_scalar_text`. The three object-shaped cases are mutually exclusive at\n * runtime, so their order relative to the scalar cases is immaterial.\n */\nfunction render_value_text(value: unknown, path: Path, strict: boolean): string {\n if (is_step(value)) return render_step_text(value, path, strict)\n if (Array.isArray(value)) {\n return `[${value.map((item: unknown) => render_value_text(item, path, strict)).join(', ')}]`\n }\n if (is_renderable_object(value)) {\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 return render_scalar_text(value)\n}\n\n/**\n * Render a Step reference for the text tree: a back-reference on the current\n * path becomes `<cycle>(id)` (or throws under strict mode); otherwise `kind(id)`.\n */\nfunction render_step_text(value: AnyStep, path: Path, strict: boolean): string {\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\n/**\n * Render the non-recursive value cases for the text tree: functions (`<fn>` or\n * `<fn:name>`), the empty markers, zod schemas, and (via `render_primitive_text`)\n * raw primitives.\n */\nfunction render_scalar_text(value: unknown): 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 return render_primitive_text(value)\n}\n\n/**\n * Render a primitive (or unrecognized) value for the text tree. Strings are\n * JSON-quoted so empty and whitespace values stay visible; bigints keep an `n`\n * suffix; anything unexpected falls back to JSON.\n */\nfunction render_primitive_text(value: unknown): string {\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: AnyStep,\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 *\n * Mirrors `render_value_text`: steps, arrays, and renderable objects each own a\n * branch, and everything else resolves through `render_scalar_json`.\n */\nfunction render_value_json(value: unknown, path: Path, strict: boolean): FlowValue {\n if (is_step(value)) return render_step_json(value, path, strict)\n if (Array.isArray(value)) {\n return value.map((item: unknown) => render_value_json(item, path, strict))\n }\n if (is_renderable_object(value)) {\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 return render_scalar_json(value)\n}\n\n/**\n * Serialize a Step reference: a back-reference on the current path becomes\n * `{ kind: '<cycle>', id }` (or throws under strict mode); otherwise `{ kind, id }`.\n */\nfunction render_step_json(value: AnyStep, path: Path, strict: boolean): FlowValue {\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\n/**\n * Serialize the non-recursive value cases: functions, the empty markers, zod\n * schemas, and (via `render_primitive_json`) raw primitives.\n */\nfunction render_scalar_json(value: unknown): 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 return render_primitive_json(value)\n}\n\n/**\n * Serialize a primitive (or unrecognized) value. `undefined` already resolves\n * to `null` in `render_scalar_json`; bigints and symbols become strings so the\n * result survives `JSON.stringify` without loss.\n */\nfunction render_primitive_json(value: unknown): FlowValue {\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/**\n * True for a plain object rendered by recursing into its own entries: an object\n * that is neither null nor a zod schema. The Step and array cases are checked\n * before this at every call site, so they never reach it.\n */\nfunction is_renderable_object(value: unknown): value is object {\n return typeof value === 'object' && value !== null && !is_zod_schema(value)\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 }\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 { describe } from './describe.js'\nimport { resolve_display_name } from './display_name.js'\nimport { aborted_error, suspended_error } from './errors.js'\nimport { create_streaming_channel, STREAMING_HIGH_WATER_MARK } from './streaming.js'\nimport type {\n AnyStep,\n CheckpointStore,\n RunContext,\n Step,\n TrajectoryEvent,\n TrajectoryLogger,\n} from './types.js'\n\ntype Dispatcher = (\n flow: AnyStep,\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 via `register_traced_kind` at module load, which is\n * how the runner stays free of composer-specific logic.\n */\nfunction register_kind(kind: string, fn: Dispatcher): void {\n dispatch.set(kind, fn)\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_display_name(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 // The dispatch table is the type-erasure boundary: `dispatch_step`\n // pairs each step with the input its parent produced for it, a pairing\n // `AnyStep` (input `never`) cannot carry, so the call re-asserts it.\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n const out = await flow.run(input as never, 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, { id: flow.id, ...error_meta(err) })\n throw err\n }\n })\n}\n\n/**\n * Project an escaping error onto trajectory meta fields.\n *\n * `error` is always present (the message); `error_name` and `error_kind`\n * surface the class name and the `kind` discriminant the typed error classes\n * carry, so a consumer can classify a failure without regex-matching the\n * message. `error_path` is the chain of step ids the error crossed below this\n * point, already accumulated on the error by `prepend_path` as it bubbled up.\n */\nfunction error_meta(err: unknown): Record<string, unknown> {\n const meta: Record<string, unknown> = {\n error: err instanceof Error ? err.message : String(err),\n }\n if (err instanceof Error && err.name.length > 0) meta['error_name'] = err.name\n if (err !== null && typeof err === 'object') {\n const kind = Reflect.get(err, 'kind')\n if (typeof kind === 'string') meta['error_kind'] = kind\n const path = Reflect.get(err, 'path')\n if (Array.isArray(path)) {\n meta['error_path'] = path.filter((v): v is string => typeof v === 'string')\n }\n }\n return meta\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 */\nfunction 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 * Install a fan-out abort listener over a set of child controllers: when\n * `ctx.abort` fires, every controller currently in `controllers` is aborted\n * with the same reason. An already-aborted parent fires immediately instead\n * of registering a listener.\n *\n * Concurrent composers (`map`, `parallel`) use this to propagate a parent\n * abort into each in-flight child's composed signal. `controllers` is read by\n * reference, so a caller that appends to the array after installing (as\n * `map` does per newly started item) is still covered by later aborts.\n * Returns the listener so the caller can remove it once its children settle.\n */\nexport function install_abort_fan_out(\n ctx: RunContext,\n controllers: ReadonlyArray<AbortController>,\n): () => void {\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 return on_parent_abort\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 * the `flow_structure` event that opens an observed run, and the\n * settle-time teardown ordering (cleanup handlers first, then unlinking and\n * 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 // Structure is worth its one describe() walk only when something will see\n // it: a real logger, or a run.stream() consumer reading the channel.\n if (options.trajectory !== undefined || streaming) {\n logger.record({ kind: 'flow_structure', structure: describe.json(flow) })\n }\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 call<ci, co>(this: RunContext, s: Step<ci, co>, child_input: ci): Promise<co> {\n throw_if_aborted(this)\n return dispatch_step(s, child_input, this)\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 let terminal: TrajectoryEvent = { kind: 'run_end', status: 'done' }\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 let thrown: unknown = err\n if (controller.signal.aborted && !(err instanceof aborted_error)) {\n const reason = controller.signal.reason\n if (reason instanceof aborted_error) thrown = reason\n }\n // A caller may abort with a plain-Error cause, which surfaces verbatim\n // rather than as aborted_error; identity with the signal reason is what\n // marks that ending as a cancellation rather than a failure.\n const was_aborted =\n thrown instanceof aborted_error ||\n (controller.signal.aborted && thrown === controller.signal.reason)\n terminal = run_end_event(thrown, was_aborted)\n throw thrown\n } finally {\n try {\n await cleanup.run_all()\n } finally {\n // Recorded after cleanup so run_end is the true last event of the\n // run, and before the stream closes so `run.stream` consumers see it.\n logger.record(terminal)\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 the terminal `run_end` event for a run that did not complete.\n *\n * Control-flow endings get their own statuses (`aborted`, `suspended`) so a\n * consumer never has to sniff error text to tell a cancellation or a pending\n * approval from a real failure; only `failed` carries the full error meta.\n */\nfunction run_end_event(err: unknown, was_aborted: boolean): TrajectoryEvent {\n if (err instanceof suspended_error) {\n return { kind: 'run_end', status: 'suspended', suspend_id: err.suspend_id }\n }\n if (was_aborted) {\n return {\n kind: 'run_end',\n status: 'aborted',\n error: err instanceof Error ? err.message : String(err),\n }\n }\n return { kind: 'run_end', status: 'failed', ...error_meta(err) }\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\nexport type RunOutcome<o> =\n | { readonly kind: 'done'; readonly output: o }\n | {\n readonly kind: 'suspended'\n readonly id: string\n // Whatever the suspend gate raised (for the built-in `suspend` composer,\n // `{ input }`), so a driver loop can render what awaits approval without\n // re-running the flow. `unknown` because gates declare no payload type.\n readonly payload: unknown\n readonly resume: (data: unknown) => Promise<RunOutcome<o>>\n }\n\n/**\n * Execute a flow, reporting suspension as a typed outcome instead of a\n * thrown `suspended_error`.\n *\n * Resolves `{ kind: 'done', output }` on completion. When a `suspend` gate\n * fires, resolves `{ kind: 'suspended', id, payload, resume }` where `id` is\n * the gate's suspend id, `payload` is what the gate raised on its\n * `suspended_error`, and `resume(data)` re-runs the flow from the original\n * input with `resume_data[id] = data` merged over the caller's options: the\n * same full re-run semantics as calling `run` again yourself, so pure\n * prefixes replay and `checkpoint`ed steps are served from the store. The\n * returned promise resolves to the next outcome, so a flow with several\n * gates is driven by awaiting `resume` repeatedly. Real errors still throw,\n * from the initial call and from `resume` alike.\n */\nasync function run_until_suspended<i, o>(\n flow: Step<i, o>,\n input: i,\n options: RunOptions = {},\n): Promise<RunOutcome<o>> {\n try {\n return { kind: 'done', output: await run_impl(flow, input, options) }\n } catch (err) {\n if (!(err instanceof suspended_error)) throw err\n const id = err.suspend_id\n return {\n kind: 'suspended',\n id,\n payload: err.payload,\n resume: (data) =>\n run_until_suspended(flow, input, {\n ...options,\n resume_data: { ...options.resume_data, [id]: data },\n }),\n }\n }\n}\n\n/**\n * The public entry point for executing a flow.\n *\n * Callable as `run(flow, input, options?)` for a plain result,\n * `run.stream(flow, input, options?)` for `{ events, result }`, or\n * `run.until_suspended(flow, input, options?)` for a `RunOutcome` that\n * carries suspension as data. All share one implementation, so every entry\n * point runs the same graph identically.\n */\nexport const run: typeof run_impl & {\n stream: typeof run_stream\n until_suspended: typeof run_until_suspended\n} = Object.assign(run_impl, {\n stream: run_stream,\n until_suspended: run_until_suspended,\n})\n","/**\n * Step id validation.\n *\n * Every id in the system is constrained to a valid JavaScript identifier\n * rather than an arbitrary string, because ids are read back as property\n * names: `chain` merges each binding into a typed record under its name, and\n * a name you cannot destructure is a name the record cannot offer. Holding\n * one rule across `step`, `chain`, and the agent surface means a user learns\n * it once instead of discovering per-primitive exceptions.\n *\n * Prose is not constrained, because prose has its own channel: `meta.name`\n * on a step, `name` on a chain binding or composer.\n *\n * Nothing normalizes an id on the caller's behalf. A silent transformation\n * would map several distinct names onto one key ('my-id', 'my.id', and\n * 'my_id' all reduce to 'my_id') and would have to stay bug-for-bug in sync\n * with the equivalent type-level transformation. The suggestion in the\n * failure message is a courtesy for the reader, never a contract.\n */\n\n// `$` sits outside ID_Continue, so both classes name it explicitly.\nconst IDENTIFIER = /^[\\p{ID_Start}$_][\\p{ID_Continue}$]*$/u\n\n/**\n * Report whether `id` can be read back as a property name.\n */\nexport function is_valid_step_id(id: string): boolean {\n return IDENTIFIER.test(id)\n}\n\n/**\n * Render the closest identifier-shaped spelling of `raw`, for failure\n * messages only. Prefixes an underscore when the swap alone still leaves an\n * illegal leading character, so the suggestion is always usable as written.\n */\nexport function suggest_step_id(raw: string): string {\n const swapped = raw.replace(/[^\\p{ID_Continue}$]/gu, '_')\n return IDENTIFIER.test(swapped) ? swapped : `_${swapped}`\n}\n\n/**\n * Throw when `id` is not identifier-shaped. `subject` names the failing\n * surface so the message points at the call the reader actually wrote, and\n * `remedy` says where the prose spelling belongs instead.\n */\nexport function assert_valid_step_id(id: string, subject: string, remedy: string): void {\n if (is_valid_step_id(id)) return\n throw new TypeError(\n `${subject} ${JSON.stringify(id)} is not a valid identifier: ids are read back as property names, so use ${suggest_step_id(id)} and ${remedy}`,\n )\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 carrying descriptive metadata. `meta.name` is the\n * display channel: it labels the step's trajectory span and its\n * describe() line, leaving the id free to stay a stable\n * identifier. Nothing keys off it, so it is safe to reword.\n * step(fn): anonymous step. id is `step_<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 * An explicit id must be identifier-shaped: ids are read back as property\n * names wherever a step's output is bound (see step_id.ts). Free prose goes\n * in `meta.name`.\n */\n\nimport { register_traced_kind } from './runner.js'\nimport { assert_valid_step_id } from './step_id.js'\nimport type { Step, StepFn, StepMetadata } from './types.js'\n\nlet step_counter = 0\n\n/**\n * Generate a unique id of the form `step_<n>` for anonymous steps.\n */\nfunction next_step_id(): string {\n step_counter += 1\n return `step_${step_counter}`\n}\n\n/**\n * Wrap a plain function as a `Step`, named or anonymous.\n *\n * The named form takes an explicit id (identity) and optional `meta` (display\n * and description); the anonymous form generates a `step_<n>` id and marks the\n * step so checkpoint 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_step_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 assert_valid_step_id(id_or_fn, 'step id', 'put the label in meta.name')\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 * 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 * For a literal tuple of children, every joint is checked at compile time:\n * each child after the first must accept its predecessor's output, and a\n * mismatch resolves the offending element to a branded SequenceJointMismatch\n * so the error names the joint and both types. A spread segment inside a\n * tuple (`sequence([first, ...mids, last])`) is checked as a homogeneous\n * self-composing segment rather than index-zipped, since its positions are\n * not statically known. Arrays built at runtime carry no positional types,\n * so they must be homogeneous `ReadonlyArray<Step<T, T>>` and produce a\n * `Step<T, T>`; heterogeneous runtime arrays are rejected rather than\n * silently degrading to `Step<unknown, unknown>`.\n */\n\nimport { is_step } from './is_step.js'\nimport { dispatch_step, register_traced_kind, throw_if_aborted } from './runner.js'\nimport type { AnyStep, RunContext, Step, StepInput, StepOutput } from './types.js'\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<never, infer o>]\n ? o\n : children extends readonly [Step<never, infer o>]\n ? o\n : unknown\n\ntype OutputOf<s> = StepOutput<s>\n\n// `never` fallback so a non-step can never satisfy a joint by accident.\ntype InputOf<s> = StepInput<s>\n\n// Branded impossible type for joint failures. A mismatched element's expected\n// type resolves to this interface, so the first line of the compile error\n// names the joint position and both types instead of burying them under a\n// structural Step assignability chain (which drags in irrelevant\n// exactOptionalPropertyTypes advice).\ninterface SequenceJointMismatch<at extends string, upstream_output, this_step_accepts> {\n readonly sequence_joint_mismatch: at\n readonly upstream_output: upstream_output\n readonly this_step_accepts: this_step_accepts\n}\n\n// The joint check: an element must be a step whose input accepts the\n// upstream output. `upstream` is bracketed to suppress union distribution,\n// since after a spread segment the upstream is a union and every constituent\n// must be accepted, not just one.\n//\n// The `unknown extends element` guard is load-bearing. While `children` is\n// being inferred, the checker computes contextual types for the array literal\n// from this parameter type instantiated with degenerate stand-ins (the type\n// parameter's constraint and the infer variables' constraints), under which\n// every element resolves to `unknown`. The guard collapses those\n// instantiations to the inert contextual type `unknown`, so an inline\n// generic leaf (a bare `model_step({ ... })`) resolves its own type\n// parameters from its arguments and defaults instead of absorbing `unknown`\n// from a step-shaped context. No concrete element is typed as exactly\n// `unknown`, so real elements always reach the checking branches.\ntype CheckedJoint<element, upstream, at extends string> = unknown extends element\n ? unknown\n : element extends AnyStep\n ? [upstream] extends [InputOf<element>]\n ? element\n : SequenceJointMismatch<at, upstream, InputOf<element>>\n : AnyStep\n\n// First position has no predecessor: any step passes, a non-step fails\n// against AnyStep. Guarded like CheckedJoint, for the same reason.\ntype CheckedFirst<element> = unknown extends element\n ? unknown\n : element extends AnyStep\n ? element\n : AnyStep\n\n// Index-zips the tail against the full tuple: `rest` is `children` shifted\n// left by one, so `children[k]` is the predecessor of `rest[k]`. A mapped\n// tuple instead of recursion, so length is unbounded. Only sound for tuples\n// without a spread segment, where `k` is a real position; CheckedChildren\n// routes spread-bearing tuples to CheckedSpreadTail instead.\ntype CheckedTail<children extends readonly unknown[], rest extends readonly unknown[]> = {\n readonly [k in keyof rest]: CheckedJoint<\n rest[k],\n OutputOf<k extends keyof children ? children[k] : never>,\n `after children[${k & string}]`\n >\n}\n\n// True only for spread segments and plain runtime arrays: any tuple with a\n// fixed element fails the mutual assignability probe on length grounds.\ntype IsPlainArray<t extends readonly unknown[]> = t extends readonly []\n ? false\n : t[number][] extends [...t]\n ? true\n : false\n\n// A spread segment admits any length including zero, so each element must\n// accept both the upstream output (it may run first) and its own output (it\n// may follow a sibling). `e` is bracketed against distribution so a union\n// element type is checked as a whole, where InputOf infers the intersection\n// of inputs and OutputOf the union of outputs, which is exactly the sound\n// requirement.\ntype CheckedSegment<seg extends readonly unknown[], e, upstream> = unknown extends e\n ? seg\n : [e] extends [AnyStep]\n ? [upstream | OutputOf<e>] extends [InputOf<e>]\n ? seg\n : readonly SequenceJointMismatch<'spread segment', upstream | OutputOf<e>, InputOf<e>>[]\n : readonly AnyStep[]\n\n// Peels fixed trailing elements off a spread-first remainder until only the\n// spread segment is left. The head-infer pattern fails on a leading spread,\n// so recursion arrives here exactly when the segment is at the front.\ntype SplitSpreadTrail<\n t extends readonly unknown[],\n trail extends readonly unknown[] = [],\n> = IsPlainArray<t> extends true\n ? [t, trail]\n : t extends readonly [...infer init, infer last_el]\n ? SplitSpreadTrail<init, [last_el, ...trail]>\n : [t, trail]\n\n// Position tracker for joint labels: a counting tuple while positions are\n// statically known, the 'spread' marker once a spread segment has consumed\n// the absolute indices.\ntype SpreadPos = readonly unknown[] | 'spread'\n\ntype JointAt<p extends SpreadPos> = p extends readonly unknown[]\n ? `after children[${p['length']}]`\n : 'after spread segment'\n\ntype NextPos<p extends SpreadPos> = p extends readonly unknown[] ? readonly [...p, unknown] : p\n\n// Walks a tuple that contains a spread segment. Fixed heads are joint-checked\n// with exact labels; the segment itself goes through CheckedSegment; fixed\n// elements after the segment are checked against the upstream widened by the\n// segment's output, because the segment may be empty at run time and both\n// paths must be sound. Recursion is fine here: spread-bearing tuples have few\n// fixed elements, while the unbounded fixed-tuple case keeps the mapped zip.\ntype CheckedSpreadTail<\n upstream,\n t extends readonly unknown[],\n p extends SpreadPos,\n> = t extends readonly []\n ? readonly []\n : IsPlainArray<t> extends true\n ? readonly [...CheckedSegment<t, t[number], upstream>]\n : t extends readonly [infer h, ...infer r]\n ? readonly [\n CheckedJoint<h, upstream, JointAt<p>>,\n ...CheckedSpreadTail<OutputOf<h>, r, NextPos<p>>,\n ]\n : SplitSpreadTrail<t> extends [\n infer seg extends readonly unknown[],\n infer trail extends readonly unknown[],\n ]\n ? readonly [\n ...CheckedSegment<seg, seg[number], upstream>,\n ...CheckedSpreadTail<upstream | OutputOf<seg[number]>, trail, 'spread'>,\n ]\n : never\n\n// Rejection brands: both are impossible to satisfy, so the checked overload\n// fails and the call either falls through to the homogeneous array overload\n// or errors with the brand's name and advice on the first line.\ninterface SequenceRuntimeChildrenMustBeHomogeneous<element> {\n readonly runtime_built_children: 'no tuple positions to check; use ReadonlyArray<Step<T, T>>'\n readonly element: element\n}\n\ninterface SequenceLeadingSpreadNeedsFixedFirst {\n readonly leading_spread: 'joint checking needs a fixed first element; a homogeneous ReadonlyArray<Step<T, T>> works via the array overload'\n}\n\n// `unknown[] extends children` is true only for the degenerate constraint\n// instantiation (and a genuine unknown[] argument), which must stay\n// contextually inert. Plain runtime arrays are rejected here so the call\n// falls through to the homogeneous overload instead of degrading to\n// `Step<unknown, unknown>`. `number extends length` detects a spread segment\n// somewhere in the tuple; the trailing `children` fallback only fires for\n// the empty tuple.\ntype CheckedChildren<children extends readonly unknown[]> = unknown[] extends children\n ? children\n : IsPlainArray<children> extends true\n ? SequenceRuntimeChildrenMustBeHomogeneous<children[number]>\n : number extends children['length']\n ? children extends readonly [infer first, ...infer rest]\n ? readonly [CheckedFirst<first>, ...CheckedSpreadTail<OutputOf<first>, rest, readonly []>]\n : SequenceLeadingSpreadNeedsFixedFirst\n : children extends readonly [infer first, ...infer rest]\n ? readonly [CheckedFirst<first>, ...CheckedTail<children, rest>]\n : children\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 * The children parameter is checked joint by joint for literal tuples via\n * `CheckedChildren`; the intersection with the bare `children` parameter is\n * what lets inference read the precise tuple while the checked shape\n * constrains it. Runtime-built arrays carry no positional types, so the\n * second overload requires them to be homogeneous and self-composing, which\n * keeps `run` sound instead of degrading to the unknown boundary. Validates\n * every element up front so a non-Step (usually a bare function) fails at\n * construction with a pointed message rather than at run time. Checks\n * `ctx.abort` before each child so aborts land on step boundaries.\n */\nexport function sequence<const children extends readonly unknown[]>(\n children: children & CheckedChildren<children>,\n options?: SequenceOptions,\n): Step<FirstInput<children>, LastOutput<children>>\nexport function sequence<t>(\n children: ReadonlyArray<Step<t, t>>,\n options?: SequenceOptions,\n): Step<t, t>\nexport function sequence(children: readonly unknown[], options?: SequenceOptions): AnyStep {\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: unknown, index: number) => {\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 // Validation above guarantees every element is a Step; the compile-time\n // story lives in CheckedChildren, so the erased view is a plain step array.\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n const children_ref = children as readonly AnyStep[]\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 // The erased list drops the joint types; the checked signature pairs\n // each child with its predecessor's output, so the dispatch re-asserts.\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n acc = await dispatch_step(child, acc as never, 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 return {\n id,\n kind: 'sequence',\n children: children_ref,\n ...(config_meta ? { config: config_meta } : {}),\n run: run_fn,\n }\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 { suspended_error } from './errors.js'\nimport { dispatch_step, install_abort_fan_out, register_traced_kind, throw_if_aborted } from './runner.js'\nimport type { AnyStep, RunContext, Step, StepInput, StepOutput } from './types.js'\n\n// Distributes the union of member inputs into an intersection: the parallel\n// step's input must satisfy every child, since each receives it verbatim.\ntype UnionToIntersection<u> = (u extends unknown ? (x: u) => void : never) extends (\n x: infer i,\n) => void\n ? i\n : never\n\ntype ParallelInput<children extends Record<string, AnyStep>> = UnionToIntersection<\n StepInput<children[keyof children]>\n>\n\ntype ParallelOutputs<children extends Record<string, AnyStep>> = {\n [k in keyof children]: StepOutput<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\ntype Settled =\n | { readonly status: 'ok'; readonly key: string; readonly value: unknown }\n | { readonly status: 'err'; readonly key: string; readonly err: unknown }\n\n/**\n * Run one child under its own composed abort signal and settle it: an\n * `'ok'`/`'err'` record rather than a thrown error, so a sibling's failure\n * never short-circuits `Promise.all` before every child has finished.\n */\nasync function run_child(\n entry: readonly [string, AnyStep],\n local: AbortController | undefined,\n input: unknown,\n ctx: RunContext,\n): Promise<Settled> {\n const [key, child] = entry\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 // The entry list erases child types; the public signature guarantees the\n // input satisfies every child, so the erased dispatch re-asserts it.\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n const value = await dispatch_step(child, input as never, child_ctx)\n return { status: 'ok', key, value }\n } catch (err) {\n return { status: 'err', key, err }\n }\n}\n\ntype ErrorChoice = { readonly thrown: boolean; readonly err: unknown }\n\n/**\n * Choose which settled error (if any) `run_fn` should rethrow: a\n * `suspended_error` wins over any application error so a human-approval gate\n * inside a branch stays resumable rather than masked by a sibling's failure;\n * otherwise the first error in declared order propagates.\n */\nfunction pick_error(settled: ReadonlyArray<Settled>): ErrorChoice {\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) return { thrown: true, err: suspended }\n if (has_err) return { thrown: true, err: first_err }\n return { thrown: false, err: undefined }\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 * The step's input type is the intersection of the children's inputs, since\n * every child receives the input verbatim. Returns an object keyed by child\n * name. All children settle before any error propagates; a `suspended_error`\n * wins over application errors so a human-approval gate stays resumable\n * instead of being masked by a sibling's failure.\n */\nexport function parallel<children extends Record<string, AnyStep>>(\n members: children,\n options?: ParallelOptions,\n): Step<ParallelInput<children>, 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 (\n input: ParallelInput<children>,\n ctx: RunContext,\n ): Promise<ParallelOutputs<children>> => {\n const controllers = entries.map(() => new AbortController())\n const on_parent_abort = install_abort_fan_out(ctx, controllers)\n\n try {\n const settled = await Promise.all(\n entries.map((entry, idx) => run_child(entry, controllers[idx], input, ctx)),\n )\n\n throw_if_aborted(ctx)\n\n const choice = pick_error(settled)\n if (choice.thrown) throw choice.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 { dispatch_step, install_abort_fan_out, register_traced_kind, throw_if_aborted } 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 const on_parent_abort = install_abort_fan_out(ctx, controllers)\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 throw_if_aborted(ctx)\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 this module is the\n * single algebra they express those delays through. Holding the exponential\n * arithmetic and the timer/abort-listener dance in one place is what keeps the\n * two from disagreeing about whether a delay jitters or caps.\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`. See the factories in `core/retry.ts` and `engine/retry.ts`\n * for what each one 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?, when?, on_error?, project? })`\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. `when` decides which application errors are retryable: one it\n * rejects propagates at once, untouched, without consuming an attempt or\n * firing `on_error`. `on_error` is called on every retryable failure. The\n * last error is rethrown if all attempts fail.\n *\n * `project` maps the `{ value, attempts, errors }` envelope into the step's\n * output, so a caller can record how the value was reached without a\n * mutable closure or a trajectory read. Omitted, the value is the output.\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\n/**\n * How a retry reached its value: `attempts` counts every dispatch including the\n * one that succeeded, and `errors` holds each failed attempt's error in order,\n * so `errors.length === attempts - 1`.\n */\nexport type RetryOutcome<o> = {\n readonly value: o\n readonly attempts: number\n readonly errors: ReadonlyArray<unknown>\n}\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 /**\n * Decide whether an application error is retryable. Returning false\n * propagates the error untouched, the way a control-flow signal does.\n * Omitted, every application error is retryable.\n */\n readonly when?: (err: unknown, attempt: number) => boolean\n readonly on_error?: (err: unknown, attempt: number) => void\n}\n\n/**\n * The `project` option `retry` accepts beside `RetryConfig`. It sits outside\n * `RetryConfig` so a config annotated as `RetryConfig` leaves the output type\n * to be inferred from the inner step.\n */\nexport type RetryProjection<o, projected> = {\n /**\n * Map the `RetryOutcome` envelope into the step's output inside the retry\n * step itself, so `describe` and the trajectory gain no wrapper node.\n * Omitted, the value is the output.\n */\n readonly project?: (outcome: RetryOutcome<o>) => projected\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\ntype Settled<o> = { readonly ok: true; readonly value: o } | { readonly ok: false; readonly error: unknown }\n\n/**\n * Settle one attempt into a value or the error it threw, so the attempt loop\n * reads as a sequence of decisions instead of a nest of try/catch arms.\n */\nasync function settle<o>(attempt: Promise<o>): Promise<Settled<o>> {\n try {\n return { ok: true, value: await attempt }\n } catch (error) {\n return { ok: false, error }\n }\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. Retryable application errors consume an attempt and fire\n * `on_error`; control-flow signals and errors `when` rejects propagate\n * untouched. `project` maps the outcome envelope into the output.\n */\nexport function retry<i, o, projected = o>(\n inner: Step<i, o>,\n config: RetryConfig & RetryProjection<o, projected>,\n): Step<i, projected> {\n // A NaN or Infinity max_attempts would make the attempt loop never run (or\n // never end), so the misconfiguration fails at construction, not mid-run.\n if (!Number.isFinite(config.max_attempts)) {\n throw new TypeError(\n `retry: max_attempts must be a finite number, got ${config.max_attempts}`,\n )\n }\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 when = config.when\n const on_error = config.on_error\n // When `project` is omitted, `projected` defaults to `o`, so handing back\n // the bare value is sound; the cast records that default.\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n const project = config.project ?? ((r: RetryOutcome<o>) => r.value as unknown as projected)\n const backoff_policy: BackoffPolicy = { initial_delay_ms: backoff_ms, max_delay_ms, jitter }\n\n const is_retryable = (err: unknown, attempt: number): boolean =>\n !is_control_flow_error(err) && (when === undefined || when(err, attempt))\n\n const run_fn = async (input: i, ctx: RunContext): Promise<projected> => {\n const errors: unknown[] = []\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 const settled = await settle(dispatch_step(inner, input, ctx))\n // `project` runs outside the settled attempt, so an error it throws is\n // the caller's bug surfacing once rather than a failure that consumes\n // another attempt.\n if (settled.ok) return project({ value: settled.value, attempts: attempt, errors })\n if (!is_retryable(settled.error, attempt)) throw settled.error\n errors.push(settled.error)\n if (on_error) on_error(settled.error, 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 // Stryker disable next-line all: the finiteness guard above forces max_attempts >= 1, so the loop always records an error before this throw; the ?? arm is unreachable belt and braces.\n throw errors.at(-1) ?? new Error('retry: no attempts executed')\n }\n\n const config_meta: Record<string, unknown> = { max_attempts, backoff_ms, max_delay_ms, jitter }\n if (when) config_meta['when'] = when\n if (on_error) config_meta['on_error'] = on_error\n if (config.project) config_meta['project'] = config.project\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 with the\n * primary's error attached as its `cause` (unless it already carries one),\n * so the original failure stays diagnosable from the escaping error.\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. The `when`\n * option narrows the set further: a primary error it rejects propagates the\n * same way, untouched.\n *\n * `project` maps the `{ value, source, primary_error }` envelope into the\n * step's output, so a caller can tell a backup's value from the primary's\n * without a mutable closure. Omitted, the value is the output.\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\n/**\n * Which leg produced a fallback's value. `primary_error` is the error that\n * sent the run to the backup, present only when `source` is `'backup'`.\n */\nexport type FallbackOutcome<o> =\n | { readonly value: o; readonly source: 'primary'; readonly primary_error?: undefined }\n | { readonly value: o; readonly source: 'backup'; readonly primary_error: unknown }\n\nexport type FallbackOptions<i = unknown> = {\n readonly name?: string\n /**\n * Decide whether a primary error sends the run to the backup. Returning\n * false propagates the error untouched, the way a control-flow signal\n * does. Omitted, every application error does.\n */\n readonly when?: (err: unknown) => boolean\n readonly handoff?: (input: i, err: unknown) => i\n}\n\n/**\n * The `project` option `fallback` accepts beside `FallbackOptions`. It sits\n * outside `FallbackOptions` so options annotated as `FallbackOptions` leave\n * the output type to be inferred from the two legs.\n */\nexport type FallbackProjection<o, projected> = {\n /**\n * Map the `FallbackOutcome` envelope into the step's output inside the\n * fallback step itself, so `describe` and the trajectory gain no wrapper\n * node. Omitted, the value is the output.\n */\n readonly project?: (outcome: FallbackOutcome<o>) => projected\n}\n\n/**\n * Build a primary-or-backup step.\n *\n * Runs `primary`; on an application error `when` accepts, runs `backup` with\n * the same input, or with `handoff(input, err)` when the option is set.\n * Control-flow signals and errors `when` rejects propagate without\n * triggering the backup or the handoff. `project` maps the outcome envelope\n * into the output.\n */\nexport function fallback<i, o, projected = o>(\n primary: Step<i, o>,\n backup: Step<i, o>,\n options?: FallbackOptions<i> & FallbackProjection<o, projected>,\n): Step<i, projected> {\n const id = next_id()\n const when = options?.when\n const handoff = options?.handoff\n // When `project` is omitted, `projected` defaults to `o`, so handing back\n // the bare value is sound; the cast records that default.\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n const project = options?.project ?? ((r: FallbackOutcome<o>) => r.value as unknown as projected)\n\n const run_backup = async (input: i, primary_error: unknown, ctx: RunContext): Promise<o> => {\n const backup_input = handoff === undefined ? input : handoff(input, primary_error)\n try {\n return await dispatch_step(backup, backup_input, ctx)\n } catch (backup_err) {\n // When both legs fail, only the backup's error escapes; without this\n // the primary's failure would be lost entirely. Control-flow signals\n // are not failures and pass through unmodified, and an existing cause\n // is never clobbered.\n if (\n !is_control_flow_error(backup_err) &&\n backup_err instanceof Error &&\n !('cause' in backup_err)\n ) {\n backup_err.cause = primary_error\n }\n throw backup_err\n }\n }\n\n // Each leg's value is projected outside its try, so an error thrown by\n // `project` is the caller's bug surfacing once rather than a primary\n // failure that sends the run to the backup.\n const run_fn = async (input: i, ctx: RunContext): Promise<projected> => {\n let value: o\n try {\n value = await dispatch_step(primary, input, ctx)\n } catch (err) {\n if (is_control_flow_error(err)) throw err\n if (when !== undefined && !when(err)) throw err\n const backup_value = await run_backup(input, err, ctx)\n return project({ value: backup_value, source: 'backup', primary_error: err })\n }\n return project({ value, source: 'primary' })\n }\n\n const config_meta: Record<string, unknown> = {}\n if (when) config_meta['when'] = when\n if (options?.project) config_meta['project'] = options.project\n if (options?.name !== undefined) config_meta['display_name'] = options.name\n\n return {\n id,\n kind: 'fallback',\n children: [primary, backup],\n ...(Object.keys(config_meta).length > 0 ? { 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; a bare `(state) => boolean` predicate is\n * accepted as shorthand for a guard that stops without transforming.\n * 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 { step } from './step.js'\nimport type { AnyStep, RunContext, Step } from './types.js'\n\nexport type LoopGuardResult<state> = {\n readonly stop: boolean\n readonly state: state\n}\n\nexport type LoopGuardPredicate<state> = (state: state) => boolean | Promise<boolean>\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>> | LoopGuardPredicate<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 of the form `loop_<n>`.\n *\n * The display `name` deliberately stays out of the id. It is free prose, so\n * folding it in would both make a cosmetic rename move a trajectory id and\n * put an arbitrary string where an identifier is required.\n */\nfunction next_id(): string {\n loop_counter += 1\n return `loop_${loop_counter}`\n}\n\n/**\n * Normalize the guard config to its step form.\n *\n * A bare predicate is sugar for the state-preserving guard step, wrapped here\n * (with an id derived from the loop's, so trees with several loops stay\n * unambiguous) rather than special-cased in the run loop: the predicate form\n * then dispatches, traces, and terminates identically to a hand-written guard.\n */\nfunction wrap_guard<state>(\n guard: Step<state, LoopGuardResult<state>> | LoopGuardPredicate<state> | undefined,\n loop_id: string,\n): Step<state, LoopGuardResult<state>> | undefined {\n if (guard === undefined) return undefined\n if (typeof guard !== 'function') return guard\n return step(`${loop_id}_guard`, async (state: state) => ({\n stop: await guard(state),\n state,\n }))\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, finish, name } = config\n const rounds_limit = Math.max(1, Math.floor(config.max_rounds))\n const id = next_id()\n const guard = wrap_guard(config.guard, id)\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<AnyStep> = 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(inner, { name })` wraps any step and labels its trajectory span\n * with `name`. The inner step's own span (for example, a `sequence`) appears\n * as a child of the compose span: the implementation tree is preserved while\n * the user's intent (\"this whole thing is an ensemble\") is surfaced in\n * 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'` and its id is `compose_<n>`.\n * The user-supplied label lives in `config.display_name`, is the span name\n * the dispatcher opens, and never reaches the id: it is free prose, so\n * folding it in would let a cosmetic rename move a trajectory id.\n */\n\nimport { dispatch_step, register_traced_kind } from './runner.js'\nimport type { RunContext, Step } from './types.js'\n\nexport type ComposeConfig = {\n readonly name: string\n}\n\nlet compose_counter = 0\n\n/**\n * Generate a unique step id of the form `compose_<n>`.\n */\nfunction next_id(): string {\n compose_counter += 1\n return `compose_${compose_counter}`\n}\n\n/**\n * Wrap `inner` in a named composite step.\n *\n * The step's `kind` is always `'compose'`; `config.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>(inner: Step<i, o>, config: ComposeConfig): Step<i, o> {\n const name = config?.name\n if (typeof name !== 'string' || name.length === 0) {\n throw new TypeError('compose(inner, { name }): name must be a non-empty string')\n }\n const id = next_id()\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. Every\n * lookup records a `checkpoint` trajectory event with\n * `status: 'hit' | 'miss' | 'read_error'`.\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(\n \"checkpoint requires a named step, got anonymous — give the inner step an id with step('id', fn)\",\n )\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 // Every lookup records exactly one `checkpoint` event so hits, misses,\n // and swallowed read errors are all visible in the trajectory. A\n // throwing `store.get` still behaves as a miss (a broken store must not\n // fail the run), but under `status: 'read_error'` instead of silently.\n const lookup_meta: Record<string, unknown> = { id, key }\n if (ctx.parent_span_id !== undefined) lookup_meta['span_id'] = ctx.parent_span_id\n try {\n cached = await store.get(key)\n hit = cached !== null && cached !== undefined\n ctx.trajectory.record({\n kind: 'checkpoint',\n status: hit ? 'hit' : 'miss',\n ...lookup_meta,\n })\n } catch (err) {\n hit = false\n ctx.trajectory.record({\n kind: 'checkpoint',\n status: 'read_error',\n error: err instanceof Error ? err.message : String(err),\n ...lookup_meta,\n })\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),\n * records a `suspended` trajectory event, and throws `suspended_error`\n * 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 { is_step } from './is_step.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<i, o>\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 // Mark the suspension on the wire before the throw, so a consumer sees\n // the gate pause as its own event ahead of the span-end error the\n // runner records for the escaping suspended_error. step_id is the\n // suspend step's id (the suspend id), the join key back to the\n // flow_structure node.\n ctx.trajectory.record({ kind: 'suspended', suspend_id, step_id: suspend_id })\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 { AnyStep, RunContext, Step } from './types.js'\n\ntype LastOutput<children> = children extends readonly [...unknown[], Step<never, infer o>]\n ? o\n : children extends readonly [Step<never, 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 // The children list erases step types; the chaining contract pairs each\n // child with its predecessor's output, so the dispatch re-asserts it.\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n acc = await dispatch_step(child, acc as never, 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 * chain: named steps over a growing record.\n *\n * `chain<i>(input_name?)` opens a builder whose threaded value is a record of\n * named outputs rather than a single value. The input type must be stated,\n * either as the type argument or via `.input<t>()` on the freshly opened\n * chain; an unannotated `chain()` defaults to `never` so the omission fails\n * at the `run` call site instead of accepting anything. `.step(name, fn)`\n * runs `fn` over the record and merges its output back in under `name`;\n * `.stage(name, project?)` concludes a phase: it opens a grouping span in\n * the trajectory and, when `project` is given, replaces the record with the\n * projection so earlier bindings go out of scope; `.output(fn)` closes the\n * builder and returns an ordinary `Step<i, o>`.\n *\n * Each `.step` entry is a regular `step(name, fn)` whose input happens to be\n * the record, so anything true of steps (spans, error paths, abort checks\n * between entries) is true of chain entries, and the binding name doubles as\n * the entry's id in trajectories. A binding whose whole job is to invoke an\n * arm is `.step(name, arm, select)`: the chain projects the record through\n * `select`, dispatches the arm via `ctx.call`, and records it as the\n * binding's child, so what `describe` renders and what runs cannot diverge.\n * The escape hatch for bodies that need code around the call is\n * `.step(name, fn, { arm })`: the body does its own `ctx.call` and the arm\n * is metadata only, recorded for `describe` but never dispatched.\n *\n * Builder values are immutable: every method returns a new chain, so a\n * prefix can be shared and extended in different directions safely.\n */\n\nimport { is_step } from './is_step.js'\nimport { dispatch_step, register_traced_kind, throw_if_aborted } from './runner.js'\nimport { step } from './step.js'\nimport { assert_valid_step_id } from './step_id.js'\nimport type { AnyStep, RunContext, Step, StepMetadata } from './types.js'\n\nlet chain_counter = 0\n\n/**\n * Generate a unique step id of the form `chain_<n>`.\n */\nfunction next_chain_id(): string {\n chain_counter += 1\n return `chain_${chain_counter}`\n}\n\ntype merge<a, b> = { readonly [k in keyof (a & b)]: (a & b)[k] }\n\nexport type ChainStepOptions = {\n readonly arm?: AnyStep\n /**\n * Display label for the binding's span and `describe` line. The binding\n * name is a record key and so must be identifier-shaped; this is where the\n * free prose goes, exactly as `meta.name` does for a plain `step`.\n */\n readonly name?: string\n}\n\nexport type Chain<i, acc> = {\n readonly step: {\n <k extends string, o>(\n name: k,\n fn: (s: acc, ctx: RunContext) => Promise<o> | o,\n options?: ChainStepOptions,\n ): Chain<i, merge<acc, { readonly [p in k]: o }>>\n <k extends string, a, o>(\n name: k,\n arm: Step<a, o>,\n select: (s: acc) => a,\n options?: ChainStepOptions,\n ): Chain<i, merge<acc, { readonly [p in k]: o }>>\n }\n readonly stage: {\n (name: string): Chain<i, acc>\n <next extends Record<string, unknown>>(\n name: string,\n project: (s: acc, ctx: RunContext) => Promise<next> | next,\n ): Chain<i, merge<next, unknown>>\n }\n readonly output: <o>(fn: (s: acc, ctx: RunContext) => Promise<o> | o) => Step<i, o>\n}\n\n/**\n * A freshly opened chain: `Chain` plus `.input<t>()`, which restates the\n * input type once with the binding name already fixed, so\n * `chain('q').input<Request>()` equals `chain<Request, 'q'>('q')`. The first\n * `.step` or `.stage` returns plain `Chain`, so refinement is only possible\n * before any entry is recorded.\n */\nexport type ChainOpen<i, k extends string, acc> = Chain<i, acc> & {\n readonly input: <t>() => Chain<t, { readonly [p in k]: t }>\n}\n\ntype LooseFn = (s: Record<string, unknown>, ctx: RunContext) => unknown\n\ntype LooseSelect = (s: Record<string, unknown>) => unknown\n\ntype ChainEntry =\n | { readonly kind: 'step'; readonly name: string; readonly node: Step<Record<string, unknown>, unknown> }\n | { readonly kind: 'stage'; readonly name: string; readonly project?: LooseFn }\n\ntype LooseChain = {\n readonly step: (\n name: string,\n fn_or_arm: LooseFn | AnyStep,\n options_or_select?: ChainStepOptions | LooseSelect,\n options?: ChainStepOptions,\n ) => LooseChain\n readonly stage: (name: string, project?: LooseFn) => LooseChain\n readonly output: (fn: LooseFn) => Step<unknown, unknown>\n}\n\n/**\n * Assemble the runnable chain Step from its entries and output node.\n *\n * Runs entries in order over a record seeded with the input under\n * `input_name`. Step entries merge their output under their name; stage\n * entries end the previous stage span, open a new one that subsequent\n * entries nest under, and, when projecting, replace the record. The output\n * node runs last and its value is the chain's output. `config.plan` lists\n * the entry names in order so `describe` shows the topology without running.\n *\n * The `Step<unknown, unknown>` return is the concrete type, not an erased\n * top type: the run function genuinely accepts any input, seeding the record\n * with whatever arrives. The typed `chain` surface narrows it at the cast.\n */\nfunction build_chain(\n input_name: string,\n entries: ReadonlyArray<ChainEntry>,\n output_node: Step<Record<string, unknown>, unknown>,\n): Step<unknown, unknown> {\n const id = next_chain_id()\n const plan = [\n ...entries.map((e) => (e.kind === 'stage' ? `stage:${e.name}` : e.name)),\n 'output',\n ]\n const children = [\n ...entries.flatMap((e) => (e.kind === 'step' ? [e.node] : [])),\n output_node,\n ]\n\n const run_fn = async (input: unknown, ctx: RunContext): Promise<unknown> => {\n let record: Record<string, unknown> = { [input_name]: input }\n let current_ctx = ctx\n let stage_span: string | undefined\n let stage_id: string | undefined\n\n const end_stage = (error?: string): void => {\n if (stage_span === undefined) return\n const meta: Record<string, unknown> = { id: stage_id }\n if (error !== undefined) meta['error'] = error\n ctx.trajectory.end_span(stage_span, meta)\n stage_span = undefined\n }\n\n try {\n for (const entry of entries) {\n throw_if_aborted(current_ctx)\n if (entry.kind === 'stage') {\n end_stage()\n stage_id = `stage:${entry.name}`\n const meta: Record<string, unknown> = { id: stage_id }\n if (ctx.parent_span_id !== undefined) meta['parent_span_id'] = ctx.parent_span_id\n stage_span = ctx.trajectory.start_span(entry.name, meta)\n current_ctx = { ...ctx, parent_span_id: stage_span }\n if (entry.project !== undefined) {\n // The typed surface constrains projections to return a record; the\n // runtime trusts that the same way `use` trusts its callback.\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n record = (await entry.project(record, current_ctx)) as Record<string, unknown>\n }\n } else {\n const value = await dispatch_step(entry.node, record, current_ctx)\n record = { ...record, [entry.name]: value }\n }\n }\n throw_if_aborted(current_ctx)\n const out = await dispatch_step(output_node, record, current_ctx)\n end_stage()\n return out\n } catch (err) {\n end_stage(err instanceof Error ? err.message : String(err))\n throw err\n }\n }\n\n return {\n id,\n kind: 'chain',\n children,\n config: { input: input_name, plan },\n run: run_fn,\n }\n}\n\n/**\n * Project a binding's options onto `step`'s trailing metadata argument.\n *\n * Returned as a spreadable tuple so a binding with no label calls `step`\n * with two arguments, leaving `meta` genuinely absent rather than set to an\n * empty object that `describe` would then echo.\n */\nfunction binding_meta(options: ChainStepOptions | undefined): [] | [StepMetadata] {\n return options?.name === undefined ? [] : [{ name: options.name }]\n}\n\n/**\n * Build the binding node for the arm-first `.step(name, arm, select)` form.\n *\n * The chain owns the dispatch: the synthesized body projects the record\n * through `select` and hands the result to the arm via `ctx.call`, and the\n * same arm is recorded as the binding's child, so the subtree `describe`\n * renders and the step that runs are one value by construction.\n */\nfunction arm_node(\n name: string,\n arm: AnyStep,\n select: ChainStepOptions | LooseSelect | undefined,\n options: ChainStepOptions | undefined,\n): Step<Record<string, unknown>, unknown> {\n if (typeof select !== 'function') {\n throw new TypeError('chain.step(name, arm, select): select must be a function')\n }\n const base = step(\n name,\n (s: Record<string, unknown>, ctx: RunContext) =>\n // The typed surface pairs select's projection with the arm's input, a\n // pairing the erased AnyStep cannot carry, so the call re-asserts it.\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n ctx.call(arm, select(s) as never),\n ...binding_meta(options),\n )\n return { ...base, children: [arm] }\n}\n\n/**\n * Build the binding node for the body form `.step(name, fn, { arm? })`.\n */\nfunction body_node(\n name: string,\n fn: LooseFn,\n options: ChainStepOptions | LooseSelect | undefined,\n): Step<Record<string, unknown>, unknown> {\n const settings = typeof options === 'function' ? undefined : options\n const base = step(name, fn, ...binding_meta(settings))\n const arm = settings?.arm\n // The arm is describe metadata only: recorded as the binding's child so\n // the subtree renders, never dispatched (the body's ctx.call runs it).\n return arm === undefined ? base : { ...base, children: [arm] }\n}\n\n/**\n * Internal untyped builder behind `chain`.\n *\n * `bound` holds the binding names of the current stage segment so duplicate\n * names fail at build time (the typed surface would silently intersect\n * them); a projecting stage resets it because the projection's keys are only\n * known to the type system.\n */\nfunction make_chain(\n input_name: string,\n entries: ReadonlyArray<ChainEntry>,\n bound: ReadonlySet<string>,\n): LooseChain {\n return {\n step: (name, fn_or_arm, options_or_select, arm_options) => {\n assert_valid_step_id(\n name,\n 'chain.step: binding name',\n 'put the label in the options object as { name }',\n )\n if (bound.has(name)) {\n throw new TypeError(\n `chain.step: binding '${name}' is already defined in this stage; names are single-assignment`,\n )\n }\n const node = is_step(fn_or_arm)\n ? arm_node(name, fn_or_arm, options_or_select, arm_options)\n : body_node(name, fn_or_arm, options_or_select)\n return make_chain(\n input_name,\n [...entries, { kind: 'step', name, node }],\n new Set([...bound, name]),\n )\n },\n stage: (name, project) =>\n make_chain(\n input_name,\n [\n ...entries,\n project === undefined ? { kind: 'stage', name } : { kind: 'stage', name, project },\n ],\n project === undefined ? bound : new Set(),\n ),\n output: (fn) => build_chain(input_name, entries, step('output', fn)),\n }\n}\n\n/**\n * Open a chain builder whose record starts as `{ [input_name]: input }`.\n *\n * `input_name` defaults to `'input'`. The input type defaults to `never`, so\n * a chain that never states it produces a `Step<never, o>` that no real\n * input satisfies at `run`; state it as the type argument or, when the\n * binding is renamed, once via `.input<t>()` on the fresh builder. Each\n * `.step` narrows subsequent callbacks to the record accumulated so far, and\n * `.stage` with a projection re-types the record to the projection's\n * return, so binding names and views are checked at compile time with no\n * declared state shape.\n */\nexport function chain<i = never, k extends string = 'input'>(\n input_name?: k,\n): ChainOpen<i, k, { readonly [p in k]: i }> {\n const name = input_name ?? 'input'\n assert_valid_step_id(name, 'chain: input name', 'rename the binding')\n const open = make_chain(name, [], new Set([name]))\n // `.input` is compile-time refinement over the same empty builder, so\n // returning it unchanged is the whole implementation.\n // oxlint-disable-next-line typescript/no-unsafe-type-assertion\n return { ...open, input: () => open } as unknown as ChainOpen<i, k, { readonly [p in k]: i }>\n}\n\nregister_traced_kind('chain')\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 type { RunOptions, RunOutcome, StreamingRunHandle } from './runner.js'\nexport { step } from './step.js'\nexport { describe } from './describe.js'\nexport type { DescribeOptions, FlowNode, FlowValue } from './describe.js'\nexport { resolve_display_name } from './display_name.js'\nexport { assert_valid_step_id, is_valid_step_id, suggest_step_id } from './step_id.js'\nexport { sequence } from './sequence.js'\nexport type { SequenceOptions } from './sequence.js'\nexport { parallel } from './parallel.js'\nexport type { ParallelOptions } from './parallel.js'\nexport { branch } from './branch.js'\nexport type { BranchConfig } from './branch.js'\nexport { map } from './map.js'\nexport type { MapConfig } from './map.js'\nexport { pipe } from './pipe.js'\nexport type { PipeOptions } from './pipe.js'\nexport { retry } from './retry.js'\nexport type { RetryConfig, RetryOutcome, RetryProjection } from './retry.js'\nexport { fallback } from './fallback.js'\nexport type { FallbackOptions, FallbackOutcome, FallbackProjection } from './fallback.js'\nexport { timeout } from './timeout.js'\nexport type { TimeoutOptions } from './timeout.js'\nexport { loop } from './loop.js'\nexport type { LoopConfig, LoopGuardPredicate, LoopGuardResult, LoopOutcome } from './loop.js'\nexport { compose } from './compose.js'\nexport type { ComposeConfig } from './compose.js'\nexport { checkpoint } from './checkpoint.js'\nexport type { CheckpointConfig } from './checkpoint.js'\nexport { suspend } from './suspend.js'\nexport type { SuspendConfig } from './suspend.js'\nexport { scope, stash, use } from './scope.js'\nexport type { ScopeOptions, StashOptions, UseOptions } from './scope.js'\nexport { chain } from './chain.js'\nexport type { Chain, ChainOpen, ChainStepOptions } from './chain.js'\n\nexport {\n aborted_error,\n describe_cycle_error,\n error_path,\n resume_validation_error,\n suspended_error,\n timeout_error,\n} from './errors.js'\n\n// Named in core's public signatures (SuspendConfig.resume_schema,\n// resume_validation_error.issues), so they must be nameable from the same\n// surface that exports those.\nexport type { AnySchema, SchemaIssue } from '#schema'\n\nexport type {\n AnyStep,\n CheckpointStore,\n CleanupFn,\n RunContext,\n Step,\n StepFn,\n StepInput,\n StepMetadata,\n StepOutput,\n TrajectoryEvent,\n TrajectoryLogger,\n} from './types.js'\n\nexport { is_step } from './is_step.js'\nexport { is_step_kind, STEP_KINDS } from './step_kinds.js'\nexport type { StepKind } from './step_kinds.js'\n\nexport {\n is_checkpoint_event,\n is_custom_trajectory_event,\n is_emit_event,\n is_run_end_event,\n is_span_end_event,\n is_span_start_event,\n parse_trajectory_event,\n} from './trajectory.js'\nexport type {\n CheckpointEvent,\n CheckpointStatus,\n CustomTrajectoryEvent,\n EmitEvent,\n ParsedTrajectoryEvent,\n RunEndEvent,\n RunEndStatus,\n SpanEndEvent,\n SpanStartEvent,\n TrajectoryParseResult,\n} from './trajectory.js'\n\nexport { flow_schema_data as flow_schema }\n"],"mappings":";;AAYA,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;;;AC7EA,IAAa,gBAAb,cAAmC,MAAM;CACvC,OAAgB;CAEhB;CACA,YAAY,SAAiB,YAAoB;EAC/C,MAAM,OAAO;EACb,KAAK,OAAO;EACZ,KAAK,aAAa;CACpB;AACF;AAEA,IAAa,kBAAb,cAAqC,MAAM;CACzC,OAAgB;CAEhB;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;CAEhB;CACA,YAAY,SAAiB,QAAoC;EAC/D,MAAM,OAAO;EACb,KAAK,OAAO;EACZ,KAAK,SAAS;CAChB;AACF;AAEA,IAAa,uBAAb,cAA0C,MAAM;CAC9C,OAAgB;CAEhB;CACA,YAAY,SAAiB,SAAkB;EAC7C,MAAM,WAAW,wCAAwC,SAAS;EAClE,KAAK,OAAO;EACZ,KAAK,UAAU;CACjB;AACF;AAEA,IAAa,gBAAb,cAAmC,MAAM;CACvC,OAAgB;CAEhB;CAIA;CACA;CACA,YACE,UAAU,WACV,WAII,CAAC,GACL;EACA,MAAM,OAAO;EACb,KAAK,OAAO;EACZ,IAAI,SAAS,WAAW,KAAA,GAAW,KAAK,SAAS,SAAS;EAC1D,IAAI,SAAS,eAAe,KAAA,GAAW,KAAK,aAAa,SAAS;EAClE,IAAI,SAAS,wBAAwB,KAAA,GACnC,KAAK,sBAAsB,SAAS;CAExC;AACF;;;;;;;;;;AAWA,SAAgB,sBACd,KACwC;CACxC,OAAO,eAAe,mBAAmB,eAAe;AAC1D;;;;;;;;;;AAWA,SAAgB,WAAW,KAAiD;CAC1E,IAAI,QAAQ,QAAQ,OAAO,QAAQ,UAAU,OAAO,KAAA;CACpD,MAAM,OAAgB,QAAQ,IAAI,KAAK,MAAM;CAC7C,IAAI,CAAC,MAAM,QAAQ,IAAI,GAAG,OAAO,KAAA;CACjC,MAAM,UAAkC;CACxC,MAAM,MAAM,QAAQ,QAAQ,MAAmB,OAAO,MAAM,QAAQ;CACpE,OAAO,IAAI,WAAW,QAAQ,SAAS,MAAM,KAAA;AAC/C;;;;;;;;;ACtGA,SAAgB,QAAQ,OAAkC;CACxD,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,SAAgB,qBAAqB,MAAe,UAA0B;CAC5E,MAAM,UAAU,KAAK,SAAS;CAC9B,IAAI,OAAO,YAAY,YAAY,QAAQ,SAAS,GAAG,OAAO;CAC9D,MAAM,OAAO,KAAK,MAAM;CACxB,IAAI,OAAO,SAAS,YAAY,KAAK,SAAS,GAAG,OAAO;CACxD,OAAO;AACT;;;;;;;;;;;;;;;;;;;ACLA,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,KAAK,GAAG,SAAS,qBAAqB,MAAM,KAAK,IAAI,EAAE,GAAG,KAAK,GAAG,EAAE;EAC1E,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;;;;;;;;;;;;;AAcA,SAAS,kBAAkB,OAAgB,MAAY,QAAyB;CAC9E,IAAI,QAAQ,KAAK,GAAG,OAAO,iBAAiB,OAAO,MAAM,MAAM;CAC/D,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO,IAAI,MAAM,KAAK,SAAkB,kBAAkB,MAAM,MAAM,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE;CAE5F,IAAI,qBAAqB,KAAK,GAI5B,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,OAAO,mBAAmB,KAAK;AACjC;;;;;AAMA,SAAS,iBAAiB,OAAgB,MAAY,QAAyB;CAC7E,IAAI,KAAK,IAAI,KAAK,GAAG;EACnB,IAAI,QAAQ,MAAM,IAAI,qBAAqB,MAAM,EAAE;EACnD,OAAO,WAAW,MAAM,GAAG;CAC7B;CACA,OAAO,GAAG,MAAM,KAAK,GAAG,MAAM,GAAG;AACnC;;;;;;AAOA,SAAS,mBAAmB,OAAwB;CAClD,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,OAAO,sBAAsB,KAAK;AACpC;;;;;;AAOA,SAAS,sBAAsB,OAAwB;CACrD,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;;;;;;;;;;;;AAaA,SAAS,kBAAkB,OAAgB,MAAY,QAA4B;CACjF,IAAI,QAAQ,KAAK,GAAG,OAAO,iBAAiB,OAAO,MAAM,MAAM;CAC/D,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO,MAAM,KAAK,SAAkB,kBAAkB,MAAM,MAAM,MAAM,CAAC;CAE3E,IAAI,qBAAqB,KAAK,GAAG;EAC/B,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,OAAO,mBAAmB,KAAK;AACjC;;;;;AAMA,SAAS,iBAAiB,OAAgB,MAAY,QAA4B;CAChF,IAAI,KAAK,IAAI,KAAK,GAAG;EACnB,IAAI,QAAQ,MAAM,IAAI,qBAAqB,MAAM,EAAE;EACnD,OAAO;GAAE,MAAM;GAAW,IAAI,MAAM;EAAG;CACzC;CACA,OAAO;EAAE,MAAM,MAAM;EAAM,IAAI,MAAM;CAAG;AAC1C;;;;;AAMA,SAAS,mBAAmB,OAA2B;CACrD,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,OAAO,sBAAsB,KAAK;AACpC;;;;;;AAOA,SAAS,sBAAsB,OAA2B;CACxD,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;;;;;;AAOA,SAAS,qBAAqB,OAAiC;CAC7D,OAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,cAAc,KAAK;AAC5E;;;AClSA,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;EACb;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;;;;;;;;;;;;;;;;;;;AC7EA,MAAM,2BAAW,IAAI,IAAwB;;;;;;;AAQ7C,SAAS,cAAc,MAAc,IAAsB;CACzD,SAAS,IAAI,MAAM,EAAE;AACvB;;;;;;;;;;;AAYA,SAAgB,qBAAqB,MAAoB;CACvD,cAAc,MAAM,OAAO,MAAM,OAAO,QAAQ;EAC9C,MAAM,QAAQ,qBAAqB,MAAM,IAAI;EAC7C,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;GAKF,MAAM,MAAM,MAAM,KAAK,IAAI,OAAgB,SAAS;GACpD,IAAI,WAAW,SAAS,SAAS,EAAE,IAAI,KAAK,GAAG,CAAC;GAChD,OAAO;EACT,SAAS,KAAK;GACZ,IAAI,WAAW,SAAS,SAAS;IAAE,IAAI,KAAK;IAAI,GAAG,WAAW,GAAG;GAAE,CAAC;GACpE,MAAM;EACR;CACF,CAAC;AACH;;;;;;;;;;AAWA,SAAS,WAAW,KAAuC;CACzD,MAAM,OAAgC,EACpC,OAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,EACxD;CACA,IAAI,eAAe,SAAS,IAAI,KAAK,SAAS,GAAG,KAAK,gBAAgB,IAAI;CAC1E,IAAI,QAAQ,QAAQ,OAAO,QAAQ,UAAU;EAC3C,MAAM,OAAO,QAAQ,IAAI,KAAK,MAAM;EACpC,IAAI,OAAO,SAAS,UAAU,KAAK,gBAAgB;EACnD,MAAM,OAAO,QAAQ,IAAI,KAAK,MAAM;EACpC,IAAI,MAAM,QAAQ,IAAI,GACpB,KAAK,gBAAgB,KAAK,QAAQ,MAAmB,OAAO,MAAM,QAAQ;CAE9E;CACA,OAAO;AACT;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,SAAS,aAAa,KAAc,IAAkB;CACpD,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;;;;;;;;;;;;;AAcA,SAAgB,sBACd,KACA,aACY;CACZ,MAAM,wBAA8B;EAClC,KAAK,MAAM,KAAK,aAAa,EAAE,MAAM,IAAI,MAAM,MAAM;CACvD;CACA,IAAI,IAAI,MAAM,SACZ,gBAAgB;MAEhB,IAAI,MAAM,iBAAiB,SAAS,iBAAiB,EAAE,MAAM,KAAK,CAAC;CAErE,OAAO;AACT;;;;;;;;;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;;;;;;;;;;;AAiBA,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;CAI9D,IAAI,QAAQ,eAAe,KAAA,KAAa,WACtC,OAAO,OAAO;EAAE,MAAM;EAAkB,WAAW,SAAS,KAAK,IAAI;CAAE,CAAC;CAG1E,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,KAA+B,GAAiB,aAA8B;GAC5E,iBAAiB,IAAI;GACrB,OAAO,cAAc,GAAG,aAAa,IAAI;EAC3C;EACA,kBAAkB,QAAQ;EAC1B,aAAa,QAAQ;EACrB;CACF;CAEA,YAAY,IAAI,UAAU;CAC1B,IAAI,yBACF,uBAAuB;CAGzB,MAAM,UAAU,YAAwB;EACtC,IAAI,WAA4B;GAAE,MAAM;GAAW,QAAQ;EAAO;EAClE,IAAI;GAIF,iBAAiB,GAAG;GACpB,OAAO,MAAM,cAAc,MAAM,OAAO,GAAG;EAC7C,SAAS,KAAK;GACZ,IAAI,SAAkB;GACtB,IAAI,WAAW,OAAO,WAAW,EAAE,eAAe,gBAAgB;IAChE,MAAM,SAAS,WAAW,OAAO;IACjC,IAAI,kBAAkB,eAAe,SAAS;GAChD;GAIA,MAAM,cACJ,kBAAkB,iBACjB,WAAW,OAAO,WAAW,WAAW,WAAW,OAAO;GAC7D,WAAW,cAAc,QAAQ,WAAW;GAC5C,MAAM;EACR,UAAU;GACR,IAAI;IACF,MAAM,QAAQ,QAAQ;GACxB,UAAU;IAGR,OAAO,OAAO,QAAQ;IACtB,aAAa;IACb,YAAY,OAAO,UAAU;IAC7B,wBAAwB;IACxB,IAAI,cAAc,aAAa;GACjC;EACF;CACF,EAAA,CAAG;CAEH,OAAO;EAAE,QAAQ;EAAe;CAAO;AACzC;;;;;;;;AASA,SAAS,cAAc,KAAc,aAAuC;CAC1E,IAAI,eAAe,iBACjB,OAAO;EAAE,MAAM;EAAW,QAAQ;EAAa,YAAY,IAAI;CAAW;CAE5E,IAAI,aACF,OAAO;EACL,MAAM;EACN,QAAQ;EACR,OAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;CACxD;CAEF,OAAO;EAAE,MAAM;EAAW,QAAQ;EAAU,GAAG,WAAW,GAAG;CAAE;AACjE;;;;;;;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;;;;;;;;;;;;;;;;AA6BA,eAAe,oBACb,MACA,OACA,UAAsB,CAAC,GACC;CACxB,IAAI;EACF,OAAO;GAAE,MAAM;GAAQ,QAAQ,MAAM,SAAS,MAAM,OAAO,OAAO;EAAE;CACtE,SAAS,KAAK;EACZ,IAAI,EAAE,eAAe,kBAAkB,MAAM;EAC7C,MAAM,KAAK,IAAI;EACf,OAAO;GACL,MAAM;GACN;GACA,SAAS,IAAI;GACb,SAAS,SACP,oBAAoB,MAAM,OAAO;IAC/B,GAAG;IACH,aAAa;KAAE,GAAG,QAAQ;MAAc,KAAK;IAAK;GACpD,CAAC;EACL;CACF;AACF;;;;;;;;;;AAWA,MAAa,MAGT,OAAO,OAAO,UAAU;CAC1B,QAAQ;CACR,iBAAiB;AACnB,CAAC;;;;;;;;;;;;;;;;;;;;;;AC5hBD,MAAM,aAAa;;;;AAKnB,SAAgB,iBAAiB,IAAqB;CACpD,OAAO,WAAW,KAAK,EAAE;AAC3B;;;;;;AAOA,SAAgB,gBAAgB,KAAqB;CACnD,MAAM,UAAU,IAAI,QAAQ,yBAAyB,GAAG;CACxD,OAAO,WAAW,KAAK,OAAO,IAAI,UAAU,IAAI;AAClD;;;;;;AAOA,SAAgB,qBAAqB,IAAY,SAAiB,QAAsB;CACtF,IAAI,iBAAiB,EAAE,GAAG;CAC1B,MAAM,IAAI,UACR,GAAG,QAAQ,GAAG,KAAK,UAAU,EAAE,EAAE,0EAA0E,gBAAgB,EAAE,EAAE,OAAO,QACxI;AACF;;;;;;;;;;;;;;;;;;;;;AC3BA,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,qBAAqB,UAAU,WAAW,4BAA4B;CACtE,IAAI,MACF,OAAO;EACL,IAAI;EACJ,MAAM;EACN,KAAK;EACL;CACF;CAEF,OAAO;EACL,IAAI;EACJ,MAAM;EACN,KAAK;CACP;AACF;AAEA,qBAAqB,MAAM;;;;;;;;;;;;;;;;;;;;;AC4H3B,IAAI,mBAAmB;;;;AAKvB,SAASA,aAAkB;CACzB,oBAAoB;CACpB,OAAO,YAAY;AACrB;AA2BA,SAAgB,SAAS,UAA8B,SAAoC;CACzF,IAAI,CAAC,MAAM,QAAQ,QAAQ,GACzB,MAAM,IAAI,UACR,+DAA+D,OAAO,SAAS,4DACjF;CAEF,SAAS,SAAS,OAAgB,UAAkB;EAClD,IAAI,QAAQ,KAAK,GAAG;EAKpB,MAAM,IAAI,UACR,gCAAgC,MAAM,uBAAuB,OAAO,QAJpE,OAAO,UAAU,aACb,sFACA,IAGN;CACF,CAAC;CAED,MAAM,KAAKA,WAAQ;CAInB,MAAM,eAAe;CACrB,MAAM,SAAS,OAAO,OAAgB,QAAsC;EAC1E,IAAI,MAAe;EACnB,KAAK,MAAM,SAAS,cAAc;GAChC,iBAAiB,GAAG;GAIpB,MAAM,MAAM,cAAc,OAAO,KAAc,GAAG;EACpD;EACA,OAAO;CACT;CAEA,MAAM,cACJ,SAAS,SAAS,KAAA,IAAY,KAAA,IAAY,EAAE,cAAc,QAAQ,KAAK;CAEzE,OAAO;EACL;EACA,MAAM;EACN,UAAU;EACV,GAAI,cAAc,EAAE,QAAQ,YAAY,IAAI,CAAC;EAC7C,KAAK;CACP;AACF;AAEA,qBAAqB,UAAU;;;;;;;;;;;;;;;;;;;;ACjP/B,IAAI,mBAAmB;;;;AAKvB,SAASC,YAAkB;CACzB,oBAAoB;CACpB,OAAO,YAAY;AACrB;;;;;;AAWA,eAAe,UACb,OACA,OACA,OACA,KACkB;CAClB,MAAM,CAAC,KAAK,SAAS;CACrB,IAAI,CAAC,OAAO,MAAM,IAAI,MAAM,8BAA8B;CAC1D,MAAM,WAAW,YAAY,IAAI,CAAC,IAAI,OAAO,MAAM,MAAM,CAAC;CAC1D,MAAM,YAAwB;EAAE,GAAG;EAAK,OAAO;CAAS;CACxD,IAAI;EAKF,OAAO;GAAE,QAAQ;GAAM;GAAK,OAAA,MADR,cAAc,OAAO,OAAgB,SAAS;EAChC;CACpC,SAAS,KAAK;EACZ,OAAO;GAAE,QAAQ;GAAO;GAAK;EAAI;CACnC;AACF;;;;;;;AAUA,SAAS,WAAW,SAA8C;CAChE,IAAI;CACJ,IAAI,UAAU;CACd,IAAI;CACJ,IAAI,gBAAgB;CACpB,KAAK,MAAM,KAAK,SAAS;EACvB,IAAI,EAAE,WAAW,OAAO;EACxB,IAAI,CAAC,SAAS;GACZ,YAAY,EAAE;GACd,UAAU;EACZ;EACA,IAAI,CAAC,iBAAiB,EAAE,eAAe,iBAAiB;GACtD,YAAY,EAAE;GACd,gBAAgB;EAClB;CACF;CACA,IAAI,eAAe,OAAO;EAAE,QAAQ;EAAM,KAAK;CAAU;CACzD,IAAI,SAAS,OAAO;EAAE,QAAQ;EAAM,KAAK;CAAU;CACnD,OAAO;EAAE,QAAQ;EAAO,KAAK,KAAA;CAAU;AACzC;;;;;;;;;;AAeA,SAAgB,SACd,SACA,SAC0D;CAC1D,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,OACb,OACA,QACuC;EACvC,MAAM,cAAc,QAAQ,UAAU,IAAI,gBAAgB,CAAC;EAC3D,MAAM,kBAAkB,sBAAsB,KAAK,WAAW;EAE9D,IAAI;GACF,MAAM,UAAU,MAAM,QAAQ,IAC5B,QAAQ,KAAK,OAAO,QAAQ,UAAU,OAAO,YAAY,MAAM,OAAO,GAAG,CAAC,CAC5E;GAEA,iBAAiB,GAAG;GAEpB,MAAM,SAAS,WAAW,OAAO;GACjC,IAAI,OAAO,QAAQ,MAAM,OAAO;GAEhC,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;;;;;;;;;;ACvJ/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;;;;;;;;;;;;;;;;ACjC7B,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;EACxC,MAAM,kBAAkB,sBAAsB,KAAK,WAAW;EAE9D,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,iBAAiB,GAAG;GACpB,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;;;;;;;;;ACxG1B,IAAI,eAAe;;;;AAKnB,SAASC,YAAkB;CACzB,gBAAgB;CAChB,OAAO,QAAQ;AACjB;;;;;;;;AAaA,SAAgB,KACd,OACA,IACA,SACY;CACZ,IAAI,CAAC,QAAQ,KAAK,GAEhB,MAAM,IAAI,UAAU,8CAA8C,OAAO,QAD5D,OAAO,UAAU,aAAa,0CAA0C,IACE;CAEzF,IAAI,OAAO,OAAO,YAAY;EAC5B,IAAI,QAAQ,EAAE,GACZ,MAAM,IAAI,UACR,+GACF;EAEF,MAAM,IAAI,UAAU,+CAA+C,OAAO,IAAI;CAChF;CACA,IAAI,QAAQ,OAAO,GACjB,MAAM,IAAI,UACR,uHACF;CAGF,MAAM,KAAKA,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC5CA,MAAM,qBAAqB;AAC3B,MAAM,uBAAuB;AA0C7B,IAAI,gBAAgB;;;;AAKpB,SAASC,YAAkB;CACzB,iBAAiB;CACjB,OAAO,SAAS;AAClB;;;;;;;;;;;;;;;;AAiBA,SAAS,eAAe,QAAwB;CAC9C,OAAO,kBAAkB,QAAQ,SAAS,IAAI,cAAc,WAAW,EAAE,OAAO,CAAC;AACnF;;;;;AAQA,eAAe,OAAU,SAA0C;CACjE,IAAI;EACF,OAAO;GAAE,IAAI;GAAM,OAAO,MAAM;EAAQ;CAC1C,SAAS,OAAO;EACd,OAAO;GAAE,IAAI;GAAO;EAAM;CAC5B;AACF;;;;;;;;;AAUA,SAAgB,MACd,OACA,QACoB;CAGpB,IAAI,CAAC,OAAO,SAAS,OAAO,YAAY,GACtC,MAAM,IAAI,UACR,oDAAoD,OAAO,cAC7D;CAEF,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,OAAO,OAAO;CACpB,MAAM,WAAW,OAAO;CAIxB,MAAM,UAAU,OAAO,aAAa,MAAuB,EAAE;CAC7D,MAAM,iBAAgC;EAAE,kBAAkB;EAAY;EAAc;CAAO;CAE3F,MAAM,gBAAgB,KAAc,YAClC,CAAC,sBAAsB,GAAG,MAAM,SAAS,KAAA,KAAa,KAAK,KAAK,OAAO;CAEzE,MAAM,SAAS,OAAO,OAAU,QAAwC;EACtE,MAAM,SAAoB,CAAC;EAC3B,KAAK,IAAI,UAAU,GAAG,WAAW,cAAc,WAAW,GAAG;GAC3D,IAAI,IAAI,MAAM,SACZ,MAAM,eAAe,IAAI,MAAM,MAAM;GAEvC,MAAM,UAAU,MAAM,OAAO,cAAc,OAAO,OAAO,GAAG,CAAC;GAI7D,IAAI,QAAQ,IAAI,OAAO,QAAQ;IAAE,OAAO,QAAQ;IAAO,UAAU;IAAS;GAAO,CAAC;GAClF,IAAI,CAAC,aAAa,QAAQ,OAAO,OAAO,GAAG,MAAM,QAAQ;GACzD,OAAO,KAAK,QAAQ,KAAK;GACzB,IAAI,UAAU,SAAS,QAAQ,OAAO,OAAO;GAC7C,IAAI,WAAW,cAAc;GAE7B,MAAM,gBADQ,gBAAgB,gBAAgB,UAAU,CAC9B,GAAG,IAAI,OAAO,cAAc;EACxD;EAEA,MAAM,OAAO,GAAG,EAAE,qBAAK,IAAI,MAAM,6BAA6B;CAChE;CAEA,MAAM,cAAuC;EAAE;EAAc;EAAY;EAAc;CAAO;CAC9F,IAAI,MAAM,YAAY,UAAU;CAChC,IAAI,UAAU,YAAY,cAAc;CACxC,IAAI,OAAO,SAAS,YAAY,aAAa,OAAO;CACpD,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;;;;;;;;;;;;;;;;;;;;;;;ACvK5B,IAAI,mBAAmB;;;;AAKvB,SAASC,YAAkB;CACzB,oBAAoB;CACpB,OAAO,YAAY;AACrB;;;;;;;;;;AA4CA,SAAgB,SACd,SACA,QACA,SACoB;CACpB,MAAM,KAAKA,UAAQ;CACnB,MAAM,OAAO,SAAS;CACtB,MAAM,UAAU,SAAS;CAIzB,MAAM,UAAU,SAAS,aAAa,MAA0B,EAAE;CAElE,MAAM,aAAa,OAAO,OAAU,eAAwB,QAAgC;EAC1F,MAAM,eAAe,YAAY,KAAA,IAAY,QAAQ,QAAQ,OAAO,aAAa;EACjF,IAAI;GACF,OAAO,MAAM,cAAc,QAAQ,cAAc,GAAG;EACtD,SAAS,YAAY;GAKnB,IACE,CAAC,sBAAsB,UAAU,KACjC,sBAAsB,SACtB,EAAE,WAAW,aAEb,WAAW,QAAQ;GAErB,MAAM;EACR;CACF;CAKA,MAAM,SAAS,OAAO,OAAU,QAAwC;EACtE,IAAI;EACJ,IAAI;GACF,QAAQ,MAAM,cAAc,SAAS,OAAO,GAAG;EACjD,SAAS,KAAK;GACZ,IAAI,sBAAsB,GAAG,GAAG,MAAM;GACtC,IAAI,SAAS,KAAA,KAAa,CAAC,KAAK,GAAG,GAAG,MAAM;GAC5C,MAAM,eAAe,MAAM,WAAW,OAAO,KAAK,GAAG;GACrD,OAAO,QAAQ;IAAE,OAAO;IAAc,QAAQ;IAAU,eAAe;GAAI,CAAC;EAC9E;EACA,OAAO,QAAQ;GAAE;GAAO,QAAQ;EAAU,CAAC;CAC7C;CAEA,MAAM,cAAuC,CAAC;CAC9C,IAAI,MAAM,YAAY,UAAU;CAChC,IAAI,SAAS,SAAS,YAAY,aAAa,QAAQ;CACvD,IAAI,SAAS,SAAS,KAAA,GAAW,YAAY,kBAAkB,QAAQ;CAEvE,OAAO;EACL;EACA,MAAM;EACN,UAAU,CAAC,SAAS,MAAM;EAC1B,GAAI,OAAO,KAAK,WAAW,CAAC,CAAC,SAAS,IAAI,EAAE,QAAQ,YAAY,IAAI,CAAC;EACrE,KAAK;CACP;AACF;AAEA,qBAAqB,UAAU;;;;;;;;;;;;;;;;;;ACxH/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;;;;;;;;;;;;;;;;;;;;;;;;;;;AC5C9B,IAAI,eAAe;;;;;;;;AASnB,SAASC,YAAkB;CACzB,gBAAgB;CAChB,OAAO,QAAQ;AACjB;;;;;;;;;AAUA,SAAS,WACP,OACA,SACiD;CACjD,IAAI,UAAU,KAAA,GAAW,OAAO,KAAA;CAChC,IAAI,OAAO,UAAU,YAAY,OAAO;CACxC,OAAO,KAAK,GAAG,QAAQ,SAAS,OAAO,WAAkB;EACvD,MAAM,MAAM,MAAM,KAAK;EACvB;CACF,EAAE;AACJ;;;;;;;;;;AAWA,SAAgB,KAAkB,QAA6C;CAC7E,MAAM,EAAE,MAAM,MAAM,QAAQ,SAAS;CACrC,MAAM,eAAe,KAAK,IAAI,GAAG,KAAK,MAAM,OAAO,UAAU,CAAC;CAC9D,MAAM,KAAKA,UAAQ;CACnB,MAAM,QAAQ,WAAW,OAAO,OAAO,EAAE;CAEzC,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,UAPuC,QACrC,CAAC,MAAM,KAAK,IACZ,CAAC,IAAI;EAMP,QAAQ;EACR,KAAK;CACP;AACF;AAEA,qBAAqB,MAAM;;;;;;;;;;;;;;;;;;;;;AC/G3B,IAAI,kBAAkB;;;;AAKtB,SAASC,YAAkB;CACzB,mBAAmB;CACnB,OAAO,WAAW;AACpB;;;;;;;;AASA,SAAgB,QAAc,OAAmB,QAAmC;CAClF,MAAM,OAAO,QAAQ;CACrB,IAAI,OAAO,SAAS,YAAY,KAAK,WAAW,GAC9C,MAAM,IAAI,UAAU,2DAA2D;CAEjF,MAAM,KAAKA,UAAQ;CAEnB,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;;;;;;;;;;;;;;;;;ACtC9B,IAAI,qBAAqB;;;;AAKzB,SAAS,UAAkB;CACzB,sBAAsB;CACtB,OAAO,cAAc;AACvB;;;;;;;;;;AAWA,SAAgB,WAAiB,OAAmB,QAAyC;CAC3F,IAAI,MAAM,cAAc,MACtB,MAAM,IAAI,MACR,iGACF;CAGF,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;GAKV,MAAM,cAAuC;IAAE;IAAI;GAAI;GACvD,IAAI,IAAI,mBAAmB,KAAA,GAAW,YAAY,aAAa,IAAI;GACnE,IAAI;IACF,SAAS,MAAM,MAAM,IAAI,GAAG;IAC5B,MAAM,WAAW,QAAQ,WAAW,KAAA;IACpC,IAAI,WAAW,OAAO;KACpB,MAAM;KACN,QAAQ,MAAM,QAAQ;KACtB,GAAG;IACL,CAAC;GACH,SAAS,KAAK;IACZ,MAAM;IACN,IAAI,WAAW,OAAO;KACpB,MAAM;KACN,QAAQ;KACR,OAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;KACtD,GAAG;IACL,CAAC;GACH;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;;;;;;;;;;;AC7FjC,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;;;;;;;;;;;;;;;;;;;;;;;;ACrBA,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;GAMtB,IAAI,WAAW,OAAO;IAAE,MAAM;IAAa;IAAY,SAAS;GAAW,CAAC;GAC5E,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;;;;;;;;;;;;;;;;AC/D9B,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;GAI1B,MAAM,MAAM,cAAc,OAAO,KAAc,SAAS;EAC1D;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACnK1B,IAAI,gBAAgB;;;;AAKpB,SAAS,gBAAwB;CAC/B,iBAAiB;CACjB,OAAO,SAAS;AAClB;;;;;;;;;;;;;;;AAkFA,SAAS,YACP,YACA,SACA,aACwB;CACxB,MAAM,KAAK,cAAc;CACzB,MAAM,OAAO,CACX,GAAG,QAAQ,KAAK,MAAO,EAAE,SAAS,UAAU,SAAS,EAAE,SAAS,EAAE,IAAK,GACvE,QACF;CACA,MAAM,WAAW,CACf,GAAG,QAAQ,SAAS,MAAO,EAAE,SAAS,SAAS,CAAC,EAAE,IAAI,IAAI,CAAC,CAAE,GAC7D,WACF;CAEA,MAAM,SAAS,OAAO,OAAgB,QAAsC;EAC1E,IAAI,SAAkC,GAAG,aAAa,MAAM;EAC5D,IAAI,cAAc;EAClB,IAAI;EACJ,IAAI;EAEJ,MAAM,aAAa,UAAyB;GAC1C,IAAI,eAAe,KAAA,GAAW;GAC9B,MAAM,OAAgC,EAAE,IAAI,SAAS;GACrD,IAAI,UAAU,KAAA,GAAW,KAAK,WAAW;GACzC,IAAI,WAAW,SAAS,YAAY,IAAI;GACxC,aAAa,KAAA;EACf;EAEA,IAAI;GACF,KAAK,MAAM,SAAS,SAAS;IAC3B,iBAAiB,WAAW;IAC5B,IAAI,MAAM,SAAS,SAAS;KAC1B,UAAU;KACV,WAAW,SAAS,MAAM;KAC1B,MAAM,OAAgC,EAAE,IAAI,SAAS;KACrD,IAAI,IAAI,mBAAmB,KAAA,GAAW,KAAK,oBAAoB,IAAI;KACnE,aAAa,IAAI,WAAW,WAAW,MAAM,MAAM,IAAI;KACvD,cAAc;MAAE,GAAG;MAAK,gBAAgB;KAAW;KACnD,IAAI,MAAM,YAAY,KAAA,GAIpB,SAAU,MAAM,MAAM,QAAQ,QAAQ,WAAW;IAErD,OAAO;KACL,MAAM,QAAQ,MAAM,cAAc,MAAM,MAAM,QAAQ,WAAW;KACjE,SAAS;MAAE,GAAG;OAAS,MAAM,OAAO;KAAM;IAC5C;GACF;GACA,iBAAiB,WAAW;GAC5B,MAAM,MAAM,MAAM,cAAc,aAAa,QAAQ,WAAW;GAChE,UAAU;GACV,OAAO;EACT,SAAS,KAAK;GACZ,UAAU,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG,CAAC;GAC1D,MAAM;EACR;CACF;CAEA,OAAO;EACL;EACA,MAAM;EACN;EACA,QAAQ;GAAE,OAAO;GAAY;EAAK;EAClC,KAAK;CACP;AACF;;;;;;;;AASA,SAAS,aAAa,SAA4D;CAChF,OAAO,SAAS,SAAS,KAAA,IAAY,CAAC,IAAI,CAAC,EAAE,MAAM,QAAQ,KAAK,CAAC;AACnE;;;;;;;;;AAUA,SAAS,SACP,MACA,KACA,QACA,SACwC;CACxC,IAAI,OAAO,WAAW,YACpB,MAAM,IAAI,UAAU,0DAA0D;CAWhF,OAAO;EAAE,GATI,KACX,OACC,GAA4B,QAI3B,IAAI,KAAK,KAAK,OAAO,CAAC,CAAU,GAClC,GAAG,aAAa,OAAO,CAEV;EAAG,UAAU,CAAC,GAAG;CAAE;AACpC;;;;AAKA,SAAS,UACP,MACA,IACA,SACwC;CACxC,MAAM,WAAW,OAAO,YAAY,aAAa,KAAA,IAAY;CAC7D,MAAM,OAAO,KAAK,MAAM,IAAI,GAAG,aAAa,QAAQ,CAAC;CACrD,MAAM,MAAM,UAAU;CAGtB,OAAO,QAAQ,KAAA,IAAY,OAAO;EAAE,GAAG;EAAM,UAAU,CAAC,GAAG;CAAE;AAC/D;;;;;;;;;AAUA,SAAS,WACP,YACA,SACA,OACY;CACZ,OAAO;EACL,OAAO,MAAM,WAAW,mBAAmB,gBAAgB;GACzD,qBACE,MACA,4BACA,iDACF;GACA,IAAI,MAAM,IAAI,IAAI,GAChB,MAAM,IAAI,UACR,wBAAwB,KAAK,gEAC/B;GAEF,MAAM,OAAO,QAAQ,SAAS,IAC1B,SAAS,MAAM,WAAW,mBAAmB,WAAW,IACxD,UAAU,MAAM,WAAW,iBAAiB;GAChD,OAAO,WACL,YACA,CAAC,GAAG,SAAS;IAAE,MAAM;IAAQ;IAAM;GAAK,CAAC,mBACzC,IAAI,IAAI,CAAC,GAAG,OAAO,IAAI,CAAC,CAC1B;EACF;EACA,QAAQ,MAAM,YACZ,WACE,YACA,CACE,GAAG,SACH,YAAY,KAAA,IAAY;GAAE,MAAM;GAAS;EAAK,IAAI;GAAE,MAAM;GAAS;GAAM;EAAQ,CACnF,GACA,YAAY,KAAA,IAAY,wBAAQ,IAAI,IAAI,CAC1C;EACF,SAAS,OAAO,YAAY,YAAY,SAAS,KAAK,UAAU,EAAE,CAAC;CACrE;AACF;;;;;;;;;;;;;AAcA,SAAgB,MACd,YAC2C;CAC3C,MAAM,OAAO,cAAc;CAC3B,qBAAqB,MAAM,qBAAqB,oBAAoB;CACpE,MAAM,OAAO,WAAW,MAAM,CAAC,mBAAG,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC;CAIjD,OAAO;EAAE,GAAG;EAAM,aAAa;CAAK;AACtC;AAEA,qBAAqB,OAAO"}
|