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

package/dist/clickhouse/rebuild/replicas.d.ts

@@ -0,0 +1,78 @@
+/**
+ * A replica of a Replicated database that is down (#3270): what each step of
+ * the rebuild does about it.
+ *
+ * DDL (create, dual-write view, EXCHANGE, the views' DETACH and ATTACH, the
+ * drops, the receipts table) goes through the database's log in Keeper. The
+ * replica the run talks to executes it, and the others take it from the log;
+ * one that is down runs it in order when it comes back. So DDL proceeds on
+ * the live replicas: every statement carries
+ * `distributed_ddl_output_mode = throw_only_active`, which "doesn't wait for
+ * inactive replicas of the Replicated database" and still throws when a live
+ * one fails the statement
+ * (https://clickhouse.com/docs/reference/settings/session-settings/distributed-ddl).
+ * With the default `throw` the statement would wait the whole
+ * `distributed_ddl_task_timeout` (180s) for the down replica and then fail,
+ * after the live replicas had already run it. A replica counts as inactive
+ * once its Keeper session has expired (the client's `session_timeout_ms`,
+ * 30s by default), so a statement right after a replica goes down waits that
+ * long and then goes on. `KILL QUERY ON CLUSTER` takes the same setting and
+ * behaves the same way.
+ *
+ * Reading rows is different. A part written on a replica that went down
+ * before the others fetched it is on that replica alone, and the rows in it
+ * cannot be read anywhere else. A backfill that went on without them would
+ * copy the table less those rows, the verification would compare two tables
+ * that both lack them and pass, and the swap would lose them. So before a
+ * step reads rows it waits, for a bounded time, until this replica has
+ * fetched everything the others wrote (`SYSTEM SYNC REPLICA ... LIGHTWEIGHT`,
+ * https://clickhouse.com/docs/sql-reference/statements/system#sync-replica).
+ * When the down replica holds nothing this one lacks, which is the usual case,
+ * the wait returns at once and the step goes on. Otherwise the step stops
+ * with a {@link ReplicaFetchError} naming the replica and its parts.
+ */
+import { type ClickHouseEndpoint } from "../http.js";
+/** Settings every DDL statement of the rebuild carries: go on without the replicas that are down. Ignored in an Atomic database. */
+export declare const DDL_SETTINGS: Readonly<Record<string, string>>;
+/** How long a step waits for this replica to fetch what the others wrote, by default. */
+export declare const DEFAULT_REPLICA_TIMEOUT_MS = 120000;
+/** A part this replica still has to fetch, and the replica it is to fetch it from. */
+export interface MissingPart {
+    part: string;
+    /** The replica that wrote it, as `system.replication_queue` names it. */
+    source: string;
+    /** Whether Keeper still lists that replica as active (it does for a while after it went down, until its session expires). */
+    sourceActive: boolean;
+    /** The last fetch error, first line, if any. */
+    lastError?: string;
+}
+/** A step stopped because this replica could not fetch parts that only another replica has. */
+export declare class ReplicaFetchError extends Error {
+    /** `db.t`. */
+    readonly table: string;
+    /** The replica the run talks to. */
+    readonly replica: string;
+    readonly missing: MissingPart[];
+    readonly waitedMs: number;
+    constructor(
+    /** `db.t`. */
+    table: string, 
+    /** The replica the run talks to. */
+    replica: string, missing: MissingPart[], waitedMs: number);
+}
+/**
+ * Wait until this replica has fetched every part the others have written to
+ * `database.table`, for at most `timeoutMs`; then throw a
+ * {@link ReplicaFetchError} naming what it still lacks and where that is.
+ */
+export declare function syncReplicaWithin(endpoint: ClickHouseEndpoint, database: string, table: string, opts?: {
+    timeoutMs?: number;
+    log?: (line: string) => void;
+    signal?: AbortSignal;
+}): Promise<void>;
+/** The parts this replica's queue is still to fetch for `database.table`, with where from. */
+export declare function missingParts(endpoint: ClickHouseEndpoint, database: string, table: string): Promise<{
+    replica: string;
+    missing: MissingPart[];
+}>;
+//# sourceMappingURL=replicas.d.ts.map

