effect 4.0.0-beta.101 → 4.0.0-beta.103

package/src/unstable/persistence/KeyValueStore.ts

@@ -355,7 +355,12 @@ export const layerMemory: Layer.Layer<KeyValueStore> = Layer.sync(KeyValueStore)
  *
  * **Details**
  *
- * The directory is created if needed, and each key is encoded as a file name.
+ * The directory is created if needed, and each key is percent-encoded as a
+ * single file name. Empty keys, `.` and `..` are rejected. Keys are only
+ * guaranteed to be distinct on case-sensitive file systems.
+ *
+ * `clear` removes the directory recursively, so it must not be shared with
+ * unrelated data.
  *
  * @category layers
  * @since 4.0.0
@@ -366,7 +371,20 @@ export const layerFileSystem = (
   Layer.effect(KeyValueStore)(Effect.gen(function*() {
     const fs = yield* FileSystem.FileSystem
     const path = yield* Path.Path
-    const keyPath = (key: string) => path.join(directory, encodeURIComponent(key))
+    const withKeyPath = <A>(
+      method: string,
+      key: string,
+      f: (path: string) => Effect.Effect<A, KeyValueStoreError>
+    ): Effect.Effect<A, KeyValueStoreError> =>
+      key.length === 0 || key === "." || key === ".."
+        ? Effect.fail(
+          new KeyValueStoreError({
+            method,
+            key,
+            message: `Invalid key ${key}`
+          })
+        )
+        : f(path.join(directory, encodeURIComponent(key)))
 
     if (!(yield* fs.exists(directory))) {
       yield* fs.makeDirectory(directory, { recursive: true })
@@ -374,60 +392,65 @@ export const layerFileSystem = (
 
     return make({
       get: (key: string) =>
-        Effect.catchTag(
-          fs.readFileString(keyPath(key)),
-          "PlatformError",
-          (cause) =>
-            cause.reason._tag === "NotFound" ? Effect.undefined : Effect.fail(
-              new KeyValueStoreError({
-                method: "get",
-                key,
-                message: `Unable to get item with key ${key}`,
-                cause
-              })
-            )
-        ),
+        withKeyPath("get", key, (path) =>
+          Effect.catchTag(
+            fs.readFileString(path),
+            "PlatformError",
+            (cause) =>
+              cause.reason._tag === "NotFound" ? Effect.undefined : Effect.fail(
+                new KeyValueStoreError({
+                  method: "get",
+                  key,
+                  message: `Unable to get item with key ${key}`,
+                  cause
+                })
+              )
+          )),
       getUint8Array: (key: string) =>
-        Effect.catchTag(
-          fs.readFile(keyPath(key)),
-          "PlatformError",
-          (cause) =>
-            cause.reason._tag === "NotFound" ? Effect.undefined : Effect.fail(
+        withKeyPath("getUint8Array", key, (path) =>
+          Effect.catchTag(
+            fs.readFile(path),
+            "PlatformError",
+            (cause) =>
+              cause.reason._tag === "NotFound" ? Effect.undefined : Effect.fail(
+                new KeyValueStoreError({
+                  method: "getUint8Array",
+                  key,
+                  message: `Unable to get item with key ${key}`,
+                  cause
+                })
+              )
+          )),
+      set: (key: string, value: string | Uint8Array) =>
+        withKeyPath("set", key, (path) =>
+          Effect.mapError(
+            typeof value === "string" ? fs.writeFileString(path, value) : fs.writeFile(path, value),
+            (cause) =>
               new KeyValueStoreError({
-                method: "getUint8Array",
+                method: "set",
                 key,
-                message: `Unable to get item with key ${key}`,
+                message: `Unable to set item with key ${key}`,
                 cause
               })
-            )
-        ),
-      set: (key: string, value: string | Uint8Array) =>
-        Effect.mapError(
-          typeof value === "string" ? fs.writeFileString(keyPath(key), value) : fs.writeFile(keyPath(key), value),
-          (cause) =>
+          )),
+      remove: (key: string) =>
+        withKeyPath("remove", key, (path) =>
+          Effect.mapError(fs.remove(path), (cause) =>
             new KeyValueStoreError({
-              method: "set",
+              method: "remove",
               key,
-              message: `Unable to set item with key ${key}`,
+              message: `Unable to remove item with key ${key}`,
               cause
-            })
-        ),
-      remove: (key: string) =>
-        Effect.mapError(fs.remove(keyPath(key)), (cause) =>
-          new KeyValueStoreError({
-            method: "remove",
-            key,
-            message: `Unable to remove item with key ${key}`,
-            cause
-          })),
+            }))),
       has: (key: string) =>
-        Effect.mapError(fs.exists(keyPath(key)), (cause) =>
-          new KeyValueStoreError({
-            method: "has",
-            key,
-            message: `Unable to check existence of item with key ${key}`,
-            cause
-          })),
+        withKeyPath("has", key, (path) =>
+          Effect.mapError(fs.exists(path), (cause) =>
+            new KeyValueStoreError({
+              method: "has",
+              key,
+              message: `Unable to check existence of item with key ${key}`,
+              cause
+            }))),
       clear: Effect.mapError(
         Effect.andThen(
           fs.remove(directory, { recursive: true }),
@@ -692,7 +715,7 @@ const SchemaStoreTypeId = "~effect/persistence/KeyValueStore/SchemaStore" as con
 /**
  * Schema-aware view of a `KeyValueStore` that stores values as encoded JSON.
  *
- * @category SchemaStore
+ * @category models
  * @since 4.0.0
  */
 export interface SchemaStore<S extends Schema.Constraint> {
@@ -753,7 +776,7 @@ export interface SchemaStore<S extends Schema.Constraint> {
 /**
  * Adapts a `KeyValueStore` into a `SchemaStore` using the schema's JSON codec.
  *
- * @category SchemaStore
+ * @category converting
  * @since 4.0.0
  */
 export const toSchemaStore = <S extends Schema.Constraint>(self: KeyValueStore, schema: S): SchemaStore<S> => {

package/src/unstable/persistence/Persistable.ts

@@ -10,6 +10,7 @@
 import type * as Duration from "../../Duration.ts"
 import type * as Effect from "../../Effect.ts"
 import type * as Exit from "../../Exit.ts"
+import * as InternalRecord from "../../internal/record.ts"
 import * as PrimaryKey from "../../PrimaryKey.ts"
 import * as Request from "../../Request.ts"
 import * as Schema from "../../Schema.ts"
@@ -55,7 +56,7 @@ export type Any = Persistable<Schema.Constraint, Schema.Constraint>
 /**
  * Extracts the success schema from a persistable request.
  *
- * @category models
+ * @category utility types
  * @since 4.0.0
  */
 export type SuccessSchema<A extends Any> = A["~effect/persistence/Persistable"]["success"]
@@ -63,7 +64,7 @@ export type SuccessSchema<A extends Any> = A["~effect/persistence/Persistable"][
 /**
  * Extracts the success value type from a persistable request.
  *
- * @category models
+ * @category utility types
  * @since 4.0.0
  */
 export type Success<A extends Any> = A["~effect/persistence/Persistable"]["success"]["Type"]
@@ -71,7 +72,7 @@ export type Success<A extends Any> = A["~effect/persistence/Persistable"]["succe
 /**
  * Extracts the error schema from a persistable request.
  *
- * @category models
+ * @category utility types
  * @since 4.0.0
  */
 export type ErrorSchema<A extends Any> = A["~effect/persistence/Persistable"]["error"]
@@ -79,7 +80,7 @@ export type ErrorSchema<A extends Any> = A["~effect/persistence/Persistable"]["e
 /**
  * Extracts the error value type from a persistable request.
  *
- * @category models
+ * @category utility types
  * @since 4.0.0
  */
 export type Error<A extends Any> = A["~effect/persistence/Persistable"]["error"]["Type"]
@@ -88,7 +89,7 @@ export type Error<A extends Any> = A["~effect/persistence/Persistable"]["error"]
  * Services required to decode a persisted success or error value for the
  * request.
  *
- * @category models
+ * @category utility types
  * @since 4.0.0
  */
 export type DecodingServices<A extends Any> =
@@ -98,7 +99,7 @@ export type DecodingServices<A extends Any> =
 /**
  * Services required to encode a success or error value for persistence.
  *
- * @category models
+ * @category utility types
  * @since 4.0.0
  */
 export type EncodingServices<A extends Any> =
@@ -109,7 +110,7 @@ export type EncodingServices<A extends Any> =
  * All schema services required to encode and decode a persistable request
  * result.
  *
- * @category models
+ * @category utility types
  * @since 4.0.0
  */
 export type Services<A extends Any> =
@@ -122,7 +123,7 @@ export type Services<A extends Any> =
  * Computes the time to live for a persisted result from the result `Exit` and
  * request value.
  *
- * @category models
+ * @category utility types
  * @since 4.0.0
  */
 export type TimeToLiveFn<K extends Any> = (exit: Exit.Exit<Success<K>, Error<K>>, request: K) => Duration.Input
@@ -179,10 +180,10 @@ export const Class = <
     | ("requires" extends keyof Config ? Config["requires"] : never)
   > =>
 {
-  function Persistable(this: any, props: any) {
+  function Persistable(this: any, props: object | undefined) {
     this._tag = tag
     if (props) {
-      Object.assign(this, props)
+      InternalRecord.assignProperties(this, props)
     }
   }
   Persistable.prototype = {

package/src/unstable/persistence/PersistedQueue.ts

@@ -245,7 +245,7 @@ export class PersistedQueueError extends Schema.ErrorClass<PersistedQueueError>(
  * The store persists offered elements and returns taken elements in a scope so
  * the finalizer can complete or retry them based on the processing exit.
  *
- * @category store
+ * @category services
  * @since 4.0.0
  */
 export class PersistedQueueStore extends Context.Service<
@@ -283,7 +283,7 @@ export class PersistedQueueStore extends Context.Service<
  * The store is process-local and volatile; failed takes are requeued until the
  * configured maximum attempts is reached.
  *
- * @category store
+ * @category layers
  * @since 4.0.0
  */
 export const layerStoreMemory: Layer.Layer<
@@ -357,7 +357,7 @@ export const layerStoreMemory: Layer.Layer<
  * refreshes locks while items are being processed, and moves exhausted items
  * to a failed queue.
  *
- * @category store
+ * @category constructors
  * @since 4.0.0
  */
 export const makeStoreRedis = Effect.fnUntraced(function*(
@@ -720,7 +720,7 @@ end
 /**
  * Provides a Redis-backed `PersistedQueueStore` using `makeStoreRedis`.
  *
- * @category store
+ * @category layers
  * @since 4.0.0
  */
 export const layerStoreRedis: (
@@ -745,7 +745,7 @@ export const layerStoreRedis: (
  * per-worker locks, refreshes active locks while scoped takes are running, and
  * retries or completes rows according to the processing exit.
  *
- * @category store
+ * @category constructors
  * @since 4.0.0
  */
 export const makeStoreSql: (
@@ -1181,7 +1181,7 @@ class QueueKey extends Data.Class<{
 /**
  * Provides a SQL-backed `PersistedQueueStore` using `makeStoreSql`.
  *
- * @category store
+ * @category layers
  * @since 4.0.0
  */
 export const layerStoreSql: (

package/src/unstable/persistence/Persistence.ts

@@ -15,8 +15,10 @@ import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import { identity } from "../../Function.ts"
+import { sqlCleanupBatchSize } from "../../internal/persistence.ts"
 import * as Layer from "../../Layer.ts"
 import * as PrimaryKey from "../../PrimaryKey.ts"
+import * as Schedule from "../../Schedule.ts"
 import * as Schema from "../../Schema.ts"
 import type * as Scope from "../../Scope.ts"
 import * as SqlClient from "../sql/SqlClient.ts"
@@ -50,7 +52,7 @@ export class PersistenceError extends Schema.ErrorClass<PersistenceError>(ErrorT
  * Service for creating scoped stores of persisted `Persistable` request
  * results.
  *
- * @category models
+ * @category services
  * @since 4.0.0
  */
 export class Persistence extends Context.Service<Persistence, {
@@ -97,7 +99,7 @@ export interface PersistenceStore {
 /**
  * Service for creating raw backing stores for persistence store ids.
  *
- * @category BackingPersistence
+ * @category services
  * @since 4.0.0
  */
 export class BackingPersistence extends Context.Service<BackingPersistence, {
@@ -108,7 +110,7 @@ export class BackingPersistence extends Context.Service<BackingPersistence, {
  * Raw persistence backing store for JSON-compatible objects with optional
  * TTLs.
  *
- * @category BackingPersistence
+ * @category services
  * @since 4.0.0
  */
 export interface BackingPersistenceStore {
@@ -412,18 +414,16 @@ export const layerBackingSqlMultiTable: Layer.Layer<
               })
             ),
             Effect.flatMap((rows) => {
-              const out = new Array<object | undefined>(keys.length)
+              const values = new Map<string, object>()
               for (let i = 0; i < rows.length; i++) {
                 const row = rows[i]
-                const index = keys.indexOf(row.id)
-                if (index === -1) continue
                 try {
-                  out[index] = JSON.parse(row.value)
+                  values.set(row.id, JSON.parse(row.value))
                 } catch {
                   // ignore
                 }
               }
-              return Effect.succeed(out as Arr.NonEmptyArray<object | undefined>)
+              return Effect.succeed(keys.map((key) => values.get(key)) as Arr.NonEmptyArray<object | undefined>)
             })
           ),
         set: (key, value, ttl) =>
@@ -560,6 +560,120 @@ export const layerBackingSql: Layer.Layer<
       `
   }).pipe(Effect.orDie)
 
+  yield* sql.onDialectOrElse({
+    pg: () =>
+      sql`CREATE INDEX IF NOT EXISTS effect_persistence_expires_idx ON ${table} (expires) WHERE expires IS NOT NULL`
+        .pipe(Effect.orDie, Effect.asVoid),
+    mysql: () =>
+      Effect.gen(function*() {
+        const indexExists = sql<{ readonly count: number }>`
+          SELECT COUNT(*) AS count FROM information_schema.statistics
+          WHERE table_schema = DATABASE()
+            AND table_name = 'effect_persistence'
+            AND index_name = 'effect_persistence_expires_idx'
+        `.pipe(
+          Effect.map((rows) => Number(rows[0].count) > 0)
+        )
+
+        yield* sql`CREATE INDEX effect_persistence_expires_idx ON ${table} (expires)`.pipe(
+          Effect.catch((error) => Effect.flatMap(indexExists, (exists) => exists ? Effect.void : Effect.fail(error)))
+        )
+      }).pipe(Effect.orDie),
+    mssql: () =>
+      Effect.gen(function*() {
+        const indexExists = sql<{ readonly count: number }>`
+          SELECT COUNT(*) AS count FROM sys.indexes
+          WHERE name = N'effect_persistence_expires_idx'
+            AND object_id = OBJECT_ID(N'effect_persistence')
+        `.pipe(
+          Effect.map((rows) => Number(rows[0].count) > 0)
+        )
+
+        yield* sql`CREATE INDEX effect_persistence_expires_idx ON ${table} (expires) WHERE expires IS NOT NULL`.pipe(
+          Effect.catch((error) => Effect.flatMap(indexExists, (exists) => exists ? Effect.void : Effect.fail(error)))
+        )
+      }).pipe(Effect.orDie),
+    // sqlite
+    orElse: () =>
+      sql`CREATE INDEX IF NOT EXISTS effect_persistence_expires_idx ON ${table} (expires) WHERE expires IS NOT NULL`
+        .pipe(Effect.orDie, Effect.asVoid)
+  })
+
+  const cleanupBatchDelay = Duration.millis(10)
+  const cleanupInterval = Duration.minutes(5)
+
+  const deleteExpiredBatch = sql.onDialectOrElse({
+    pg: () => (expiresAtOrBefore: number) =>
+      sql<{ readonly count: number }>`
+        WITH deleted_entries AS (
+          DELETE FROM ${table}
+          WHERE ctid IN (
+            SELECT ctid FROM ${table}
+            WHERE expires IS NOT NULL AND expires <= ${expiresAtOrBefore}
+            LIMIT ${sql.literal(String(sqlCleanupBatchSize))}
+          )
+          RETURNING 1
+        )
+        SELECT COUNT(*)::INT AS count FROM deleted_entries
+      `.pipe(Effect.map((rows) => rows[0].count)),
+    mysql: () =>
+      Effect.fnUntraced(
+        function*(expiresAtOrBefore: number) {
+          const connection = yield* sql.reserve
+          const [statement, parameters] = sql`
+            DELETE FROM ${table}
+            WHERE expires IS NOT NULL AND expires <= ${expiresAtOrBefore}
+            LIMIT ${sql.literal(String(sqlCleanupBatchSize))}
+          `.compile()
+          yield* connection.execute(statement, parameters, undefined)
+          const rows = yield* connection.executeValues("SELECT ROW_COUNT()", [])
+          return Number(rows[0][0])
+        },
+        Effect.scoped
+      ),
+    mssql: () => (expiresAtOrBefore: number) =>
+      sql<{ readonly store_id: string }>`
+        WITH expired_entries AS (
+          SELECT TOP ${sql.literal(String(sqlCleanupBatchSize))} store_id, id FROM ${table}
+          WITH (UPDLOCK, READPAST, READCOMMITTEDLOCK)
+          WHERE expires IS NOT NULL AND expires <= ${expiresAtOrBefore}
+        )
+        DELETE persistence
+        OUTPUT DELETED.store_id
+        FROM ${table} AS persistence
+        INNER JOIN expired_entries
+          ON persistence.store_id = expired_entries.store_id
+          AND persistence.id = expired_entries.id
+      `.pipe(Effect.map((deletedEntries) => deletedEntries.length)),
+    // Some sqlite clients do not support interactive transactions, so use one bounded statement.
+    orElse: () => (expiresAtOrBefore: number) =>
+      sql<{ readonly deleted: number }>`
+        DELETE FROM ${table}
+        WHERE rowid IN (
+          SELECT rowid FROM ${table}
+          WHERE expires IS NOT NULL AND expires <= ${expiresAtOrBefore}
+          LIMIT ${sql.literal(String(sqlCleanupBatchSize))}
+        )
+        RETURNING 1 AS deleted
+      `.pipe(Effect.map((deletedEntries) => deletedEntries.length))
+  })
+
+  const deleteExpired = Effect.gen(function*() {
+    const expiresAtOrBefore = yield* Clock.currentTimeMillis
+    return yield* deleteExpiredBatch(expiresAtOrBefore).pipe(
+      Effect.repeat({
+        while: (deletedCount) => deletedCount === sqlCleanupBatchSize,
+        schedule: Schedule.spaced(cleanupBatchDelay)
+      })
+    )
+  })
+
+  yield* deleteExpired.pipe(
+    Effect.catch((cause) => Effect.logWarning("Failed to clean up expired persistence entries", cause)),
+    Effect.repeat(Schedule.spaced(cleanupInterval)),
+    Effect.forkScoped
+  )
+
   type UpsertFn = (
     entries: Array<{ store_id: string; id: string; value: string; expires: number | null }>
   ) => Effect.Effect<unknown, SqlError>
@@ -606,11 +720,6 @@ export const layerBackingSql: Layer.Layer<
     make: Effect.fnUntraced(function*(storeId) {
       const clock = yield* Clock.Clock
 
-      // Cleanup expired entries on startup
-      yield* Effect.ignore(
-        sql`DELETE FROM ${table} WHERE store_id = ${storeId} AND expires IS NOT NULL AND expires <= ${clock.currentTimeMillisUnsafe()}`
-      )
-
       return identity<BackingPersistenceStore>({
         get: (key) =>
           sql<
@@ -650,18 +759,16 @@ export const layerBackingSql: Layer.Layer<
               })
             ),
             Effect.flatMap((rows) => {
-              const out = new Array<object | undefined>(keys.length)
+              const values = new Map<string, object>()
               for (let i = 0; i < rows.length; i++) {
                 const row = rows[i]
-                const index = keys.indexOf(row.id)
-                if (index === -1) continue
                 try {
-                  out[index] = JSON.parse(row.value)
+                  values.set(row.id, JSON.parse(row.value))
                 } catch {
                   // ignore
                 }
               }
-              return Effect.succeed(out as Arr.NonEmptyArray<object | undefined>)
+              return Effect.succeed(keys.map((key) => values.get(key)) as Arr.NonEmptyArray<object | undefined>)
             })
           ),
         set: (key, value, ttl) =>
@@ -854,7 +961,7 @@ export const layerBackingRedis: Layer.Layer<
               ({ cause }) => new PersistenceError({ message: `Failed to remove key ${key} from Redis`, cause })
             ),
           clear: redis.send<Array<string>>("KEYS", `${prefix}:*`).pipe(
-            Effect.flatMap((keys) => redis.send("DEL", ...keys)),
+            Effect.flatMap((keys) => keys.length === 0 ? Effect.void : redis.send("DEL", ...keys)),
             Effect.mapError(({ cause }) =>
               new PersistenceError({
                 message: `Failed to clear keys from Redis`,

package/src/unstable/persistence/RateLimiter.ts

@@ -234,16 +234,17 @@ export const layer: Layer.Layer<
  *
  * **Example** (Applying rate limits to effects)
  *
- * ```ts
- * import { Effect } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Layer } from "effect"
  * import { RateLimiter } from "effect/unstable/persistence"
  *
- * Effect.gen(function*() {
+ * const messages: Array<string> = []
+ * const program = Effect.gen(function*() {
  *   // Access the `withLimiter` function from the RateLimiter module
  *   const withLimiter = yield* RateLimiter.makeWithRateLimiter
  *
  *   // Apply a rate limiter to an effect
- *   yield* Effect.log("Making a request with rate limiting").pipe(
+ *   yield* Effect.sync(() => messages.push("Making a request with rate limiting")).pipe(
  *     withLimiter({
  *       key: "some-key",
  *       limit: 10,
@@ -252,7 +253,12 @@ export const layer: Layer.Layer<
  *       algorithm: "fixed-window"
  *     })
  *   )
- * })
+ * }).pipe(
+ *   Effect.provide(RateLimiter.layer.pipe(Layer.provide(RateLimiter.layerStoreMemory)))
+ * )
+ *
+ * await Effect.runPromise(program)
+ * messages // => ["Making a request with rate limiting"]
  * ```
  *
  * @category accessors
@@ -283,23 +289,28 @@ export const makeWithRateLimiter: Effect.Effect<
  *
  * **Example** (Sleeping until rate limit permits)
  *
- * ```ts
- * import { Effect } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Layer } from "effect"
  * import { RateLimiter } from "effect/unstable/persistence"
  *
- * Effect.gen(function*() {
+ * const program = Effect.gen(function*() {
  *   // Access the `sleep` function from the RateLimiter module
  *   const sleep = yield* RateLimiter.makeSleep
  *
  *   // Use the `sleep` function with specific rate limiting parameters.
  *   // This will only sleep if the rate limit has been exceeded.
- *   yield* sleep({
+ *   const result = yield* sleep({
  *     key: "some-key",
  *     limit: 10,
  *     window: "5 seconds",
  *     algorithm: "fixed-window"
  *   })
- * })
+ *   return result.remaining
+ * }).pipe(
+ *   Effect.provide(RateLimiter.layer.pipe(Layer.provide(RateLimiter.layerStoreMemory)))
+ * )
+ *
+ * await Effect.runPromise(program) // => 9
  * ```
  *
  * @category accessors
@@ -362,8 +373,8 @@ export class RateLimitExceeded extends Schema.ErrorClass<RateLimitExceeded>(
   _tag: Schema.tag("RateLimitExceeded"),
   retryAfter: Schema.DurationFromMillis,
   key: Schema.String,
-  limit: Schema.Number,
-  remaining: Schema.Number
+  limit: Schema.Finite,
+  remaining: Schema.Finite
 }) {
   /**
    * Public message used when the rate limiter rejects a request.
@@ -486,7 +497,7 @@ export type AdaptivePhase = "inactive" | "cooldown" | "learning" | "learned"
 /**
  * Options for consuming tokens from the adaptive rate limiter store.
  *
- * @category models
+ * @category options
  * @since 4.0.0
  */
 export interface AdaptiveConsumeOptions {
@@ -537,7 +548,7 @@ export interface AdaptiveConsumeResult {
 /**
  * Options for reporting response feedback to the adaptive rate limiter store.
  *
- * @category models
+ * @category options
  * @since 4.0.0
  */
 export interface AdaptiveFeedbackOptions {
@@ -575,7 +586,7 @@ export interface AdaptiveFeedbackOptions {
  * Use to provide the shared counter storage and adaptive feedback state used by
  * persistent rate-limit checks.
  *
- * @category store
+ * @category services
  * @since 4.0.0
  */
 export class RateLimiterStore extends Context.Service<
@@ -655,7 +666,7 @@ interface AdaptiveState {
 /**
  * Provides a process-local in-memory `RateLimiterStore`.
  *
- * @category RateLimiterStore
+ * @category layers
  * @since 4.0.0
  */
 export const layerStoreMemory: Layer.Layer<
@@ -874,7 +885,7 @@ export const layerStoreMemory: Layer.Layer<
  * Creates a Redis-backed `RateLimiterStore` using Lua scripts and the
  * configured key prefix.
  *
- * @category RateLimiterStore
+ * @category constructors
  * @since 4.0.0
  */
 export const makeStoreRedis = Effect.fnUntraced(function*(

package/src/unstable/persistence/Redis.ts

@@ -123,7 +123,7 @@ const ScriptTypeId: ScriptTypeId = "~effect/persistence/Redis/Script"
  * It defines the Lua source, parameter-to-argument mapping, Redis key count,
  * and result type used by `Redis.eval`.
  *
- * @category Scripting
+ * @category scripting
  * @since 4.0.0
  */
 export interface Script<
@@ -173,7 +173,7 @@ const ScriptProto = {
  * The result type defaults to `void` and can be refined with
  * `withReturnType`.
  *
- * @category Scripting
+ * @category scripting
  * @since 4.0.0
  */
 export const script = <Params extends ReadonlyArray<any>>(
@@ -186,8 +186,8 @@ export const script = <Params extends ReadonlyArray<any>>(
   params: Params
   result: void
 }> =>
-  Object.assign(Object.create(ScriptProto), {
+  Object.setPrototypeOf({
     ...options,
     params: f,
     numberOfKeys: typeof options.numberOfKeys === "number" ? constant(options.numberOfKeys) : options.numberOfKeys
-  })
+  }, ScriptProto)