@smithy-hono/adapter-postgres 0.2.2

package/README.md

@@ -0,0 +1,158 @@
+# @smithy-hono/adapter-postgres
+
+Postgres-backed `DataStore<T>` for [`@smithy-hono/data-core`](../data-core)
+(Plan 13 D7). It maps the `DataStore<T>` persistence port onto Postgres over a
+narrow *structural client port* so nothing here imports the `pg` driver at
+runtime (ARCH-01).
+
+**Postgres is the recommended durable store of record for the Node deployment.**
+The Redis `DataStore` in [`@smithy-hono/adapter-node`](../adapter-node) is the
+optional **cache-grade** alternative — for ephemeral/cache-like entities or shops
+already running Redis. Redis is RAM-bound and weaker at rich list/filter/count
+(it needs hand-maintained index SETs + a capped client-side scan for undeclared
+filters). For durable CRUD, reach for Postgres. (Redis remains correct for the
+*security* stores — that is a separate concern.)
+
+| Concern | Backend | Class / fn | Consistency |
+|---------|---------|------------|-------------|
+| `DataStore<T>` | Postgres (`jsonb`) | `PostgresDataStore` / `createPostgresDataStore` | **strong** (SQL CAS) |
+
+Full capabilities: optimistic concurrency (versioned CAS), equality `filter` +
+`count` on **any** field (server-side, no client scan), opaque-cursor
+pagination, and (opt-in) soft-delete.
+
+## The PORT pattern
+
+The store never imports `pg`. All logic runs against a narrow **SEMANTIC** port
+(`PgDataPort` — `getRow` / `insertIfAbsent` / `putRow` / `updateCas` /
+`deleteCas` / `listRows` / `count`), never raw SQL. Two ports satisfy it:
+
+- **`createPgDataPort(client, table?)`** — the REAL port, the only place that
+  speaks SQL. It codes against a structural **`PgClientLike`**:
+
+  ```ts
+  interface PgClientLike {
+    query(text: string, params?: unknown[]): Promise<{
+      rows: Array<Record<string, unknown>>
+      rowCount: number | null
+    }>
+  }
+  ```
+
+  A `pg` `Pool`/`Client` is a structural superset; a `postgres.js` client
+  (adapted to this `query` shape) or a Neon serverless client satisfies it too.
+  All queries are parameterized (`$1`, `$2`, ...).
+- **`createFakePgDataPort()`** — an in-process port over a `Map` that honors the
+  SAME atomicity contract synchronously (single JS tick == atomic). It backs the
+  always-on conformance suite, so all store logic is exercised with no Postgres.
+
+## Table schema (run as a migration)
+
+The adapter never issues DDL at runtime. The consumer runs `pgCreateTableSql()`
+(+ a `pgCreateIndexSql()` per declared `@persisted` index) once per collection:
+
+```sql
+CREATE TABLE IF NOT EXISTS "data_store" (
+  scope text NOT NULL,
+  id text NOT NULL,
+  value jsonb NOT NULL,
+  version bigint NOT NULL,
+  deleted_at timestamptz,
+  PRIMARY KEY (scope, id)
+);
+-- one per declared @persisted index field (a short field-name hash is appended
+-- to the index name to keep distinct fields from colliding):
+CREATE INDEX IF NOT EXISTS "data_store_idx_ownerId_e51b6a79"
+  ON "data_store" (scope, (value->>'ownerId'));
+```
+
+- `(scope, id)` is the composite PRIMARY KEY → tenant A literally cannot address
+  tenant B's rows (cross-scope `get` returns `null`), and the same key in two
+  scopes never collides. `scope` is a length-prefixed `DataScope` segment.
+- `value` is `jsonb`, so an equality filter on **any** field is a server-side
+  `WHERE value->>'field' = $n` — **there is no client-side scan fallback**.
+  Declared indexes are purely a performance optimization (btree expression
+  indexes that keep the filter sargable at scale); an undeclared filter is still
+  answered server-side, just without a dedicated index.
+- `version` (`bigint`) is the optimistic-concurrency token; a versioned write is
+  a single conditional `UPDATE ... WHERE version = $` whose `rowCount` we inspect.
+- `deleted_at` (`timestamptz`) is NULL for live rows; a tombstone when
+  soft-deleted (hidden from `get`/`list`/`count`).
+
+## Consumer wiring
+
+### node-postgres (`pg`)
+
+```ts
+import { Pool } from 'pg'
+import {
+  createPostgresDataStore,
+  createPgDataPort,
+  pgCreateTableSql,
+  pgCreateIndexSql,
+} from '@smithy-hono/adapter-postgres'
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL })
+
+// Migration (once):
+await pool.query(pgCreateTableSql('todos'))
+await pool.query(pgCreateIndexSql('todos', 'ownerId'))
+
+const store = createPostgresDataStore(
+  createPgDataPort(pool, 'todos'),
+  { table: 'todos', indexes: ['ownerId'], softDelete: false },
+)
+// const ops = createDefaultTodoOperations(store)   // zero-handler CRUD
+```
+
+### postgres.js
+
+`postgres.js`'s tagged-template client is not `PgClientLike`-shaped, so wrap it:
+
+```ts
+import postgres from 'postgres'
+const sql = postgres(process.env.DATABASE_URL!)
+const client = {
+  async query(text: string, params: unknown[] = []) {
+    const rows = await sql.unsafe(text, params as never[])
+    return { rows: rows as unknown as Array<Record<string, unknown>>, rowCount: rows.count }
+  },
+}
+const store = createPostgresDataStore(createPgDataPort(client, 'todos'), { table: 'todos' })
+```
+
+### Neon serverless
+
+The Neon serverless driver exports a `pg`-compatible `Pool`, so it satisfies
+`PgClientLike` directly:
+
+```ts
+import { Pool } from '@neondatabase/serverless'
+const store = createPostgresDataStore(
+  createPgDataPort(new Pool({ connectionString: process.env.DATABASE_URL })),
+)
+```
+
+## Test / verify
+
+```
+npx tsc --noEmit -p tsconfig.build.json   # types (source-only, ARCH-01 guard)
+npx vitest run                            # conformance (fake-backed)
+```
+
+The always-on conformance (`src/dataStore.conformance.test.ts`) runs the
+`@smithy-hono/data-core` `describeDataStore` suite against `createFakePgDataPort`
+— full capabilities, hard-delete + soft-delete variants — so it proves adapter
+logic with root-hoisted tooling only (no Postgres, no `pg` install).
+
+## Live verification (real Postgres)
+
+`src/live.postgres.dataStore.test.ts` (gated on `DATABASE_URL` / `POSTGRES_URL`,
+self-skips when unset) runs the SAME conformance suite against a **real
+Postgres** via the real `createPgDataPort` over a `pg` `Pool` — validating the
+genuine versioned CAS, `INSERT ... ON CONFLICT`, `WHERE value->>'field'` filter +
+`COUNT(*)`, and opaque-cursor pagination server-side. `pg` is imported via a
+non-literal specifier so the file typechecks without it installed. Run it locally
+with `./scripts/verify-live.sh` (Postgres in Docker) or in CI via
+`.github/workflows/live-conformance.yml` (a `postgres:16-alpine` service
+container).

package/dist/dataStore.d.ts

