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

package/dist/config.d.ts

@@ -0,0 +1,213 @@
+/**
+ * The `sql` namespace in `chant.config.ts`.
+ *
+ * ```ts
+ * import type { ChantConfig } from "@intentius/chant/config";
+ * import "@intentius/chant-lexicon-sql";   // brings the `sql` key into ChantConfig
+ *
+ * export default {
+ *   lexicons: ["sql"],
+ *   sql: {
+ *     dialect: "clickhouse",
+ *     profiles: {
+ *       staging: { url: "http://clickhouse.staging:8123", user: { env: "CH_USER" }, password: { env: "CH_PASSWORD" } },
+ *       prod: { url: "https://clickhouse.example.com:8443", user: { env: "CH_USER" }, password: { env: "CH_PROD_PASSWORD" }, databases: ["analytics"] },
+ *     },
+ *   },
+ * } satisfies ChantConfig;
+ * ```
+ *
+ * A profile is keyed by chant environment, as `grafana.profiles.<env>` is:
+ * the server `chant import --from <env>`, `chant lifecycle diff <env> --live`
+ * and `plan` read. Credentials are named by their environment variable, never
+ * written in the config. An environment with no profile falls back to
+ * `CLICKHOUSE_URL`, `CLICKHOUSE_USER` and `CLICKHOUSE_PASSWORD`, or for
+ * Postgres `POSTGRES_URL`, `POSTGRES_USER` and `POSTGRES_PASSWORD`. A profile
+ * whose `url` is `postgres://` or `postgresql://` is a Postgres server.
+ *
+ * `dialect` names the database a project's schema is for. Declarations carry
+ * their dialect in their own type (a ClickHouse table is `ClickHouse::Table`),
+ * so the setting is for the things a declaration cannot answer: which dialect
+ * a live environment is read as on import, and which dialect's checks run on
+ * output that names none. It defaults to `clickhouse`, the first dialect.
+ * `postgres` is the second (#3289). A list (`dialect: ["clickhouse",
+ * "postgres"]`) is accepted for a workspace with members of more than one
+ * dialect (#3047 question 1); one build still holds one dialect.
+ *
+ * `provider` (#3282) names the managed Postgres service, on the namespace or
+ * on one profile: `sql: { dialect: "postgres", provider: "rds" }`, or
+ * `profiles: { prod: { url, provider: "aurora" } }`. A provider's data lives
+ * in `@intentius/chant-lexicon-sql/postgres` (`providerData`).
+ */
+import { z } from "zod";
+import type { ChantConfig } from "@intentius/chant/config";
+export declare const sqlProfileSchema: z.ZodObject<{
+    /**
+     * Where the server is. ClickHouse: the base URL of its HTTP interface
+     * (`http://clickhouse:8123`). Postgres: a connection URL
+     * (`postgres://db.internal:5432/shop`), with no password in it; the scheme
+     * is what makes a profile a Postgres one.
+     */
+    url: z.ZodString;
+    /** The user, named by its environment variable. `default` when omitted. */
+    user: z.ZodOptional<z.ZodObject<{
+        env: z.ZodString;
+    }, z.core.$strict>>;
+    /** The password, named by its environment variable. */
+    password: z.ZodOptional<z.ZodObject<{
+        env: z.ZodString;
+    }, z.core.$strict>>;
+    /**
+     * The databases this environment's schema lives in. Import reads these and
+     * nothing else; when omitted, every database except the server's own
+     * (`system`, `information_schema`, `INFORMATION_SCHEMA`).
+     */
+    databases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    /** The database an unqualified declaration is created in. `default` when omitted. */
+    defaultDatabase: z.ZodOptional<z.ZodString>;
+    /**
+     * Postgres: the schemas this environment's schema lives in. Import and
+     * observation read these and nothing else; when omitted, every schema except
+     * the server's own (`pg_catalog`, `information_schema`, `pg_toast`, the temp
+     * schemas).
+     */
+    schemas: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    /** Postgres: the schema an unqualified declaration is created in. `public` when omitted. */
+    defaultSchema: z.ZodOptional<z.ZodString>;
+    /**
+     * The managed service this environment's Postgres runs on, when it differs
+     * from `sql.provider`. Import reads the provider's own roles, schemas and
+     * extensions as foreign.
+     */
+    provider: z.ZodOptional<z.ZodEnum<{
+        rds: "rds";
+        aurora: "aurora";
+        "cloud-sql": "cloud-sql";
+        azure: "azure";
+        neon: "neon";
+        supabase: "supabase";
+    }>>;
+    /**
+     * Postgres apply: how long one statement waits for its lock before it
+     * fails (`lock_timeout`), in milliseconds, so a change blocked behind a
+     * long query fails fast instead of queueing every query behind it. 5000
+     * when omitted.
+     */
+    lockTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Postgres apply: the `statement_timeout` for a statement that changes only
+     * the catalog, in milliseconds. 60000 when omitted.
+     */
+    statementTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    /**
+     * Postgres apply: the `statement_timeout` for a statement that reads or
+     * rewrites every row (a table rewrite, a constraint validation, a
+     * `CONCURRENTLY` index build), in milliseconds. 0, no limit, when omitted.
+     */
+    scanTimeoutMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const sqlConfigSchema: z.ZodObject<{
+    /** The dialect, or the dialects, the project's schema is for. */
+    dialect: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        clickhouse: "clickhouse";
+        postgres: "postgres";
+    }>, z.ZodArray<z.ZodEnum<{
+        clickhouse: "clickhouse";
+        postgres: "postgres";
+    }>>]>>;
+    /**
+     * The managed Postgres service the project deploys to (`rds`, `aurora`,
+     * `cloud-sql`, `azure`, `neon`, `supabase`). SQLPG004 reads it to refuse an
+     * extension the provider does not allow. Omit it for a self-hosted server.
+     */
+    provider: z.ZodOptional<z.ZodEnum<{
+        rds: "rds";
+        aurora: "aurora";
+        "cloud-sql": "cloud-sql";
+        azure: "azure";
+        neon: "neon";
+        supabase: "supabase";
+    }>>;
+    /**
+     * The Postgres major the project targets. The editor completes and hovers
+     * only what that major has (a function added in 18 is not offered at 16);
+     * without it, the newest supported major is used.
+     */
+    postgresMajor: z.ZodOptional<z.ZodNumber>;
+    /** One server per chant environment. */
+    profiles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        /**
+         * Where the server is. ClickHouse: the base URL of its HTTP interface
+         * (`http://clickhouse:8123`). Postgres: a connection URL
+         * (`postgres://db.internal:5432/shop`), with no password in it; the scheme
+         * is what makes a profile a Postgres one.
+         */
+        url: z.ZodString;
+        /** The user, named by its environment variable. `default` when omitted. */
+        user: z.ZodOptional<z.ZodObject<{
+            env: z.ZodString;
+        }, z.core.$strict>>;
+        /** The password, named by its environment variable. */
+        password: z.ZodOptional<z.ZodObject<{
+            env: z.ZodString;
+        }, z.core.$strict>>;
+        /**
+         * The databases this environment's schema lives in. Import reads these and
+         * nothing else; when omitted, every database except the server's own
+         * (`system`, `information_schema`, `INFORMATION_SCHEMA`).
+         */
+        databases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        /** The database an unqualified declaration is created in. `default` when omitted. */
+        defaultDatabase: z.ZodOptional<z.ZodString>;
+        /**
+         * Postgres: the schemas this environment's schema lives in. Import and
+         * observation read these and nothing else; when omitted, every schema except
+         * the server's own (`pg_catalog`, `information_schema`, `pg_toast`, the temp
+         * schemas).
+         */
+        schemas: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        /** Postgres: the schema an unqualified declaration is created in. `public` when omitted. */
+        defaultSchema: z.ZodOptional<z.ZodString>;
+        /**
+         * The managed service this environment's Postgres runs on, when it differs
+         * from `sql.provider`. Import reads the provider's own roles, schemas and
+         * extensions as foreign.
+         */
+        provider: z.ZodOptional<z.ZodEnum<{
+            rds: "rds";
+            aurora: "aurora";
+            "cloud-sql": "cloud-sql";
+            azure: "azure";
+            neon: "neon";
+            supabase: "supabase";
+        }>>;
+        /**
+         * Postgres apply: how long one statement waits for its lock before it
+         * fails (`lock_timeout`), in milliseconds, so a change blocked behind a
+         * long query fails fast instead of queueing every query behind it. 5000
+         * when omitted.
+         */
+        lockTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Postgres apply: the `statement_timeout` for a statement that changes only
+         * the catalog, in milliseconds. 60000 when omitted.
+         */
+        statementTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        /**
+         * Postgres apply: the `statement_timeout` for a statement that reads or
+         * rewrites every row (a table rewrite, a constraint validation, a
+         * `CONCURRENTLY` index build), in milliseconds. 0, no limit, when omitted.
+         */
+        scanTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type SqlProfile = z.infer<typeof sqlProfileSchema>;
+export type SqlConfig = z.infer<typeof sqlConfigSchema>;
+declare module "@intentius/chant/config" {
+    interface ChantConfig {
+        sql?: SqlConfig;
+    }
+}
+/** Compile-time proof that the augmentation above reaches `ChantConfig`. */
+export type SqlConfigNamespace = NonNullable<ChantConfig["sql"]>;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAY3D,eAAO,MAAM,gBAAgB;IAC3B;;;;;OAKG;;IAEH,2EAA2E;;;;IAE3E,uDAAuD;;;;IAEvD;;;;OAIG;;IAEH,qFAAqF;;IAErF;;;;;OAKG;;IAEH,4FAA4F;;IAE5F;;;;OAIG;;;;;;;;;IAEH;;;;;OAKG;;IAEH;;;OAGG;;IAEH;;;;OAIG;;kBAEH,CAAC;AAcH,eAAO,MAAM,eAAe;IAC1B,iEAAiE;;;;;;;;IAEjE;;;;OAIG;;;;;;;;;IAEH;;;;OAIG;;IAMH,wCAAwC;;QArFxC;;;;;WAKG;;QAEH,2EAA2E;;;;QAE3E,uDAAuD;;;;QAEvD;;;;WAIG;;QAEH,qFAAqF;;QAErF;;;;;WAKG;;QAEH,4FAA4F;;QAE5F;;;;WAIG;;;;;;;;;QAEH;;;;;WAKG;;QAEH;;;WAGG;;QAEH;;;;WAIG;;;kBAqCH,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,OAAO,QAAQ,yBAAyB,CAAC;IACvC,UAAU,WAAW;QACnB,GAAG,CAAC,EAAE,SAAS,CAAC;KACjB;CACF;AAED,4EAA4E;AAC5E,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC"}

