@crvouga/postgres-mem 0.1.0

package/compat/scenario-types.ts

@@ -0,0 +1,98 @@
+/** Construct-level drop-in parity catalog types (PostgreSQL dialect). */
+
+export const SECTION_CODES = [
+  "TOK",
+  "PAR",
+  "TYP",
+  "EXP",
+  "FUN",
+  "DAT",
+  "JSN",
+  "ARR",
+  "AGG",
+  "WIN",
+  "SEL",
+  "JOI",
+  "CTE",
+  "DDL",
+  "DML",
+  "CON",
+  "SEQ",
+  "TRG",
+  "TXN",
+  "GUC",
+  "SCH",
+  "CAT",
+  "TSR",
+  "CPY",
+  "PRE",
+  "API",
+  "SNP",
+  "DET",
+  "ERR",
+  "UNI",
+  "LIM",
+  "FZZ",
+  "ECO",
+] as const;
+
+export type SectionCode = (typeof SECTION_CODES)[number];
+
+export type ScenarioKind = "differential" | "documented_divergence" | "fuzz" | "property" | "ecosystem";
+
+export type ProofStrength = "proves" | "smoke";
+
+export interface Scenario {
+  id: string;
+  title: string;
+  kind: ScenarioKind;
+  evidence: string[];
+  notes?: string;
+  divergenceId?: string;
+  strength?: ProofStrength;
+}
+
+export interface CatalogSection {
+  code: SectionCode;
+  title: string;
+  promoted: boolean;
+  scenarios: Scenario[];
+}
+
+/** IDs look like `TOK-01`, `WIN-frame-04`, `DET-seed-01`. */
+export const SCENARIO_ID_RE = /^([A-Z]{3})(?:-[a-z0-9]+)*-\d{2,}$/;
+
+export function catalogTestFile(code: SectionCode): string {
+  return `tests/contract/catalog/${code.toLowerCase()}.test.ts`;
+}
+
+export type ScenarioRow = [
+  suffix: string,
+  title: string,
+  kind?: ScenarioKind,
+  notes?: string,
+  extraEvidence?: string[],
+  divergenceId?: string,
+];
+
+/** Build a catalog section from compact rows; IDs become `CODE-suffix`. */
+export function section(code: SectionCode, title: string, promoted: boolean, items: ScenarioRow[]): CatalogSection {
+  return {
+    code,
+    title,
+    promoted,
+    scenarios: items.map(([suffix, rowTitle, kind = "differential", notes, extra, divergenceId]) => {
+      const id = `${code}-${suffix}`;
+      if (!SCENARIO_ID_RE.test(id)) throw new Error(`bad scenario id: ${id}`);
+      const scenario: Scenario = {
+        id,
+        title: rowTitle,
+        kind,
+        evidence: [catalogTestFile(code), ...(extra ?? [])],
+      };
+      if (notes !== undefined) scenario.notes = notes;
+      if (divergenceId !== undefined) scenario.divergenceId = divergenceId;
+      return scenario;
+    }),
+  };
+}

package/compat/scenarios.ts

