effect 4.0.0-beta.99 → 4.0.0-rc.109

package/src/unstable/schema/VariantSchema.ts

@@ -11,10 +11,10 @@
 import type { Brand } from "../../Brand.ts"
 import * as Effect from "../../Effect.ts"
 import { dual } from "../../Function.ts"
+import * as InternalRecord from "../../internal/record.ts"
 import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
-import type * as SchemaAST from "../../SchemaAST.ts"
 import * as Struct_ from "../../Struct.ts"
 
 /**
@@ -26,6 +26,7 @@ import * as Struct_ from "../../Struct.ts"
 export const TypeId = "~effect/schema/VariantSchema"
 
 const cacheSymbol = Symbol.for(`${TypeId}/cache`)
+const defaultCacheSymbol = Symbol.for(`${TypeId}/defaultCache`)
 
 /**
  * Pipeable container of schema fields that can be extracted into per-variant
@@ -38,6 +39,8 @@ export interface Struct<in out A extends Field.Fields> extends Pipeable {
   readonly [TypeId]: A
   /** @internal */
   [cacheSymbol]?: Record<string, Schema.Top>
+  /** @internal */
+  [defaultCacheSymbol]?: Record<string, Schema.Top>
 }
 
 /**
@@ -87,7 +90,7 @@ export declare namespace Struct {
   export type Validate<A, Variant extends string> = {
     readonly [K in keyof A]: A[K] extends { readonly [TypeId]: infer _ } ? Validate<A[K], Variant> :
       A[K] extends Field<infer Config> ? [keyof Config] extends [Variant] ? {} : "field must have valid variants"
-      : {}
+      : unknown
   }
 }
 
@@ -144,7 +147,7 @@ export declare namespace Field {
    * @since 4.0.0
    */
   export type ConfigWithKeys<K extends string> = {
-    readonly [P in K]?: Schema.Top
+    readonly [P in K]?: Schema.Top | undefined
   }
 
   /**
@@ -167,7 +170,7 @@ export declare namespace Field {
  * Computes the `Schema.Struct` field map for a variant by selecting matching
  * field schemas and recursively extracting nested structs.
  *
- * @category extractors
+ * @category utility types
  * @since 4.0.0
  */
 export type ExtractFields<V extends string, Fields extends Struct.Fields, IsDefault = false> = {
@@ -186,7 +189,7 @@ export type ExtractFields<V extends string, Fields extends Struct.Fields, IsDefa
  * Computes the schema type produced by extracting a single variant from a variant
  * schema struct.
  *
- * @category extractors
+ * @category utility types
  * @since 4.0.0
  */
 export type Extract<V extends string, A extends Struct<any>, IsDefault = false> = [A] extends [
@@ -214,29 +217,38 @@ const extract: {
       readonly isDefault?: boolean | undefined
     }
   ): Extract<V, A> => {
-    const cache = self[cacheSymbol] ?? (self[cacheSymbol] = {})
-    const cacheKey = options?.isDefault === true ? "__default" : variant
-    if (cache[cacheKey] !== undefined) {
-      return cache[cacheKey] as any
+    const cache = options?.isDefault === true
+      ? self[defaultCacheSymbol] ?? (self[defaultCacheSymbol] = Object.create(null))
+      : self[cacheSymbol] ?? (self[cacheSymbol] = Object.create(null))
+    if (Object.hasOwn(cache, variant)) {
+      return cache[variant] as any
     }
     const fields: Record<string, any> = {}
     for (const key of Object.keys(self[TypeId])) {
       const value = self[TypeId][key]
+      if (value === undefined) {
+        continue
+      }
       if (TypeId in value) {
         if (options?.isDefault === true && Schema.isSchema(value)) {
-          fields[key] = value
+          InternalRecord.assignProperty(fields, key, value)
         } else {
-          fields[key] = extract(value, variant)
+          InternalRecord.assignProperty(fields, key, extract(value, variant))
         }
       } else if (FieldTypeId in value) {
-        if (variant in value.schemas) {
-          fields[key] = value.schemas[variant]
+        if (Object.hasOwn(value.schemas, variant)) {
+          const schema = value.schemas[variant]
+          if (schema !== undefined) {
+            InternalRecord.assignProperty(fields, key, schema)
+          }
         }
       } else {
-        fields[key] = value
+        InternalRecord.assignProperty(fields, key, value)
       }
     }
-    return cache[cacheKey] = Schema.Struct(fields) as any
+    const schema = Schema.Struct(fields)
+    cache[variant] = schema
+    return schema as any
   }
 )
 
@@ -261,19 +273,7 @@ export interface Class<
   S extends Schema.Top & {
     readonly fields: Schema.Struct.Fields
   }
-> extends
-  Schema.BottomLazy<
-    SchemaAST.Declaration,
-    Schema.decodeTo<Schema.declareConstructor<Self, S["Encoded"], readonly [S], S["Iso"]>, S>,
-    readonly [S],
-    S["~type.mutability"],
-    S["~type.optionality"],
-    S["~type.constructor.default"],
-    S["~encoded.mutability"],
-    S["~encoded.optionality"]
-  >,
-  Struct<Struct_.Simplify<Fields>>
-{
+> extends Schema.Class<Self, S, {}>, Struct<Struct_.Simplify<Fields>> {
   readonly "Type": Self
   readonly "Encoded": S["Encoded"]
   readonly "DecodingServices": S["DecodingServices"]
@@ -306,12 +306,13 @@ type MissingSelfGeneric<Params extends string = ""> =
  * @category models
  * @since 4.0.0
  */
-export interface Union<Members extends ReadonlyArray<Struct<any>>> extends
-  Schema.Union<
-    {
-      readonly [K in keyof Members]: [Members[K]] extends [Schema.Top] ? Members[K] : never
-    }
-  >
+export interface Union<Members extends ReadonlyArray<Struct<any>>, Default extends string = string>
+  extends
+    Schema.Union<
+      {
+        readonly [K in keyof Members]: Extract<Default, Members[K], true>
+      }
+    >
 {}
 
 /**
@@ -420,7 +421,7 @@ export const make = <
       }
   readonly Union: <const Members extends ReadonlyArray<Struct<any>>>(
     members: Members
-  ) => Union<Members> & Union.Variants<Members, Variants[number]>
+  ) => Union<Members, Default> & Union.Variants<Members, Variants[number]>
   readonly extract: {
     <V extends Variants[number]>(
       variant: V
@@ -462,7 +463,7 @@ export const make = <
     return function<S extends Schema.Top>(schema: S) {
       const obj: Record<string, S> = {}
       for (const key of keys) {
-        obj[key] = schema
+        InternalRecord.assignProperty(obj, key, schema)
       }
       return Field(obj)
     }
@@ -472,14 +473,14 @@ export const make = <
       const obj: Record<string, S> = {}
       for (const variant of options.variants) {
         if (!keys.includes(variant)) {
-          obj[variant] = schema
+          InternalRecord.assignProperty(obj, variant, schema)
         }
       }
       return Field(obj)
     }
   }
   function UnionVariants(members: ReadonlyArray<Struct<any>>) {
-    return Union(members, options.variants)
+    return Union(members, options.defaultVariant, options.variants)
   }
   const fieldEvolve = dual(
     2,
@@ -516,7 +517,7 @@ export const make = <
 /**
  * Marks a value as an explicit override for an `Overrideable` schema default.
  *
- * @category overrideable
+ * @category constructors
  * @since 4.0.0
  */
 export const Override = <A>(value: A): A & Brand<"Override"> => value as any
@@ -525,7 +526,7 @@ export const Override = <A>(value: A): A & Brand<"Override"> => value as any
  * Schema type whose constructor can use an effectful default unless a value is
  * explicitly branded with `Override`.
  *
- * @category overrideable
+ * @category schemas
  * @since 4.0.0
  */
 export interface Overrideable<S extends Schema.Top & Schema.WithoutConstructorDefault> extends
@@ -553,7 +554,7 @@ export interface Overrideable<S extends Schema.Top & Schema.WithoutConstructorDe
  * Wraps a schema with an effectful constructor default while allowing explicit
  * values to be marked with `Override`.
  *
- * @category overrideable
+ * @category schemas
  * @since 4.0.0
  */
 export const Overrideable = <S extends Schema.Top & Schema.WithoutConstructorDefault>(
@@ -592,11 +593,18 @@ const Field = <const A extends Field.Config>(schemas: A): Field<A> => {
   return self
 }
 
-const Union = <Members extends ReadonlyArray<Struct<any>>, Variants extends ReadonlyArray<string>>(
+const Union = <
+  Members extends ReadonlyArray<Struct<any>>,
+  Default extends string,
+  Variants extends ReadonlyArray<string>
+>(
   members: Members,
+  defaultVariant: Default,
   variants: Variants
 ) => {
-  const VariantUnion = Schema.Union(members.filter((member) => Schema.isSchema(member))) as any
+  const VariantUnion = Schema.Union(
+    members.map((member) => Schema.isSchema(member) ? member : extract(member, defaultVariant, { isDefault: true }))
+  ) as any
   for (const variant of variants) {
     Object.defineProperty(VariantUnion, variant, {
       value: Schema.Union(members.map((member) => extract(member, variant)))

package/src/unstable/socket/Socket.ts

@@ -185,7 +185,7 @@ export class CloseEvent {
 /**
  * Returns `true` when a value is a `CloseEvent`.
  *
- * @category refinements
+ * @category guards
  * @since 4.0.0
  */
 export const isCloseEvent = (u: unknown): u is CloseEvent => Predicate.hasProperty(u, CloseEventTypeId)
@@ -209,7 +209,7 @@ export const SocketErrorTypeId: SocketErrorTypeId = "~effect/socket/Socket/Socke
 /**
  * Returns `true` when a value is a `SocketError`.
  *
- * @category refinements
+ * @category guards
  * @since 4.0.0
  */
 export const isSocketError = (u: unknown): u is SocketError => Predicate.hasProperty(u, SocketErrorTypeId)
@@ -220,7 +220,7 @@ export const isSocketError = (u: unknown): u is SocketError => Predicate.hasProp
  * @category errors
  * @since 4.0.0
  */
-export class SocketReadError extends Schema.ErrorClass<SocketReadError>("effect/socket/Socket/SocketReadError")({
+export class SocketReadError extends Schema.Error<SocketReadError>("effect/socket/Socket/SocketReadError")({
   _tag: Schema.tag("SocketReadError"),
   cause: Schema.Defect()
 }) {
@@ -238,7 +238,7 @@ export class SocketReadError extends Schema.ErrorClass<SocketReadError>("effect/
  * @category errors
  * @since 4.0.0
  */
-export class SocketWriteError extends Schema.ErrorClass<SocketWriteError>("effect/socket/Socket/SocketWriteError")({
+export class SocketWriteError extends Schema.Error<SocketWriteError>("effect/socket/Socket/SocketWriteError")({
   _tag: Schema.tag("SocketWriteError"),
   cause: Schema.Defect()
 }) {
@@ -257,7 +257,7 @@ export class SocketWriteError extends Schema.ErrorClass<SocketWriteError>("effec
  * @category errors
  * @since 4.0.0
  */
-export class SocketOpenError extends Schema.ErrorClass<SocketOpenError>("effect/socket/Socket/SocketOpenError")({
+export class SocketOpenError extends Schema.Error<SocketOpenError>("effect/socket/Socket/SocketOpenError")({
   _tag: Schema.tag("SocketOpenError"),
   kind: Schema.Literals(["Unknown", "Timeout"]),
   cause: Schema.Defect()
@@ -281,9 +281,9 @@ export class SocketOpenError extends Schema.ErrorClass<SocketOpenError>("effect/
  * @category errors
  * @since 4.0.0
  */
-export class SocketCloseError extends Schema.ErrorClass<SocketCloseError>("effect/socket/Socket/SocketCloseError")({
+export class SocketCloseError extends Schema.Error<SocketCloseError>("effect/socket/Socket/SocketCloseError")({
   _tag: Schema.tag("SocketCloseError"),
-  code: Schema.Number,
+  code: Schema.Int,
   closeReason: Schema.optional(Schema.String)
 }) {
   /**
@@ -339,7 +339,7 @@ export type SocketErrorReason =
  * @category errors
  * @since 4.0.0
  */
-export class SocketError extends Schema.TaggedErrorClass<SocketError>(SocketErrorTypeId)("SocketError", {
+export class SocketError extends Schema.TaggedError<SocketError>(SocketErrorTypeId)("SocketError", {
   _tag: Schema.tag("SocketError"),
   reason: SocketErrorReason
 }) {
@@ -619,10 +619,19 @@ export const fromWebSocket = <RO>(
   options?: {
     readonly closeCodeIsError?: ((code: number) => boolean) | undefined
     readonly openTimeout?: Duration.Input | undefined
+    /**
+     * Replays buffered events on the first run after the socket opens and before
+     * the run's `onOpen` effect.
+     *
+     * @category options
+     * @since 4.0.0
+     */
+    readonly onInitialRun?: ((ws: globalThis.WebSocket) => ReadonlyArray<MessageEvent>) | undefined
   } | undefined
 ): Effect.Effect<Socket, never, Exclude<RO, Scope.Scope>> =>
   Effect.withFiber((fiber) => {
     let currentWS: globalThis.WebSocket | undefined
+    let initial = true
     const latch = Latch.makeUnsafe(false)
     const acquireContext = fiber.context as Context.Context<RO>
     const closeCodeIsError = options?.closeCodeIsError ?? defaultCloseCodeIsError
@@ -649,7 +658,7 @@ export const fromWebSocket = <RO>(
             )
             return run(effect)
           }
-          const result = handler(event.data)
+          const result = handler(event.data instanceof ArrayBuffer ? new Uint8Array(event.data) : event.data)
           if (Effect.isEffect(result)) {
             run(result)
           }
@@ -719,6 +728,10 @@ export const fromWebSocket = <RO>(
         open = true
         currentWS = ws
         latch.openUnsafe()
+        if (initial && options?.onInitialRun) {
+          initial = false
+          for (const event of options.onInitialRun(ws)) onMessage(event)
+        }
         if (opts?.onOpen) yield* opts.onOpen
         return yield* Effect.catchFilter(
           FiberSet.join(fiberSet),
@@ -734,14 +747,21 @@ export const fromWebSocket = <RO>(
       )
 
     const write = (chunk: Uint8Array | string | CloseEvent) =>
-      latch.whenOpen(Effect.sync(() => {
-        const ws = currentWS!
-        if (isCloseEvent(chunk)) {
-          ws.close(chunk.code, chunk.reason)
-        } else {
-          ws.send(chunk as string | Uint8Array<ArrayBuffer>)
-        }
-      }))
+      latch.whenOpen(
+        Effect.suspend(() => {
+          try {
+            const ws = currentWS!
+            if (isCloseEvent(chunk)) {
+              ws.close(chunk.code, chunk.reason)
+            } else {
+              ws.send(chunk as string | Uint8Array<ArrayBuffer>)
+            }
+            return Effect.void
+          } catch (cause) {
+            return Effect.fail(new SocketError({ reason: new SocketWriteError({ cause }) }))
+          }
+        })
+      )
     const writer = Effect.succeed(write)
 
     return Effect.succeed(make({
@@ -794,7 +814,7 @@ export const layerWebSocket: (
 /**
  * Context reference for socket send queue capacity, defaulting to `16`.
  *
- * @category fiber refs
+ * @category services
  * @since 4.0.0
  */
 export const SendQueueCapacity = Context.Reference<number>("~effect/socket/Socket/SendQueueCapacity", {
@@ -904,7 +924,10 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
             })
           )
         }
-        return Effect.promise(() => getWriter(stream).write(typeof chunk === "string" ? encoder.encode(chunk) : chunk))
+        return Effect.tryPromise({
+          try: () => getWriter(stream).write(typeof chunk === "string" ? encoder.encode(chunk) : chunk),
+          catch: (cause) => new SocketError({ reason: new SocketWriteError({ cause }) })
+        })
       }))
     const writer = Effect.acquireRelease(
       Effect.succeed(write),

package/src/unstable/sql/Migrator.ts

@@ -15,6 +15,7 @@ import { FileSystem } from "../../FileSystem.ts"
 import { pipe } from "../../Function.ts"
 import * as Option from "../../Option.ts"
 import * as Order from "../../Order.ts"
+import { Path } from "../../Path.ts"
 import * as Client from "./SqlClient.ts"
 import type { SqlError } from "./SqlError.ts"
 
@@ -400,11 +401,19 @@ export const fromRecord = (migrations: Record<string, Effect.Effect<void, unknow
  * files named `<id>_<name>.js`, `<id>_<name>.ts`,
  * `<id>_<name>.mjs`, or `<id>_<name>.mts`, and sorts migrations by id.
  *
+ * **Details**
+ *
+ * Requires a `Path` service appropriate for the migration directory's path
+ * syntax. On Windows, prefer a platform-aware implementation such as
+ * `NodePath.layer`; the core `Path.layer` uses POSIX semantics and does not
+ * preserve Windows drive-letter paths.
+ *
  * @category loaders
  * @since 4.0.0
  */
-export const fromFileSystem: (directory: string) => Loader<FileSystem> = Effect.fnUntraced(function*(directory) {
+export const fromFileSystem: (directory: string) => Loader<FileSystem | Path> = Effect.fnUntraced(function*(directory) {
   const Fs = yield* FileSystem
+  const path = yield* Path
   const files = yield* Effect.mapError(
     Fs.readDirectory(directory),
     (cause) =>
@@ -424,14 +433,18 @@ export const fromFileSystem: (directory: string) => Loader<FileSystem> = Effect.
             [
               Number(id),
               name,
-              Effect.promise(
-                () =>
-                  import(
-                    /* @vite-ignore */
-                    /* webpackIgnore: true */
-                    `${directory}/${basename}`
-                  )
-              )
+              // `import` needs a file URL: on Windows an absolute path such as
+              // `D:\migrations\1_init.ts` is rejected by the ESM loader. `orDie` keeps the
+              // failure a defect so `loadMigration` reports it as an import error.
+              Effect.flatMap(Effect.orDie(path.toFileUrl(path.join(directory, basename))), (url) =>
+                Effect.promise(
+                  () =>
+                    import(
+                      /* @vite-ignore */
+                      /* webpackIgnore: true */
+                      url.href
+                    )
+                ))
             ]
           ] as const
       })

package/src/unstable/sql/SqlClient.ts

@@ -12,10 +12,12 @@ import { Clock } from "../../Clock.ts"
 import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
+import { identity } from "../../Function.ts"
 import * as Option from "../../Option.ts"
 import type * as Queue from "../../Queue.ts"
 import type { ReadonlyRecord } from "../../Record.ts"
 import * as Scope from "../../Scope.ts"
+import * as Semaphore from "../../Semaphore.ts"
 import * as Stream from "../../Stream.ts"
 import * as Tracer from "../../Tracer.ts"
 import type { NoInfer } from "../../Types.ts"
@@ -126,6 +128,7 @@ export declare namespace SqlClient {
 }
 
 let clientIdCounter = 0
+let transactionSemaphoreIdCounter = 0
 
 /**
  * Constructs a `SqlClient` from connection acquirers, a compiler, transaction
@@ -227,67 +230,75 @@ export const makeWithTransaction = <I, S>(options: {
   readonly commit: (conn: NoInfer<S>) => Effect.Effect<void, SqlError>
   readonly rollback: (conn: NoInfer<S>) => Effect.Effect<void, SqlError>
   readonly rollbackSavepoint: (conn: NoInfer<S>, id: number) => Effect.Effect<void, SqlError>
-}) =>
-<R, E, A>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E | SqlError, R> => {
-  return Effect.uninterruptibleMask((restore) =>
-    Effect.useSpan(
-      "sql.transaction",
-      { kind: "client" },
-      (span) =>
-        Effect.withFiber<A, E | SqlError, R>((fiber) => {
-          for (const [key, value] of options.spanAttributes) {
-            span.attribute(key, value)
-          }
-          const services = fiber.context
-          const clock = fiber.getRef(Clock)
-          const connOption = Context.getOption(services, options.transactionService)
-          const conn = connOption._tag === "Some"
-            ? Effect.succeed([undefined, connOption.value[0]] as const)
-            : options.acquireConnection
-          const id = connOption._tag === "Some" ? connOption.value[1] + 1 : 0
-          return Effect.flatMap(
-            conn,
-            (
-              [scope, conn]
-            ) =>
-              (id === 0 ? options.begin(conn) : options.savepoint(conn, id)).pipe(
-                Effect.flatMap(() =>
-                  Effect.provideContext(
-                    restore(effect),
-                    Context.mutate(services, (services) =>
-                      services.pipe(
-                        Context.add(options.transactionService, [conn, id]),
-                        Context.add(Tracer.ParentSpan, span)
-                      ))
-                  )
-                ),
-                Effect.exit,
-                Effect.flatMap((exit) => {
-                  let effect: Effect.Effect<void>
-                  if (Exit.isSuccess(exit)) {
-                    if (id === 0) {
-                      span.event("db.transaction.commit", clock.currentTimeNanosUnsafe())
-                      effect = Effect.orDie(options.commit(conn))
-                    } else {
-                      span.event("db.transaction.savepoint", clock.currentTimeNanosUnsafe())
-                      effect = Effect.void
-                    }
-                  } else {
-                    span.event("db.transaction.rollback", clock.currentTimeNanosUnsafe())
-                    effect = Effect.orDie(
-                      id > 0
-                        ? options.rollbackSavepoint(conn, id)
-                        : options.rollback(conn)
+}) => {
+  const transactionSemaphore = Context.Service<Semaphore.Semaphore>(
+    `effect/sql/SqlClient/TransactionSemaphore/${transactionSemaphoreIdCounter++}`
+  )
+  return <R, E, A>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E | SqlError, R> =>
+    Effect.uninterruptibleMask((restore) =>
+      Effect.useSpan(
+        "sql.transaction",
+        { kind: "client" },
+        (span) =>
+          Effect.withFiber<A, E | SqlError, R>((fiber) => {
+            for (const [key, value] of options.spanAttributes) {
+              span.attribute(key, value)
+            }
+            const services = fiber.context
+            const clock = fiber.getRef(Clock)
+            const connOption = Context.getOption(services, options.transactionService)
+            const conn = connOption._tag === "Some"
+              ? Effect.succeed([undefined, connOption.value[0]] as const)
+              : options.acquireConnection
+            const id = connOption._tag === "Some" ? connOption.value[1] + 1 : 0
+            const transaction = Effect.flatMap(
+              conn,
+              (
+                [scope, conn]
+              ) =>
+                (id === 0 ? options.begin(conn) : options.savepoint(conn, id)).pipe(
+                  Effect.flatMap(() =>
+                    Effect.onExitPrimitive(
+                      Effect.provideContext(
+                        restore(effect),
+                        services.pipe(
+                          Context.add(options.transactionService, [conn, id]),
+                          Context.add(transactionSemaphore, Semaphore.makeUnsafe(1)),
+                          Context.add(Tracer.ParentSpan, span)
+                        )
+                      ),
+                      (exit) => {
+                        let effect: Effect.Effect<void>
+                        if (Exit.isSuccess(exit)) {
+                          if (id === 0) {
+                            span.event("db.transaction.commit", clock.currentTimeNanosUnsafe())
+                            effect = Effect.orDie(options.commit(conn))
+                          } else {
+                            span.event("db.transaction.savepoint", clock.currentTimeNanosUnsafe())
+                            effect = Effect.void
+                          }
+                        } else {
+                          span.event("db.transaction.rollback", clock.currentTimeNanosUnsafe())
+                          effect = Effect.orDie(
+                            id > 0
+                              ? options.rollbackSavepoint(conn, id)
+                              : options.rollback(conn)
+                          )
+                        }
+                        return Effect.flatMap(effect, () => exit)
+                      },
+                      true
                     )
-                  }
-                  const withScope = scope !== undefined ? Effect.ensuring(effect, Scope.close(scope, exit)) : effect
-                  return Effect.flatMap(withScope, () => exit)
-                })
-              )
-          )
-        })
+                  ),
+                  scope ? (eff) => Effect.onExitPrimitive(eff, (exit) => Scope.close(scope, exit), true) : identity
+                )
+            )
+            return id === 0
+              ? transaction
+              : Context.getUnsafe(services, transactionSemaphore).withPermit(transaction)
+          })
+      )
     )
-  )
 }
 
 /**
@@ -333,7 +344,7 @@ export const TransactionConnection = (
  * Context reference used by SQL integrations to opt in to safe integer
  * handling; defaults to `false`.
  *
- * @category references
+ * @category services
  * @since 4.0.0
  */
 export const SafeIntegers = Context.Reference<boolean>("effect/sql/SqlClient/SafeIntegers", {