package/dist/core/apply.d.ts

@@ -0,0 +1,89 @@
+/**
+ * The applier's plumbing, the same in every dialect (lexicon-authoring/
+ * applying.mdx): reading a build's output, the outcome's tri-state (applied,
+ * not attempted, and failed for a statement the server refused), its
+ * projection onto core's apply envelope, and the ownership marker an apply
+ * stamps and prunes by.
+ *
+ * What a dialect's applier decides for itself: the statements a change takes,
+ * which changes it refuses and why, how it waits for the server, and how a
+ * prune drops an object.
+ */
+import type { ChantConfig } from "@intentius/chant/config";
+import type { OwnershipMarker } from "@intentius/chant/ownership";
+import { type AppliedResource, type ApplyRef, type ApplyResult, type NotAttemptedResource, type PrunedResource } from "@intentius/chant/apply";
+/** One object of a build's output, as the serializer wrote it. */
+export interface BuildObject {
+    export: string;
+    type: string;
+    ddl: string;
+    /** The export names it references (a column reference by its object's export). */
+    dependsOn: string[];
+}
+/**
+ * The objects a `chant build` output declares for `dialect`, in creation
+ * order, each passed through `map`. Takes the sql lexicon's primary output,
+ * or a multi-lexicon output holding it under `sql`.
+ */
+export declare function readBuildObjects<T>(json: string, dialect: string, map: (o: BuildObject, index: number) => T): T[];
+/** An object the server refused a statement for: attempted, and not converged. */
+export interface FailedObject extends ApplyRef {
+    error: string;
+    /** The statements that did run before the one that failed. */
+    statements: string[];
+}
+/** What an apply did, per object. Every declared object is in exactly one of applied, not attempted or failed. */
+export interface SqlApplyOutcome {
+    /** The server's address. */
+    target: string;
+    /** Where the binding came from, e.g. `sql.profiles.<env>`. */
+    source: string;
+    applied: Array<AppliedResource & {
+        statements: string[];
+    }>;
+    pruned: Array<PrunedResource & {
+        statement: string;
+    }>;
+    notAttempted: NotAttemptedResource[];
+    failed: FailedObject[];
+}
+/**
+ * An apply in which the server refused a statement. The envelope has no
+ * bucket for "attempted and not converged", so the applier finishes the rest
+ * and throws this, carrying the outcome.
+ */
+export declare class SqlApplyError<O extends SqlApplyOutcome = SqlApplyOutcome> extends Error {
+    readonly outcome: O;
+    constructor(
+    /** The dialect as a message names it: `ClickHouse`. */
+    dialect: string, outcome: O);
+}
+/** An outcome in which nothing was attempted: every object not attempted with one reason. */
+export declare function notAttemptedOutcome(refs: readonly ApplyRef[], reason: NotAttemptedResource["reason"], detail: string): SqlApplyOutcome;
+/**
+ * Project an apply outcome onto core's apply envelope. The outcome keeps what
+ * the envelope has no room for: the statements each object took and the
+ * server they went to.
+ */
+export declare function toApplyResult(outcome: SqlApplyOutcome): ApplyResult;
+/**
+ * The marker to stamp and prune by: `stack` and `ownershipEnv` when passed,
+ * else the project's `ownership` config. Undefined without a stack. `who`
+ * names the caller in the error for an env an apply cannot resolve.
+ */
+export declare function resolveOwnershipMarker(args: {
+    stack?: string;
+    ownershipEnv?: string;
+}, config: Pick<ChantConfig, "ownership"> | undefined, who: string): OwnershipMarker | undefined;
+/** Changes grouped by the object they change, in order. */
+export declare function changesByObject<C extends {
+    object: string;
+}>(changes: readonly C[]): Map<string, C[]>;
+/**
+ * The declared objects `dependsOn` names that are not on the server: declared
+ * in this build, and not created or found in this apply. An object with any
+ * is not attempted, `dependency-failed`, with {@link dependencyFailedDetail}.
+ */
+export declare function missingDependencies(self: string, dependsOn: readonly string[], declared: ReadonlySet<string>, onServer: ReadonlySet<string>): string[];
+export declare const dependencyFailedDetail: (missing: readonly string[]) => string;
+//# sourceMappingURL=apply.d.ts.map

