@intentius/chant-lexicon-sql 0.0.0-stage → 0.112.0

package/dist/postgres/plan/schema.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The two sides a Postgres diff compares: a build's output (the
+ * declarations), or what a live server's catalog prints. Both are parsed with
+ * the tag each object was declared with and brought to canonical form
+ * (`./normalize.ts`), so the diff compares like with like.
+ */
+import type { Keyed } from "../../core/diff.js";
+import type { LivePgObject } from "../live/catalog.js";
+import { type CanonicalPgObject } from "./normalize.js";
+/** A canonical object with what the diff needs besides: rename hints, how an index is created, a view's outputs. */
+export interface PgDiffObject extends CanonicalPgObject {
+    type: string;
+    /** `-- previously: <old name>` before the CREATE. */
+    previously?: string;
+    /** Per column, `-- previously: <old name>` on its line. */
+    columnPreviously: Record<string, string>;
+    /** The index is declared CONCURRENTLY. */
+    concurrently?: boolean;
+    /** A view's output columns, in order. */
+    outputs?: string[];
+    /** The tool another object belongs to (an ORM's revision table), when it is not chant's to change. */
+    foreign?: string;
+    /** The export name, against a server. */
+    exportName?: string;
+}
+export type PgSchemaObject = Keyed<PgDiffObject>;
+/** The rename hints in a statement: the object's (a comment before the CREATE) and each column's (a comment on its line). */
+export declare function renameHints(ddl: string): {
+    previously?: string;
+    columns: Record<string, string>;
+};
+/** One object, from its type and statements, in the diff's form. */
+export declare function diffObject(type: string, ddl: string, defaultSchema: string): PgDiffObject;
+/** The objects a Postgres `chant build` output holds, keyed by export name. */
+export declare function pgSchemaFromBuildOutput(json: string, defaultSchema?: string): PgSchemaObject[];
+/** The major a Postgres build recorded (`postgresMajor`), or undefined for output that predates the field. */
+export declare function pgBuildMajor(json: string): number | undefined;
+export declare function pgBuildFileMajor(path: string): number | undefined;
+export declare function pgSchemaFromBuildFile(path: string, defaultSchema?: string): PgSchemaObject[];
+/** The identity an object has on a server: its kind's namespace and its qualified name. */
+export declare function qualifiedKey(o: {
+    kind: string;
+    schema?: string;
+    name: string;
+}): string;
+/** The declared objects re-keyed by qualified name, the only identity a server has. */
+export declare function keyedByQualifiedName(objects: readonly PgSchemaObject[]): PgSchemaObject[];
+/** What a server holds, in the diff's form, keyed by qualified name. */
+export declare function pgSchemaFromLive(live: readonly LivePgObject[], defaultSchema: string): PgSchemaObject[];
+//# sourceMappingURL=schema.d.ts.map

package/dist/postgres/plan/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/postgres/plan/schema.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAE7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD,OAAO,EAAqB,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAGxE,oHAAoH;AACpH,MAAM,WAAW,YAAa,SAAQ,iBAAiB;IACrD,IAAI,EAAE,MAAM,CAAC;IACb,qDAAqD;IACrD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,2DAA2D;IAC3D,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,0CAA0C;IAC1C,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,yCAAyC;IACzC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,sGAAsG;IACtG,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,yCAAyC;IACzC,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,MAAM,cAAc,GAAG,KAAK,CAAC,YAAY,CAAC,CAAC;AAEjD,6HAA6H;AAC7H,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAajG;AAED,oEAAoE;AACpE,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,YAAY,CAgBzF;AAQD,+EAA+E;AAC/E,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,SAAW,GAAG,cAAc,EAAE,CAIhG;AAED,8GAA8G;AAC9G,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAG7D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEjE;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,SAAW,GAAG,cAAc,EAAE,CAE9F;AAED,2FAA2F;AAC3F,wBAAgB,YAAY,CAAC,CAAC,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAGvF;AAED,uFAAuF;AACvF,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,GAAG,cAAc,EAAE,CAEzF;AAED,wEAAwE;AACxE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,YAAY,EAAE,EAAE,aAAa,EAAE,MAAM,GAAG,cAAc,EAAE,CAKvG"}

package/dist/postgres/plan/server-normalize.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The backstop for normalization against a live server: what the rules in
+ * `./normalize.ts` cannot see (a view's `SELECT *`, which the server expands;
+ * the parentheses it adds inside a check) is asked of the server itself.
+ *
+ * For each declared table or view whose expressions still differ from the
+ * server's, the declaration's expressions are created as a temporary object
+ * (`CREATE TEMP VIEW`, or a `CREATE TEMP TABLE` holding the columns' types,
+ * defaults and generated expressions and the checks) inside a transaction
+ * that is always rolled back, with a short `lock_timeout`, and read back with
+ * the same printers the catalog read uses. Nothing is left behind: Postgres
+ * DDL is transactional and a temporary object lives in the session's own
+ * schema. A server that refuses (no TEMP privilege, a lock not granted in
+ * time, an expression it rejects) leaves the rules' answer standing.
+ */
+import type { PostgresClient } from "../live/client.js";
+import { type CanonicalPgObject } from "./normalize.js";
+/**
+ * The declared object with its expressions in the server's own printing,
+ * when the server answers; the object unchanged otherwise. Only the
+ * expressions are touched: everything else stays the rules'.
+ */
+export declare function serverNormalized<T extends CanonicalPgObject & {
+    outputs?: string[];
+}>(client: PostgresClient, o: T, defaultSchema: string): Promise<T>;
+//# sourceMappingURL=server-normalize.d.ts.map

