@kairos-es/store-postgres 1.0.0-alpha.4 → 1.0.0-alpha.6

package/README.md

@@ -13,20 +13,17 @@ database without interference.
 
 ## Installation
 
-`@kairos-es/core`, `effect`, and the Effect SQL/Postgres stack are peer
-dependencies (so the app owns the single shared Effect + `SqlClient` instance,
-per ADR-0003):
+`@kairos-es/core`, `effect`, and `@effect/sql-pg` are peer dependencies (so
+the app owns the single shared Effect + `SqlClient` instance, per ADR-0003):
 
 ```sh
 pnpm add @kairos-es/store-postgres@alpha @kairos-es/core@alpha \
-  @effect/sql@^0.52.0 @effect/sql-pg@^0.53.0 @effect/platform@^0.97.0 \
-  @effect/experimental@^0.61.0 effect@^3.22.0
+  @effect/sql-pg@^4.0.5 effect@^4.0.5
 ```
 
-`@effect/platform` and `@effect/experimental` are pulled in because
-`@effect/sql-pg` requires them (the pooled client's `Reactivity` service lives in
-`@effect/experimental`); declaring them here keeps the peer graph resolvable for
-consumers.
+The generic SQL modules (`SqlClient`, `Migrator`, `SqlError`) and the
+`Reactivity` service the pooled client requires ship inside `effect` itself, as
+`effect/sql` and `effect/reactivity`, so nothing else has to be installed.
 
 ## Schema: `ensureSchema` as a migration
 
@@ -37,17 +34,24 @@ replaces its append functions. Every statement is `CREATE … IF NOT EXISTS` or
 **orchestration** is yours; the package only provides the idempotent **payload**.
 
 **Upgrading.** A re-run replaces the append functions but never alters an existing
-table. So when a release adds a column, its release notes give the `ALTER TABLE`
-statement, and an upgrade is that statement followed by this version's
-`ensureSchema` again, registered as a NEW migration: a migrator never re-runs one
-it has already applied, and an append function left behind silently ignores the
-new column.
+table. So register this version's `ensureSchema` again as a NEW migration on every
+upgrade, even one that adds no column: a migrator never re-runs one it has already
+applied, and an append function left behind keeps the older version's body. When a
+release adds a column, its release notes give the `ALTER TABLE` statement, and it
+runs before that `ensureSchema`; an append function left behind silently ignores
+the new column.
 
-Drop it straight into an `@effect/sql` migrator as a one-liner:
+**One statement per call.** `@effect/sql-pg` 4 has no simple-query path: every
+statement goes through the extended protocol, which takes one command. So a string
+holding several statements, such as a SQL migration file, fails with `cannot insert
+multiple commands into a prepared statement`, and `prepare: false` does not change
+that. Split the file and run each statement on its own.
+
+Drop it straight into an `effect/sql` migrator as a one-liner:
 
 ```ts
-import { Migrator } from '@effect/sql'
 import { ensureSchema } from '@kairos-es/store-postgres'
+import { Migrator } from 'effect/sql'
 
 const config = { schema: 'public', tablePrefix: 'dcb_events' }
 
@@ -56,14 +60,13 @@ const migrations = Migrator.fromRecord({
 })
 ```
 
-Because `ensureSchema` requires the **generic** `SqlClient` tag (not the
-store-owned client tags), it slots into any migrator or boot sequence that
+Because `ensureSchema` requires the **generic** `SqlClient` service (not the
+store-owned client services), it slots into any migrator or boot sequence that
 already provides a `SqlClient`.
 
 Or run it directly once at boot, over whatever `SqlClient` you have wired:
 
 ```ts
-import { SqlClient } from '@effect/sql'
 import { PgClient } from '@effect/sql-pg'
 import { ensureSchema } from '@kairos-es/store-postgres'
 import { Effect, Layer, Redacted } from 'effect'
@@ -78,24 +81,34 @@ await Effect.runPromise(program.pipe(Effect.provide(SqlLive)))
 ```
 
 `ensureSchema` must have run before the store `layer` is used; the `layer` itself
-performs no DDL and depends only on the two client tags.
+performs no DDL and depends only on the two client services.
 
 ## Two-endpoint wiring (Neon)
 
-`@effect/sql-pg` exposes a single `PgClient`/`SqlClient` tag, so this package
-defines **two distinct tags**, each holding a `PgClient` value:
+`@effect/sql-pg` exposes a single `PgClient`/`SqlClient` service, so this
+package defines **two distinct services**, each holding a `PgClient` value:
 
 - `PgClientPooled` — reads, the append function, and `NOTIFY`. Point it at your
   pooled endpoint.
 - `PgClientDirect` — used **only** by `subscribe`'s `LISTEN`. Point it at a
   **direct** (non-pooler) endpoint.
 
-Why the split matters on Neon: the built-in `listen` constructs a standalone
-connection inheriting the pool's host. A Neon **pooled** endpoint
-(`…-pooler…`) lands that connection on the PgBouncer front door, which
-**silently drops `LISTEN`/`NOTIFY`** — the subscription would simply never wake.
-Pointing `PgClientDirect` at Neon's direct endpoint fixes it. `subscribe` is the
-only method that touches `PgClientDirect`.
+Why the split matters on Neon: the built-in `listen` reserves a connection from
+its own client's pool, so it listens on whatever host that client was given. A
+Neon **pooled** endpoint (`…-pooler…`) lands that connection on the PgBouncer
+front door, which **silently drops `LISTEN`/`NOTIFY`** — the subscription would
+never wake, and would deliver only at the poll interval. Pointing
+`PgClientDirect` at Neon's direct endpoint fixes it. `subscribe` is the only
+method that touches `PgClientDirect`.
+
+Each live subscription holds one `PgClientDirect` connection for as long as it
+runs, so that client's `maxConnections` (default 10) is how many subscriptions
+can be listening at once. One past it still delivers, at the poll interval,
+until a connection frees up. Size `directLayer` for your subscriber count:
+
+```ts
+directLayer({ url, maxConnections: 50 })
+```
 
 ```ts
 import {
@@ -117,7 +130,19 @@ const clients = Layer.merge(
 const store = layer(config).pipe(Layer.provide(clients))
 ```
 