@@ -0,0 +1,255 @@
+/**
+ * `DataStore<T>` (Plan 13 D7 — Postgres is the durable Node default) over
+ * Postgres, behind a narrow structural client port (ARCH-01).
+ *
+ * Postgres is a *database* backend, not a runtime, so this is its own package —
+ * usable from any runtime with a structural client (`pg`, `postgres.js`, Neon
+ * serverless). It is the **recommended durable store of record for the Node
+ * deployment**; the Redis `DataStore` in `@smithy-hono/adapter-node` is the
+ * optional cache-grade alternative (RAM-bound, weaker at rich list/filter/count).
+ *
+ * The store mirrors the adapter-cf D1 store almost line-for-line — both are SQL,
+ * so the SEMANTIC port + real-impl + Map-fake + factory + schema-helper structure
+ * is the same. The one Postgres advantage over D1/Redis: a `jsonb` value column
+ * means an equality filter on **any** field is a server-side
+ * `WHERE value->>'field' = $n` (and `COUNT(*)`) — so there is **NO client-side
+ * scan fallback** (unlike Redis). Declared `@persisted(indexes)` are purely a
+ * performance optimization: btree expression indexes on `(value->>'field')` that
+ * keep the filter sargable at scale; an undeclared filter is still answered
+ * server-side, just without a dedicated index.
+ *
+ * Like the security stores it never imports the `pg` driver: the consumer's real
+ * `pg` `Pool`/`Client`, a `postgres.js` client (adapted), or a Neon serverless
+ * client structurally satisfies {@link PgClientLike}, and all store logic runs
+ * against a narrow SEMANTIC port ({@link PgDataPort}) — never raw SQL — so the
+ * conformance fake reimplements the semantics in JS with no SQL parser.
+ *
+ * Storage model (one entity = one row):
+ *   - table {@link PG_TABLE_DEFAULT} (override via `opts.table`), columns:
+ *     `scope` (length-prefixed {@link DataScope}), `id` (the entity key),
+ *     `value` (`jsonb`, the JSON entity), `version` (`bigint`, the
+ *     optimistic-concurrency token), `deleted_at` (`timestamptz` tombstone, only
+ *     written when `softDelete`). PRIMARY KEY is `(scope, id)`, so tenant A
+ *     literally cannot address tenant B's rows (cross-scope `get` → null), and
+ *     the same key in two scopes never collides.
+ *   - Declared `@persisted(indexes)` map to btree expression indexes over the
+ *     JSONB so a filtered `list`/`count` stays sargable. See
+ *     {@link pgCreateTableSql} for the migration the consumer runs.
+ */
+import { type DataScope, type DataStore, type ListQuery, type Page, type Stored } from '@smithy-hono/data-core';
+/** A persisted row as the port exchanges it (the store owns the JSON shape). */
+export interface PgRow {
+    /** The entity key (the resource identifier). */
+    id: string;
+    /** The JSON-serialized entity (without the store-managed `version`). */
+    value: string;
+    /** The optimistic-concurrency version. */
+    version: number;
+    /** ISO tombstone timestamp, or `null` for a live row. */
+    deletedAt: string | null;
+}
+/** A query the Postgres port resolves server-side (the store never builds SQL). */
+export interface PgListArgs {
+    /** Max rows to return (the store asks for `limit + 1` to detect more pages). */
+    limit: number;
+    /** Exclusive lower bound on `id` (the decoded cursor), or undefined for the start. */
+    after?: string;
+    /** Equality filter over JSONB fields (resolved as `value->>'field' = $n` predicates). */
+    filter?: Record<string, string | number | boolean>;
+    /** When true, tombstoned rows are excluded (soft-delete stores). */
+    excludeDeleted: boolean;
+}
+/**
+ * The minimal SEMANTIC port {@link PostgresDataStore} uses. Implementations MUST
+ * preserve the atomicity of {@link updateCas} / {@link deleteCas} (the
+ * versioned read-compare-write) and the create-if-absent of
+ * {@link insertIfAbsent}.
+ */
+export interface PgDataPort {
+    /** Fetch one row by `(scope, id)`, or `null`. Tombstones are returned (the store hides them). */
+    getRow(scope: string, id: string): Promise<PgRow | null>;
+    /**
+     * Create-if-absent. Returns the ASSIGNED version on a write (`1` for a
+     * brand-new key or a create after a HARD delete; `tombstone.version + 1` when
+     * resurrecting a soft-delete tombstone — the version CONTINUES, never resets),
+     * or `null` if a (live) row already existed at `(scope, id)` (atomic
+     * `INSERT ... ON CONFLICT DO NOTHING`). `allowOverTombstone` resurrects a
+     * tombstoned row (soft-delete create).
+     */
+    insertIfAbsent(scope: string, row: PgRow, allowOverTombstone: boolean): Promise<number | null>;
+    /** Unconditional upsert (idempotent `put`). Returns the resulting version. */
+    putRow(scope: string, row: PgRow, prevVersion: number | null): Promise<number>;
+    /**
+     * Versioned compare-and-set. Writes `row` only if the current version equals
+     * `expectedVersion` (when given) and the row exists+is live. Returns the new
+     * version on success, `-1` on miss, `-2` on a version conflict.
+     */
+    updateCas(scope: string, row: PgRow, expectedVersion: number | undefined): Promise<number>;
+    /**
+     * Versioned delete. Hard-removes (or, when `softDeletePayload` is given,
+     * tombstones) the row at `(scope, id)`. Returns the new version on a
+     * soft-delete, `0` on a successful hard delete, `-1` on miss, `-2` on conflict.
+     */
+    deleteCas(scope: string, id: string, expectedVersion: number | undefined, softDeletePayload: PgRow | null): Promise<number>;
+    /** List rows in a scope, ordered by `id`, honoring filter + cursor. */
+    listRows(scope: string, args: PgListArgs): Promise<PgRow[]>;
+    /** Count rows in a scope honoring the filter (server-side `COUNT(*)`). */
+    count(scope: string, filter: Record<string, string | number | boolean> | undefined, excludeDeleted: boolean): Promise<number>;
+}
+/**
+ * The slice of a node-postgres client {@link createPgDataPort} maps onto. A
+ * consumer's real `pg` `Pool`/`Client` is a structural superset — so nothing
+ * here imports `pg` (ARCH-01). A `postgres.js` client (adapted to this `query`
+ * shape) or a Neon serverless client satisfies it too. Only `query` is used;
+ * queries are always parameterized (`$1`, `$2`, ...).
+ */
+export interface PgClientLike {
+    query(text: string, params?: unknown[]): Promise<{
+        rows: Array<Record<string, unknown>>;
+        rowCount: number | null;
+    }>;
+    /**
+     * OPTIONAL: check out a single dedicated connection (the node-postgres
+     * `Pool.connect()` shape). When present, the `statement_timeout`-scoped read
+     * path runs its whole `BEGIN`/`SET LOCAL`/read/`COMMIT` on this ONE connection
+     * so the timeout actually applies (a bare `Pool.query()` per statement can land
+     * each on a different pooled connection, defeating `SET LOCAL`). Adding this is
+     * a backward-compatible widening: a bare `query()`-only client still satisfies
+     * the interface and falls back to an untimed read.
+     */
+    connect?(): Promise<{
+        query(text: string, params?: unknown[]): Promise<{
+            rows: Array<Record<string, unknown>>;
+            rowCount: number | null;
+        }>;
+        release(err?: unknown): void;
+    }>;
+}
+/** Default Postgres table name; override via {@link PostgresDataStoreOptions.table}. */
+export declare const PG_TABLE_DEFAULT = "data_store";
+/** Options for {@link createPostgresDataStore} / {@link PostgresDataStore}. */
+export interface PostgresDataStoreOptions {
+    /**
+     * The Postgres table backing this collection. Default {@link PG_TABLE_DEFAULT}.
+     * Used by {@link createPgDataPort} when building SQL; the consumer must have
+     * created the table (see {@link pgCreateTableSql}).
+     */
+    table?: string;
+    /**
+     * Tombstone on delete instead of hard-removing, and hide tombstoned rows from
+     * `get`/`list`/`count` (default `false`). Mirrors `@persisted(softDelete:)`.
+     */
+    softDelete?: boolean;
+    /**
+     * Declared `@persisted` index field names. With Postgres an equality filter on
+     * ANY field is a server-side `WHERE value->>'field' = $n` (no client scan, even
+     * undeclared) — declaring an index just adds a matching btree expression index
+     * (see {@link pgCreateIndexSql}) so the filter stays sargable at scale. Kept for
+     * parity with the other adapters.
+     */
+    indexes?: readonly string[];
+    /**
+     * OPTIONAL upper bound on a `list`'s effective page size (defense-in-depth). When
+     * set, `list` silently CLAMPS `query.limit` down to `maxLimit`
+     * (`Math.min(query.limit, maxLimit)`) so a large caller `limit` cannot drive an
+     * unbounded scan — it does NOT reject the request. Unset (default) means NO clamp:
+     * behavior is identical to before this knob existed. The clamp only lowers rows
+     * returned per page; the opaque resume-cursor contract is unchanged.
+     */
+    maxLimit?: number;
+}
+declare class PostgresDataStore<T extends Record<string, unknown>> implements DataStore<T> {
+    #private;
+    constructor(port: PgDataPort, opts?: PostgresDataStoreOptions);
+    get(key: string, scope: DataScope): Promise<Stored<T> | null>;
+    create(key: string, value: T, scope: DataScope): Promise<Stored<T>>;
+    put(key: string, value: T, scope: DataScope): Promise<Stored<T>>;
+    update(key: string, value: T, expectedVersion: number | undefined, scope: DataScope): Promise<Stored<T>>;
+    patch(key: string, partial: Partial<T>, expectedVersion: number | undefined, scope: DataScope): Promise<Stored<T>>;
+    delete(key: string, expectedVersion: number | undefined, scope: DataScope): Promise<boolean>;
+    list(query: ListQuery, scope: DataScope): Promise<Page<T>>;
+    count(query: Omit<ListQuery, 'cursor' | 'limit'>, scope: DataScope): Promise<number>;
+}
+/**
+ * The `CREATE TABLE` for a Postgres-backed {@link DataStore}. The consumer runs
+ * this once (a migration) per collection — the adapter never issues DDL at
+ * runtime.
+ *
+ *   - `(scope, id)` is the composite PRIMARY KEY → cross-scope get returns
+ *     nothing, same key in two scopes never collides.
+ *   - `value` is `jsonb`, so an equality filter on ANY field is a server-side
+ *     `value->>'field' = $n`; declared indexes are btree expressions over it
+ *     (see {@link pgCreateIndexSql}).
+ *   - `version` is `bigint` (the optimistic-concurrency token).
+ *   - `deleted_at` is NULL for live rows; a tombstone `timestamptz` when soft-deleted.
+ *
+ * @param table the table name (default {@link PG_TABLE_DEFAULT}); must match the
+ *   `opts.table` passed to {@link createPostgresDataStore} / {@link createPgDataPort}.
+ */
+export declare function pgCreateTableSql(table?: string): string;
+/**
+ * A btree expression index for one declared `@persisted` index field, so an
+ * equality `filter` on it stays sargable in SQL. Mirrors the adapter-cf D1
+ * computed-column index. The consumer runs this alongside {@link pgCreateTableSql}.
+ *
+ * @example pgCreateIndexSql('data_store', 'ownerId')
+ */
+export declare function pgCreateIndexSql(table: string, field: string): string;
+export interface PgDataPortOptions {
+    /**
+     * Per-query `statement_timeout` (ms) applied to the `list`/`count` read
+     * statements via a transaction-scoped `SET LOCAL`, so a single pathological
+     * unindexed scan cannot run unbounded. Omit (or `0`) to leave the
+     * server/pool default in force.
+     */
+    statementTimeoutMs?: number;
+}
+/**
+ * Build the REAL {@link PgDataPort} over a structural {@link PgClientLike}. This
+ * is the only SQL in the adapter; the store logic stays SQL-free.
+ *
+ * Versioned writes are a single conditional `UPDATE ... WHERE scope=$ AND id=$
+ * AND version=$ AND deleted_at IS NULL` — Postgres runs each statement
+ * atomically, so `rowCount === 0` means "no row matched the version"; a follow-up
+ * `SELECT` disambiguates miss vs {@link CONFLICT}. Create is `INSERT ... ON
+ * CONFLICT (scope, id) DO NOTHING` (0 rows ⇒ already exists; the soft-delete
+ * variant `DO UPDATE ... WHERE deleted_at IS NOT NULL` resurrects a tombstone).
+ *
+ * Production wiring: `createPgDataPort(new Pool({ connectionString }))`.
+ *
+ * @param client the consumer's `pg` `Pool`/`Client` (structural).
+ * @param table the table name; must match {@link createPostgresDataStore}'s `opts.table`.
+ * @param opts.statementTimeoutMs optional per-query `statement_timeout` for reads.
+ */
+export declare function createPgDataPort(client: PgClientLike, table?: string, opts?: PgDataPortOptions): PgDataPort;
+/**
+ * An in-process {@link PgDataPort} backed by a `Map`. Reimplements the CAS /
+ * create-if-absent / filtered-list semantics in JS — exactly as adapter-cf's
+ * `createFakeD1DataPort` reimplements the SQL CAS — so the always-on conformance
+ * suite exercises all store logic with no Postgres. The real SQL is validated by
+ * `live.postgres.dataStore.test.ts` in CI.
+ *
+ * Each call runs its read-compare-write in one synchronous section before the
+ * returned promise settles, so there is no interleaving (JS single-thread), the
+ * same atomicity Postgres gives per statement.
+ */
+export declare function createFakePgDataPort(): PgDataPort;
+/**
+ * Construct a Postgres-backed {@link DataStore} over a {@link PgDataPort}. Like
+ * the security stores, the logic lives only against the port, so the same class
+ * passes the `@smithy-hono/data-core` conformance suite against the in-process
+ * fake AND runs unchanged against real Postgres in production.
+ *
+ * Full capabilities: optimistic concurrency (SQL CAS), equality filter + count on
+ * ANY field (server-side `WHERE value->>'field' = $n` / `COUNT(*)` — no client
+ * scan), opaque-cursor pagination, and (opt-in) soft-delete.
+ *
+ * @example
+ *   const store = createPostgresDataStore(
+ *     createPgDataPort(new Pool({ connectionString }), 'todos'),
+ *     { table: 'todos', indexes: ['ownerId'], softDelete: false },
+ *   )
+ */
+export declare function createPostgresDataStore<T extends Record<string, unknown> = Record<string, unknown>>(port: PgDataPort, opts?: PostgresDataStoreOptions): DataStore<T>;
+export { PostgresDataStore };
+//# sourceMappingURL=dataStore.d.ts.map

