effect 4.0.0-beta.50 → 4.0.0-beta.51

package/src/SchemaGetter.ts

@@ -483,7 +483,8 @@ export function onSome<T, E, R = never>(
  *   - `undefined` or `true` — value is valid, passes through.
  *   - `false` or a `string` — value is invalid, fails with an `Issue`.
  *   - An `Issue` object — fails with that issue directly.
- *   - `{ path, message }` — fails with a nested path issue.
+ *   - `{ path, issue }` — fails with a nested path issue (`issue` may be a
+ *     message string or a full {@link Issue.Issue}).
  * - Does not transform the value — input and output types are the same.
  *
  * **Example** (Effectful validation)
@@ -505,17 +506,14 @@ export function onSome<T, E, R = never>(
  */
 export function checkEffect<T, R = never>(
   f: (input: T, options: AST.ParseOptions) => Effect.Effect<
-    undefined | boolean | string | Issue.Issue | {
-      readonly path: ReadonlyArray<PropertyKey>
-      readonly message: string
-    },
+    undefined | boolean | Schema.FilterIssue,
     never,
     R
   >
 ): Getter<T, T, R> {
   return onSome((t, options) => {
     return f(t, options).pipe(Effect.flatMapEager((out) => {
-      const issue = Issue.make(t, out)
+      const issue = Issue.makeSingle(t, out)
       return issue ?
         Effect.fail(issue) :
         Effect.succeed(Option.some(t))

package/src/SchemaIssue.ts

@@ -79,6 +79,7 @@
  * @since 4.0.0
  */
 import type { StandardSchemaV1 } from "@standard-schema/spec"
+import * as Arr from "./Array.ts"
 import { format, formatPath, type Formatter as FormatterI } from "./Formatter.ts"
 import * as InternalAnnotations from "./internal/schema/annotations.ts"
 import * as Option from "./Option.ts"
@@ -867,30 +868,42 @@ export function getActual(issue: Issue): Option.Option<unknown> {
   }
 }
 
-/** @internal */
-export function make(
-  input: unknown,
-  out: undefined | boolean | string | Issue | {
-    readonly path: ReadonlyArray<PropertyKey>
-    readonly message: string
+function makeFilterIssue(input: unknown, entry: Schema.FilterIssue): Issue {
+  if (isIssue(entry)) {
+    return entry
   }
-) {
-  if (isIssue(out)) {
-    return out
+  if (typeof entry === "string") {
+    return new InvalidValue(Option.some(input), { message: entry })
   }
+  const inner = typeof entry.issue === "string"
+    ? new InvalidValue(Option.some(input), { message: entry.issue })
+    : entry.issue
+  return new Pointer(entry.path, inner)
+}
+
+/** @internal */
+export function makeSingle(input: unknown, out: undefined | boolean | Schema.FilterIssue): Issue | undefined {
   if (out === undefined) {
     return undefined
   }
   if (typeof out === "boolean") {
     return out ? undefined : new InvalidValue(Option.some(input))
   }
-  if (typeof out === "string") {
-    return new InvalidValue(Option.some(input), { message: out })
+  return makeFilterIssue(input, out)
+}
+
+/** @internal */
+export function make(input: unknown, ast: AST.AST, out: Schema.FilterOutput): Issue | undefined {
+  if (Array.isArray(out)) {
+    if (Arr.isReadonlyArrayNonEmpty(out)) {
+      if (out.length === 1) {
+        return makeFilterIssue(input, out[0])
+      }
+      return new Composite(ast, Option.some(input), Arr.map(out, (entry) => makeFilterIssue(input, entry)))
+    }
+    return undefined
   }
-  return new Pointer(
-    out.path,
-    new InvalidValue(Option.some(input), { message: out.message })
-  )
+  return makeSingle(input, out as undefined | boolean | Schema.FilterIssue)
 }
 
 /**

package/src/SchemaParser.ts

@@ -417,16 +417,22 @@ export interface Parser {
 const recur = memoize(
   (ast: AST.AST): Parser => {
     let parser: Parser
+    const astOptions = InternalAnnotations.resolve(ast)?.["parseOptions"]
     if (!ast.context && !ast.encoding && !ast.checks) {
       return (ou, options) => {
         parser ??= ast.getParser(recur)
-        return parser(ou, InternalAnnotations.resolve(ast)?.["parseOptions"] ?? options)
+        if (astOptions) {
+          options = { ...options, ...astOptions }
+        }
+        return parser(ou, options)
       }
     }
     const isStructural = AST.isArrays(ast) || AST.isObjects(ast) ||
       (AST.isDeclaration(ast) && ast.typeParameters.length > 0)
     return (ou, options) => {
-      options = InternalAnnotations.resolve(ast)?.["parseOptions"] ?? options
+      if (astOptions) {
+        options = { ...options, ...astOptions }
+      }
       const encoding = ast.encoding
       let srou: Effect.Effect<Option.Option<unknown>, Issue.Issue, unknown> | undefined
       if (encoding) {

package/src/internal/effect.ts

@@ -58,7 +58,6 @@ import {
   contA,
   contAll,
   contE,
-  Die,
   evaluate,
   exitDie,
   exitFail,
@@ -4457,72 +4456,8 @@ export const forEach: {
     const out: Array<B> | undefined = options?.discard
       ? undefined
       : new Array(length)
-    let index = 0
-    const annotations = fiberStackAnnotations(parent)
-
-    return callback((resume) => {
-      const fibers = new Set<Fiber.Fiber<unknown, unknown>>()
-      const failures: Array<Cause.Reason<E>> = []
-      let failed = false
-      let inProgress = 0
-      let doneCount = 0
-      let pumping = false
-      let interrupted = false
-      function pump() {
-        pumping = true
-        while (inProgress < concurrency && index < length) {
-          const currentIndex = index
-          const item = items[currentIndex]
-          index++
-          inProgress++
-          try {
-            const child = forkUnsafe(parent, f(item, currentIndex), true, true, "inherit")
-            fibers.add(child)
-            child.addObserver((exit) => {
-              if (interrupted) {
-                return
-              }
-              fibers.delete(child)
-              if (exit._tag === "Failure") {
-                if (!failed) {
-                  failed = true
-                  length = index
-                  failures.push(...exit.cause.reasons)
-                  fibers.forEach((fiber) => fiber.interruptUnsafe(parent.id, annotations))
-                } else {
-                  for (const f of exit.cause.reasons) {
-                    if (f._tag === "Interrupt") continue
-                    failures.push(f)
-                  }
-                }
-              } else if (out !== undefined) {
-                out[currentIndex] = exit.value
-              }
-              doneCount++
-              inProgress--
-              if (doneCount === length) {
-                resume(failures.length > 0 ? exitFailCause(causeFromReasons(failures)) : succeed(out))
-              } else if (!pumping && !failed && inProgress < concurrency) {
-                pump()
-              }
-            })
-          } catch (err) {
-            failed = true
-            length = index
-            failures.push(new Die(err))
-            fibers.forEach((fiber) => fiber.interruptUnsafe(parent.id, annotations))
-          }
-        }
-        pumping = false
-      }
-      pump()
-
-      return suspend(() => {
-        interrupted = true
-        index = length
-        return fiberInterruptAll(fibers)
-      })
-    })
+    const eff = forEachConcurrent({ f, out }, items, { concurrency })
+    return eff ? as(eff, out as any) : succeed(out as any)
   }))
 
 const forEachSequential = <A, B, E, R>(
@@ -4550,6 +4485,188 @@ const forEachSequential = <A, B, E, R>(
     )
   })
 
+const iterateEagerImpl = <S, A, X, E, R, E2>(options: {
+  readonly onItem: (state: S, item: A, index: number) => Effect.Effect<X, E, R>
+  readonly step: (state: NoInfer<S>, item: A, exit: Exit.Exit<X, E>, index: number) => Exit.Exit<void, E2> | void
+}): (
+  initialState: S,
+  items: ReadonlyArray<A>,
+  options?: {
+    readonly concurrency?: number | undefined
+    readonly start?: number | undefined
+    readonly end?: number | undefined
+  }
+) => Effect.Effect<void, E | E2, R> | undefined => {
+  const onItem = options.onItem
+  const step = options.step
+
+  return (
+    state: S,
+    items: ReadonlyArray<A>,
+    opts: {
+      readonly concurrency?: number | undefined
+      readonly start?: number | undefined
+      readonly end?: number | undefined
+    } | undefined
+  ): Effect.Effect<void, E | E2, R> | undefined => {
+    let index = opts?.start ?? 0
+    const end = opts?.end ?? items.length
+    const concurrency = opts?.concurrency ?? 1
+    let done = false
+    let parentFiber: Fiber.Fiber<any, any> | undefined
+    let fibers: Set<Fiber.Fiber<any, any>> | undefined
+    let resume: ((effect: Effect.Effect<void, E | E2, R>) => void) | undefined
+    let interrupted = false
+    let terminal: Exit.Exit<void, E | E2> | void
+    let effect: Effect.Effect<X, E, R> | undefined
+
+    const go = (): Effect.Effect<void, E | E2, R> | undefined => {
+      let paused = false
+      for (; !terminal && index < end; index++) {
+        const item = items[index]
+        const eff = effect ?? onItem(state, item, index)
+
+        // fast case (already an exit)
+        if (effectIsExit(eff)) {
+          terminal = step(state, item, eff, index)
+          if (terminal) break
+
+          // Use flatMap for concurrency of 1
+        } else if (concurrency === 1) {
+          return flatMap(exit(eff), (exit) => {
+            terminal = step(state, item, exit, index)
+            index++
+            return terminal ?? go() ?? void_
+          })
+
+          // We have an effect, so enter "async" mode
+        } else if (!parentFiber) {
+          return callback((cb) => {
+            parentFiber = getCurrentFiber()!
+            effect = eff
+            resume = cb
+            const result = go()
+            if (result) return cb(result)
+            return suspend(() => {
+              terminal = exitVoid
+              interrupted = true
+              return fibers ? fiberInterruptAll(fibers) : void_
+            })
+          })
+
+          // Fork the effect with concurrency > 1
+        } else {
+          // Clear the temporary effect from capturing the parentFiber
+          effect = undefined
+
+          const fiber = forkUnsafe(parentFiber, eff, true, true, "inherit")
+          if (fiber._exit) {
+            terminal = step(state, item, fiber._exit, index)
+            if (terminal) break
+            continue
+          }
+
+          // Add the fiber to the Set
+          if (fibers) fibers.add(fiber)
+          else fibers = new Set([fiber])
+
+          const currentIndex = index
+          fiber.addObserver((exit) => {
+            fibers!.delete(fiber)
+            if (terminal) {
+              if (!interrupted && exit._tag === "Failure") {
+                for (const reason of exit.cause.reasons) {
+                  if (reason._tag === "Interrupt") continue
+                  else if (terminal._tag === "Failure") {
+                    ;(terminal.cause.reasons as Array<any>).push(reason)
+                  } else {
+                    terminal = exitFailCause(causeFromReasons([reason]))
+                  }
+                }
+              }
+            } else {
+              const result = step(state, item, exit, currentIndex)
+              if (result) {
+                terminal = result._tag === "Failure"
+                  ? exitFailCause(causeFromReasons(result.cause.reasons.slice()))
+                  : result
+                go()
+              }
+            }
+
+            if (paused) {
+              const eff = go()
+              if (eff) resume!(eff)
+            } else if (done && fibers!.size === 0) {
+              resume!(terminal ?? void_)
+            }
+          })
+
+          // Check if we have reached the concurrency limit
+          if (fibers.size < concurrency) continue
+          paused = true
+          index++
+          return
+        }
+      }
+
+      done = true
+
+      if (terminal) {
+        if (fibers && fibers.size > 0) {
+          const annotations = fiberStackAnnotations(parentFiber!)
+          fibers.forEach((f) => f.interruptUnsafe(parentFiber!.id, annotations))
+          return
+        }
+        if (resume || terminal._tag === "Failure") {
+          return terminal
+        }
+      } else if (resume) {
+        if (!fibers) {
+          return exitVoid
+        } else if (fibers.size === 0) {
+          resume(void_)
+        }
+      }
+    }
+
+    return go()
+  }
+}
+
+/** @internal */
+export const iterateEager = <S, A>(): <X, E, R, E2>(options: {
+  readonly onItem: (state: S, item: A, index: number) => Effect.Effect<X, E, R>
+  readonly step: (state: NoInfer<S>, item: A, exit: Exit.Exit<X, E>, index: number) => Exit.Exit<void, E2> | void
+}) => (
+  initialState: S,
+  items: ReadonlyArray<A>,
+  options?: {
+    readonly concurrency?: number | undefined
+    readonly start?: number | undefined
+    readonly end?: number | undefined
+  }
+) => Effect.Effect<void, E | E2, R> | undefined => iterateEagerImpl
+
+const forEachConcurrent = iterateEagerImpl({
+  onItem(
+    state: {
+      readonly f: (a: any, i: number) => Effect.Effect<any, any, any>
+      readonly out: Array<any> | undefined
+    },
+    item,
+    index
+  ) {
+    return state.f(item, index)
+  },
+  step(state, _, exit, index) {
+    if (exit._tag === "Failure") return exit
+    else if (state.out) {
+      state.out[index] = exit.value
+    }
+  }
+})
+
 /* @internal */
 export const filterOrElse: {
   <A, C, E2, R2, B extends A>(
@@ -4862,7 +4979,7 @@ export const forkUnsafe = <FA, FE, A, E, R>(
   immediate = false,
   daemon = false,
   uninterruptible: boolean | "inherit" = false
-): Fiber.Fiber<A, E> => {
+): FiberImpl<A, E> => {
   const interruptible = uninterruptible === "inherit" ? parent.interruptible : !uninterruptible
   const child = new FiberImpl<A, E>(parent.context, interruptible)
   if (immediate) {
@@ -5332,7 +5449,7 @@ export const makeSpanUnsafe = <XA, XE>(
       parent,
       annotations: options?.annotations ?? Context.empty(),
       links,
-      startTime: timingEnabled ? clock.currentTimeNanosUnsafe() : 0n,
+      startTime: timingEnabled ? clock.currentTimeNanosUnsafe() : BigInt(0),
       kind: options?.kind ?? "internal",
       root: options?.root ?? Option.isNone(parent),
       sampled: options?.sampled ??
@@ -6022,6 +6139,7 @@ const prettyLoggerTty = (options: {
   return loggerMake<unknown, void>(
     ({ cause, date, fiber, logLevel, message: message_ }) => {
       const console = fiber.getRef(ConsoleRef)
+      // oxlint-disable-next-line no-console
       const log = fiber.getRef(LogToStderr) ? console.error : console.log
 
       const message = Array.isArray(message_) ? message_.slice() : [message_]
@@ -6047,6 +6165,7 @@ const prettyLoggerTty = (options: {
       }
 
       log(firstLine)
+      // oxlint-disable-next-line no-console
       if (!processIsBun) console.group()
 
       if (cause.reasons.length > 0) {
@@ -6064,6 +6183,7 @@ const prettyLoggerTty = (options: {
         log(color(`${key}:`, colors.bold, colors.white), redact(value))
       }
 
+      // oxlint-disable-next-line no-console
       if (!processIsBun) console.groupEnd()
     }
   )
@@ -6110,14 +6230,17 @@ const prettyLoggerBrowser = (options: {
         }
       }
 
+      // oxlint-disable-next-line no-console
       console.groupCollapsed(firstLine, ...firstParams)
 
       if (cause.reasons.length > 0) {
+        // oxlint-disable-next-line no-console
         console.error(causePretty(cause))
       }
 
       if (messageIndex < message.length) {
         for (; messageIndex < message.length; messageIndex++) {
+          // oxlint-disable-next-line no-console
           console.log(redact(message[messageIndex]))
         }
       }
@@ -6126,12 +6249,15 @@ const prettyLoggerBrowser = (options: {
       for (const [key, value] of Object.entries(annotations)) {
         const redacted = redact(value)
         if (options.colors) {
+          // oxlint-disable-next-line no-console
           console.log(`%c${key}:`, "color:gray", redacted)
         } else {
+          // oxlint-disable-next-line no-console
           console.log(`${key}:`, redacted)
         }
       }
 
+      // oxlint-disable-next-line no-console
       console.groupEnd()
     }
   )
@@ -6154,6 +6280,7 @@ export const defaultLogger = loggerMake<unknown, void>(({ cause, date, fiber, lo
     message_.push(annotations)
   }
   const console = fiber.getRef(ConsoleRef)
+  // oxlint-disable-next-line no-console
   const log = fiber.getRef(LogToStderr) ? console.error : console.log
   log(`[${defaultDateFormat(date)}] ${logLevel.toUpperCase()} (#${fiber.id})${spanString}:`, ...message_)
 })

package/src/unstable/cluster/Runners.ts

@@ -589,11 +589,14 @@ export const makeRpc: Effect.Effect<
         return Effect.void
       }
       const envelope = message.envelope
-      return RcMap.get(clients, address.value).pipe(
-        Effect.flatMap((client) => client.Notify({ envelope })),
-        Effect.scoped,
-        Effect.ignore
-      )
+      const encode: Effect.Effect<Envelope.AckChunk | Envelope.Interrupt | Envelope.PartialRequest> =
+        message._tag === "OutgoingRequest" ? Effect.orDie(Message.serializeRequest(message)) : Effect.succeed(envelope)
+      return Effect.flatMap(encode, (envelope) =>
+        RcMap.get(clients, address.value).pipe(
+          Effect.flatMap((client) => client.Notify({ envelope })),
+          Effect.scoped,
+          Effect.ignore
+        ))
     },
     onRunnerUnavailable: (address) => RcMap.invalidate(clients, address)
   })

package/src/unstable/cluster/SqlMessageStorage.ts

@@ -1,6 +1,7 @@
 /**
  * @since 4.0.0
  */
+// eslint-disable effect/no-bigint-literals
 import * as Arr from "../../Array.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"

package/src/unstable/cluster/SqlRunnerStorage.ts

@@ -536,7 +536,8 @@ export const make = Effect.fnUntraced(function*(options: {
         shardIds.length > 0 ?
           Effect.andThen(refreshShards(address, shardIds)) :
           Effect.as([]),
-        PersistenceError.refail
+        PersistenceError.refail,
+        withTracerDisabled
       ),
 
     release: sql.onDialectOrElse({
@@ -544,7 +545,8 @@ export const make = Effect.fnUntraced(function*(options: {
         if (disableAdvisoryLocks) {
           return (address: string, shardId: string) =>
             sql`DELETE FROM ${locksTableSql} WHERE address = ${address} AND shard_id = ${shardId}`.pipe(
-              PersistenceError.refail
+              PersistenceError.refail,
+              withTracerDisabled
             )
         }
         return Effect.fnUntraced(
@@ -564,14 +566,16 @@ export const make = Effect.fnUntraced(function*(options: {
           },
           Effect.onError(() => lockConn!.rebuildUnsafe()),
           Effect.asVoid,
-          PersistenceError.refail
+          PersistenceError.refail,
+          withTracerDisabled
         )
       },
       mysql: () => {
         if (disableAdvisoryLocks) {
           return (address: string, shardId: string) =>
             sql`DELETE FROM ${locksTableSql} WHERE address = ${address} AND shard_id = ${shardId}`.pipe(
-              PersistenceError.refail
+              PersistenceError.refail,
+              withTracerDisabled
             )
         }
         return Effect.fnUntraced(
@@ -589,12 +593,14 @@ export const make = Effect.fnUntraced(function*(options: {
           },
           Effect.onError(() => lockConn!.rebuildUnsafe()),
           Effect.asVoid,
-          PersistenceError.refail
+          PersistenceError.refail,
+          withTracerDisabled
         )
       },
       orElse: () => (address, shardId) =>
         sql`DELETE FROM ${locksTableSql} WHERE address = ${address} AND shard_id = ${shardId}`.pipe(
-          PersistenceError.refail
+          PersistenceError.refail,
+          withTracerDisabled
         )
     }),
 

package/src/unstable/eventlog/SqlEventJournal.ts

@@ -71,7 +71,7 @@ export const make = (options?: {
             payload BLOB NOT NULL,
             timestamp INTEGER NOT NULL
           )`
-    })
+    }).pipe(withTracerDisabled)
 
     yield* sql.onDialectOrElse({
       pg: () =>
@@ -106,7 +106,7 @@ export const make = (options?: {
             sequence INT NOT NULL,
             PRIMARY KEY (remote_id, entry_id)
           )`
-    })
+    }).pipe(withTracerDisabled)
 
     const decodeEntryRows = Schema.decodeUnknownEffect(EntryRowArray)
     const toEntries = (rows: ReadonlyArray<EntryRow>): ReadonlyArray<EventJournal.Entry> => rows.map(toEntry)
@@ -193,6 +193,7 @@ export const make = (options?: {
 
     return EventJournal.EventJournal.of({
       entries: sql`SELECT * FROM ${entryTableSql} ORDER BY timestamp ASC`.pipe(
+        withTracerDisabled,
         Effect.flatMap(decodeEntryRows),
         Effect.map(toEntries),
         Effect.mapError((cause) => new EventJournal.EventJournalError({ cause, method: "entries" }))
@@ -210,10 +211,12 @@ export const make = (options?: {
           yield* PubSub.publish(pubsub, entry)
           return value
         },
+        withTracerDisabled,
         Effect.mapError((cause) => new EventJournal.EventJournalError({ cause, method: "write" }))
       ),
       writeFromRemote: (options) =>
         writeFromRemote(options).pipe(
+          withTracerDisabled,
           Effect.catchIf(
             (e) => e._tag !== "EventJournalError",
             (cause) => Effect.fail(new EventJournal.EventJournalError({ cause, method: "writeFromRemote" }))
@@ -232,6 +235,7 @@ export const make = (options?: {
           )
           return yield* f(entries)
         },
+        withTracerDisabled,
         Effect.mapError((cause) => new EventJournal.EventJournalError({ cause, method: "withRemoteUncommited" }))
       ),
       nextRemoteSequence: (remoteId) =>
@@ -242,6 +246,7 @@ export const make = (options?: {
               if (value === null || value === undefined) return 0
               return Number(value) + 1
             }),
+            withTracerDisabled,
             Effect.mapError((cause) => new EventJournal.EventJournalError({ cause, method: "nextRemoteSequence" }))
           ),
       changes: PubSub.subscribe(pubsub),
@@ -249,6 +254,7 @@ export const make = (options?: {
         yield* sql`DROP TABLE ${entryTableSql}`
         yield* sql`DROP TABLE ${remotesTableSql}`
       }).pipe(
+        withTracerDisabled,
         Effect.mapError((cause) => new EventJournal.EventJournalError({ cause, method: "destroy" }))
       ),
       withLock(_storeId) {
@@ -305,3 +311,5 @@ const RemoteRow = Schema.Struct({
 })
 
 const RemoteRowArray = Schema.Array(RemoteRow)
+
+const withTracerDisabled = Effect.withTracerEnabled(false)

package/src/unstable/eventlog/SqlEventLogServerEncrypted.ts

@@ -148,7 +148,7 @@ export const makeStorage = (options?: {
           PubSub.shutdown
         )
         return { pubsub, table } as const
-      }),
+      }, withTracerDisabled),
       idleTimeToLive: "5 minutes"
     })
 
@@ -182,6 +182,7 @@ export const makeStorage = (options?: {
           )
         },
         sql.withTransaction,
+        withTracerDisabled,
         Effect.orDie
       ),
       write: Effect.fnUntraced(
@@ -228,7 +229,8 @@ export const makeStorage = (options?: {
           return allEntries
         },
         Effect.orDie,
-        Effect.scoped
+        Effect.scoped,
+        withTracerDisabled
       ),
       changes: Effect.fnUntraced(
         function*(publicKey, storeId, startSequence) {
@@ -243,10 +245,11 @@ export const makeStorage = (options?: {
           return Stream.fromArray(initial).pipe(Stream.concat(Stream.fromSubscription(subscription)))
         },
         Effect.orDie,
+        withTracerDisabled,
         Stream.unwrap
       )
     })
-  })
+  }).pipe(withTracerDisabled)
 
 const EncryptedRemoteEntrySql = Schema.Struct({
   sequence: Schema.Number,
@@ -314,3 +317,5 @@ const makeEncryptedScopeKey = (
   publicKey: string,
   storeId: string
 ): string => `${publicKey}/${storeId}`
+
+const withTracerDisabled = Effect.withTracerEnabled(false)