package/dist/postgres/plan/server-normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-normalize.d.ts","sourceRoot":"","sources":["../../../src/postgres/plan/server-normalize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,OAAO,EAAiB,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAwEpE;;;;GAIG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,SAAS,iBAAiB,GAAG;IAAE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,EAAE,MAAM,EAAE,cAAc,EAAE,CAAC,EAAE,CAAC,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CA2B5J"}

package/dist/postgres/providers/aurora.d.ts

@@ -0,0 +1,12 @@
+import { type ProviderData } from "./types.js";
+/**
+ * Amazon Aurora PostgreSQL. Roles and refused statements are RDS's (Aurora
+ * uses the same master-user model). The extension list is the table
+ * "Extensions supported for Aurora PostgreSQL 18" on the Aurora release-notes
+ * page, read 2026-10-03; package names were mapped to extension names as in
+ * rds.ts (h3-pg is `h3`, pgvector is `vector`, pg_roaringbitmap is
+ * `roaringbitmap`). Aurora adds apg_plan_mgmt, aurora_stat_utils, aws_ml,
+ * pg_ad_mapping and pg_columnmask.
+ */
+export declare const aurora: ProviderData;
+//# sourceMappingURL=aurora.d.ts.map

package/dist/postgres/providers/aurora.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aurora.d.ts","sourceRoot":"","sources":["../../../src/postgres/providers/aurora.ts"],"names":[],"mappings":"AACA,OAAO,EAAS,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAEnD;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM,EAAE,YAgCpB,CAAC"}

package/dist/postgres/providers/azure.d.ts

@@ -0,0 +1,14 @@
+import { type ProviderData } from "./types.js";
+/**
+ * Azure Database for PostgreSQL flexible server. The extension list is "List
+ * of extensions and modules by name", the entries available on major 18,
+ * read 2026-10-03. Besides being on that list, an extension must be allow-
+ * listed in the server's `azure.extensions` parameter before CREATE EXTENSION
+ * succeeds, and some also need `shared_preload_libraries`; that is server
+ * configuration, not something the list says, so it is not modelled.
+ * Roles are the three the access-control page names: azure_pg_admin (the
+ * pseudo-superuser the administrator belongs to), azuresu (Microsoft's
+ * control-plane superuser) and the administrator role the customer names.
+ */
+export declare const azure: ProviderData;
+//# sourceMappingURL=azure.d.ts.map

package/dist/postgres/providers/azure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"azure.d.ts","sourceRoot":"","sources":["../../../src/postgres/providers/azure.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAEnE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,KAAK,EAAE,YAwCnB,CAAC"}

package/dist/postgres/providers/cloud-sql.d.ts

@@ -0,0 +1,11 @@
+import { type ProviderData } from "./types.js";
+/**
+ * Google Cloud SQL for PostgreSQL. The extension list is the tables on
+ * "Configure PostgreSQL extensions" (PostGIS, data type, language and
+ * miscellaneous groups), read 2026-10-03. Names are the `CREATE EXTENSION`
+ * names: the page's pgAudit is `pgaudit`, pgTAP is `pgtap`, pgvector is
+ * `vector`. The page says a customer cannot create their own extensions.
+ * Roles are the `cloudsql*` names the Cloud SQL users page lists.
+ */
+export declare const cloudSql: ProviderData;
+//# sourceMappingURL=cloud-sql.d.ts.map

package/dist/postgres/providers/cloud-sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloud-sql.d.ts","sourceRoot":"","sources":["../../../src/postgres/providers/cloud-sql.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAEnE;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ,EAAE,YA+BtB,CAAC"}

