effect 4.0.0-beta.6 → 4.0.0-beta.62

package/src/unstable/workflow/WorkflowEngine.ts

@@ -2,14 +2,17 @@
  * @since 4.0.0
  */
 import type * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
+import * as Fiber from "../../Fiber.ts"
+import * as FiberMap from "../../FiberMap.ts"
 import * as Latch from "../../Latch.ts"
+import * as Layer from "../../Layer.ts"
 import * as Option from "../../Option.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Schema from "../../Schema.ts"
 import * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type * as Activity from "./Activity.ts"
 import type { DurableClock } from "./DurableClock.ts"
 import type * as DurableDeferred from "./DurableDeferred.ts"
@@ -19,7 +22,7 @@ import * as Workflow from "./Workflow.ts"
  * @since 4.0.0
  * @category Services
  */
-export class WorkflowEngine extends ServiceMap.Service<
+export class WorkflowEngine extends Context.Service<
   WorkflowEngine,
   {
     /**
@@ -95,7 +98,7 @@ export class WorkflowEngine extends ServiceMap.Service<
       workflow: Workflow.Workflow<Name, Payload, Success, Error>,
       executionId: string
     ) => Effect.Effect<
-      Workflow.Result<Success["Type"], Error["Type"]> | undefined,
+      Option.Option<Workflow.Result<Success["Type"], Error["Type"]>>,
       never,
       Success["DecodingServices"] | Error["DecodingServices"]
     >
@@ -108,6 +111,15 @@ export class WorkflowEngine extends ServiceMap.Service<
       executionId: string
     ) => Effect.Effect<void>
 
+    /**
+     * Unsafely interrupt a registered workflow, potentially ignoring
+     * compensation finalizers and orphaning child workflows.
+     */
+    readonly interruptUnsafe: (
+      workflow: Workflow.Any,
+      executionId: string
+    ) => Effect.Effect<void>
+
     /**
      * Resume a registered workflow.
      */
@@ -144,7 +156,7 @@ export class WorkflowEngine extends ServiceMap.Service<
     >(
       deferred: DurableDeferred.DurableDeferred<Success, Error>
     ) => Effect.Effect<
-      Exit.Exit<Success["Type"], Error["Type"]> | undefined,
+      Option.Option<Exit.Exit<Success["Type"], Error["Type"]>>,
       never,
       WorkflowInstance
     >
@@ -187,7 +199,7 @@ export class WorkflowEngine extends ServiceMap.Service<
  * @since 4.0.0
  * @category Services
  */
-export class WorkflowInstance extends ServiceMap.Service<
+export class WorkflowInstance extends Context.Service<
   WorkflowInstance,
   {
     /**
@@ -274,11 +286,15 @@ export interface Encoded {
   readonly poll: (
     workflow: Workflow.Any,
     executionId: string
-  ) => Effect.Effect<Workflow.Result<unknown, unknown> | undefined>
+  ) => Effect.Effect<Option.Option<Workflow.Result<unknown, unknown>>>
   readonly interrupt: (
     workflow: Workflow.Any,
     executionId: string
   ) => Effect.Effect<void>
+  readonly interruptUnsafe: (
+    workflow: Workflow.Any,
+    executionId: string
+  ) => Effect.Effect<void>
   readonly resume: (
     workflow: Workflow.Any,
     executionId: string
@@ -294,7 +310,7 @@ export interface Encoded {
   readonly deferredResult: (
     deferred: DurableDeferred.Any
   ) => Effect.Effect<
-    Exit.Exit<unknown, unknown> | undefined,
+    Option.Option<Exit.Exit<unknown, unknown>>,
     never,
     WorkflowInstance
   >
@@ -320,13 +336,13 @@ export interface Encoded {
 export const makeUnsafe = (options: Encoded): WorkflowEngine["Service"] =>
   WorkflowEngine.of({
     register: Effect.fnUntraced(function*(workflow, execute) {
-      const services = yield* Effect.services<WorkflowEngine>()
+      const services = yield* Effect.context<WorkflowEngine>()
       yield* options.register(workflow, (payload, executionId) =>
         Effect.suspend(() =>
           execute(payload, executionId)
         ).pipe(
-          Effect.updateServices(
-            (input) => ServiceMap.merge(services, input) as ServiceMap.ServiceMap<any>
+          Effect.updateContext(
+            (input) => Context.merge(services, input) as Context.Context<any>
           )
         ))
     }),
@@ -351,14 +367,14 @@ export const makeUnsafe = (options: Encoded): WorkflowEngine["Service"] =>
       const executionId = opts.executionId
       const suspendedRetrySchedule = opts.suspendedRetrySchedule ?? defaultRetrySchedule
       yield* Effect.annotateCurrentSpan({ executionId })
-      let result: Workflow.Result<Success["Type"], Error["Type"]> | undefined
+      let result = Option.none<Workflow.Result<Success["Type"], Error["Type"]>>()
 
       // link interruption with parent workflow
       const parentInstance = yield* Effect.serviceOption(WorkflowInstance)
       if (Option.isSome(parentInstance)) {
         const instance = parentInstance.value
         yield* Effect.addFinalizer(() => {
-          if (!instance.interrupted || result?._tag === "Complete") {
+          if (!instance.interrupted || (Option.isSome(result) && result.value._tag === "Complete")) {
             return Effect.void
           }
           return options.interrupt(self, executionId)
@@ -381,21 +397,23 @@ export const makeUnsafe = (options: Encoded): WorkflowEngine["Service"] =>
         parent: Option.getOrUndefined(parentInstance)
       })
       if (Option.isSome(parentInstance)) {
-        result = yield* Workflow.wrapActivityResult(
+        const wrapped = yield* Workflow.wrapActivityResult(
           run,
           (result) => result._tag === "Suspended"
         )
-        if (result._tag === "Suspended") {
+        result = Option.some(wrapped)
+        if (wrapped._tag === "Suspended") {
           return yield* Workflow.suspend(parentInstance.value)
         }
-        return yield* result.exit
+        return yield* wrapped.exit
       }
 
       let sleep: Effect.Effect<any> | undefined
       while (true) {
-        result = yield* run
-        if (result._tag === "Complete") {
-          return yield* result.exit as Exit.Exit<any>
+        const wrapped = yield* run
+        result = Option.some(wrapped)
+        if (wrapped._tag === "Complete") {
+          return yield* wrapped.exit as Exit.Exit<any>
         }
         sleep ??= (yield* Schedule.toStepWithSleep(suspendedRetrySchedule))(
           void 0
@@ -411,6 +429,7 @@ export const makeUnsafe = (options: Encoded): WorkflowEngine["Service"] =>
     }),
     poll: options.poll,
     interrupt: options.interrupt,
+    interruptUnsafe: options.interruptUnsafe,
     resume: options.resume,
     activityExecute: Effect.fnUntraced(function*<
       Success extends Schema.Top,
@@ -435,12 +454,14 @@ export const makeUnsafe = (options: Encoded): WorkflowEngine["Service"] =>
           executionId: instance.executionId
         })
         const exit = yield* options.deferredResult(deferred)
-        if (exit === undefined) {
-          return exit
+        if (Option.isNone(exit)) {
+          return Option.none()
         }
-        return yield* Effect.orDie(
-          Schema.decodeEffect(deferred.exitSchema)(toJsonExit(exit))
-        ) as Effect.Effect<Exit.Exit<Success["Type"], Error["Type"]>>
+        return Option.some(
+          yield* Effect.orDie(
+            Schema.decodeEffect(deferred.exitSchema)(toJsonExit(exit.value))
+          ) as Effect.Effect<Exit.Exit<Success["Type"], Error["Type"]>>
+        )
       },
       Effect.withSpan(
         "WorkflowEngine.deferredResult",
@@ -498,4 +519,196 @@ const defaultRetrySchedule = Schedule.exponential(200, 1.5).pipe(
   Schedule.either(Schedule.spaced(30000))
 )
 
+/**
+ * A in-memory implementation of the WorkflowEngine. This is useful for testing
+ * and local development, but is not suitable for production use as it does not
+ * provide durability guarantees.
+ *
+ * @since 4.0.0
+ * @category Layers
+ */
+export const layerMemory: Layer.Layer<WorkflowEngine> = Layer.effect(WorkflowEngine)(
+  Effect.gen(function*() {
+    const scope = yield* Effect.scope
+
+    const workflows = new Map<string, {
+      readonly workflow: Workflow.Any
+      readonly execute: (
+        payload: object,
+        executionId: string
+      ) => Effect.Effect<unknown, unknown, WorkflowInstance | WorkflowEngine>
+      readonly scope: Scope.Scope
+    }>()
+
+    type ExecutionState = {
+      readonly payload: object
+      readonly execute: (
+        payload: object,
+        executionId: string
+      ) => Effect.Effect<unknown, unknown, WorkflowInstance | WorkflowEngine>
+      readonly parent: string | undefined
+      instance: WorkflowInstance["Service"]
+      fiber: Fiber.Fiber<Workflow.Result<unknown, unknown>> | undefined
+    }
+    const executions = new Map<string, ExecutionState>()
+
+    type ActivityState = {
+      exit: Exit.Exit<Workflow.Result<unknown, unknown>> | undefined
+    }
+    const activities = new Map<string, ActivityState>()
+
+    const resume = Effect.fnUntraced(function*(executionId: string): Effect.fn.Return<void> {
+      const state = executions.get(executionId)
+      if (!state) return
+      const exit = state.fiber?.pollUnsafe()
+      if (exit && exit._tag === "Success" && exit.value._tag === "Complete") {
+        return
+      } else if (state.fiber && !exit) {
+        return
+      }
+
+      const entry = workflows.get(state.instance.workflow.name)!
+      const instance = WorkflowInstance.initial(state.instance.workflow, state.instance.executionId)
+      instance.interrupted = state.instance.interrupted
+      state.instance = instance
+      state.fiber = yield* state.execute(state.payload, state.instance.executionId).pipe(
+        Effect.onExit(() => {
+          if (!instance.interrupted) {
+            return Effect.void
+          }
+          instance.suspended = false
+          return Effect.withFiber((fiber) => Effect.interruptible(Fiber.interrupt(fiber)))
+        }),
+        Workflow.intoResult,
+        Effect.provideService(WorkflowInstance, instance),
+        Effect.provideService(WorkflowEngine, engine),
+        Effect.tap((result) => {
+          if (!state.parent || result._tag !== "Complete") {
+            return Effect.void
+          }
+          return Effect.forkIn(resume(state.parent), scope)
+        }),
+        Effect.forkIn(entry.scope)
+      )
+    })
+
+    const deferredResults = new Map<string, Exit.Exit<any, any>>()
+
+    const clocks = yield* FiberMap.make<string>()
+
+    const engine = makeUnsafe({
+      register: Effect.fnUntraced(function*(workflow, execute) {
+        workflows.set(workflow.name, {
+          workflow,
+          execute,
+          scope: yield* Effect.scope
+        })
+      }),
+      execute: Effect.fnUntraced(function*(workflow, options) {
+        const entry = workflows.get(workflow.name)
+        if (!entry) {
+          return yield* Effect.orDie(Effect.fail(`Workflow ${workflow.name} is not registered`))
+        }
+
+        let state = executions.get(options.executionId)
+        if (!state) {
+          state = {
+            payload: options.payload,
+            execute: entry.execute,
+            instance: WorkflowInstance.initial(workflow, options.executionId),
+            fiber: undefined,
+            parent: options.parent?.executionId
+          }
+          executions.set(options.executionId, state)
+          yield* resume(options.executionId)
+        }
+        if (options.discard) return
+        return (yield* Fiber.join(state.fiber!)) as any
+      }),
+      interrupt: Effect.fnUntraced(function*(_workflow, executionId) {
+        const state = executions.get(executionId)
+        if (!state) return
+        state.instance.interrupted = true
+        yield* resume(executionId)
+      }),
+      interruptUnsafe: Effect.fnUntraced(function*(_workflow, executionId) {
+        const state = executions.get(executionId)
+        if (!state) return
+        state.instance.interrupted = true
+        if (state.fiber) {
+          yield* Fiber.interrupt(state.fiber)
+        }
+      }),
+      resume(_workflow, executionId) {
+        return resume(executionId)
+      },
+      activityExecute: Effect.fnUntraced(function*(activity, attempt) {
+        const instance = yield* WorkflowInstance
+        const activityId = `${instance.executionId}/${activity.name}/${attempt}`
+        let state = activities.get(activityId)
+        if (state) {
+          const exit = state.exit
+          if (exit && exit._tag === "Success" && exit.value._tag === "Suspended") {
+            state.exit = undefined
+          } else if (exit) {
+            return yield* exit
+          }
+        } else {
+          state = { exit: undefined }
+          activities.set(activityId, state)
+        }
+        const activityInstance = WorkflowInstance.initial(instance.workflow, instance.executionId)
+        activityInstance.interrupted = instance.interrupted
+        return yield* activity.executeEncoded.pipe(
+          Workflow.intoResult,
+          Effect.provideService(WorkflowInstance, activityInstance),
+          Effect.onExit((exit) => {
+            state.exit = exit
+            return Effect.void
+          })
+        )
+      }),
+      poll: (_workflow, executionId) =>
+        Effect.suspend(() => {
+          const state = executions.get(executionId)
+          if (!state) {
+            return Effect.succeedNone
+          }
+          const exit = state.fiber?.pollUnsafe()
+          if (!exit) {
+            return Effect.succeedNone
+          }
+          return exit._tag === "Success"
+            ? Effect.succeedSome(exit.value)
+            : Effect.die(exit.cause)
+        }),
+      deferredResult: Effect.fnUntraced(function*(deferred) {
+        const instance = yield* WorkflowInstance
+        const id = `${instance.executionId}/${deferred.name}`
+        return Option.fromNullishOr(deferredResults.get(id))
+      }),
+      deferredDone: (options) =>
+        Effect.suspend(() => {
+          const id = `${options.executionId}/${options.deferredName}`
+          if (deferredResults.has(id)) return Effect.void
+          deferredResults.set(id, options.exit)
+          return resume(options.executionId)
+        }),
+      scheduleClock: (workflow, options) =>
+        engine.deferredDone(options.clock.deferred, {
+          workflowName: workflow.name,
+          executionId: options.executionId,
+          deferredName: options.clock.deferred.name,
+          exit: Exit.void
+        }).pipe(
+          Effect.delay(options.clock.duration),
+          FiberMap.run(clocks, `${options.executionId}/${options.clock.name}`, { onlyIfMissing: true }),
+          Effect.asVoid
+        )
+    })
+
+    return engine
+  })
+)
+
 const toJsonExit = Exit.map((value: any) => value ?? null)

package/src/unstable/workflow/WorkflowProxyServer.ts

@@ -2,9 +2,9 @@
  * @since 4.0.0
  */
 import type { NonEmptyReadonlyArray } from "../../Array.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type * as HttpApi from "../httpapi/HttpApi.ts"
 import * as HttpApiBuilder from "../httpapi/HttpApiBuilder.ts"
 import type * as HttpApiGroup from "../httpapi/HttpApiGroup.ts"
@@ -90,8 +90,8 @@ export const layerRpcHandlers = <
   never,
   WorkflowEngine | Workflow.RequirementsHandler<Workflows[number]>
 > =>
-  Layer.effectServices(Effect.gen(function*() {
-    const services = yield* Effect.services<never>()
+  Layer.effectContext(Effect.gen(function*() {
+    const services = yield* Effect.context<never>()
     const prefix = options?.prefix ?? ""
     const handlers = new Map<string, Rpc.Handler<string>>()
     for (const workflow_ of workflows) {
@@ -118,7 +118,7 @@ export const layerRpcHandlers = <
         handler: (payload: any) => workflow.resume(payload.executionId) as any
       } as any)
     }
-    return ServiceMap.makeUnsafe(handlers)
+    return Context.makeUnsafe(handlers)
   }))
 
 /**

package/dist/NullOr.d.ts

@@ -1,149 +0,0 @@
-/**
- * This module provides small, allocation-free utilities for working with values of type
- * `A | null`, where `null` means "no value".
- *
- * Why not `Option<A>`?
- * In TypeScript, `Option<A>` is often unnecessary. If `null` already models absence
- * in your domain, using `A | null` keeps types simple, avoids extra wrappers, and
- * reduces overhead. The key is that `A` itself must not include `null`; in this
- * module `null` is reserved to mean "no value".
- *
- * When to use `A | null`:
- * - Absence can be represented by `null` in your domain model.
- * - You do not need to distinguish between "no value" and "value is null".
- * - You want straightforward ergonomics and zero extra allocations.
- *
- * When to prefer `Option<A>`:
- * - You must distinguish `None` from `Some(null)` (that is, `null` is a valid
- *   payload and carries meaning on its own).
- * - You need a tagged representation for serialization or pattern matching across
- *   boundaries where `null` would be ambiguous.
- * - You want the richer `Option` API and are comfortable with the extra wrapper.
- *
- * Lawfulness note:
- * All helpers treat `null` as absence. Do not use these utilities with payloads
- * where `A` can itself be `null`, or you will lose information. If you need to
- * carry `null` as a valid payload, use `Option<A>` instead.
- *
- * @since 4.0.0
- */
-import * as Combiner from "./Combiner.ts";
-import type { LazyArg } from "./Function.ts";
-import * as Reducer from "./Reducer.ts";
-/**
- * @since 4.0.0
- */
-export declare const map: {
-    /**
-     * @since 4.0.0
-     */
-    <A, B>(f: (a: A) => B): (self: A | null) => B | null;
-    /**
-     * @since 4.0.0
-     */
-    <A, B>(self: A | null, f: (a: A) => B): B | null;
-};
-/**
- * @since 4.0.0
- */
-export declare const match: {
-    /**
-     * @since 4.0.0
-     */
-    <B, A, C = B>(options: {
-        readonly onNull: LazyArg<B>;
-        readonly onNotNull: (a: A) => C;
-    }): (self: A | null) => B | C;
-    /**
-     * @since 4.0.0
-     */
-    <A, B, C = B>(self: A | null, options: {
-        readonly onNull: LazyArg<B>;
-        readonly onNotNull: (a: A) => C;
-    }): B | C;
-};
-/**
- * @since 4.0.0
- */
-export declare const getOrThrowWith: {
-    /**
-     * @since 4.0.0
-     */
-    (onNull: () => unknown): <A>(self: A | null) => A;
-    /**
-     * @since 4.0.0
-     */
-    <A>(self: A | null, onNull: () => unknown): A;
-};
-/**
- * @since 4.0.0
- */
-export declare const getOrThrow: <A>(self: A | null) => A;
-/**
- * @since 4.0.0
- */
-export declare const liftThrowable: <A extends ReadonlyArray<unknown>, B>(f: (...a: A) => B) => (...a: A) => B | null;
-/**
- * Creates a `Reducer` for `NullOr<A>` that prioritizes the first non-`null`
- * value and combines values when both operands are present.
- *
- * This `Reducer` is useful for scenarios where you want to:
- * - Take the first available value (like a fallback chain)
- * - Combine values when both are present
- * - Maintain a `null` state only when all values are `null`
- *
- * The `initialValue` of the `Reducer` is `null`.
- *
- * **Behavior:**
- * - `null` + `null` = `null`
- * - `a` + `null` = `a` (first value wins)
- * - `null` + `b` = `b` (second value wins)
- * - `a` + `b` = `a + b` (values combined)
- *
- * @since 4.0.0
- */
-export declare function makeReducer<A>(combiner: Combiner.Combiner<A>): Reducer.Reducer<A | null>;
-/**
- * Creates a `Combiner` for `NullOr<A>` that only combines values when both
- * operands are not `null`, failing fast if either is `null`.
- *
- * This `Combiner` is useful for scenarios where you need both values to be
- * present to perform an operation, such as:
- * - Mathematical operations that require two operands
- * - Data validation that needs both fields
- * - Operations that can't proceed with partial data
- *
- * **Behavior:**
- * - `null` + `null` = `null`
- * - `a` + `null` = `null` (fails fast)
- * - `null` + `b` = `null` (fails fast)
- * - `a` + `b` = `a + b` (values combined)
- *
- * @see {@link makeReducerFailFast} if you have a `Reducer` and want to lift it
- * to `NullOr` values.
- *
- * @since 4.0.0
- */
-export declare function makeCombinerFailFast<A>(combiner: Combiner.Combiner<A>): Combiner.Combiner<A | null>;
-/**
- * Creates a `Reducer` for `NullOr<A>` by wrapping an existing `Reducer` with
- * fail-fast semantics for `NullOr` values.
- *
- * This function lifts a regular `Reducer` into the `NullOr` context, allowing
- * you to use existing `Reducer`s with `NullOr` values while maintaining the
- * fail-fast behavior where any `null` value causes the entire reduction to fail.
- *
- * The initial value is `some(reducer.initialValue)`, ensuring the `Reducer`
- * starts with a valid `NullOr` value.
- *
- * **Behavior:**
- * - Fails fast (returns `null`) if any operand is `null`
- * - Uses the underlying reducer's combine logic when both values are present
- *
- * @see {@link makeCombinerFailFast} if you only have a `Combiner` and want to
- * lift it to `NullOr` values.
- *
- * @since 4.0.0
- */
-export declare function makeReducerFailFast<A>(reducer: Reducer.Reducer<A>): Reducer.Reducer<A | null>;
-//# sourceMappingURL=NullOr.d.ts.map

package/dist/NullOr.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"NullOr.d.ts","sourceRoot":"","sources":["../src/NullOr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AACzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAE5C,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AAEvC;;GAEG;AACH,eAAO,MAAM,GAAG,EAAE;IAChB;;OAEG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI,KAAK,CAAC,GAAG,IAAI,CAAA;IACpD;;OAEG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,CAAA;CACQ,CAAA;AAE1D;;GAEG;AACH,eAAO,MAAM,KAAK,EAAE;IAClB;;OAEG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,EACV,OAAO,EAAE;QACP,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;QAC3B,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAA;KAChC,GACA,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI,KAAK,CAAC,GAAG,CAAC,CAAA;IAC5B;;OAEG;IACH,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,EACV,IAAI,EAAE,CAAC,GAAG,IAAI,EACd,OAAO,EAAE;QACP,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;QAC3B,QAAQ,CAAC,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAA;KAChC,GACA,CAAC,GAAG,CAAC,CAAA;CAOT,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE;IAC3B;;OAEG;IACH,CAAC,MAAM,EAAE,MAAM,OAAO,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,KAAK,CAAC,CAAA;IACjD;;OAEG;IACH,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,MAAM,OAAO,GAAG,CAAC,CAAA;CAM7C,CAAA;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,KAAK,CAAkE,CAAA;AAElH;;GAEG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,SAAS,aAAa,CAAC,OAAO,CAAC,EAAE,CAAC,EAC/D,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,KAChB,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,IAOnB,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAMxF;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC,GAAG,IAAI,CAAC,CAKnG;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAW7F"}