effect 4.0.0-rc.112 → 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

@@ -9,11 +9,6 @@
  */
 export * as Ini from "./Ini.ts"
 
-/**
- * @since 4.0.0
- */
-export * as Msgpack from "./Msgpack.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

@@ -25,7 +25,7 @@ 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"
 
 /**
@@ -272,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
@@ -285,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.

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] = {
@@ -903,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

@@ -14,6 +14,7 @@ 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"
@@ -124,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({
@@ -156,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) {
@@ -223,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(
@@ -248,13 +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" }))
           )
           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}`
@@ -318,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({

package/src/unstable/http/Cookies.ts

@@ -19,8 +19,6 @@ import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Record from "../../Record.ts"
 import * as Result from "../../Result.ts"
-import * as Schema from "../../Schema.ts"
-import * as SchemaTransformation from "../../SchemaTransformation.ts"
 import type * as Types from "../../Types.ts"
 
 const TypeId = "~effect/http/Cookies"
@@ -44,57 +42,6 @@ export interface Cookies extends Pipeable, Inspectable.Inspectable {
   readonly cookies: Record.ReadonlyRecord<string, Cookie>
 }
 
-/**
- * Schema interface for validating and encoding `Cookies` collections.
- *
- * @category schemas
- * @since 4.0.0
- */
-export interface CookiesSchema extends Schema.declare<Cookies, Record.ReadonlyRecord<string, Cookie>> {}
-
-/**
- * Schema for `Cookies` collections.
- *
- * **Details**
- *
- * JSON encoding uses `Set-Cookie` header strings, while isomorphic encoding uses
- * a readonly record of cookie values.
- *
- * @category schemas
- * @since 4.0.0
- */
-export const CookiesSchema: CookiesSchema = Schema.declare(
-  isCookies,
-  {
-    representation: {
-      id: "effect/http/Cookies",
-      payload: null
-    },
-    toCode: () => ({
-      runtime: "Cookies.CookiesSchema",
-      Type: "Cookies.Cookies",
-      importDeclarations: [`import * as Cookies from "effect/unstable/http/Cookies"`]
-    }),
-    expected: "Cookies",
-    toCodecJson: () =>
-      Schema.link<Cookies>()(
-        Schema.Array(Schema.String),
-        SchemaTransformation.transform({
-          decode: (input) => fromSetCookie(input),
-          encode: (cookies) => toSetCookieHeaders(cookies)
-        })
-      ),
-    toCodecIso: () =>
-      Schema.link<Cookies>()(
-        Schema.Record(Schema.String, CookieSchema),
-        SchemaTransformation.transform({
-          decode: (input) => fromReadonlyRecord(input),
-          encode: (cookies) => cookies.cookies
-        })
-      )
-  }
-)
-
 const CookieTypeId = "~effect/http/Cookies/Cookie"
 
 /**
@@ -130,36 +77,6 @@ export interface Cookie extends Inspectable.Inspectable {
  */
 export const isCookie = (u: unknown): u is Cookie => Predicate.hasProperty(u, CookieTypeId)
 
-/**
- * Schema interface for validating `Cookie` values.
- *
- * @category schemas
- * @since 4.0.0
- */
-export interface CookieSchema extends Schema.declare<Cookie> {}
-
-/**
- * Schema for `Cookie` values.
- *
- * @category schemas
- * @since 4.0.0
- */
-export const CookieSchema: CookieSchema = Schema.declare(
-  isCookie,
-  {
-    representation: {
-      id: "effect/http/Cookie",
-      payload: null
-    },
-    toCode: () => ({
-      runtime: "Cookies.CookieSchema",
-      Type: "Cookies.Cookie",
-      importDeclarations: [`import * as Cookies from "effect/unstable/http/Cookies"`]
-    }),
-    expected: "Cookie"
-  }
-)
-
 const CookieErrorTypeId = "~effect/http/Cookies/CookieError"
 
 /**
@@ -189,7 +106,7 @@ export class CookiesErrorReason extends Data.Error<{
  * @category errors
  * @since 4.0.0
  */
-export class CookiesError extends Data.TaggedError("CookieError")<{
+export class CookiesError extends Data.TaggedError("CookiesError")<{
   readonly reason: CookiesErrorReason
 }> {
   /**
@@ -288,7 +205,7 @@ function parseSetCookie(header: string): Cookie | undefined {
     return undefined
   }
   const name = parts[0].slice(0, firstEqual)
-  if (!fieldContentRegExp.test(name)) {
+  if (!cookieNameRegExp.test(name)) {
     return undefined
   }
 
@@ -1050,23 +967,6 @@ export const toRecord = (self: Cookies): Record<string, string> => {
   return record
 }
 
-/**
- * Schema for transforming `Cookies` into records of decoded string values keyed
- * by cookie name.
- *
- * @category schemas
- * @since 4.0.0
- */
-export const schemaRecord = CookiesSchema.pipe(
-  Schema.decodeTo(
-    Schema.Record(Schema.String, Schema.String),
-    SchemaTransformation.transform({
-      decode: toRecord,
-      encode: (self) => fromIterable(Object.entries(self).map(([name, value]) => makeCookieUnsafe(name, value)))
-    })
-  )
-)
-
 /**
  * Serializes a `Cookies` collection into an array of `Set-Cookie` header values.
  *