-On a plain (non-Neon) Postgres, point both tags at the **same** URL — the split
+Both layers take `@effect/sql-pg`'s own pool config, so its options pass
+straight through. That driver caches named prepared statements by default, and a
+transaction-mode pooler, such as the PgBouncer behind Neon's `-pooler` endpoint,
+may run each statement on a different server connection from the one that
+prepared it. Behind such a pooler, unless it documents support for
+protocol-level prepared statements, pass `prepare: false` to the client pointed
+at it:
+
+```ts
+pooledLayer({ url: Redacted.make(process.env.NEON_POOLED_URL!), prepare: false })
+```
+
+On a plain (non-Neon) Postgres, point both services at the **same** URL — the split
 costs nothing there:
 
 ```ts

package/dist/cjs/clients.js

@@ -4,59 +4,69 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.pooledLayer = exports.directLayer = exports.PgClientPooled = exports.PgClientDirect = void 0;
-var _experimental = require("@effect/experimental");
 var _sqlPg = require("@effect/sql-pg");
 var _effect = require("effect");
+var _reactivity = require("effect/reactivity");
 /**
  * The TWO store-owned Postgres clients — the "Neon trap" mitigation (ADR-0002).
  *
- * `@effect/sql-pg` exposes a single `PgClient` (and `SqlClient`) tag; a
+ * `@effect/sql-pg` exposes a single `PgClient` (and `SqlClient`) service; a
  * `PgClient.layer` claims BOTH. If we built two `PgClient.layer`s they would
- * collide on that one tag — the second would shadow the first. So instead we
- * define two DISTINCT `Context.Tag`s, each HOLDING a `PgClient` value:
+ * collide on that one key — the second would shadow the first. So instead we
+ * define two DISTINCT `Context.Service`s, each HOLDING a `PgClient` value:
  *
  * - `PgClientPooled` — the pooled client used for reads, the append function,
- *   and `notify`. Backed by a `pg.Pool`; connections are recycled per query.
+ *   and `notify`. Its statements borrow a connection from the client's pool per
+ *   query.
  * - `PgClientDirect` — a client used ONLY by `subscribe`'s `listen`. Its
- *   built-in `listen` constructs a STANDALONE `pg.Client` from the pool's
- *   `options`, inheriting the pool's host. On a Neon POOLED endpoint
- *   (`…-pooler…`) that standalone connection lands on the PgBouncer front door,
- *   which SILENTLY DROPS `LISTEN`/`NOTIFY` — the subscription would simply never
+ *   built-in `listen` RESERVES a connection from that client's own pool and
+ *   holds it for the life of the subscription, so the listening session lives
+ *   on whatever host the client was configured with. On a Neon POOLED endpoint
+ *   (`…-pooler…`) that session is a PgBouncer front-door connection, which
+ *   SILENTLY DROPS `LISTEN`/`NOTIFY` — the subscription would simply never
  *   wake. Pointing `PgClientDirect` at Neon's DIRECT (non-pooler) endpoint fixes
  *   it. `subscribe` is the ONLY method that touches `PgClientDirect`.
  *
- * For a plain (non-Neon) Postgres both tags point at the same URL; the split
- * costs nothing there. The two-tag design is what makes the Neon fix a
+ * Because each live subscription holds one of `PgClientDirect`'s pooled
+ * connections until it closes, that client's `maxConnections` is also the number
+ * of subscriptions that can be listening at once. A subscription past it waits
+ * for a connection on its wake fibre only — delivery still proceeds at the poll
+ * rate meanwhile (see `store.ts`) — so size the direct client for the expected
+ * subscriber count rather than for query throughput.
+ *
+ * For a plain (non-Neon) Postgres both services point at the same URL; the split
+ * costs nothing there. The two-service design is what makes the Neon fix a
  * deployment-time wiring choice rather than a code change.
  */
 
 /**
- * The pooled client tag: reads, the append function, and `notify`. Holds a
+ * The pooled client service: reads, the append function, and `notify`. Holds a
  * `PgClient` value rather than being a `PgClient.layer`, so it never collides
- * with the direct client on the shared `PgClient`/`SqlClient` tag.
+ * with the direct client on the shared `PgClient`/`SqlClient` key.
  */
-class PgClientPooled extends /*#__PURE__*/_effect.Context.Tag('@kairos-es/store-postgres/PgClientPooled')() {}
+class PgClientPooled extends /*#__PURE__*/_effect.Context.Service()('@kairos-es/store-postgres/PgClientPooled') {}
 /**
- * The direct (non-pooler) client tag: the `subscribe` listener ONLY. Point this
- * at a direct endpoint on Neon so `LISTEN`/`NOTIFY` is not dropped by the pooler.
+ * The direct (non-pooler) client service: the `subscribe` listener ONLY. Point
+ * this at a direct endpoint on Neon so `LISTEN`/`NOTIFY` is not dropped by the
+ * pooler.
  */
 exports.PgClientPooled = PgClientPooled;
-class PgClientDirect extends /*#__PURE__*/_effect.Context.Tag('@kairos-es/store-postgres/PgClientDirect')() {}
+class PgClientDirect extends /*#__PURE__*/_effect.Context.Service()('@kairos-es/store-postgres/PgClientDirect') {}
 /**
- * Build a `PgClientPooled` layer from a `PgClient` config. We construct the
- * client via `PgClient.make` (scoped) and place it in our OWN tag, then provide
- * `Reactivity.layer` (which `PgClient.make` requires) — exactly what the
+ * Build a `PgClientPooled` layer from a `PgClient` pool config. We construct the
+ * client via `PgClient.make` (scoped) and place it in our OWN service, then
+ * provide `Reactivity.layer` (which `PgClient.make` requires) — exactly what the
  * built-in `PgClient.layer` does internally, minus the collision-prone claim on
- * the shared `PgClient` tag.
+ * the shared `PgClient` key.
  */
 exports.PgClientDirect = PgClientDirect;
-const pooledLayer = config => _effect.Layer.scoped(PgClientPooled, _sqlPg.PgClient.make(config)).pipe(_effect.Layer.provide(_experimental.Reactivity.layer));
+const pooledLayer = config => _effect.Layer.effect(PgClientPooled, _sqlPg.PgClient.make(config)).pipe(_effect.Layer.provide(_reactivity.Reactivity.layer));
 /**
- * Build a `PgClientDirect` layer from a `PgClient` config. Same construction as
+ * Build a `PgClientDirect` layer from a `PgClient` pool config. Same construction as
  * `pooledLayer`; the two differ only in which endpoint the caller points them
  * at (and that only matters on Neon).
  */
 exports.pooledLayer = pooledLayer;
-const directLayer = config => _effect.Layer.scoped(PgClientDirect, _sqlPg.PgClient.make(config)).pipe(_effect.Layer.provide(_experimental.Reactivity.layer));
+const directLayer = config => _effect.Layer.effect(PgClientDirect, _sqlPg.PgClient.make(config)).pipe(_effect.Layer.provide(_reactivity.Reactivity.layer));
 exports.directLayer = directLayer;
 //# sourceMappingURL=clients.js.map

package/dist/cjs/clients.js.map

@@ -1 +1 @@
-{"version":3,"file":"clients.js","names":["_experimental","require","_sqlPg","_effect","PgClientPooled","Context","Tag","exports","PgClientDirect","pooledLayer","config","Layer","scoped","PgClient","make","pipe","provide","Reactivity","layer","directLayer"],"sources":["../../src/clients.ts"],"sourcesContent":[null],"mappings":";;;;;;AAsBA,IAAAA,aAAA,GAAAC,OAAA;AAEA,IAAAC,MAAA,GAAAD,OAAA;AACA,IAAAE,OAAA,GAAAF,OAAA;AAzBA;;;;;;;;;;;;;;;;;;;;;;;AA2BA;;;;;AAKM,MAAOG,cAAe,sBAAQC,eAAO,CAACC,GAAG,CAC7C,0CAA0C,CAC3C,EAAqC;AAEtC;;;;AAAAC,OAAA,CAAAH,cAAA,GAAAA,cAAA;AAIM,MAAOI,cAAe,sBAAQH,eAAO,CAACC,GAAG,CAC7C,0CAA0C,CAC3C,EAAqC;AAEtC;;;;;;;AAAAC,OAAA,CAAAC,cAAA,GAAAA,cAAA;AAOO,MAAMC,WAAW,GACtBC,MAA+B,IAE/BC,aAAK,CAACC,MAAM,CAACR,cAAc,EAAES,eAAQ,CAACC,IAAI,CAACJ,MAAM,CAAC,CAAC,CAACK,IAAI,CACtDJ,aAAK,CAACK,OAAO,CAACC,wBAAU,CAACC,KAAK,CAAC,CAChC;AAEH;;;;;AAAAX,OAAA,CAAAE,WAAA,GAAAA,WAAA;AAKO,MAAMU,WAAW,GACtBT,MAA+B,IAE/BC,aAAK,CAACC,MAAM,CAACJ,cAAc,EAAEK,eAAQ,CAACC,IAAI,CAACJ,MAAM,CAAC,CAAC,CAACK,IAAI,CACtDJ,aAAK,CAACK,OAAO,CAACC,wBAAU,CAACC,KAAK,CAAC,CAChC;AAAAX,OAAA,CAAAY,WAAA,GAAAA,WAAA","ignoreList":[]}
+{"version":3,"file":"clients.js","names":["_sqlPg","require","_effect","_reactivity","PgClientPooled","Context","Service","exports","PgClientDirect","pooledLayer","config","Layer","effect","PgClient","make","pipe","provide","Reactivity","layer","directLayer"],"sources":["../../src/clients.ts"],"sourcesContent":[null],"mappings":";;;;;;AA+BA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AACA,IAAAE,WAAA,GAAAF,OAAA;AAjCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA;;;;;AAKM,MAAOG,cAAe,sBAAQC,eAAO,CAACC,OAAO,EAGhD,CAAC,0CAA0C,CAAC;AAE/C;;;;;AAAAC,OAAA,CAAAH,cAAA,GAAAA,cAAA;AAKM,MAAOI,cAAe,sBAAQH,eAAO,CAACC,OAAO,EAGhD,CAAC,0CAA0C,CAAC;AAE/C;;;;;;;AAAAC,OAAA,CAAAC,cAAA,GAAAA,cAAA;AAOO,MAAMC,WAAW,GACtBC,MAA6B,IAE7BC,aAAK,CAACC,MAAM,CAACR,cAAc,EAAES,eAAQ,CAACC,IAAI,CAACJ,MAAM,CAAC,CAAC,CAACK,IAAI,CACtDJ,aAAK,CAACK,OAAO,CAACC,sBAAU,CAACC,KAAK,CAAC,CAChC;AAEH;;;;;AAAAX,OAAA,CAAAE,WAAA,GAAAA,WAAA;AAKO,MAAMU,WAAW,GACtBT,MAA6B,IAE7BC,aAAK,CAACC,MAAM,CAACJ,cAAc,EAAEK,eAAQ,CAACC,IAAI,CAACJ,MAAM,CAAC,CAAC,CAACK,IAAI,CACtDJ,aAAK,CAACK,OAAO,CAACC,sBAAU,CAACC,KAAK,CAAC,CAChC;AAAAX,OAAA,CAAAY,WAAA,GAAAA,WAAA","ignoreList":[]}

package/dist/cjs/config.js

@@ -34,7 +34,7 @@ var _ddl = require("./internal/ddl.js");
  * `sql(identifier)` dot-splits, so an embedded dot would silently re-partition
  * the name into the wrong schema/object.
  */
-const IdentifierAtom = /*#__PURE__*/_effect.Schema.String.pipe(/*#__PURE__*/_effect.Schema.nonEmptyString(), /*#__PURE__*/_effect.Schema.pattern(/^[^.]+$/, {
+const IdentifierAtom = /*#__PURE__*/_effect.Schema.String.check(/*#__PURE__*/_effect.Schema.isNonEmpty(), /*#__PURE__*/_effect.Schema.isPattern(/^[^.]+$/, {
   identifier: 'PostgresIdentifierAtom',
   description: 'a non-empty identifier atom containing no "."'
 }));
@@ -65,29 +65,23 @@ const IdentifierAtom = /*#__PURE__*/_effect.Schema.String.pipe(/*#__PURE__*/_eff
  *   fetches before looping.
  */
 const PostgresStoreConfig = exports.PostgresStoreConfig = /*#__PURE__*/_effect.Schema.Struct({
-  // `exact: true` keeps the decoded type at `key?: T` (never `T | undefined`),
+  // `optionalKey` keeps the decoded type at `key?: T` (never `T | undefined`),
   // matching the repo's `exactOptionalPropertyTypes` discipline — an absent key,
   // not an explicit `undefined`.
-  schema: _effect.Schema.optionalWith(IdentifierAtom, {
-    exact: true
-  }),
-  tablePrefix: _effect.Schema.optionalWith(IdentifierAtom, {
-    exact: true
-  }),
-  lockTimeout: _effect.Schema.optionalWith(_effect.Schema.Number.pipe(_effect.Schema.nonNegative(), _effect.Schema.finite()), {
-    exact: true
-  }),
+  schema: _effect.Schema.optionalKey(IdentifierAtom),
+  tablePrefix: _effect.Schema.optionalKey(IdentifierAtom),
+  lockTimeout: _effect.Schema.optionalKey(_effect.Schema.Number.check(_effect.Schema.isGreaterThanOrEqualTo(0), _effect.Schema.isFinite())),
   // The two subscribe knobs are core's field definitions, not this engine's: see
   // `subscriptionTuningFields`.
   ..._core.subscriptionTuningFields
-}).pipe(/*#__PURE__*/
+}).check(/*#__PURE__*/
 // Cross-field guard: the derived table/index/function/channel names must all
 // fit Postgres's 63-byte identifier limit. Returning the message string fails
-// the decode with it; `undefined`/`true` passes.
-_effect.Schema.filter(config => (0, _ddl.oversizedIdentifier)(config) ?? true));
+// the decode with it; `undefined` passes.
+_effect.Schema.makeFilter(config => (0, _ddl.oversizedIdentifier)(config)));
 /**
  * Decode an unknown value into a validated `PostgresStoreConfig`, throwing a
- * `ParseError` on any violation. Used by `layer`/`ensureSchema` so a bad config
+ * `SchemaError` on any violation. Used by `layer`/`ensureSchema` so a bad config
  * fails at construction time.
  */
 const decodePostgresStoreConfig = exports.decodePostgresStoreConfig = /*#__PURE__*/_effect.Schema.decodeUnknownSync(PostgresStoreConfig);

package/dist/cjs/config.js.map

@@ -1 +1 @@
-{"version":3,"file":"config.js","names":["_core","require","_effect","_ddl","IdentifierAtom","Schema","String","pipe","nonEmptyString","pattern","identifier","description","PostgresStoreConfig","exports","Struct","schema","optionalWith","exact","tablePrefix","lockTimeout","Number","nonNegative","finite","subscriptionTuningFields","filter","config","oversizedIdentifier","decodePostgresStoreConfig","decodeUnknownSync"],"sources":["../../src/config.ts"],"sourcesContent":[null],"mappings":";;;;;;AAoBA,IAAAA,KAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AACA,IAAAE,IAAA,GAAAF,OAAA;AAtBA;;;;;;;;;;;;;;;;;;;;;AAwBA;;;;;;AAMA,MAAMG,cAAc,gBAAGC,cAAM,CAACC,MAAM,CAACC,IAAI,cACvCF,cAAM,CAACG,cAAc,EAAE,eACvBH,cAAM,CAACI,OAAO,CAAC,SAAS,EAAE;EACxBC,UAAU,EAAE,wBAAwB;EACpCC,WAAW,EAAE;CACd,CAAC,CACH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BO,MAAMC,mBAAmB,GAAAC,OAAA,CAAAD,mBAAA,gBAAGP,cAAM,CAACS,MAAM,CAAC;EAC/C;EACA;EACA;EACAC,MAAM,EAAEV,cAAM,CAACW,YAAY,CAACZ,cAAc,EAAE;IAAEa,KAAK,EAAE;EAAI,CAAE,CAAC;EAC5DC,WAAW,EAAEb,cAAM,CAACW,YAAY,CAACZ,cAAc,EAAE;IAAEa,KAAK,EAAE;EAAI,CAAE,CAAC;EACjEE,WAAW,EAAEd,cAAM,CAACW,YAAY,CAC9BX,cAAM,CAACe,MAAM,CAACb,IAAI,CAACF,cAAM,CAACgB,WAAW,EAAE,EAAEhB,cAAM,CAACiB,MAAM,EAAE,CAAC,EACzD;IAAEL,KAAK,EAAE;EAAI,CAAE,CAChB;EACD;EACA;EACA,GAAGM;CACJ,CAAC,CAAChB,IAAI;AACL;AACA;AACA;AACAF,cAAM,CAACmB,MAAM,CAAEC,MAAM,IAAK,IAAAC,wBAAmB,EAACD,MAAM,CAAC,IAAI,IAAI,CAAC,CAC/D;AAGD;;;;;AAKO,MAAME,yBAAyB,GAAAd,OAAA,CAAAc,yBAAA,gBACpCtB,cAAM,CAACuB,iBAAiB,CAAChB,mBAAmB,CAAC","ignoreList":[]}
+{"version":3,"file":"config.js","names":["_core","require","_effect","_ddl","IdentifierAtom","Schema","String","check","isNonEmpty","isPattern","identifier","description","PostgresStoreConfig","exports","Struct","schema","optionalKey","tablePrefix","lockTimeout","Number","isGreaterThanOrEqualTo","isFinite","subscriptionTuningFields","makeFilter","config","oversizedIdentifier","decodePostgresStoreConfig","decodeUnknownSync"],"sources":["../../src/config.ts"],"sourcesContent":[null],"mappings":";;;;;;AAoBA,IAAAA,KAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AACA,IAAAE,IAAA,GAAAF,OAAA;AAtBA;;;;;;;;;;;;;;;;;;;;;AAwBA;;;;;;AAMA,MAAMG,cAAc,gBAAGC,cAAM,CAACC,MAAM,CAACC,KAAK,cACxCF,cAAM,CAACG,UAAU,EAAE,eACnBH,cAAM,CAACI,SAAS,CAAC,SAAS,EAAE;EAC1BC,UAAU,EAAE,wBAAwB;EACpCC,WAAW,EAAE;CACd,CAAC,CACH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BO,MAAMC,mBAAmB,GAAAC,OAAA,CAAAD,mBAAA,gBAAGP,cAAM,CAACS,MAAM,CAAC;EAC/C;EACA;EACA;EACAC,MAAM,EAAEV,cAAM,CAACW,WAAW,CAACZ,cAAc,CAAC;EAC1Ca,WAAW,EAAEZ,cAAM,CAACW,WAAW,CAACZ,cAAc,CAAC;EAC/Cc,WAAW,EAAEb,cAAM,CAACW,WAAW,CAC7BX,cAAM,CAACc,MAAM,CAACZ,KAAK,CAACF,cAAM,CAACe,sBAAsB,CAAC,CAAC,CAAC,EAAEf,cAAM,CAACgB,QAAQ,EAAE,CAAC,CACzE;EACD;EACA;EACA,GAAGC;CACJ,CAAC,CAACf,KAAK;AACN;AACA;AACA;AACAF,cAAM,CAACkB,UAAU,CAAEC,MAAM,IAAK,IAAAC,wBAAmB,EAACD,MAAM,CAAC,CAAC,CAC3D;AAGD;;;;;AAKO,MAAME,yBAAyB,GAAAb,OAAA,CAAAa,yBAAA,gBACpCrB,cAAM,CAACsB,iBAAiB,CAACf,mBAAmB,CAAC","ignoreList":[]}

package/dist/cjs/ensureSchema.js

@@ -4,8 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.ensureSchema = void 0;
-var _sql = require("@effect/sql");
 var _effect = require("effect");
+var _sql = require("effect/sql");
 var _config = require("./config.js");
 var _ddl = require("./internal/ddl.js");
 /**
@@ -14,7 +14,7 @@ var _ddl = require("./internal/ddl.js");
  * This is deliberately NOT a migrator. It is a single `Effect<void, SqlError,
  * SqlClient>` that creates (or refreshes) every object a store owns: both
  * tables, both indexes, and both plpgsql functions. It requires the GENERIC
- * `SqlClient` tag — NOT `PgClientPooled` — precisely so a consumer can drop it
+ * `SqlClient` service — NOT `PgClientPooled` — precisely so a consumer can drop it
  * straight into THEIR OWN migrator, e.g.:
  *
  * ```ts