package/dist/dataStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataStore.d.ts","sourceRoot":"","sources":["../src/dataStore.ts"],"names":[],"mappings":"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"}

package/dist/dataStore.js

@@ -0,0 +1,620 @@
+/**
+ * `DataStore<T>` (Plan 13 D7 — Postgres is the durable Node default) over
+ * Postgres, behind a narrow structural client port (ARCH-01).
+ *
+ * Postgres is a *database* backend, not a runtime, so this is its own package —
+ * usable from any runtime with a structural client (`pg`, `postgres.js`, Neon
+ * serverless). It is the **recommended durable store of record for the Node
+ * deployment**; the Redis `DataStore` in `@smithy-hono/adapter-node` is the
+ * optional cache-grade alternative (RAM-bound, weaker at rich list/filter/count).
+ *
+ * The store mirrors the adapter-cf D1 store almost line-for-line — both are SQL,
+ * so the SEMANTIC port + real-impl + Map-fake + factory + schema-helper structure
+ * is the same. The one Postgres advantage over D1/Redis: a `jsonb` value column
+ * means an equality filter on **any** field is a server-side
+ * `WHERE value->>'field' = $n` (and `COUNT(*)`) — so there is **NO client-side
+ * scan fallback** (unlike Redis). Declared `@persisted(indexes)` are purely a
+ * performance optimization: btree expression indexes on `(value->>'field')` that
+ * keep the filter sargable at scale; an undeclared filter is still answered
+ * server-side, just without a dedicated index.
+ *
+ * Like the security stores it never imports the `pg` driver: the consumer's real
+ * `pg` `Pool`/`Client`, a `postgres.js` client (adapted), or a Neon serverless
+ * client structurally satisfies {@link PgClientLike}, and all store logic runs
+ * against a narrow SEMANTIC port ({@link PgDataPort}) — never raw SQL — so the
+ * conformance fake reimplements the semantics in JS with no SQL parser.
+ *
+ * Storage model (one entity = one row):
+ *   - table {@link PG_TABLE_DEFAULT} (override via `opts.table`), columns:
+ *     `scope` (length-prefixed {@link DataScope}), `id` (the entity key),
+ *     `value` (`jsonb`, the JSON entity), `version` (`bigint`, the
+ *     optimistic-concurrency token), `deleted_at` (`timestamptz` tombstone, only
+ *     written when `softDelete`). PRIMARY KEY is `(scope, id)`, so tenant A
+ *     literally cannot address tenant B's rows (cross-scope `get` → null), and
+ *     the same key in two scopes never collides.
+ *   - Declared `@persisted(indexes)` map to btree expression indexes over the
+ *     JSONB so a filtered `list`/`count` stays sargable. See
+ *     {@link pgCreateTableSql} for the migration the consumer runs.
+ */
+import { OptimisticConflictError, } from '@smithy-hono/data-core';
+// ---------------------------------------------------------------------------
+// Shared scope + cursor helpers (mirror the adapter-cf D1 DataStore exactly).
+// ---------------------------------------------------------------------------
+/** Length-prefixed scope segment (collision-proof, mirrors the other adapters). */
+function scopeSeg(scope) {
+    const t = scope.tenantId ?? '';
+    const o = scope.ownerId ?? '';
+    return `${t.length}:${t}|${o.length}:${o}`;
+}
+/** Opaque base64 cursor of the last entity key emitted — NEVER an offset. */
+function encodeCursor(lastKey) {
+    return btoa(unescape(encodeURIComponent(lastKey)));
+}
+function decodeCursor(cursor) {
+    return decodeURIComponent(escape(atob(cursor)));
+}
+/** Reply sentinels from {@link PgDataPort.updateCas} / {@link PgDataPort.deleteCas}. */
+const MISS = -1;
+const CONFLICT = -2;
+// ---------------------------------------------------------------------------
+// PostgresDataStore.
+// ---------------------------------------------------------------------------
+/** Default Postgres table name; override via {@link PostgresDataStoreOptions.table}. */
+export const PG_TABLE_DEFAULT = 'data_store';
+class PostgresDataStore {
+    #port;
+    #softDelete;
+    /** Declared `@persisted` index fields (for the undeclared-filter warn/refuse guard). */
+    #indexes;
+    #maxLimit;
+    constructor(port, opts = {}) {
+        this.#port = port;
+        this.#softDelete = opts.softDelete ?? false;
+        this.#indexes = new Set(opts.indexes ?? []);
+        this.#maxLimit = opts.maxLimit;
+    }
+    /** Filter field names that are NOT declared indexes (force a sequential scope scan). */
+    #undeclaredFilterFields(filter) {
+        return filter ? Object.keys(filter).filter((f) => !this.#indexes.has(f)) : [];
+    }
+    async get(key, scope) {
+        const row = await this.#port.getRow(scopeSeg(scope), key);
+        if (row === null)
+            return null;
+        if (row.deletedAt !== null)
+            return null; // tombstone invisible
+        return this.#decode(row);
+    }
+    async create(key, value, scope) {
+        // The port assigns the version: 1 for a brand-new key (or create after a HARD
+        // delete), tombstone.version + 1 when resurrecting a soft-delete tombstone.
+        const version = await this.#port.insertIfAbsent(scopeSeg(scope), { id: key, value: JSON.stringify(this.#strip(value)), version: 1, deletedAt: null }, this.#softDelete);
+        if (version === null) {
+            throw new Error(`Entity already exists at key '${key}'`);
+        }
+        return { ...value, version };
+    }
+    async put(key, value, scope) {
+        const existing = await this.#port.getRow(scopeSeg(scope), key);
+        const newVersion = await this.#port.putRow(scopeSeg(scope), { id: key, value: JSON.stringify(this.#strip(value)), version: 0, deletedAt: null }, existing?.version ?? null);
+        return { ...value, version: newVersion };
+    }
+    async update(key, value, expectedVersion, scope) {
+        const reply = await this.#port.updateCas(scopeSeg(scope), { id: key, value: JSON.stringify(this.#strip(value)), version: 0, deletedAt: null }, expectedVersion);
+        this.#assertWritten(reply, key);
+        return { ...value, version: reply };
+    }
+    async patch(key, partial, expectedVersion, scope) {
+        const existing = await this.#port.getRow(scopeSeg(scope), key);
+        if (!existing || existing.deletedAt !== null) {
+            throw new Error(`Entity not found at key '${key}'`);
+        }
+        if (expectedVersion !== undefined && existing.version !== expectedVersion) {
+            throw new OptimisticConflictError(`Version mismatch: expected ${expectedVersion}, found ${existing.version}`);
+        }
+        const current = JSON.parse(existing.value);
+        const merged = { ...current, ...partial };
+        const reply = await this.#port.updateCas(scopeSeg(scope), { id: key, value: JSON.stringify(this.#strip(merged)), version: 0, deletedAt: null }, 
+        // Guard on the version we just read so a racing writer still trips CONFLICT.
+        existing.version);
+        this.#assertWritten(reply, key);
+        return { ...merged, version: reply };
+    }
+    async delete(key, expectedVersion, scope) {
+        let payload = null;
+        if (this.#softDelete) {
+            const existing = await this.#port.getRow(scopeSeg(scope), key);
+            if (!existing || existing.deletedAt !== null)
+                return false;
+            if (expectedVersion !== undefined && existing.version !== expectedVersion) {
+                throw new OptimisticConflictError(`Version mismatch: expected ${expectedVersion}, stale delete on key '${key}'`);
+            }
+            payload = {
+                id: key,
+                value: existing.value,
+                version: existing.version + 1,
+                deletedAt: new Date().toISOString(),
+            };
+        }
+        const reply = await this.#port.deleteCas(scopeSeg(scope), key, expectedVersion, payload);
+        if (reply === MISS)
+            return false;
+        if (reply === CONFLICT) {
+            throw new OptimisticConflictError(`Version mismatch: expected ${expectedVersion}, stale delete on key '${key}'`);
+        }
+        return true;
+    }
+    async list(query, scope) {
+        // A non-positive limit would silently make all data unreachable — fail fast.
+        if (query.limit < 1)
+            throw new RangeError('list limit must be >= 1');
+        // Optional defense-in-depth clamp: lower the effective page size to maxLimit
+        // when configured. Unset = no clamp = identical to the prior behavior.
+        const effectiveLimit = this.#maxLimit !== undefined ? Math.min(query.limit, this.#maxLimit) : query.limit;
+        // An undeclared filter field has no btree expression index → a sequential scan
+        // of the scope partition before the LIMIT applies. Warn (matching adapter-node)
+        // so operators see the unindexed scan; the LIMIT + optional statement_timeout
+        // bound it.
+        const undeclared = this.#undeclaredFilterFields(query.filter);
+        if (undeclared.length > 0) {
+            console.warn(`[adapter-postgres] DataStore.list: filtering on non-declared index ` +
+                `${undeclared.join(',')} via a sequential scope scan; declare it in ` +
+                `@persisted(indexes) for a sargable btree expression index.`);
+        }
+        const after = query.cursor ? decodeCursor(query.cursor) : undefined;
+        // Ask for one extra row to know whether a further page exists.
+        const rows = await this.#port.listRows(scopeSeg(scope), {
+            limit: effectiveLimit + 1,
+            after,
+            filter: query.filter,
+            excludeDeleted: this.#softDelete,
+        });
+        const page = rows.slice(0, effectiveLimit);
+        const items = page.map((r) => this.#decode(r));
+        const hasMore = rows.length > effectiveLimit;
+        const cursor = hasMore && page.length > 0 ? encodeCursor(page[page.length - 1].id) : undefined;
+        return cursor ? { items, cursor } : { items };
+    }
+    async count(query, scope) {
+        // `count` must be EXACT, so an undeclared-filter scan can't be silently
+        // row-capped (a capped count would lie). Refuse it loudly — mirroring
+        // adapter-aws — so the field is declared in @persisted(indexes) for a
+        // server-side, index-backed count.
+        const undeclared = this.#undeclaredFilterFields(query.filter);
+        if (undeclared.length > 0) {
+            throw new Error(`[adapter-postgres] DataStore.count: an exact count on a non-declared index ` +
+                `(${undeclared.join(',')}) would require an unbounded sequential scope scan; ` +
+                `declare it in @persisted(indexes) for a server-side index count.`);
+        }
+        return this.#port.count(scopeSeg(scope), query.filter, this.#softDelete);
+    }
+    // --- internals ----------------------------------------------------------
+    /** Reconstruct a {@link Stored} envelope from a row's JSON + version. */
+    #decode(row) {
+        const obj = JSON.parse(row.value);
+        return { ...obj, version: row.version };
+    }
+    /**
+     * Drop the store-managed `version` and `deletedAt` from the persisted JSON —
+     * `version` lives in its own column and `deletedAt` in `deleted_at`, so neither
+     * belongs in the value blob (and dropping `deletedAt` stops a caller injecting
+     * one to forge a tombstone, matching the memory store).
+     */
+    #strip(stored) {
+        const { version: _v, deletedAt: _d, ...rest } = stored;
+        return rest;
+    }
+    #assertWritten(reply, key) {
+        if (reply === MISS)
+            throw new Error(`Entity not found at key '${key}'`);
+        if (reply === CONFLICT) {
+            throw new OptimisticConflictError(`Version mismatch on key '${key}'`);
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Postgres schema helpers (the consumer runs these as a migration).
+// ---------------------------------------------------------------------------
+/**
+ * The `CREATE TABLE` for a Postgres-backed {@link DataStore}. The consumer runs
+ * this once (a migration) per collection — the adapter never issues DDL at
+ * runtime.
+ *
+ *   - `(scope, id)` is the composite PRIMARY KEY → cross-scope get returns
+ *     nothing, same key in two scopes never collides.
+ *   - `value` is `jsonb`, so an equality filter on ANY field is a server-side
+ *     `value->>'field' = $n`; declared indexes are btree expressions over it
+ *     (see {@link pgCreateIndexSql}).
+ *   - `version` is `bigint` (the optimistic-concurrency token).
+ *   - `deleted_at` is NULL for live rows; a tombstone `timestamptz` when soft-deleted.
+ *
+ * @param table the table name (default {@link PG_TABLE_DEFAULT}); must match the
+ *   `opts.table` passed to {@link createPostgresDataStore} / {@link createPgDataPort}.
+ */
+export function pgCreateTableSql(table = PG_TABLE_DEFAULT) {
+    const t = quoteIdent(table);
+    return (`CREATE TABLE IF NOT EXISTS ${t} (\n` +
+        `  scope text NOT NULL,\n` +
+        `  id text NOT NULL,\n` +
+        `  value jsonb NOT NULL,\n` +
+        `  version bigint NOT NULL,\n` +
+        `  deleted_at timestamptz,\n` +
+        `  PRIMARY KEY (scope, id)\n` +
+        `);`);
+}
+/**
+ * A btree expression index for one declared `@persisted` index field, so an
+ * equality `filter` on it stays sargable in SQL. Mirrors the adapter-cf D1
+ * computed-column index. The consumer runs this alongside {@link pgCreateTableSql}.
+ *
+ * @example pgCreateIndexSql('data_store', 'ownerId')
+ */
+export function pgCreateIndexSql(table, field) {
+    const safeTable = table.replace(/[^A-Za-z0-9_]/g, '_');
+    const safeField = field.replace(/[^A-Za-z0-9_]/g, '_');
+    // Sanitizing punctuation to `_` collapses distinct fields (`a.b` vs `a-b`) onto
+    // the same name; with IF NOT EXISTS the second would silently get no index.
+    // A short hash of the RAW field keeps each declared index distinct.
+    const suffix = fieldNameHash(field);
+    return (`CREATE INDEX IF NOT EXISTS ${quoteIdent(`${safeTable}_idx_${safeField}_${suffix}`)} ` +
+        `ON ${quoteIdent(table)} (scope, (value->>${quoteLiteral(field)}));`);
+}
+/** Short, stable hex hash of a raw field name (disambiguates index names). */
+function fieldNameHash(field) {
+    // FNV-1a (32-bit) — tiny, dependency-free, stable across runs.
+    let h = 0x811c9dc5;
+    for (let i = 0; i < field.length; i++) {
+        h ^= field.charCodeAt(i);
+        h = Math.imul(h, 0x01000193);
+    }
+    return (h >>> 0).toString(16).padStart(8, '0');
+}
+// ---------------------------------------------------------------------------
+// Real Postgres port — the ONLY place that speaks SQL (ARCH-01: structural client).
+// ---------------------------------------------------------------------------
+/** Quote a SQL identifier (table / index name) — doubles embedded quotes. */
+function quoteIdent(name) {
+    return `"${name.replace(/"/g, '""')}"`;
+}
+/** Quote a SQL string literal (used only for the static field name in DDL). */
+function quoteLiteral(s) {
+    return `'${s.replace(/'/g, "''")}'`;
+}
+/**
+ * Build an equality predicate list from a filter, starting bind placeholders at
+ * `startIndex`.
+ *
+ * The comparison is TYPED to the JS filter value so it matches the stored JSON
+ * value the way `@persisted` callers expect — NOT via `->>`'s text projection,
+ * which silently diverges from `String(value)` for exotic numbers (`1e21` →
+ * `'1000000000000000000000'` vs `'1e+21'`, `0.0000001` → `'0.0000001'` vs
+ * `'1e-7'`, `1.10` → `'1.10'` vs `'1.1'`) and would return NO rows:
+ *   - number  → `jsonb_typeof(value->'field') = 'number' AND (value->'field')::numeric = $n::numeric`
+ *   - boolean → `jsonb_typeof(value->'field') = 'boolean' AND (value->'field')::boolean = $n::boolean`
+ *   - string  → `value->>'field' = $n` (text; `->>` IS the canonical text here)
+ *
+ * The `jsonb_typeof(...) = '...'` guard is what makes the numeric/boolean cast
+ * safe for mixed-type rows: a row whose field is absent, null, or a different
+ * type fails the guard and is filtered out by short-circuit BEFORE the `::numeric`
+ * / `::boolean` cast is reached, so an unrelated row never raises a cast error.
+ */
+function filterPredicates(filter, startIndex) {
+    if (!filter)
+        return { sql: '', binds: [], next: startIndex };
+    const clauses = [];
+    const binds = [];
+    let n = startIndex;
+    for (const [field, value] of Object.entries(filter)) {
+        const path = `value->${quoteLiteral(field)}`;
+        if (typeof value === 'number') {
+            // typeof guard short-circuits before the cast → cast-safe for mixed rows.
+            clauses.push(`(jsonb_typeof(${path}) = 'number' AND (${path})::numeric = $${n}::numeric)`);
+            binds.push(value);
+        }
+        else if (typeof value === 'boolean') {
+            clauses.push(`(jsonb_typeof(${path}) = 'boolean' AND (${path})::boolean = $${n}::boolean)`);
+            binds.push(value);
+        }
+        else {
+            // String value: `->>` IS the canonical text, so a text compare is exact.
+            clauses.push(`value->>${quoteLiteral(field)} = $${n}`);
+            binds.push(value);
+        }
+        n++;
+    }
+    return { sql: clauses.length ? ` AND ${clauses.join(' AND ')}` : '', binds, next: n };
+}
+/**
+ * Build the REAL {@link PgDataPort} over a structural {@link PgClientLike}. This
+ * is the only SQL in the adapter; the store logic stays SQL-free.
+ *
+ * Versioned writes are a single conditional `UPDATE ... WHERE scope=$ AND id=$
+ * AND version=$ AND deleted_at IS NULL` — Postgres runs each statement
+ * atomically, so `rowCount === 0` means "no row matched the version"; a follow-up
+ * `SELECT` disambiguates miss vs {@link CONFLICT}. Create is `INSERT ... ON
+ * CONFLICT (scope, id) DO NOTHING` (0 rows ⇒ already exists; the soft-delete
+ * variant `DO UPDATE ... WHERE deleted_at IS NOT NULL` resurrects a tombstone).
+ *
+ * Production wiring: `createPgDataPort(new Pool({ connectionString }))`.
+ *
+ * @param client the consumer's `pg` `Pool`/`Client` (structural).
+ * @param table the table name; must match {@link createPostgresDataStore}'s `opts.table`.
+ * @param opts.statementTimeoutMs optional per-query `statement_timeout` for reads.
+ */
+export function createPgDataPort(client, table = PG_TABLE_DEFAULT, opts = {}) {
+    const t = quoteIdent(table);
+    const statementTimeoutMs = opts.statementTimeoutMs ?? 0;
+    /**
+     * Run a read query (`list`/`count`) under an optional `statement_timeout`. When
+     * a timeout is configured we wrap the single statement in a transaction so
+     * `SET LOCAL` scopes the timeout to JUST this query (and resets on COMMIT/
+     * ROLLBACK).
+     *
+     * ⚠️ The transaction MUST run on a single dedicated connection: with a
+     * node-postgres `Pool`, each `Pool.query()` checks out a possibly-different
+     * pooled connection, so `BEGIN`, `SET LOCAL`, the SELECT and `COMMIT` could
+     * land on different backends — the timeout would not apply and the BEGIN's
+     * connection would be returned idle-in-transaction. So when the client exposes
+     * `connect()` we check out ONE connection and run the whole transaction on it
+     * (releasing with the error on the failure path so the pool discards the
+     * in-transaction connection). A bare `query()`-only client (no `connect`) can't
+     * safely scope `SET LOCAL`, so it falls back to a plain untimed read.
+     */
+    const runRead = async (text, binds) => {
+        if (statementTimeoutMs <= 0 || client.connect === undefined) {
+            return client.query(text, binds);
+        }
+        const conn = await client.connect();
+        try {
+            await conn.query('BEGIN');
+            await conn.query(`SET LOCAL statement_timeout = ${Math.floor(statementTimeoutMs)}`);
+            const res = await conn.query(text, binds);
+            await conn.query('COMMIT');
+            conn.release();
+            return res;
+        }
+        catch (err) {
+            // Release WITH the error so the pool discards this connection rather than
+            // returning it idle-in-transaction (no ROLLBACK round-trip needed).
+            conn.release(err);
+            throw err;
+        }
+    };
+    const toRow = (r) => {
+        if (!r)
+            return null;
+        // `value` is jsonb: node-postgres parses it to an object, so re-serialize to
+        // the JSON string the store's #decode expects. (A `postgres.js`/Neon client
+        // may already hand back a string — handle both.)
+        const value = typeof r.value === 'string' ? r.value : JSON.stringify(r.value);
+        const deleted = r.deleted_at;
+        return {
+            id: String(r.id),
+            value,
+            version: Number(r.version),
+            deletedAt: deleted === null || deleted === undefined
+                ? null
+                : deleted instanceof Date
+                    ? deleted.toISOString()
+                    : String(deleted),
+        };
+    };
+    const selectOne = async (scope, id) => {
+        const res = await client.query(`SELECT id, value, version, deleted_at FROM ${t} WHERE scope = $1 AND id = $2`, [scope, id]);
+        return toRow(res.rows[0]);
+    };
+    return {
+        async getRow(scope, id) {
+            return selectOne(scope, id);
+        },
+        async insertIfAbsent(scope, row, allowOverTombstone) {
+            // INSERT-if-absent. When soft-delete create-over-tombstone is allowed, the
+            // ON CONFLICT path resurrects a tombstoned row (deleted_at IS NOT NULL) but
+            // still refuses to overwrite a LIVE row (the WHERE keeps create exclusive).
+            const onConflict = allowOverTombstone
+                ? ` ON CONFLICT (scope, id) DO UPDATE SET value = excluded.value, ` +
+                    // CONTINUE the version off the tombstone (never reset to 1) so a
+                    // resurrected row never reuses a version a stale holder still has.
+                    `version = ${t}.version + 1, deleted_at = NULL WHERE ${t}.deleted_at IS NOT NULL`
+                : ` ON CONFLICT (scope, id) DO NOTHING`;
+            const res = await client.query(`INSERT INTO ${t} (scope, id, value, version, deleted_at) ` +
+                `VALUES ($1, $2, $3::jsonb, $4, NULL)` +
+                onConflict +
+                // RETURNING the assigned version surfaces the CONTINUED tombstone version
+                // (or 1 for a fresh insert); 0 rows ⇒ a live row blocked the create.
+                ` RETURNING version`, [scope, row.id, row.value, row.version]);
+            const r = res.rows[0];
+            return r ? Number(r.version) : null;
+        },
+        async putRow(scope, row, prevVersion) {
+            const newVersion = prevVersion === null ? 1 : prevVersion + 1;
+            await client.query(`INSERT INTO ${t} (scope, id, value, version, deleted_at) ` +
+                `VALUES ($1, $2, $3::jsonb, $4, NULL) ` +
+                `ON CONFLICT (scope, id) DO UPDATE SET value = excluded.value, ` +
+                `version = excluded.version, deleted_at = NULL`, [scope, row.id, row.value, newVersion]);
+            return newVersion;
+        },
+        async updateCas(scope, row, expectedVersion) {
+            // Read the live row to disambiguate miss vs conflict (rowCount alone can't
+            // tell them apart). The conditional UPDATE then enforces the CAS atomically
+            // — a racing writer still flips rowCount to 0.
+            const cur = await selectOne(scope, row.id);
+            if (!cur || cur.deletedAt !== null)
+                return MISS;
+            const guard = expectedVersion === undefined ? cur.version : expectedVersion;
+            const res = await client.query(`UPDATE ${t} SET value = $1::jsonb, version = version + 1 ` +
+                `WHERE scope = $2 AND id = $3 AND version = $4 AND deleted_at IS NULL`, [row.value, scope, row.id, guard]);
+            if ((res.rowCount ?? 0) === 0)
+                return CONFLICT;
+            return guard + 1;
+        },
+        async deleteCas(scope, id, expectedVersion, softDeletePayload) {
+            const cur = await selectOne(scope, id);
+            if (!cur || cur.deletedAt !== null)
+                return MISS;
+            if (expectedVersion !== undefined && cur.version !== expectedVersion)
+                return CONFLICT;
+            const guard = cur.version;
+            if (softDeletePayload) {
+                const res = await client.query(`UPDATE ${t} SET deleted_at = $1, version = version + 1 ` +
+                    `WHERE scope = $2 AND id = $3 AND version = $4 AND deleted_at IS NULL`, [softDeletePayload.deletedAt, scope, id, guard]);
+                if ((res.rowCount ?? 0) === 0)
+                    return CONFLICT;
+                return guard + 1;
+            }
+            const res = await client.query(`DELETE FROM ${t} WHERE scope = $1 AND id = $2 AND version = $3`, [scope, id, guard]);
+            if ((res.rowCount ?? 0) === 0)
+                return CONFLICT;
+            return 0;
+        },
+        async listRows(scope, args) {
+            const { sql: filterSql, binds: filterBinds, next } = filterPredicates(args.filter, 2);
+            const binds = [scope, ...filterBinds];
+            let n = next;
+            const deletedSql = args.excludeDeleted ? ` AND deleted_at IS NULL` : '';
+            let afterSql = '';
+            if (args.after !== undefined) {
+                afterSql = ` AND id > $${n}`;
+                binds.push(args.after);
+                n++;
+            }
+            const limitPlaceholder = `$${n}`;
+            binds.push(args.limit);
+            const res = await runRead(`SELECT id, value, version, deleted_at FROM ${t} ` +
+                `WHERE scope = $1${filterSql}${deletedSql}${afterSql} ORDER BY id ASC LIMIT ${limitPlaceholder}`, binds);
+            return res.rows.map((r) => toRow(r)).filter((r) => r !== null);
+        },
+        async count(scope, filter, excludeDeleted) {
+            const { sql: filterSql, binds: filterBinds } = filterPredicates(filter, 2);
+            const deletedSql = excludeDeleted ? ` AND deleted_at IS NULL` : '';
+            const res = await runRead(`SELECT COUNT(*) AS n FROM ${t} WHERE scope = $1${filterSql}${deletedSql}`, [scope, ...filterBinds]);
+            const r = res.rows[0];
+            return r ? Number(r.n) : 0;
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Fake Postgres port — in-process Map, reimplements the semantics (no SQL parser).
+// ---------------------------------------------------------------------------
+/**
+ * An in-process {@link PgDataPort} backed by a `Map`. Reimplements the CAS /
+ * create-if-absent / filtered-list semantics in JS — exactly as adapter-cf's
+ * `createFakeD1DataPort` reimplements the SQL CAS — so the always-on conformance
+ * suite exercises all store logic with no Postgres. The real SQL is validated by
+ * `live.postgres.dataStore.test.ts` in CI.
+ *
+ * Each call runs its read-compare-write in one synchronous section before the
+ * returned promise settles, so there is no interleaving (JS single-thread), the
+ * same atomicity Postgres gives per statement.
+ */
+export function createFakePgDataPort() {
+    /** `${scope} ${id}` → row. */
+    const rows = new Map();
+    const k = (scope, id) => `${scope} ${id}`;
+    const liveMatches = (row, scope, filter, excludeDeleted, afterId, scopeKey) => {
+        if (!scopeKey.startsWith(`${scope} `))
+            return false;
+        if (excludeDeleted && row.deletedAt !== null)
+            return false;
+        if (afterId !== undefined && !(row.id > afterId))
+            return false;
+        if (filter) {
+            const obj = JSON.parse(row.value);
+            for (const [field, want] of Object.entries(filter)) {
+                // Both sides are real parsed JS values here (stored value + filter value),
+                // so compare them with strict equality — matching the REAL port's TYPED
+                // comparison (numbers/booleans compared as values, not via `String()`,
+                // which diverges from Postgres `->>` text for exotic numbers).
+                if (obj[field] !== want)
+                    return false;
+            }
+        }
+        return true;
+    };
+    return {
+        async getRow(scope, id) {
+            return rows.get(k(scope, id)) ?? null;
+        },
+        async insertIfAbsent(scope, row, allowOverTombstone) {
+            const cur = rows.get(k(scope, row.id));
+            if (cur && !(allowOverTombstone && cur.deletedAt !== null))
+                return null;
+            // Resurrecting a tombstone CONTINUES the version (mirrors the real port's
+            // `version = <table>.version + 1`); a fresh insert starts at 1.
+            const version = cur ? cur.version + 1 : 1;
+            rows.set(k(scope, row.id), { ...row, version, deletedAt: null });
+            return version;
+        },
+        async putRow(scope, row, prevVersion) {
+            const newVersion = prevVersion === null ? 1 : prevVersion + 1;
+            rows.set(k(scope, row.id), { ...row, version: newVersion, deletedAt: null });
+            return newVersion;
+        },
+        async updateCas(scope, row, expectedVersion) {
+            const cur = rows.get(k(scope, row.id));
+            if (!cur || cur.deletedAt !== null)
+                return MISS;
+            if (expectedVersion !== undefined && cur.version !== expectedVersion)
+                return CONFLICT;
+            const newVersion = cur.version + 1;
+            rows.set(k(scope, row.id), { ...row, version: newVersion, deletedAt: null });
+            return newVersion;
+        },
+        async deleteCas(scope, id, expectedVersion, softDeletePayload) {
+            const cur = rows.get(k(scope, id));
+            if (!cur || cur.deletedAt !== null)
+                return MISS;
+            if (expectedVersion !== undefined && cur.version !== expectedVersion)
+                return CONFLICT;
+            if (softDeletePayload) {
+                const newVersion = cur.version + 1;
+                rows.set(k(scope, id), { ...softDeletePayload, version: newVersion });
+                return newVersion;
+            }
+            rows.delete(k(scope, id));
+            return 0;
+        },
+        async listRows(scope, args) {
+            const out = [];
+            for (const [key, row] of rows) {
+                if (liveMatches(row, scope, args.filter, args.excludeDeleted, args.after, key)) {
+                    out.push(row);
+                }
+            }
+            out.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+            return out.slice(0, args.limit);
+        },
+        async count(scope, filter, excludeDeleted) {
+            let n = 0;
+            for (const [key, row] of rows) {
+                if (liveMatches(row, scope, filter, excludeDeleted, undefined, key))
+                    n++;
+            }
+            return n;
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Postgres factory.
+// ---------------------------------------------------------------------------
+/**
+ * Construct a Postgres-backed {@link DataStore} over a {@link PgDataPort}. Like
+ * the security stores, the logic lives only against the port, so the same class
+ * passes the `@smithy-hono/data-core` conformance suite against the in-process
+ * fake AND runs unchanged against real Postgres in production.
+ *
+ * Full capabilities: optimistic concurrency (SQL CAS), equality filter + count on
+ * ANY field (server-side `WHERE value->>'field' = $n` / `COUNT(*)` — no client
+ * scan), opaque-cursor pagination, and (opt-in) soft-delete.
+ *
+ * @example
+ *   const store = createPostgresDataStore(
+ *     createPgDataPort(new Pool({ connectionString }), 'todos'),
+ *     { table: 'todos', indexes: ['ownerId'], softDelete: false },
+ *   )
+ */
+export function createPostgresDataStore(port, opts = {}) {
+    return new PostgresDataStore(port, opts);
+}
+export { PostgresDataStore };
+//# sourceMappingURL=dataStore.js.map

package/dist/dataStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataStore.js","sourceRoot":"","sources":["../src/dataStore.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `@smithy-hono/adapter-postgres` — the Postgres-backed `DataStore<T>` for
+ * `@smithy-hono/data-core` (Plan 13 D7).
+ *
+ * Postgres is the **recommended durable store of record for the Node
+ * deployment**: a `jsonb` value column with versioned CAS, server-side
+ * `WHERE value->>'field' = $n` filtering on ANY field (no client scan), opaque-
+ * cursor pagination, and soft-delete. The Redis `DataStore` in
+ * `@smithy-hono/adapter-node` is the optional cache-grade alternative.
+ *
+ * All store logic runs against a narrow SEMANTIC port ({@link PgDataPort}); the
+ * real port ({@link createPgDataPort}) is the only place that speaks SQL, over a
+ * structural client ({@link PgClientLike}) so nothing here imports the `pg`
+ * driver at runtime (ARCH-01). The in-process fake ({@link createFakePgDataPort})
+ * backs the always-on conformance suite; the live test validates the real SQL.
+ */
+export { createPostgresDataStore, PostgresDataStore, type PostgresDataStoreOptions, } from './dataStore.js';
+export { createPgDataPort, createFakePgDataPort, type PgDataPort, type PgDataPortOptions, type PgClientLike, type PgRow, type PgListArgs, } from './dataStore.js';
+export { pgCreateTableSql, pgCreateIndexSql, PG_TABLE_DEFAULT, } from './dataStore.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EACL,uBAAuB,EACvB,iBAAiB,EACjB,KAAK,wBAAwB,GAC9B,MAAM,gBAAgB,CAAA;AAGvB,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACpB,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,KAAK,EACV,KAAK,UAAU,GAChB,MAAM,gBAAgB,CAAA;AAGvB,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,gBAAgB,CAAA"}

package/dist/index.js

@@ -0,0 +1,23 @@
+/**
+ * `@smithy-hono/adapter-postgres` — the Postgres-backed `DataStore<T>` for
+ * `@smithy-hono/data-core` (Plan 13 D7).
+ *
+ * Postgres is the **recommended durable store of record for the Node
+ * deployment**: a `jsonb` value column with versioned CAS, server-side
+ * `WHERE value->>'field' = $n` filtering on ANY field (no client scan), opaque-
+ * cursor pagination, and soft-delete. The Redis `DataStore` in
+ * `@smithy-hono/adapter-node` is the optional cache-grade alternative.
+ *
+ * All store logic runs against a narrow SEMANTIC port ({@link PgDataPort}); the
+ * real port ({@link createPgDataPort}) is the only place that speaks SQL, over a
+ * structural client ({@link PgClientLike}) so nothing here imports the `pg`
+ * driver at runtime (ARCH-01). The in-process fake ({@link createFakePgDataPort})
+ * backs the always-on conformance suite; the live test validates the real SQL.
+ */
+// --- DataStore<T> factory + class (Plan 13 D7) ------------------------------
+export { createPostgresDataStore, PostgresDataStore, } from './dataStore.js';
+// --- Ports: the SEMANTIC port + the real/fake builders + structural client ---
+export { createPgDataPort, createFakePgDataPort, } from './dataStore.js';
+// --- Schema helpers (the consumer runs these as a migration) ----------------
+export { pgCreateTableSql, pgCreateIndexSql, PG_TABLE_DEFAULT, } from './dataStore.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,+EAA+E;AAC/E,OAAO,EACL,uBAAuB,EACvB,iBAAiB,GAElB,MAAM,gBAAgB,CAAA;AAEvB,gFAAgF;AAChF,OAAO,EACL,gBAAgB,EAChB,oBAAoB,GAMrB,MAAM,gBAAgB,CAAA;AAEvB,+EAA+E;AAC/E,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,GACjB,MAAM,gBAAgB,CAAA"}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@smithy-hono/adapter-postgres",
+  "version": "0.2.2",
+  "type": "module",
+  "description": "Postgres-backed DataStore<T> for @smithy-hono/data-core (Plan 13 D7) — the recommended durable store of record for the Node deployment. A JSONB value column with versioned CAS, server-side WHERE/COUNT filtering on any field, opaque-cursor pagination, and soft-delete, all behind a narrow structural client port — no pg SDK at runtime (ARCH-01).",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "npm run clean && tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.build.json --noEmit",
+    "prepare": "npm run build",
+    "test": "vitest run",
+    "test:ci": "vitest run --exclude '**/live.*.test.ts'",
+    "test:watch": "vitest",
+    "lint": "eslint src"
+  },
+  "peerDependencies": {
+    "@smithy-hono/data-core": "^0.2.2",
+    "pg": "^8"
+  },
+  "peerDependenciesMeta": {
+    "pg": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@smithy-hono/data-core": "^0.2.2",
+    "@types/pg": "^8",
+    "@typescript-eslint/parser": "^8.0.0",
+    "eslint": "^9.0.0",
+    "pg": "^8",
+    "typescript": "^5.4.0",
+    "vitest": "^2.0.0"
+  },
+  "optionalDependencies": {},
+  "//optionalDevDependencies": {
+    "pg": "The node-postgres driver. Used ONLY by the gated live test (src/live.postgres.dataStore.test.ts) via dynamic import — the runtime source codes against the structural PgClientLike, never `import 'pg'` (ARCH-01). @types/pg is likewise live-test-only and must NOT leak into the src build (tsconfig types:[])."
+  }
+}