package/dist/postgres/providers/index.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Managed-provider knowledge for the Postgres dialect (#3282): which roles
+ * and schemas a provider owns, which extensions it lets a customer create,
+ * and which statements it refuses. See ./types.ts for what a list means and
+ * how stale one can be.
+ */
+import { type PostgresProvider, type ProviderData, type RefusedStatement } from "./types.js";
+export { POSTGRES_PROVIDERS, COMMON_REFUSED } from "./types.js";
+export type { PostgresProvider, ProviderData, ProviderSource, RefusedStatement, ProviderSetting } from "./types.js";
+/** The data for one provider. */
+export declare function providerData(provider: PostgresProvider): ProviderData;
+export declare const isPostgresProvider: (v: unknown) => v is PostgresProvider;
+/**
+ * Whether the provider lets a customer create the extension. `undefined` when
+ * the provider's list is partial and does not name it: the answer is unknown,
+ * not no.
+ */
+export declare function providerAllowsExtension(provider: PostgresProvider, name: string): boolean | undefined;
+/** A live object as import or describe sees it: its kind and name, schema-less for roles, schemas and extensions. */
+export interface LiveObjectRef {
+    kind: "role" | "schema" | "extension";
+    name: string;
+}
+/**
+ * Whether the provider owns a live object, so import and describe can read it
+ * as foreign (not the project's to declare or change). A role or schema the
+ * provider created, an extension the provider installs, or a `pg_` built-in
+ * role. Names are compared case-folded.
+ */
+export declare function isProviderOwned(provider: PostgresProvider, object: LiveObjectRef): boolean;
+/** Reduce a statement to what the refused-statement patterns match: comments and strings removed, upper case, whitespace collapsed. */
+export declare function normalizeStatement(sql: string): string;
+/** The refused-statement entry a statement matches on the provider, if any. */
+export declare function refusedStatement(provider: PostgresProvider, sql: string): RefusedStatement | undefined;
+//# sourceMappingURL=index.d.ts.map

package/dist/postgres/providers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/postgres/providers/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH,OAAO,EAAsB,KAAK,gBAAgB,EAAE,KAAK,YAAY,EAAE,KAAK,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAE9G,OAAO,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAC7D,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,cAAc,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAWjH,iCAAiC;AACjC,wBAAgB,YAAY,CAAC,QAAQ,EAAE,gBAAgB,GAAG,YAAY,CAErE;AAED,eAAO,MAAM,kBAAkB,GAAI,GAAG,OAAO,KAAG,CAAC,IAAI,gBAC2B,CAAC;AAKjF;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,gBAAgB,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAIrG;AAED,qHAAqH;AACrH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,WAAW,CAAC;IACtC,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,gBAAgB,EAAE,MAAM,EAAE,aAAa,GAAG,OAAO,CAW1F;AAED,uIAAuI;AACvI,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAQtD;AAED,+EAA+E;AAC/E,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,gBAAgB,EAAE,GAAG,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAGtG"}

package/dist/postgres/providers/neon.d.ts

@@ -0,0 +1,13 @@
+import { type ProviderData } from "./types.js";
+/**
+ * Neon. The extension list is the "Postgres extensions" table, the entries
+ * with a PG18 version (entries marked `-` for PG18, such as plv8, rum and
+ * pg_search, are left out), read 2026-10-03. Table names were mapped to
+ * `CREATE EXTENSION` names where the page says so: pgvector is `vector`,
+ * pg_roaringbitmap is `roaringbitmap`. wal2json is a decoder plugin the page
+ * says needs no CREATE EXTENSION, so it is not listed. Reserved roles are
+ * the "Reserved role names" list plus neon_service, which the roles page
+ * describes as internal.
+ */
+export declare const neon: ProviderData;
+//# sourceMappingURL=neon.d.ts.map

package/dist/postgres/providers/neon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"neon.d.ts","sourceRoot":"","sources":["../../../src/postgres/providers/neon.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAEnE;;;;;;;;;GASG;AACH,eAAO,MAAM,IAAI,EAAE,YAgClB,CAAC"}

package/dist/postgres/providers/rds.d.ts

@@ -0,0 +1,10 @@
+import { type ProviderData } from "./types.js";
+/**
+ * Amazon RDS for PostgreSQL. The extension list is the table for major 18 on
+ * the "Extensions supported for RDS for PostgreSQL" page, read 2026-10-03;
+ * the other majors differ at the edges and are not modelled (the list is the
+ * newest GA major's). Package names on that page were mapped to extension
+ * names: pgvector is `vector`, h3-pg is `h3` and `h3_postgis`.
+ */
+export declare const rds: ProviderData;
+//# sourceMappingURL=rds.d.ts.map

package/dist/postgres/providers/rds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rds.d.ts","sourceRoot":"","sources":["../../../src/postgres/providers/rds.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAEnE;;;;;;GAMG;AACH,eAAO,MAAM,GAAG,EAAE,YAsCjB,CAAC"}

package/dist/postgres/providers/supabase.d.ts

@@ -0,0 +1,12 @@
+import { type ProviderData } from "./types.js";
+/**
+ * Supabase. The extension names are the ones the extensions overview's
+ * sidebar documents (plv8, pgjwt, timescaledb and pgsodium are marked
+ * deprecated there and left out), read 2026-10-03. The overview's full list
+ * is rendered by script and could not be read, so the list is partial:
+ * `extensionListComplete` is false and SQLPG004 does not report a name
+ * outside it. Roles are the "Supabase roles" section of the roles page. The
+ * unsupported operations are the two the roles-and-superuser page names.
+ */
+export declare const supabase: ProviderData;
+//# sourceMappingURL=supabase.d.ts.map

package/dist/postgres/providers/supabase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supabase.d.ts","sourceRoot":"","sources":["../../../src/postgres/providers/supabase.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAEnD;;;;;;;;GAQG;AACH,eAAO,MAAM,QAAQ,EAAE,YAkCtB,CAAC"}

package/dist/postgres/providers/types.d.ts

@@ -0,0 +1,59 @@
+/**
+ * What the Postgres dialect knows about a managed provider (#3282): the
+ * roles and schemas the provider owns, the extensions it lets a customer
+ * create, and the statements it refuses because they need a superuser.
+ *
+ * The lists are data, one file per provider, each citing the page it was read
+ * from and the date it was read. A provider changes its lists without
+ * announcing it, so a list is a snapshot, not a contract: an extension a
+ * provider added since is reported by SQLPG004 as not allowed until the list
+ * is refreshed, and `toCheck` names what a file did not verify.
+ */
+/** The providers the dialect has data for. */
+export declare const POSTGRES_PROVIDERS: readonly ["rds", "aurora", "cloud-sql", "azure", "neon", "supabase"];
+export type PostgresProvider = (typeof POSTGRES_PROVIDERS)[number];
+/** A documentation page a provider's data was read from. */
+export interface ProviderSource {
+    url: string;
+    /** ISO date the page was read. */
+    readOn: string;
+    /** What the page was used for. */
+    covers: string;
+}
+/** A statement the provider refuses, matched on the statement's text with comments and string contents removed. */
+export interface RefusedStatement {
+    id: string;
+    /** Tested against the upper-cased statement with whitespace collapsed. */
+    pattern: RegExp;
+    reason: string;
+}
+export interface ProviderData {
+    provider: PostgresProvider;
+    /** The provider's name as its documentation spells it. */
+    label: string;
+    sources: readonly ProviderSource[];
+    /** Roles the provider creates and owns; a declared role of this name is refused or foreign. */
+    reservedRoles: readonly string[];
+    /** Schemas the provider creates and owns. */
+    reservedSchemas: readonly string[];
+    /** Extensions the provider lets a customer create (`CREATE EXTENSION name`). */
+    allowedExtensions: readonly string[];
+    /**
+     * Whether `allowedExtensions` is the provider's whole list. When false the
+     * list is what a page named and SQLPG004 stays silent about a name outside
+     * it, because the page that has the full list could not be read.
+     */
+    extensionListComplete: boolean;
+    /** Extensions the provider installs and owns; objects they create are the provider's. */
+    providerExtensions: readonly string[];
+    refusedStatements: readonly RefusedStatement[];
+    /** What the data file did not verify against a page, each with the URL to check. */
+    toCheck: readonly string[];
+}
+/** The `sql.provider` setting, as a profile or the namespace holds it. */
+export type ProviderSetting = PostgresProvider;
+/** Split a whitespace-separated list, so a long extension list stays readable in source. */
+export declare const words: (s: string) => string[];
+/** Statements that need the superuser every managed provider withholds. */
+export declare const COMMON_REFUSED: readonly RefusedStatement[];
+//# sourceMappingURL=types.d.ts.map

package/dist/postgres/providers/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/postgres/providers/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,8CAA8C;AAC9C,eAAO,MAAM,kBAAkB,sEAAuE,CAAC;AAEvG,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEnE,4DAA4D;AAC5D,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,kCAAkC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,kCAAkC;IAClC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,mHAAmH;AACnH,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,0EAA0E;IAC1E,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,0DAA0D;IAC1D,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,SAAS,cAAc,EAAE,CAAC;IACnC,+FAA+F;IAC/F,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,6CAA6C;IAC7C,eAAe,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,gFAAgF;IAChF,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC;;;;OAIG;IACH,qBAAqB,EAAE,OAAO,CAAC;IAC/B,yFAAyF;IACzF,kBAAkB,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,iBAAiB,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC/C,oFAAoF;IACpF,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5B;AAED,0EAA0E;AAC1E,MAAM,MAAM,eAAe,GAAG,gBAAgB,CAAC;AAE/C,4FAA4F;AAC5F,eAAO,MAAM,KAAK,GAAI,GAAG,MAAM,KAAG,MAAM,EAAoC,CAAC;AAE7E,2EAA2E;AAC3E,eAAO,MAAM,cAAc,EAAE,SAAS,gBAAgB,EAIrD,CAAC"}

package/dist/postgres/testing/fake-client.d.ts

@@ -0,0 +1,38 @@
+/**
+ * A fake Postgres client for unit tests: answers the catalog reader's queries
+ * (`../live/catalog.ts`) from rows the test gives, by which catalog each query
+ * reads. Anything else answers no rows.
+ */
+import type { PostgresClient } from "../live/client.js";
+export interface FakeCatalog {
+    schemas?: Array<{
+        name: string;
+        comment?: string;
+    }>;
+    tables?: Array<{
+        schema: string;
+        name: string;
+        comment?: string;
+        columns?: Array<{
+            name: string;
+            type: string;
+            notnull?: boolean;
+            dflt?: string;
+        }>;
+    }>;
+    views?: Array<{
+        schema: string;
+        name: string;
+        def: string;
+        materialized?: boolean;
+        comment?: string;
+    }>;
+    indexes?: Array<{
+        schema: string;
+        name: string;
+        table: string;
+        def: string;
+    }>;
+}
+export declare function fakeClient(catalog: FakeCatalog, log?: string[]): PostgresClient;
+//# sourceMappingURL=fake-client.d.ts.map

package/dist/postgres/testing/fake-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-client.d.ts","sourceRoot":"","sources":["../../../src/postgres/testing/fake-client.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,MAAM,WAAW,WAAW;IAC1B,OAAO,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACpD,MAAM,CAAC,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,OAAO,CAAC,EAAE,OAAO,CAAC;YAAC,IAAI,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC,CAAA;KAAE,CAAC,CAAC;IACtJ,KAAK,CAAC,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACvG,OAAO,CAAC,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC/E;AAED,wBAAgB,UAAU,CAAC,OAAO,EAAE,WAAW,EAAE,GAAG,GAAE,MAAM,EAAO,GAAG,cAAc,CA0BnF"}

package/dist/postgres/testing/migration.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Running `PostgresMigrationOp` in a live test (#3281, #3322): the Op's
+ * activities with the test's config and server, core's local executor, and
+ * an in-memory gate ledger a test approves on.
+ */
+import { type ActivityFn, type GateLedgerPort, type OpRunResult } from "@intentius/chant/op";
+import type { PostgresMigrationDeps } from "../../op/activities/postgres-migration.js";
+import { type PostgresMigrationOpConfig } from "../migrate/op.js";
+/** The migration activities, each called with `deps()`, as the local executor resolves them. */
+export declare function migrationActivityMap(deps: () => PostgresMigrationDeps): Map<string, ActivityFn>;
+/** One run of the Op through core's local executor, as far as its next gate. */
+export declare function runMigrationOp(config: PostgresMigrationOpConfig, gates: GateLedgerPort, deps: () => PostgresMigrationDeps): Promise<OpRunResult>;
+/** An in-memory gate ledger a person approves on: each approval answers the gate the last run stopped at, for the plan it recorded. */
+export declare class ApprovingLedger {
+    private pending;
+    private resolutions;
+    port: GateLedgerPort & {
+        appended: import("@intentius/chant/lifecycle/gate-ledger").PendingGateRecord[];
+        resolved: import("@intentius/chant/lifecycle/gate-ledger").GateResolutionRecord[];
+    };
+    approveLast(): void;
+}
+/** An outcome attribute a run recorded. */
+export declare const runOutcome: (r: OpRunResult, name: string) => unknown;
+//# sourceMappingURL=migration.d.ts.map

package/dist/postgres/testing/migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration.d.ts","sourceRoot":"","sources":["../../../src/postgres/testing/migration.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAoD,KAAK,UAAU,EAAE,KAAK,cAAc,EAAiB,KAAK,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAE9J,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,wCAAwC,CAAC;AACpF,OAAO,EAAuB,KAAK,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAEpF,gGAAgG;AAChG,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,qBAAqB,GAAG,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAO/F;AAED,gFAAgF;AAChF,wBAAsB,cAAc,CAAC,MAAM,EAAE,yBAAyB,EAAE,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,qBAAqB,GAAG,OAAO,CAAC,WAAW,CAAC,CAItJ;AAED,uIAAuI;AACvI,qBAAa,eAAe;IAC1B,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,WAAW,CAAiB;IACpC,IAAI;;;MAA0B;IAE9B,WAAW,IAAI,IAAI;CAcpB;AAED,2CAA2C;AAC3C,eAAO,MAAM,UAAU,GAAI,GAAG,WAAW,EAAE,MAAM,MAAM,KAAG,OAAyF,CAAC"}

package/dist/postgres/testing/roundtrip-schema.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The schema the live round trip creates on its source server: every object
+ * kind the dialect declares, with what the catalog's printers rewrite most
+ * (type aliases, literal casts, `IN` lists, unnamed constraints, identity and
+ * sequence options, storage parameters, comments), an extension and the
+ * domain over its type, a partitioned table and a partition, an ORM's
+ * revision table that import leaves out, and an object carrying chant's
+ * ownership trailer.
+ */
+export declare const ROUNDTRIP_SCHEMA = "\nCREATE SCHEMA app;\nCOMMENT ON SCHEMA app IS 'The shop';\nCREATE EXTENSION citext WITH SCHEMA app;\nCREATE TYPE app.order_status AS ENUM ('placed', 'paid', 'shipped');\nCREATE DOMAIN app.email AS app.citext CONSTRAINT email_shape CHECK (VALUE LIKE '%@%');\nCOMMENT ON CONSTRAINT email_shape ON DOMAIN app.email IS 'needs an @';\nCREATE SEQUENCE app.invoice_seq AS integer START WITH 1000 CACHE 10;\nCREATE TABLE app.users (\n  id bigint GENERATED ALWAYS AS IDENTITY (START WITH 10) PRIMARY KEY,\n  email app.email NOT NULL UNIQUE,\n  plan text NOT NULL DEFAULT 'free' CHECK (plan IN ('free', 'pro')),\n  created_at timestamptz NOT NULL DEFAULT now()\n) WITH (fillfactor = 90);\nCOMMENT ON TABLE app.users IS 'Accounts [chant managed-by=chant stack=shop env=e2e]';\nCOMMENT ON COLUMN app.users.email IS 'Login name';\nCREATE TABLE app.orders (\n  id serial PRIMARY KEY,\n  user_id bigint NOT NULL REFERENCES app.users (id) ON DELETE CASCADE,\n  invoice_no integer NOT NULL DEFAULT nextval('app.invoice_seq'),\n  status app.order_status NOT NULL DEFAULT 'placed',\n  amount numeric(12, 2) NOT NULL CONSTRAINT amount_positive CHECK (amount >= 0),\n  discount int DEFAULT -1,\n  total numeric GENERATED ALWAYS AS (amount * 2) STORED,\n  placed_at timestamp(3) without time zone\n);\nCREATE INDEX orders_user_idx ON app.orders (user_id, placed_at DESC) WHERE status <> 'shipped';\nCREATE UNIQUE INDEX orders_invoice_idx ON app.orders USING btree (invoice_no) INCLUDE (amount);\nCREATE TABLE app.measures (ts date NOT NULL, v double precision) PARTITION BY RANGE (ts);\nCREATE TABLE app.measures_2026 PARTITION OF app.measures FOR VALUES FROM ('2026-01-01') TO ('2027-01-01');\nCREATE VIEW app.order_totals AS\n  SELECT u.id AS user_id, u.email, count(o.id) AS n, coalesce(sum(o.amount), 0) AS total\n  FROM app.users u LEFT JOIN app.orders o ON o.user_id = u.id\n  GROUP BY u.id, u.email;\nCREATE MATERIALIZED VIEW app.daily AS SELECT placed_at::date AS day, count(*) AS n FROM app.orders GROUP BY 1 WITH NO DATA;\nCREATE TABLE public._prisma_migrations (id varchar(36) PRIMARY KEY, checksum varchar(64) NOT NULL);\n";
+//# sourceMappingURL=roundtrip-schema.d.ts.map

package/dist/postgres/testing/roundtrip-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roundtrip-schema.d.ts","sourceRoot":"","sources":["../../../src/postgres/testing/roundtrip-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,skEAoC5B,CAAC"}

package/dist/postgres/testing/server.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A throwaway Postgres server for the live tests: the pinned image on a random
+ * loopback port, a client for it, and a URL for a second database on it.
+ * Always removed with its volume.
+ */
+import { type PostgresClient, type PostgresEndpoint } from "../live/client.js";
+export { dockerAvailable } from "../../core/container.js";
+export interface TestPostgres {
+    name: string;
+    /** The endpoint of database `db` (default `postgres`). */
+    endpoint(db?: string): PostgresEndpoint;
+    /** A client on database `db`, with the catalog-reading session (empty search_path). */
+    connect(db?: string): Promise<PostgresClient>;
+    stop(): Promise<void>;
+}
+export declare function startTestPostgres(major?: number): Promise<TestPostgres>;
+//# sourceMappingURL=server.d.ts.map

package/dist/postgres/testing/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../src/postgres/testing/server.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,EAAmB,KAAK,cAAc,EAAE,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAE7F,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAAC;IACxC,uFAAuF;IACvF,OAAO,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;IAC9C,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB;AAKD,wBAAsB,iBAAiB,CAAC,KAAK,SAAwB,GAAG,OAAO,CAAC,YAAY,CAAC,CA+B5F"}

package/dist/postgres/testing/writable-server.d.ts

@@ -0,0 +1,45 @@
+/**
+ * A fake Postgres server for the applier's unit tests (#3280): a client that
+ * keeps the objects it was sent `CREATE` for, their comments set by
+ * `COMMENT ON`, and drops them on `DROP`, with transactions that roll back;
+ * and a catalog reader over what it keeps, standing in for
+ * `../live/catalog.ts`. What it was sent is recorded, so a test asserts on
+ * the transport.
+ *
+ * It parses statements with the dialect's own parser, so what it stores reads
+ * back as the declaration it came from. It does not model locks, column
+ * changes or dependencies: a test that needs those runs against the pinned
+ * server (`../../op/activities/postgres-apply.e2e.test.ts`).
+ */
+import type { PostgresClient } from "../live/client.js";
+import type { LivePgObject } from "../live/catalog.js";
+import { type PostgresEntityType } from "../entity-types.js";
+/** One object the fake holds. */
+export interface StoredPgObject {
+    type: PostgresEntityType;
+    schema?: string;
+    name: string;
+    /** The CREATE statement, as sent. */
+    create: string;
+    /** The comment, chant's trailer included. */
+    comment?: string;
+    /** Another tool keeps it (an ORM's revision table). */
+    foreign?: string;
+}
+export interface WritablePostgres {
+    client: PostgresClient;
+    /** Reads what the fake holds, as the catalog reader would print it. */
+    readLive: () => Promise<LivePgObject[]>;
+    objects: StoredPgObject[];
+    /** Every statement sent that is not session or transaction control. */
+    writes: string[];
+    /** The DROP statements sent. */
+    deletes: string[];
+    /** Transaction control as sent: BEGIN, COMMIT, ROLLBACK. */
+    control: string[];
+    /** A statement matching this fails with `refuseCode`. */
+    refuse?: RegExp;
+    refuseCode?: string;
+}
+export declare function writablePostgres(seed?: StoredPgObject[]): WritablePostgres;
+//# sourceMappingURL=writable-server.d.ts.map

package/dist/postgres/testing/writable-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writable-server.d.ts","sourceRoot":"","sources":["../../../src/postgres/testing/writable-server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAIpD,OAAO,EAAyB,KAAK,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAGjF,iCAAiC;AACjC,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,kBAAkB,CAAC;IACzB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,qCAAqC;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,6CAA6C;IAC7C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uDAAuD;IACvD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,cAAc,CAAC;IACvB,uEAAuE;IACvE,QAAQ,EAAE,MAAM,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;IACxC,OAAO,EAAE,cAAc,EAAE,CAAC;IAC1B,uEAAuE;IACvE,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,gCAAgC;IAChC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,4DAA4D;IAC5D,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,yDAAyD;IACzD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAoBD,wBAAgB,gBAAgB,CAAC,IAAI,GAAE,cAAc,EAAO,GAAG,gBAAgB,CAqH9E"}

package/dist/postgres/tokens.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Postgres's lexical rules over the shared lossless tokenizer
+ * (`../core/tokens.ts`, chant #3278), from the Postgres 18 reference,
+ * "Lexical Structure":
+ *
+ * - `"` quotes an identifier; a backtick is an operator character.
+ * - A backslash is an ordinary character in `'...'` (standard_conforming_strings
+ *   is on by default since 9.1) and escapes only in an `E'...'` string. `B'...'`,
+ *   `X'...'`, `N'...'` and `U&'...'` are strings too, each one token.
+ * - `$$...$$` and `$tag$...$tag$` are strings; `$1` is a parameter.
+ * - Block comments nest.
+ * - `( ) , ; . [ ]` are punctuation; `=` is an operator, so `WITH (a = 1)`
+ *   reads `=` as an `op` token.
+ * - A number never runs into a name: `42`, `3.5`, `.5`, `1e-3`, `0x1F`,
+ *   `0o17`, `0b101`, `1_000`.
+ * - A multi-character operator does not end in `+` or `-` unless it holds
+ *   one of `~ ! @ # % ^ & | \` ?`, so `fillfactor=-30` reads `=` then `-`.
+ */
+import { type LexicalRules, type Token } from "../core/tokens.js";
+export { isTrivia, SqlSyntaxError, untokenize, type LexicalRules, type Token, type TokenKind } from "../core/tokens.js";
+export declare const POSTGRES_LEXICAL: LexicalRules;
+/** Tokenize one string with Postgres's rules. `part` is the part index recorded on each token and on an error. */
+export declare function tokenizeText(src: string, part: number): Token[];
+/** Tokenize a template's parts with Postgres's rules, with a `ref` token for each interpolation between them. */
+export declare function tokenize(parts: readonly string[]): Token[];
+//# sourceMappingURL=tokens.d.ts.map

package/dist/postgres/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../src/postgres/tokens.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAA8D,KAAK,YAAY,EAAE,KAAK,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE3H,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,UAAU,EAAE,KAAK,YAAY,EAAE,KAAK,KAAK,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAErH,eAAO,MAAM,gBAAgB,EAAE,YAY9B,CAAC;AAEF,kHAAkH;AAClH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,KAAK,EAAE,CAE/D;AAED,iHAAiH;AACjH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,KAAK,EAAE,CAE1D"}

package/dist/postgres.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `@intentius/chant-lexicon-sql/postgres`: the Postgres dialect (#3289).
+ *
+ * Everything here is spec-true to Postgres, not a database-agnostic model:
+ * the statements are Postgres's own DDL, parsed at build time into entities,
+ * and the names fold and quote as Postgres folds and quotes them.
+ */
+export { schema, table, index, view, sequence, type, domain, extension, literal, SqlLiteral, SqlTemplateError, PostgresObject, POSTGRES_ENTITY_TYPES, isPostgresObject, isColumnRef, quoteIdent, type PostgresEntityType, type PostgresSchema, type PostgresRelation, type PostgresTable, type PostgresView, type PostgresIndex, type PostgresSequence, type PostgresEnum, type PostgresDomain, type PostgresExtension, type ColumnDef, type KeyDef, type CheckDef, type ForeignKeyDef, type ExclusionDef, type SchemaProps, type TableProps, type IndexProps, type ViewProps, type SequenceProps, type EnumProps, type DomainProps, type ExtensionProps, type LineageEdge, } from "./postgres/entities.js";
+export { POSTGRES_PROVIDERS, COMMON_REFUSED, providerData, isPostgresProvider, providerAllowsExtension, isProviderOwned, refusedStatement, normalizeStatement, type PostgresProvider, type ProviderData, type ProviderSource, type RefusedStatement, type LiveObjectRef, } from "./postgres/providers/index.js";
+export { PostgresMigrationOp, type PostgresMigrationOpConfig, type PostgresMigrationOpResources, type PostgresMigrationArgs, } from "./postgres/migrate/op.js";
+export { POSTGRES_RECEIPTS_TABLE } from "./postgres/migrate/receipts.js";
+export * from "./composites/postgres.js";
+//# sourceMappingURL=postgres.d.ts.map

package/dist/postgres.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../src/postgres.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,MAAM,EACN,KAAK,EACL,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,IAAI,EACJ,MAAM,EACN,SAAS,EACT,OAAO,EACP,UAAU,EACV,gBAAgB,EAChB,cAAc,EACd,qBAAqB,EACrB,gBAAgB,EAChB,WAAW,EACX,UAAU,EACV,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,SAAS,EACd,KAAK,MAAM,EACX,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,WAAW,GACjB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,kBAAkB,EAClB,cAAc,EACd,YAAY,EACZ,kBAAkB,EAClB,uBAAuB,EACvB,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,aAAa,GACnB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,mBAAmB,EACnB,KAAK,yBAAyB,EAC9B,KAAK,4BAA4B,EACjC,KAAK,qBAAqB,GAC3B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,cAAc,uBAAuB,CAAC"}

package/dist/rules/audit-entries.ts

@@ -0,0 +1,29 @@
+/**
+ * Audit metadata for the ClickHouse post-synth checks (SQLCH1xx). Spread into
+ * `sqlAuditCatalog` by ../audit-catalog.ts. Deprecation checks are filed under
+ * best-practice: the audit categories have no deprecation of their own.
+ */
+
+import { auditRule, type RuleMeta } from "@intentius/chant/audit/catalog";
+
+export const sqlPostSynthAuditEntries: Record<string, RuleMeta> = {
+  SQLCH102: auditRule("SQLCH102", "merge-worthy", "guidance", "A PRIMARY KEY that is not a prefix of ORDER BY", "Make the primary key a leading prefix of the sort key, or drop it to use the sort key.", { category: "correctness" }),
+  SQLCH103: auditRule("SQLCH103", "merge-worthy", "guidance", "An engine's version, sign or is_deleted column has an unsupported type", "Use UInt*, Date, DateTime or DateTime64 for a version, Int8 for a sign, UInt8 for is_deleted.", { category: "correctness" }),
+  SQLCH104: auditRule("SQLCH104", "merge-worthy", "guidance", "A MergeTree engine argument names a column the table does not declare", "Declare the column, or fix the name in the engine arguments.", { category: "correctness" }),
+  SQLCH105: auditRule("SQLCH105", "merge-worthy", "guidance", "A table key clause names a column the table does not declare", "Declare the column, or fix the name in ORDER BY, PRIMARY KEY, PARTITION BY or SAMPLE BY.", { category: "correctness" }),
+  SQLCH106: auditRule("SQLCH106", "merge-worthy", "guidance", "A skip index expression names a column the table does not declare", "Declare the column, or fix the index expression.", { category: "correctness" }),
+  SQLCH107: auditRule("SQLCH107", "merge-worthy", "guidance", "A TTL expression is built on a column that is not a Date or DateTime", "Base the TTL on a Date or DateTime column, or convert it in the expression.", { category: "correctness" }),
+  SQLCH108: auditRule("SQLCH108", "merge-worthy", "guidance", "CREATE OR REPLACE TABLE in a database that is not Atomic", "Create the database with ENGINE = Atomic or Replicated, or drop OR REPLACE.", { category: "correctness" }),
+  SQLCH109: auditRule("SQLCH109", "report-only", "guidance", "A materialized view selects *", "List the columns the view writes.", { category: "best-practice" }),
+  SQLCH110: auditRule("SQLCH110", "report-only", "guidance", "A materialized view writes a column its TO target does not declare", "Add the column to the target table, or drop it from the SELECT.", { category: "correctness" }),
+  SQLCH111: auditRule("SQLCH111", "report-only", "guidance", "A String column limited to a few values is not LowCardinality", "Declare the column LowCardinality(String).", { category: "best-practice" }),
+  SQLCH112: auditRule("SQLCH112", "report-only", "guidance", "A PARTITION BY expression is finer than a day", "Partition by month (toYYYYMM) or day, and keep the finer time in ORDER BY.", { category: "best-practice" }),
+  SQLCH113: auditRule("SQLCH113", "merge-worthy", "guidance", "A MergeTree table declares no sort key", "Add ORDER BY, or ORDER BY tuple() for no sorting.", { category: "correctness" }),
+  SQLCH114: auditRule("SQLCH114", "merge-worthy", "guidance", "A column codec is not one the pinned server has", "Use a codec from the pinned server's system.codecs.", { category: "correctness" }),
+  SQLCH115: auditRule("SQLCH115", "report-only", "guidance", "A secret- or PII-named column carries no comment, TTL or encryption", "Add a COMMENT saying what it holds, a TTL that bounds retention, or an AES_*_GCM_SIV codec.", { category: "security" }),
+  SQLCH116: auditRule("SQLCH116", "report-only", "guidance", "A view is SQL SECURITY DEFINER with no DEFINER", "Write DEFINER = <user> before SQL SECURITY DEFINER.", { category: "security" }),
+  SQLCH117: auditRule("SQLCH117", "report-only", "guidance", "A MergeTree setting is obsolete at the pinned server", "Remove the setting; the server ignores it.", { category: "best-practice" }),
+  SQLCH118: auditRule("SQLCH118", "merge-worthy", "guidance", "A MergeTree setting is not one the pinned server has", "Fix the setting name, or pick a setting from the pinned server's system.merge_tree_settings.", { category: "correctness" }),
+  SQLCH119: auditRule("SQLCH119", "report-only", "guidance", "An object uses a deprecated or experimental engine", "Use the engine that replaced it (Atomic for Ordinary), or accept the experimental engine knowingly.", { category: "best-practice" }),
+  SQLCH120: auditRule("SQLCH120", "report-only", "guidance", "A MergeTree engine uses the deprecated positional arguments", "Write a bare MergeTree with ORDER BY, PARTITION BY and SETTINGS.", { category: "best-practice" }),
+};