@@ -0,0 +1,98 @@
+/**
+ * Construct-level drop-in parity catalog. Every scenario ID here must execute
+ * in `tests/contract/catalog/<code>.test.ts` — the gate enforces the mapping.
+ */
+import { type CatalogSection, SCENARIO_ID_RE, type Scenario } from "./scenario-types.ts";
+import { AGG_SECTION } from "./sections/agg.ts";
+import { API_SECTION } from "./sections/api.ts";
+import { ARR_SECTION } from "./sections/arr.ts";
+import { CAT_SECTION } from "./sections/cat.ts";
+import { CON_SECTION } from "./sections/con.ts";
+import { CPY_SECTION } from "./sections/cpy.ts";
+import { CTE_SECTION } from "./sections/cte.ts";
+import { DAT_SECTION } from "./sections/dat.ts";
+import { DDL_SECTION } from "./sections/ddl.ts";
+import { DET_SECTION } from "./sections/det.ts";
+import { DML_SECTION } from "./sections/dml.ts";
+import { ECO_SECTION } from "./sections/eco.ts";
+import { ERR_SECTION } from "./sections/err.ts";
+import { EXP_SECTION } from "./sections/exp.ts";
+import { FUN_SECTION } from "./sections/fun.ts";
+import { FZZ_SECTION } from "./sections/fzz.ts";
+import { GUC_SECTION } from "./sections/guc.ts";
+import { JOI_SECTION } from "./sections/joi.ts";
+import { JSN_SECTION } from "./sections/jsn.ts";
+import { LIM_SECTION } from "./sections/lim.ts";
+import { PAR_SECTION } from "./sections/par.ts";
+import { PRE_SECTION } from "./sections/pre.ts";
+import { SCH_SECTION } from "./sections/sch.ts";
+import { SEL_SECTION } from "./sections/sel.ts";
+import { SEQ_SECTION } from "./sections/seq.ts";
+import { SNP_SECTION } from "./sections/snp.ts";
+import { TOK_SECTION } from "./sections/tok.ts";
+import { TRG_SECTION } from "./sections/trg.ts";
+import { TSR_SECTION } from "./sections/tsr.ts";
+import { TXN_SECTION } from "./sections/txn.ts";
+import { TYP_SECTION } from "./sections/typ.ts";
+import { UNI_SECTION } from "./sections/uni.ts";
+import { WIN_SECTION } from "./sections/win.ts";
+
+export const SCENARIO_CATALOG: CatalogSection[] = [
+  TOK_SECTION,
+  PAR_SECTION,
+  TYP_SECTION,
+  EXP_SECTION,
+  FUN_SECTION,
+  DAT_SECTION,
+  JSN_SECTION,
+  ARR_SECTION,
+  AGG_SECTION,
+  WIN_SECTION,
+  SEL_SECTION,
+  JOI_SECTION,
+  CTE_SECTION,
+  DDL_SECTION,
+  DML_SECTION,
+  CON_SECTION,
+  SEQ_SECTION,
+  TRG_SECTION,
+  TXN_SECTION,
+  GUC_SECTION,
+  SCH_SECTION,
+  CAT_SECTION,
+  TSR_SECTION,
+  CPY_SECTION,
+  PRE_SECTION,
+  API_SECTION,
+  SNP_SECTION,
+  DET_SECTION,
+  ERR_SECTION,
+  UNI_SECTION,
+  LIM_SECTION,
+  FZZ_SECTION,
+  ECO_SECTION,
+];
+
+export function allScenarios(): Scenario[] {
+  return SCENARIO_CATALOG.flatMap((section) => section.scenarios);
+}
+
+export function scenarioById(): Map<string, Scenario> {
+  return new Map(allScenarios().map((scenario) => [scenario.id, scenario]));
+}
+
+export function knownScenarioIds(): Set<string> {
+  return new Set(allScenarios().map((scenario) => scenario.id));
+}
+
+const seen = new Set<string>();
+for (const section of SCENARIO_CATALOG) {
+  for (const scenario of section.scenarios) {
+    if (!SCENARIO_ID_RE.test(scenario.id)) throw new Error(`bad scenario id: ${scenario.id}`);
+    if (!scenario.id.startsWith(`${section.code}-`)) {
+      throw new Error(`scenario ${scenario.id} does not belong to section ${section.code}`);
+    }
+    if (seen.has(scenario.id)) throw new Error(`duplicate scenario id: ${scenario.id}`);
+    seen.add(scenario.id);
+  }
+}

package/compat/sections/agg.ts

