effect 4.0.0-rc.111 → 4.0.0-rc.113

package/src/unstable/encoding/Sse.ts

@@ -311,7 +311,7 @@ export function makeParser(onParse: (event: AnyEvent) => void, options?: DecodeO
       let fieldLength = startingFieldLength
       let character: string
 
-      for (let index = startingPosition; lineLength < 0 && index < length; ++index) {
+      for (let index = position + startingPosition; lineLength < 0 && index < length; ++index) {
         character = buffer[index]
         if (character === ":" && fieldLength < 0) {
           fieldLength = index - position

package/src/unstable/encoding/Toml.ts

@@ -45,7 +45,7 @@ class TomlParser {
   private index = 0
   private line = 1
   private column = 1
-  private readonly explicitTables = new Set<string>()
+  private readonly explicitTables = new Set<Table>()
 
   constructor(input: string) {
     this.input = input
@@ -85,14 +85,14 @@ class TomlParser {
     }
     this.finishStatement()
 
-    const pathKey = JSON.stringify(path)
-    if (!array && this.explicitTables.has(pathKey)) {
+    const table = this.resolveTable(path, array)
+    if (!array && this.explicitTables.has(table)) {
       this.fail(`Cannot redefine table '${path.join(".")}'`)
     }
     if (!array) {
-      this.explicitTables.add(pathKey)
+      this.explicitTables.add(table)
     }
-    this.current = this.resolveTable(path, array)
+    this.current = table
   }
 
   private resolveTable(path: ReadonlyArray<string>, array: boolean): Table {
@@ -495,6 +495,8 @@ class TomlParser {
 /**
  * Parses a TOML document into a null-prototype record.
  *
+ * **Details**
+ *
  * Offset date-times are represented by `Date`, matching the package this
  * parser replaces. Local dates and times remain strings.
  *

package/src/unstable/encoding/Yaml.ts

@@ -480,14 +480,25 @@ class YamlParser {
     if (style === "|") {
       output = content.join("\n")
     } else {
-      for (let index = 0; index < content.length; index++) {
-        output += content[index]
-        if (index < content.length - 1) {
-          output += content[index].length === 0 || content[index + 1].length === 0 ? "\n" : " "
+      let blankLines = 0
+      let previousMoreIndented: boolean | undefined
+      for (const line of content) {
+        if (line.length === 0) {
+          blankLines++
+        } else {
+          const moreIndented = line.startsWith(" ")
+          const hardBreak = moreIndented || previousMoreIndented === true
+          if (previousMoreIndented === undefined) output += "\n".repeat(blankLines)
+          else if (blankLines === 0) output += hardBreak ? "\n" : " "
+          else output += "\n".repeat(blankLines + (hardBreak ? 1 : 0))
+          output += line
+          blankLines = 0
+          previousMoreIndented = moreIndented
         }
       }
+      output += "\n".repeat(blankLines)
     }
-    if (chomp === "keep") return `${output}\n`
+    if (chomp === "keep") return output.endsWith("\n") ? output : `${output}\n`
     output = output.replace(/\n+$/, "")
     return chomp === "strip" ? output : `${output}\n`
   }
@@ -517,6 +528,8 @@ class YamlParser {
 /**
  * Parses one YAML document into JavaScript values.
  *
+ * **Details**
+ *
  * The core YAML 1.2 scalar schema is used, so booleans, nulls, and numbers are
  * decoded while date-like values remain strings.
  *

package/src/unstable/encoding/index.ts

@@ -12,12 +12,12 @@ export * as Ini from "./Ini.ts"
 /**
  * @since 4.0.0
  */
-export * as Msgpack from "./Msgpack.ts"
+export * as Ndjson from "./Ndjson.ts"
 
 /**
  * @since 4.0.0
  */
-export * as Ndjson from "./Ndjson.ts"
+export * as SchemaBinary from "./SchemaBinary.ts"
 
 /**
  * @since 4.0.0

package/src/unstable/eventlog/Event.ts

@@ -5,7 +5,7 @@
  * replicas. It gives an event a stable tag, derives the aggregate or entity
  * primary key from the decoded payload, and records the schemas used for the
  * payload, handler result, and handler errors. The payload schema is also used
- * to derive the MessagePack encoding for journal entries and remote
+ * to derive the SchemaBinary encoding for journal entries and remote
  * replication.
  *
  * @since 4.0.0
@@ -13,7 +13,7 @@
 import { pipeArguments } from "../../Pipeable.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
-import * as Msgpack from "../encoding/Msgpack.ts"
+import * as SchemaBinary from "../encoding/SchemaBinary.ts"
 
 /**
  * Unique type identifier used to mark event log event definitions.
@@ -45,7 +45,7 @@ export const isEvent = (u: unknown): u is Event<any, any, any, any> => Predicate
  * **Details**
  *
  * An event definition contains its tag, primary-key function, payload schema,
- * MessagePack payload schema, success schema, and error schema.
+ * SchemaBinary payload codec, success schema, and error schema.
  *
  * @category models
  * @since 4.0.0
@@ -60,7 +60,7 @@ export interface Event<
   readonly tag: Tag
   readonly primaryKey: (payload: Schema.Schema.Type<Payload>) => string
   readonly payload: Payload
-  readonly payloadMsgPack: Msgpack.schema<Payload>
+  readonly payloadSchemaBinary: SchemaBinary.toCodec<Payload>
   readonly success: Success
   readonly error: Error
 }
@@ -97,7 +97,7 @@ export interface Any {
   readonly tag: string
   readonly primaryKey: (payload: any) => string
   readonly payload: Schema.Top
-  readonly payloadMsgPack: Msgpack.schema<Schema.Top>
+  readonly payloadSchemaBinary: SchemaBinary.toCodec<Schema.Top>
   readonly success: Schema.Top
   readonly error: Schema.Top
 }
@@ -383,7 +383,7 @@ const Proto = {
  * **Details**
  *
  * If omitted, the payload and success schemas default to `Schema.Void`, the error
- * schema defaults to `Schema.Never`, and the MessagePack payload schema is derived
+ * schema defaults to `Schema.Never`, and the SchemaBinary payload codec is derived
  * from the payload schema.
  *
  * @category constructors
@@ -415,7 +415,7 @@ export function make(options: {
     tag: options.tag,
     primaryKey: options.primaryKey,
     payload,
-    payloadMsgPack: Msgpack.schema(payload),
+    payloadSchemaBinary: SchemaBinary.toCodec(payload),
     success,
     error
   })

package/src/unstable/eventlog/EventJournal.ts

@@ -11,6 +11,7 @@
  *
  * @since 4.0.0
  */
+import * as Arr from "../../Array.ts"
 import type { Brand } from "../../Brand.ts"
 import * as Context from "../../Context.ts"
 import * as Data from "../../Data.ts"
@@ -18,12 +19,13 @@ import * as DateTime from "../../DateTime.ts"
 import * as Effect from "../../Effect.ts"
 import * as Uuid from "../../internal/uuid.ts"
 import * as Layer from "../../Layer.ts"
+import type { Option } from "../../Option.ts"
 import * as Order from "../../Order.ts"
 import * as PubSub from "../../PubSub.ts"
 import * as Schema from "../../Schema.ts"
 import type { Scope } from "../../Scope.ts"
 import * as Semaphore from "../../Semaphore.ts"
-import * as Msgpack from "../encoding/Msgpack.ts"
+import * as SchemaBinary from "../encoding/SchemaBinary.ts"
 import type { StoreId } from "./EventLogMessage.ts"
 
 /**
@@ -78,12 +80,16 @@ export class EventJournal extends Context.Service<EventJournal, {
   }, EventJournalError>
 
   /**
-   * Return the uncommitted entries for a remote source.
+   * Run an effect with the uncommitted entries for a remote source.
+   *
+   * The effect is not run when there are no uncommitted entries, in which case
+   * `Option.none()` is returned. Otherwise, its result is wrapped in
+   * `Option.some()`.
    */
   readonly withRemoteUncommited: <A, E, R>(
     remoteId: RemoteId,
-    f: (entries: ReadonlyArray<Entry>) => Effect.Effect<A, E, R>
-  ) => Effect.Effect<A, EventJournalError | E, R>
+    f: (entries: Arr.NonEmptyReadonlyArray<Entry>) => Effect.Effect<A, E, R>
+  ) => Effect.Effect<Option<A>, EventJournalError | E, R>
 
   /**
    * Retrieve the first unused sequence number for a remote source.
@@ -266,8 +272,8 @@ export const entryIdMillis = (entryId: EntryId): number => {
  *
  * **Details**
  *
- * An entry records its ID, event tag, primary key, and MessagePack-encoded
- * payload, with helpers for array MessagePack encoding and creation timestamps.
+ * An entry records its ID, event tag, primary key, and SchemaBinary-encoded
+ * payload, with helpers for array SchemaBinary encoding and creation timestamps.
  *
  * @category schemas
  * @since 4.0.0
@@ -279,25 +285,25 @@ export class Entry extends Schema.Class<Entry>("effect/eventlog/EventJournal/Ent
   payload: Schema.Uint8Array
 }) {
   /**
-   * MessagePack schema for arrays of committed event journal entries.
+   * SchemaBinary codec for arrays of committed event journal entries.
    *
    * @since 4.0.0
    */
-  static arrayMsgpack = Schema.Array(Msgpack.schema(Entry))
+  static arraySchemaBinary = Schema.Array(SchemaBinary.toCodec(Entry))
 
   /**
-   * Encodes arrays of committed entries with the MessagePack entry schema.
+   * Encodes arrays of committed entries with the SchemaBinary entry codec.
    *
    * @since 4.0.0
    */
-  static encodeArray = Schema.encodeUnknownEffect(Entry.arrayMsgpack)
+  static encodeArray = Schema.encodeUnknownEffect(Entry.arraySchemaBinary)
 
   /**
-   * Decodes arrays of committed entries with the MessagePack entry schema.
+   * Decodes arrays of committed entries with the SchemaBinary entry codec.
    *
    * @since 4.0.0
    */
-  static decodeArray = Schema.decodeUnknownEffect(Entry.arrayMsgpack)
+  static decodeArray = Schema.decodeUnknownEffect(Entry.arraySchemaBinary)
 
   /**
    * Ordering for committed entries by their event journal entry id.
@@ -471,7 +477,7 @@ export const makeMemory: Effect.Effect<EventJournal["Service"]> = Effect.gen(fun
     withRemoteUncommited: (remoteId, f) =>
       Effect.acquireUseRelease(
         Effect.sync(() => ensureRemote(remoteId).missing.slice()),
-        f,
+        (entries) => Arr.isReadonlyArrayNonEmpty(entries) ? Effect.asSome(f(entries)) : Effect.succeedNone,
         (entries, exit) =>
           Effect.sync(() => {
             if (exit._tag === "Failure") return
@@ -705,7 +711,7 @@ export const makeIndexedDb = (options?: {
           return Effect.sync(() => tx.abort())
         }).pipe(
           Effect.flatMap((entries) => {
-            if (entries.length === 0) return f(entries)
+            if (!Arr.isReadonlyArrayNonEmpty(entries)) return Effect.succeedNone
             const entryId = entries[entries.length - 1].id
             return Effect.uninterruptibleMask((restore) =>
               restore(f(entries)).pipe(
@@ -715,7 +721,8 @@ export const makeIndexedDb = (options?: {
                       remoteId,
                       entryId
                     }))
-                )
+                ),
+                Effect.asSome
               )
             )
           })

package/src/unstable/eventlog/EventLog.ts

@@ -589,7 +589,7 @@ export const groupCompaction = <Events extends Event.Any, R>(
         effect: Effect.fnUntraced(function*({ entries, write }): Effect.fn.Return<void> {
           const isEventTag = (tag: string): tag is Event.Tag<Events> => Object.hasOwn(group.events, tag)
           const decodePayload = <Tag extends Event.Tag<Events>>(tag: Tag, payload: Uint8Array) =>
-            Schema.decodeUnknownEffect(group.events[tag].payloadMsgPack)(payload).pipe(
+            Schema.decodeUnknownEffect(group.events[tag].payloadSchemaBinary)(payload).pipe(
               Effect.updateContext((input) => Context.merge(services, input)),
               Effect.orDie
             ) as unknown as Effect.Effect<Event.PayloadWithTag<Events, Tag>>
@@ -602,7 +602,7 @@ export const groupCompaction = <Events extends Event.Any, R>(
             const entry = new Entry({
               id: makeEntryIdUnsafe({ msecs: timestamp }),
               event: tag,
-              payload: yield* Schema.encodeUnknownEffect(event.payloadMsgPack)(payload).pipe(
+              payload: yield* Schema.encodeUnknownEffect(event.payloadSchemaBinary)(payload).pipe(
                 Effect.orDie
               ) as any,
               primaryKey: event.primaryKey(payload)
@@ -702,7 +702,7 @@ export const makeReplayFromRemote = (options: {
   readonly handlers: ReadonlyMap<string, Handlers.Item<any>>
   readonly storeId: StoreId
   readonly identity: Identity["Service"]
-  readonly reactivity: Reactivity["Service"]
+  readonly reactivity: Reactivity
   readonly reactivityKeys: Record<string, ReadonlyArray<string>>
   readonly logAnnotations: {
     readonly service: string
@@ -719,7 +719,7 @@ export const makeReplayFromRemote = (options: {
         return yield* Effect.logDebug(`Event handler not found for: "${entry.event}"`)
       }
 
-      const decodePayload = Schema.decodeUnknownEffect(handler.event.payloadMsgPack)
+      const decodePayload = Schema.decodeUnknownEffect(handler.event.payloadSchemaBinary)
       const decodedConflicts: Array<{ entry: Entry; payload: unknown }> = new Array(conflicts.length)
       for (let i = 0; i < conflicts.length; i++) {
         decodedConflicts[i] = {
@@ -763,6 +763,11 @@ export const makeReplayFromRemote = (options: {
       })
   )
 
+const remoteRetrySchedule = Schedule.min([
+  Schedule.exponential(200, 1.5),
+  Schedule.spaced({ seconds: 10 })
+])
+
 const make = Effect.gen(function*() {
   const storeId = yield* CurrentStoreId
   const identity = yield* Identity
@@ -860,12 +865,7 @@ const make = Effect.gen(function*() {
       }).pipe(
         Effect.scoped,
         Effect.catchCause(Effect.logError),
-        Effect.repeat(
-          Schedule.min([
-            Schedule.exponential(200, 1.5),
-            Schedule.spaced({ seconds: 10 })
-          ])
-        ),
+        Effect.repeat(remoteRetrySchedule),
         Effect.annotateLogs({
           service: "EventLog",
           effect: "runRemote consume"
@@ -874,11 +874,21 @@ const make = Effect.gen(function*() {
       )
 
       const write = journal.withRemoteUncommited(remote.id, (entries) => remote.write({ identity, entries, storeId }))
+      const writeUntilSuccess = write.pipe(
+        Effect.tapCause(Effect.logDebug),
+        Effect.retry(remoteRetrySchedule)
+      )
       yield* Effect.addFinalizer(() => Effect.ignore(write))
-      yield* write
       const changesSub = yield* journal.changes
-      return yield* PubSub.takeAll(changesSub).pipe(
-        Effect.andThen(write),
+      const changes = yield* Queue.dropping<void>(1)
+      yield* PubSub.takeAll(changesSub).pipe(
+        Effect.andThen(Queue.offer(changes, undefined)),
+        Effect.forever,
+        Effect.forkScoped
+      )
+      yield* writeUntilSuccess
+      return yield* Queue.take(changes).pipe(
+        Effect.andThen(writeUntilSuccess),
         Effect.catchCause(Effect.logError),
         Effect.forever
       )
@@ -893,7 +903,7 @@ const make = Effect.gen(function*() {
     readonly event: string
     readonly payload: unknown
   }) {
-    const payload = yield* Schema.encodeUnknownEffect(handler.event.payloadMsgPack)(options.payload).pipe(
+    const payload = yield* Schema.encodeUnknownEffect(handler.event.payloadSchemaBinary)(options.payload).pipe(
       Effect.orDie
     )
     return yield* journal.withLock(storeId)(journal.write({

package/src/unstable/eventlog/EventLogMessage.ts

@@ -10,8 +10,9 @@
  */
 import type { NonEmptyArray, NonEmptyReadonlyArray } from "../../Array.ts"
 import type { Brand } from "../../Brand.ts"
+import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
-import * as Msgpack from "../encoding/Msgpack.ts"
+import * as SchemaBinary from "../encoding/SchemaBinary.ts"
 import * as Rpc from "../rpc/Rpc.ts"
 import * as RpcGroup from "../rpc/RpcGroup.ts"
 import * as RpcMiddleware from "../rpc/RpcMiddleware.ts"
@@ -71,7 +72,16 @@ export class EventLogProtocolError extends Schema.TaggedError<EventLogProtocolEr
   storeId: Schema.optional(StoreId),
   code: Schema.Literals(["Unauthorized", "Forbidden", "NotFound", "InvalidRequest", "InternalServerError"]),
   message: Schema.String
-}) {}
+}) {
+  /**
+   * Returns `true` when the value is an `EventLogProtocolError`.
+   *
+   * @since 4.0.0
+   */
+  static is(u: unknown): u is EventLogProtocolError {
+    return Predicate.isTagged(u, "EventLogProtocolError")
+  }
+}
 
 /**
  * RPC middleware that authenticates event-log requests and provides the client
@@ -188,7 +198,7 @@ export class ChunkedMessage
    * @since 4.0.0
    */
   static split(id: number, data: Uint8Array): NonEmptyReadonlyArray<ChunkedMessage> {
-    const parts = Math.ceil(data.byteLength / ChunkedMessage.chunkSize)
+    const parts = Math.max(1, Math.ceil(data.byteLength / ChunkedMessage.chunkSize))
     const result: NonEmptyArray<ChunkedMessage> = new Array(parts) as any
     for (let i = 0; i < parts; i++) {
       const start = i * ChunkedMessage.chunkSize
@@ -272,9 +282,9 @@ export class WriteEntries extends Schema.Class<WriteEntries>("effect/eventlog/Ev
   storeId: StoreId,
   encryptedEntries: Schema.Array(EncryptedEntry)
 }) {
-  static FromMsgpack = Msgpack.schema(WriteEntries)
-  static encode = Schema.encodeEffect(this.FromMsgpack)
-  static decode = Schema.decodeEffect(this.FromMsgpack)
+  static FromSchemaBinary = SchemaBinary.toCodec(WriteEntries)
+  static encode = Schema.encodeEffect(this.FromSchemaBinary)
+  static decode = Schema.decodeEffect(this.FromSchemaBinary)
   get encoded() {
     return WriteEntries.encode(this)
   }
@@ -293,9 +303,9 @@ export class WriteEntriesUnencrypted
     entries: Schema.Array(Entry)
   })
 {
-  static FromMsgpack = Msgpack.schema(WriteEntriesUnencrypted)
-  static encode = Schema.encodeEffect(this.FromMsgpack)
-  static decode = Schema.decodeEffect(this.FromMsgpack)
+  static FromSchemaBinary = SchemaBinary.toCodec(WriteEntriesUnencrypted)
+  static encode = Schema.encodeEffect(this.FromSchemaBinary)
+  static decode = Schema.decodeEffect(this.FromSchemaBinary)
   get encoded() {
     return WriteEntriesUnencrypted.encode(this)
   }
@@ -336,12 +346,12 @@ export class ChangesRpc extends Rpc.make("EventLog.Changes", {
   error: EventLogProtocolError,
   stream: true
 }).middleware(EventLogAuthentication) {
-  static EncryptedFromMsgpack = Msgpack.schema(Schema.NonEmptyArray(EncryptedRemoteEntry))
-  static UnencryptedFromMsgpack = Msgpack.schema(Schema.NonEmptyArray(RemoteEntry))
-  static encodeEncrypted = Schema.encodeEffect(ChangesRpc.EncryptedFromMsgpack)
-  static decodeEncrypted = Schema.decodeEffect(ChangesRpc.EncryptedFromMsgpack)
-  static encodeUnencrypted = Schema.encodeEffect(ChangesRpc.UnencryptedFromMsgpack)
-  static decodeUnencrypted = Schema.decodeEffect(ChangesRpc.UnencryptedFromMsgpack)
+  static EncryptedFromSchemaBinary = SchemaBinary.toCodec(Schema.NonEmptyArray(EncryptedRemoteEntry))
+  static UnencryptedFromSchemaBinary = SchemaBinary.toCodec(Schema.NonEmptyArray(RemoteEntry))
+  static encodeEncrypted = Schema.encodeEffect(ChangesRpc.EncryptedFromSchemaBinary)
+  static decodeEncrypted = Schema.decodeEffect(ChangesRpc.EncryptedFromSchemaBinary)
+  static encodeUnencrypted = Schema.encodeEffect(ChangesRpc.UnencryptedFromSchemaBinary)
+  static decodeUnencrypted = Schema.decodeEffect(ChangesRpc.UnencryptedFromSchemaBinary)
 }
 
 /**

package/src/unstable/eventlog/EventLogRemote.ts

@@ -30,7 +30,7 @@ import {
   Authenticate,
   ChangesRpc,
   ChunkedMessage,
-  type EventLogProtocolError,
+  EventLogProtocolError,
   EventLogRemoteRpcs,
   type HelloResponse,
   type StoreId,
@@ -83,7 +83,16 @@ export class EventLogRemote extends Context.Service<EventLogRemote, {
 export class EventLogRemoteError extends Data.TaggedError("EventLogRemoteError")<{
   readonly method: string
   readonly cause: unknown
-}> {}
+}> {
+  /**
+   * Returns `true` when the value is an `EventLogRemoteError`.
+   *
+   * @since 4.0.0
+   */
+  static is(u: unknown): u is EventLogRemoteError {
+    return Predicate.isTagged(u, "EventLogRemoteError")
+  }
+}
 
 const getIdentityRootSecretMaterial = makeGetIdentityRootSecretMaterial(globalThis.crypto)
 
@@ -206,8 +215,10 @@ export const makeWith = Effect.fnUntraced(function*({ encodeWrite, decodeChanges
     Effect.retry(effect, {
       while(e) {
         hello = null
-        const isForbidden = Predicate.isTagged(e, "EventLogProtocolError") &&
-          (e as any as EventLogProtocolError).code === "Forbidden"
+        const error = EventLogRemoteError.is(e) && e.method === "authenticate"
+          ? e.cause
+          : e
+        const isForbidden = EventLogProtocolError.is(error) && error.code === "Forbidden"
         return Cache.invalidate(authCache, options.identity.publicKey).pipe(
           Effect.as(isForbidden)
         )

package/src/unstable/eventlog/EventLogServerUnencrypted.ts

@@ -730,7 +730,7 @@ export const make = Effect.gen(function*() {
           id: makeEntryIdUnsafe(),
           event: options.event,
           primaryKey: schemaEvent.primaryKey(options.payload),
-          payload: yield* Schema.encodeUnknownEffect(schemaEvent.payloadMsgPack)(options.payload).pipe(
+          payload: yield* Schema.encodeUnknownEffect(schemaEvent.payloadSchemaBinary)(options.payload).pipe(
             Effect.mapError((_) =>
               new EventLogServerStoreError({
                 reason: "PersistenceFailure",
@@ -866,7 +866,7 @@ const makeServerHandler = Effect.gen(function*() {
         return yield* Effect.logDebug(`Event handler not found for: "${options.entry.event}"`)
       }
 
-      const decodePayload = Schema.decodeUnknownEffect(handler.event.payloadMsgPack)
+      const decodePayload = Schema.decodeUnknownEffect(handler.event.payloadSchemaBinary)
       const decodedConflicts: Array<{ readonly entry: Entry; readonly payload: unknown }> = []
 
       for (const conflict of options.conflicts) {

package/src/unstable/eventlog/SqlEventJournal.ts

@@ -8,11 +8,13 @@
  *
  * @since 4.0.0
  */
+import * as Arr from "../../Array.ts"
 import * as Effect from "../../Effect.ts"
 import * as Uuid from "../../internal/uuid.ts"
 import * as Layer from "../../Layer.ts"
 import * as PubSub from "../../PubSub.ts"
 import * as Schema from "../../Schema.ts"
+import * as SchemaTransformation from "../../SchemaTransformation.ts"
 import * as SqlClient from "../sql/SqlClient.ts"
 import * as SqlError from "../sql/SqlError.ts"
 import * as SqlSchema from "../sql/SqlSchema.ts"
@@ -123,6 +125,7 @@ export const make = (options?: {
     }).pipe(withTracerDisabled)
 
     const decodeEntryRows = Schema.decodeUnknownEffect(EntryRowArray)
+    const decodeEntryIdRows = Schema.decodeUnknownEffect(EntryIdRowArray)
     const toEntries = (rows: ReadonlyArray<EntryRow>): ReadonlyArray<EventJournal.Entry> => rows.map(toEntry)
 
     const insertEntry = SqlSchema.void({
@@ -155,12 +158,13 @@ export const make = (options?: {
 
       const existingIds = new Set<string>()
       if (entries.length > 0) {
-        yield* sql<{ id: Uint8Array }>`SELECT id FROM ${entryTableSql} WHERE ${
+        yield* sql`SELECT id FROM ${entryTableSql} WHERE ${
           sql.in(
             "id",
             entries.map((entry) => entry.id)
           )
         }`.pipe(
+          Effect.flatMap(decodeEntryIdRows),
           Effect.tap((rows) =>
             Effect.sync(() => {
               for (const row of rows) {
@@ -222,13 +226,16 @@ export const make = (options?: {
           }, { disableChecks: true })
           return yield* Effect.uninterruptibleMask((restore) =>
             restore(effect(entry)).pipe(
-              Effect.tap(insertEntry(toEntryRow(entry))),
+              Effect.tap(
+                insertEntry(toEntryRow(entry)).pipe(
+                  Effect.mapError((cause) => new EventJournal.EventJournalError({ cause, method: "write" }))
+                )
+              ),
               Effect.tap(PubSub.publish(pubsub, entry))
             )
           )
         },
-        withTracerDisabled,
-        Effect.mapError((cause) => new EventJournal.EventJournalError({ cause, method: "write" }))
+        withTracerDisabled
       ),
       writeFromRemote: (options) =>
         writeFromRemote(options).pipe(
@@ -247,12 +254,13 @@ export const make = (options?: {
             ORDER BY timestamp ASC
           `.pipe(
             Effect.flatMap(decodeEntryRows),
-            Effect.map(toEntries)
+            Effect.map(toEntries),
+            Effect.mapError((cause) => new EventJournal.EventJournalError({ cause, method: "withRemoteUncommited" }))
           )
-          return yield* f(entries)
+          if (!Arr.isReadonlyArrayNonEmpty(entries)) return yield* Effect.succeedNone
+          return yield* Effect.asSome(f(entries))
         },
-        withTracerDisabled,
-        Effect.mapError((cause) => new EventJournal.EventJournalError({ cause, method: "withRemoteUncommited" }))
+        withTracerDisabled
       ),
       nextRemoteSequence: (remoteId) =>
         sql<{ max: number | null }>`SELECT MAX(sequence) AS max FROM ${remotesTableSql} WHERE remote_id = ${remoteId}`
@@ -316,15 +324,32 @@ export const layer = (options?: {
 }): Layer.Layer<EventJournal.EventJournal, SqlError.SqlError, SqlClient.SqlClient> =>
   Layer.effect(EventJournal.EventJournal)(make(options))
 
+const ArrayBuffer = Schema.instanceOf(globalThis.ArrayBuffer, {
+  expected: "ArrayBuffer"
+})
+
+const SqlUint8Array = Schema.Union([Schema.Uint8Array, ArrayBuffer]).pipe(
+  Schema.decodeTo(
+    Schema.Uint8Array,
+    SchemaTransformation.transform({
+      decode: (value) => value instanceof globalThis.ArrayBuffer ? new globalThis.Uint8Array(value) : value,
+      encode: (value) => value
+    })
+  )
+)
+
+const SqlEntryId = SqlUint8Array.pipe(Schema.decodeTo(EventJournal.EntryId))
+
 const EntryRow = Schema.Struct({
-  id: EventJournal.EntryId,
+  id: SqlEntryId,
   event: Schema.String,
   primary_key: Schema.String,
-  payload: Schema.Uint8Array,
+  payload: SqlUint8Array,
   timestamp: Schema.Int
 })
 
 const EntryRowArray = Schema.Array(EntryRow)
+const EntryIdRowArray = Schema.Array(Schema.Struct({ id: SqlEntryId }))
 
 type EntryRow = Schema.Schema.Type<typeof EntryRow>
 

package/src/unstable/eventlog/SqlEventLogServerUnencrypted.ts

@@ -15,6 +15,7 @@ import * as Layer from "../../Layer.ts"
 import * as PubSub from "../../PubSub.ts"
 import * as RcMap from "../../RcMap.ts"
 import * as Schema from "../../Schema.ts"
+import * as SchemaTransformation from "../../SchemaTransformation.ts"
 import type * as Scope from "../../Scope.ts"
 import * as Stream from "../../Stream.ts"
 import * as SqlClient from "../sql/SqlClient.ts"
@@ -463,7 +464,16 @@ type EntrySql = Schema.Schema.Type<typeof EntrySql>
 
 const SqlNatural = Schema.Union([
   Schema.Natural,
-  Schema.FiniteFromString.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0))
+  Schema.FiniteFromString.check(Schema.isInt(), Schema.isGreaterThanOrEqualTo(0)),
+  Schema.BigInt.pipe(
+    Schema.decodeTo(
+      Schema.Natural,
+      SchemaTransformation.transform({
+        decode: Number,
+        encode: BigInt
+      })
+    )
+  )
 ])
 
 const RemoteEntrySql = Schema.Struct({