package/dist/core/apply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../../src/core/apply.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAClE,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,QAAQ,EACb,KAAK,WAAW,EAChB,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACpB,MAAM,wBAAwB,CAAC;AAMhC,kEAAkE;AAClE,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,kFAAkF;IAClF,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,GAAG,CAAC,EAAE,CAajH;AAED,kFAAkF;AAClF,MAAM,WAAW,YAAa,SAAQ,QAAQ;IAC5C,KAAK,EAAE,MAAM,CAAC;IACd,8DAA8D;IAC9D,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,kHAAkH;AAClH,MAAM,WAAW,eAAe;IAC9B,4BAA4B;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,8DAA8D;IAC9D,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,KAAK,CAAC,eAAe,GAAG;QAAE,UAAU,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAC;IAC3D,MAAM,EAAE,KAAK,CAAC,cAAc,GAAG;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACtD,YAAY,EAAE,oBAAoB,EAAE,CAAC;IACrC,MAAM,EAAE,YAAY,EAAE,CAAC;CACxB;AAED;;;;GAIG;AACH,qBAAa,aAAa,CAAC,CAAC,SAAS,eAAe,GAAG,eAAe,CAAE,SAAQ,KAAK;IAIjF,QAAQ,CAAC,OAAO,EAAE,CAAC;;IAFnB,uDAAuD;IACvD,OAAO,EAAE,MAAM,EACN,OAAO,EAAE,CAAC;CAStB;AAED,6FAA6F;AAC7F,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,QAAQ,EAAE,EAAE,MAAM,EAAE,oBAAoB,CAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,eAAe,CAEtI;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,eAAe,GAAG,WAAW,CAMnE;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,EAC/C,MAAM,EAAE,IAAI,CAAC,WAAW,EAAE,WAAW,CAAC,GAAG,SAAS,EAClD,GAAG,EAAE,MAAM,GACV,eAAe,GAAG,SAAS,CAU7B;AAED,2DAA2D;AAC3D,wBAAgB,eAAe,CAAC,CAAC,SAAS;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CAIrG;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,MAAM,EAAE,EAAE,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,CAEtJ;AAED,eAAO,MAAM,sBAAsB,GAAI,SAAS,SAAS,MAAM,EAAE,KAAG,MAC0C,CAAC"}