package/dist/cjs/ensureSchema.js.map

@@ -1 +1 @@
-{"version":3,"file":"ensureSchema.js","names":["_sql","require","_effect","_config","_ddl","ensureSchema","config","Effect","gen","sql","SqlClient","names","resolveNames","decodePostgresStoreConfig","all","runDdl","discard","exports"],"sources":["../../src/ensureSchema.ts"],"sourcesContent":[null],"mappings":";;;;;;AA8BA,IAAAA,IAAA,GAAAC,OAAA;AACA,IAAAC,OAAA,GAAAD,OAAA;AACA,IAAAE,OAAA,GAAAF,OAAA;AACA,IAAAG,IAAA,GAAAH,OAAA;AAjCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA;;;;;AAKO,MAAMI,YAAY,GACvBC,MAA2B,IAE3BC,cAAM,CAACC,GAAG,CAAC,aAAS;EAClB,MAAMC,GAAG,GAAG,OAAOC,cAAS,CAACA,SAAS;EACtC;EACA;EACA,MAAMC,KAAK,GAAG,IAAAC,iBAAY,EAAC,IAAAC,iCAAyB,EAACP,MAAM,CAAC,CAAC;EAC7D;EACA,OAAOC,cAAM,CAACO,GAAG,CAAC,IAAAC,WAAM,EAACN,GAAG,EAAEE,KAAK,CAAC,EAAE;IAAEK,OAAO,EAAE;EAAI,CAAE,CAAC;AAC1D,CAAC,CAAC;AAAAC,OAAA,CAAAZ,YAAA,GAAAA,YAAA","ignoreList":[]}
+{"version":3,"file":"ensureSchema.js","names":["_effect","require","_sql","_config","_ddl","ensureSchema","config","Effect","gen","sql","SqlClient","names","resolveNames","decodePostgresStoreConfig","all","runDdl","discard","exports"],"sources":["../../src/ensureSchema.ts"],"sourcesContent":[null],"mappings":";;;;;;AA8BA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,IAAA,GAAAD,OAAA;AACA,IAAAE,OAAA,GAAAF,OAAA;AACA,IAAAG,IAAA,GAAAH,OAAA;AAjCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA;;;;;AAKO,MAAMI,YAAY,GACvBC,MAA2B,IAE3BC,cAAM,CAACC,GAAG,CAAC,aAAS;EAClB,MAAMC,GAAG,GAAG,OAAOC,cAAS,CAACA,SAAS;EACtC;EACA;EACA,MAAMC,KAAK,GAAG,IAAAC,iBAAY,EAAC,IAAAC,iCAAyB,EAACP,MAAM,CAAC,CAAC;EAC7D;EACA,OAAOC,cAAM,CAACO,GAAG,CAAC,IAAAC,WAAM,EAACN,GAAG,EAAEE,KAAK,CAAC,EAAE;IAAEK,OAAO,EAAE;EAAI,CAAE,CAAC;AAC1D,CAAC,CAAC;AAAAC,OAAA,CAAAZ,YAAA,GAAAA,YAAA","ignoreList":[]}

