@livestore/utils 0.0.54-dev.5 → 0.0.55-dev.0

package/src/effect/Schema/index.ts

@@ -0,0 +1,60 @@
+import { Transferable } from '@effect/platform'
+import { Schema } from '@effect/schema'
+import type { ParseOptions } from '@effect/schema/AST'
+import type { ParseError } from '@effect/schema/ParseResult'
+import { Effect, Hash } from 'effect'
+
+import { objectToString } from '../../misc.js'
+
+export * from '@effect/schema/Schema'
+export * from './debug-diff.js'
+
+// NOTE this is a temporary workaround until Effect schema has a better way to hash schemas
+// https://github.com/Effect-TS/effect/issues/2719
+// TODO remove this once the issue is resolved
+export const hash = (schema: Schema.Schema<any>) => {
+  try {
+    return Hash.string(JSON.stringify(schema.ast, null, 2))
+  } catch {
+    console.warn(
+      `Schema hashing failed, falling back to hashing the shortend schema AST string. This is less reliable and may cause false positives.`,
+    )
+    return Hash.hash(schema.ast.toString())
+  }
+}
+
+const errorStructSchema = Schema.Struct({
+  message: Schema.String,
+  stack: Schema.optional(Schema.String),
+})
+
+export class AnyError extends Schema.transform(errorStructSchema, Schema.Any, {
+  decode: (errorStruct) => {
+    const { message, stack } = errorStruct
+    const previousLimit = Error.stackTraceLimit
+    Error.stackTraceLimit = 0
+    // eslint-disable-next-line unicorn/error-message
+    const error = new Error('')
+    Error.stackTraceLimit = previousLimit
+    error.message = message
+    error.stack = stack
+    return error
+  },
+  encode: (anyError) => ({
+    message: objectToString(anyError).replace(/^Error: /, ''),
+    stack: anyError.stack,
+  }),
+}) {}
+
+export const encodeWithTransferables =
+  <A, I, R>(schema: Schema.Schema<A, I, R>, options?: ParseOptions | undefined) =>
+  (a: A, overrideOptions?: ParseOptions | undefined): Effect.Effect<[I, Transferable[]], ParseError, R> =>
+    Effect.gen(function* () {
+      const collector = yield* Transferable.makeCollector
+
+      const encoded: I = yield* Schema.encode(schema, options)(a, overrideOptions).pipe(
+        Effect.provideService(Transferable.Collector, collector),
+      )
+
+      return [encoded, collector.unsafeRead() as Transferable[]]
+    })

package/src/effect/Stream.ts

@@ -1,7 +1,7 @@
 export * from 'effect/Stream'
 
 import type { Chunk } from 'effect'
-import { Effect, pipe, Stream } from 'effect'
+import { Effect, Option, pipe, Ref, Stream } from 'effect'
 
 export const tapLog = <R, E, A>(stream: Stream.Stream<A, E, R>): Stream.Stream<A, E, R> =>
   tapChunk<never, never, A, void>(Effect.forEach((_) => Effect.succeed(console.log(_))))(stream)
@@ -20,3 +20,39 @@ export const tapChunk =
         Effect.map(() => chunks),
       ),
     )
+
+const isIdentity = <A>(a1: A, a2: A): boolean => a1 === a2
+
+export const skipRepeated =
+  <A>(isEqual: (prevEl: A, newEl: A) => boolean = isIdentity) =>
+  <R, E>(stream: Stream.Stream<A, E, R>): Stream.Stream<A, E, R> =>
+    skipRepeated_(stream, isEqual)
+
+export const skipRepeated_ = <R, E, A>(
+  stream: Stream.Stream<A, E, R>,
+  isEqual: (prevEl: A, newEl: A) => boolean = isIdentity,
+): Stream.Stream<A, E, R> =>
+  pipe(
+    Ref.make<Option.Option<A>>(Option.none()),
+    Stream.fromEffect,
+    Stream.flatMap((ref) =>
+      pipe(
+        stream,
+        Stream.filterEffect((el) =>
+          pipe(
+            Ref.get(ref),
+            Effect.flatMap((prevEl) => {
+              if (prevEl._tag === 'None' || isEqual(prevEl.value, el) === false) {
+                return pipe(
+                  Ref.set(ref, Option.some(el)),
+                  Effect.map(() => true),
+                )
+              } else {
+                return Effect.succeed(false)
+              }
+            }),
+          ),
+        ),
+      ),
+    ),
+  )