package/dist/core/classifier.d.ts

@@ -0,0 +1,88 @@
+/**
+ * The change classifier's framework, the same in every dialect: the shape of
+ * a rule, a classified change, `classifyDisruption()` over a dialect's rules,
+ * and the text report.
+ *
+ * The classes are data, one set per dialect. ClickHouse classes a change by
+ * whether `ALTER` can make it (metadata, background rewrite, rebuild); another
+ * dialect classes by the lock a change takes and whether it rewrites the
+ * table. Each dialect declares its classes with {@link ChangeClasses} and its
+ * rules with {@link classifierRule}, every rule citing the database's own
+ * documentation for the restriction behind it.
+ */
+import type { DisruptionQuery, DisruptionVerdict, Disruption } from "@intentius/chant/lifecycle/disruption";
+/** One way a declared object can change, the class of change it is on the server, and why. */
+export interface ClassifierRule<C extends string = string> {
+    id: string;
+    class: C;
+    title: string;
+    /** The restriction, in a sentence. */
+    restriction: string;
+    /** The documentation page the restriction is stated on. */
+    cite: string;
+}
+export declare const classifierRule: <C extends string>(id: string, cls: C, title: string, restriction: string, cite: string) => ClassifierRule<C>;
+/** A dialect's change classes as data: their order in a report, their labels, and what each costs to apply. */
+export interface ChangeClasses<C extends string> {
+    /** The order a report counts the classes in. */
+    order: readonly C[];
+    /** Each class as a report names it. */
+    label: Readonly<Record<C, string>>;
+    /** Each class as `classifyDisruption()` reports it. */
+    disruption: Readonly<Record<C, Disruption>>;
+}
+/** One classified change to one object. */
+export interface ClassifiedChange<R extends string = string, C extends string = string> {
+    /** The object's identity. */
+    object: string;
+    /** What changed, e.g. `columns.kind.type`, `orderBy`, `name`. */
+    field: string;
+    before?: string;
+    after?: string;
+    rule: R;
+    class: C;
+    /** Data is removed and not recoverable. */
+    destructive?: boolean;
+    /** What a reader should know besides the rule. */
+    note?: string;
+}
+/** A classified change from `before` to `after`, its class read from `rules`. */
+export declare function classifiedChange<R extends string, C extends string>(rules: Readonly<Record<R, ClassifierRule<C>>>, object: string, field: string, rule: R, before?: unknown, after?: unknown, extra?: Partial<ClassifiedChange<R, C>>): ClassifiedChange<R, C>;
+/** The changes between two schemas, and hints for the author. */
+export interface ChangeSet<Ch extends ClassifiedChange = ClassifiedChange> {
+    changes: Ch[];
+    /** Hints for the author: a drop and an add that look like a rename. */
+    hints: string[];
+}
+export interface DisruptionClassifier<R extends string, C extends string> {
+    /** The entity type prefix the dialect's objects carry (`ClickHouse::`); other types are left out. */
+    typePrefix: string;
+    rules: Readonly<Record<R, ClassifierRule<C>>>;
+    classes: Pick<ChangeClasses<C>, "disruption">;
+    /** The rule a changed path falls under, `ambiguous` when the path alone cannot say, undefined when no rule covers it. */
+    ruleFor(path: string): R | "ambiguous" | undefined;
+    /** The detail of an `unknown` verdict: why the paths cannot decide, and what does. */
+    ambiguousDetail: string;
+}
+/**
+ * `classifyDisruption()` over a dialect's rules: each update's disruption is
+ * the worst class among its changed paths, and `unknown` when any path cannot
+ * be classified from the path alone.
+ */
+export declare function classifyDisruptionWith<R extends string, C extends string>(classifier: DisruptionClassifier<R, C>, options: {
+    environment: string;
+    changes: DisruptionQuery[];
+}): Record<string, DisruptionVerdict>;
+/**
+ * A change set as text, for a terminal or a pull request: each object's
+ * changes with their class, rule, restriction and citation, then a count per
+ * class and the hints. `trailer` is the dialect's closing lines (what a plan
+ * refuses and what to run instead); it is left out when nothing changed.
+ */
+export declare function renderChangeSet<R extends string, C extends string>(diff: ChangeSet<ClassifiedChange<R, C>>, opts: {
+    title?: string;
+    rules: Readonly<Record<R, ClassifierRule<C>>>;
+    classes: Pick<ChangeClasses<C>, "order" | "label">;
+    trailer?: readonly string[];
+}): string;
+//# sourceMappingURL=classifier.d.ts.map