@@ -0,0 +1,45 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+export const AGG_SECTION: CatalogSection = section("AGG", "Aggregate functions", true, [
+  ["cnt-01", "count star column constant and NULL"],
+  ["cnt-02", "count DISTINCT incl row values"],
+  ["sum-01", "sum over ints numerics floats"],
+  ["sum-02", "sum and avg result types"],
+  ["sum-03", "bigint sum avoids overflow via numeric"],
+  ["avg-01", "avg over ints and filters nulls"],
+  ["minmax-01", "min max over ints and text"],
+  ["minmax-02", "min max over dates and intervals"],
+  ["empty-01", "aggregates over an empty table"],
+  ["empty-02", "aggregates over all-NULL input"],
+  ["str-01", "string_agg with ORDER BY and delimiters"],
+  ["str-02", "string_agg NULL handling and NULL separator"],
+  ["str-03", "string_agg per group"],
+  ["arr-01", "array_agg ordered incl NULLs"],
+  ["arr-02", "array_agg empty input and per group"],
+  ["jsn-01", "json_agg and jsonb_agg"],
+  ["jsn-02", "json_object_agg and jsonb_object_agg"],
+  ["bool-01", "bool_and bool_or every"],
+  ["bool-02", "bool aggregates over empty input"],
+  ["bit-01", "bit_and bit_or bit_xor"],
+  ["dist-01", "DISTINCT inside sum and avg"],
+  ["dist-02", "DISTINCT inside string_agg and array_agg"],
+  ["fil-01", "FILTER WHERE on aggregates"],
+  ["fil-02", "FILTER with GROUP BY"],
+  ["fil-03", "FILTER excluding all rows and with DISTINCT"],
+  ["grp-01", "GROUP BY with HAVING"],
+  ["grp-02", "GROUP BY expression"],
+  ["grp-03", "aggregates over joins"],
+  ["std-01", "stddev family"],
+  ["std-02", "variance family"],
+  ["std-03", "stddev variance degenerate inputs"],
+  ["pct-01", "percentile_cont median and interpolation"],
+  ["pct-02", "percentile_disc and bounds"],
+  ["pct-03", "percentile over empty input"],
+  ["mode-01", "mode and tie-breaking"],
+  ["corr-01", "corr and covariance"],
+  ["corr-02", "linear regression family"],
+  ["expr-01", "aggregates inside expressions and CASE"],
+  ["ord-01", "ORDER BY inside plain aggregates"],
+  ["sub-01", "aggregate in a correlated subquery"],
+  ["err-01", "undefined column inside aggregate errors"],
+]);

package/compat/sections/api.ts

@@ -0,0 +1,28 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+const D = "documented_divergence" as const;
+const DIV = "sync-api-surface";
+
+export const API_SECTION: CatalogSection = section("API", "JavaScript surface contracts", true, [
+  ["exec-01", "exec runs multiple statements", D, "JS API surface, no oracle analog", undefined, DIV],
+  ["exec-02", "exec rejects bind parameters", D, "JS API surface, no oracle analog", undefined, DIV],
+  ["query-01", "query and prepare are single-statement", D, "JS API surface, no oracle analog", undefined, DIV],
+  ["query-02", "query positional $n binds"],
+  ["prep-01", "prepare-time syntax errors", D, "JS API surface, no oracle analog", undefined, DIV],
+  ["prep-02", "prepared statement reuse"],
+  ["prep-03", "re-executed statement sees ALTER TABLE", undefined, undefined, ["tests/contract/api/"]],
+  ["run-01", "run/all/get/result shapes", D, "JS API surface, no oracle analog", undefined, DIV],
+  ["run-02", "get returns undefined for zero rows", D, "JS API surface, no oracle analog", undefined, DIV],
+  ["run-03", "result keeps column metadata for zero rows", D, "JS API surface, no oracle analog", undefined, DIV],
+  ["run-04", "all on INSERT RETURNING"],
+  ["bind-01", "accepted bind types"],
+  ["bind-02", "rejected bind types throw misuse", D, "JS API surface, no oracle analog", undefined, DIV],
+  ["bind-03", "bigint binds enforce int8 range", D, "JS API surface, no oracle analog", undefined, DIV],
+  ["ret-01", "int8 results surface as JS bigint", D, "JS API surface, no oracle analog", undefined, DIV],
+  ["ret-02", "numeric/date/jsonb surface as canonical text", D, "JS API surface, no oracle analog", undefined, DIV],
+  ["close-01", "close is idempotent; use after close is misuse", D, "JS API surface, no oracle analog", undefined, DIV],
+  ["txn-01", "transaction(fn) commits and rolls back", D, "JS API surface, no oracle analog", undefined, DIV],
+  ["txn-02", "nested transaction(fn) uses savepoints", D, "JS API surface, no oracle analog", undefined, DIV],
+  ["sync-01", "methods return values, not Promises", D, "JS API surface, no oracle analog", undefined, DIV],
+  ["copy-01", "copyFrom API loads COPY FROM STDIN data", D, "API-level COPY hook", ["tests/contract/copy/"], DIV],
+]);

package/compat/sections/arr.ts

