@effect/platform-browser 4.0.0-beta.7 → 4.0.0-beta.70

package/src/BrowserRuntime.ts

@@ -1,17 +1,42 @@
 /**
- * @since 1.0.0
+ * Browser entry-point helpers for running Effect programs.
+ *
+ * This module exposes `runMain`, a browser-oriented main runner for launching
+ * an Effect as the root program of a page, single-page application, demo, or
+ * browser test harness. It delegates execution to the core Effect runtime while
+ * adding the browser lifecycle hook needed to interrupt the main fiber when the
+ * page receives `beforeunload`.
+ *
+ * `BrowserRuntime` does not provide application services by itself. Provide
+ * any required layers, such as browser HTTP, storage, worker, geolocation, or
+ * permission services, before passing the effect to `runMain`. Keep long-lived
+ * browser resources scoped so interruption can run their finalizers while the
+ * page is still active.
+ *
+ * Browser unload is more constrained than a process signal. Finalizers that
+ * need the network, timers, prompts, or long asynchronous work may not complete
+ * once navigation or tab close has started, and browsers do not expose a
+ * process exit status. Use `runMain` to connect the page lifecycle to Effect
+ * interruption, and use browser-specific persistence or delivery APIs for work
+ * that must survive page teardown.
+ *
+ * @since 4.0.0
  */
 import type * as Effect from "effect/Effect"
 import { makeRunMain, type Teardown } from "effect/Runtime"
 
 /**
- * @since 1.0.0
+ * Runs an effect as the browser main program and interrupts its fiber when the page receives a `beforeunload` event.
+ *
  * @category Runtime
+ * @since 4.0.0
  */
 export const runMain: {
   /**
-   * @since 1.0.0
+   * Runs an effect as the browser main program and interrupts its fiber when the page receives a `beforeunload` event.
+   *
    * @category Runtime
+   * @since 4.0.0
    */
   (
     options?: {
@@ -20,8 +45,10 @@ export const runMain: {
     }
   ): <E, A>(effect: Effect.Effect<A, E>) => void
   /**
-   * @since 1.0.0
+   * Runs an effect as the browser main program and interrupts its fiber when the page receives a `beforeunload` event.
+   *
    * @category Runtime
+   * @since 4.0.0
    */
   <E, A>(
     effect: Effect.Effect<A, E>,

package/src/BrowserSocket.ts

@@ -1,12 +1,37 @@
 /**
- * @since 1.0.0
+ * Browser WebSocket layers for Effect sockets.
+ *
+ * This module provides the browser entry point for `Socket.Socket` values
+ * backed by the platform `WebSocket` implementation. Use `layerWebSocket` when
+ * client-side Effect programs, browser tests, RPC transports, or realtime UI
+ * features need a bidirectional socket connected to a WebSocket URL, and use
+ * `layerWebSocketConstructor` when lower-level socket APIs need access to the
+ * browser constructor service.
+ *
+ * Browser WebSocket rules still apply. Connections are created through
+ * `globalThis.WebSocket`, so URL schemes, subprotocol negotiation, mixed-content
+ * blocking, cookies, authentication, CORS-like origin checks, and extension
+ * negotiation are controlled by the browser and server rather than by Effect.
+ * Close events are translated into socket errors unless the provided
+ * `closeCodeIsError` predicate classifies the close code as clean, which is
+ * useful for protocols that use application-specific close codes.
+ *
+ * Messages are delivered as strings or binary `Uint8Array` values; browser
+ * `Blob` messages are read into bytes before they reach the socket handler.
+ * Outgoing data should already be serialized to a string or bytes, and protocol
+ * frames that represent an intentional close should be sent as `CloseEvent`
+ * values so the underlying `WebSocket.close` code and reason are preserved.
+ *
+ * @since 4.0.0
  */
 import * as Layer from "effect/Layer"
 import * as Socket from "effect/unstable/socket/Socket"
 
 /**
- * @since 1.0.0
- * @category Layers
+ * Creates a `Socket` layer connected to the given URL using the browser `WebSocket` constructor.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layerWebSocket = (url: string, options?: {
   readonly closeCodeIsError?: (code: number) => boolean
@@ -16,10 +41,10 @@ export const layerWebSocket = (url: string, options?: {
   )
 
 /**
- * A WebSocket constructor that uses `globalThis.WebSocket`.
+ * Layer that provides a `WebSocketConstructor` service backed by `globalThis.WebSocket`.
  *
- * @since 1.0.0
- * @category Layers
+ * @category layers
+ * @since 4.0.0
  */
 export const layerWebSocketConstructor: Layer.Layer<Socket.WebSocketConstructor> =
   Socket.layerWebSocketConstructorGlobal

package/src/BrowserStream.ts

@@ -1,5 +1,27 @@
 /**
- * @since 1.0.0
+ * Browser `Stream` constructors for DOM event targets.
+ *
+ * This module provides typed helpers for turning `window.addEventListener` and
+ * `document.addEventListener` callbacks into Effect `Stream`s. They are useful
+ * for UI and runtime signals such as resize, visibility, keyboard, pointer,
+ * focus, online / offline, and other browser events that should be composed
+ * with Effect stream operators and finalized with the consuming fiber.
+ *
+ * Browser events are push-based `EventTarget` notifications, so they do not
+ * apply Web Streams backpressure to the browser event source. Events are
+ * buffered until downstream pulls them; the default buffer is unbounded, so
+ * high-frequency sources like scroll, pointermove, or mousemove should usually
+ * set `bufferSize` and use stream operators that sample, debounce, throttle, or
+ * drop work as appropriate.
+ *
+ * These helpers are for DOM events, not for adapting `ReadableStream` request
+ * or response bodies. Fetch bodies follow the Web Streams body rules, including
+ * single-consumer locking and disturbed bodies after reads, and should be
+ * handled with body-specific HTTP or Web Streams APIs instead. When using the
+ * browser `once` option, pair the stream with `Stream.take(1)` if a finite
+ * stream is required.
+ *
+ * @since 4.0.0
  */
 
 import * as Stream from "effect/Stream"
@@ -7,11 +29,14 @@ import * as Stream from "effect/Stream"
 /**
  * Creates a `Stream` from `window.addEventListener`.
  *
+ * **Details**
+ *
  * By default, the underlying buffer is unbounded in size. You can customize the
- * buffer size an object as the second argument with the `bufferSize` field.
+ * buffer size by passing an object as the second argument with the `bufferSize`
+ * field.
  *
- * @since 1.0.0
  * @category Streams
+ * @since 4.0.0
  */
 export const fromEventListenerWindow = <K extends keyof WindowEventMap>(
   type: K,
@@ -26,11 +51,14 @@ export const fromEventListenerWindow = <K extends keyof WindowEventMap>(
 /**
  * Creates a `Stream` from `document.addEventListener`.
  *
+ * **Details**
+ *
  * By default, the underlying buffer is unbounded in size. You can customize the
- * buffer size an object as the second argument with the `bufferSize` field.
+ * buffer size by passing an object as the second argument with the `bufferSize`
+ * field.
  *
- * @since 1.0.0
  * @category Streams
+ * @since 4.0.0
  */
 export const fromEventListenerDocument = <K extends keyof DocumentEventMap>(
   type: K,

package/src/BrowserWorker.ts

@@ -1,5 +1,25 @@
 /**
- * @since 1.0.0
+ * Parent-side browser support for Effect workers.
+ *
+ * This module provides the `WorkerPlatform` used by browser applications that
+ * spawn or connect to `Worker`, `SharedWorker`, and `MessagePort` endpoints
+ * through Effect's worker protocol. Pair it with `BrowserWorkerRunner` in the
+ * worker entrypoint when building worker-backed RPC clients, moving CPU-bound
+ * work off the main thread, isolating browser-only services, or adapting an
+ * existing `MessageChannel` in tests and custom transports.
+ *
+ * Dedicated workers communicate through the worker object itself, while shared
+ * workers communicate through `worker.port`; raw `MessagePort` values are also
+ * accepted and are started when supported. Messages are posted with the browser
+ * structured-clone algorithm, so payloads must be cloneable by the target
+ * runtime. Transfer lists can avoid copying values such as `ArrayBuffer` or
+ * `MessagePort`, but transferring moves ownership away from the sender and
+ * invalid or mismatched transferables can fail the send. Scope finalization
+ * sends the worker close signal over the port; the application that created a
+ * dedicated `Worker` remains responsible for any broader lifecycle such as
+ * terminating it.
+ *
+ * @since 4.0.0
  */
 import * as Deferred from "effect/Deferred"
 import * as Effect from "effect/Effect"
@@ -9,8 +29,10 @@ import * as Worker from "effect/unstable/workers/Worker"
 import { WorkerError, WorkerReceiveError } from "effect/unstable/workers/WorkerError"
 
 /**
- * @since 1.0.0
- * @category Layers
+ * Creates browser worker layers by combining the default `WorkerPlatform` with a spawner for `Worker`, `SharedWorker`, or `MessagePort` instances.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layer = (
   spawn: (id: number) => Worker | SharedWorker | MessagePort
@@ -21,8 +43,10 @@ export const layer = (
   )
 
 /**
- * @since 1.0.0
- * @category Layers
+ * Layer that provides the browser `WorkerPlatform` for `Worker`, `SharedWorker`, and `MessagePort` communication.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layerPlatform: Layer.Layer<Worker.WorkerPlatform> = Layer.succeed(Worker.WorkerPlatform)(
   Worker.makePlatform<globalThis.SharedWorker | globalThis.Worker | MessagePort>()({
@@ -50,7 +74,7 @@ export const layerPlatform: Layer.Layer<Worker.WorkerPlatform> = Layer.succeed(W
               message: "An error event was emitter",
               cause: event.error ?? event.message
             })
-          }).asEffect()
+          })
         )
       }
       port.addEventListener("message", onMessage as any)

package/src/BrowserWorkerRunner.ts

@@ -1,5 +1,23 @@
 /**
- * @since 1.0.0
+ * Browser runtime support for Effect worker runners.
+ *
+ * This module is intended for code that is already executing in a browser
+ * worker context, or for tests and adapters that supply a `MessagePort` or
+ * `Window` endpoint directly. It provides the `WorkerRunnerPlatform` used by
+ * `WorkerRunner` and `RpcServer.layerProtocolWorkerRunner` to receive parent
+ * or client requests, run Effect handlers, and send responses through the
+ * browser `postMessage` channel.
+ *
+ * Use it with `BrowserWorker` when a browser application needs to move RPC
+ * handlers, CPU-bound computations, or browser-only services into a dedicated
+ * worker or shared worker. Dedicated workers communicate through the current
+ * `self` endpoint; shared workers accept multiple `onconnect` ports and cache
+ * ports that connect before the runner layer starts. Messages still use the
+ * browser structured-clone algorithm, so payload schemas, transfer lists,
+ * `messageerror` events, and the lifetime of each `MessagePort` must be
+ * considered when crossing worker boundaries.
+ *
+ * @since 4.0.0
  */
 import * as Cause from "effect/Cause"
 import * as Deferred from "effect/Deferred"
@@ -22,8 +40,10 @@ if (typeof self !== "undefined" && "onconnect" in self) {
 }
 
 /**
- * @since 1.0.0
- * @category Constructors
+ * Creates a `WorkerRunnerPlatform` service that runs worker handlers over a `MessagePort` or `Window`.
+ *
+ * @category constructors
+ * @since 4.0.0
  */
 export const make = (self: MessagePort | Window): WorkerRunner.WorkerRunnerPlatform["Service"] => ({
   start: Effect.fnUntraced(function*<O = unknown, I = unknown>() {
@@ -44,7 +64,7 @@ export const make = (self: MessagePort | Window): WorkerRunner.WorkerRunnerPlatf
       Effect.scopedWith(Effect.fnUntraced(function*(scope) {
         const closeLatch = Deferred.makeUnsafe<void, WorkerError>()
         const trackFiber = Fiber.runIn(scope)
-        const services = yield* Effect.services<R>()
+        const services = yield* Effect.context<R>()
         const runFork = Effect.runForkWith(services)
         const onExit = (exit: Exit.Exit<any, E>) => {
           if (exit._tag === "Failure" && !Cause.hasInterruptsOnly(exit.cause)) {
@@ -83,7 +103,7 @@ export const make = (self: MessagePort | Window): WorkerRunner.WorkerRunnerPlatf
                 message: "An messageerror event was emitted",
                 cause: error.data
               })
-            }).asEffect()
+            })
           )
         }
         function onError(error: any) {
@@ -94,7 +114,7 @@ export const make = (self: MessagePort | Window): WorkerRunner.WorkerRunnerPlatf
                 message: "An error event was emitted",
                 cause: error.data
               })
-            }).asEffect()
+            })
           )
         }
         function handlePort(port: MessagePort) {
@@ -151,16 +171,20 @@ export const make = (self: MessagePort | Window): WorkerRunner.WorkerRunnerPlatf
 })
 
 /**
- * @since 1.0.0
- * @category Layers
+ * Layer that provides a browser `WorkerRunnerPlatform` using the global `self` worker context.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layer: Layer.Layer<WorkerRunner.WorkerRunnerPlatform> = Layer.sync(WorkerRunner.WorkerRunnerPlatform)(() =>
   make(self)
 )
 
 /**
- * @since 1.0.0
- * @category Layers
+ * Layer that provides a `WorkerRunnerPlatform` using the supplied `MessagePort` or `Window`.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layerMessagePort = (port: MessagePort | Window): Layer.Layer<WorkerRunner.WorkerRunnerPlatform> =>
   Layer.succeed(WorkerRunner.WorkerRunnerPlatform)(make(port))

package/src/Clipboard.ts

@@ -1,17 +1,35 @@
 /**
- * @since 1.0.0
+ * Browser clipboard service for Effect programs.
+ *
+ * This module wraps the browser `navigator.clipboard` API in a `Clipboard`
+ * service so client-side applications can read, write, and clear clipboard
+ * contents as typed Effects. It is useful for common UI workflows such as copy
+ * buttons, paste/import actions, sharing generated text, and moving rich
+ * clipboard payloads like `Blob`-backed `ClipboardItem`s through an Effect
+ * environment.
+ *
+ * Browser clipboard rules still apply. Clipboard access generally requires a
+ * secure context, and browsers may require a user gesture, permission prompt, or
+ * active focused document before reads or writes are allowed. Support also
+ * varies by operation and payload type: text helpers are the most portable,
+ * while `ClipboardItem` and non-text MIME types may be unavailable or restricted
+ * in some browsers. Failed browser operations are surfaced as `ClipboardError`.
+ *
+ * @since 4.0.0
  */
