@crvouga/mockingbird-service-postgres 3.2.0 → 3.4.0

package/CHANGELOG.md

@@ -1,6 +1,22 @@
 # Changelog — @crvouga/mockingbird-service-postgres
 
-## 3.2.0 (2026-10-09)
+## 3.4.0 (2026-10-12)
+
+### Features
+
+- unify the emulator control plane ([2068547](https://github.com/crvouga/mockingbird/commit/2068547bedde4e2e2331c1657c1a78120e84428b))
+
+## 3.3.0 (2026-10-10)
+
+### Features
+
+- resolve reported emulator coverage gaps ([6edc643](https://github.com/crvouga/mockingbird/commit/6edc6438444853a51aca27849c4c8c0449109ea0))
+
+### Fixes and improvements
+
+- make README examples pass consumer smoke ([9f5bf6a](https://github.com/crvouga/mockingbird/commit/9f5bf6a212fffb03b1f70fb67bce7fcb49f08c40))
+
+## 3.2.0 (2026-10-08)
 
 ### Features
 

package/COMPATIBILITY.md

@@ -18,7 +18,7 @@ clock controls. This supervisor surface does not change the SQL dialect compatib
 
 Differential tests compare a **tuple** per statement: rows (normalized to canonical PostgreSQL text where typed), column names and type names where requested, error SQLSTATE class + normalized message, command tag / `rowCount`, and transaction status, plus a **logical state dump** (catalog names, column definitions, row payloads, sequence values) after write sequences.
 
-A catalog ID appearing in a test file is **not** proof by itself. Trivial probes are tracked in [`compat/smoke-baseline.json`](compat/smoke-baseline.json) and ratcheted downward (currently **0 smoke stubs** across 945 catalog scenarios). Generated operator/cast matrices live under [`tests/contract/matrices/`](tests/contract/matrices/). Observed mem≠oracle diffs must bind to a `compat/divergences.json` entry or be a **FAILURE** — unexplained diffs are not allowed.
+A catalog ID appearing in a test file is **not** proof by itself. Trivial probes are tracked in [`compat/smoke-baseline.json`](compat/smoke-baseline.json) and ratcheted downward (currently **0 smoke stubs** across 998 catalog scenarios). Generated operator/cast matrices live under [`tests/contract/matrices/`](tests/contract/matrices/). Observed mem≠oracle diffs must bind to a `compat/divergences.json` entry or be a **FAILURE** — unexplained diffs are not allowed.
 
 Intentional differences are finite and machine-readable in `compat/divergences.json` (PGMM snapshots, seeded `random()`/`now()`, sync single-session API, no aborted-transaction state, EXPLAIN stubs, trigger-order/`UPDATE OF` edges, float8 rounding/overflow edges, …). The wire server supports isolated database catalogs, startup selection, database lifecycle DDL, and copy-on-write template cloning. Human-readable: [DIVERGENCES.md](DIVERGENCES.md).
 
@@ -26,6 +26,25 @@ The wire server supports protocol-v3 text and CSV `COPY FROM STDIN` / `COPY TO S
 incremental `CopyData`, client aborts, and statement-atomic rollback. Binary COPY remains outside
 the compatibility surface.
 
+The wire server keeps settings per connection and applies the startup packet's run-time parameters
+(libpq `options=-c name=value` / `--name=value`, split like `pg_split_opts`, then parameters sent by
+name) as session defaults that `RESET` returns to. Malformed options, unknown parameters, bad
+values and read-only parameters end the connection with the `FATAL` SQLSTATEs PostgreSQL 18.3
+reports (`42601`, `42704`, `22023`, `55P02`), pinned by `tests/wire/startup-options.test.ts`.
+Known gaps: parameters the engine has no setting for are `42704`, `postgres` switches other than
+`-c` / `--` are `0A000`, `ParameterStatus` is not re-sent when a reported setting changes,
+`SET LOCAL` does not carry across the statements of a wire transaction block, `DISCARD ALL` is a
+no-op, and with no schema of `search_path` present an unqualified `CREATE` goes to `public` where
+PostgreSQL raises `3F000`.
+
+The wire server's opt-in durable mode (`serve({ durable })`, `--durable <dir>`) persists the
+cluster before a commit is acknowledged, so acknowledged commits survive a killed process. It is
+snapshot persistence of PGMM bytes behind an injectable storage port, with an atomic file-backed
+implementation. It is not a write-ahead log and not PostgreSQL's on-disk format: there is no
+`pg_wal`, no data directory another PostgreSQL could open, no physical replication or
+point-in-time recovery, and each commit costs an encode of the database it changed. See the README
+for the guarantees and their limits (`tests/wire/durable*.test.ts`, `tests/wire/file-storage.test.ts`).
+
 ## Status vocabulary
 
 | Status | Meaning |
@@ -44,7 +63,7 @@ Anything a PostgreSQL application can invoke through SQL against the PGlite **18
 3. **Single-session sync API** — no concurrent sessions or `25P02` aborted-transaction state. The optional wire server separately provides per-session `READ COMMITTED` workspaces and row locks.
 4. **NOT APPLICABLE** rows in `compat/coverage.json` (roles, replication, VACUUM internals, LISTEN/NOTIFY, cursors, full PL/pgSQL, extensions other than `pgcrypto`'s `digest()` and `pg_trgm`'s `similarity` / `<%` / `gin_trgm_ops`).
 
-The oracle exposes **2787 builtin functions** and **74 operators** in `pg_catalog`; postgres-mem implements **302 functions** and **41 operators**, and every remaining item is an explicit entry in [`compat/unsupported-register.json`](compat/unsupported-register.json) with a reason (trigger/internal plumbing, admin/monitoring, unsupported type families, …). The gate fails closed on silence.
+The oracle exposes **2787 builtin functions** and **74 operators** in `pg_catalog`; postgres-mem implements **306 functions** and **41 operators**, and every remaining item is an explicit entry in [`compat/unsupported-register.json`](compat/unsupported-register.json) with a reason (trigger/internal plumbing, admin/monitoring, unsupported type families, …). The gate fails closed on silence.
 
 ## Requirements coverage (PostgreSQL 18 SQL commands)
 
@@ -67,10 +86,21 @@ The oracle exposes **2787 builtin functions** and **74 operators** in `pg_catalo
 | Sequences / serial / identity | VERIFIED | Includes pg_dump identity sequence names and options |
 | Schemas + search_path + pg_catalog / information_schema | VERIFIED | Catalog columns are the commonly-queried subset |
 | Enums, domains, generated columns | VERIFIED | |
+| `ALTER COLUMN SET / DROP NOT NULL`, `SET / DROP DEFAULT` | VERIFIED | PostgreSQL's errors for existing NULLs (`23502`), primary-key and identity columns, column references and subqueries in a default, and literals that are not valid input for the column type. Every action of one `ALTER TABLE` applies or none does. An undefined function in a default is reported when a row first uses it, not by `ALTER TABLE` (`tests/contract/alter-table/set-not-null.test.ts`, `set-default.test.ts`) |
+| `information_schema.columns.column_default` | PARTIALLY VERIFIED | Rendered the way `pg_get_expr` prints the analyzed default: constants of every type, casts, SQL value functions, `nextval`, the built-in functions with a signature on record, operators, `ARRAY[...]`, `CASE`, `IN`, `BETWEEN`, `LIKE`. Functions outside that table print an untyped literal argument as `text`; `CURRENT_TIMESTAMP(n)`, `current_schema()` and unary `+` lose the detail the parser drops; a nested `CASE` is printed on one line. `pg_attrdef` and `pg_get_expr` are not exposed |
+| `ALTER COLUMN SET STORAGE`, `STORAGE` column clause, `pg_attribute.attstorage` | VERIFIED | SQL and catalog contract only: `PLAIN` / `EXTERNAL` / `EXTENDED` / `MAIN` / `DEFAULT`, per-type defaults, `LIKE ... INCLUDING STORAGE`, PostgreSQL's errors for an unknown mode (`22023`), a non-toastable type (`0A000`) and a missing column. **No TOAST**: values are never compressed or moved out of line, so the mode changes nothing about how rows are held. `SET STORAGE` on a materialized view fails loud (`0A000`); `SET COMPRESSION` is unsupported (`tests/contract/alter-table/set-storage.test.ts`) |
+| `CREATE UNLOGGED TABLE / SEQUENCE`, `SET LOGGED / UNLOGGED`, `pg_class.relpersistence` | VERIFIED | SQL and catalog contract only: `p` / `u` / `t` for tables, their indexes and owned sequences; contents, indexes and constraints are kept across a conversion; PostgreSQL's errors for temporary tables, for logged / unlogged / temporary foreign-key combinations (`42P16`) and for a second change in one statement. **No WAL and no crash recovery**: an unlogged table is stored exactly like a logged one, is not truncated after a crash, and is included in snapshots (`tests/contract/alter-table/set-logged.test.ts`) |
+| Index identity: `pg_class` / `pg_index` / `pg_indexes` / `pg_am` / `pg_constraint.conindid` | VERIFIED | Every index is a relation with its own oid, distinct from its table, kept through `ALTER INDEX / TABLE / SCHEMA ... RENAME`, `SET SCHEMA`, transactions and snapshots; `DROP` + `CREATE` and `REINDEX CONCURRENTLY` make a new one. The index behind a `PRIMARY KEY` or `UNIQUE` constraint appears in all of them and follows `ADD / RENAME / DROP CONSTRAINT`; dropping it directly is `2BP01`. Snapshots written before indexes had oids load with distinct ones. `pg_index` has the flag columns only: `indexprs` / `indpred` are the text `pg_get_expr()` returns, and `indkey`, `indclass`, `indoption`, `indcollation` are absent. A constraint's index name must be free among the schema's relations (`42P07`), and a generated name steps past one that is taken (`t_pkey1`) (`tests/contract/catalogs/index-definitions.test.ts`) |
+| `pg_get_indexdef(oid)`, `pg_get_indexdef(oid, column, pretty)`, `pg_indexes.indexdef` | VERIFIED | `UNIQUE`, `USING` method, `DESC` / `NULLS FIRST / LAST`, `INCLUDE`, non-default operator classes, `COLLATE`, `NULLS NOT DISTINCT`, `WITH (...)`, quoted identifiers (every non-unreserved keyword), and expressions and predicates printed as PostgreSQL prints the analyzed tree: typed constants, the implicit casts operator resolution adds, `= ANY (ARRAY[...])` for `IN`, `~~` for `LIKE`, expanded `BETWEEN`, flattened `AND` / `OR`, `CASE` layout, SQL-syntax functions. Column positions past the end or negative are `''`, an oid that is not an index is NULL, and pretty-printing drops the schema and redundant parentheses. Differential over a 127-index construct matrix; expressions outside it (subqueries, row constructors, `SIMILAR TO`, array slices) are best-effort. Access methods other than btree are recorded and rendered, not implemented differently (`tests/contract/catalogs/index-definitions.test.ts`) |
+| `pg_index.indisvalid`, `CREATE / DROP INDEX CONCURRENTLY`, `REINDEX` | VERIFIED | Completed indexes are valid, ready and live. A concurrent unique build that hits duplicates fails (`23505`) and leaves the index in the catalog, invalid and not enforced; `DROP INDEX` removes it and `REINDEX INDEX / TABLE / SCHEMA / DATABASE` repairs it once the data allows; a failed `REINDEX INDEX CONCURRENTLY` leaves `name_ccnew`. The commands PostgreSQL refuses in a transaction block are `25001`. An *interrupted* build (cancel, deadlock) cannot be provoked in the oracle: `Database.fault({ concurrentIndexBuild: "57014" })` and `server.fault({ failConcurrentIndexBuild })` arm one for tests, in the build-phase state (`indisready = false`); the state a failure in the later validation scan leaves (`indisready = true`, still enforcing) is not modelled (divergence `concurrent-index-build-fault`). `REINDEX` has no physical index to rebuild (`tests/contract/catalogs/index-validity.test.ts`, `tests/wire/index-catalog.test.ts`) |
+| `COMMENT ON INDEX`, `pg_description`, `obj_description` | VERIFIED | Stored on the index: replace, clear with `NULL` or `''`, removed with the index / table / schema, kept through renames, transactional, in snapshots, isolated per wire transaction; `42P01` / `3F000` / `42809` for a missing index, a missing schema, a relation that is not an index. Comments on every other kind of object are still accepted and not stored (divergence `comment-on-not-stored`) (`tests/contract/catalogs/index-comments.test.ts`) |
+| `regnamespace`, `to_regnamespace` | VERIFIED | Input (`-`, an all-digit oid, or exactly one identifier, case-folded unless quoted), output (quoted like `quote_ident`, numeric when no schema has the oid, `-` for zero), casts from text / name / oid / integers, implicit use as `oid` in comparisons, `pg_toast` / `pg_catalog` / `information_schema`; `3F000`, `42602` and `22003` as PostgreSQL raises them. `public` has a generated oid, not 2200 (`tests/contract/catalogs/regnamespace.test.ts`) |
+| `pg_stat_user_tables`, `pg_stat_user_indexes`, `ANALYZE` | PARTIALLY VERIFIED | PostgreSQL 18's columns and types; one row per user table and materialized view (and per index), `relid` joins `pg_class.oid`, follows create / drop / rename / schema moves, restored with snapshots. `n_live_tup` is the exact row count, immediately; `ANALYZE` validates its targets (`42P01`, `42703`, `42701`, `42601`) and records `analyze_count` / `last_analyze` from the database clock. Not tracked (read zero / NULL): scans, tuples inserted / updated / deleted, dead tuples, vacuum; `idx_scan` counts only the unique-key lookups made for `SELECT`. `VACUUM ANALYZE` does not count. Temporary tables are listed under the schema they were created in, not `pg_temp` (divergence `pg-stat-counters-immediate`) (`tests/contract/catalogs/table-statistics.test.ts`) |
 | Triggers (row-level, LANGUAGE sql-expressible) | PARTIALLY VERIFIED | Creation-order firing, `UPDATE OF` ignored, no INSTEAD OF (documented) |
 | CREATE FUNCTION LANGUAGE sql / plpgsql-lite | PARTIALLY VERIFIED | Scalar + set-returning; plpgsql subset: DECLARE, EXCEPTION WHEN others, CASE, FOR-IN-SELECT, RETURN NEXT |
 | Text search (tsvector / tsquery / @@ / ts_rank) | PARTIALLY VERIFIED | `simple`-style config; no ispell/synonym dictionaries |
 | `CREATE EXTENSION pgcrypto` / `digest()` | PARTIALLY VERIFIED | `digest(bytea, text)` and `digest(text, text)` for md5, sha1, sha224, sha256, sha384, sha512. `crypt`, `hmac`, `gen_salt`, and PGP functions are not installed. OpenSSL-only names (sha3, blake2, ripemd160, sm3) are not available. Extensions other than `pgcrypto` and `pg_trgm` still fail loud (`0A000`) |
+| `pg_available_extensions`, `pg_available_extension_versions`, `pg_extension` | VERIFIED | List exactly what `CREATE EXTENSION` can install here: `pgcrypto` (1.3, 1.4), `pg_trgm` (1.3 to 1.6) and the built-in `plpgsql` (1.0), with `installed_version`, schema and version following `CREATE` / `DROP EXTENSION`, rollback and snapshots. A stock PostgreSQL server lists every contrib module it ships; those are absent here (zero rows, and `CREATE EXTENSION` is `0A000`). An older version installs the same partial function set as the default one. `DROP EXTENSION` reports dependents (`2BP01`) and `CASCADE` removes dependent defaults, generated columns, CHECK constraints, views and indexes; `DROP EXTENSION plpgsql` and `ALTER EXTENSION` fail loud (`0A000`) (`tests/contract/extensions/catalogs.test.ts`) |
 | `CREATE EXTENSION pg_trgm` | PARTIALLY VERIFIED | `similarity(text, text)`, `<%` at the default word-similarity threshold 0.6, and a single-column `gin_trgm_ops` index on `text` or `varchar`. `gist_trgm_ops`, multicolumn `gin_trgm_ops`, and non-default thresholds are not installed. |
 | COPY FROM/TO (text, csv) | VERIFIED | Via `copyFrom` API hook / rows out |
 | PREPARE / EXECUTE / DEALLOCATE, SET / SHOW / RESET | VERIFIED | GUC subset, including PostgreSQL dump and migration-client preambles |
@@ -79,9 +109,9 @@ The oracle exposes **2787 builtin functions** and **74 operators** in `pg_catalo
 | Regex (`~`, `~*`, POSIX functions) | PARTIALLY VERIFIED | JS regex flavor mapped to POSIX ERE; documented edges |
 | EXPLAIN | PARTIALLY VERIFIED | Stub plan shapes |
 | MERGE / CALL / cursors / LISTEN / full PL/pgSQL | UNSUPPORTED | Fail loud `0A000`, registered |
-| Roles / GRANT / VACUUM / ANALYZE / LOCK | NOT APPLICABLE | Parsed no-ops where harmless |
-| Wire protocol / multi-session concurrency | PARTIALLY VERIFIED | `READ COMMITTED` workspaces; `FOR UPDATE`, `NOWAIT`, `SKIP LOCKED`, and deadlock detection |
-| On-disk PostgreSQL format | NOT APPLICABLE | PGMM snapshots are the persistence format |
+| Roles / GRANT / VACUUM / LOCK | NOT APPLICABLE | Parsed no-ops where harmless |
+| Wire protocol / multi-session concurrency | PARTIALLY VERIFIED | `READ COMMITTED` workspaces; `FOR UPDATE`, `NOWAIT`, `SKIP LOCKED`, and deadlock detection; per-connection settings and startup `options` / run-time parameters |
+| On-disk PostgreSQL format | NOT APPLICABLE | PGMM snapshots are the persistence format, also for the wire server's opt-in durable mode (snapshot persistence, not WAL) |
 
 ## How to verify
 

package/README.md

@@ -55,44 +55,59 @@ dependency instead of `-D` if you ship it to the browser.
 ## Usage
 
 ```ts
-import { Database, Snapshot } from "@crvouga/mockingbird-service-postgres"
+import pg from "pg"
+import { Snapshot } from "@crvouga/mockingbird-service-postgres"
+import { serve } from "@crvouga/mockingbird-service-postgres/wire"
 
-const db = new Database()
+// Test setup: start the emulator on a free port.
+const server = await serve({ port: 0 })
+
+// Application code: the `pg` client it already uses, given the emulator's connection string.
+const client = new pg.Client({ connectionString: server.connectionString })
+await client.connect()
 
-db.exec(`
+await client.query(`
   CREATE TABLE users (
     id serial PRIMARY KEY,
     email text UNIQUE NOT NULL,
     created_at timestamptz NOT NULL DEFAULT now()
   )
 `)
+await client.query(`INSERT INTO users (email) VALUES ($1)`, ["ada@example.com"])
 
-db.prepare(`INSERT INTO users (email) VALUES ($1)`).run("ada@example.com")
+const users = await client.query<{ id: number; email: string; created_at: Date }>(
+  `SELECT * FROM users`,
+)
+console.log(users.rows) // [{ id: 1, email: "ada@example.com", created_at: 2000-01-01T00:00:00.000Z }]
 
-const users = db.query<{ id: number; email: string; created_at: string }>(`SELECT * FROM users`)
-console.log(users) // [{ id: 1, email: "ada@example.com", created_at: "2000-01-01 00:00:00+00" }]
+// Test control, snapshots: freeze a template, boot a fork from it, or persist it as bytes.
+const seed = server.snapshot()
+const fork = await serve({ database: seed })
+const restored = await serve({ database: Snapshot.decode(seed.encode()) })
 
-// Snapshots: freeze a template, fork it cheaply, or persist it as bytes.
-const seed = db.snapshot()
-const db2 = seed.open()
-const bytes = seed.encode()
-const db3 = Snapshot.decode(bytes).open()
-console.log(db2.query(`SELECT count(*) AS n FROM users`), db3.changes) // [{ n: 1n }] 1
+await client.end()
+await Promise.all([server.close(), fork.close(), restored.close()])
 ```
 
-All methods are **synchronous**; do not `await` them. Browser and Node/Bun share the same
-in-memory surface (no filesystem). For a real TCP listener separate processes can connect to, see
-the [wire-protocol server](#wire-protocol-server-separate-processes) (Node/Bun only).
+`postgres.js`, a JDBC client and `psql` connect with the same connection string; see the
+[wire-protocol server](#wire-protocol-server-separate-processes) (Node/Bun only). In the browser,
+where no listener can run, use the embedded `Database` from the package root instead. It shares
+the same in-memory engine (no filesystem) and all its methods are **synchronous**; do not `await`
+them. See [Method semantics](#method-semantics).
 
 ### Per-test isolation with snapshots
 
-Run migrations and fixtures once, `snapshot()` the result, and `open()` a copy-on-write fork per
-test (microseconds, tables are shared until either side writes):
+Run migrations and fixtures once, `snapshot()` the result, and boot a server from that snapshot
+per test. Each one is a copy-on-write fork (microseconds, tables are shared until either side
+writes); with the embedded `Database`, `seed.open()` is the same fork without a listener:
 
 ```ts
-import { beforeEach, expect, test } from "bun:test"
-import { Database, PostgresError } from "@crvouga/mockingbird-service-postgres"
+import { afterEach, beforeEach, expect, test } from "bun:test"
+import pg from "pg"
+import { Database } from "@crvouga/mockingbird-service-postgres"
+import { type PostgresServer, serve } from "@crvouga/mockingbird-service-postgres/wire"
 
+// Test setup: build the template once, then boot a server from it for every test.
 const template = new Database()
 template.exec(`
   CREATE TABLE accounts (id serial PRIMARY KEY, email text UNIQUE NOT NULL);
@@ -100,64 +115,68 @@ template.exec(`
 `)
 const seed = template.snapshot()
 
-let db: Database
-beforeEach(() => {
-  db = seed.open()
+let server: PostgresServer
+let db: pg.Client
+beforeEach(async () => {
+  server = await serve({ database: seed })
+  db = new pg.Client({ connectionString: server.connectionString })
+  await db.connect()
+})
+afterEach(async () => {
+  await db.end()
+  await server.close()
 })
 
-test("unique violation surfaces SQLSTATE 23505", () => {
-  let error: unknown
-  try {
-    db.prepare(`INSERT INTO accounts (email) VALUES ($1)`).run("seed@example.com")
-  } catch (caught) {
-    error = caught
-  }
-  expect(error).toBeInstanceOf(PostgresError)
-  expect((error as PostgresError).code).toBe("23505")
-  expect((error as PostgresError).category).toBe("constraint_unique")
+// Application code under test uses `db`, an ordinary `pg` client.
+test("unique violation surfaces SQLSTATE 23505", async () => {
+  const insert = db.query(`INSERT INTO accounts (email) VALUES ($1)`, ["seed@example.com"])
+  await expect(insert).rejects.toMatchObject({ code: "23505", constraint: "accounts_email_key" })
 })
 
-test("each test starts from the seed", () => {
-  expect(db.query(`SELECT email FROM accounts`)).toEqual([{ email: "seed@example.com" }])
+test("each test starts from the seed", async () => {
+  const { rows } = await db.query(`SELECT email FROM accounts`)
+  expect(rows).toEqual([{ email: "seed@example.com" }])
 })
 ```
 
-### Adapting it to code written against `pg`
+### Code written against `pg`
 
-There is no async client, so put a small shim behind whatever query interface your code uses. With
-`{ int8: "string" }`, `int8` / `bigserial` / `count(*)` come back as strings, like node-postgres's
-default:
+Code written against `pg` needs no adapter: give `pg.Pool` (or `pg.Client`) the server's connection
+string. `pg` applies its own type parsers, so `int8` / `bigserial` / `count(*)` come back as
+strings, as they do against a real server:
 
 ```ts
-import { type BindValue, Database } from "@crvouga/mockingbird-service-postgres"
-
-const db = new Database({ int8: "string", now: "system" })
+import pg from "pg"
+import { serve } from "@crvouga/mockingbird-service-postgres/wire"
 
-/** Minimal pg.Pool-shaped facade: `query(text, values)` resolving to `{ rows, rowCount, command }`. */
-export const pool = {
-  query: async <T = Record<string, unknown>>(text: string, values: BindValue[] = []) => {
-    const result = db.prepare(text).result(...values)
-    return { rows: result.rows as T[], rowCount: result.rowCount, command: result.command }
-  },
-}
+// Test setup: start the emulator and give the pool its connection string.
+const server = await serve({ port: 0 })
+export const pool = new pg.Pool({ connectionString: server.connectionString })
 
+// Application code: unchanged `pg` queries.
 await pool.query(`CREATE TABLE notes (id bigserial PRIMARY KEY, body text)`)
 const inserted = await pool.query<{ id: string }>(
   `INSERT INTO notes (body) VALUES ($1) RETURNING id`,
   ["hello"],
 )
 console.log(inserted.rows[0]?.id, inserted.rowCount) // "1" 1
+
+await pool.end()
+await server.close()
 ```
 
-Differences from node-postgres to account for: timestamps, dates, `numeric` and `json`/`jsonb` come
-back as PostgreSQL text (node-postgres parses timestamps to `Date` and JSON to objects);
-`prepare`/`query` accept one statement at a time (use `exec` for scripts); errors are
-`PostgresError` with `code` set to the SQLSTATE, like `pg`'s `DatabaseError.code`.
+Errors are `pg`'s own `DatabaseError` with `code` set to the SQLSTATE. Where no listener can run
+(the browser), put the embedded `Database` behind whatever query interface your code uses. The
+differences from node-postgres to account for there: `int8` is a `bigint` unless you pass
+`{ int8: "string" }`; timestamps, dates, `numeric` and `json`/`jsonb` come back as PostgreSQL text
+(node-postgres parses timestamps to `Date` and JSON to objects); `prepare`/`query` accept one
+statement at a time (use `exec` for scripts); errors are `PostgresError` with `code` set to the
+SQLSTATE, like `pg`'s `DatabaseError.code`.
 
 ### Wire-protocol server (separate processes)
 
 When another process must connect over TCP — `pg`, `postgres.js`, a JDBC client, `psql`, a service
-in a local multi-service stack — start the frontend/backend v3 server instead of a shim. It needs
+in a local multi-service stack — start the frontend/backend v3 server. It needs
 `node:net`, so it is a separate Node/Bun entry (`/wire`) and the main package stays browser-safe.
 
 ```ts
@@ -185,6 +204,7 @@ Or from the command line (installs a `mockingbird-postgres` bin):
 ```bash
 mockingbird-postgres serve --port 55432            # trust auth
 mockingbird-postgres serve postgres://postgres:secret@0.0.0.0:55432/app --log
+mockingbird-postgres serve --port 55432 --durable ./.postgres   # commits survive a restart
 ```
 
 `serve({ database })` shares an existing `Database`, and `serve({ database: snapshot })` boots every
@@ -202,7 +222,10 @@ return a conflict until closed.
 
 `server.snapshot()` freezes the live state; `server.fault({ dropConnection | delayStatementMs |
 failCommit })` arms the next statement or connection for a drop, a delay, or a `40001` commit
-failure.
+failure. `server.fault({ failConcurrentIndexBuild: "57014" })` (and `database.fault({
+concurrentIndexBuild: "57014" })` on the sync API) interrupts the next `CREATE INDEX CONCURRENTLY`
+or `REINDEX ... CONCURRENTLY` with that SQLSTATE and, as PostgreSQL does, leaves the index it was
+building in the catalog with `pg_index.indisvalid = false` until it is dropped or reindexed.
 
 One committed engine is shared by every connection. Explicit transactions execute in per-session
 copy-on-write workspaces that rebase each statement on the latest committed state, providing
@@ -222,20 +245,155 @@ the wire. `COPY … FROM STDIN` and `COPY … TO STDOUT` use protocol-v3 `CopyIn
 incrementally across arbitrary frame and quoted-record boundaries; failed imports are atomic and
 leave the connection in PostgreSQL's transaction state.
 
+**Session settings and startup parameters.** Every connection has its own settings: a `SET`,
+`RESET` or `set_config()` on one never reaches another, a `SET` inside a transaction block is
+undone by `ROLLBACK`, and a new connection starts from the database's settings, not a neighbour's.
+The startup packet's run-time parameters are applied before the first query, the way a PostgreSQL
+backend applies them: libpq's `options` string first, then every parameter sent by name (which
+therefore wins).
+
+```ts
+import pg from "pg"
+import { serve } from "@crvouga/mockingbird-service-postgres/wire"
+
+const server = await serve({ port: 0 })
+const client = new pg.Client({
+  connectionString: `${server.connectionString}?options=-c%20search_path%3Dapp`,
+})
+await client.connect()
+await client.query("CREATE SCHEMA app")
+await client.query("CREATE TABLE app.notes (id integer)")
+await client.query("SET search_path TO app")
+await client.end()
+await server.close()
+```
+
+Other clients set the same startup option with their own configuration (for example, JDBC's
+`currentSchema` or postgres.js / Bun SQL's `connection.search_path`).
+
+`options` is split like `pg_split_opts` (whitespace separates arguments, `\ ` is a literal space,
+`\\` a backslash) and accepts `-c name=value`, `-cname=value` and `--name=value` (dashes in a
+`--name` are underscores). A schema named in `search_path` need not exist yet: it starts resolving
+once it is created. Startup values are the session's defaults, so `RESET search_path`,
+`SET search_path TO DEFAULT` and `RESET ALL` return to them. Invalid input ends the connection
+with a `FATAL` ErrorResponse, as PostgreSQL 18.3 does: `42601` for a malformed `options` string
+(`-c name` without a value, a stray argument, an unknown switch), `42704` for an unknown
+parameter, `22023` for a bad value (`search_path` list syntax, booleans, integers and timeouts with
+units, enum parameters, `DateStyle`, `TimeZone`) and `55P02` for a read-only parameter such as
+`server_version`. The session-aware functions (`pg_advisory_lock`, `pg_backend_pid`, `pg_notify`,
+…) live in `pg_catalog`, so they keep working when `search_path` leaves out `public`.
+
+Boundaries: a parameter is known when the engine has a setting for it (the same rule as `SET`), so
+a real PostgreSQL parameter the engine does not model, such as `work_mem` or `jit`, is `42704`
+at startup too; names with a dot are custom parameters and always accepted. The other `postgres`
+switches (`-e`, `-S`, `-d`, …) fail loud with `0A000`. `client_encoding`, `lc_*` and
+`application_name` values are stored as sent, an unquoted upper-case schema in a startup
+`search_path` is shown folded to lower case, and `ParameterStatus` is sent at startup only, not
+again when a reported setting changes. `SET LOCAL` and `DISCARD ALL` keep their engine behaviour
+(see [COMPATIBILITY.md](COMPATIBILITY.md)).
+
 **Not modelled by the server:** transaction ID and snapshot-inspection functions, predicate and
 table locks, isolation levels beyond `READ COMMITTED`, and the binary parameter formats beyond the
 common scalar types (a client that sends another binary type gets `0A000`, and can switch that
 parameter to text). Binary `COPY` is not supported.
 
+#### Durable mode (opt-in)
+
+The server keeps everything in memory, and that stays the default: no option, no filesystem, the
+same bytes on every run. For local development, where the server replaces a native database and
+a killed process must not lose acknowledged work, `durable` persists the cluster before each
+commit is acknowledged:
+
+```ts
+import { serve } from "@crvouga/mockingbird-service-postgres/wire"
+
+const server = await serve({ port: 55432, durable: "./.postgres" }) // a directory
+// … the process is SIGKILLed …
+const again = await serve({ port: 55432, durable: "./.postgres" }) // resumes from the last acknowledged commit
+await again.close()
+```
+
+| | Guarantee |
+| --- | --- |
+| Acknowledged commit | An autocommit write, a `COMMIT`, the implicit commit of a multi-statement query, a `COPY … FROM STDIN` and `CREATE` / `DROP` / `ALTER DATABASE` are in storage before `CommandComplete` (for an implicit commit, before `ReadyForQuery`) is sent. They survive `SIGKILL`. |
+| Uncommitted work | A transaction that was open or rolled back is never restored: it only ever existed in its session's workspace. |
+| Storage failure | The commit is not acknowledged. The statement fails with `58030` (`io_error`), or `53100` (`disk_full`) when the storage reports `ENOSPC` / `EDQUOT`; the change is taken back out of memory, the transaction is gone (as after any failed `COMMIT`: the session is idle, not in an aborted block), its `NOTIFY`s are dropped, and the next statement runs normally. |
+| Atomic | The file-backed store writes each file under a temporary name, fsyncs it, renames it into place and fsyncs the directory; the manifest swap is the commit point. A crash leaves the previous state or the new one. Leftovers of an interrupted write are removed on the next start, and a snapshot whose length or SHA-256 does not match its manifest entry is refused, never decoded. |
+| Whole cluster | Every database with its catalog, data, sequences and deterministic random position. A restart restores all of them; separate directories (or storages) are separate clusters. |
+| Visibility | A commit being persisted holds the statement turn, so no other connection reads it before it is durable. |
+
+It is **snapshot persistence, not a write-ahead log, and not PostgreSQL's on-disk format**: the
+payload is the [PGMM snapshot](#snapshots) of each database (`<sha256>.pgmm`)
+plus a `MANIFEST.json` naming the current one per database. Nothing reads a PostgreSQL data
+directory, and `pg_dump`, physical replication and point-in-time recovery do not apply.
+
+The trade-off is cost per commit: every commit re-encodes the database it changed (other
+databases are not rewritten) and then waits for two file fsyncs and two directory fsyncs. That is
+proportional to the size of that database, not to the size of the change: about 10 ms for a
+200 KB snapshot and several hundred milliseconds for 2 MB (100 000 short rows) on a laptop. It
+suits development datasets; batch bulk writes into one transaction (one `COMMIT`, one encode), and
+keep the in-memory default for tests. Reads, `SET` and statements inside an open transaction
+never touch storage; a statement that could have written (a `SELECT` calling a user-defined
+function, a view or `nextval`) is encoded and compared, and written only if the snapshot differs.
+`fsync` is as strong as the platform makes it: surviving a killed process does not depend on it,
+surviving power loss does.
+
+Boundaries of durable mode:
+
+- One server process per directory; nothing locks it.
+- `database` seeds an empty storage (the seed is persisted at startup). Once storage holds a
+  cluster, that cluster is served and `database` only supplies the runtime: clock, seed, entropy
+  mode and `int8` mode. Read state through `server.database`, not the object you passed.
+- What a PGMM snapshot does not hold is not restored: functions added with `registerFunction`,
+  session state (settings, prepared statements, advisory locks, `LISTEN`s), and faults.
+- Writes made from the host process (`server.database.exec(...)`, `restoreAll()`) are not commits
+  of a connection: call `await server.persist()` to store them. A host-side read during a commit
+  can see it before it is durable.
+- `nextval()` and `setval()` are persisted at once. The random position consumed by a statement
+  that wrote nothing (`SELECT gen_random_uuid()`) is stored with the next commit of that database.
+- `mockingbird-postgres serve --config` (the fleet) has no durable option.
+
+The storage is a port, so a test can model failure and crashes without a filesystem:
+
+```ts
+import { type ClusterImage, type DurableStorage, fileStorage, serve } from "@crvouga/mockingbird-service-postgres/wire"
+
+let image: ClusterImage | null = null
+let failing = false
+const paused = Promise.resolve()
+const storage: DurableStorage = {
+  read: async () => image,
+  write: async (next) => {
+    if (failing) throw Object.assign(new Error("disk full"), { code: "ENOSPC" }) // → 53100, not acknowledged
+    image = new Map(next)
+  },
+}
+const server = await serve({
+  durable: {
+    storage, // or a directory, or fileStorage(directory)
+    beforeAcknowledge: (commit) => paused, // persisted, not acknowledged yet: crash here
+    afterAcknowledge: (commit) => paused, // the acknowledgement is on the socket: crash here
+  },
+})
+const restarted = await serve({ durable: storage }) // "restart" from what storage holds
+```
+
+`write` receives the whole cluster as PGMM bytes per database and must be atomic: resolve once the
+image would survive a kill, or reject and leave the previous image in place. The server never
+calls it concurrently and passes the same `Uint8Array` for a database that did not change.
+`beforeAcknowledge` / `afterAcknowledge` receive `{ pid, database, sql }` and are awaited, which
+is how a crash-regression test stops the server on either side of the acknowledgement.
+
 ### Method semantics
 
 | Method | Behaviour |
 | --- | --- |
 | `exec(sql)` | Runs all semicolon-separated statements; **discards** row results (`void`). Does **not** accept bind parameters. Read `db.changes` afterwards if needed (reflects the **most recent** completed DML statement). Dump-only `DO` blocks and `ALTER TABLE ... SET (` storage parameters are no-ops. |
-| `registerFunction(spec)` | Install a JavaScript scalar. Not stored in PGMM snapshots; `open()` of a live snapshot copies the implementation by reference. |
+| `registerFunction(spec)` | Install a JavaScript scalar. Not stored in PGMM snapshots; `open()` of a live snapshot copies the implementation by reference. A `pg_catalog.`-qualified name is found ahead of `search_path`, as PostgreSQL's own functions are. |
 | `query(sql, params?, { at? }?)` | **Single statement only** (trailing `;` is fine). Returns all rows. `at` is a `Snapshot` or a timeline checkpoint id and queries that checkpoint without changing live state. Multi-statement scripts throw `misuse`. |
 | `prepare(sql)` | **Single statement only**. Parses immediately; the AST is reused. Pass binds as rest args to `run` / `all` / `get` / `result` / `textResult` on each call. |
 | `transaction(fn)` | If idle: `BEGIN`, `fn()`, `COMMIT`, or `ROLLBACK` + rethrow. If already in a transaction: nested savepoint. A nested SQL `BEGIN` inside is a no-op warning like PostgreSQL. `close()` inside `fn` throws `misuse`. |
+| `fault({ concurrentIndexBuild })` | Test control: arm the next `CREATE INDEX CONCURRENTLY` / `REINDEX ... CONCURRENTLY` to fail with the given SQLSTATE (`"57014"` canceled, `"40P01"` deadlock) and leave its index invalid (`pg_index.indisvalid = false`), as an interrupted build does on PostgreSQL. One shot; not part of snapshots. |
 | `copyFrom(sql, data)` | Executes `COPY table [(cols)] FROM STDIN` with `data` as the copy-in payload (text or csv per the COPY options). Returns rows copied. `COPY ... TO STDOUT` output is returned as result rows by `query`. |
 | `snapshot()` | Freeze a reusable `Snapshot` template (no encode) and commit it on the followed timeline branch. Illegal inside a transaction (`25P01`). |
 | `checkpoint()` / `branch(at?)` | `checkpoint` records the same timeline point as `snapshot`. `branch` opens an isolated database from a snapshot (or the current state). |
@@ -335,12 +493,16 @@ Intentional differences: custom `PGMM` snapshots; seeded `random()` / fixed `now
 - `EXPLAIN`: stub plan shapes, not real planner output
 - The in-process API does **not** poison a transaction after a failed statement (no `25P02`); the wire-protocol server does, per connection
 - Triggers fire in **creation order** (PostgreSQL: name order); `UPDATE OF` column lists are ignored; `INSTEAD OF` is unsupported
-- `COMMENT ON` parses but comments are not stored
+- `COMMENT ON INDEX` is stored (`pg_description`, `obj_description`); comments on every other kind of object parse but are not stored
 - `round(float8)` rounds ties away from zero (PostgreSQL: half-to-even); numeric `round()` has full parity
 - `'1e400'::float8` saturates to `Infinity` instead of raising `22003`
 - In the engine `MERGE`, `CALL`/procedures, cursors (`DECLARE`/`FETCH`), `LISTEN`/`NOTIFY`, and full PL/pgSQL (packages, NOTICE, cursors) fail loud (`0A000`); the wire-protocol server implements `LISTEN`/`NOTIFY` itself
-- `VACUUM` / `ANALYZE` / `CLUSTER` / `REINDEX` / `CHECKPOINT` / `GRANT` / `REVOKE` / `LOCK` are parsed no-ops
+- `VACUUM` / `CLUSTER` / `CHECKPOINT` / `GRANT` / `REVOKE` / `LOCK` are parsed no-ops. `ANALYZE` validates its targets and records `analyze_count` / `last_analyze`, and `REINDEX` validates its targets and repairs an invalid index; neither has planner statistics or a physical index behind it
+- `pg_stat_user_tables` / `pg_stat_user_indexes` have PostgreSQL 18's columns, but only `n_live_tup` (the exact row count, immediately), the `ANALYZE` bookkeeping and `idx_scan` for unique-key lookups are real; the other activity counters read zero
+- Index access methods other than btree (`USING hash` / `gin` / …) are recorded and shown by `pg_get_indexdef` and `pg_am`, not implemented differently; `pg_index` has no `indkey` (use `pg_get_indexdef(oid, n, pretty)`)
 - Collation is `C` semantics (byte order); locale/ICU-dependent ordering is out of scope
+- Column `STORAGE` modes (`pg_attribute.attstorage`) and `UNLOGGED` persistence (`pg_class.relpersistence`) follow PostgreSQL's SQL and catalog contract but are metadata only: there is no TOAST and no WAL, so an unlogged table is stored, snapshotted and kept like any other
+- `pg_available_extensions` / `pg_extension` list only what `CREATE EXTENSION` can install here (`pgcrypto`, `pg_trgm`) plus the built-in `plpgsql`; any other extension is absent from the views and `CREATE EXTENSION` fails with `0A000`
 
 **Also supported (oracle parity):** schemas + `search_path`, `pg_catalog` / `information_schema`
 introspection, sequences (`serial`, identity, `nextval`/`currval`/`setval`), enums, domains,

package/compat/coverage.json

@@ -1,5 +1,5 @@
 {
-  "generatedAt": "2026-08-21T18:49:46.346Z",
+  "generatedAt": "2026-10-11T00:19:02.759Z",
   "referenceServerVersion": "18.3",
   "counts": {
     "total": 183,
@@ -251,9 +251,9 @@
     "sql-analyze": {
       "status": "PARTIALLY_VERIFIED",
       "evidence": [
-        "tests/contract/misc/"
+        "tests/contract/catalogs/"
       ],
-      "notes": "parsed no-op; no planner statistics"
+      "notes": "targets, columns and options are validated and pg_stat_user_tables records analyze_count / last_analyze; no planner statistics are gathered (divergence pg-stat-counters-immediate)"
     },
     "sql-begin": {
       "status": "VERIFIED",
@@ -289,9 +289,10 @@
     "sql-comment": {
       "status": "PARTIALLY_VERIFIED",
       "evidence": [
-        "tests/contract/catalog/"
+        "tests/contract/catalog/",
+        "tests/contract/catalogs/"
       ],
-      "notes": "parsed and accepted; comments are not stored (divergence comment-on-not-stored)"
+      "notes": "COMMENT ON INDEX is stored (pg_description, obj_description); comments on other objects are accepted and not stored (divergence comment-on-not-stored)"
     },
     "sql-commit": {
       "status": "VERIFIED",
@@ -924,9 +925,9 @@
     "sql-reindex": {
       "status": "PARTIALLY_VERIFIED",
       "evidence": [
-        "tests/contract/misc/"
+        "tests/contract/catalogs/"
       ],
-      "notes": "parsed no-op"
+      "notes": "INDEX / TABLE / SCHEMA / DATABASE / SYSTEM with CONCURRENTLY: targets are validated, a unique index is re-checked, an invalid index is repaired and a failed concurrent rebuild leaves its _ccnew index; there is no physical index to rebuild and TABLESPACE is ignored"
     },
     "sql-release-savepoint": {
       "status": "VERIFIED",

package/compat/divergences.json

@@ -145,8 +145,8 @@
     {
       "id": "comment-on-not-stored",
       "scope": "sql",
-      "predicate": "COMMENT ON parses and succeeds but the comment is not stored; obj_description() returns NULL",
-      "specifiedBehavior": "COMMENT ON is accepted for compatibility; descriptions are not persisted.",
+      "predicate": "COMMENT ON for any object other than an index parses and succeeds but the comment is not stored; obj_description() / col_description() return NULL for it and pg_description has no row",
+      "specifiedBehavior": "COMMENT ON INDEX is persisted (pg_description, obj_description) and differential-tested. For tables, columns and every other object kind COMMENT ON is accepted for compatibility and the description is not persisted; a missing target of those kinds is not an error either.",
       "pinnedBy": ["DDL-comment-01"]
     },
     {
@@ -190,6 +190,41 @@
       "predicate": "pg_get_viewdef() is not implemented and raises 42883",
       "specifiedBehavior": "View definitions are visible via information_schema.views.view_definition (stored SQL text).",
       "pinnedBy": ["CAT-viewdef-01"]
+    },
+    {
+      "id": "storage-persistence-catalog-only",
+      "scope": "sql",
+      "predicate": "Column storage modes (STORAGE / SET STORAGE, pg_attribute.attstorage) and relation persistence (UNLOGGED, SET LOGGED / UNLOGGED, pg_class.relpersistence) are catalog metadata only: there is no TOAST and no write-ahead log",
+      "specifiedBehavior": "The SQL and catalog contract matches PostgreSQL, including its errors for invalid modes, targets and conversions, and is differential-tested. Physically nothing changes: values are never compressed or moved out of line, an unlogged table is stored like a logged one, is not truncated by a crash and is part of every snapshot. PostgreSQL also keeps a storage mode for materialized-view columns; here ALTER COLUMN ... SET STORAGE on a materialized view fails loud with 0A000.",
+      "pinnedBy": ["tests/contract/alter-table/set-storage.test.ts", "tests/contract/alter-table/set-logged.test.ts"]
+    },
+    {
+      "id": "extension-catalog-subset",
+      "scope": "catalog",
+      "predicate": "pg_available_extensions, pg_available_extension_versions and pg_extension list only the extensions the engine can install (pgcrypto, pg_trgm) plus the built-in plpgsql; DROP EXTENSION plpgsql is refused with 0A000",
+      "specifiedBehavior": "A stock PostgreSQL server lists every contrib module it ships; here an extension that is not implemented is absent from the views (zero rows) and CREATE EXTENSION fails with 0A000, as it does on a server without that control file. The PGlite oracle is built with exactly the same three extensions, so the views are compared in full. plpgsql cannot be dropped because the language is part of the engine; PostgreSQL allows dropping and recreating it.",
+      "pinnedBy": ["tests/contract/extensions/catalogs.test.ts"]
+    },
+    {
+      "id": "concurrent-index-build-fault",
+      "scope": "engine",
+      "predicate": "Database.fault({ concurrentIndexBuild: sqlstate }) and, on the wire server, server.fault({ failConcurrentIndexBuild: sqlstate }) make the next CREATE INDEX CONCURRENTLY or REINDEX ... CONCURRENTLY fail with that SQLSTATE and leave the index it was building in the catalog with indisvalid = false, indisready = false, indislive = true",
+      "specifiedBehavior": "PostgreSQL leaves such an invalid index when a concurrent build is canceled, deadlocks or otherwise fails partway (sql-createindex, 'Building Indexes Concurrently'); an interruption cannot be provoked deterministically in the oracle, so this one-shot test control stands in for it. The failure PostgreSQL can be made to produce, duplicate keys in a concurrent unique build, is differential-tested, as are DROP INDEX and REINDEX as the repair. The preset models an interruption in the build phase, the state PostgreSQL shows for the duplicate-key failure (not ready, so not maintained and not enforcing). A failure in the later validation scan, where PostgreSQL leaves indisready = true and a unique index keeps enforcing, is not modeled. The fault is not part of snapshots and is not undone by a rollback.",
+      "pinnedBy": ["CAT-index-valid-07", "tests/contract/catalogs/index-validity.test.ts", "tests/wire/index-catalog.test.ts"]
+    },
+    {
+      "id": "pg-stat-counters-immediate",
+      "scope": "catalog",
+      "predicate": "pg_stat_user_tables.n_live_tup is the exact current row count, current as soon as a statement finishes; seq_scan, seq_tup_read, idx_tup_fetch, n_tup_ins / n_tup_upd / n_tup_del, n_tup_hot_upd, n_dead_tup, n_mod_since_analyze and the vacuum columns are not tracked and read zero or NULL; idx_scan (also in pg_stat_user_indexes) counts only the unique-key equality lookups the engine performs for SELECT; VACUUM, including VACUUM ANALYZE, is a no-op and does not count",
+      "specifiedBehavior": "PostgreSQL reports these counters asynchronously (after pg_stat_force_next_flush() or a delay) and n_live_tup is an estimate that ANALYZE resets. The differential tests read after pg_stat_force_next_flush() and ANALYZE, where PostgreSQL's value is the row count too, and compare relid, schemaname, relname, n_live_tup, analyze_count, last_analyze and the column list and types of both views. There are no dead tuples and no planner, so the activity counters have nothing to count; treat them as absent, not as zero activity.",
+      "pinnedBy": ["CAT-table-stat-04", "tests/contract/catalogs/table-statistics.test.ts"]
+    },
+    {
+      "id": "pg-index-catalog-subset",
+      "scope": "catalog",
+      "predicate": "pg_index exposes indexrelid, indrelid, indnatts, indnkeyatts and the boolean flags; indexprs and indpred are the deparsed text that pg_get_expr() returns rather than pg_node_tree, and indkey, indcollation, indclass and indoption are absent. Index access methods other than btree are recorded and rendered (USING hash / gin / gist / spgist / brin) but every index is maintained the same way",
+      "specifiedBehavior": "pg_get_indexdef(), pg_indexes.indexdef and pg_get_expr(indpred | indexprs, indrelid) are differential-tested against PostgreSQL across methods, ordering, NULLS placement, INCLUDE, operator classes, collations, storage parameters, quoted identifiers and an expression / predicate matrix. Read index columns through pg_get_indexdef(oid, n, pretty) instead of indkey. Expressions outside that matrix (subqueries, row constructors, SIMILAR TO, array slices, window or aggregate calls) are rendered best-effort.",
+      "pinnedBy": ["tests/contract/catalogs/index-definitions.test.ts"]
     }
   ]
 }

package/compat/requirements.json

@@ -1,5 +1,5 @@
 {
-  "generatedAt": "2026-08-21T18:49:46.345Z",
+  "generatedAt": "2026-10-11T00:19:02.756Z",
   "sourceUrl": "https://www.postgresql.org/docs/18/sql-commands.html",
   "count": 183,
   "requirements": [