effect 4.0.0-beta.4 → 4.0.0-beta.40

package/src/unstable/workflow/DurableClock.ts

@@ -28,11 +28,11 @@ export interface DurableClock {
  */
 export const make = (options: {
   readonly name: string
-  readonly duration: Duration.DurationInput
+  readonly duration: Duration.Input
 }): DurableClock => ({
   [TypeId]: TypeId,
   name: options.name,
-  duration: Duration.fromDurationInputUnsafe(options.duration),
+  duration: Duration.fromInputUnsafe(options.duration),
   deferred: DurableDeferred.make(`DurableClock/${options.name}`)
 })
 
@@ -54,14 +54,14 @@ const InstanceTag = ServiceMap.Service<
 export const sleep: (
   options: {
     readonly name: string
-    readonly duration: Duration.DurationInput
+    readonly duration: Duration.Input
     /**
      * If the duration is less than or equal to this threshold, the clock will
      * be executed in memory.
      *
      * Defaults to 60 seconds.
      */
-    readonly inMemoryThreshold?: Duration.DurationInput | undefined
+    readonly inMemoryThreshold?: Duration.Input | undefined
   }
 ) => Effect.Effect<
   void,
@@ -69,16 +69,16 @@ export const sleep: (
   WorkflowEngine | WorkflowInstance
 > = Effect.fnUntraced(function*(options: {
   readonly name: string
-  readonly duration: Duration.DurationInput
-  readonly inMemoryThreshold?: Duration.DurationInput | undefined
+  readonly duration: Duration.Input
+  readonly inMemoryThreshold?: Duration.Input | undefined
 }) {
-  const duration = Duration.fromDurationInputUnsafe(options.duration)
+  const duration = Duration.fromInputUnsafe(options.duration)
   if (Duration.isZero(duration)) {
     return
   }
 
   const inMemoryThreshold = options.inMemoryThreshold
-    ? Duration.fromDurationInputUnsafe(options.inMemoryThreshold)
+    ? Duration.fromInputUnsafe(options.inMemoryThreshold)
     : defaultInMemoryThreshold
 
   if (Duration.isLessThanOrEqualTo(duration, inMemoryThreshold)) {

package/src/unstable/workflow/DurableDeferred.ts

@@ -5,10 +5,10 @@ import type { NonEmptyReadonlyArray } from "../../Array.ts"
 import type * as Brand from "../../Brand.ts"
 import type * as Cause from "../../Cause.ts"
 import * as Effect from "../../Effect.ts"
-import * as Base64Url from "../../encoding/Base64Url.ts"
+import * as Encoding from "../../Encoding.ts"
 import * as Exit from "../../Exit.ts"
 import { dual } from "../../Function.ts"
-import * as Predicate from "../../Predicate.ts"
+import * as Option from "../../Option.ts"
 import * as Schema from "../../Schema.ts"
 import * as Getter from "../../SchemaGetter.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
@@ -124,12 +124,12 @@ const await_: <Success extends Schema.Top, Error extends Schema.Top>(
   const instance = yield* InstanceTag
   const exit = yield* Workflow.wrapActivityResult(
     engine.deferredResult(self),
-    Predicate.isUndefined
+    Option.isNone
   )
-  if (exit === undefined) {
+  if (Option.isNone(exit)) {
     return yield* Workflow.suspend(instance)
   }
-  return yield* exit as Exit.Exit<any, any>
+  return yield* exit.value as Exit.Exit<any, any>
 })
 
 export {
@@ -241,8 +241,8 @@ export const raceAll = <
   return Effect.gen(function*() {
     const engine = yield* EngineTag
     const exit = yield* engine.deferredResult(deferred)
-    if (exit !== undefined) {
-      return yield* Effect.flatten(exit) as Effect.Effect<any, any, any>
+    if (Option.isSome(exit)) {
+      return yield* Effect.flatten(exit.value) as Effect.Effect<any, any, any>
     }
     return yield* into(Effect.raceAll(options.effects), deferred)
   })
@@ -285,7 +285,7 @@ export class TokenParsed extends Schema.Class<TokenParsed>(
    * @since 4.0.0
    */
   get asToken(): Token {
-    return Base64Url.encode(
+    return Encoding.encodeBase64Url(
       JSON.stringify([this.workflowName, this.executionId, this.deferredName])
     ) as Token
   }

package/src/unstable/workflow/Workflow.ts

@@ -44,7 +44,7 @@ export interface Workflow<
    * Add an annotation to the workflow.
    */
   annotate<I, S>(
-    key: ServiceMap.Service<I, S>,
+    key: ServiceMap.Key<I, S>,
     value: S
   ): Workflow<Name, Payload, Success, Error>
 
@@ -78,7 +78,7 @@ export interface Workflow<
   readonly poll: (
     executionId: string
   ) => Effect.Effect<
-    Result<Success["Type"], Error["Type"]> | undefined,
+    Option.Option<Result<Success["Type"], Error["Type"]>>,
     never,
     WorkflowEngine | Success["DecodingServices"] | Error["DecodingServices"]
   >
@@ -374,7 +374,11 @@ export const make = <
           return yield* engine.register(self, execute)
         })
       ),
-    executionId: (payload) => makeExecutionId(self.payloadSchema.make(payload)),
+    executionId: (payload) =>
+      Effect.flatMap(
+        Effect.sync(() => self.payloadSchema.makeUnsafe(payload)),
+        makeExecutionId
+      ),
     withCompensation
   }
 

package/src/unstable/workflow/WorkflowEngine.ts

@@ -4,6 +4,10 @@
 import type * as Cause from "../../Cause.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"
@@ -94,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"]
     >
@@ -143,7 +147,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
     >
@@ -224,7 +228,7 @@ export class WorkflowInstance extends ServiceMap.Service<
 
     readonly activityState: {
       count: number
-      readonly latch: Effect.Latch
+      readonly latch: Latch.Latch
     }
   }
 >()("effect/workflow/WorkflowEngine/WorkflowInstance") {
@@ -241,7 +245,7 @@ export class WorkflowInstance extends ServiceMap.Service<
       cause: undefined,
       activityState: {
         count: 0,
-        latch: Effect.makeLatchUnsafe()
+        latch: Latch.makeUnsafe()
       }
     })
   }
@@ -273,7 +277,7 @@ 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
@@ -293,7 +297,7 @@ export interface Encoded {
   readonly deferredResult: (
     deferred: DurableDeferred.Any
   ) => Effect.Effect<
-    Exit.Exit<unknown, unknown> | undefined,
+    Option.Option<Exit.Exit<unknown, unknown>>,
     never,
     WorkflowInstance
   >
@@ -350,14 +354,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)
@@ -380,21 +384,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
@@ -434,12 +440,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",
@@ -497,4 +505,188 @@ 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)
+      }),
+      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/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"}