effect 4.0.4 → 4.0.6

package/src/persistence/Persistence.ts

@@ -301,6 +301,24 @@ export const layerBackingMemory: Layer.Layer<BackingPersistence> = Layer.sync(Ba
  * Each table is created if needed and stores JSON-encoded values with optional
  * expiration timestamps.
  *
+ * **Gotchas**
+ *
+ * Store ids are used directly in `effect_persistence_${storeId}` table names,
+ * without encoding or collision detection. Choose ids whose full table names
+ * are distinct under the database's identifier rules:
+ *
+ * - Do not use dots: they are interpreted as schema separators.
+ * - Do not rely on case alone to distinguish stores: SQLite treats ASCII-case
+ *   variants such as `Users` and `users` as the same table.
+ * - Stay within the database's identifier length limit, including the prefix.
+ *   PostgreSQL normally truncates identifiers to 63 bytes, leaving 44 bytes
+ *   for the store id. Ids sharing those first 44 bytes can alias the same table.
+ *
+ * Aliased stores share entries: writes can overwrite another store's values,
+ * and clearing one clears the other. For arbitrary store ids, prefer
+ * `layerBackingSql`, which stores ids as row values rather than table names.
+ *
+ * @see layerBackingSql
  * @stability unstable
  * @category layers
  * @since 4.0.0
@@ -397,9 +415,11 @@ export const layerBackingSqlMultiTable: Layer.Layer<
 
       return identity<BackingPersistenceStore>({
         get: (key) =>
-          sql<
-            { value: string }
-          >`SELECT value FROM ${table} WHERE id = ${key} AND (expires IS NULL OR expires > ${clock.currentTimeMillisUnsafe()})`
+          Effect.suspend(() =>
+            sql<
+              { value: string }
+            >`SELECT value FROM ${table} WHERE id = ${key} AND (expires IS NULL OR expires > ${clock.currentTimeMillisUnsafe()})`
+          )
             .pipe(
               Effect.mapError((cause) =>
                 new PersistenceError({
@@ -424,9 +444,11 @@ export const layerBackingSqlMultiTable: Layer.Layer<
               })
             ),
         getMany: (keys) =>
-          sql<{ id: string; value: string }>`SELECT id, value FROM ${table} WHERE ${
-            sql.in("id", keys)
-          } AND (expires IS NULL OR expires > ${clock.currentTimeMillisUnsafe()})`.unprepared.pipe(
+          Effect.suspend(() =>
+            sql<{ id: string; value: string }>`SELECT id, value FROM ${table} WHERE ${
+              sql.in("id", keys)
+            } AND (expires IS NULL OR expires > ${clock.currentTimeMillisUnsafe()})`.unprepared
+          ).pipe(
             Effect.mapError((cause) =>
               new PersistenceError({
                 message: `Failed to getMany from backing store`,
@@ -585,35 +607,33 @@ export const layerBackingSql: Layer.Layer<
     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 }>`
+    mysql: Effect.fnUntraced(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)
-        )
+        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 }>`
+      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)))
+      )
+    }, (_) => Effect.orDie(_)),
+    mssql: Effect.fnUntraced(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)
-        )
+        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),
+      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)))
+      )
+    }, (_) => Effect.orDie(_)),
     // sqlite
     orElse: () =>
       sql`CREATE INDEX IF NOT EXISTS effect_persistence_expires_idx ON ${table} (expires) WHERE expires IS NOT NULL`