@@ -0,0 +1,45 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+export const ARR_SECTION: CatalogSection = section("ARR", "Arrays", true, [
+  ["lit-01", "ARRAY constructor int and text"],
+  ["lit-02", "text literal input incl quoted elements"],
+  ["lit-03", "empty arrays typed"],
+  ["lit-04", "NULL elements rendering"],
+  ["lit-05", "expression elements and coercion"],
+  ["lit-06", "multi-dim constructor and literal"],
+  ["lit-07", "ARRAY from a subquery"],
+  ["sub-01", "one-based subscripting"],
+  ["sub-02", "out-of-range zero negative subscripts are NULL"],
+  ["sub-03", "column and expression subscripts"],
+  ["sub-04", "multi-dim subscripts and partial access"],
+  ["slice-01", "basic slices"],
+  ["slice-02", "open-ended slices"],
+  ["slice-03", "clamped and empty slices"],
+  ["slice-04", "multi-dim slices"],
+  ["meta-01", "array_length and cardinality"],
+  ["meta-02", "array_dims ndims upper lower"],
+  ["srf-01", "unnest in FROM"],
+  ["srf-02", "unnest in the SELECT list"],
+  ["srf-03", "unnest WITH ORDINALITY"],
+  ["srf-04", "multi-argument unnest"],
+  ["srf-05", "generate_subscripts forward and reverse"],
+  ["agg-01", "array_agg with ORDER BY and DISTINCT"],
+  ["agg-02", "unnest array_agg round trip per group"],
+  ["op-01", "|| concatenation element and array forms"],
+  ["op-02", "@> and <@ containment"],
+  ["op-03", "&& overlap"],
+  ["op-04", "equality and lexicographic ordering"],
+  ["op-05", "comparisons with NULL elements"],
+  ["fn-01", "array_append prepend cat"],
+  ["fn-02", "array_remove and array_replace"],
+  ["fn-03", "array_position and array_positions"],
+  ["fn-04", "array_to_string with NULL handling"],
+  ["fn-05", "string_to_array with null token"],
+  ["fn-06", "array_fill and trim_array"],
+  ["any-01", "ANY over arrays"],
+  ["any-02", "ALL and non-equality operators"],
+  ["where-01", "array predicates filter rows in WHERE"],
+  ["store-01", "stored arrays in GROUP BY and DISTINCT"],
+  ["err-01", "malformed array literal errors"],
+  ["err-02", "ragged multi-dim constructor errors"],
+]);

package/compat/sections/cat.ts

@@ -0,0 +1,47 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+const D = "documented_divergence" as const;
+
+export const CAT_SECTION: CatalogSection = section("CAT", "pg_catalog and information_schema", true, [
+  ["class-01", "user table appears in pg_class with relkind r"],
+  ["class-02", "view appears in pg_class with relkind v"],
+  ["class-03", "sequence appears in pg_class with relkind S"],
+  ["class-04", "pg_class joined to pg_namespace resolves the schema"],
+  ["class-05", "pg_class row disappears after DROP TABLE"],
+  ["attr-01", "pg_attribute lists user columns in order"],
+  ["attr-02", "pg_attribute attnotnull reflects NOT NULL and PK"],
+  ["attr-03", "pg_attribute joined to pg_type resolves column types"],
+  ["type-01", "pg_type has entries for builtin type names"],
+  ["ns-01", "system schemas present in pg_namespace"],
+  ["proc-01", "user function appears in pg_proc"],
+  ["proc-02", "overloads produce multiple pg_proc rows"],
+  ["proc-03", "builtin function present in pg_proc"],
+  ["tabs-01", "pg_tables shows the user table with its schema"],
+  ["views-01", "pg_views shows the user view"],
+  ["info-01", "information_schema.tables reports the user table"],
+  ["info-02", "information_schema.tables reports views as VIEW"],
+  ["info-03", "information_schema.columns basic shape"],
+  ["info-04", "information_schema.columns ordinal positions"],
+  ["info-05", "information_schema.columns numeric data types"],
+  ["cons-01", "information_schema.table_constraints for PK, UNIQUE, CHECK"],
+  ["cons-02", "information_schema.key_column_usage lists key columns"],
+  ["cons-03", "foreign key appears in table_constraints"],
+  ["fn-01", "current_database() and current_schema() shapes"],
+  ["fn-02", "version() reports a PostgreSQL banner"],
+  [
+    "ver-01",
+    "version() full text names postgres-mem",
+    D,
+    "memory: 'PostgreSQL 18.3 (postgres-mem) on TypeScript, in-memory engine'; oracle reports the real build banner",
+    undefined,
+    "version-banner",
+  ],
+  [
+    "viewdef-01",
+    "pg_get_viewdef is not implemented",
+    D,
+    "memory: 42883 function pg_get_viewdef(...) does not exist; PostgreSQL returns the view definition",
+    undefined,
+    "pg-get-viewdef-missing",
+  ],
+]);