package/dist/clickhouse/rebuild/replicas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replicas.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/rebuild/replicas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,EAAyC,KAAK,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAGzF,oIAAoI;AACpI,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAwD,CAAC;AAEnH,yFAAyF;AACzF,eAAO,MAAM,0BAA0B,SAAU,CAAC;AAUlD,sFAAsF;AACtF,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,yEAAyE;IACzE,MAAM,EAAE,MAAM,CAAC;IACf,6HAA6H;IAC7H,YAAY,EAAE,OAAO,CAAC;IACtB,gDAAgD;IAChD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,+FAA+F;AAC/F,qBAAa,iBAAkB,SAAQ,KAAK;IAExC,cAAc;IACd,QAAQ,CAAC,KAAK,EAAE,MAAM;IACtB,oCAAoC;IACpC,QAAQ,CAAC,OAAO,EAAE,MAAM;IACxB,QAAQ,CAAC,OAAO,EAAE,WAAW,EAAE;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM;;IALzB,cAAc;IACL,KAAK,EAAE,MAAM;IACtB,oCAAoC;IAC3B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,WAAW,EAAE,EACtB,QAAQ,EAAE,MAAM;CAe5B;AAID;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,kBAAkB,EAC5B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,IAAI,GAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAAC,MAAM,CAAC,EAAE,WAAW,CAAA;CAAO,GACpF,OAAO,CAAC,IAAI,CAAC,CAoBf;AAED,8FAA8F;AAC9F,wBAAsB,YAAY,CAAC,QAAQ,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,WAAW,EAAE,CAAA;CAAE,CAAC,CAyBtJ"}

package/dist/clickhouse/rebuild/steps.d.ts