@@ -738,9 +758,11 @@ export const layerBackingSql: Layer.Layer<
 
       return identity<BackingPersistenceStore>({
         get: (key) =>
-          sql<
-            { value: string }
-          >`SELECT value FROM ${table} WHERE store_id = ${storeId} AND id = ${key} AND (expires IS NULL OR expires > ${clock.currentTimeMillisUnsafe()})`
+          Effect.suspend(() =>
+            sql<
+              { value: string }
+            >`SELECT value FROM ${table} WHERE store_id = ${storeId} AND id = ${key} AND (expires IS NULL OR expires > ${clock.currentTimeMillisUnsafe()})`
+          )
             .pipe(
               Effect.mapError((cause) =>
                 new PersistenceError({
@@ -765,9 +787,11 @@ export const layerBackingSql: Layer.Layer<
               })
             ),
         getMany: (keys) =>
-          sql<{ id: string; value: string }>`SELECT id, value FROM ${table} WHERE store_id = ${storeId} AND ${
-            sql.in("id", keys)
-          } AND (expires IS NULL OR expires > ${clock.currentTimeMillisUnsafe()})`.unprepared.pipe(
+          Effect.suspend(() =>
+            sql<{ id: string; value: string }>`SELECT id, value FROM ${table} WHERE store_id = ${storeId} AND ${
+              sql.in("id", keys)
+            } AND (expires IS NULL OR expires > ${clock.currentTimeMillisUnsafe()})`.unprepared
+          ).pipe(
             Effect.mapError((cause) =>
               new PersistenceError({
                 message: `Failed to getMany from backing store`,
@@ -1172,6 +1196,16 @@ export const layerRedis: Layer.Layer<Persistence, never, Redis.Redis> = layer.pi
 /**
  * Provides `Persistence` backed by SQL with one table per store id.
  *
+ * **Gotchas**
+ *
+ * Store ids become `effect_persistence_${storeId}` table names and must obey
+ * the database's identifier rules. Avoid dots, case-only distinctions, and
+ * names exceeding the database's identifier length limit (including the
+ * prefix). Colliding names share data, including writes and clears.
+ * Prefer `layerSql` for arbitrary store ids.
+ *
+ * @see layerBackingSqlMultiTable for database-specific store-id restrictions
+ * @see layerSql
  * @stability unstable
  * @category layers
  * @since 4.0.0

package/src/persistence/RateLimiter.ts

@@ -109,24 +109,17 @@ export const make: Effect.Effect<
       const refillRate = Duration.divideUnsafe(window, options.limit)
       const refillRateMillis = Duration.toMillis(refillRate)
 
-      if (tokens > options.limit) {
-        return onExceeded === "fail"
-          ? Effect.fail(
-            new RateLimiterError({
-              reason: new RateLimitExceeded({
-                key: options.key,
-                retryAfter: window,
-                limit: options.limit,
-                remaining: 0
-              })
+      if (onExceeded === "fail" && tokens > options.limit) {
+        return Effect.fail(
+          new RateLimiterError({
+            reason: new RateLimitExceeded({
+              key: options.key,
+              retryAfter: window,
+              limit: options.limit,
+              remaining: 0
             })
-          )
-          : Effect.succeed<ConsumeResult>({
-            delay: window,
-            limit: options.limit,
-            remaining: 0,
-            resetAfter: window
           })
+        )
       }
 
       if (algorithm === "fixed-window") {
@@ -959,7 +952,10 @@ export const makeStoreRedis = Effect.fnUntraced(function*(
       const key = `${prefix}${options.key}`
       const refillMillis = Duration.toMillis(options.refillRate)
       return Effect.mapError(
-        fixedWindow(key, options.tokens, refillMillis, options.limit),
+        Effect.map(
+          fixedWindow(key, options.tokens, refillMillis, options.limit),
+          ([currentTokens, nextPttl]) => [Number(currentTokens), nextPttl] as const
+        ),
         (cause) =>
           new RateLimiterError({
             reason: new RateLimitStoreError({
@@ -1063,21 +1059,22 @@ local current = tonumber(redis.call("GET", key))
 if not current then
   local nextpttl = math.max(1, math.ceil(refillms * tokens))
   redis.call("SET", key, tokens, "PX", nextpttl)
-  return { tokens, nextpttl }
+  return { string.format("%.17g", tokens), nextpttl }
 end
 
 local currentpttl = tonumber(redis.call("PTTL", key) or "0")
 local next = current + tokens
 if limit and next > limit then
-  return { next, currentpttl }
+  return { string.format("%.17g", next), currentpttl }
 end
 
 local nextpttl = math.max(1, math.ceil(currentpttl + (refillms * tokens)))
 redis.call("SET", key, next, "PX", nextpttl)
-return { next, nextpttl }
+-- Use 17 significant digits to round-trip fractional token counts.
+return { string.format("%.17g", next), nextpttl }
 `
   }
-).withReturnType<readonly [currentTokens: number, nextPttl: number]>()
+).withReturnType<readonly [currentTokens: string, nextPttl: number]>()
 
 const tokenBucketScript = Redis.script(
   (

package/src/persistence/UserDirectories.ts

@@ -0,0 +1,273 @@
+/**
+ * Well-known directories for an application's persisted data.
+ *
+ * `UserDirectories` resolves where an application should keep its
+ * configuration, data, cache and state, following the conventions of the host
+ * platform. The resolved directories are what `KeyValueStore.layerFileSystem`
+ * expects.
+ *
+ * **Example** (Backing a key-value store with the config directory)
+ *
+ * ```ts import.meta.vitest
+ * import { Effect, Layer } from "effect"
+ * import { KeyValueStore, UserDirectories } from "effect/persistence"
+ *
+ * const StoreLive = Layer.unwrap(
+ *   Effect.gen(function*() {
+ *     const dirs = yield* UserDirectories.UserDirectories
+ *     return KeyValueStore.layerFileSystem(yield* dirs.config("myapp"))
+ *   })
+ * ).pipe(Layer.provide(UserDirectories.layer))
+ * ```
+ *
+ * @stability unstable
+ * @since 4.0.0
+ */
+import * as Config from "../Config.ts"
+import * as Context from "../Context.ts"
+import * as Effect from "../Effect.ts"
+import * as Layer from "../Layer.ts"
+import * as PlatformError from "../PlatformError.ts"
+
+/**
+ * Identifies a `UserDirectories` service.
+ *
+ * @stability unstable
+ * @category type ids
+ * @since 4.0.0
+ */
+export const TypeId: TypeId = "~effect/persistence/UserDirectories"
+
+/**
+ * Type of the `UserDirectories` type id.
+ *
+ * @stability unstable
+ * @category type ids
+ * @since 4.0.0
+ */
+export type TypeId = "~effect/persistence/UserDirectories"
+
+/**
+ * Resolves the directories where an application keeps its files.
+ *
+ * **Details**
+ *
+ * An absolute `XDG_CONFIG_HOME`, `XDG_DATA_HOME`, `XDG_CACHE_HOME` or
+ * `XDG_STATE_HOME` is used on every platform, with the application name
+ * appended. A relative one is ignored. Otherwise the native location is used:
+ *
+ * | kind   | Windows                                | macOS                          | other            |
+ * | ------ | -------------------------------------- | ------------------------------ | ---------------- |
+ * | config | `%APPDATA%`                            | `~/Library/Application Support` | `~/.config`      |
+ * | data   | `%APPDATA%`                            | `~/Library/Application Support` | `~/.local/share` |
+ * | cache  | `%LOCALAPPDATA%`, then `\Cache` suffix | `~/Library/Caches`             | `~/.cache`       |
+ * | state  | `%LOCALAPPDATA%`                       | `~/Library/Application Support` | `~/.local/state` |
+ *
+ * `APPDATA` and `LOCALAPPDATA` are used when absolute and otherwise replaced
+ * by `%USERPROFILE%\AppData\Roaming` and `%USERPROFILE%\AppData\Local`.
+ *
+ * **Gotchas**
+ *
+ * `config` and `data` resolve to the same directory on Windows and macOS, and
+ * `state` joins them on macOS. That is the native convention. Keep each kind
+ * in its own subdirectory when the same application uses more than one, since
+ * `KeyValueStore.layerFileSystem` clears a directory recursively.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export interface UserDirectories {
+  readonly [TypeId]: TypeId
+  /**
+   * The current user's home directory.
+   */
+  readonly home: Effect.Effect<string, PlatformError.PlatformError>
+  /**
+   * Where `appName` keeps its settings.
+   */
+  readonly config: (appName: string) => Effect.Effect<string, PlatformError.PlatformError>
+  /**
+   * Where `appName` keeps data it cannot regenerate.
+   */
+  readonly data: (appName: string) => Effect.Effect<string, PlatformError.PlatformError>
+  /**
+   * Where `appName` keeps data it can regenerate.
+   */
+  readonly cache: (appName: string) => Effect.Effect<string, PlatformError.PlatformError>
+  /**
+   * Where `appName` keeps logs, history and other state that is not user data.
+   */
+  readonly state: (appName: string) => Effect.Effect<string, PlatformError.PlatformError>
+}
+
+/**
+ * Service tag for the user directory resolver.
+ *
+ * @stability unstable
+ * @category services
+ * @since 4.0.0
+ */
+export const UserDirectories: Context.Service<UserDirectories, UserDirectories> = Context.Service<UserDirectories>(
+  TypeId
+)
+
+type Kind = "config" | "data" | "cache" | "state"
+
+type Environment = {
+  readonly home: string | undefined
+  readonly xdg: string | undefined
+  readonly appData: string | undefined
+}
+
+const isAbsolute = (platform: string, path: string): boolean =>
+  platform === "win32" ? /^([a-zA-Z]:)?[\\/]/.test(path) : path.startsWith("/")
+
+const join = (platform: string, base: string, ...segments: ReadonlyArray<string>): string =>
+  platform === "win32"
+    ? [base.replace(/[\\/]+$/, ""), ...segments].join("\\")
+    : [base.replace(/\/+$/, ""), ...segments].join("/")
+
+const xdgVariable: Record<Kind, string> = {
+  config: "XDG_CONFIG_HOME",
+  data: "XDG_DATA_HOME",
+  cache: "XDG_CACHE_HOME",
+  state: "XDG_STATE_HOME"
+}
+
+const windowsBase = (kind: Kind, env: Environment): string | undefined => {
+  if (env.appData !== undefined && isAbsolute("win32", env.appData)) {
+    return env.appData
+  }
+  if (env.home === undefined) {
+    return undefined
+  }
+  return join("win32", env.home, "AppData", kind === "config" || kind === "data" ? "Roaming" : "Local")
+}
+
+const posixBase = (platform: string, kind: Kind, home: string): string => {
+  if (platform === "darwin") {
+    return join(platform, home, "Library", kind === "cache" ? "Caches" : "Application Support")
+  }
+  switch (kind) {
+    case "config":
+      return join(platform, home, ".config")
+    case "data":
+      return join(platform, home, ".local", "share")
+    case "cache":
+      return join(platform, home, ".cache")
+    case "state":
+      return join(platform, home, ".local", "state")
+  }
+}
+
+const resolve = (platform: string, kind: Kind, appName: string, env: Environment): string | undefined => {
+  if (env.xdg !== undefined && isAbsolute(platform, env.xdg)) {
+    return join(platform, env.xdg, appName)
+  }
+  if (platform === "win32") {
+    const base = windowsBase(kind, env)
+    if (base === undefined) {
+      return undefined
+    }
+    return kind === "cache" ? join(platform, base, appName, "Cache") : join(platform, base, appName)
+  }
+  if (env.home === undefined) {
+    return undefined
+  }
+  return join(platform, posixBase(platform, kind, env.home), appName)
+}
+
+/**
+ * Creates a resolver that reads the environment from the current
+ * `ConfigProvider` on every call, using the conventions of `platform`, which
+ * defaults to the host platform.
+ *
+ * **Example** (Resolving for another platform)
+ *
+ * ```ts import.meta.vitest
+ * import { ConfigProvider, Effect } from "effect"
+ * import { UserDirectories } from "effect/persistence"
+ *
+ * const dirs = UserDirectories.make({ platform: "darwin" })
+ *
+ * const program = dirs.cache("myapp").pipe(
+ *   Effect.provideService(
+ *     ConfigProvider.ConfigProvider,
+ *     ConfigProvider.fromEnv({ env: { HOME: "/Users/ada" } })
+ *   )
+ * )
+ *
+ * await Effect.runPromise(program) // => "/Users/ada/Library/Caches/myapp"
+ * ```
+ *
+ * @stability unstable
+ * @category constructors
+ * @since 4.0.0
+ */
+export const make = (options?: {
+  readonly platform?: string | undefined
+}): UserDirectories => {
+  const platform = options?.platform ?? (globalThis as any).process?.platform ?? "linux"
+  const homeVariable = platform === "win32" ? "USERPROFILE" : "HOME"
+  const optionalString = (name: string) => Config.String(name).pipe(Config.withDefault(undefined))
+  const read = <A>(method: string, config: Config.Config<A>): Effect.Effect<A, PlatformError.PlatformError> =>
+    Effect.mapError(config, (cause) =>
+      PlatformError.systemError({
+        _tag: "Unknown",
+        module: "UserDirectories",
+        method,
+        description: "Failed to read the environment",
+        cause
+      }))
+  const notFound = (method: string) =>
+    PlatformError.systemError({
+      _tag: "NotFound",
+      module: "UserDirectories",
+      method,
+      description: `${homeVariable} is not set`
+    })
+  const directory = (kind: Kind) => {
+    const environment = Config.all({
+      home: optionalString(homeVariable),
+      xdg: optionalString(xdgVariable[kind]),
+      appData: optionalString(kind === "config" || kind === "data" ? "APPDATA" : "LOCALAPPDATA")
+    })
+    return (appName: string) =>
+      Effect.flatMap(read(kind, environment), (env) => {
+        const resolved = resolve(platform, kind, appName, env)
+        return resolved === undefined ? Effect.fail(notFound(kind)) : Effect.succeed(resolved)
+      })
+  }
+  return {
+    [TypeId]: TypeId,
+    home: Effect.flatMap(
+      read("home", optionalString(homeVariable)),
+      (home) => home === undefined ? Effect.fail(notFound("home")) : Effect.succeed(home)
+    ),
+    config: directory("config"),
+    data: directory("data"),
+    cache: directory("cache"),
+    state: directory("state")
+  }
+}
+
+/**
+ * Layer that resolves directories for the host platform.
+ *
+ * @stability unstable
+ * @category layers
+ * @since 4.0.0
+ */
+export const layer: Layer.Layer<UserDirectories> = Layer.sync(UserDirectories, () => make())
+
+/**
+ * Layer that resolves directories for the given platform, such as `"win32"`,
+ * `"darwin"` or `"linux"`.
+ *
+ * @stability unstable
+ * @category layers
+ * @since 4.0.0
+ */
+export const layerPlatform = (platform: string): Layer.Layer<UserDirectories> =>
+  Layer.sync(UserDirectories, () => make({ platform }))

package/src/persistence/index.ts

@@ -46,3 +46,9 @@ export * as RateLimiter from "./RateLimiter.ts"
  * @since 4.0.0
  */
 export * as Redis from "./Redis.ts"
+
+/**
+ * @stability unstable
+ * @since 4.0.0
+ */
+export * as UserDirectories from "./UserDirectories.ts"

package/src/process/ChildProcess.ts

@@ -259,7 +259,8 @@ export interface KillOptions {
   /**
    * The duration of time to wait after the child process has been terminated
    * before forcefully killing the child process by sending it the `"SIGKILL"`
-   * signal. Defaults to `undefined`, so `"SIGKILL"` is never sent.
+   * signal. Defaults to `undefined`, so `"SIGKILL"` is never sent and termination
+   * waits for the process to exit with no time limit.
    *
    * **Details**
    *

package/src/reactivity/AsyncResult.ts

@@ -127,8 +127,8 @@ const ResultProto = {
   pipe() {
     return pipeArguments(this, arguments)
   },
-  [Equal.symbol](this: AsyncResult<any, any>, that: AsyncResult<any, any>): boolean {
-    if (this._tag !== that._tag || this.waiting !== that.waiting) {
+  [Equal.symbol](this: AsyncResult<any, any>, that: Equal.Equal): boolean {
+    if (!isAsyncResult(that) || this._tag !== that._tag || this.waiting !== that.waiting) {
       return false
     }
     switch (this._tag) {
@@ -676,47 +676,13 @@ export const flatMap: {
       case "Initial":
         return self as any as AsyncResult<B, E>
       case "Failure":
-        return failure</**
-         * Maps the success value of an `AsyncResult` and flattens the result.
-         *
-         * **When to use**
-         *
-         * Use to sequence computations that may return another `AsyncResult` while
-         * preserving initial and failure states.
-         *
-         * **Details**
-         *
-         * Initial results are left unchanged. Failures preserve their cause and remap
-         * the stored previous success when the mapping function returns a success.
-         *
-         * @stability unstable
-         * @category combinators
-         * @since 4.0.0
-         */
-        B, /**
-         * Maps the success value of an `AsyncResult` and flattens the result.
-         *
-         * **When to use**
-         *
-         * Use to sequence computations that may return another `AsyncResult` while
-         * preserving initial and failure states.
-         *
-         * **Details**
-         *
-         * Initial results are left unchanged. Failures preserve their cause and remap
-         * the stored previous success when the mapping function returns a success.
-         *
-         * @stability unstable
-         * @category combinators
-         * @since 4.0.0
-         */
-        E | E2>(self.cause, {
+        return failure<B, E | E2>(self.cause, {
           previousSuccess: Option.flatMap(self.previousSuccess, (s) => {
             const next = f(s.value, s)
             return isSuccess(next) ? Option.some(next) : Option.none()
           }),
           waiting: self.waiting
-        });
+        })
       case "Success":
         return f(self.value, self)
     }
@@ -901,6 +867,12 @@ export const matchWithWaiting: {
 /**
  * Combines an iterable or record of `AsyncResult` and plain values into one `AsyncResult`, returning the first non-success result or a success of the collected values marked waiting when any input success is waiting.
  *
+ * **Details**
+ *
+ * If the first non-success result is a failure, its previous success is
+ * rebuilt in the combined shape from each input's current or previous value.
+ * It is omitted if any input has no value.
+ *
  * @stability unstable
  * @category combinators
  * @since 4.0.0
@@ -932,6 +904,11 @@ export const all = <const Arg extends Iterable<any> | Record<string, any>>(
     if (!isAsyncResult(result)) {
       InternalRecord.assignProperty(successes, key, result)
       continue
+    } else if (isFailure(result)) {
+      return failure(result.cause, {
+        previousSuccess: combinedPreviousSuccess(entries, isIter),
+        waiting: result.waiting
+      }) as any
     } else if (!isSuccess(result)) {
       return result as any
     }
@@ -943,6 +920,26 @@ export const all = <const Arg extends Iterable<any> | Record<string, any>>(
   return success(successes, { waiting }) as any
 }
 
+const combinedPreviousSuccess = (
+  entries: ReadonlyArray<readonly [PropertyKey, unknown]>,
+  isIter: boolean
+): Option.Option<Success<unknown, never>> => {
+  const values: any = isIter ? [] : {}
+  for (let i = 0; i < entries.length; i++) {
+    const [key, entry] = entries[i]
+    if (!isAsyncResult(entry)) {
+      InternalRecord.assignProperty(values, key, entry)
+      continue
+    }
+    const entryValue = value(entry)
+    if (Option.isNone(entryValue)) {
+      return Option.none()
+    }
+    InternalRecord.assignProperty(values, key, entryValue.value)
+  }
+  return Option.some(success(values))
+}
+
 /**
  * Creates a typed builder for rendering an `AsyncResult` by handling waiting, initial, success, error, defect, interrupt, and failure cases.
  *