effect-mq 0.5.0 → 0.6.0

package/README.md

@@ -51,7 +51,7 @@ const producer = Effect.gen(function*() {
 // 3. Run. Workers are layers — deploy them in the same process or across
 //    machines against shared storage.
 const RunnerLive = SendEmail.toLayer(
-  (payload, ctx) => Effect.succeed(`message-${ctx.jobId}`),
+  (payload) => Effect.map(Worker.CurrentJob, ({ jobId }) => `message-${jobId}`),
   { concurrency: 5 }
 ).pipe(
   Layer.provideMerge(Worker.layer()),
@@ -144,6 +144,49 @@ occurrences, missed slots collapse into one run (the next sweep enqueues the
 overdue slot once, then advances past `now`). Options mirror `enqueue`:
 `metadata`, `priority`, `attempts`, `backoff`, `keep`, `timeout`.
 
+## Parent-child flows
+
+A flow fans a parent job out into N children, parks the parent until every
+child settles, then resumes it with their typed results. Children can live
+on a **different store** than the parent (a cron parent in Postgres fanning
+out 10k idempotent sends into Redis, collecting the outcomes back):
+
+```ts
+import { Flow } from "effect-mq"
+
+const DigestFlow = Flow.make("daily-digest", {
+  parent: SendDigest,            // Postgres
+  children: [SendEmail],         // Redis
+  onChildFailure: "continue"     // or "fail": first failure settles the flow
+})
+
+// The parent worker runs two phases (requires parent AND child stores):
+const DigestWorker = DigestFlow.toLayer({
+  fanOut: (payload) =>
+    Effect.map(Users.active, (users) =>
+      Flow.children(SendEmail, users.map((user) => ({
+        key: user.id,                       // unique in the flow = idempotency
+        payload: { userId: user.id }
+      })))),
+  collect: (payload, results) =>
+    Effect.succeed({ sent: results.counts.completed, failed: results.counts.failed })
+})
+
+// Workers that run the children declare the flow so their relay can push
+// results to the parent store the moment each child acks:
+Worker.layer({ store: EmailStore, flows: [DigestFlow] })
+```
+
+The parent's store owns the flow (manifest, per-child results, outcome
+counters), so "settle exactly once" is single-store atomic. Cross-store,
+every terminal child transition appends its report to the child store's
+**outbox** in the same atomic operation; worker relays push those in
+batches (children keep completing through parent-store outages) and a
+reconciliation sweeper repairs anything the push path misses, from storage
+alone. Flows nest (a child can be another flow's parent), and `collect`
+reads results as plain `counts`, materialized buckets, or a paged `Stream`.
+Docs: [Parent-child flows](https://www.effect-mq.com/guide/flows).
+
 ## Timeouts, cancellation, and unrecoverable errors
 
 Because handlers are Effect fibers, the runtime can *actually stop them* —
@@ -357,16 +400,26 @@ migrations** — no library-run DDL, no parallel migration system:
 
 ```ts
 // db/schema.ts
-import { mqDedupe, mqJobAttempts, mqJobs, mqQueueControl, mqSchedules } from "effect-mq/drizzle-postgres"
+import {
+  mqDedupe,
+  mqFlowChildren,
+  mqFlowOutbox,
+  mqJobAttempts,
+  mqJobs,
+  mqQueueControl,
+  mqSchedules
+} from "effect-mq/drizzle-postgres"
 
 // The `name` column is typed to your job tags (derived, not hand-written):
 type JobNames = typeof GenerateInvoice._tag | typeof SendEmail._tag
 
-export const jobs = mqJobs<JobNames>()          // default table: effect_mq_jobs
-export const jobAttempts = mqJobAttempts(jobs)  // default: effect_mq_job_attempts
-export const jobSchedules = mqSchedules()       // default: effect_mq_schedules
-export const jobQueues = mqQueueControl()       // default: effect_mq_queue_control
-export const jobDedupe = mqDedupe()             // default: effect_mq_dedupe
+export const jobs = mqJobs<JobNames>()            // default table: effect_mq_jobs
+export const jobAttempts = mqJobAttempts(jobs)    // default: effect_mq_job_attempts
+export const jobSchedules = mqSchedules()         // default: effect_mq_schedules
+export const jobQueues = mqQueueControl()         // default: effect_mq_queue_control
+export const jobDedupe = mqDedupe()               // default: effect_mq_dedupe
+export const jobFlowChildren = mqFlowChildren()   // default: effect_mq_flow_children
+export const jobFlowOutbox = mqFlowOutbox()       // default: effect_mq_flow_outbox
 ```
 
 Need more indexes (the built-ins cover claiming, listing, metadata
@@ -390,7 +443,7 @@ table; at enqueue the store fills each extended column from the job's
 `metadata: (payload) => ...` is your creation-time hook), NULL when absent:
 
 ```ts
-class SyncBenefits extends Job.make("sync-benefits", {
+class SyncPayments extends Job.make("sync-payments", {
   payload: { companyId: Schema.String, objectId: Schema.String },
   metadata: ({ companyId, objectId }) => ({ companyId, objectId })
 }) {}
@@ -427,14 +480,24 @@ When a future effect-mq version changes the layout, the factory changes and
 import { DrizzleJobStore } from "effect-mq/drizzle-postgres"
 import { PgClient } from "@effect/sql-pg"
 import { Layer, Redacted } from "effect"
-import { jobAttempts, jobDedupe, jobQueues, jobs, jobSchedules } from "./db/schema.ts"
+import {
+  jobAttempts,
+  jobDedupe,
+  jobFlowChildren,
+  jobFlowOutbox,
+  jobQueues,
+  jobs,
+  jobSchedules
+} from "./db/schema.ts"
 
 const JobStoreLive = DrizzleJobStore.layer({
   jobs,
   attempts: jobAttempts,
   schedules: jobSchedules,
   queues: jobQueues,
-  dedupe: jobDedupe
+  dedupe: jobDedupe,
+  flowChildren: jobFlowChildren,
+  flowOutbox: jobFlowOutbox
 }).pipe(
   Layer.provide(PgClient.layer({ url: Redacted.make(process.env.DATABASE_URL!) }))
 )
@@ -593,6 +656,9 @@ ledger), `retry`, `cancel`, `cancelByKey` (by dedup key, idempotent),
 | `queueMetricsInterval` | off | sample `store.counts()` per queue into the depth gauge |
 | `handlerSpanName` | `` `${name}.run` `` | name of the span wrapping each handler run |
 | `traceLinking` | `auto` | parent for immediate jobs, causal link for delayed ones (`parent`/`link`/`none` force a mode) |
+| `onJobFailure` | — | callback after each failed run is acked; runs isolated |
+| `flows` | — | flows whose children this worker runs (lets its relay push results) |
+| `flowSweepInterval` | 30s | flow sweeper cadence + the relay's fallback drain cadence |
 | `id` | random | identifier used in lock tokens |
 
 **Store construction** — every driver accepts `idGenerator`, `historyTtl`,
@@ -629,12 +695,14 @@ plain Effect, so it works with any test runner.
 
 ## Writing a storage driver
 
-Implement the `JobStore` service (one atomic seam: `enqueue`, `claim`, `ack`,
-`release`, `extendLocks`, `recoverStalled`, `awaitWake`, `getJob`,
-`getAttempts`, `list`, `retry`, `counts`, `remove`, `cancel`, `promote`,
-`pause`/`resume`/`pausedQueues`, `cancelByDedupe`, and the schedule ops
-`upsertSchedule`/`removeSchedule`/`listSchedules`/`dueSchedules`/`advanceSchedule`)
-and run the conformance suite against it:
+Implement the `JobStore` service (one atomic seam: `enqueue`/`enqueueMany`,
+`claim`, `ack`, `release`, `extendLocks`, `recoverStalled`, `awaitWake`,
+`getJob`, `getAttempts`, `list`, `retry`, `counts`, `remove`, `cancel`,
+`promote`, `pause`/`resume`/`pausedQueues`, `cancelByDedupe`, the schedule
+ops `upsertSchedule`/`removeSchedule`/`listSchedules`/`dueSchedules`/
+`tickSchedule`/`advanceSchedule`, and the flow ops `recordChildResults`/
+`listChildResults`/`flowSweepWork`/`markChildrenCascaded`/`peekOutbox`/
+`deleteOutbox`) and run the conformance suite against it:
 
 ```ts
 import { jobStoreConformance } from "effect-mq/testing"
@@ -652,7 +720,7 @@ suite in this repo runs the same conformance tests against a real database.
 
 Next up: drizzle schema customization (column renames, native id and
 timestamp column types, a typed queue registry), a cross-process event
-stream, and parent-child fan-out. Full prioritized list:
+stream, and global queue concurrency/rate limits. Full prioritized list:
 [ROADMAP.md](https://github.com/TeamWarp/effect-mq/blob/main/ROADMAP.md);
 release history:
 [CHANGELOG.md](https://github.com/TeamWarp/effect-mq/blob/main/CHANGELOG.md).

package/dist/Flow.d.ts

@@ -0,0 +1,381 @@
+/**
+ * Cross-store parent-child flows.
+ *
+ * A flow's PARENT job fans out N child jobs, parks in `waiting-children`
+ * until every child settles, then resumes with their typed results. The
+ * children may live on a **different store** than the parent — a
+ * cron-scheduled parent in Postgres can fan out thousands of idempotent
+ * sends into Redis and collect the outcomes back in Postgres.
+ *
+ * ```ts
+ * const DigestFlow = Flow.make("daily-digest", {
+ *   parent: SendDigest,          // a Job bound to the Postgres store
+ *   children: [SendEmail],       // Jobs, each bound to their own store
+ *   onChildFailure: "continue"   // default; "fail" settles on first failure
+ * })
+ *
+ * // the parent worker runs both phases (requires the parent AND child stores)
+ * const DigestWorker = DigestFlow.toLayer({
+ *   fanOut: (payload) =>
+ *     Effect.gen(function*() {
+ *       const users = yield* Users.active
+ *       return Flow.children(SendEmail, users.map((user) => ({
+ *         key: user.id,
+ *         payload: { userId: user.id }
+ *       })))
+ *     }),
+ *   collect: (payload, results) =>
+ *     Effect.succeed({ sent: results.counts.completed, failed: results.counts.failed })
+ *     // or: yield* results.all (materialized buckets), results.stream (paged)
+ * })
+ *
+ * // workers that run the CHILDREN list the flow so results push instantly:
+ * // Worker.layer({ store: EmailStore, flows: [DigestFlow] })
+ * ```
+ *
+ * Architecture (see `designs/parent-child-flows.md`): the parent's store
+ * owns the flow — child manifest, per-child results, outcome counters — so
+ * "the flow settles exactly once" is single-store atomic. Cross-store needs
+ * only two at-least-once idempotent mechanisms: every terminal child
+ * transition atomically appends its report to the CHILD store's outbox,
+ * which worker relays *push* into the parent store in batches (children
+ * keep completing even while the parent store is down); and the parent
+ * worker's flow sweeper *reconciles* from child-store state (repairs
+ * everything the push path can miss: crashes mid-enqueue, dropped outbox
+ * entries, children terminal on stores no relay reaches).
+ *
+ * Flows nest: a child may itself be another flow's parent, reporting upward
+ * through the same machinery when it settles. Depth is capped (8) so a
+ * cyclic definition surfaces as an unrecoverable failure instead of an
+ * unbounded chain.
+ *
+ * Flow children bypass the child definition's `idempotencyKey`/`dedupe` —
+ * the child `key` (unique within the flow) IS the idempotency mechanism,
+ * carried in the deterministic job id. Handlers should be idempotent, as
+ * everywhere under at-least-once.
+ *
+ * @since 0.6.0
+ */
+import { Cause, Context, Effect, Layer, Schema, Stream } from "effect";
+import { type AnyStructSchema, type JobOptions, type ResolvedDefaults } from "./Job.ts";
+import { JobId, type QueueName, type Service as StoreService } from "./JobStore.ts";
+import { type CurrentJob, type RegisterOptions, Worker } from "./Worker.ts";
+/**
+ * The structural view of a `Job.make` class a flow needs from its members.
+ * Contravariant callback members are typed with `never` parameters so every
+ * concrete job satisfies the constraint; the runtime only ever passes a
+ * job's own payload back into them.
+ *
+ * @since 0.6.0
+ */
+export interface MemberJob {
+    readonly _tag: string;
+    readonly queue: QueueName;
+    readonly store: Context.Key<any, StoreService>;
+    readonly payloadSchema: AnyStructSchema;
+    readonly payloadJsonSchema: Schema.Top;
+    readonly successSchema: Schema.Top;
+    readonly errorSchema: Schema.Top;
+    readonly exitSchema: Schema.Top;
+    readonly defaults: ResolvedDefaults;
+    readonly metadata: ((payload: never) => Readonly<Record<string, string>>) | undefined;
+    readonly retryable: ((error: never) => boolean) | undefined;
+}
+/**
+ * The structural view of the parent job: a `MemberJob` plus the producer
+ * surface the flow delegates (`Flow.enqueue` IS the parent's `enqueue`).
+ *
+ * @since 0.6.0
+ */
+export interface ParentJob extends MemberJob {
+    readonly enqueue: (...args: ReadonlyArray<never>) => Effect.Effect<any, any, any>;
+    readonly enqueueMany: (...args: ReadonlyArray<never>) => Effect.Effect<any, any, any>;
+    readonly execute: (...args: ReadonlyArray<never>) => Effect.Effect<any, any, any>;
+    readonly poll: (...args: ReadonlyArray<never>) => Effect.Effect<any, any, any>;
+    readonly attempts: (...args: ReadonlyArray<never>) => Effect.Effect<any, any, any>;
+    readonly awaitResult: (...args: ReadonlyArray<never>) => Effect.Effect<any, any, any>;
+    readonly retry: (...args: ReadonlyArray<never>) => Effect.Effect<any, any, any>;
+    readonly cancel: (...args: ReadonlyArray<never>) => Effect.Effect<any, any, any>;
+    readonly promote: (...args: ReadonlyArray<never>) => Effect.Effect<any, any, any>;
+    readonly schedule: (...args: ReadonlyArray<never>) => Effect.Effect<any, any, any>;
+    readonly unschedule: (...args: ReadonlyArray<never>) => Effect.Effect<any, any, any>;
+}
+type NameOf<J> = J extends {
+    readonly _tag: infer N extends string;
+} ? N : never;
+type PayloadMakeIn<J> = J extends {
+    readonly payloadSchema: infer P extends AnyStructSchema;
+} ? P["~type.make.in"] : never;
+type PayloadType<J> = J extends {
+    readonly payloadSchema: infer P extends AnyStructSchema;
+} ? P["Type"] : never;
+type PayloadEncodingServices<J> = J extends {
+    readonly payloadSchema: infer P extends AnyStructSchema;
+} ? P["EncodingServices"] : never;
+type SuccessValue<J> = J extends {
+    readonly successSchema: infer S extends Schema.Top;
+} ? S["Type"] : never;
+type SuccessDecodingServices<J> = J extends {
+    readonly successSchema: infer S extends Schema.Top;
+} ? S["DecodingServices"] : never;
+type SuccessEncodingServices<J> = J extends {
+    readonly successSchema: infer S extends Schema.Top;
+} ? S["EncodingServices"] : never;
+type ErrorValue<J> = J extends {
+    readonly errorSchema: infer E extends Schema.Top;
+} ? E["Type"] : never;
+type ErrorDecodingServices<J> = J extends {
+    readonly errorSchema: infer E extends Schema.Top;
+} ? E["DecodingServices"] : never;
+type ErrorEncodingServices<J> = J extends {
+    readonly errorSchema: infer E extends Schema.Top;
+} ? E["EncodingServices"] : never;
+type PayloadDecodingServices<J> = J extends {
+    readonly payloadSchema: infer P extends AnyStructSchema;
+} ? P["DecodingServices"] : never;
+/**
+ * The StoreIds of a flow's members — what `toLayer` requires so the parent
+ * worker is guaranteed able to reconcile and cascade into every child store.
+ *
+ * @since 0.6.0
+ */
+export type MemberStores<J> = J extends {
+    readonly store: Context.Key<infer Id, StoreService>;
+} ? Id : never;
+/**
+ * Per-child options accepted by `Flow.children` items — the shared
+ * `JobOptions` minus `delay` (flow children run immediately), plus
+ * `metadata` merged over the child definition's callback.
+ *
+ * @since 0.6.0
+ */
+export type ChildOptions = Omit<JobOptions, "delay"> & {
+    readonly metadata?: Readonly<Record<string, string>> | undefined;
+};
+/**
+ * One child to fan out: its flow-unique `key` (the idempotency mechanism —
+ * re-runs of `fanOut` re-produce the same child, never a second one), the
+ * payload, and optional per-child options.
+ *
+ * @since 0.6.0
+ */
+export interface ChildItem<PayloadInput> {
+    readonly key: string;
+    readonly payload: PayloadInput;
+    readonly options?: ChildOptions | undefined;
+}
+/**
+ * A group of children of one member type, built by `Flow.children`. A
+ * `fanOut` handler returns one group or an array of them.
+ *
+ * @since 0.6.0
+ */
+export interface ChildGroup<out J extends MemberJob = MemberJob> {
+    readonly job: J;
+    readonly items: ReadonlyArray<ChildItem<PayloadMakeIn<J>>>;
+}
+/**
+ * A naked-parameter distribution of `ChildGroup` over a union of members,
+ * so a group literal must pair a member's `job` with THAT member's payloads
+ * (the undistributed `ChildGroup<A | B>` would accept `A`'s job with `B`'s
+ * items).
+ *
+ * @since 0.6.0
+ */
+export type GroupsOf<J> = J extends MemberJob ? ChildGroup<J> : never;
+/**
+ * What `fanOut` returns: children of any of the flow's member types.
+ *
+ * @since 0.6.0
+ */
+export type ChildrenInput<J extends MemberJob> = GroupsOf<J> | ReadonlyArray<GroupsOf<J>>;
+/**
+ * The deterministic id of a flow child. Every component is an arbitrary
+ * string (store keys, ids, and child keys may all contain "/"), so the two
+ * variable-length boundaries are pinned by a length prefix — distinct
+ * (storeKey, flowId, childKey) triples can never alias.
+ *
+ * @internal
+ */
+export declare const childJobId: (parentStoreKey: string, flowId: string, childKey: string) => string;
+/**
+ * Declare children of one member type. Payloads are validated through the
+ * child's schema when the specs are built; duplicate keys (across ALL
+ * groups) fail the fan-out unrecoverably.
+ *
+ * @since 0.6.0
+ */
+export declare const children: <J extends MemberJob>(job: J, items: ReadonlyArray<ChildItem<PayloadMakeIn<J>>>) => ChildGroup<J>;
+/**
+ * A child that completed, with its decoded success value.
+ *
+ * @since 0.6.0
+ */
+export interface CompletedChild<Name extends string, A> {
+    readonly key: string;
+    readonly name: Name;
+    readonly value: A;
+}
+/**
+ * A child that failed terminally. `cause` carries the decoded typed failure
+ * — or a die for store-side failures that never produced an exit (stall
+ * exhaustion, a nested parent's fail-fast settle).
+ *
+ * @since 0.6.0
+ */
+export interface FailedChild<Name extends string, E> {
+    readonly key: string;
+    readonly name: Name;
+    readonly cause: Cause.Cause<E>;
+}
+/**
+ * A child that was cancelled — directly in its store, or by a flow settle
+ * (fail-fast, or a cancel of the waiting parent).
+ *
+ * @since 0.6.0
+ */
+export interface CancelledChild<Name extends string> {
+    readonly key: string;
+    readonly name: Name;
+}
+type CompletedOf<J> = J extends MemberJob ? CompletedChild<NameOf<J>, SuccessValue<J>> : never;
+type FailedOf<J> = J extends MemberJob ? FailedChild<NameOf<J>, ErrorValue<J>> : never;
+type CancelledOf<J> = J extends MemberJob ? CancelledChild<NameOf<J>> : never;
+/**
+ * Per-outcome tallies, read straight off the parent's persisted `FlowState`
+ * — no dependency-row reads. When `collect` runs, `pending` is 0.
+ *
+ * @since 0.6.0
+ */
+export interface ChildCounts {
+    readonly pending: number;
+    readonly completed: number;
+    readonly failed: number;
+    readonly cancelled: number;
+}
+/**
+ * One settled child, discriminated by `outcome` (and by `name` across
+ * member types), decoded through its member's schemas.
+ *
+ * @since 0.6.0
+ */
+export type SettledChild<J extends MemberJob> = ({
+    readonly outcome: "completed";
+} & CompletedOf<J>) | ({
+    readonly outcome: "failed";
+} & FailedOf<J>) | ({
+    readonly outcome: "cancelled";
+} & CancelledOf<J>);
+/**
+ * Every settled child, materialized into outcome buckets.
+ *
+ * @since 0.6.0
+ */
+export interface SettledChildren<J extends MemberJob> {
+    readonly completed: ReadonlyArray<Extract<SettledChild<J>, {
+        readonly outcome: "completed";
+    }>>;
+    readonly failed: ReadonlyArray<Extract<SettledChild<J>, {
+        readonly outcome: "failed";
+    }>>;
+    readonly cancelled: ReadonlyArray<Extract<SettledChild<J>, {
+        readonly outcome: "cancelled";
+    }>>;
+}
+/**
+ * What `collect` (and `Flow.childResults`) receives: `counts` for free,
+ * `all` to materialize the outcome buckets (one array — fine into the
+ * tens of thousands), and `stream` to fold huge flows one page at a time.
+ *
+ * @since 0.6.0
+ */
+export interface ChildResults<J extends MemberJob> {
+    readonly counts: ChildCounts;
+    readonly all: Effect.Effect<SettledChildren<J>>;
+    readonly stream: Stream.Stream<SettledChild<J>>;
+}
+/**
+ * The two-phase flow handler. `fanOut` runs once per flow (persisted phase
+ * dispatch — a resumed parent can never fan out twice) and returns the
+ * children; `collect` runs after every child settled, with their results.
+ * Both draw on the PARENT's attempt budget: a failing `fanOut` retries
+ * against it until the manifest lands, a failing `collect` retries with
+ * what remains.
+ *
+ * @since 0.6.0
+ */
+export interface FlowHandlers<Parent extends ParentJob, Children extends ReadonlyArray<MemberJob>, R1, R2> {
+    readonly fanOut: (payload: PayloadType<Parent>) => Effect.Effect<ChildrenInput<Children[number]>, ErrorValue<Parent>, R1>;
+    readonly collect: (payload: PayloadType<Parent>, results: ChildResults<Children[number]>) => Effect.Effect<SuccessValue<Parent>, ErrorValue<Parent>, R2>;
+}
+/**
+ * A flow definition. The producer surface (`enqueue`, `execute`, `poll`,
+ * `awaitResult`, `schedule`, ...) IS the parent job's — a flow parent is a
+ * real job row in the parent store, and a scheduled parent needs no flow
+ * awareness in its schedule row.
+ *
+ * Note on fail-fast (`onChildFailure: "fail"`): the first failed child
+ * settles the parent terminally `failed` store-side (`failedReason` names
+ * the child; there is no parent exit, so `awaitResult` dies — like stall
+ * exhaustion) and the remaining children are cancelled. The failed child's
+ * own exit stays inspectable via `childResults`. An admin `retry` of the
+ * parent re-enters `collect` with the mixed results.
+ *
+ * @since 0.6.0
+ */
+export interface Flow<Name extends string, Parent extends ParentJob, Children extends ReadonlyArray<MemberJob>> {
+    readonly name: Name;
+    readonly parent: Parent;
+    readonly children: Children;
+    /** True when `onChildFailure` is `"fail"`. */
+    readonly failFast: boolean;
+    readonly enqueue: Parent["enqueue"];
+    readonly enqueueMany: Parent["enqueueMany"];
+    readonly execute: Parent["execute"];
+    readonly poll: Parent["poll"];
+    readonly attempts: Parent["attempts"];
+    readonly awaitResult: Parent["awaitResult"];
+    readonly retry: Parent["retry"];
+    readonly cancel: Parent["cancel"];
+    readonly promote: Parent["promote"];
+    readonly schedule: Parent["schedule"];
+    readonly unschedule: Parent["unschedule"];
+    /**
+     * The flow's recorded child results, in any parent state: live `counts`
+     * plus the `all`/`stream` accessors — children still pending are absent
+     * from both.
+     */
+    readonly childResults: (flowId: JobId) => Effect.Effect<ChildResults<Children[number]>, never, MemberStores<Parent> | SuccessDecodingServices<Children[number]> | ErrorDecodingServices<Children[number]>>;
+    /**
+     * Register the parent's two phases on a worker (bound to the parent's
+     * store). Requires every member store — this is what makes the parent
+     * worker the one process guaranteed capable of reconciling and cascading
+     * across the whole flow.
+     */
+    readonly toLayer: <R1, R2>(handlers: FlowHandlers<Parent, Children, R1, R2>, options?: RegisterOptions | undefined) => Layer.Layer<never, never, Worker | Exclude<R1, CurrentJob> | Exclude<R2, CurrentJob> | MemberStores<Parent> | MemberStores<Children[number]> | PayloadDecodingServices<Parent> | SuccessEncodingServices<Parent> | ErrorEncodingServices<Parent> | PayloadEncodingServices<Children[number]> | SuccessDecodingServices<Children[number]> | ErrorDecodingServices<Children[number]>>;
+}
+/**
+ * Define a flow over existing job definitions.
+ *
+ * Throws (synchronously, at definition time) on duplicate child names or a
+ * parent listed among its own children (direct self-recursion). Nesting
+ * across DIFFERENT flows is supported — see the module docs.
+ *
+ * @since 0.6.0
+ */
+export declare const make: <const Name extends string, Parent extends ParentJob, const Children extends ReadonlyArray<MemberJob>>(name: Name, options: {
+    /** The parent job: its store owns the flow. */
+    readonly parent: Parent;
+    /** The closed set of member definitions `fanOut` may produce. */
+    readonly children: Children;
+    /**
+     * What a failed child does to the flow:
+     * - `"continue"` (default): every child settles; `collect` sees the
+     *   failures in `results.failed`.
+     * - `"fail"`: the first failed child settles the parent as `failed`
+     *   and cancels the remaining children (see the `Flow` docs).
+     */
+    readonly onChildFailure?: "continue" | "fail" | undefined;
+}) => Flow<Name, Parent, Children>;
+export {};
+//# sourceMappingURL=Flow.d.ts.map

package/dist/Flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Flow.d.ts","sourceRoot":"","sources":["../src/Flow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,OAAO,EAAE,KAAK,EAAE,OAAO,EAAY,MAAM,EAAQ,KAAK,EAAU,MAAM,EAAmB,MAAM,EAAU,MAAM,QAAQ,CAAA;AACvH,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,UAAU,EAGf,KAAK,gBAAgB,EACtB,MAAM,UAAU,CAAA;AACjB,OAAO,EAIL,KAAK,EACL,KAAK,SAAS,EACd,KAAK,OAAO,IAAI,YAAY,EAE7B,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,KAAK,UAAU,EAAwC,KAAK,eAAe,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAEjH;;;;;;;GAOG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;IACzB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,YAAY,CAAC,CAAA;IAC9C,QAAQ,CAAC,aAAa,EAAE,eAAe,CAAA;IACvC,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC,GAAG,CAAA;IACtC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC,GAAG,CAAA;IAClC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,GAAG,CAAA;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,GAAG,CAAA;IAC/B,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAA;IACnC,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC,OAAO,EAAE,KAAK,KAAK,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,SAAS,CAAA;IACrF,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,GAAG,SAAS,CAAA;CAC5D;AAED;;;;;GAKG;AACH,MAAM,WAAW,SAAU,SAAQ,SAAS;IAC1C,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;IACjF,QAAQ,CAAC,WAAW,EAAE,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;IACrF,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;IACjF,QAAQ,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;IAC9E,QAAQ,CAAC,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;IAClF,QAAQ,CAAC,WAAW,EAAE,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;IACrF,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;IAC/E,QAAQ,CAAC,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;IAChF,QAAQ,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;IACjF,QAAQ,CAAC,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;IAClF,QAAQ,CAAC,UAAU,EAAE,CAAC,GAAG,IAAI,EAAE,aAAa,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAA;CACrF;AAID,KAAK,MAAM,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,SAAS,MAAM,CAAA;CAAE,GAAG,CAAC,GAAG,KAAK,CAAA;AAChF,KAAK,aAAa,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC,SAAS,eAAe,CAAA;CAAE,GAAG,CAAC,CAAC,eAAe,CAAC,GAC9G,KAAK,CAAA;AACT,KAAK,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC,SAAS,eAAe,CAAA;CAAE,GAAG,CAAC,CAAC,MAAM,CAAC,GAAG,KAAK,CAAA;AAC/G,KAAK,uBAAuB,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC,SAAS,eAAe,CAAA;CAAE,GACnG,CAAC,CAAC,kBAAkB,CAAC,GACrB,KAAK,CAAA;AACT,KAAK,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC,SAAS,MAAM,CAAC,GAAG,CAAA;CAAE,GAAG,CAAC,CAAC,MAAM,CAAC,GAAG,KAAK,CAAA;AAC3G,KAAK,uBAAuB,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC,SAAS,MAAM,CAAC,GAAG,CAAA;CAAE,GAC9F,CAAC,CAAC,kBAAkB,CAAC,GACrB,KAAK,CAAA;AACT,KAAK,uBAAuB,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC,SAAS,MAAM,CAAC,GAAG,CAAA;CAAE,GAC9F,CAAC,CAAC,kBAAkB,CAAC,GACrB,KAAK,CAAA;AACT,KAAK,UAAU,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,SAAS,MAAM,CAAC,GAAG,CAAA;CAAE,GAAG,CAAC,CAAC,MAAM,CAAC,GAAG,KAAK,CAAA;AACvG,KAAK,qBAAqB,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,SAAS,MAAM,CAAC,GAAG,CAAA;CAAE,GAC1F,CAAC,CAAC,kBAAkB,CAAC,GACrB,KAAK,CAAA;AACT,KAAK,qBAAqB,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,SAAS,MAAM,CAAC,GAAG,CAAA;CAAE,GAC1F,CAAC,CAAC,kBAAkB,CAAC,GACrB,KAAK,CAAA;AACT,KAAK,uBAAuB,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC,SAAS,eAAe,CAAA;CAAE,GACnG,CAAC,CAAC,kBAAkB,CAAC,GACrB,KAAK,CAAA;AAET;;;;;GAKG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,YAAY,CAAC,CAAA;CAAE,GAAG,EAAE,GAAG,KAAK,CAAA;AAE5G;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,GAAG;IACrD,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,CAAA;CACjE,CAAA;AAED;;;;;;GAMG;AACH,MAAM,WAAW,SAAS,CAAC,YAAY;IACrC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;IAC9B,QAAQ,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,SAAS,CAAA;CAC5C;AAED;;;;;GAKG;AACH,MAAM,WAAW,UAAU,CAAC,GAAG,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS;IAC7D,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAA;IACf,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;CAC3D;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,KAAK,CAAA;AAErE;;;;GAIG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,SAAS,IAAI,QAAQ,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAA;AAEzF;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,mBAAoB,MAAM,UAAU,MAAM,YAAY,MAAM,KAAG,MACI,CAAA;AAE1F;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,SAAS,OACrC,CAAC,SACC,aAAa,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,KAChD,UAAU,CAAC,CAAC,CAAqB,CAAA;AAEpC;;;;GAIG;AACH,MAAM,WAAW,cAAc,CAAC,IAAI,SAAS,MAAM,EAAE,CAAC;IACpD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IACnB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;CAClB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,WAAW,CAAC,IAAI,SAAS,MAAM,EAAE,CAAC;IACjD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IACnB,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;CAC/B;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc,CAAC,IAAI,SAAS,MAAM;IACjD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;CACpB;AAED,KAAK,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAA;AAC9F,KAAK,QAAQ,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAA;AACtF,KAAK,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAA;AAE7E;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AAED;;;;;GAKG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,SAAS,IACxC,CAAC;IAAE,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAA;CAAE,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,GACpD,CAAC;IAAE,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,GAC9C,CAAC;IAAE,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAA;CAAE,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAA;AAExD;;;;GAIG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,SAAS;IAClD,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAA;KAAE,CAAC,CAAC,CAAA;IAC9F,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAA;KAAE,CAAC,CAAC,CAAA;IACxF,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAA;KAAE,CAAC,CAAC,CAAA;CAC/F;AAED;;;;;;GAMG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC,SAAS,SAAS;IAC/C,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;IAC5B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAA;IAC/C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAA;CAChD;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,YAAY,CAC3B,MAAM,SAAS,SAAS,EACxB,QAAQ,SAAS,aAAa,CAAC,SAAS,CAAC,EACzC,EAAE,EACF,EAAE;IAEF,QAAQ,CAAC,MAAM,EAAE,CACf,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,KACzB,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC,CAAA;IAC3E,QAAQ,CAAC,OAAO,EAAE,CAChB,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,EAC5B,OAAO,EAAE,YAAY,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,KACpC,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,EAAE,UAAU,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC,CAAA;CACjE;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,IAAI,CACnB,IAAI,SAAS,MAAM,EACnB,MAAM,SAAS,SAAS,EACxB,QAAQ,SAAS,aAAa,CAAC,SAAS,CAAC;IAEzC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IACnB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;IAC3B,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAE1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,SAAS,CAAC,CAAA;IACnC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,aAAa,CAAC,CAAA;IAC3C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,SAAS,CAAC,CAAA;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,UAAU,CAAC,CAAA;IACrC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC,aAAa,CAAC,CAAA;IAC3C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,OAAO,CAAC,CAAA;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAA;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,SAAS,CAAC,CAAA;IACnC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,UAAU,CAAC,CAAA;IACrC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC,YAAY,CAAC,CAAA;IAEzC;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,CACrB,MAAM,EAAE,KAAK,KACV,MAAM,CAAC,MAAM,CAChB,YAAY,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,EAC9B,KAAK,EACH,YAAY,CAAC,MAAM,CAAC,GACpB,uBAAuB,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,GACzC,qBAAqB,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAC1C,CAAA;IAED;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,EAAE,EAAE,EAAE,EACvB,QAAQ,EAAE,YAAY,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,CAAC,EAChD,OAAO,CAAC,EAAE,eAAe,GAAG,SAAS,KAClC,KAAK,CAAC,KAAK,CACd,KAAK,EACL,KAAK,EACH,MAAM,GAEN,OAAO,CAAC,EAAE,EAAE,UAAU,CAAC,GACvB,OAAO,CAAC,EAAE,EAAE,UAAU,CAAC,GACvB,YAAY,CAAC,MAAM,CAAC,GACpB,YAAY,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,GAC9B,uBAAuB,CAAC,MAAM,CAAC,GAC/B,uBAAuB,CAAC,MAAM,CAAC,GAC/B,qBAAqB,CAAC,MAAM,CAAC,GAC7B,uBAAuB,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,GACzC,uBAAuB,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,GACzC,qBAAqB,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAC1C,CAAA;CACF;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,IAAI,GACf,KAAK,CAAC,IAAI,SAAS,MAAM,EACzB,MAAM,SAAS,SAAS,EACxB,KAAK,CAAC,QAAQ,SAAS,aAAa,CAAC,SAAS,CAAC,QAEzC,IAAI,WACD;IACP,+CAA+C;IAC/C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,iEAAiE;IACjE,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;IAC3B;;;;;;OAMG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,UAAU,GAAG,MAAM,GAAG,SAAS,CAAA;CAC1D,KACA,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAuU7B,CAAA"}