@@ -0,0 +1,151 @@
+/**
+ * The rebuild migration's steps (#3198), each one convergent: it observes
+ * the server (`./observe.ts`), does what is left of its own part, and
+ * reports. Running a step twice does what running it once did.
+ *
+ * The backfill and the verification are in `./backfill.ts` and
+ * `./verify.ts`; the Op that orders them is `./op.ts`.
+ */
+import type { OwnershipMarker } from "@intentius/chant/ownership";
+import type { ClickHouseTarget } from "../live/bind.js";
+import { type DeclaredObject } from "../apply/statements.js";
+import { type DualWrite, type RebuildObservation } from "./observe.js";
+/** What every step is given. */
+export interface RebuildRun {
+    target: ClickHouseTarget;
+    /** The declared table being rebuilt. */
+    declared: DeclaredObject;
+    /** This project's ownership marker, stamped on every working object. */
+    marker?: OwnershipMarker;
+    dualWrite: DualWrite;
+    /** How long the old table is kept after the swap, in milliseconds. */
+    retainMs: number;
+    /** How long to wait for one table's mutations. Default: ten minutes. */
+    mutationTimeoutMs?: number;
+    /** In a Replicated database, how long a step waits for this replica to fetch what the others wrote. Default: two minutes. */
+    replicaTimeoutMs?: number;
+    log: (line: string) => void;
+    signal?: AbortSignal;
+    /** The run's id, recorded on the receipts it writes. */
+    runId?: string;
+}
+/** The server's clock, in milliseconds: the cut-over and the retention are the server's times, not this machine's. */
+export declare function serverNow(target: ClickHouseTarget): Promise<number>;
+/** `2026-10-02 12:00:00.000`, UTC: how a cut-over is written into SQL. */
+export declare const sqlUtc: (ms: number) => string;
+/** A `DateTime64` literal in UTC. */
+export declare const utcLiteral: (ms: number) => string;
+export declare const observe: (run: RebuildRun) => Promise<RebuildObservation>;
+export declare function waitOn(run: RebuildRun, database: string, table: string): Promise<void>;
+/**
+ * In a Replicated database, wait until this replica has every part the
+ * others have written to `database.table` (`SYSTEM SYNC REPLICA ...
+ * LIGHTWEIGHT`, which waits for fetches and not for merges). A step that
+ * reads rows on one replica after a copy ran on another reads them all.
+ * A replica that is down and holds parts this one lacks stops the step once
+ * `replicaTimeoutMs` has passed, naming it (`./replicas.ts`). Nothing to
+ * wait for in an Atomic database.
+ */
+export declare function syncReplica(run: RebuildRun, o: Pick<RebuildObservation, "replicated">, database: string, table: string): Promise<void>;
+export interface CreateResult {
+    state: RebuildObservation["state"];
+    /** `db.t__chant_new`. */
+    table: string;
+    created: boolean;
+}
+/**
+ * Create the new table from the declaration, under `t__chant_new`, marked as
+ * this project's and this rebuild's. The old table's unfinished mutations are
+ * waited on first, so what is copied is what they produce. A new table that
+ * is already there is kept when it matches the declaration; one made from an
+ * earlier declaration is refused, and the run's onFailure drops it.
+ */
+export declare function createNewTable(run: RebuildRun): Promise<CreateResult>;
+export interface DualWriteResult {
+    state: RebuildObservation["state"];
+    mode: DualWrite["mode"];
+    /** The cut-over (materialized-view mode), ISO-8601 UTC. */
+    cutover?: string;
+    created: boolean;
+}
+/**
+ * Materialized-view mode: create `t__chant_dual`, a materialized view on the
+ * old table that writes every row at or after the cut-over into the new
+ * table. The cut-over is the server's time now plus the delay, kept in the
+ * view's own comment (`cutover=`), so a later run and the backfill read it
+ * back from the server. App mode creates nothing; its gate is the Op's.
+ */
+export declare function startDualWrite(run: RebuildRun): Promise<DualWriteResult>;
+/** The cut-over in milliseconds, from the dual-write view; undefined in app mode. */
+export declare function cutoverOf(run: RebuildRun, o: RebuildObservation): number | undefined;
+export interface SwapResult {
+    state: RebuildObservation["state"];
+    swapped: boolean;
+    /** The materialized views that read the table, recreated against the new one. */
+    dependents: string[];
+    /** Where the old table is kept, and until when. */
+    oldTable?: string;
+    retainUntil?: string;
+}
+/**
+ * Swap the new table in: `EXCHANGE TABLES`, then drop the dual-write view,
+ * rename the old table (now under the new table's name) to `t__chant_old`
+ * with its retention date, recreate the materialized views that read the
+ * table, and stamp the table's own comment as declared.
+ *
+ * Each part checks for itself whether it is done, so a swap interrupted
+ * anywhere finishes on the next run. The table's comment is stamped last:
+ * until it is, the table still carries `role=new` and the next run knows the
+ * swap has not finished.
+ *
+ * Recreating a dependent view: in this server line a materialized view
+ * follows its source by name, so after the EXCHANGE it already reads the new
+ * table. It is detached and attached again so the server analyzes its query
+ * against the new table's columns and types, and a view the new definition
+ * breaks fails here, with the old table still kept, rather than on the next
+ * insert. A view with an inner table keeps its data, which dropping and
+ * creating it would not. Inserts that land while a view is detached are not
+ * passed to it; in materialized-view mode writes go on through the swap, so
+ * that window is the length of one DETACH and one ATTACH. In a Replicated
+ * database the DETACH is `PERMANENTLY`, the form that database takes, and
+ * the EXCHANGE, the DETACH and the ATTACH each run on every replica: now on
+ * the live ones, and from the database's log on one that is down, when it
+ * comes back.
+ */
+export declare function swapTables(run: RebuildRun): Promise<SwapResult>;
+/** The materialized views that read `database.name`, as `system.tables` lists them. */
+export declare function dependentViews(run: Pick<RebuildRun, "target">, database: string, name: string): Promise<Array<[string, string]>>;
+export interface RetainResult {
+    state: RebuildObservation["state"];
+    /** `db.t__chant_old`, while it is kept. */
+    oldTable?: string;
+    retainUntil?: string;
+    /** The retention date has passed. */
+    due: boolean;
+    /** What the drop gate approves: this old table, by its UUID, and its date. Absent when there is nothing to drop. */
+    dropDigest?: string;
+}
+/** Where the old table is kept and until when, and the digest the drop gate binds. */
+export declare function retainPlan(run: RebuildRun): Promise<RetainResult>;
+export interface DropResult {
+    state: RebuildObservation["state"];
+    dropped: boolean;
+    oldTable?: string;
+    retainUntil?: string;
+}
+/** Drop the old table once its retention date has passed. Before then, say until when and drop nothing. */
+export declare function dropOldTable(run: RebuildRun): Promise<DropResult>;
+export interface CompensateResult {
+    dropped: string[];
+}
+/**
+ * onFailure: drop the dual-write view and the new table, and nothing else.
+ * Each is dropped only when its comment names this rebuild and its role and
+ * carries this project's marker. After the EXCHANGE the new table is under
+ * the table's own name and the old one under the new table's name without
+ * `role=new`, so neither is touched: the swap is finished by the next run,
+ * not undone. The old table kept after a swap (`role=old`) is never dropped
+ * here; the drop gate decides that.
+ */
+export declare function compensate(run: Pick<RebuildRun, "target" | "declared" | "marker" | "log" | "signal">): Promise<CompensateResult>;
+//# sourceMappingURL=steps.d.ts.map