package/dist/core/classifier.d.ts.map

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

package/dist/core/container.d.ts

@@ -0,0 +1,45 @@
+/**
+ * A throwaway database server in a container, for every dialect: started on a
+ * random loopback port under a unique name, waited on until it answers, and
+ * always removed.
+ *
+ * Generation uses it on a pin move to read the pinned server's catalog, and
+ * the live tests use it so every container chant starts is started and
+ * cleaned up one way. What "answers" means (an HTTP ping, a query) and the
+ * image's environment are the dialect's.
+ */
+/** True when a Docker daemon answers. Tests that need a server skip when this is false. */
+export declare function dockerAvailable(): Promise<boolean>;
+/** A container name no other run picks: `<prefix>-<pid>-<random>`. */
+export declare function uniqueContainerName(prefix: string): string;
+/** The loopback host port Docker published for `containerPort` on `name`. */
+export declare function publishedPort(name: string, containerPort: number): Promise<string>;
+export interface ScratchContainer {
+    /** The container's name, for a log line. */
+    name: string;
+    /** The loopback host port `containerPort` is published on. */
+    port: string;
+    /** Remove the container. Safe to call twice. */
+    stop(): Promise<void>;
+}
+/**
+ * Run `image` detached, publish `containerPort` on a random loopback port,
+ * and wait until `ready(port)` is true, polling every half second. Pulls the
+ * image when it is not present, which is the one network step here. On any
+ * failure the container is removed before the error is thrown.
+ */
+export declare function startScratchContainer(options: {
+    image: string;
+    namePrefix: string;
+    containerPort: number;
+    env?: Readonly<Record<string, string>>;
+    ready: (port: string) => Promise<boolean>;
+    readyTimeoutMs: number;
+    /** What the container did not do in time, for the error: `did not answer /ping`. */
+    notReady: string;
+    /** Called with the container's name once it is running, before the readiness wait. */
+    onStarted?: (name: string) => void;
+    /** Remove the container's anonymous volumes with it (an image that declares a `VOLUME`, as `postgres` does). */
+    removeVolumes?: boolean;
+}): Promise<ScratchContainer>;
+//# sourceMappingURL=container.d.ts.map

