effect 4.0.4 → 4.0.6

package/src/cluster/SqlMessageStorage.ts

@@ -277,13 +277,42 @@ const makeEncodedStorage = Effect.fnUntraced(function*(
   const sqlFalse = sql.literal(supportsBooleans ? "FALSE" : "0")
   const sqlTrue = sql.literal(supportsBooleans ? "TRUE" : "1")
 
+  // Read SQLite IDs as text to avoid rounding on number-returning drivers
+  // such as Durable Objects.
+  const idsAsText = sql.onDialectOrElse({
+    sqlite: () => true,
+    orElse: () => false
+  })
+  const idAs = (column: string, alias: string) =>
+    idsAsText ? `CAST(${column} AS TEXT) AS ${alias}` : `${column} AS ${alias}`
+  const replyJoinColumns = "r.kind as reply_kind, r.payload as reply_payload, r.sequence as reply_sequence"
+  const messageColumns = idsAsText
+    ? `${idAs("m.id", "id")}, m.message_id, m.shard_id, m.entity_type, m.entity_id, m.kind, m.tag, m.payload, ` +
+      `m.headers, m.trace_id, m.span_id, m.sampled, m.processed, ${idAs("m.request_id", "request_id")}, ` +
+      `${idAs("m.reply_id", "reply_id")}, ${idAs("m.last_reply_id", "last_reply_id")}, m.last_read, m.deliver_at`
+    : "m.*"
+
+  const idColumn = sql.literal(idAs("id", "id"))
+  const replyColumns = sql.literal(
+    `${idAs("id", "id")}, kind, ${idAs("request_id", "request_id")}, payload, sequence`
+  )
+  const duplicateColumns = sql.literal(
+    `${idAs("m.id", "id")}, ${idAs("r.id", "reply_id")}, ${replyJoinColumns}`
+  )
+  const messageJoinColumns = sql.literal(
+    `${messageColumns}, ${idAs("r.id", "reply_reply_id")}, ${replyJoinColumns}`
+  )
+
   const selectByMessageId = (message_id: string): Effect.Effect<ReadonlyArray<Row>, SqlError> =>
     sql`
-      SELECT m.id, r.id as reply_id, r.kind as reply_kind, r.payload as reply_payload, r.sequence as reply_sequence
+      SELECT ${duplicateColumns}
       FROM ${messagesTableSql} m
       LEFT JOIN ${repliesTableSql} r ON r.id = m.last_reply_id
       WHERE m.message_id = ${message_id}
     `
+  // an insert that returned no rows hit an existing message_id
+  const selectUnlessInserted = (message_id: string) => (inserted: ReadonlyArray<unknown>) =>
+    inserted.length > 0 ? Effect.succeed([]) : selectByMessageId(message_id)
 
   const insertEnvelope: (
     row: MessageRow,
@@ -294,11 +323,7 @@ const makeEncodedStorage = Effect.fnUntraced(function*(
         INSERT INTO ${messagesTableSql} ${sql.insert(row)}
         ON CONFLICT (message_id) DO NOTHING
         RETURNING id
-      `.pipe(Effect.flatMap((rows) => {
-        // inserted a new row
-        if (rows.length > 0) return Effect.succeed([])
-        return selectByMessageId(message_id)
-      })),
+      `.pipe(Effect.flatMap(selectUnlessInserted(message_id))),
     mysql: () => (row, message_id) =>
       Effect.flatMap(
         sql`INSERT IGNORE INTO ${messagesTableSql} ${sql.insert(row)}`.raw,
@@ -316,37 +341,8 @@ const makeEncodedStorage = Effect.fnUntraced(function*(
         ON target.message_id = source.message_id
         WHEN NOT MATCHED THEN
           INSERT ${sql.insert(row)}
-        OUTPUT
-          inserted.id,
-          CASE
-            WHEN inserted.id IS NULL THEN (
-              SELECT r.id, r.kind, r.payload
-              FROM ${repliesTableSql} r
-              WHERE r.id = target.last_reply_id
-            )
-          END as reply_id,
-          CASE
-            WHEN inserted.id IS NULL THEN (
-              SELECT r.kind
-              FROM ${repliesTableSql} r
-              WHERE r.id = target.last_reply_id
-            )
-          END as reply_kind,
-          CASE
-            WHEN inserted.id IS NULL THEN (
-              SELECT r.payload
-              FROM ${repliesTableSql} r
-              WHERE r.id = target.last_reply_id
-            )
-          END as reply_payload,
-          CASE
-            WHEN inserted.id IS NULL THEN (
-              SELECT r.sequence
-              FROM ${repliesTableSql} r
-              WHERE r.id = target.last_reply_id
-            )
-          END as reply_sequence;
-      `,
+        OUTPUT inserted.id;
+      `.pipe(Effect.flatMap(selectUnlessInserted(message_id))),
     orElse: () => (row, message_id) =>
       selectByMessageId(message_id).pipe(
         Effect.tap(sql`INSERT OR IGNORE INTO ${messagesTableSql} ${sql.insert(row)}`),
@@ -374,9 +370,15 @@ const makeEncodedStorage = Effect.fnUntraced(function*(
     orElse: () => (s: string) => `'${s}'`
   })
   const forUpdate = sql.onDialectOrElse({
+    mssql: () => sql.literal(""),
     sqlite: () => sql.literal(""),
     orElse: () => sql.literal("FOR UPDATE")
   })
+  // mssql locks claimed rows with a table hint instead of FOR UPDATE
+  const updateLock = sql.onDialectOrElse({
+    mssql: () => sql.literal("WITH (UPDLOCK)"),
+    orElse: () => sql.literal("")
+  })
 
   const emptyFragment = sql.literal("")
   // mssql only limits with OFFSET/FETCH, which requires the ORDER BY that
@@ -459,8 +461,8 @@ const makeEncodedStorage = Effect.fnUntraced(function*(
       `,
     orElse: () => (shardIds: ReadonlyArray<string>, now: number, filters: UnprocessedFilters) =>
       sql<MessageJoinRow>`
-        SELECT m.*, r.id as reply_reply_id, r.kind as reply_kind, r.payload as reply_payload, r.sequence as reply_sequence
-        FROM ${messagesTableSql} m
+        SELECT ${messageJoinColumns}
+        FROM ${messagesTableSql} m ${updateLock}
         LEFT JOIN ${repliesTableSql} r ON r.id = m.last_reply_id
         WHERE m.shard_id IN (${sql.literal(shardIds.map(wrapString).join(","))})
         ${filters.addressFilter}
@@ -630,11 +632,11 @@ const makeEncodedStorage = Effect.fnUntraced(function*(
     requestIdForPrimaryKey: (primaryKey) =>
       messageIdForPrimaryKey(primaryKey).pipe(
         Effect.flatMap((messageId) =>
-          sql<{ id: string | bigint }>`SELECT id FROM ${messagesTableSql} WHERE message_id = ${messageId}`
+          sql<{ id: string | bigint }>`SELECT ${idColumn} FROM ${messagesTableSql} WHERE message_id = ${messageId}`
         ),
         Effect.flatMap((rows) =>
           rows.length === 0 && mayHaveLegacyRow(primaryKey)
-            ? sql<{ id: string | bigint }>`SELECT id FROM ${messagesTableSql} WHERE message_id = ${primaryKey}`
+            ? sql<{ id: string | bigint }>`SELECT ${idColumn} FROM ${messagesTableSql} WHERE message_id = ${primaryKey}`
             : Effect.succeed(rows)
         ),
         Effect.map((rows) => Option.map(Option.fromNullishOr(rows[0]?.id), Snowflake.Snowflake)),
@@ -649,7 +651,7 @@ const makeEncodedStorage = Effect.fnUntraced(function*(
       // - the kind is WithExit
       // - or the kind is Chunk and has not been acked yet
       sql<ReplyRow>`
-        SELECT id, kind, request_id, payload, sequence
+        SELECT ${replyColumns}
         FROM ${repliesTableSql}
         WHERE request_id IN (${sql.literal(requestIds.join(","))})
         AND (
@@ -669,7 +671,7 @@ const makeEncodedStorage = Effect.fnUntraced(function*(
 
     repliesForUnfiltered: (requestIds) =>
       sql<ReplyRow>`
-        SELECT id, kind, request_id, payload, sequence
+        SELECT ${replyColumns}
         FROM ${repliesTableSql}
         WHERE request_id IN (${sql.literal(requestIds.join(","))})
         ORDER BY rowid ASC
@@ -705,7 +707,7 @@ const makeEncodedStorage = Effect.fnUntraced(function*(
     unprocessedMessagesById(ids, now) {
       const idArr = Array.from(ids, (id) => String(id))
       return sql<MessageRow & ReplyJoinRow>`
-        SELECT m.*, r.id as reply_reply_id, r.kind as reply_kind, r.payload as reply_payload, r.sequence as reply_sequence
+        SELECT ${messageJoinColumns}
         FROM ${messagesTableSql} m
         LEFT JOIN ${repliesTableSql} r ON r.id = m.last_reply_id
         WHERE m.id IN (${sql.literal(idArr.join(","))})
@@ -840,6 +842,8 @@ export const migrations = (options?: {
       const messagesTableSql = sql(messagesTable)
       const repliesTableSql = sql(repliesTable)
 
+      // mssql UNIQUE constraints treat NULLs as equal, so nullable keys use
+      // filtered unique indexes instead
       yield* sql.onDialectOrElse({
         mssql: () =>
           sql`
@@ -853,8 +857,8 @@ export const migrations = (options?: {
               entity_id VARCHAR(255) NOT NULL,
               kind INT NOT NULL,
               tag VARCHAR(50),
-              payload TEXT,
-              headers TEXT,
+              payload NVARCHAR(MAX),
+              headers NVARCHAR(MAX),
               trace_id VARCHAR(32),
               span_id VARCHAR(16),
               sampled BIT,
@@ -864,7 +868,7 @@ export const migrations = (options?: {
               last_reply_id BIGINT,
               last_read DATETIME,
               deliver_at BIGINT,
-              UNIQUE (message_id)
+              INDEX ${sql(messagesTable + "_message_id_idx")} UNIQUE (message_id) WHERE message_id IS NOT NULL
             )
           `,
         mysql: () =>
@@ -967,17 +971,16 @@ export const migrations = (options?: {
             CREATE INDEX ${sql(requestIdLookupIndex)}
             ON ${messagesTableSql} (request_id);
           `.unprepared.pipe(Effect.ignore),
-        pg: () =>
-          Effect.gen(function*() {
-            yield* sql`
+        pg: Effect.fnUntraced(function*() {
+          yield* sql`
               CREATE INDEX IF NOT EXISTS ${sql(shardLookupIndex)}
               ON ${messagesTableSql} (shard_id, processed, last_read, deliver_at)
             `
-            yield* sql`
+          yield* sql`
               CREATE INDEX IF NOT EXISTS ${sql(requestIdLookupIndex)}
               ON ${messagesTableSql} (request_id)
             `
-          }),
+        }),
         orElse: () =>
           // sqlite
           Effect.all([
@@ -1001,11 +1004,11 @@ export const migrations = (options?: {
               rowid BIGINT IDENTITY(1,1),
               kind INT,
               request_id BIGINT NOT NULL,
-              payload TEXT NOT NULL,
+              payload NVARCHAR(MAX) NOT NULL,
               sequence INT,
               acked BIT NOT NULL DEFAULT 0,
-              CONSTRAINT ${sql(repliesTable + "_one_exit")} UNIQUE (request_id, kind),
-              CONSTRAINT ${sql(repliesTable + "_sequence")} UNIQUE (request_id, sequence)
+              INDEX ${sql(repliesTable + "_one_exit")} UNIQUE (request_id, kind) WHERE kind IS NOT NULL,
+              INDEX ${sql(repliesTable + "_sequence")} UNIQUE (request_id, sequence) WHERE sequence IS NOT NULL
             )
           `,
         mysql: () =>

package/src/cluster/SqlRunnerStorage.ts

@@ -6,6 +6,8 @@
  * shard. This module migrates the required runner and lock tables, supports an
  * optional table prefix, uses advisory locks for PostgreSQL and MySQL when
  * enabled, and provides constructors and layers for the storage service.
+ * PGlite clients always use lock table rows on the shared client, so the
+ * storage never holds their only connection.
  *
  * `layer`, `layerWith`, and `make` run the migrations before building the
  * storage. To run migrations with a different connection, such as a schema
@@ -53,9 +55,13 @@ const makeStorage = Effect.fnUntraced(function*(options: {
   const config = yield* ShardingConfig.ShardingConfig
   const shardGroups = ShardingConfig.shardGroupConfig(config)
   const availableShardGroups = Array.from(shardGroups.available)
-  const disableAdvisoryLocks = config.shardLockDisableAdvisory
   const lockOperationInterval = effectiveInterval(config)
   const sql = (yield* SqlClient.SqlClient).withoutTransforms()
+  // PGlite runs every statement on one session, so advisory locks are shared by
+  // every user of the client and a reserved connection would block all other
+  // statements. Use table leases on the shared client instead.
+  const singleSession = sql.driver === "pglite"
+  const disableAdvisoryLocks = config.shardLockDisableAdvisory || singleSession
   const layerScope = yield* Effect.scope
   const prefix = options?.prefix ?? "cluster"
   const table = (name: string) => `${prefix}_${name}`
@@ -65,7 +71,7 @@ const makeStorage = Effect.fnUntraced(function*(options: {
 
   // Keep all PostgreSQL and MySQL shard-lock operations on a rebuildable
   // reserved connection, including when advisory locks are disabled.
-  const acquireLockConn = sql.onDialectOrElse({
+  const acquireLockConn = singleSession ? undefined : sql.onDialectOrElse({
     pg: () =>
       Effect.fnUntraced(function*(scope: Scope.Scope) {
         const conn = yield* Effect.orDie(sql.reserve).pipe(
@@ -667,8 +673,8 @@ const makeStorage = Effect.fnUntraced(function*(options: {
  * permission to create tables. When `prefix` is omitted, `make` uses the
  * `cluster` prefix, creating `cluster_runners`, `cluster_locks`, and the
  * `cluster_runner_migrations` history table. PostgreSQL and MySQL use advisory
- * locks unless `ShardingConfig.shardLockDisableAdvisory` is enabled; other
- * dialects use rows in the locks table.
+ * locks unless `ShardingConfig.shardLockDisableAdvisory` is enabled or the
+ * client is PGlite; other dialects and PGlite use rows in the locks table.
  *
  * **Gotchas**
  *

package/src/cluster/internal/entityManager.ts

@@ -8,7 +8,7 @@ import * as Effect from "../../Effect.ts"
 import * as Equal from "../../Equal.ts"
 import * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
-import { identity } from "../../Function.ts"
+import { constVoid, identity } from "../../Function.ts"
 import { scopeAddFinalizerUnsafe, scopeRemoveFinalizerUnsafe } from "../../internal/effect.ts"
 import * as Latch from "../../Latch.ts"
 import * as Metric from "../../Metric.ts"
@@ -67,6 +67,9 @@ export interface EntityManager {
   readonly interruptShard: (shardId: ShardId, options?: {
     readonly force?: boolean
   }) => Effect.Effect<void>
+  // Whether any of the shard's entities are still open, including those that
+  // `interruptShard` is waiting on
+  readonly hasServersUnsafe: (shardId: ShardId) => boolean
 
   readonly activeEntityCount: Effect.Effect<number>
 }
@@ -137,6 +140,7 @@ export const make = Effect.fnUntraced(function*<
     readonly maxIdleTime?: Input | undefined
     readonly concurrency?: number | "unbounded" | undefined
     readonly mailboxCapacity?: number | "unbounded" | undefined
+    readonly mailboxMetrics?: boolean | undefined
     readonly disableFatalDefects?: boolean | undefined
     readonly defectRetryPolicy?: Schedule.Schedule<any, unknown, never, never> | undefined
     readonly spanAttributes?: Record<string, string> | undefined
@@ -147,6 +151,7 @@ export const make = Effect.fnUntraced(function*<
   const managerScope = yield* Effect.scope
   const storageEnabled = options.storage !== MessageStorage.noop
   const mailboxCapacity = options.mailboxCapacity ?? config.entityMailboxCapacity
+  const mailboxMetrics = options.mailboxMetrics ?? config.entityMailboxMetrics
   const clock = yield* Clock
   const context = yield* Effect.context<Rpc.Services<Rpcs> | Rpc.Middleware<Rpcs> | RX>()
   const defectRetryPolicy = options.defectRetryPolicy
@@ -155,6 +160,22 @@ export const make = Effect.fnUntraced(function*<
   const retryDriver = yield* Schedule.toStepWithSleep(defectRetryPolicy)
   const entityRpcs = new Map(entity.protocol.requests)
 
+  // The series reads the mailbox size on snapshot, so delivery does no extra work.
+  const registerMailboxSize = (address: EntityAddress, activeRequests: EntityState["activeRequests"]) =>
+    Metric.registerUnsafe(
+      Metric.withAttributes(ClusterMetrics.entityMailboxSize, {
+        type: entity.type,
+        id: address.entityId,
+        shard: address.shardId.toString()
+      }),
+      context as Context.Context<never>,
+      {
+        get: () => ({ value: BigInt(activeRequests.size) }),
+        update: constVoid,
+        modify: constVoid
+      }
+    )
+
   // add internal rpcs
   entityRpcs.set(KeepAliveRpc._tag, KeepAliveRpc as any)
 
@@ -162,6 +183,34 @@ export const make = Effect.fnUntraced(function*<
   // Entities finishing their in-flight requests after removal, which still
   // accept interrupts and acks
   const drainingServers = new Map<EntityId, EntityState>()
+  // Mailboxes of every resident entity, including draining ones. Unlike the
+  // server maps it is not keyed by entity id, which can be resident on several
+  // shards at once.
+  const residentMailboxes = new Set<EntityState["activeRequests"]>()
+
+  // Registered before the entities resource map, so the series is removed
+  // only after every entity has drained on shutdown.
+  yield* Effect.acquireRelease(
+    Effect.sync(() =>
+      Metric.registerUnsafe(
+        Metric.withAttributes(ClusterMetrics.entityMailboxSizeMax, { type: entity.type }),
+        context as Context.Context<never>,
+        {
+          get: () => {
+            let max = 0
+            for (const mailbox of residentMailboxes) {
+              if (mailbox.size > max) max = mailbox.size
+            }
+            return { value: BigInt(max) }
+          },
+          update: constVoid,
+          modify: constVoid
+        }
+      )
+    ),
+    (registration) => Effect.sync(registration.remove)
+  )
+
   const serverCloseLatches = new Map<EntityAddress, {
     readonly closed: Latch.Latch
     readonly force: Latch.Latch
@@ -196,10 +245,16 @@ export const make = Effect.fnUntraced(function*<
       closing: false
     }
 
+    // Finalizers run in reverse, so the mailbox series and the resident
+    // mailbox are removed only after the drain finalizer below has finished.
+    const activeRequests: EntityState["activeRequests"] = new Map()
+    let mailboxSeries: Metric.Registration | undefined
     yield* Scope.addFinalizer(
       scope,
       Effect.sync(() => {
         releaseEntity(address)
+        mailboxSeries?.remove()
+        residentMailboxes.delete(activeRequests)
       })
     )
 
@@ -213,7 +268,6 @@ export const make = Effect.fnUntraced(function*<
       }
     )
 
-    const activeRequests: EntityState["activeRequests"] = new Map()
     const retired = Latch.makeUnsafe()
     const isActive = () => !retired.isOpen()
 
@@ -250,7 +304,7 @@ export const make = Effect.fnUntraced(function*<
         ) as Effect.Effect<Context.Context<Rpc.ToHandler<Rpcs>>>)
 
         const server = yield* RpcServer.makeNoSerialization(entity.protocol, {
-          spanPrefix: `${entity.type}(${address.entityId})`,
+          spanPrefix: entity.type,
           spanAttributes: {
             ...options.spanAttributes,
             "entity.type": entity.type,
@@ -488,6 +542,9 @@ export const make = Effect.fnUntraced(function*<
             yield* state.write(0, { _tag: "Eof" })
           }).pipe(
             Effect.andThen(endLatch.await),
+            // A defect restart that finds the entity retired opens `endLatch`
+            // without building handlers, so the writes above may never land.
+            Effect.raceFirst(endLatch.await),
             Effect.timeoutOption(config.entityTerminationTimeout),
             Effect.interruptible
           ),
@@ -505,6 +562,10 @@ export const make = Effect.fnUntraced(function*<
     // Do not make shard interruption wait for an entity that is still building.
     serverCloseLatches.set(address, closeLatches)
     activeServers.set(address.entityId, state)
+    residentMailboxes.add(activeRequests)
+    if (mailboxMetrics) {
+      mailboxSeries = registerMailboxSize(address, activeRequests)
+    }
 
     return state
   }, Effect.provideService(CurrentLogAnnotations, {})))
@@ -521,15 +582,18 @@ export const make = Effect.fnUntraced(function*<
     })
   }
 
-  // update metrics for active servers
-  const typeAttributes = Metric.CurrentMetricAttributes.context({ type: entity.type })
-  yield* Effect.sync(() => {
-    ClusterMetrics.entities.updateUnsafe(BigInt(activeServers.size), typeAttributes)
-  }).pipe(
-    Effect.andThen(Effect.sleep(1000)),
-    Effect.forever,
-    Effect.forkIn(managerScope)
+  // The series reads the active entity count on snapshot, so an idle runner
+  // does no work.
+  const entitiesSeries = Metric.registerUnsafe(
+    Metric.withAttributes(ClusterMetrics.entities, { type: entity.type }),
+    context as Context.Context<never>,
+    {
+      get: () => ({ value: BigInt(activeServers.size) }),
+      update: constVoid,
+      modify: constVoid
+    }
   )
+  yield* Scope.addFinalizer(managerScope, Effect.sync(entitiesSeries.remove))
 
   function sendEnvelope(server: EntityState, message: Message.IncomingEnvelope): Effect.Effect<void> {
     const entry = server.activeRequests.get(message.envelope.requestId)
@@ -752,6 +816,12 @@ export const make = Effect.fnUntraced(function*<
     clearProcessed() {
       processedRequestIds.clear()
     },
+    hasServersUnsafe(shardId) {
+      for (const address of serverCloseLatches.keys()) {
+        if (shardId[Equal.symbol](address.shardId)) return true
+      }
+      return false
+    },
     isResidentUnsafe: (address) => entities.hasUnsafe(address),
     residentAddressesUnsafe: () => entities.keysUnsafe(),
     sendLocal,

package/src/devtools/DevTools.ts

@@ -56,8 +56,9 @@ export const layerWebSocket = (
  * **Gotchas**
  *
  * This layer only installs the client-side tracer; it does not start a devtools
- * server, so the configured WebSocket endpoint must already be reachable. It
- * relies on `globalThis.WebSocket` being available in the runtime.
+ * server. The client retries failed connections every second, so the configured
+ * endpoint can become reachable after startup. It relies on
+ * `globalThis.WebSocket` being available in the runtime.
  *
  * @see {@link layerWebSocket} for installing the devtools tracer with an explicit `WebSocketConstructor` requirement
  * @see {@link layerSocket} for installing the devtools tracer over an existing `Socket` transport

package/src/devtools/DevToolsClient.ts

@@ -9,7 +9,6 @@
  * @stability unstable
  * @since 4.0.0
  */
-import * as Cause from "../Cause.ts"
 import * as Context from "../Context.ts"
 import * as Deferred from "../Deferred.ts"
 import * as Effect from "../Effect.ts"
@@ -18,6 +17,7 @@ import * as Fiber from "../Fiber.ts"
 import * as Layer from "../Layer.ts"
 import * as Metric from "../Metric.ts"
 import * as Queue from "../Queue.ts"
+import * as Schedule from "../Schedule.ts"
 import * as Schema from "../Schema.ts"
 import type * as Scope from "../Scope.ts"
 import * as Socket from "../socket/Socket.ts"
@@ -49,7 +49,20 @@ const makeEffect = Effect.gen(function*() {
   const socket = yield* Socket.Socket
   const services = yield* Effect.context<never>()
   const requests = yield* Queue.unbounded<DevToolsSchema.Request>()
+  yield* Queue.offer(requests, { _tag: "Ping" })
   const connected = yield* Deferred.make<void>()
+  let closing = false
+  let writable = false
+  const setWritable = (value: boolean) =>
+    Effect.sync(() => {
+      writable = value
+    })
+  // Tracks whether the current connection has a writer that can drain the
+  // queue on shutdown.
+  const transport = Socket.make({
+    reader: socket.reader,
+    writer: Effect.tap(socket.writer, Effect.acquireRelease(setWritable(true), () => setWritable(false)))
+  })
 
   const offerMetricsSnapshot = Effect.sync(() => {
     Queue.offerUnsafe(requests, toMetricsSnapshot(services))
@@ -70,24 +83,28 @@ const makeEffect = Effect.gen(function*() {
 
   const fiber = yield* Stream.fromQueue(requests).pipe(
     Stream.pipeThroughChannel(
-      Ndjson.duplexSchemaString(Socket.toChannelString(socket), {
+      Ndjson.duplexSchemaString(Socket.toChannelString(transport), {
         inputSchema: RequestSchema,
         outputSchema: ResponseSchema
       })
     ),
     Stream.onFirst(() => Deferred.completeWith(connected, Effect.void)),
+    // Each run closes its stream scope, including the socket reader and writer,
+    // before retrying with a fresh connection and the same request queue.
     Stream.runForEach(handleResponse),
+    Effect.tapError((error) => Effect.logDebug("DevTools connection failed", error)),
+    Effect.retry({ schedule: Schedule.spaced("1 second"), while: () => !closing }),
     Effect.forkDetach
   )
 
-  yield* Effect.addFinalizer(() =>
-    offerMetricsSnapshot.pipe(
-      Effect.andThen(
-        Effect.flatMap(Effect.fiberId, (id) => Queue.failCause(requests, Cause.interrupt(id)))
-      ),
-      Effect.andThen(Fiber.await(fiber))
-    )
-  )
+  yield* Effect.addFinalizer(Effect.fnUntraced(function*() {
+    closing = true
+    yield* offerMetricsSnapshot
+    yield* Queue.interrupt(requests)
+    // A ready writer drains the queue before stopping. Failed or pending
+    // acquisition cannot observe the queue interruption, so stop it directly.
+    yield* writable ? Fiber.await(fiber) : Fiber.interrupt(fiber)
+  }))
 
   yield* Effect.suspend(() => Queue.offer(requests, { _tag: "Ping" })).pipe(
     Effect.delay("3 seconds"),

package/src/encoding/Base64Url.ts

@@ -32,6 +32,7 @@ import { EncodingError } from "./EncodingError.ts"
  * Base64Url.encode(bytes) // => "SGVsbG8_"
  * ```
  *
+ * @see {@link encodePadded} for output that keeps `=` padding
  * @see {@link decode} for decoding URL-safe Base64 to bytes
  * @see {@link decodeString} for decoding URL-safe Base64 to UTF-8 text
  *
@@ -42,6 +43,36 @@ import { EncodingError } from "./EncodingError.ts"
 export const encode: (input: Uint8Array | string) => string = (input) =>
   Base64.encode(input).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_")
 
+/**
+ * Encodes the given value into a padded URL-safe Base64 string.
+ *
+ * **When to use**
+ *
+ * Use when a consumer requires `=` padding on URL-safe Base64, such as Go's
+ * `base64.URLEncoding`.
+ *
+ * **Details**
+ *
+ * Same as {@link encode}, but keeps the `=` padding. {@link decode} accepts
+ * both forms.
+ *
+ * **Example** (Encoding padded URL-safe Base64)
+ *
+ * ```ts import.meta.vitest
+ * import { Base64Url } from "effect/encoding"
+ *
+ * Base64Url.encodePadded("fo") // => "Zm8="
+ * ```
+ *
+ * @see {@link encode} for unpadded output
+ *
+ * @stability stable
+ * @category encoding
+ * @since 4.0.6
+ */
+export const encodePadded: (input: Uint8Array | string) => string = (input) =>
+  Base64.encode(input).replace(/\+/g, "-").replace(/\//g, "_")
+
 /**
  * Decodes a padded or unpadded URL-safe Base64 string into bytes safely.
  *

package/src/encoding/Ini.ts

@@ -77,6 +77,9 @@ const unquote = (input: string | undefined): string => {
       output += character
     }
   }
+  if (escaped) {
+    output += "\\"
+  }
   return output.trim()
 }