package/dist/clickhouse/rebuild/steps.d.ts.map

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

package/dist/clickhouse/rebuild/verify.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The verification (#3198): row counts and checksums per partition, the old
+ * table against the new one, before anyone is asked to approve the swap.
+ *
+ * Per partition of the old table: the number of rows and the sum of a
+ * 64-bit hash of each row's copied columns, read in one grouped query on
+ * each side. The old side casts each column to its type in the new table
+ * first, so a column whose type the rebuild changes hashes the same when
+ * its values survived the change. In materialized-view mode both sides are
+ * limited to the rows before the cut-over, which are the backfill's; the
+ * rows after it were written by the dual-write view and keep arriving.
+ *
+ * Any difference fails the run, naming the partitions; the run's onFailure
+ * then drops the new table. On a match the result carries the digest the
+ * swap gate binds: the rebuild's plan and the verification together, so an
+ * approval is for this plan with these counts, and a changed count needs a
+ * new approval.
+ */
+import { type RebuildObservation } from "./observe.js";
+import { type RebuildRun } from "./steps.js";
+export interface PartitionCheck {
+    partition: string;
+    rows: number;
+    checksum: string;
+}
+export interface VerifyResult {
+    state: RebuildObservation["state"];
+    /** The digest the swap gate binds: plan plus verification. Absent once the swap has run: there is nothing left for that gate to approve. */
+    planDigest?: string;
+    partitions: number;
+    rows: number;
+    /** One line for the run record and the gate. */
+    summary: string;
+    verification: PartitionCheck[];
+}
+/** A verification that found the tables different. */
+export declare class RebuildVerificationError extends Error {
+    readonly table: string;
+    readonly mismatches: Array<{
+        partition: string;
+        old?: PartitionCheck;
+        new?: PartitionCheck;
+    }>;
+    constructor(table: string, mismatches: Array<{
+        partition: string;
+        old?: PartitionCheck;
+        new?: PartitionCheck;
+    }>);
+}
+export declare function verifyRebuild(run: RebuildRun): Promise<VerifyResult>;
+//# sourceMappingURL=verify.d.ts.map

package/dist/clickhouse/rebuild/verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/rebuild/verify.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAKH,OAAO,EAAsC,KAAK,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAExF,OAAO,EAAuD,KAAK,UAAU,EAAE,MAAM,SAAS,CAAC;AAE/F,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,kBAAkB,CAAC,OAAO,CAAC,CAAC;IACnC,4IAA4I;IAC5I,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,gDAAgD;IAChD,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,cAAc,EAAE,CAAC;CAChC;AAED,sDAAsD;AACtD,qBAAa,wBAAyB,SAAQ,KAAK;IAE/C,QAAQ,CAAC,KAAK,EAAE,MAAM;IACtB,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,cAAc,CAAC;QAAC,GAAG,CAAC,EAAE,cAAc,CAAA;KAAE,CAAC;gBADpF,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,cAAc,CAAC;QAAC,GAAG,CAAC,EAAE,cAAc,CAAA;KAAE,CAAC;CAYhG;AAED,wBAAsB,aAAa,CAAC,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,YAAY,CAAC,CA8D1E"}

package/dist/clickhouse/testing/fake-server.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A stand-in for a ClickHouse server's HTTP interface, for tests: answers the
+ * catalog queries chant's live reads make from a fixed set of objects.
+ * Not a SQL engine.
+ */
+export interface FakeObject {
+    database?: string;
+    name: string;
+    engine: string;
+    statement: string;
+    comment?: string;
+}
+export interface FakeServer {
+    url: string;
+    queries: string[];
+    close(): Promise<void>;
+}
+export interface FakeOptions {
+    /** Answer every query with this status and body (an auth failure, say). */
+    fail?: {
+        status: number;
+        body: string;
+    };
+    version?: string;
+}
+export declare function fakeClickHouse(objects: FakeObject[], options?: FakeOptions): Promise<FakeServer>;
+//# sourceMappingURL=fake-server.d.ts.map

package/dist/clickhouse/testing/fake-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-server.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/testing/fake-server.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,MAAM,WAAW,WAAW;IAC1B,2EAA2E;IAC3E,IAAI,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACxC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAKD,wBAAsB,cAAc,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,OAAO,GAAE,WAAgB,GAAG,OAAO,CAAC,UAAU,CAAC,CAiC1G"}

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

@@ -0,0 +1,3 @@
+/** The schema the round trip tests import, build, and compare: roundtrip.e2e.test.ts against live servers, import/roundtrip.test.ts offline. */
+export declare const SCHEMA: string[];
+//# sourceMappingURL=roundtrip-schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"roundtrip-schema.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/testing/roundtrip-schema.ts"],"names":[],"mappings":"AAAA,gJAAgJ;AAChJ,eAAO,MAAM,MAAM,UAuBlB,CAAC"}

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

@@ -0,0 +1,35 @@
+/**
+ * A stand-in for a ClickHouse server that an apply can write to, for the
+ * applier's tests (#3208). It keeps a set of objects, answers the catalog
+ * reads observation makes, and takes the writes an apply sends: a `CREATE`
+ * adds an object with the statement as its definition, a `DROP` removes one,
+ * `MODIFY COMMENT` sets a comment. Every other `ALTER` is recorded and
+ * answered, and does not change the definition. Not a SQL engine.
+ */
+export interface StoredObject {
+    database?: string;
+    name: string;
+    engine: string;
+    statement: string;
+    comment?: string;
+}
+export interface WritableServer {
+    url: string;
+    objects: StoredObject[];
+    /** Every statement that is not a read, in order. */
+    writes: string[];
+    /** The targets of every DROP. */
+    deletes: string[];
+    /** Unfinished mutations `system.mutations` reports. */
+    mutations: Array<{
+        database: string;
+        table: string;
+        mutation_id: string;
+        latest_fail_reason?: string;
+    }>;
+    /** Refuse statements matching this, with the server's error. */
+    refuse?: RegExp;
+    close(): Promise<void>;
+}
+export declare function writableClickHouse(initial?: StoredObject[]): Promise<WritableServer>;
+//# sourceMappingURL=writable-server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"writable-server.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/testing/writable-server.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,oDAAoD;IACpD,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,iCAAiC;IACjC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,uDAAuD;IACvD,SAAS,EAAE,KAAK,CAAC;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,kBAAkB,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACxG,gEAAgE;IAChE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAaD,wBAAsB,kBAAkB,CAAC,OAAO,GAAE,YAAY,EAAO,GAAG,OAAO,CAAC,cAAc,CAAC,CA+F9F"}

package/dist/clickhouse/tokens.d.ts

@@ -0,0 +1,15 @@
+/**
+ * ClickHouse's lexical rules over the shared lossless tokenizer
+ * (`../core/tokens.ts`, chant #3196): `` ` `` and `"` quote an identifier, a
+ * backslash escapes inside any quote, `( ) , ; . =` are punctuation, and a
+ * number may run into letters (`00662_events`, which the parser accepts as a
+ * name).
+ */
+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 CLICKHOUSE_LEXICAL: LexicalRules;
+/** Tokenize one string with ClickHouse'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 ClickHouse'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/clickhouse/tokens.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../src/clickhouse/tokens.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;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,kBAAkB,EAAE,YAKhC,CAAC;AAEF,oHAAoH;AACpH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,KAAK,EAAE,CAE/D;AAED,mHAAmH;AACnH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,KAAK,EAAE,CAE1D"}

package/dist/clickhouse.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `@intentius/chant-lexicon-sql/clickhouse`: the ClickHouse dialect.
+ *
+ * Everything here is spec-true to ClickHouse at the pinned server release
+ * (`CLICKHOUSE_VERSION`), not a database-agnostic model: the engine names,
+ * column type families, codecs, skip index types and settings are the pinned
+ * server's own, read from its `system.*` tables, and the argument grammar the
+ * catalog does not carry comes from the overlays beside them.
+ */
+export { database, table, view, literal, SqlLiteral, SqlTemplateError, ClickHouseObject, CLICKHOUSE_ENTITY_TYPES, isClickHouseObject, isColumnRef, quoteIdentifier, type ClickHouseEntityType, type ClickHouseDatabase, type ClickHouseRelation, type ClickHouseTable, type ClickHouseView, type ColumnDef, type DatabaseProps, type EngineDef, type LineageEdge, type TableProps, type ViewProps, } from "./clickhouse/entities.js";
+export * from "./generated/clickhouse.js";
+export * from "./composites/clickhouse.js";
+export type * from "./clickhouse/catalog-types.js";
+export { ENGINE_ARGUMENTS } from "./clickhouse/overlays/engines.js";
+export { SKIP_INDEX_PARAMETERS } from "./clickhouse/overlays/skip-indexes.js";
+export { CODEC_OVERLAY, type CodecOverlay } from "./clickhouse/overlays/codecs.js";
+export { TYPE_PARAMETERS, WRAPPER_TYPES, type TypeParameter } from "./clickhouse/overlays/types.js";
+export { TTL_ACTIONS, COLUMN_TTL_ACTIONS, TTL_RESULT_TYPES, TTL_SETTINGS, type TtlAction, } from "./clickhouse/overlays/ttl.js";
+export { PROJECTION_FORMS, PROJECTION_SETTINGS, PROJECTION_FORBIDDEN_CLAUSES, type ProjectionForm, } from "./clickhouse/overlays/projections.js";
+export { CLICKHOUSE_IMAGE_DIGEST, CLICKHOUSE_IMAGE_REPOSITORY, clickhouseImage } from "./spec/pin.js";
+export { ClickHouseRebuildOp, type ClickHouseRebuildOpConfig, type ClickHouseRebuildOpResources, type ClickHouseRebuildArgs, } from "./clickhouse/rebuild/op.js";
+export type { DualWrite } from "./clickhouse/rebuild/observe.js";
+export { RECEIPTS_DATABASE, RECEIPTS_TABLE } from "./clickhouse/rebuild/receipts.js";
+//# sourceMappingURL=clickhouse.d.ts.map

package/dist/clickhouse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clickhouse.d.ts","sourceRoot":"","sources":["../src/clickhouse.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,QAAQ,EACR,KAAK,EACL,IAAI,EACJ,OAAO,EACP,UAAU,EACV,gBAAgB,EAChB,gBAAgB,EAChB,uBAAuB,EACvB,kBAAkB,EAClB,WAAW,EACX,eAAe,EACf,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,SAAS,GACf,MAAM,uBAAuB,CAAC;AAC/B,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,mBAAmB,4BAA4B,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,aAAa,EAAE,KAAK,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAChF,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,6BAA6B,CAAC;AACjG,OAAO,EACL,WAAW,EACX,kBAAkB,EAClB,gBAAgB,EAChB,YAAY,EACZ,KAAK,SAAS,GACf,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,4BAA4B,EAC5B,KAAK,cAAc,GACpB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,uBAAuB,EAAE,2BAA2B,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AACnG,OAAO,EACL,mBAAmB,EACnB,KAAK,yBAAyB,EAC9B,KAAK,4BAA4B,EACjC,KAAK,qBAAqB,GAC3B,MAAM,yBAAyB,CAAC;AACjC,YAAY,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAC9D,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/codegen/classifier-page.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `docs/pages/change-classifier.mdx`, written from the classifier's own rule
+ * table by `npm run docs`, so the page cannot disagree with the rules.
+ */
+export declare function renderClassifierPage(): string;
+//# sourceMappingURL=classifier-page.d.ts.map

package/dist/codegen/classifier-page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classifier-page.d.ts","sourceRoot":"","sources":["../../src/codegen/classifier-page.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAcH,wBAAgB,oBAAoB,IAAI,MAAM,CA0D7C"}

package/dist/codegen/clickhouse-module.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Render `src/generated/clickhouse.ts`, the ClickHouse dialect's generated
+ * surface: string-literal unions for every named thing in the catalog, the two
+ * settings interfaces, and the tables lint and the LSP read (engines with
+ * their typed arguments, type families, codecs, skip index types, settings).
+ *
+ * The overlays are merged here, and checked against the catalog in both
+ * directions. An overlay key the pinned server does not have, or a codec at
+ * the pin with no overlay entry, is an error: a pin move that changes the
+ * grammar has to change the overlay in the same commit.
+ */
+import type { ClickHouseCatalog } from "../spec/catalog.js";
+export declare function settingTsType(type: string): string;
+export interface RenderedModule {
+    /** `clickhouse-types.ts`: types only, compiles on its own (also written as the packaged `index.d.ts`). */
+    declarations: string;
+    /** `clickhouse.ts`: the runtime tables, re-exporting the declarations. */
+    tables: string;
+    /** Things worth a log line: engines left untyped. */
+    notes: string[];
+}
+export declare function renderClickHouseModule(catalog: ClickHouseCatalog): RenderedModule;
+//# sourceMappingURL=clickhouse-module.d.ts.map

package/dist/codegen/clickhouse-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clickhouse-module.d.ts","sourceRoot":"","sources":["../../src/codegen/clickhouse-module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAc,MAAM,iBAAiB,CAAC;AA6BrE,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AAmED,MAAM,WAAW,cAAc;IAC7B,0GAA0G;IAC1G,YAAY,EAAE,MAAM,CAAC;IACrB,0EAA0E;IAC1E,MAAM,EAAE,MAAM,CAAC;IACf,qDAAqD;IACrD,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,iBAAiB,GAAG,cAAc,CAqJjF"}

package/dist/codegen/docs-cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env tsx
+export {};
+//# sourceMappingURL=docs-cli.d.ts.map

package/dist/codegen/docs-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"docs-cli.d.ts","sourceRoot":"","sources":["../../src/codegen/docs-cli.ts"],"names":[],"mappings":""}