package/compat/sections/con.ts

@@ -0,0 +1,32 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+export const CON_SECTION: CatalogSection = section("CON", "Constraints & enforcement", true, [
+  ["nn-01", "NOT NULL violation on INSERT (23502)"],
+  ["nn-02", "NOT NULL violation on UPDATE"],
+  ["nn-03", "DEFAULT satisfies NOT NULL"],
+  ["ck-01", "named CHECK violation on INSERT (23514)"],
+  ["ck-02", "CHECK evaluating to NULL passes"],
+  ["ck-03", "table-level multi-column CHECK"],
+  ["ck-04", "CHECK enforced on UPDATE"],
+  ["uq-01", "UNIQUE violation on INSERT (23505)"],
+  ["uq-02", "UNIQUE allows multiple NULLs"],
+  ["uq-03", "composite UNIQUE blocks full duplicates only"],
+  ["pk-01", "PRIMARY KEY duplicate violation"],
+  ["pk-02", "PRIMARY KEY rejects NULL (23502)"],
+  ["pk-03", "composite PRIMARY KEY"],
+  ["fk-01", "FK insert violation (23503)"],
+  ["fk-02", "parent DELETE blocked by default NO ACTION"],
+  ["fk-03", "parent key UPDATE blocked by FK"],
+  ["fk-04", "ON DELETE CASCADE"],
+  ["fk-05", "ON DELETE SET NULL"],
+  ["fk-06", "ON DELETE SET DEFAULT"],
+  ["fk-07", "ON UPDATE CASCADE"],
+  ["fk-08", "ON UPDATE SET NULL"],
+  ["fk-09", "composite FK violation"],
+  ["fk-10", "NULL child reference bypasses FK"],
+  ["defer-01", "DEFERRABLE INITIALLY IMMEDIATE still enforces"],
+  ["defer-02", "DEFERRABLE INITIALLY DEFERRED parses and enforces outside txn"],
+  ["addcon-01", "ALTER TABLE ADD CONSTRAINT CHECK is enforced"],
+  ["addcon-02", "ALTER TABLE ADD CONSTRAINT UNIQUE is enforced"],
+  ["dropcon-01", "DROP CONSTRAINT lifts enforcement"],
+]);

package/compat/sections/cpy.ts

@@ -0,0 +1,24 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+const D = "documented_divergence" as const;
+const CPY_NOTE =
+  "COPY data flows through the JS copyFrom API / result rows; the PGlite adapter streams COPY separately, so no differential compare is possible";
+const EXTRA = ["tests/contract/copy/"];
+const DIV = "copy-stdin-api";
+
+export const CPY_SECTION: CatalogSection = section("CPY", "COPY", true, [
+  ["from-01", "COPY FROM STDIN text loads rows and returns the count", D, CPY_NOTE, EXTRA, DIV],
+  ["from-02", "\\N is NULL and text escapes decode", D, CPY_NOTE, EXTRA, DIV],
+  ["from-03", "\\. terminates the stream", D, CPY_NOTE, EXTRA, DIV],
+  ["from-04", "column list may reorder and omit columns", D, CPY_NOTE, EXTRA, DIV],
+  ["from-05", "values pass through type input and constraints", D, CPY_NOTE, EXTRA, DIV],
+  ["csv-01", "csv quoted fields, delimiters, doubled quotes", D, CPY_NOTE, EXTRA, DIV],
+  ["csv-02", "csv empty unquoted is NULL; quoted empty is not", D, CPY_NOTE, EXTRA, DIV],
+  ["csv-03", "csv HEADER, DELIMITER, and NULL options", D, CPY_NOTE, EXTRA, DIV],
+  ["to-01", "COPY TO STDOUT text renders \\N nulls and escapes", D, CPY_NOTE, EXTRA, DIV],
+  ["to-02", "COPY TO STDOUT csv quotes only when needed", D, CPY_NOTE, EXTRA, DIV],
+  ["to-03", "COPY (SELECT ...) TO STDOUT supports queries", D, CPY_NOTE, EXTRA, DIV],
+  ["to-04", "COPY TO STDOUT respects the column list", D, CPY_NOTE, EXTRA, DIV],
+  ["rt-01", "COPY TO output round-trips through COPY FROM", D, CPY_NOTE, EXTRA, DIV],
+  ["api-01", "copyFrom rejects non-COPY statements as misuse", D, CPY_NOTE, EXTRA, DIV],
+]);