package/dist/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["_clients","require","_ensureSchema","_store"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCA,IAAAA,QAAA,GAAAC,OAAA;AAOA,IAAAC,aAAA,GAAAD,OAAA;AACA,IAAAE,MAAA,GAAAF,OAAA","ignoreList":[]}
+{"version":3,"file":"index.js","names":["_clients","require","_ensureSchema","_store"],"sources":["../../src/index.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,IAAAA,QAAA,GAAAC,OAAA;AAOA,IAAAC,aAAA,GAAAD,OAAA;AACA,IAAAE,MAAA,GAAAF,OAAA","ignoreList":[]}

package/dist/cjs/internal/matchSql.js

@@ -66,9 +66,20 @@ const RECORDSET_ALIAS = exports.RECORDSET_ALIAS = 'ne';
  * Typed as a `Record` over `EventColumnName` so that adding a column to
  * `EVENT_COLUMNS` without saying where its value comes from is a COMPILE error,
  * rather than a column the insert silently leaves at its default. Every column but
- * `data` passes through as the recordset already types it — `text[]` tags,
- * `timestamptz`, `jsonb` metadata — because `jsonb_to_recordset` did the casting;
- * `data` crosses as base64 TEXT and is restored to `bytea` here, its one decode.
+ * `data` and `metadata` passes through as the recordset already types it — `text[]`
+ * tags, `timestamptz` — because `jsonb_to_recordset` did the casting; `data`
+ * crosses as base64 TEXT and is restored to `bytea` here, its one decode.
+ *
+ * `metadata` is wrapped in `COALESCE(…, '{}'::jsonb)`, for a caller this package's
+ * own client never is. `ensureSchema` replaces each append function with
+ * `CREATE OR REPLACE`, which keeps its argument signature, so a client from before
+ * the column existed (`1.0.0-alpha.3` and earlier) goes on calling the current body
+ * with events JSON that has no `metadata` key. `jsonb_to_recordset` reads an absent
+ * key as `NULL`, and an insert that names the column inserts that `NULL` rather than
+ * the column's `DEFAULT`, so `NOT NULL` would refuse every such append. The
+ * `COALESCE` gives that row the empty bag the `DEFAULT` would have, which is what
+ * makes "migrate, then deploy" a safe order from those versions. An event sent WITH
+ * a bag passes through unchanged, so what is stored for it does not move.
  */
 const EVENT_COLUMN_SOURCE = {
   type: `${RECORDSET_ALIAS}.type`,
@@ -76,7 +87,7 @@ const EVENT_COLUMN_SOURCE = {
   tags: `${RECORDSET_ALIAS}.tags`,
   uuid: `${RECORDSET_ALIAS}.uuid`,
   occurred_at: `${RECORDSET_ALIAS}.occurred_at`,
-  metadata: `${RECORDSET_ALIAS}.metadata`
+  metadata: `COALESCE(${RECORDSET_ALIAS}.metadata, '{}'::jsonb)`
 };
 /**
  * The bare event column names — `type, data, tags, uuid, occurred_at, metadata` —

package/dist/cjs/internal/matchSql.js.map

@@ -1 +1 @@
-{"version":3,"file":"matchSql.js","names":["EVENT_COLUMNS","eventRecordsetColumns","exports","map","name","type","join","readColumns","prefix","RECORDSET_ALIAS","EVENT_COLUMN_SOURCE","data","tags","uuid","occurred_at","metadata","eventColumnList","eventInsertSelectList","allowedTypesPredicate","typesCol","taggedMatchChain","tokens","queryItemsExpr","tag","afterExpr","qualifiedRows","main","wildcardReadSql","typeOnlyReadSql","taggedReadSql"],"sources":["../../../src/internal/matchSql.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}
+{"version":3,"file":"matchSql.js","names":["EVENT_COLUMNS","eventRecordsetColumns","exports","map","name","type","join","readColumns","prefix","RECORDSET_ALIAS","EVENT_COLUMN_SOURCE","data","tags","uuid","occurred_at","metadata","eventColumnList","eventInsertSelectList","allowedTypesPredicate","typesCol","taggedMatchChain","tokens","queryItemsExpr","tag","afterExpr","qualifiedRows","main","wildcardReadSql","typeOnlyReadSql","taggedReadSql"],"sources":["../../../src/internal/matchSql.ts"],"sourcesContent":[null],"mappings":";;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;AAwBA;;;;;;;;;;;AAWA,MAAMA,aAAa,GAAG,CACpB,CAAC,MAAM,EAAE,MAAM,CAAC,EAChB,CAAC,MAAM,EAAE,MAAM,CAAC,EAChB,CAAC,MAAM,EAAE,QAAQ,CAAC,EAClB,CAAC,MAAM,EAAE,MAAM,CAAC,EAChB,CAAC,aAAa,EAAE,aAAa,CAAC,EAC9B,CAAC,UAAU,EAAE,OAAO,CAAC,CAGtB;AAYD;;;;;;;AAOO,MAAMC,qBAAqB,GAAAC,OAAA,CAAAD,qBAAA,gBAAWD,aAAa,CAACG,GAAG,CAC5D,CAAC,CAACC,IAAI,EAAEC,IAAI,CAAC,KAAK,GAAGD,IAAI,IAAIC,IAAI,EAAE,CACpC,CAACC,IAAI,CAAC,IAAI,CAAC;AAEZ;;;;;AAKO,MAAMC,WAAW,GAAGA,CAACC,MAAM,GAAG,EAAE,KACrC,CAAC,GAAGA,MAAM,IAAI,EAAE,GAAGR,aAAa,CAACG,GAAG,CAAC,CAAC,CAACC,IAAI,CAAC,KAAK,GAAGI,MAAM,GAAGJ,IAAI,EAAE,CAAC,CAAC,CAACE,IAAI,CACxE,IAAI,CACL;AAEH;;;;;AAAAJ,OAAA,CAAAK,WAAA,GAAAA,WAAA;AAKO,MAAME,eAAe,GAAAP,OAAA,CAAAO,eAAA,GAAG,IAAI;AAEnC;;;;;;;;;;;;;;;;;;;;;AAqBA,MAAMC,mBAAmB,GAAoC;EAC3DL,IAAI,EAAE,GAAGI,eAAe,OAAO;EAC/BE,IAAI,EAAE,UAAUF,eAAe,kBAAkB;EACjDG,IAAI,EAAE,GAAGH,eAAe,OAAO;EAC/BI,IAAI,EAAE,GAAGJ,eAAe,OAAO;EAC/BK,WAAW,EAAE,GAAGL,eAAe,cAAc;EAC7CM,QAAQ,EAAE,YAAYN,eAAe;CACtC;AAED;;;;;AAKO,MAAMO,eAAe,GAAAd,OAAA,CAAAc,eAAA,gBAAWhB,aAAa,CAACG,GAAG,CAAC,CAAC,CAACC,IAAI,CAAC,KAAKA,IAAI,CAAC,CAACE,IAAI,CAC7E,IAAI,CACL;AAED;;;;;;;;;;AAUO,MAAMW,qBAAqB,GAAAf,OAAA,CAAAe,qBAAA,gBAAWjB,aAAa,CAACG,GAAG,CAC5D,CAAC,CAACC,IAAI,CAAC,KAAKM,mBAAmB,CAACN,IAAI,CAAC,CACtC,CAACE,IAAI,CAAC,IAAI,CAAC;AAEZ;;;;;;AAMO,MAAMY,qBAAqB,GAAIC,QAAgB,IACpD,iBAAiBA,QAAQ,gCAAgCA,QAAQ,4BAA4BA,QAAQ,IAAI;AAc3G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAAjB,OAAA,CAAAgB,qBAAA,GAAAA,qBAAA;AA4CO,MAAME,gBAAgB,GAAIC,MAAmB,IAClD;;;;;;;2BAOyBA,MAAM,CAACC,cAAc;;;;;;;WAOrCD,MAAM,CAACE,GAAG;wBACGF,MAAM,CAACG,SAAS;;;;;;;;;;;;;IAapC;AAEJ;;;;;;AAAAtB,OAAA,CAAAkB,gBAAA,GAAAA,gBAAA;AAMO,MAAMK,aAAa,GACxBJ,MAA+C,IAE/C;WACSA,MAAM,CAACK,IAAI;mBACHL,MAAM,CAACG,SAAS;YACvBN,qBAAqB,CAAC,iBAAiB,CAAC,EAAE;AAEtD;AAAAhB,OAAA,CAAAuB,aAAA,GAAAA,aAAA;AACO,MAAME,eAAe,GAAID,IAAY,IAC1C,UAAUnB,WAAW,EAAE;UACfmB,IAAI;;;YAGF;AAEZ;AAAAxB,OAAA,CAAAyB,eAAA,GAAAA,eAAA;AACO,MAAMC,eAAe,GAAIF,IAAY,IAC1C,UAAUnB,WAAW,EAAE;UACfmB,IAAI;;;YAGF;AAEZ;;;;;;AAAAxB,OAAA,CAAA0B,eAAA,GAAAA,eAAA;AAMO,MAAMC,aAAa,GAAGA,CAACH,IAAY,EAAEH,GAAW,KACrD,QAAQH,gBAAgB,CAAC;EAAEE,cAAc,EAAE,WAAW;EAAEE,SAAS,EAAE,IAAI;EAAEE,IAAI;EAAEH;AAAG,CAAE,CAAC;;;MAGjFE,aAAa,CAAC;EAAEC,IAAI;EAAEF,SAAS,EAAE;AAAI,CAAE,CAAC;;;;WAInCjB,WAAW,CAAC,IAAI,CAAC;SACnBmB,IAAI;;oBAEO;AAAAxB,OAAA,CAAA2B,aAAA,GAAAA,aAAA","ignoreList":[]}

package/dist/cjs/internal/readPlan.js

@@ -7,6 +7,30 @@ exports.runFetch = exports.compileFetchPlan = void 0;
 var _core = require("@kairos-es/core");
 var _matchSql = require("./matchSql.js");
 var _transport = require("./transport.js");
+/**
+ * The read-plan compiler for the Postgres engine, extracted from `store.ts` so it
+ * is a self-contained unit depending only on the PRE-QUOTED table names — never on
+ * the SQL clients. `store.ts`'s `read` and its `subscribe` — the latter feeding the
+ * plan to core's subscribe machine as that machine's `fetch` seam — both compile a
+ * plan here and run it against whichever client they hold.
+ *
+ * `compileFetchPlan` turns a servable `Query` into prepared SQL text plus a
+ * cursor-only `bind`, so a long-lived subscription re-binds only the cursor rather
+ * than re-dispatching the shape and re-serialising the query JSON on every poll.
+ * Which shape a query IS is not decided here: core's `classifyServableQuery` owns
+ * that dispatch beside the grammar it dispatches over (`Query.ts`), including the
+ * degenerate empty item's routing. The JSON/JSONB transport shapes and
+ * (de)serialisers — `EventRow`, `jsonbText`, `toQueryItemsJson`, `rowToSequenced`
+ * — live in `internal/transport.ts`, and this module only compiles plans.
+ *
+ * A plan compiled here is therefore the one place the Postgres engine dispatches
+ * a shape in TypeScript, and the exhaustiveness below protects BOTH verbs that
+ * compile one — `read`, and the `subscribe` poll sharing its plan. What it cannot
+ * reach is the append: its conflict guard covers the same three shapes inside its
+ * plpgsql body, where no compiler follows, and `ddl.ts` owns what that rests on
+ * instead.
+ */
+
 /**
  * Compile a servable query into a `FetchPlan`. The SQL comes from the shared
  * `matchSql` builders (the tagged path composes the same emitted match chain as the
@@ -35,7 +59,7 @@ const compileFetchPlan = (tables, query) => {
       };
     case 'typeOnly':
       {
-        // node-postgres binds a JS array param as a Postgres array literal, so
+        // `@effect/sql-pg` binds a JS array of strings as a `text[]` param, so
         // `type = ANY($2)` matches any of the item's types. A branded `EventType` IS
         // its string to the driver, so nothing has to be unwrapped — but the list is
         // COPIED here, at compile time. The driver serialises the array afresh on

package/dist/cjs/internal/readPlan.js.map

@@ -1 +1 @@
-{"version":3,"file":"readPlan.js","names":["_core","require","_matchSql","_transport","compileFetchPlan","tables","query","shape","classifyServableQuery","kind","text","wildcardReadSql","main","bind","after","limit","types","typeOnlyReadSql","itemsJson","jsonbText","toQueryItemsJson","taggedReadSql","tag","exports","runFetch","sql","plan","unsafe","ORIGIN"],"sources":["../../../src/internal/readPlan.ts"],"sourcesContent":[null],"mappings":";;;;;;AAyBA,IAAAA,KAAA,GAAAC,OAAA;AAEA,IAAAC,SAAA,GAAAD,OAAA;AACA,IAAAE,UAAA,GAAAF,OAAA;AA0BA;;;;;;;;;;;;;;;;;;AAkBO,MAAMG,gBAAgB,GAAGA,CAC9BC,MAAkB,EAClBC,KAAY,KACC;EACb,MAAMC,KAAK,GAAG,IAAAC,2BAAqB,EAACF,KAAK,CAAC;EAC1C,QAAQC,KAAK,CAACE,IAAI;IAChB,KAAK,UAAU;MACb,OAAO;QACLC,IAAI,EAAE,IAAAC,yBAAe,EAACN,MAAM,CAACO,IAAI,CAAC;QAClCC,IAAI,EAAEA,CAACC,KAAK,EAAEC,KAAK,KAAK,CAACD,KAAK,EAAEC,KAAK;OACtC;IACH,KAAK,UAAU;MAAE;QACf;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA,MAAMC,KAAK,GAAG,CAAC,GAAGT,KAAK,CAACS,KAAK,CAAC;QAC9B,OAAO;UACLN,IAAI,EAAE,IAAAO,yBAAe,EAACZ,MAAM,CAACO,IAAI,CAAC;UAClCC,IAAI,EAAEA,CAACC,KAAK,EAAEC,KAAK,KAAK,CAACD,KAAK,EAAEE,KAAK,EAAED,KAAK;SAC7C;MACH;IACA,KAAK,QAAQ;MAAE;QACb;QACA;QACA,MAAMG,SAAS,GAAG,IAAAC,oBAAS,EAAC,IAAAC,2BAAgB,EAACd,KAAK,CAAC,CAAC;QACpD,OAAO;UACLI,IAAI,EAAE,IAAAW,uBAAa,EAAChB,MAAM,CAACO,IAAI,EAAEP,MAAM,CAACiB,GAAG,CAAC;UAC5CT,IAAI,EAAEA,CAACC,KAAK,EAAEC,KAAK,KAAK,CAACG,SAAS,EAAEJ,KAAK,EAAEC,KAAK;SACjD;MACH;EACF;AACF,CAAC;AAED;;;;AAAAQ,OAAA,CAAAnB,gBAAA,GAAAA,gBAAA;AAIO,MAAMoB,QAAQ,GAAGA,CACtBC,GAAwB,EACxBC,IAAe,EACfZ,KAA2B,EAC3BC,KAA4B,KAE5BU,GAAG,CAACE,MAAM,CAAWD,IAAI,CAAChB,IAAI,EAAEgB,IAAI,CAACb,IAAI,CAACC,KAAK,IAAIc,YAAM,EAAEb,KAAK,IAAI,IAAI,CAAC,CAAC;AAAAQ,OAAA,CAAAC,QAAA,GAAAA,QAAA","ignoreList":[]}
+{"version":3,"file":"readPlan.js","names":["_core","require","_matchSql","_transport","compileFetchPlan","tables","query","shape","classifyServableQuery","kind","text","wildcardReadSql","main","bind","after","limit","types","typeOnlyReadSql","itemsJson","jsonbText","toQueryItemsJson","taggedReadSql","tag","exports","runFetch","sql","plan","unsafe","ORIGIN"],"sources":["../../../src/internal/readPlan.ts"],"sourcesContent":[null],"mappings":";;;;;;AAyBA,IAAAA,KAAA,GAAAC,OAAA;AAGA,IAAAC,SAAA,GAAAD,OAAA;AACA,IAAAE,UAAA,GAAAF,OAAA;AA7BA;;;;;;;;;;;;;;;;;;;;;;;;AAuDA;;;;;;;;;;;;;;;;;;AAkBO,MAAMG,gBAAgB,GAAGA,CAC9BC,MAAkB,EAClBC,KAAY,KACC;EACb,MAAMC,KAAK,GAAG,IAAAC,2BAAqB,EAACF,KAAK,CAAC;EAC1C,QAAQC,KAAK,CAACE,IAAI;IAChB,KAAK,UAAU;MACb,OAAO;QACLC,IAAI,EAAE,IAAAC,yBAAe,EAACN,MAAM,CAACO,IAAI,CAAC;QAClCC,IAAI,EAAEA,CAACC,KAAK,EAAEC,KAAK,KAAK,CAACD,KAAK,EAAEC,KAAK;OACtC;IACH,KAAK,UAAU;MAAE;QACf;QACA;QACA;QACA;QACA;QACA;QACA;QACA;QACA,MAAMC,KAAK,GAAG,CAAC,GAAGT,KAAK,CAACS,KAAK,CAAC;QAC9B,OAAO;UACLN,IAAI,EAAE,IAAAO,yBAAe,EAACZ,MAAM,CAACO,IAAI,CAAC;UAClCC,IAAI,EAAEA,CAACC,KAAK,EAAEC,KAAK,KAAK,CAACD,KAAK,EAAEE,KAAK,EAAED,KAAK;SAC7C;MACH;IACA,KAAK,QAAQ;MAAE;QACb;QACA;QACA,MAAMG,SAAS,GAAG,IAAAC,oBAAS,EAAC,IAAAC,2BAAgB,EAACd,KAAK,CAAC,CAAC;QACpD,OAAO;UACLI,IAAI,EAAE,IAAAW,uBAAa,EAAChB,MAAM,CAACO,IAAI,EAAEP,MAAM,CAACiB,GAAG,CAAC;UAC5CT,IAAI,EAAEA,CAACC,KAAK,EAAEC,KAAK,KAAK,CAACG,SAAS,EAAEJ,KAAK,EAAEC,KAAK;SACjD;MACH;EACF;AACF,CAAC;AAED;;;;AAAAQ,OAAA,CAAAnB,gBAAA,GAAAA,gBAAA;AAIO,MAAMoB,QAAQ,GAAGA,CACtBC,GAAwB,EACxBC,IAAe,EACfZ,KAA2B,EAC3BC,KAA4B,KAE5BU,GAAG,CAACE,MAAM,CAAWD,IAAI,CAAChB,IAAI,EAAEgB,IAAI,CAACb,IAAI,CAACC,KAAK,IAAIc,YAAM,EAAEb,KAAK,IAAI,IAAI,CAAC,CAAC;AAAAQ,OAAA,CAAAC,QAAA,GAAAA,QAAA","ignoreList":[]}

package/dist/cjs/internal/transport.js

@@ -5,18 +5,20 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.toQueryItemsJson = exports.toEventJson = exports.rowToSequenced = exports.jsonbText = void 0;
 var _effect = require("effect");
+var _encoding = require("effect/encoding");
 /**
  * Serialise a value to a JSON STRING for transport as a `::jsonb`-cast bound
  * parameter.
  *
- * WHY not `sql.json(value)`: `@effect/sql-pg`'s `json` helper binds the RAW
- * value, and node-postgres serialises a JS *array* bound param as a Postgres
- * ARRAY literal (`{…}`), not JSON — so `sql.json([...])::jsonb` fails with a
- * `22P02` invalid-JSON error (an array literal is not valid JSON). Passing a
- * pre-stringified JSON string and casting `::jsonb` sends plain text that
- * Postgres parses as JSON, which round-trips reliably for both objects and
- * arrays. Kept as a named helper so every JSON-transport call site is consistent
- * and the reasoning lives in one place.
+ * WHY a string and not `sql.json(value)`: the read plan runs through
+ * `sql.unsafe(text, params)` with POSITIONAL parameters, and a positional
+ * parameter must be a plain scalar or a flat array of scalars — `@effect/sql-pg`
+ * cannot infer a Postgres type for an object or an array of objects, and a
+ * `sql.json` fragment is not a value that list can carry. A pre-stringified
+ * JSON string binds untyped and the `::jsonb` cast has Postgres parse it, which
+ * round-trips reliably for both objects and arrays on the positional path and
+ * the tagged-template path alike. Kept as a named helper so every
+ * JSON-transport call site is consistent and the reasoning lives in one place.
  */
 const jsonbText = value => JSON.stringify(value);
 /** Serialise a `Query`'s items into their transport JSON shape. */
@@ -29,9 +31,11 @@ const toQueryItemsJson = query => query.items.map(item => ({
 exports.toQueryItemsJson = toQueryItemsJson;
 const toEventJson = event => ({
   type: event.type,
-  // `Encoding.encodeBase64` (from `effect`) keeps this dependency-free and pure
-  // — no `Buffer`, so no `@types/node` and no browser/runtime coupling.
-  data: _effect.Encoding.encodeBase64(event.data),
+  // `Base64.encode` (from `effect/encoding`) keeps this dependency-free and pure
+  // — no `Buffer`, so no `@types/node` and no browser/runtime coupling. It emits
+  // the standard RFC 4648 alphabet with `=` padding, which is what plpgsql's
+  // `decode(…, 'base64')` reads.
+  data: _encoding.Base64.encode(event.data),
   tags: [...event.tags],
   uuid: event.uuid,
   occurred_at: _effect.DateTime.formatIso(event.occurredAt),
@@ -59,7 +63,7 @@ const metadataFrom = value => {
 /**
  * Map a raw main-table row to a core `SequencedEvent`. `data` NULL → empty bytes
  * (a payload-less event round-trips to a zero-length `Uint8Array`); `occurred_at`
- * Date → `DateTime.Utc`; `id` string → branded `Position`; `metadata` through
+ * Date → `DateTime.Utc`; `id` → branded `Position`; `metadata` through
  * `metadataFrom`. The column is `NOT NULL DEFAULT '{}'`, so there is no absent
  * case to reconcile: an event appended with an empty bag reads back as `{}` on
  * this engine exactly as on the in-memory oracle.
@@ -80,7 +84,7 @@ const rowToSequenced = row => ({
     data: row.data ?? new Uint8Array(0),
     tags: row.tags,
     uuid: row.uuid,
-    occurredAt: _effect.DateTime.unsafeFromDate(row.occurred_at),
+    occurredAt: _effect.DateTime.fromDateUnsafe(row.occurred_at),
     metadata: metadataFrom(row.metadata)
   },
   position: BigInt(row.id)

package/dist/cjs/internal/transport.js.map

@@ -1 +1 @@
-{"version":3,"file":"transport.js","names":["_effect","require","jsonbText","value","JSON","stringify","exports","toQueryItemsJson","query","items","map","item","types","tags","toEventJson","event","type","data","Encoding","encodeBase64","uuid","occurred_at","DateTime","formatIso","occurredAt","metadata","metadataFrom","Array","isArray","Error","rowToSequenced","row","Uint8Array","unsafeFromDate","position","BigInt","id"],"sources":["../../../src/internal/transport.ts"],"sourcesContent":[null],"mappings":";;;;;;AA4BA,IAAAA,OAAA,GAAAC,OAAA;AAGA;;;;;;;;;;;;;AAaO,MAAMC,SAAS,GAAIC,KAAc,IAAaC,IAAI,CAACC,SAAS,CAACF,KAAK,CAAC;AAQ1E;AAAAG,OAAA,CAAAJ,SAAA,GAAAA,SAAA;AACO,MAAMK,gBAAgB,GAAIC,KAAY,IAC3CA,KAAK,CAACC,KAAK,CAACC,GAAG,CAAEC,IAAI,KAAM;EACzBC,KAAK,EAAE,CAAC,GAAGD,IAAI,CAACC,KAAK,CAAC;EACtBC,IAAI,EAAE,CAAC,GAAGF,IAAI,CAACE,IAAI;CACpB,CAAC,CAAC;AA+BL;AAAAP,OAAA,CAAAC,gBAAA,GAAAA,gBAAA;AACO,MAAMO,WAAW,GAAIC,KAAe,KAAiB;EAC1DC,IAAI,EAAED,KAAK,CAACC,IAAI;EAChB;EACA;EACAC,IAAI,EAAEC,gBAAQ,CAACC,YAAY,CAACJ,KAAK,CAACE,IAAI,CAAC;EACvCJ,IAAI,EAAE,CAAC,GAAGE,KAAK,CAACF,IAAI,CAAC;EACrBO,IAAI,EAAEL,KAAK,CAACK,IAAI;EAChBC,WAAW,EAAEC,gBAAQ,CAACC,SAAS,CAACR,KAAK,CAACS,UAAU,CAAC;EACjDC,QAAQ,EAAEV,KAAK,CAACU;CACjB,CAAC;AAgCF;;;;;;;;;;;;AAAAnB,OAAA,CAAAQ,WAAA,GAAAA,WAAA;AAYA,MAAMY,YAAY,GAAIvB,KAAc,IAAc;EAChD,IAAI,OAAOA,KAAK,KAAK,QAAQ,IAAIA,KAAK,KAAK,IAAI,IAAIwB,KAAK,CAACC,OAAO,CAACzB,KAAK,CAAC,EAAE;IACvE,MAAM,IAAI0B,KAAK,CACb,sFAAsFzB,IAAI,CAACC,SAAS,CAACF,KAAK,CAAC,IAAI,CAChH;EACH;EACA,OAAOA,KAAiB;AAC1B,CAAC;AAED;;;;;;;;;;;;;;;;;;AAkBO,MAAM2B,cAAc,GAAIC,GAAa,KAAsB;EAChEhB,KAAK,EAAE;IACLC,IAAI,EAAEe,GAAG,CAACf,IAAwB;IAClCC,IAAI,EAAEc,GAAG,CAACd,IAAI,IAAI,IAAIe,UAAU,CAAC,CAAC,CAAC;IACnCnB,IAAI,EAAEkB,GAAG,CAAClB,IAAmC;IAC7CO,IAAI,EAAEW,GAAG,CAACX,IAAwB;IAClCI,UAAU,EAAEF,gBAAQ,CAACW,cAAc,CAACF,GAAG,CAACV,WAAW,CAAC;IACpDI,QAAQ,EAAEC,YAAY,CAACK,GAAG,CAACN,QAAQ;GACpC;EACDS,QAAQ,EAAEC,MAAM,CAACJ,GAAG,CAACK,EAAE;CACxB,CAAC;AAAA9B,OAAA,CAAAwB,cAAA,GAAAA,cAAA","ignoreList":[]}
+{"version":3,"file":"transport.js","names":["_effect","require","_encoding","jsonbText","value","JSON","stringify","exports","toQueryItemsJson","query","items","map","item","types","tags","toEventJson","event","type","data","Base64","encode","uuid","occurred_at","DateTime","formatIso","occurredAt","metadata","metadataFrom","Array","isArray","Error","rowToSequenced","row","Uint8Array","fromDateUnsafe","position","BigInt","id"],"sources":["../../../src/internal/transport.ts"],"sourcesContent":[null],"mappings":";;;;;;AA4BA,IAAAA,OAAA,GAAAC,OAAA;AACA,IAAAC,SAAA,GAAAD,OAAA;AAGA;;;;;;;;;;;;;;AAcO,MAAME,SAAS,GAAIC,KAAc,IAAaC,IAAI,CAACC,SAAS,CAACF,KAAK,CAAC;AAQ1E;AAAAG,OAAA,CAAAJ,SAAA,GAAAA,SAAA;AACO,MAAMK,gBAAgB,GAAIC,KAAY,IAC3CA,KAAK,CAACC,KAAK,CAACC,GAAG,CAAEC,IAAI,KAAM;EACzBC,KAAK,EAAE,CAAC,GAAGD,IAAI,CAACC,KAAK,CAAC;EACtBC,IAAI,EAAE,CAAC,GAAGF,IAAI,CAACE,IAAI;CACpB,CAAC,CAAC;AA+BL;AAAAP,OAAA,CAAAC,gBAAA,GAAAA,gBAAA;AACO,MAAMO,WAAW,GAAIC,KAAe,KAAiB;EAC1DC,IAAI,EAAED,KAAK,CAACC,IAAI;EAChB;EACA;EACA;EACA;EACAC,IAAI,EAAEC,gBAAM,CAACC,MAAM,CAACJ,KAAK,CAACE,IAAI,CAAC;EAC/BJ,IAAI,EAAE,CAAC,GAAGE,KAAK,CAACF,IAAI,CAAC;EACrBO,IAAI,EAAEL,KAAK,CAACK,IAAI;EAChBC,WAAW,EAAEC,gBAAQ,CAACC,SAAS,CAACR,KAAK,CAACS,UAAU,CAAC;EACjDC,QAAQ,EAAEV,KAAK,CAACU;CACjB,CAAC;AAoCF;;;;;;;;;;;;AAAAnB,OAAA,CAAAQ,WAAA,GAAAA,WAAA;AAYA,MAAMY,YAAY,GAAIvB,KAAc,IAAc;EAChD,IAAI,OAAOA,KAAK,KAAK,QAAQ,IAAIA,KAAK,KAAK,IAAI,IAAIwB,KAAK,CAACC,OAAO,CAACzB,KAAK,CAAC,EAAE;IACvE,MAAM,IAAI0B,KAAK,CACb,sFAAsFzB,IAAI,CAACC,SAAS,CAACF,KAAK,CAAC,IAAI,CAChH;EACH;EACA,OAAOA,KAAiB;AAC1B,CAAC;AAED;;;;;;;;;;;;;;;;;;AAkBO,MAAM2B,cAAc,GAAIC,GAAa,KAAsB;EAChEhB,KAAK,EAAE;IACLC,IAAI,EAAEe,GAAG,CAACf,IAAwB;IAClCC,IAAI,EAAEc,GAAG,CAACd,IAAI,IAAI,IAAIe,UAAU,CAAC,CAAC,CAAC;IACnCnB,IAAI,EAAEkB,GAAG,CAAClB,IAAmC;IAC7CO,IAAI,EAAEW,GAAG,CAACX,IAAwB;IAClCI,UAAU,EAAEF,gBAAQ,CAACW,cAAc,CAACF,GAAG,CAACV,WAAW,CAAC;IACpDI,QAAQ,EAAEC,YAAY,CAACK,GAAG,CAACN,QAAQ;GACpC;EACDS,QAAQ,EAAEC,MAAM,CAACJ,GAAG,CAACK,EAAE;CACxB,CAAC;AAAA9B,OAAA,CAAAwB,cAAA,GAAAA,cAAA","ignoreList":[]}