package/dist/codegen/docs.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Documentation generation for the sql lexicon: the generated reference pages
+ * from the core docs pipeline, plus the authored pages in docs/pages/.
+ */
+export declare function generateDocs(opts?: {
+    verbose?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=docs.d.ts.map

package/dist/codegen/docs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"docs.d.ts","sourceRoot":"","sources":["../../src/codegen/docs.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAmMH,wBAAsB,YAAY,CAAC,IAAI,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA0B9E"}

package/dist/codegen/generate-cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env tsx
+export {};
+//# sourceMappingURL=generate-cli.d.ts.map

package/dist/codegen/generate-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-cli.d.ts","sourceRoot":"","sources":["../../src/codegen/generate-cli.ts"],"names":[],"mappings":""}

package/dist/codegen/generate.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The sql lexicon's generation pipeline.
+ *
+ * Two dialects. ClickHouse's "schema" is the catalog a pinned
+ * `clickhouse-server` reports from `system.*`, committed as
+ * `src/spec/clickhouse-catalog.snapshot.json` (chant #3195). `fetchSchemas`
+ * reads that snapshot, and starts the pinned server only on a pin move; see
+ * `src/spec/fetch.ts`.
+ *
+ * Outputs, under `src/generated/`:
+ *
+ * - `clickhouse-types.ts` (and `index.d.ts`, the packaged copy): unions of every
+ *   engine, type family, codec, skip index type, format and function name, and
+ *   the `MergeTreeSettings` / `QuerySettings` interfaces.
+ * - `clickhouse.ts`: the tables lint and the LSP read, with the hand-written
+ *   overlays (engine argument kinds, codec parameters) merged in.
+ * - `lexicon-sql.json`: the entity registry.
+ */
+import { type GenerateOptions, type GenerateResult, type ParsedResult } from "@intentius/chant/codegen/generate";
+import { type ClickHouseCatalog } from "../spec/catalog.js";
+import { type FetchCatalogsOptions } from "../spec/postgres-fetch.js";
+import { type RenderedPostgresModule } from "./postgres-module.js";
+export type { GenerateResult };
+export interface ClickHouseParsed extends ParsedResult {
+    typeName: string;
+    catalog: ClickHouseCatalog;
+}
+export declare function generate(opts?: GenerateOptions): Promise<GenerateResult>;
+export type PostgresGenerateOptions = Pick<FetchCatalogsOptions, "force" | "majors" | "log">;
+/**
+ * Generate the Postgres types: the union of the catalogs of every supported
+ * major (`src/spec/postgres-catalog-<major>.snapshot.json`), rendered with the
+ * overlays. A server is started only for a major whose pin moved, or with
+ * `force`; see `src/spec/postgres-fetch.ts`. The types stay internal to the
+ * package until the `/postgres` subpath has entities to export with them.
+ */
+export declare function generatePostgres(opts?: PostgresGenerateOptions): Promise<RenderedPostgresModule>;
+/** Write the generated files under `src/generated/`. */
+export declare function writeGeneratedFiles(result: GenerateResult, pkgDir?: string, postgres?: RenderedPostgresModule): void;
+//# sourceMappingURL=generate.d.ts.map

package/dist/codegen/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/codegen/generate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,YAAY,EAClB,MAAM,mCAAmC,CAAC;AAK3C,OAAO,EAAgB,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAGvE,OAAO,EAAiB,KAAK,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAClF,OAAO,EAAwB,KAAK,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAEtF,YAAY,EAAE,cAAc,EAAE,CAAC;AAE/B,MAAM,WAAW,gBAAiB,SAAQ,YAAY;IACpD,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,iBAAiB,CAAC;CAC5B;AAED,wBAAsB,QAAQ,CAAC,IAAI,GAAE,eAAoB,GAAG,OAAO,CAAC,cAAc,CAAC,CAqDlF;AAED,MAAM,MAAM,uBAAuB,GAAG,IAAI,CAAC,oBAAoB,EAAE,OAAO,GAAG,QAAQ,GAAG,KAAK,CAAC,CAAC;AAE7F;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,GAAE,uBAA4B,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAG1G;AAED,wDAAwD;AACxD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,cAAc,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,sBAAsB,GAAG,IAAI,CAYpH"}

package/dist/codegen/package.d.ts

@@ -0,0 +1,7 @@
+/**
+ * sql lexicon packaging, delegating to core's packagePipeline.
+ */
+import { type PackageOptions, type PackageResult } from "@intentius/chant/codegen/package";
+export type { PackageOptions, PackageResult };
+export declare function packageLexicon(opts?: PackageOptions): Promise<PackageResult>;
+//# sourceMappingURL=package.d.ts.map

package/dist/codegen/package.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"package.d.ts","sourceRoot":"","sources":["../../src/codegen/package.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,EAAmB,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,kCAAkC,CAAC;AAG5G,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,CAAC;AAK9C,wBAAsB,cAAc,CAAC,IAAI,GAAE,cAAmB,GAAG,OAAO,CAAC,aAAa,CAAC,CAoBtF"}

package/dist/codegen/postgres-classifier-page.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `docs/pages/postgres-change-classifier.mdx`, written from the Postgres
+ * classifier's own rule table by `npm run docs`, so the page cannot disagree
+ * with the rules.
+ */
+export declare function renderPostgresClassifierPage(): string;
+//# sourceMappingURL=postgres-classifier-page.d.ts.map

package/dist/codegen/postgres-classifier-page.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-classifier-page.d.ts","sourceRoot":"","sources":["../../src/codegen/postgres-classifier-page.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,wBAAgB,4BAA4B,IAAI,MAAM,CAsErD"}

package/dist/codegen/postgres-module.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Render the Postgres dialect's generated surface from the catalogs of every
+ * supported major:
+ *
+ * - `src/generated/postgres-types.ts`: string-literal unions of every named
+ *   thing in any major's catalog, the `Settings` and `StorageParams_*`
+ *   interfaces, and the `VERSION_RANGES` table saying which entries are not in
+ *   all majors.
+ * - `src/generated/postgres.ts`: the tables lint and the LSP read (settings,
+ *   storage parameters, column types), with the overlays merged in.
+ *
+ * The overlays are checked against the catalogs in both directions. An overlay
+ * key no major has, or a storage parameter the probe found with no overlay
+ * entry, is an error: a pin move that changes the grammar has to change the
+ * overlay in the same commit.
+ *
+ * Output depends only on the catalogs and the overlays: every map is walked
+ * in sorted order (by code unit, not locale), so two runs are byte-identical.
+ */
+import type { PostgresCatalog } from "../spec/postgres-catalog.js";
+export interface RenderedPostgresModule {
+    /** `postgres-types.ts`: types, and the range table; compiles on its own. */
+    declarations: string;
+    /** `postgres.ts`: the runtime tables, re-exporting the declarations. */
+    tables: string;
+    /** Things worth a log line. */
+    notes: string[];
+}
+export declare function renderPostgresModule(catalogs: readonly PostgresCatalog[]): RenderedPostgresModule;
+//# sourceMappingURL=postgres-module.d.ts.map

package/dist/codegen/postgres-module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-module.d.ts","sourceRoot":"","sources":["../../src/codegen/postgres-module.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAMV,eAAe,EAGhB,MAAM,0BAA0B,CAAC;AA6GlC,MAAM,WAAW,sBAAsB;IACrC,4EAA4E;IAC5E,YAAY,EAAE,MAAM,CAAC;IACrB,wEAAwE;IACxE,MAAM,EAAE,MAAM,CAAC;IACf,+BAA+B;IAC/B,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,SAAS,eAAe,EAAE,GAAG,sBAAsB,CA8RjG"}

package/dist/codegen/registry.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The entity registry, `lexicon-sql.json`: one entry per entity kind, which the
+ * LSP completes and hovers from and `dist/meta.json` packages.
+ *
+ * The entities are hand-written: their shape is the DDL a tag parses, not a
+ * schema document. Each is keyed by the kind's name and points at the entity
+ * type the tag gives it. ClickHouse's kinds came first and keep their bare
+ * names; Postgres's carry the dialect in the name, since both have a table
+ * and a view.
+ */
+export declare function buildRegistry(): string;
+//# sourceMappingURL=registry.d.ts.map

package/dist/codegen/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/codegen/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAqBH,wBAAgB,aAAa,IAAI,MAAM,CAKtC"}