package/compat/sections/cte.ts

@@ -0,0 +1,29 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+export const CTE_SECTION: CatalogSection = section("CTE", "Common table expressions", true, [
+  ["basic-01", "basic WITH"],
+  ["cols-01", "CTE column-alias list"],
+  ["multi-01", "multiple CTEs in one WITH"],
+  ["chain-01", "CTE references an earlier CTE"],
+  ["ref-01", "CTE referenced multiple times"],
+  ["shadow-01", "CTE shadows a real table"],
+  ["mat-01", "MATERIALIZED hint"],
+  ["mat-02", "NOT MATERIALIZED hint"],
+  ["nest-01", "CTE referenced from a subquery"],
+  ["agg-01", "aggregate over a CTE"],
+  ["set-01", "CTEs feeding a set operation"],
+  ["err-01", "forward CTE reference errors"],
+  ["err-02", "self-reference without RECURSIVE errors"],
+  ["err-03", "too many CTE column aliases errors"],
+  ["rec-01", "WITH RECURSIVE integer series"],
+  ["rec-02", "recursive UNION dedup terminates cycles"],
+  ["rec-03", "recursive tree walk with depth"],
+  ["rec-04", "recursive path accumulation"],
+  ["rec-05", "recursion terminated by WHERE"],
+  ["rec-06", "LIMIT over a recursive result"],
+  ["rec-07", "multi-column recursion"],
+  ["dml-01", "WITH INSERT RETURNING read by outer SELECT"],
+  ["dml-02", "WITH UPDATE RETURNING read by outer SELECT"],
+  ["dml-03", "WITH DELETE RETURNING read by outer SELECT"],
+  ["dml-04", "modifying CTE feeding an INSERT"],
+]);

package/compat/sections/dat.ts

@@ -0,0 +1,60 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+const D = "documented_divergence" as const;
+
+export const DAT_SECTION: CatalogSection = section("DAT", "Date/time types & intervals", true, [
+  ["lit-01", "date literals and text casts"],
+  ["lit-02", "timestamp literals incl fractional seconds and T separator"],
+  ["lit-03", "time literals"],
+  ["lit-04", "timestamptz literals and offset normalization"],
+  ["lit-05", "special values epoch and infinity"],
+  ["cast-01", "casts among date timestamp time"],
+  ["ex-01", "extract date and time fields"],
+  ["ex-02", "extract dow isodow doy week"],
+  ["ex-03", "extract quarter century decade millennium"],
+  ["ex-04", "extract isoyear at year boundary"],
+  ["ex-05", "extract epoch from timestamp date interval"],
+  ["ex-06", "extract vs date_part result types"],
+  ["ex-07", "extract fields from intervals"],
+  ["trunc-01", "date_trunc fine fields"],
+  ["trunc-02", "date_trunc coarse fields"],
+  ["trunc-03", "date_trunc on interval"],
+  ["age-01", "age of two timestamps both directions"],
+  ["arith-01", "date plus/minus integer days"],
+  ["arith-02", "date arithmetic result types"],
+  ["arith-03", "timestamp plus/minus interval"],
+  ["arith-04", "timestamp difference is interval"],
+  ["arith-05", "month-end clamping and leap-year arithmetic"],
+  ["arith-06", "time plus interval wraps midnight"],
+  ["iv-01", "interval unit literals plural and abbreviated"],
+  ["iv-02", "SQL-standard and ISO 8601 interval input"],
+  ["iv-03", "mixed-sign interval formatting and ago"],
+  ["iv-04", "fractional interval units spill down"],
+  ["iv-05", "interval addition subtraction negation"],
+  ["iv-06", "interval multiplication and division"],
+  ["iv-07", "interval comparisons across units"],
+  ["just-01", "justify_hours and justify_days"],
+  ["just-02", "justify_interval and negative inputs"],
+  ["mk-01", "make_date and make_time"],
+  ["mk-02", "make_timestamp and make_timestamptz"],
+  ["mk-03", "make_interval positional and named"],
+  ["fmt-01", "to_char date and time patterns"],
+  ["fmt-02", "to_char on intervals"],
+  ["fmt-03", "to_date parsing"],
+  ["ovl-01", "OVERLAPS operator half-open semantics"],
+  ["fin-01", "isfinite on date timestamp interval"],
+  ["edge-01", "year one and century boundaries"],
+  ["ord-01", "ORDER BY date and interval columns"],
+  [
+    "now-01",
+    "now/current_date fixed to 2000-01-01",
+    D,
+    "deterministic fixed now",
+    ["tests/contract/determinism/"],
+    "deterministic-runtime",
+  ],
+  ["err-01", "out-of-range date fields error"],
+  ["err-02", "garbage date text errors"],
+  ["err-03", "invalid time errors"],
+  ["err-04", "invalid interval text errors"],
+]);