package/dist/core/container.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container.d.ts","sourceRoot":"","sources":["../../src/core/container.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAQH,2FAA2F;AAC3F,wBAAsB,eAAe,IAAI,OAAO,CAAC,OAAO,CAAC,CAOxD;AAED,sEAAsE;AACtE,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,6EAA6E;AAC7E,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAKxF;AAED,MAAM,WAAW,gBAAgB;IAC/B,4CAA4C;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,8DAA8D;IAC9D,IAAI,EAAE,MAAM,CAAC;IACb,gDAAgD;IAChD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACvB;AAED;;;;;GAKG;AACH,wBAAsB,qBAAqB,CAAC,OAAO,EAAE;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,GAAG,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACvC,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1C,cAAc,EAAE,MAAM,CAAC;IACvB,oFAAoF;IACpF,QAAQ,EAAE,MAAM,CAAC;IACjB,sFAAsF;IACtF,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,gHAAgH;IAChH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAwB5B"}

package/dist/core/cursor.d.ts

@@ -0,0 +1,67 @@
+/**
+ * The dialect-neutral half of a hand-written CREATE parser (chant #3196,
+ * #3278): a cursor over a statement's significant tokens, keyword and
+ * punctuation tests, spans, and expressions kept as balanced token spans.
+ *
+ * Statement structure is a dialect's to parse; expressions are not parsed. An
+ * expression (a default, a key, a view's SELECT) is a span of tokens: its
+ * source text, verbatim, and the interpolations inside it. A dialect parser
+ * extends {@link SqlCursor} with its statements, and says where an expression
+ * stops ({@link SqlCursor.stopsAt}) and how a token nests
+ * ({@link SqlCursor.depthChange}).
+ */
+import { type Token } from "./tokens.js";
+/** A run of tokens [from, to) in the token list, trivia included. */
+export interface Span {
+    from: number;
+    to: number;
+    /** Value indexes of the interpolations inside the span. */
+    refs: number[];
+}
+/** Whether `t` is a bare word, any of `words`, case-insensitively. */
+export declare const kw: (t: Token | undefined, ...words: string[]) => boolean;
+/** `name` with its identifier quotes taken off and doubled quotes undone; `quotes` are the dialect's identifier quotes. */
+export declare const unquoteWith: (text: string, quotes: string) => string;
+export declare class SqlCursor {
+    protected readonly tokens: Token[];
+    /** Indexes of the significant (non-trivia) tokens. */
+    protected readonly sig: number[];
+    protected p: number;
+    constructor(tokens: Token[]);
+    protected peek(n?: number): Token | undefined;
+    /** Token-list index of the significant token `n` ahead. */
+    protected idx(n?: number): number;
+    protected next(): Token;
+    fail(message: string, t?: Token | undefined): never;
+    protected lastToken(): Token | undefined;
+    protected accept(...words: string[]): boolean;
+    protected expect(...words: string[]): void;
+    /** Whether the next significant tokens are the bare words `words`, in order. */
+    protected is(...words: string[]): boolean;
+    /** Accept a sequence of bare words, all of them or none. */
+    protected acceptSeq(...words: string[]): boolean;
+    protected isPunct(c: string, n?: number): boolean;
+    protected acceptPunct(c: string): boolean;
+    protected expectPunct(c: string): void;
+    protected atEnd(): boolean;
+    protected span(from: number, refs: number[]): Span;
+    /**
+     * Whether the expression being read stops at the current token, a top-level
+     * bare word: by default when it is one of `stop`. A dialect overrides this
+     * for its multi-word stops (ClickHouse stops at `ORDER` only before `BY`).
+     */
+    protected stopsAt(stop: readonly string[]): boolean;
+    /** How `t` changes the nesting depth of an expression: `(` opens and `)` closes. */
+    protected depthChange(t: Token): number;
+    /**
+     * An expression as a token span: everything up to a top-level `,` (unless
+     * `stopAtComma` is false), `)` or `;`, or a top-level stop word. Nesting is
+     * balanced, not parsed.
+     */
+    protected expr(stop?: readonly string[], stopAtComma?: boolean): Span;
+    /** `( ... )` balanced: the span between the parentheses. */
+    protected parenthesized(): Span;
+    /** A comma-separated expression list as one span. */
+    protected exprList(stop?: readonly string[]): Span;
+}
+//# sourceMappingURL=cursor.d.ts.map