package/src/effect/SubscriptionRef.ts

@@ -1,15 +1,30 @@
-import type { Effect } from 'effect'
-import { pipe, Stream, SubscriptionRef } from 'effect'
+import { Chunk, Effect, pipe, Stream, SubscriptionRef } from 'effect'
 import { dual } from 'effect/Function'
+import type { Predicate, Refinement } from 'effect/Predicate'
 
 export * from 'effect/SubscriptionRef'
 
 export const changeStreamIncludingCurrent = <A>(sref: SubscriptionRef.SubscriptionRef<A>) =>
   pipe(Stream.fromEffect(SubscriptionRef.get(sref)), Stream.concat(sref.changes))
 
-export const waitUntil = dual<
-  <A>(predicate: (a: A) => boolean) => (sref: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<void>,
-  <A>(sref: SubscriptionRef.SubscriptionRef<A>, predicate: (a: A) => boolean) => Effect.Effect<void>
->(2, <A>(sref: SubscriptionRef.SubscriptionRef<A>, predicate: (a: A) => boolean) =>
-  pipe(changeStreamIncludingCurrent(sref), Stream.filter(predicate), Stream.take(1), Stream.runDrain),
+export const waitUntil: {
+  <A, B extends A>(
+    refinement: Refinement<NoInfer<A>, B>,
+  ): (sref: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<B, never, never>
+  <A, B extends A>(
+    predicate: Predicate<B>,
+  ): (sref: SubscriptionRef.SubscriptionRef<A>) => Effect.Effect<A, never, never>
+  <A, B extends A>(
+    sref: SubscriptionRef.SubscriptionRef<A>,
+    refinement: Refinement<NoInfer<A>, B>,
+  ): Effect.Effect<B, never, never>
+  <A, B extends A>(sref: SubscriptionRef.SubscriptionRef<A>, predicate: Predicate<B>): Effect.Effect<A, never, never>
+} = dual(2, <A>(sref: SubscriptionRef.SubscriptionRef<A>, predicate: (a: A) => boolean) =>
+  pipe(
+    changeStreamIncludingCurrent(sref),
+    Stream.filter(predicate),
+    Stream.take(1),
+    Stream.runCollect,
+    Effect.map(Chunk.unsafeHead),
+  ),
 )

package/src/effect/WebLock.ts

@@ -3,29 +3,45 @@ import { Deferred, Effect, Runtime } from 'effect'
 
 // See https://developer.mozilla.org/en-US/docs/Web/API/Web_Locks_API
 export const withLock =
-  (lockName: string, options?: Omit<LockOptions, 'signal'>) =>
-  <Ctx, E, A>(eff: Effect.Effect<A, E, Ctx>): Effect.Effect<A | void, E, Ctx> =>
-    Effect.gen(function* ($) {
-      const runtime = yield* $(Effect.runtime<Ctx>())
-
-      const exit = yield* $(
-        Effect.tryPromise<Exit.Exit<A, E>, E>({
-          try: (signal) => {
-            // NOTE The 'signal' and 'ifAvailable' options cannot be used together.
-            const requestOptions = options?.ifAvailable === true ? options : { ...options, signal }
-            return navigator.locks.request(lockName, requestOptions, async (lock) => {
-              if (lock === null) return
-
-              // TODO also propagate Effect interruption to the execution
-              return Runtime.runPromiseExit(runtime)(eff)
-            })
-          },
-          catch: (err) => err as any as E,
-        }),
-      )
+  <E2>({
+    lockName,
+    onTaken,
+    options,
+  }: {
+    lockName: string
+    onTaken?: Effect.Effect<void, E2>
+    options?: Omit<LockOptions, 'signal'>
+  }) =>
+  <Ctx, E, A>(eff: Effect.Effect<A, E, Ctx>): Effect.Effect<A | void, E | E2, Ctx> =>
+    Effect.gen(function* () {
+      const runtime = yield* Effect.runtime<Ctx>()
+
+      const exit = yield* Effect.tryPromise<Exit.Exit<A, E>, E | E2>({
+        try: (signal) => {
+          if (signal.aborted) return 'aborted' as never
+
+          // NOTE The 'signal' and 'ifAvailable' options cannot be used together.
+          const requestOptions = options?.ifAvailable === true ? options : { ...options, signal }
+          return navigator.locks.request(lockName, requestOptions, async (lock) => {
+            if (lock === null) {
+              if (onTaken) {
+                const exit = await Runtime.runPromiseExit(runtime)(onTaken)
+                if (exit._tag === 'Failure') {
+                  return exit
+                }
+              }
+              return
+            }
+
+            // TODO also propagate Effect interruption to the execution
+            return Runtime.runPromiseExit(runtime)(eff)
+          })
+        },
+        catch: (err) => err as any as E,
+      })
 
       if (exit._tag === 'Failure') {
-        return yield* $(Effect.failCause(exit.cause))
+        return yield* Effect.failCause(exit.cause)
       } else {
         return exit.value
       }
@@ -33,25 +49,47 @@ export const withLock =
 
 export const waitForDeferredLock = (deferred: Deferred.Deferred<void>, lockName: string) =>
   Effect.async<void>((cb, signal) => {
-    navigator.locks.request(lockName, { signal, mode: 'exclusive', ifAvailable: false }, async (_lock) => {
-      // immediately continuing calling Effect since we have the lock
-      cb(Effect.void)
+    if (signal.aborted) return
 
-      // the code below is still running
+    navigator.locks
+      .request(lockName, { signal, mode: 'exclusive', ifAvailable: false }, (_lock) => {
+        // immediately continuing calling Effect since we have the lock
+        cb(Effect.void)
 
-      // holding lock until deferred is resolved
-      await Effect.runPromise(Deferred.await(deferred))
-    })
+        // the code below is still running
+
+        // holding lock until deferred is resolved
+        return Effect.runPromise(Deferred.await(deferred))
+      })
+      .catch((error) => {
+        if (error.code === 20 && error.message === 'signal is aborted without reason') {
+          // Given signal interruption is handled via Effect, we can ignore this case
+        } else {
+          throw error
+        }
+      })
   })
 
 export const tryGetDeferredLock = (deferred: Deferred.Deferred<void>, lockName: string) =>
-  Effect.async<boolean>((cb) => {
-    navigator.locks.request(lockName, { mode: 'exclusive', ifAvailable: true }, async (lock) => {
+  Effect.async<boolean>((cb, signal) => {
+    navigator.locks.request(lockName, { mode: 'exclusive', ifAvailable: true }, (lock) => {
       cb(Effect.succeed(lock !== null))
 
       // the code below is still running
 
+      const abortPromise = new Promise<void>((resolve) => {
+        signal.addEventListener('abort', () => {
+          resolve()
+        })
+      })
+
       // holding lock until deferred is resolved
-      await Effect.runPromise(Deferred.await(deferred))
+      return Promise.race([
+        Effect.runPromise(Deferred.await(deferred)),
+        // .finally(() =>
+        //   console.log('[@livestore/utils:WebLock] tryGetDeferredLock. finally', lockName),
+        // ),
+        abortPromise,
+      ])
     })
   })

package/src/effect/browser-worker-tmp/BrowserWorker.ts

@@ -0,0 +1,26 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Layer from 'effect/Layer'
+
+import type * as Worker from '../worker-tmp/Worker.js'
+import * as internal from './internal/worker.js'
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerManager: Layer.Layer<Worker.WorkerManager> = internal.layerManager
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerWorker: Layer.Layer<Worker.PlatformWorker> = internal.layerWorker
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layer: (
+  spawn: (id: number) => Worker | SharedWorker | MessagePort,
+) => Layer.Layer<Worker.WorkerManager | Worker.Spawner, never, never> = internal.layer

package/src/effect/browser-worker-tmp/BrowserWorkerRunner.ts

@@ -0,0 +1,14 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Layer from 'effect/Layer'
+
+import type * as Runner from '../worker-tmp/WorkerRunner.js'
+import * as internal from './internal/workerRunner.js'
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layer: Layer.Layer<Runner.PlatformRunner> = internal.layer
+export { layerMessagePort } from './port-platform-runner.js'

package/src/effect/browser-worker-tmp/internal/worker.ts

@@ -0,0 +1,71 @@
+/* eslint-disable prefer-arrow/prefer-arrow-functions */
+import * as Deferred from 'effect/Deferred'
+import * as Effect from 'effect/Effect'
+import * as Layer from 'effect/Layer'
+import * as Queue from 'effect/Queue'
+
+import * as Worker from '../../worker-tmp/Worker.js'
+import { WorkerError } from '../../worker-tmp/WorkerError.js'
+
+const platformWorkerImpl = Worker.PlatformWorker.of({
+  [Worker.PlatformWorkerTypeId]: Worker.PlatformWorkerTypeId,
+  spawn<I, O>(worker_: unknown) {
+    return Effect.gen(function* (_) {
+      const worker = worker_ as globalThis.SharedWorker | globalThis.Worker | MessagePort
+      let port: globalThis.Worker | MessagePort
+      if ('port' in worker) {
+        port = worker.port
+      } else {
+        port = worker
+      }
+
+      yield* _(Effect.addFinalizer(() => Effect.sync(() => port.postMessage([1]))))
+
+      const queue = yield* _(Queue.unbounded<Worker.BackingWorker.Message<O>>())
+      const latch = yield* Deferred.make<void>()
+
+      const fiber = yield* _(
+        Effect.async<never, WorkerError, never>((resume) => {
+          function onMessage(event: MessageEvent) {
+            queue.unsafeOffer((event as MessageEvent).data)
+          }
+          function onError(event: ErrorEvent) {
+            resume(new WorkerError({ reason: 'unknown', error: event.error ?? event.message }))
+          }
+          port.addEventListener('message', onMessage as any)
+          port.addEventListener('error', onError as any)
+          Deferred.unsafeDone(latch, Effect.void)
+          return Effect.sync(() => {
+            port.removeEventListener('message', onMessage as any)
+            port.removeEventListener('error', onError as any)
+          })
+        }),
+        Effect.interruptible,
+        Effect.forkScoped,
+      )
+      yield* Deferred.await(latch)
+
+      if ('start' in port) {
+        port.start()
+      }
+
+      const send = (message: I, transfers?: ReadonlyArray<unknown>) =>
+        Effect.try({
+          try: () => port.postMessage([0, message], transfers as any),
+          catch: (error) => new WorkerError({ reason: 'send', error }),
+        })
+
+      return { fiber, queue, send }
+    })
+  },
+})
+
+/** @internal */
+export const layerWorker = Layer.succeed(Worker.PlatformWorker, platformWorkerImpl)
+
+/** @internal */
+export const layerManager = Layer.provide(Worker.layerManager, layerWorker)
+
+/** @internal */
+export const layer = (spawn: (id: number) => globalThis.Worker | globalThis.SharedWorker | MessagePort) =>
+  Layer.merge(layerManager, Worker.layerSpawner(spawn))

package/src/effect/browser-worker-tmp/internal/workerRunner.ts

@@ -0,0 +1,119 @@
+/// <reference lib="webworker" />
+/* eslint-disable prefer-arrow/prefer-arrow-functions */
+import * as Cause from 'effect/Cause'
+import * as Effect from 'effect/Effect'
+import * as FiberSet from 'effect/FiberSet'
+import { globalValue } from 'effect/GlobalValue'
+import * as Layer from 'effect/Layer'
+import * as Queue from 'effect/Queue'
+import * as Schedule from 'effect/Schedule'
+
+import { WorkerError } from '../../worker-tmp/WorkerError.js'
+import * as WorkerRunner from '../../worker-tmp/WorkerRunner.js'
+
+const cachedPorts = globalValue('@effect/platform-browser/Worker/cachedPorts', () => new Set<MessagePort>())
+function globalHandleConnect(event: MessageEvent) {
+  cachedPorts.add((event as MessageEvent).ports[0]!)
+}
+if (typeof self !== 'undefined' && 'onconnect' in self) {
+  // @ts-expect-error TODO
+  self.addEventListener('connect', globalHandleConnect)
+}
+
+const platformRunnerImpl = WorkerRunner.PlatformRunner.of({
+  [WorkerRunner.PlatformRunnerTypeId]: WorkerRunner.PlatformRunnerTypeId,
+  start<I, O>(shutdown: Effect.Effect<void>) {
+    return Effect.gen(function* () {
+      let currentPortId = 0
+
+      yield* Effect.addFinalizer(() => Effect.sync(() => self.close()))
+
+      const queue = yield* Queue.unbounded<readonly [portId: number, message: I]>()
+      const runFork = yield* FiberSet.makeRuntime<never>()
+      const ports = new Map<number, MessagePort>()
+      const send = (portId: number, message: O, transfer?: ReadonlyArray<unknown>) =>
+        Effect.sync(() => {
+          ports.get(portId)?.postMessage([1, message], {
+            transfer: transfer as any,
+          })
+        })
+
+      function handlePort(port: MessagePort, sharedWorker: boolean) {
+        const portId = currentPortId++
+        ports.set(portId, port)
+
+        Effect.async<never, WorkerError, never>((resume) => {
+          function onMessage(event: MessageEvent) {
+            const message = (event as MessageEvent).data as WorkerRunner.BackingRunner.Message<I>
+            if (message[0] === 0) {
+              queue.unsafeOffer([portId, message[1]])
+            } else if (sharedWorker && ports.size > 1) {
+              resume(Effect.interrupt)
+            } else {
+              Effect.runFork(shutdown)
+            }
+          }
+          function onMessageError(error: ErrorEvent) {
+            resume(new WorkerError({ reason: 'decode', error: error.error ?? error.message }))
+          }
+          function onError(error: ErrorEvent) {
+            resume(new WorkerError({ reason: 'unknown', error: error.error ?? error.message }))
+          }
+          port.addEventListener('message', onMessage as any)
+          port.addEventListener('messageerror', onMessageError as any)
+          port.addEventListener('error', onError as any)
+
+          // ready
+          if ('start' in port) {
+            port.start()
+          }
+          port.postMessage([0])
+
+          return Effect.sync(() => {
+            port.removeEventListener('message', onMessage as any)
+            port.removeEventListener('messageerror', onMessageError as any)
+            port.removeEventListener('error', onError as any)
+          })
+        }).pipe(
+          Effect.tapErrorCause((cause) => (Cause.isInterruptedOnly(cause) ? Effect.void : Effect.logDebug(cause))),
+          Effect.retry(Schedule.forever),
+          Effect.annotateLogs({
+            package: '@effect/platform-browser',
+            module: 'WorkerRunner',
+          }),
+          Effect.ensuring(
+            Effect.sync(() => {
+              ports.delete(portId)
+            }),
+          ),
+          Effect.interruptible,
+          runFork,
+        )
+      }
+
+      if ('onconnect' in self) {
+        // @ts-expect-error TODO
+        self.addEventListener('connect', (event: MessageEvent) => {
+          const port = (event as MessageEvent).ports[0]
+          handlePort(port!, true)
+        })
+        yield* Effect.addFinalizer(() =>
+          Effect.sync(() => {
+            ;(self as any).addEventListener('connect', globalHandleConnect)
+          }),
+        )
+        for (const port of cachedPorts) {
+          handlePort(port, true)
+        }
+        cachedPorts.clear()
+      } else {
+        handlePort(self as any, false)
+      }
+
+      return { queue, send }
+    })
+  },
+})
+
+/** @internal */
+export const layer = Layer.succeed(WorkerRunner.PlatformRunner, platformRunnerImpl)

package/src/effect/browser-worker-tmp/port-platform-runner.ts

@@ -0,0 +1,74 @@
+import { Deferred } from 'effect'
+import * as Cause from 'effect/Cause'
+import * as Effect from 'effect/Effect'
+import * as Layer from 'effect/Layer'
+import * as Queue from 'effect/Queue'
+import * as Schedule from 'effect/Schedule'
+
+import { WorkerError } from '../worker-tmp/WorkerError.js'
+import * as Runner from '../worker-tmp/WorkerRunner.js'
+
+const platformRunnerImpl = (port: MessagePort) =>
+  Runner.PlatformRunner.of({
+    [Runner.PlatformRunnerTypeId]: Runner.PlatformRunnerTypeId,
+    start: <I, O>(shutdown: Effect.Effect<void>) => {
+      return Effect.gen(function* () {
+        const queue = yield* Queue.unbounded<readonly [portId: number, message: I]>()
+
+        const latch = yield* Deferred.make<void>()
+
+        yield* Effect.async<never, WorkerError>((resume) => {
+          const onMessage = (msg: MessageEvent<Runner.BackingRunner.Message<I>>) => {
+            const message = msg.data
+            if (message[0] === 0) {
+              queue.unsafeOffer([0, message[1]])
+            } else {
+              Effect.runFork(shutdown)
+            }
+          }
+
+          const onError = (error: any) => {
+            resume(new WorkerError({ reason: 'decode', error }))
+          }
+
+          port.addEventListener('message', onMessage)
+          port.addEventListener('messageerror', onError)
+          port.addEventListener('error', onError)
+
+          Deferred.unsafeDone(latch, Effect.void)
+
+          return Effect.sync(() => {
+            port.removeEventListener('message', onMessage as any)
+            port.removeEventListener('error', onError as any)
+          })
+        }).pipe(
+          Effect.tapErrorCause((cause) => (Cause.isInterruptedOnly(cause) ? Effect.void : Effect.logDebug(cause))),
+          Effect.retry(Schedule.forever),
+          Effect.annotateLogs({
+            package: '@livestore/utils/effect',
+            module: 'PortPlatformRunner',
+          }),
+          Effect.interruptible,
+          Effect.forkScoped,
+        )
+
+        yield* Deferred.await(latch)
+
+        port.start()
+
+        const send = (_portId: number, message: O, transfers?: ReadonlyArray<unknown>) =>
+          Effect.try({
+            try: () => port.postMessage([1, message], transfers as any),
+            catch: (error) => new WorkerError({ reason: 'send', error }),
+          }).pipe(Effect.catchTag('WorkerError', Effect.orDie))
+
+        // ready
+        port.postMessage([0])
+
+        return { queue, send }
+      })
+    },
+  })
+
+/** @internal */
+export const layerMessagePort = (port: MessagePort) => Layer.succeed(Runner.PlatformRunner, platformRunnerImpl(port))

package/src/effect/index.ts

@@ -7,12 +7,15 @@ export {
   Queue,
   Fiber,
   FiberId,
+  FiberSet,
+  FiberMap,
+  FiberHandle,
+  Inspectable,
   RuntimeFlags,
   PubSub,
   Exit,
   Cause,
   Runtime,
-  Scheduler,
   FiberRef,
   FiberRefs,
   FiberRefsPatch,
@@ -36,6 +39,8 @@ export {
   HashSet,
   MutableHashSet,
   Option,
+  LogLevel,
+  Logger,
   Layer,
   STM,
   TRef,
@@ -55,18 +60,26 @@ export {
   TreeFormatter,
   AST as SchemaAST,
   Pretty as SchemaPretty,
+  Equivalence as SchemaEquivalence,
   Serializable,
   JSONSchema,
   ParseResult,
 } from '@effect/schema'
-export * as Schema from './Schema.js'
+export * as Schema from './Schema/index.js'
 export * as OtelTracer from '@effect/opentelemetry/Tracer'
 
-export { Transferable, FileSystem, Worker, WorkerError, WorkerRunner, Terminal, HttpServer } from '@effect/platform'
-export { BrowserWorker, BrowserWorkerRunner } from '@effect/platform-browser'
+// export { Transferable, FileSystem, Worker, WorkerError, WorkerRunner, Terminal, HttpServer } from '@effect/platform'
+// export { BrowserWorker, BrowserWorkerRunner } from '@effect/platform-browser'
+export { Transferable, FileSystem, Terminal, HttpServer } from '@effect/platform'
+export * as Worker from './worker-tmp/Worker.js'
+export * as WorkerError from './worker-tmp/WorkerError.js'
+export * as WorkerRunner from './worker-tmp/WorkerRunner.js'
+export * as BrowserWorker from './browser-worker-tmp/BrowserWorker.js'
+export * as BrowserWorkerRunner from './browser-worker-tmp/BrowserWorkerRunner.js'
 
 export * as Effect from './Effect.js'
 export * as Schedule from './Schedule.js'
+export * as Scheduler from './Scheduler.js'
 export * from './Error.js'
 export * as ServiceContext from './ServiceContext.js'
 export * as WebLock from './WebLock.js'