package/compat/sections/ddl.ts

@@ -0,0 +1,55 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+const D = "documented_divergence" as const;
+
+export const DDL_SECTION: CatalogSection = section("DDL", "Schema definition", true, [
+  ["ct-01", "CREATE TABLE with common column types"],
+  ["ct-02", "column defaults including expressions"],
+  ["ct-03", "CREATE TABLE IF NOT EXISTS is idempotent"],
+  ["ct-04", "duplicate table name errors"],
+  ["ct-05", "quoted mixed-case identifiers"],
+  ["ctas-01", "CREATE TABLE AS SELECT"],
+  ["ctas-02", "CTAS WITH NO DATA keeps shape only"],
+  ["ctas-03", "CTAS column name overrides"],
+  ["drop-01", "DROP TABLE and DROP TABLE IF EXISTS"],
+  ["drop-02", "DROP of a missing table errors"],
+  [
+    "drop-03",
+    "DROP TABLE CASCADE leaves dependent views behind",
+    D,
+    "oracle drops the dependent view; memory keeps a broken view (see tests/contract/_reports/catalog-querydml.md)",
+    undefined,
+    "drop-cascade-view-retained",
+  ],
+  ["alter-01", "ADD COLUMN with default backfills rows"],
+  ["alter-02", "DROP COLUMN removes data and star output"],
+  ["alter-03", "RENAME COLUMN"],
+  ["alter-04", "RENAME TABLE"],
+  ["view-01", "CREATE VIEW and query through it"],
+  ["view-02", "view column-alias list"],
+  ["view-03", "view on view"],
+  ["view-04", "CREATE OR REPLACE VIEW swaps definition"],
+  ["view-05", "DROP VIEW and IF EXISTS"],
+  ["idx-01", "CREATE INDEX never changes results"],
+  ["idx-02", "UNIQUE INDEX rejects duplicates"],
+  ["idx-03", "partial unique index scopes enforcement"],
+  ["idx-04", "expression unique index"],
+  ["idx-05", "DROP INDEX lifts enforcement"],
+  ["schema-01", "CREATE SCHEMA with qualified tables"],
+  ["schema-02", "DROP SCHEMA CASCADE"],
+  ["temp-01", "temp table lifecycle"],
+  ["enum-01", "CREATE TYPE AS ENUM ordering and usage"],
+  ["enum-02", "invalid enum literal errors"],
+  ["domain-01", "CREATE DOMAIN accepted values"],
+  ["domain-02", "domain CHECK violation errors"],
+  ["gen-01", "generated STORED column on insert"],
+  ["gen-02", "generated column recomputes on UPDATE"],
+  [
+    "comment-01",
+    "COMMENT ON TABLE parses but is not stored",
+    D,
+    "oracle stores the comment; memory obj_description(oid) returns NULL (see tests/contract/_reports/catalog-querydml.md)",
+    undefined,
+    "comment-on-not-stored",
+  ],
+]);

package/compat/sections/det.ts