package/dist/core/cursor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cursor.d.ts","sourceRoot":"","sources":["../../src/core/cursor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAA4B,KAAK,KAAK,EAAE,MAAM,UAAU,CAAC;AAEhE,qEAAqE;AACrE,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,2DAA2D;IAC3D,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,sEAAsE;AACtE,eAAO,MAAM,EAAE,GAAI,GAAG,KAAK,GAAG,SAAS,EAAE,GAAG,OAAO,MAAM,EAAE,KAAG,OACiB,CAAC;AAEhF,2HAA2H;AAC3H,eAAO,MAAM,WAAW,GAAI,MAAM,MAAM,EAAE,QAAQ,MAAM,KAAG,MAK1D,CAAC;AAEF,qBAAa,SAAS;IAKR,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE;IAJ9C,sDAAsD;IACtD,SAAS,CAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,CAAC;IACjC,SAAS,CAAC,CAAC,SAAK;gBAEe,MAAM,EAAE,KAAK,EAAE;IAI9C,SAAS,CAAC,IAAI,CAAC,CAAC,SAAI,GAAG,KAAK,GAAG,SAAS;IAKxC,2DAA2D;IAC3D,SAAS,CAAC,GAAG,CAAC,CAAC,SAAI,GAAG,MAAM;IAI5B,SAAS,CAAC,IAAI,IAAI,KAAK;IAOvB,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC,GAAE,KAAK,GAAG,SAAuB,GAAG,KAAK;IAMhE,SAAS,CAAC,SAAS,IAAI,KAAK,GAAG,SAAS;IAKxC,SAAS,CAAC,MAAM,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO;IAQ7C,SAAS,CAAC,MAAM,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI;IAI1C,gFAAgF;IAChF,SAAS,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO;IAIzC,4DAA4D;IAC5D,SAAS,CAAC,SAAS,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO;IAMhD,SAAS,CAAC,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,SAAI,GAAG,OAAO;IAK5C,SAAS,CAAC,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAQzC,SAAS,CAAC,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI;IAItC,SAAS,CAAC,KAAK,IAAI,OAAO;IAI1B,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI;IAIlD;;;;OAIG;IACH,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO;IAKnD,oFAAoF;IACpF,SAAS,CAAC,WAAW,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM;IAMvC;;;;OAIG;IACH,SAAS,CAAC,IAAI,CAAC,IAAI,GAAE,SAAS,MAAM,EAAO,EAAE,WAAW,UAAO,GAAG,IAAI;IAoBtE,4DAA4D;IAC5D,SAAS,CAAC,aAAa,IAAI,IAAI;IAY/B,qDAAqD;IACrD,SAAS,CAAC,QAAQ,CAAC,IAAI,GAAE,SAAS,MAAM,EAAO,GAAG,IAAI;CAWvD"}

