@entifix/workflow 0.0.0-stage → 0.12.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 r10c Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,25 @@
-# Temporary Holding Version
+# @entifix/workflow
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Durable flows. A flow is a pinned routing slip, and this package interprets it on Effect Workflow behind the `FlowEngineTag` port from `@entifix/transactions`: each step an Activity keyed `<flowId>:<step>`, a refusal before the commit point compensated in reverse, a failure after it suspended and resumed, and a `wait` step parked on a durable deferred its signal completes.
+
+`effect/workflow` and `effect/cluster` are imported here and nowhere else in entifix — their APIs are unstable, and the chaos suite pins what this package relies on.
+
+## Install
+
+```sh
+pnpm add @entifix/workflow effect
+# a deployment of several runners:
+pnpm add @effect/platform-node
+```
+
+## Entry points
+
+| Import                            | What it holds                                                                                                          |
+| --------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
+| `@entifix/workflow`               | `FlowEngineLayer`, `makeFlowEngine`, `SlipWorkflow`, `interpretSlip`, `FlowStatusStoreTag`, the in-memory status store |
+| `@entifix/workflow/postgres`      | `SingleRunnerFlowEngineLayer` and the SQL status store, over the host's `SqlClient`                                    |
+| `@entifix/workflow/socket-runner` | `SocketRunnerFlowEngineLayer`, one runner among several; needs `@effect/platform-node`                                 |
+
+---
+
+Tier 2 (adapters) of entifix — a package depends only on its own tier or below. See [the tiers](https://github.com/r10c-technologies/entifix#the-tiers-and-what-you-are-allowed-to-install). MIT licensed.

package/dist/engine/make-flow-engine.d.ts

@@ -0,0 +1,23 @@
+import { type FlowEngine, FlowEngineTag } from '@entifix/transactions';
+import { Effect, Layer } from 'effect';
+import { WorkflowEngine } from 'effect/workflow';
+import { type InterpreterOptions } from '../interpreter/slip-workflow.js';
+import { FlowStatusStoreTag } from '../status/flow-status-store.js';
+/**
+ * The flow engine port over Effect Workflow
+ * ([ADR 0016](../../../../../docs/adr/0016-a-flow-engine-port-and-a-durable-workflow-adapter.md)).
+ * A start records the flow under its key and executes the slip detached — it
+ * answers the flow id, never the outcome, which arrives as `flow.*` events and
+ * in the status record. A signal is accepted only by a flow parked on exactly
+ * that wait.
+ */
+export declare const makeFlowEngine: Effect.Effect<FlowEngine, never, FlowStatusStoreTag | WorkflowEngine.WorkflowEngine>;
+/**
+ * The flow engine with the interpreter registered. Needs a workflow engine —
+ * the in-memory one, or the cluster engine over Postgres from
+ * `@entifix/workflow/postgres` — a status store, a participant client, the
+ * outbox its events go through, and the breaker, bulkhead and retry budget
+ * every call runs under.
+ */
+export declare const FlowEngineLayer: (options: InterpreterOptions) => Layer.Layer<FlowEngineTag, never, import("@entifix/transactions").OutboxTag | import("@entifix/transactions").BulkheadTag | import("@entifix/transactions").CircuitBreakerTag | import("@entifix/transactions").ParticipantClientTag | import("@entifix/transactions").RetryBudgetTag | FlowStatusStoreTag | WorkflowEngine.WorkflowEngine>;
+//# sourceMappingURL=make-flow-engine.d.ts.map

package/dist/engine/make-flow-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-flow-engine.d.ts","sourceRoot":"","sources":["../../src/engine/make-flow-engine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,UAAU,EACf,aAAa,EAGd,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAW,MAAM,EAAE,KAAK,EAAU,MAAM,QAAQ,CAAC;AACxD,OAAO,EAAmB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAElE,OAAO,EACL,KAAK,kBAAkB,EAIxB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAEpE;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,sFAmFzB,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAAI,SAAS,kBAAkB,gVAGxD,CAAC"}

package/dist/engine/make-flow-engine.js

@@ -0,0 +1,97 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { FlowEngineTag, FlowNotFound, FlowSignalRejected } from '@entifix/transactions';
+import { Context, Effect, Layer, Option } from 'effect';
+import { DurableDeferred } from 'effect/workflow';
+import { SlipWorkflow, SlipWorkflowLayer, waitFor } from '../interpreter/slip-workflow.js';
+import { FlowStatusStoreTag } from '../status/flow-status-store.js';
+/**
+ * The flow engine port over Effect Workflow
+ * ([ADR 0016](../../../../../docs/adr/0016-a-flow-engine-port-and-a-durable-workflow-adapter.md)).
+ * A start records the flow under its key and executes the slip detached — it
+ * answers the flow id, never the outcome, which arrives as `flow.*` events and
+ * in the status record. A signal is accepted only by a flow parked on exactly
+ * that wait.
+ */ export const makeFlowEngine = Effect.gen(function*() {
+    const context = yield* Effect.context();
+    const store = Context.get(context, FlowStatusStoreTag);
+    const within = (effect)=>Effect.provideContext(effect, context);
+    const known = (flowId)=>Effect.flatMap(store.find(flowId), (found)=>Option.match(found, {
+                onNone: ()=>Effect.fail(new FlowNotFound({
+                        flowId
+                    })),
+                onSome: Effect.succeed
+            }));
+    /** Completes the wait `record` is parked on, if `token` names it. */ const complete = (token, outcome)=>(record)=>Effect.gen(function*() {
+                if (record.state !== 'waiting' || record.waitingFor !== token) return yield* Effect.fail(new FlowSignalRejected({
+                    flowId: record.flowId,
+                    token
+                }));
+                const deferred = waitFor(token);
+                yield* within(DurableDeferred.succeed(deferred, {
+                    token: DurableDeferred.tokenFromExecutionId(deferred, {
+                        workflow: SlipWorkflow,
+                        executionId: record.executionId
+                    }),
+                    value: outcome
+                }));
+                // Recorded here as well as by the flow, so a second signal racing the
+                // resume is refused rather than completing the wait twice.
+                yield* store.update(record.flowId, {
+                    state: 'running',
+                    step: token
+                });
+            });
+    const engine = {
+        start: (slip, idempotencyKey)=>Effect.gen(function*() {
+                const payload = {
+                    key: idempotencyKey,
+                    slip
+                };
+                const executionId = yield* SlipWorkflow.executionId(payload);
+                const record = yield* store.register(idempotencyKey, {
+                    flowId: slip.flowId,
+                    executionId,
+                    state: 'running'
+                });
+                if (record.executionId === executionId && record.flowId === slip.flowId) yield* within(SlipWorkflow.execute(payload, {
+                    discard: true
+                }));
+                return {
+                    flowId: record.flowId
+                };
+            }),
+        status: (flowId)=>Effect.map(known(flowId), (record)=>_extends({
+                    flowId: record.flowId,
+                    state: record.state
+                }, record.step === undefined ? {} : {
+                    step: record.step
+                })),
+        signal: (flowId, token, outcome)=>Effect.flatMap(known(flowId), complete(token, outcome)),
+        signalCorrelated: (correlation, token, outcome)=>Effect.gen(function*() {
+                const found = yield* store.findByCorrelation(correlation);
+                if (Option.isNone(found)) return yield* Effect.fail(new FlowNotFound({
+                    flowId: correlation
+                }));
+                return yield* complete(token, outcome)(found.value);
+            }),
+        interrupt: (flowId)=>Effect.gen(function*() {
+                const record = yield* known(flowId);
+                yield* within(SlipWorkflow.interrupt(record.executionId));
+                yield* store.update(flowId, _extends({
+                    state: 'interrupted'
+                }, record.step === undefined ? {} : {
+                    step: record.step
+                }));
+            })
+    };
+    return engine;
+});
+/**
+ * The flow engine with the interpreter registered. Needs a workflow engine —
+ * the in-memory one, or the cluster engine over Postgres from
+ * `@entifix/workflow/postgres` — a status store, a participant client, the
+ * outbox its events go through, and the breaker, bulkhead and retry budget
+ * every call runs under.
+ */ export const FlowEngineLayer = (options)=>Layer.effect(FlowEngineTag, makeFlowEngine).pipe(Layer.provideMerge(SlipWorkflowLayer(options)));
+
+//# sourceMappingURL=make-flow-engine.js.map

package/dist/engine/make-flow-engine.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/engine/make-flow-engine.ts"],"sourcesContent":["import {\n  type FlowEngine,\n  FlowEngineTag,\n  FlowNotFound,\n  FlowSignalRejected,\n} from '@entifix/transactions';\nimport { Context, Effect, Layer, Option } from 'effect';\nimport { DurableDeferred, WorkflowEngine } from 'effect/workflow';\n\nimport {\n  type InterpreterOptions,\n  SlipWorkflow,\n  SlipWorkflowLayer,\n  waitFor,\n} from '../interpreter/slip-workflow.js';\nimport type { FlowRecord } from '../status/flow-status-store.js';\nimport { FlowStatusStoreTag } from '../status/flow-status-store.js';\n\n/**\n * The flow engine port over Effect Workflow\n * ([ADR 0016](../../../../../docs/adr/0016-a-flow-engine-port-and-a-durable-workflow-adapter.md)).\n * A start records the flow under its key and executes the slip detached — it\n * answers the flow id, never the outcome, which arrives as `flow.*` events and\n * in the status record. A signal is accepted only by a flow parked on exactly\n * that wait.\n */\nexport const makeFlowEngine = Effect.gen(function* () {\n  const context = yield* Effect.context<\n    WorkflowEngine.WorkflowEngine | FlowStatusStoreTag\n  >();\n  const store = Context.get(context, FlowStatusStoreTag);\n  const within = <A, E>(\n    effect: Effect.Effect<A, E, WorkflowEngine.WorkflowEngine>,\n  ) => Effect.provideContext(effect, context);\n\n  const known = (flowId: string) =>\n    Effect.flatMap(store.find(flowId), found =>\n      Option.match(found, {\n        onNone: () => Effect.fail(new FlowNotFound({ flowId })),\n        onSome: Effect.succeed,\n      }),\n    );\n\n  /** Completes the wait `record` is parked on, if `token` names it. */\n  const complete = (token: string, outcome: unknown) => (record: FlowRecord) =>\n    Effect.gen(function* () {\n      if (record.state !== 'waiting' || record.waitingFor !== token)\n        return yield* Effect.fail(\n          new FlowSignalRejected({ flowId: record.flowId, token }),\n        );\n      const deferred = waitFor(token);\n      yield* within(\n        DurableDeferred.succeed(deferred, {\n          token: DurableDeferred.tokenFromExecutionId(deferred, {\n            workflow: SlipWorkflow,\n            executionId: record.executionId,\n          }),\n          value: outcome,\n        }),\n      );\n      // Recorded here as well as by the flow, so a second signal racing the\n      // resume is refused rather than completing the wait twice.\n      yield* store.update(record.flowId, { state: 'running', step: token });\n    });\n\n  const engine: FlowEngine = {\n    start: (slip, idempotencyKey) =>\n      Effect.gen(function* () {\n        const payload = { key: idempotencyKey, slip };\n        const executionId = yield* SlipWorkflow.executionId(payload);\n        const record = yield* store.register(idempotencyKey, {\n          flowId: slip.flowId,\n          executionId,\n          state: 'running',\n        });\n        if (record.executionId === executionId && record.flowId === slip.flowId)\n          yield* within(SlipWorkflow.execute(payload, { discard: true }));\n        return { flowId: record.flowId };\n      }),\n\n    status: flowId =>\n      Effect.map(known(flowId), record => ({\n        flowId: record.flowId,\n        state: record.state,\n        ...(record.step === undefined ? {} : { step: record.step }),\n      })),\n\n    signal: (flowId, token, outcome) =>\n      Effect.flatMap(known(flowId), complete(token, outcome)),\n\n    signalCorrelated: (correlation, token, outcome) =>\n      Effect.gen(function* () {\n        const found = yield* store.findByCorrelation(correlation);\n        if (Option.isNone(found))\n          return yield* Effect.fail(new FlowNotFound({ flowId: correlation }));\n        return yield* complete(token, outcome)(found.value);\n      }),\n\n    interrupt: flowId =>\n      Effect.gen(function* () {\n        const record = yield* known(flowId);\n        yield* within(SlipWorkflow.interrupt(record.executionId));\n        yield* store.update(flowId, {\n          state: 'interrupted',\n          ...(record.step === undefined ? {} : { step: record.step }),\n        });\n      }),\n  };\n  return engine;\n});\n\n/**\n * The flow engine with the interpreter registered. Needs a workflow engine —\n * the in-memory one, or the cluster engine over Postgres from\n * `@entifix/workflow/postgres` — a status store, a participant client, the\n * outbox its events go through, and the breaker, bulkhead and retry budget\n * every call runs under.\n */\nexport const FlowEngineLayer = (options: InterpreterOptions) =>\n  Layer.effect(FlowEngineTag, makeFlowEngine).pipe(\n    Layer.provideMerge(SlipWorkflowLayer(options)),\n  );\n"],"names":["FlowEngineTag","FlowNotFound","FlowSignalRejected","Context","Effect","Layer","Option","DurableDeferred","SlipWorkflow","SlipWorkflowLayer","waitFor","FlowStatusStoreTag","makeFlowEngine","gen","context","store","get","within","effect","provideContext","known","flowId","flatMap","find","found","match","onNone","fail","onSome","succeed","complete","token","outcome","record","state","waitingFor","deferred","tokenFromExecutionId","workflow","executionId","value","update","step","engine","start","slip","idempotencyKey","payload","key","register","execute","discard","status","map","undefined","signal","signalCorrelated","correlation","findByCorrelation","isNone","interrupt","FlowEngineLayer","options","pipe","provideMerge"],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './engine/make-flow-engine.js';
+export * from './interpreter/slip-workflow.js';
+export * from './status/flow-status-store.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,+BAA+B,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './engine/make-flow-engine.js';
+export * from './interpreter/slip-workflow.js';
+export * from './status/flow-status-store.js';
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export * from './engine/make-flow-engine.js';\nexport * from './interpreter/slip-workflow.js';\nexport * from './status/flow-status-store.js';\n"],"names":[],"mappings":"AAAA,cAAc,+BAA+B;AAC7C,cAAc,iCAAiC;AAC/C,cAAc,gCAAgC"}

package/dist/interpreter/slip-workflow.d.ts

@@ -0,0 +1,114 @@
+import { type FragmentCatalog, Slip } from '@entifix/business/flow';
+import { type EntifixFailure } from '@entifix/core';
+import { BulkheadTag, CircuitBreakerTag, OutboxTag, ParticipantClientTag } from '@entifix/transactions';
+import { Context, Effect, Schema } from 'effect';
+import { DurableDeferred, Workflow } from 'effect/workflow';
+import { FlowStatusStoreTag } from '../status/flow-status-store.js';
+/**
+ * A failure as an Activity journals it: the problem body on the way in, the
+ * failure its code names on the way out, so a resumed flow sees the typed
+ * refusal a participant sent rather than a cast.
+ */
+export declare const JournaledFailure: Schema.Codec<EntifixFailure, unknown>;
+/**
+ * How a flow ended, as the workflow's own result: every step ran, or a
+ * refusal before the commit point was undone, or an undoing itself failed and
+ * the flow stopped where it was — which a person has to look at.
+ */
+export declare const FlowOutcome: Schema.Literals<readonly ["completed", "compensated", "failed"]>;
+declare const FlowWaitTimedOut_base: Schema.Class<FlowWaitTimedOut, Schema.TaggedStruct<"FlowWaitTimedOut", {
+    readonly step: Schema.String;
+}>, import("effect/Cause").YieldableError & import("@entifix/core").FailureFacts<"flowWaitTimedOut", "timeout">>;
+/** A durable wait that outlived its timeout before its signal came. */
+export declare class FlowWaitTimedOut extends FlowWaitTimedOut_base {
+}
+/** How long a flow gives each participant call, and each step as a whole. */
+export interface FlowDials {
+    /** One attempt at a call. */
+    readonly attemptTimeoutMs: number;
+    /** Every attempt at a step together, retries included. */
+    readonly stepTimeoutMs: number;
+    /** Segments of one stage run at once. */
+    readonly concurrency: number;
+}
+export declare const DEFAULT_FLOW_DIALS: FlowDials;
+/** What the interpreter runs a slip with: the catalog, who announces, the dials. */
+export interface InterpreterOptions {
+    readonly catalog: FragmentCatalog;
+    /** The slice the `flow.*` events are announced from. */
+    readonly source: string;
+    readonly dials?: Partial<FlowDials>;
+    /**
+     * One participant's own attempt and step bounds, over `dials` — the same
+     * shape the breaker's `dialsFor` and the bulkhead's `permitsFor` take, so a
+     * participant's dials are one row set however many guards read them.
+     */
+    readonly dialsFor?: (participant: string) => Partial<Omit<FlowDials, 'concurrency'>> | undefined;
+}
+declare const InterpreterOptionsTag_base: Context.ServiceClass<InterpreterOptionsTag, "@entifix/workflow/InterpreterOptions", InterpreterOptions>;
+/**
+ * The interpreter's options, provided to the workflow it is registered with —
+ * the payload is the slip; the catalog and dials are the deployment's.
+ */
+export declare class InterpreterOptionsTag extends InterpreterOptionsTag_base {
+}
+/**
+ * The one workflow every flow runs as: its payload is the pinned slip and the
+ * idempotency key that started it
+ * ([ADR 0016](../../../../../docs/adr/0016-a-flow-engine-port-and-a-durable-workflow-adapter.md)).
+ * The execution id derives from the key, so the same key is the same flow.
+ *
+ * A flow suspended past its commit point is resumed on the retry schedule:
+ * a participant that comes back gets the step again, idempotently.
+ */
+export declare const SlipWorkflow: Workflow.Workflow<"entifix/slip", Schema.Struct<{
+    key: Schema.String;
+    slip: Schema.Struct<{
+        readonly slipVersion: Schema.Literal<1>;
+        readonly flowId: Schema.String;
+        readonly recipe: Schema.String;
+        readonly requiresCommitPoint: Schema.optionalKey<Schema.Boolean>;
+        readonly stages: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly steps: Schema.$Array<Schema.Struct<{
+                readonly ref: Schema.String;
+                readonly step: Schema.String;
+                readonly cardinality: Schema.Literals<readonly ["one", "perVendor", "perLine"]>;
+                readonly segment: Schema.optionalKey<Schema.Struct<{
+                    readonly vendor: Schema.optionalKey<Schema.String>;
+                    readonly paymentMethod: Schema.optionalKey<Schema.String>;
+                }>>;
+                readonly participant: Schema.optionalKey<Schema.String>;
+                readonly call: Schema.optionalKey<Schema.Struct<{
+                    readonly method: Schema.Literals<readonly ["GET", "POST", "PUT", "PATCH", "DELETE"]>;
+                    readonly path: Schema.String;
+                }>>;
+                readonly compensation: Schema.optionalKey<Schema.Struct<{
+                    readonly method: Schema.Literals<readonly ["GET", "POST", "PUT", "PATCH", "DELETE"]>;
+                    readonly path: Schema.String;
+                }>>;
+                readonly parameters: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>;
+            }>>;
+        }>>;
+        readonly resolution: Schema.$Array<Schema.Struct<{
+            readonly useCase: Schema.String;
+            readonly variant: Schema.String;
+            readonly rule: Schema.Number;
+        }>>;
+        readonly composedAt: Schema.String;
+        readonly audience: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly kind: Schema.Literals<readonly ["organization", "party", "flow"]>;
+            readonly id: Schema.String;
+            readonly digest: Schema.optionalKey<Schema.String>;
+        }>>>;
+    }>;
+}>, Schema.Literals<readonly ["completed", "compensated", "failed"]>, Schema.Codec<EntifixFailure<string, string, import("@entifix/core").FailureCategory>, unknown, never, never>>;
+/** The durable wait a `wait` step parks on, addressed by the step's name. */
+export declare const waitFor: (step: string) => DurableDeferred.DurableDeferred<Schema.Unknown, Schema.Never>;
+/** Every `slipVersion` the interpreter walks — each must have a journal. */
+export declare const interpretedSlipVersions: readonly number[];
+export declare const interpretSlip: (slip: Slip) => Effect.Effect<"completed" | "failed" | "compensated", EntifixFailure<string, string, import("@entifix/core").FailureCategory>, OutboxTag | BulkheadTag | CircuitBreakerTag | ParticipantClientTag | import("@entifix/transactions").RetryBudgetTag | FlowStatusStoreTag | InterpreterOptionsTag | import("effect/workflow/WorkflowEngine").WorkflowInstance | import("effect/workflow/WorkflowEngine").WorkflowEngine>;
+/** The interpreter registered with the workflow engine, with its options. */
+export declare const SlipWorkflowLayer: (options: InterpreterOptions) => import("effect/Layer").Layer<never, never, OutboxTag | BulkheadTag | CircuitBreakerTag | ParticipantClientTag | import("@entifix/transactions").RetryBudgetTag | FlowStatusStoreTag | import("effect/workflow/WorkflowEngine").WorkflowEngine>;
+export {};
+//# sourceMappingURL=slip-workflow.d.ts.map

package/dist/interpreter/slip-workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slip-workflow.d.ts","sourceRoot":"","sources":["../../src/interpreter/slip-workflow.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,eAAe,EACpB,IAAI,EAGL,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAEL,KAAK,cAAc,EAMpB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,WAAW,EACX,iBAAiB,EAIjB,SAAS,EACT,oBAAoB,EACrB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,OAAO,EACP,MAAM,EAIN,MAAM,EAEP,MAAM,QAAQ,CAAC;AAChB,OAAO,EAGL,eAAe,EACf,QAAQ,EACT,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAGL,kBAAkB,EACnB,MAAM,gCAAgC,CAAC;AAExC;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,KAAK,CAAC,cAAc,EAAE,OAAO,CAShE,CAAC;AAEJ;;;;GAIG;AACH,eAAO,MAAM,WAAW,kEAItB,CAAC;;;;AAEH,uEAAuE;AACvE,qBAAa,gBAAiB,SAAQ,qBAKrC;CAAG;AAEJ,6EAA6E;AAC7E,MAAM,WAAW,SAAS;IACxB,6BAA6B;IAC7B,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,0DAA0D;IAC1D,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,yCAAyC;IACzC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B;AAED,eAAO,MAAM,kBAAkB,EAAE,SAIhC,CAAC;AAEF,oFAAoF;AACpF,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;IAClC,wDAAwD;IACxD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;IACpC;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAClB,WAAW,EAAE,MAAM,KAChB,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC,GAAG,SAAS,CAAC;CAC1D;;AAED;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,0BAGA;CAAG;AAE9C;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mLAYvB,CAAC;AAEH,6EAA6E;AAC7E,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,kEAC+B,CAAC;AA0TpE,4EAA4E;AAC5E,eAAO,MAAM,uBAAuB,EAAE,SAAS,MAAM,EACd,CAAC;AAExC,eAAO,MAAM,aAAa,GAAI,MAAM,IAAI,2ZACF,CAAC;AAEvC,6EAA6E;AAC7E,eAAO,MAAM,iBAAiB,GAAI,SAAS,kBAAkB,mPAK1D,CAAC"}