@@ -0,0 +1,20 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+const D = "documented_divergence" as const;
+const DET_NOTE = "deterministic random/now by design";
+const EXTRA = ["tests/contract/determinism/"];
+
+const DIV = "deterministic-runtime";
+
+export const DET_SECTION: CatalogSection = section("DET", "Determinism invariants", true, [
+  ["seed-01", "same seed identical random streams", D, DET_NOTE, EXTRA, DIV],
+  ["seed-02", "different seeds diverge", D, DET_NOTE, EXTRA, DIV],
+  ["now-01", "now() fixed to 2000-01-01 by default", D, DET_NOTE, EXTRA, DIV],
+  ["now-02", "injectable clock overrides now", D, DET_NOTE, EXTRA, DIV],
+  ["uuid-01", "gen_random_uuid deterministic under seed", D, DET_NOTE, EXTRA, DIV],
+  ["rb-01", "PRNG rolls back with ROLLBACK", D, DET_NOTE, EXTRA, DIV],
+  ["snap-01", "random() stream continues after restore", D, DET_NOTE, EXTRA, DIV],
+  ["setseed-01", "setseed + random repeatable", D, DET_NOTE, EXTRA, DIV],
+  ["scan-01", "scan and aggregation order stable across restore", D, DET_NOTE, EXTRA, DIV],
+  ["negzero-01", "float8 -0 keeps its sign like PostgreSQL"],
+]);

package/compat/sections/dml.ts

@@ -0,0 +1,37 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+export const DML_SECTION: CatalogSection = section("DML", "Data modification", true, [
+  ["ins-01", "single-row INSERT"],
+  ["ins-02", "multi-row VALUES INSERT"],
+  ["ins-03", "INSERT ... SELECT"],
+  ["ins-04", "INSERT ... SELECT from the same table"],
+  ["ins-05", "INSERT DEFAULT VALUES"],
+  ["ins-06", "DEFAULT keyword inside VALUES"],
+  ["ins-07", "column list reorders values"],
+  ["ins-08", "zero-row INSERT ... SELECT command tag"],
+  ["ret-01", "INSERT RETURNING *"],
+  ["ret-02", "INSERT RETURNING expressions"],
+  ["ret-03", "UPDATE RETURNING"],
+  ["ret-04", "DELETE RETURNING"],
+  ["upd-01", "UPDATE with expressions"],
+  ["upd-02", "UPDATE row count for WHERE subset"],
+  ["upd-03", "UPDATE all rows command tag"],
+  ["upd-04", "UPDATE ... FROM join"],
+  ["upd-05", "UPDATE SET (a, b) = row literal"],
+  ["upd-06", "UPDATE SET (a, b) = scalar subquery row"],
+  ["upd-07", "zero-row UPDATE command tag"],
+  ["del-01", "DELETE with WHERE"],
+  ["del-02", "DELETE all rows command tag"],
+  ["del-03", "DELETE USING join"],
+  ["del-04", "zero-row DELETE command tag"],
+  ["conf-01", "ON CONFLICT DO NOTHING without target"],
+  ["conf-02", "ON CONFLICT (col) DO NOTHING"],
+  ["conf-03", "DO UPDATE with EXCLUDED"],
+  ["conf-04", "DO UPDATE referencing the existing row"],
+  ["conf-05", "DO UPDATE with WHERE clause"],
+  ["conf-06", "ON CONFLICT ON CONSTRAINT target"],
+  ["conf-07", "composite conflict target"],
+  ["conf-08", "upsert RETURNING"],
+  ["trunc-01", "TRUNCATE empties the table"],
+  ["trunc-02", "TRUNCATE RESTART IDENTITY resets sequences"],
+]);

package/compat/sections/eco.ts

@@ -0,0 +1,16 @@
+import { type CatalogSection, section } from "../scenario-types.ts";
+
+const E = "ecosystem" as const;
+
+export const ECO_SECTION: CatalogSection = section("ECO", "Ecosystem / ORM smoke", true, [
+  ["prisma-01", "Prisma-style information_schema.columns introspection", E],
+  ["drizzle-01", "Drizzle-style pg_catalog column and type introspection", E],
+  ["kysely-01", "Kysely-style table listing from pg_class", E],
+  ["knex-01", "knex-style CRUD round trip with RETURNING", E],
+  ["typeorm-01", "TypeORM-style constraint introspection", E],
+  ["mig-01", "migration-runner transactional DDL", E],
+  ["crud-01", "ORM-style serial primary key insert flow", E],
+  ["intro-01", "schema listing from information_schema.tables", E],
+  ["intro-02", "sequence discovery via pg_sequences", E],
+  ["param-01", "driver-style positional parameter binding", E],
+]);