package/dist/core/diff.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Identity and renames between two schemas, the same in every dialect
+ * (#3047 question 3).
+ *
+ * An object is identified by its key: its export name between two revisions
+ * of the declarations, its qualified name against a live server, which has no
+ * export names. An `after` object whose key is new but whose `previously` hint
+ * (`-- previously: <old name>`) names a `before` object with no `after`
+ * counterpart is that object, renamed. What changed inside a matched pair,
+ * and how each change is classed, is the dialect's.
+ */
+/** One side of a comparison: an object's identity and its canonical definition. */
+export interface Keyed<O> {
+    /** The object's identity in the comparison: an export name, or a qualified name against live. */
+    key: string;
+    canonical: O;
+}
+export type IdentityMatch<O> = {
+    kind: "created";
+    after: Keyed<O>;
+} | {
+    kind: "matched";
+    before: Keyed<O>;
+    after: Keyed<O>;
+} | {
+    kind: "dropped";
+    before: Keyed<O>;
+};
+export interface IdentityRules<O> {
+    /** The object's qualified name, which a `previously` hint may name. */
+    qualified(o: O): string;
+    /** The `-- previously: <old name>` hint on the object, if any. */
+    previously(o: O): string | undefined;
+    /**
+     * The qualified names a hint may mean, tried in order after the hint as a
+     * key: the hint itself, and for a dialect with schemas or databases the hint
+     * qualified with the object's own.
+     */
+    previousNames(o: O, previously: string): readonly string[];
+}
+/**
+ * Match `after` to `before` by key, then by rename hint. Returns every `after`
+ * object in order, created or matched, then every `before` object no `after`
+ * object matched, dropped.
+ */
+export declare function matchByIdentity<O>(before: readonly Keyed<O>[], after: readonly Keyed<O>[], rules: IdentityRules<O>): IdentityMatch<O>[];
+/** The names whose values differ between two records, sorted. */
+export declare function changedEntries(before: Readonly<Record<string, string>>, after: Readonly<Record<string, string>>): string[];
+//# sourceMappingURL=diff.d.ts.map

package/dist/core/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../src/core/diff.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,mFAAmF;AACnF,MAAM,WAAW,KAAK,CAAC,CAAC;IACtB,iGAAiG;IACjG,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,CAAC,CAAC;CACd;AAED,MAAM,MAAM,aAAa,CAAC,CAAC,IACvB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAAA;CAAE,GACpC;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;IAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAAA;CAAE,GACtD;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,CAAA;CAAE,CAAC;AAE1C,MAAM,WAAW,aAAa,CAAC,CAAC;IAC9B,uEAAuE;IACvE,SAAS,CAAC,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC;IACxB,kEAAkE;IAClE,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,MAAM,GAAG,SAAS,CAAC;IACrC;;;;OAIG;IACH,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,UAAU,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAAC;CAC5D;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,SAAS,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,EAAE,CAwBvI;AAED,iEAAiE;AACjE,wBAAgB,cAAc,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,MAAM,EAAE,CAE1H"}

package/dist/core/entity.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The entity base every dialect's objects share: the Declarable fields core
+ * reads, the hidden-property construction that keeps them out of a build's
+ * props, and the column references (`${t.columns.x}`) a relation hands out.
+ *
+ * A dialect subclasses {@link SqlObject} with its own entity types
+ * (`ClickHouse::Table`), builds its entities with {@link makeSqlEntity} on its
+ * subclass's prototype, and recognizes its own objects by their type prefix.
+ */
+import { DECLARABLE_MARKER, type Declarable } from "@intentius/chant/declarable";
+import { AttrRef } from "@intentius/chant/attrref";
+/** The lexicon every dialect's entities belong to. */
+export declare const SQL_LEXICON = "sql";
+/** The members a schema object has besides its props, in every dialect. */
+export declare abstract class SqlObject implements Declarable {
+    readonly [DECLARABLE_MARKER]: true;
+    readonly lexicon: "sql";
+    readonly entityType: string;
+    readonly kind: "resource";
+    /** The name the object is referred to by in SQL, qualified as the dialect writes it. */
+    readonly sqlName: string;
+    /** The parsed definition; each entity kind narrows it. */
+    readonly props: object;
+    /**
+     * Everything the DDL references, enumerable so core's dependency graph and
+     * `chant graph` see the edges.
+     */
+    readonly dependsOn: readonly unknown[];
+}
+/**
+ * One entity on `prototype` (a dialect's {@link SqlObject} subclass). Every
+ * field but `dependsOn` is hidden, so a build's props are the parsed
+ * definition alone. With `columnNames`, the entity gets a frozen `columns`
+ * record holding one {@link AttrRef} per column.
+ */
+export declare function makeSqlEntity<T extends SqlObject>(prototype: T, entityType: string, sqlName: string, props: object, columnNames: readonly string[] | undefined, dependsOn: unknown[]): T;
+/** Whether `value` is a sql lexicon entity whose type starts with `typePrefix` (`ClickHouse::`). */
+export declare function isSqlObjectOf(value: unknown, typePrefix: string): value is SqlObject;
+/** A column reference: an AttrRef whose parent `isOwner` accepts. */
+export declare function isColumnRefOf(value: unknown, isOwner: (parent: unknown) => boolean): value is AttrRef;
+//# sourceMappingURL=entity.d.ts.map

package/dist/core/entity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity.d.ts","sourceRoot":"","sources":["../../src/core/entity.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,iBAAiB,EAAE,KAAK,UAAU,EAAE,MAAM,6BAA6B,CAAC;AACjF,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAEnD,sDAAsD;AACtD,eAAO,MAAM,WAAW,QAAQ,CAAC;AAEjC,2EAA2E;AAC3E,8BAAsB,SAAU,YAAW,UAAU;IACnD,SAAiB,CAAC,iBAAiB,CAAC,EAAE,IAAI,CAAC;IAC3C,SAAiB,OAAO,EAAE,KAAK,CAAC;IAChC,SAAiB,UAAU,EAAE,MAAM,CAAC;IACpC,SAAiB,IAAI,EAAE,UAAU,CAAC;IAClC,wFAAwF;IACxF,SAAiB,OAAO,EAAE,MAAM,CAAC;IACjC,0DAA0D;IAC1D,SAAiB,KAAK,EAAE,MAAM,CAAC;IAC/B;;;OAGG;IACH,SAAiB,SAAS,EAAE,SAAS,OAAO,EAAE,CAAC;CAChD;AAKD;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,SAAS,EAC/C,SAAS,EAAE,CAAC,EACZ,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,EAC1C,SAAS,EAAE,OAAO,EAAE,GACnB,CAAC,CAeH;AAED,oGAAoG;AACpG,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,KAAK,IAAI,SAAS,CASpF;AAED,qEAAqE;AACrE,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,GAAG,KAAK,IAAI,OAAO,CAKrG"}