effect 4.0.0-beta.50 → 4.0.0-beta.52

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/index.ts

@@ -3528,6 +3528,7 @@ export * as SchemaAST from "./SchemaAST.ts"
  * - Parse/stringify JSON → {@link parseJson}, {@link stringifyJson}
  * - Encode/decode Base64 → {@link encodeBase64}, {@link decodeBase64}, {@link decodeBase64String}
  * - Encode/decode Hex → {@link encodeHex}, {@link decodeHex}, {@link decodeHexString}
+ * - Encode/decode URI components → {@link encodeUriComponent}, {@link decodeUriComponent}
  * - Parse DateTime → {@link dateTimeUtcFromInput}
  * - Decode/encode FormData → {@link decodeFormData}, {@link encodeFormData}
  * - Decode/encode URLSearchParams → {@link decodeURLSearchParams}, {@link encodeURLSearchParams}
@@ -3795,6 +3796,8 @@ export * as SchemaRepresentation from "./SchemaRepresentation.ts"
  * - Wrap nullable/optional as Option → {@link optionFromNullOr}, {@link optionFromOptionalKey}, {@link optionFromOptional}
  * - Parse URLs → {@link urlFromString}
  * - Base64 ↔ Uint8Array → {@link uint8ArrayFromBase64String}
+ * - Base64 ↔ string → {@link stringFromBase64String}
+ * - URI component ↔ string → {@link stringFromUriComponent}
  * - JSON string ↔ unknown → {@link fromJsonString}
  * - FormData/URLSearchParams ↔ unknown → {@link fromFormData}, {@link fromURLSearchParams}
  * - Check if a value is a Transformation → {@link isTransformation}

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/internal/schema/representation.ts

@@ -11,7 +11,6 @@ import * as AST from "../../SchemaAST.ts"
 import type * as SchemaRepresentation from "../../SchemaRepresentation.ts"
 import * as InternalAnnotations from "./annotations.ts"
 import * as InternalSchema from "./schema.ts"
-import * as InternalToCodec from "./to-codec.ts"
 
 /** @internal */
 export function fromAST(ast: AST.AST): SchemaRepresentation.Document {
@@ -213,7 +212,7 @@ export function fromASTs(asts: readonly [AST.AST, ...Array<AST.AST>]): SchemaRep
           ...annotations
         }
       case "Union": {
-        const types = InternalToCodec.jsonReorder(last.types)
+        const types = InternalSchema.jsonReorder(last.types)
         return {
           _tag: last._tag,
           types: types.map((ast) => recur(ast)),

package/src/internal/schema/schema.ts

@@ -42,6 +42,7 @@ export function make<S extends Schema.Top>(ast: S["ast"], options?: object): S {
 /** @internal */
 export const SchemaErrorTypeId = "~effect/Schema/SchemaError"
 
+// not internal
 export class SchemaError {
   readonly [SchemaErrorTypeId] = SchemaErrorTypeId
   readonly _tag = "SchemaError"
@@ -57,3 +58,45 @@ export class SchemaError {
     return `SchemaError(${this.message})`
   }
 }
+
+/** @internal */
+export const jsonReorder = makeReorder(getJsonPriority)
+
+function getJsonPriority(ast: AST.AST): number {
+  switch (ast._tag) {
+    case "BigInt":
+    case "Symbol":
+    case "UniqueSymbol":
+      return 0
+    default:
+      return 1
+  }
+}
+
+/** @internal */
+export function makeReorder(getPriority: (ast: AST.AST) => number) {
+  return (types: ReadonlyArray<AST.AST>): ReadonlyArray<AST.AST> => {
+    // Create a map of original indices for O(1) lookup
+    const indexMap = new Map<AST.AST, number>()
+    for (let i = 0; i < types.length; i++) {
+      indexMap.set(AST.toEncoded(types[i]), i)
+    }
+
+    // Create a sorted copy of the types array
+    const sortedTypes = [...types].sort((a, b) => {
+      a = AST.toEncoded(a)
+      b = AST.toEncoded(b)
+      const pa = getPriority(a)
+      const pb = getPriority(b)
+      if (pa !== pb) return pa - pb
+      // If priorities are equal, maintain original order (stable sort)
+      return indexMap.get(a)! - indexMap.get(b)!
+    })
+
+    // Check if order changed by comparing arrays
+    const orderChanged = sortedTypes.some((ast, index) => ast !== types[index])
+
+    if (!orderChanged) return types
+    return sortedTypes
+  }
+}

package/src/unstable/ai/McpServer.ts

@@ -383,6 +383,14 @@ export const run: (options: {
     const initializePayload = getInitializedClient(clientSessions, client.id, headers)
     const isInitialize = rpc._tag === "initialize"
     if (!isInitialize && !initializePayload) {
+      const fiber = Fiber.getCurrent()!
+      const httpRequest = Context.getOrUndefined(fiber.context, HttpServerRequest.HttpServerRequest)
+      if (httpRequest) {
+        appendPreResponseHandlerUnsafe(
+          httpRequest,
+          () => Effect.succeed(HttpServerResponse.empty({ status: 404 }))
+        )
+      }
       return Effect.die(new Error(`Mcp-Session-Id does not exist`))
     }
     return Effect.provideService(

package/src/unstable/cli/index.ts

@@ -25,6 +25,8 @@ export * as CliOutput from "./CliOutput.ts"
 export * as Command from "./Command.ts"
 
 /**
+ * Shell completion descriptors and script generation for the unstable CLI API.
+ *
  * @since 4.0.0
  */
 export * as Completions from "./Completions.ts"

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
         )
     }),