+import * as Context from "effect/Context"
 import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
-import * as ServiceMap from "effect/ServiceMap"
 
 const TypeId = "~@effect/platform-browser/Clipboard"
 const ErrorTypeId = "~@effect/platform-browser/Clipboard/ClipboardError"
 
 /**
- * @since 1.0.0
- * @category Models
+ * Service interface for reading from, writing to, and clearing the browser clipboard.
+ *
+ * @category models
+ * @since 4.0.0
  */
 export interface Clipboard {
   readonly [TypeId]: typeof TypeId
@@ -24,8 +42,10 @@ export interface Clipboard {
 }
 
 /**
- * @since 1.0.0
- * @category Errors
+ * Tagged error raised when a browser clipboard operation fails.
+ *
+ * @category errors
+ * @since 4.0.0
  */
 export class ClipboardError extends Data.TaggedError("ClipboardError")<{
   readonly message: string
@@ -35,14 +55,18 @@ export class ClipboardError extends Data.TaggedError("ClipboardError")<{
 }
 
 /**
- * @since 1.0.0
- * @category Service
+ * Service tag for the browser `Clipboard` service.
+ *
+ * @category services
+ * @since 4.0.0
  */
-export const Clipboard: ServiceMap.Service<Clipboard, Clipboard> = ServiceMap.Service<Clipboard>(TypeId)
+export const Clipboard: Context.Service<Clipboard, Clipboard> = Context.Service<Clipboard>(TypeId)
 
 /**
- * @since 1.0.0
- * @category Constructors
+ * Builds a `Clipboard` service from primitive read and write operations, deriving `clear` and `writeBlob` helpers.
+ *
+ * @category constructors
+ * @since 4.0.0
  */
 export const make = (
   impl: Omit<Clipboard, "clear" | "writeBlob" | typeof TypeId>
@@ -57,8 +81,8 @@ export const make = (
 /**
  * A layer that directly interfaces with the navigator.clipboard api
  *
- * @since 1.0.0
- * @category Layers
+ * @category layers
+ * @since 4.0.0
  */
 export const layer: Layer.Layer<Clipboard> = Layer.succeed(
   Clipboard,

package/src/Geolocation.ts

@@ -1,20 +1,38 @@
 /**
- * @since 1.0.0
+ * Browser geolocation support for Effect programs.
+ *
+ * This module provides a `Geolocation` service and browser-backed layer for
+ * reading device location through `navigator.geolocation`. Use
+ * `getCurrentPosition` when an application needs one location fix, such as a
+ * nearby-search, check-in, or delivery estimate, and `watchPosition` when it
+ * needs a stream of updates for navigation, tracking, or location-aware UI.
+ *
+ * The implementation is browser-only and relies on the browser permission and
+ * policy model for geolocation. Calls may prompt the user, fail when permission
+ * is denied, time out, or report that position data is unavailable because of
+ * device, browser, privacy, origin, or secure-context restrictions. Watched
+ * positions are scoped so the underlying browser watch is cleared when the
+ * stream is finalized, and slow consumers should account for the sliding
+ * buffer used by `watchPosition`.
+ *
+ * @since 4.0.0
  */
 import * as Cause from "effect/Cause"
+import * as Context from "effect/Context"
 import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
 import * as Queue from "effect/Queue"
-import * as ServiceMap from "effect/ServiceMap"
 import * as Stream from "effect/Stream"
 
 const TypeId = "~@effect/platform-browser/Geolocation"
 const ErrorTypeId = "~@effect/platform-browser/Geolocation/GeolocationError"
 
 /**
- * @since 1.0.0
- * @category Models
+ * Service interface for browser geolocation, providing effects for the current position and streams of watched positions.
+ *
+ * @category models
+ * @since 4.0.0
  */
 export interface Geolocation {
   readonly [TypeId]: typeof TypeId
@@ -31,14 +49,18 @@ export interface Geolocation {
 }
 
 /**
- * @since 1.0.0
- * @category Service
+ * Service tag for the browser `Geolocation` service.
+ *
+ * @category services
+ * @since 4.0.0
  */
-export const Geolocation: ServiceMap.Service<Geolocation, Geolocation> = ServiceMap.Service<Geolocation>(TypeId)
+export const Geolocation: Context.Service<Geolocation, Geolocation> = Context.Service<Geolocation>(TypeId)
 
 /**
- * @since 1.0.0
- * @category Errors
+ * Tagged error wrapping a browser geolocation failure reason.
+ *
+ * @category errors
+ * @since 4.0.0
  */
 export class GeolocationError extends Data.TaggedError("GeolocationError")<{
   readonly reason: GeolocationErrorReason
@@ -60,8 +82,10 @@ export class GeolocationError extends Data.TaggedError("GeolocationError")<{
 }
 
 /**
- * @since 1.0.0
- * @category Errors
+ * Error reason for the browser geolocation `POSITION_UNAVAILABLE` failure.
+ *
+ * @category errors
+ * @since 4.0.0
  */
 export class PositionUnavailable extends Data.TaggedError("PositionUnavailable")<{
   readonly cause: unknown
@@ -72,8 +96,10 @@ export class PositionUnavailable extends Data.TaggedError("PositionUnavailable")
 }
 
 /**
- * @since 1.0.0
- * @category Errors
+ * Error reason for the browser geolocation `PERMISSION_DENIED` failure.
+ *
+ * @category errors
+ * @since 4.0.0
  */
 export class PermissionDenied extends Data.TaggedError("PermissionDenied")<{
   readonly cause: unknown
@@ -84,8 +110,10 @@ export class PermissionDenied extends Data.TaggedError("PermissionDenied")<{
 }
 
 /**
- * @since 1.0.0
- * @category Errors
+ * Error reason for the browser geolocation `TIMEOUT` failure.
+ *
+ * @category errors
+ * @since 4.0.0
  */
 export class Timeout extends Data.TaggedError("Timeout")<{
   readonly cause: unknown
@@ -96,8 +124,10 @@ export class Timeout extends Data.TaggedError("Timeout")<{
 }
 
 /**
- * @since 1.0.0
- * @category Errors
+ * Union of browser geolocation error reasons represented by the service.
+ *
+ * @category errors
+ * @since 4.0.0
  */
 export type GeolocationErrorReason = PositionUnavailable | PermissionDenied | Timeout
 
@@ -141,8 +171,10 @@ const makeQueue = (
   )
 
 /**
- * @since 1.0.0
- * @category Layers
+ * Layer that provides `Geolocation` using `navigator.geolocation`, with watched positions buffered in a sliding queue.
+ *
+ * @category layers
+ * @since 4.0.0
  */
 export const layer: Layer.Layer<Geolocation> = Layer.succeed(
   Geolocation,
@@ -162,8 +194,10 @@ export const layer: Layer.Layer<Geolocation> = Layer.succeed(
 )
 
 /**
- * @since 1.0.0
+ * Streams positions from the `Geolocation` service using `watchPosition`, with an optional sliding buffer size.
+ *
  * @category Accessors
+ * @since 4.0.0
  */
 export const watchPosition = (
   options?:

package/src/IndexedDb.ts

@@ -0,0 +1,115 @@
+/**
+ * Browser IndexedDB primitives and key schemas for Effect applications.
+ *
+ * This module is the low-level bridge used by the platform-browser IndexedDB
+ * integration. It provides an `IndexedDb` service around the browser
+ * `indexedDB` factory and `IDBKeyRange` constructor, a `layerWindow` layer for
+ * wiring those primitives from `window`, and schemas for the key shapes accepted
+ * by IndexedDB object stores and indexes.
+ *
+ * Use it when building typed local persistence for browser caches,
+ * offline-first state, background queues, drafts, or other client-side data
+ * that should be validated before it reaches IndexedDB. Higher-level database,
+ * version, table, and query modules build on these primitives for migrations
+ * and typed transactions.
+ *
+ * IndexedDB still follows the browser rules: schema changes happen only during
+ * version upgrades, upgrades may be blocked by other open tabs or connections,
+ * and reads or writes must run in transactions scoped to the object stores they
+ * touch. The `layerWindow` constructor should be used only where browser
+ * globals are available, and code that also runs during SSR or in restricted
+ * browser contexts should account for `indexedDB` or `IDBKeyRange` being
+ * missing.
+ *
+ * @since 4.0.0
+ */
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Schema from "effect/Schema"
+
+const TypeId = "~@effect/platform-browser/IndexedDb"
+
+/**
+ * Service interface that provides the browser `indexedDB` factory and `IDBKeyRange` constructor.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface IndexedDb {
+  readonly [TypeId]: typeof TypeId
+  readonly indexedDB: globalThis.IDBFactory
+  readonly IDBKeyRange: typeof globalThis.IDBKeyRange
+}
+
+/**
+ * Service tag for browser IndexedDB primitives.
+ *
+ * @category tag
+ * @since 4.0.0
+ */
+export const IndexedDb: Context.Service<IndexedDb, IndexedDb> = Context.Service<IndexedDb, IndexedDb>(TypeId)
+
+/** @internal */
+const IDBFlatKey = Schema.Union([
+  Schema.String,
+  Schema.Number.check(Schema.makeFilter((input) => !Number.isNaN(input))),
+  Schema.DateValid,
+  Schema.declare(
+    (input): input is BufferSource =>
+      input instanceof ArrayBuffer ||
+      (ArrayBuffer.isView(input) && input.buffer instanceof ArrayBuffer)
+  )
+])
+
+/**
+ * Schema for IndexedDB keys: strings, non-NaN numbers, valid dates, buffer sources, or arrays of those flat key values.
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const IDBValidKey = Schema.Union([IDBFlatKey, Schema.Array(IDBFlatKey)])
+
+/**
+ * Schema for auto-incremented IndexedDB keys, accepting integers from 1 through `2 ** 53`.
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const AutoIncrement = Schema.Int.check(
+  Schema.isBetween({ minimum: 1, maximum: 2 ** 53 })
+).annotate({
+  identifier: "AutoIncrement",
+  title: "autoIncrement",
+  description: "Defines a valid autoIncrement key path for the IndexedDb table"
+})
+
+/**
+ * Creates an `IndexedDb` service from an `IDBFactory` and `IDBKeyRange` constructor.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const make = (impl: Omit<IndexedDb, typeof TypeId>): IndexedDb => IndexedDb.of({ [TypeId]: TypeId, ...impl })
+
+/**
+ * Layer that provides `IndexedDb` from `window.indexedDB` and `window.IDBKeyRange`, failing with a config error when they are unavailable.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const layerWindow: Layer.Layer<IndexedDb> = Layer.effect(
+  IndexedDb,
+  Effect.suspend(() => {
+    if (window.indexedDB && window.IDBKeyRange) {
+      return Effect.succeed(
+        make({
+          indexedDB: window.indexedDB,
+          IDBKeyRange: window.IDBKeyRange
+        })
+      )
+    } else {
+      return Effect.die(new Error("window.indexedDB is not available"))
+    }
+  })
+)