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

package/dist/op/activity-contracts.d.ts

@@ -0,0 +1,464 @@
+/**
+ * Activity contracts for the sql lexicon's own `op/activities` (chant #2101):
+ * the ClickHouse rebuild migration's steps (#3198) and the Postgres
+ * expand-and-contract migration's (#3281).
+ *
+ * `loadActivityContracts` imports this module at
+ * `@intentius/chant-lexicon-sql/op/activity-contracts` for every project that
+ * lists the sql lexicon, and core's OPS012 and OPS013 check every
+ * `ClickHouseRebuildOp` and `PostgresMigrationOp` step against it at
+ * `chant build`: the arguments, and the two references each Op makes into a
+ * step's return value, the verification's `planDigest` (the swap or switch
+ * gate) and the retention's `dropDigest` or `contractDigest` (the drop or
+ * contract gate). Arguments are `z.strictObject`, so a
+ * misspelled key fails the build instead of vanishing.
+ */
+export declare const clickhouseRebuildPlanContract: import("@intentius/chant/op").ActivityContract<{
+    table: string;
+    buildPath: string;
+    dualWrite: {
+        mode: "materialized-view";
+        cutoverColumn: string;
+        cutoverDelay?: string | undefined;
+    } | {
+        mode: "app";
+    };
+    environment?: string | undefined;
+    retain?: string | undefined;
+    mutationTimeout?: string | undefined;
+    replicaTimeout?: string | undefined;
+    stack?: string | undefined;
+    ownershipEnv?: string | undefined;
+    cwd?: string | undefined;
+}, {
+    state: "done" | "rebuild" | "swapped";
+    table: string;
+    changes: string[];
+    summary: string;
+    planDigest?: string | undefined;
+}>;
+export declare const clickhouseRebuildCreateContract: import("@intentius/chant/op").ActivityContract<{
+    table: string;
+    buildPath: string;
+    dualWrite: {
+        mode: "materialized-view";
+        cutoverColumn: string;
+        cutoverDelay?: string | undefined;
+    } | {
+        mode: "app";
+    };
+    environment?: string | undefined;
+    retain?: string | undefined;
+    mutationTimeout?: string | undefined;
+    replicaTimeout?: string | undefined;
+    stack?: string | undefined;
+    ownershipEnv?: string | undefined;
+    cwd?: string | undefined;
+}, {
+    state: "done" | "rebuild" | "swapped";
+    table: string;
+    created: boolean;
+}>;
+export declare const clickhouseRebuildDualWriteContract: import("@intentius/chant/op").ActivityContract<{
+    table: string;
+    buildPath: string;
+    dualWrite: {
+        mode: "materialized-view";
+        cutoverColumn: string;
+        cutoverDelay?: string | undefined;
+    } | {
+        mode: "app";
+    };
+    environment?: string | undefined;
+    retain?: string | undefined;
+    mutationTimeout?: string | undefined;
+    replicaTimeout?: string | undefined;
+    stack?: string | undefined;
+    ownershipEnv?: string | undefined;
+    cwd?: string | undefined;
+}, {
+    state: "done" | "rebuild" | "swapped";
+    mode: "app" | "materialized-view";
+    created: boolean;
+    cutover?: string | undefined;
+}>;
+export declare const clickhouseRebuildBackfillContract: import("@intentius/chant/op").ActivityContract<{
+    table: string;
+    buildPath: string;
+    dualWrite: {
+        mode: "materialized-view";
+        cutoverColumn: string;
+        cutoverDelay?: string | undefined;
+    } | {
+        mode: "app";
+    };
+    environment?: string | undefined;
+    retain?: string | undefined;
+    mutationTimeout?: string | undefined;
+    replicaTimeout?: string | undefined;
+    stack?: string | undefined;
+    ownershipEnv?: string | undefined;
+    cwd?: string | undefined;
+}, {
+    state: "done" | "rebuild" | "swapped";
+    partitions: number;
+    copied: number;
+    skipped: number;
+    cleared: number;
+}>;
+export declare const clickhouseRebuildVerifyContract: import("@intentius/chant/op").ActivityContract<{
+    table: string;
+    buildPath: string;
+    dualWrite: {
+        mode: "materialized-view";
+        cutoverColumn: string;
+        cutoverDelay?: string | undefined;
+    } | {
+        mode: "app";
+    };
+    environment?: string | undefined;
+    retain?: string | undefined;
+    mutationTimeout?: string | undefined;
+    replicaTimeout?: string | undefined;
+    stack?: string | undefined;
+    ownershipEnv?: string | undefined;
+    cwd?: string | undefined;
+}, {
+    state: "done" | "rebuild" | "swapped";
+    partitions: number;
+    rows: number;
+    summary: string;
+    verification: {
+        partition: string;
+        rows: number;
+        checksum: string;
+    }[];
+    planDigest?: string | undefined;
+}>;
+export declare const clickhouseRebuildSwapContract: import("@intentius/chant/op").ActivityContract<{
+    table: string;
+    buildPath: string;
+    dualWrite: {
+        mode: "materialized-view";
+        cutoverColumn: string;
+        cutoverDelay?: string | undefined;
+    } | {
+        mode: "app";
+    };
+    environment?: string | undefined;
+    retain?: string | undefined;
+    mutationTimeout?: string | undefined;
+    replicaTimeout?: string | undefined;
+    stack?: string | undefined;
+    ownershipEnv?: string | undefined;
+    cwd?: string | undefined;
+}, {
+    state: "done" | "rebuild" | "swapped";
+    swapped: boolean;
+    dependents: string[];
+    oldTable?: string | undefined;
+    retainUntil?: string | undefined;
+}>;
+export declare const clickhouseRebuildRetainContract: import("@intentius/chant/op").ActivityContract<{
+    table: string;
+    buildPath: string;
+    dualWrite: {
+        mode: "materialized-view";
+        cutoverColumn: string;
+        cutoverDelay?: string | undefined;
+    } | {
+        mode: "app";
+    };
+    environment?: string | undefined;
+    retain?: string | undefined;
+    mutationTimeout?: string | undefined;
+    replicaTimeout?: string | undefined;
+    stack?: string | undefined;
+    ownershipEnv?: string | undefined;
+    cwd?: string | undefined;
+}, {
+    state: "done" | "rebuild" | "swapped";
+    due: boolean;
+    oldTable?: string | undefined;
+    retainUntil?: string | undefined;
+    dropDigest?: string | undefined;
+}>;
+export declare const clickhouseRebuildDropContract: import("@intentius/chant/op").ActivityContract<{
+    table: string;
+    buildPath: string;
+    dualWrite: {
+        mode: "materialized-view";
+        cutoverColumn: string;
+        cutoverDelay?: string | undefined;
+    } | {
+        mode: "app";
+    };
+    environment?: string | undefined;
+    retain?: string | undefined;
+    mutationTimeout?: string | undefined;
+    replicaTimeout?: string | undefined;
+    stack?: string | undefined;
+    ownershipEnv?: string | undefined;
+    cwd?: string | undefined;
+}, {
+    state: "done" | "rebuild" | "swapped";
+    dropped: boolean;
+    oldTable?: string | undefined;
+    retainUntil?: string | undefined;
+}>;
+export declare const clickhouseRebuildCompensateContract: import("@intentius/chant/op").ActivityContract<{
+    table: string;
+    buildPath: string;
+    dualWrite: {
+        mode: "materialized-view";
+        cutoverColumn: string;
+        cutoverDelay?: string | undefined;
+    } | {
+        mode: "app";
+    };
+    environment?: string | undefined;
+    retain?: string | undefined;
+    mutationTimeout?: string | undefined;
+    replicaTimeout?: string | undefined;
+    stack?: string | undefined;
+    ownershipEnv?: string | undefined;
+    cwd?: string | undefined;
+}, {
+    dropped: string[];
+}>;
+export declare const postgresMigrationPlanContract: import("@intentius/chant/op").ActivityContract<{
+    table: string;
+    column: string;
+    buildPath: string;
+    environment?: string | undefined;
+    using?: string | undefined;
+    retain?: string | undefined;
+    batchSize?: number | undefined;
+    replicationLag?: false | {
+        max?: string | undefined;
+        wait?: string | undefined;
+    } | undefined;
+    lockTimeoutMs?: number | undefined;
+    statementTimeoutMs?: number | undefined;
+    stack?: string | undefined;
+    ownershipEnv?: string | undefined;
+    cwd?: string | undefined;
+}, {
+    state: "done" | "migrate" | "switched";
+    migration: string;
+    change: "type" | "rename";
+    changes: string[];
+    summary: string;
+    planDigest?: string | undefined;
+}>;
+export declare const postgresMigrationExpandContract: import("@intentius/chant/op").ActivityContract<{
+    table: string;
+    column: string;
+    buildPath: string;
+    environment?: string | undefined;
+    using?: string | undefined;
+    retain?: string | undefined;
+    batchSize?: number | undefined;
+    replicationLag?: false | {
+        max?: string | undefined;
+        wait?: string | undefined;
+    } | undefined;
+    lockTimeoutMs?: number | undefined;
+    statementTimeoutMs?: number | undefined;
+    stack?: string | undefined;
+    ownershipEnv?: string | undefined;
+    cwd?: string | undefined;
+}, {
+    state: "done" | "migrate" | "switched";
+    column: string;
+    added: boolean;
+}>;
+export declare const postgresMigrationDualWriteContract: import("@intentius/chant/op").ActivityContract<{
+    table: string;
+    column: string;
+    buildPath: string;
+    environment?: string | undefined;
+    using?: string | undefined;
+    retain?: string | undefined;
+    batchSize?: number | undefined;
+    replicationLag?: false | {
+        max?: string | undefined;
+        wait?: string | undefined;
+    } | undefined;
+    lockTimeoutMs?: number | undefined;
+    statementTimeoutMs?: number | undefined;
+    stack?: string | undefined;
+    ownershipEnv?: string | undefined;
+    cwd?: string | undefined;
+}, {
+    state: "done" | "migrate" | "switched";
+    trigger: string;
+    created: boolean;
+}>;
+export declare const postgresMigrationBackfillContract: import("@intentius/chant/op").ActivityContract<{
+    table: string;
+    column: string;
+    buildPath: string;
+    environment?: string | undefined;
+    using?: string | undefined;
+    retain?: string | undefined;
+    batchSize?: number | undefined;
+    replicationLag?: false | {
+        max?: string | undefined;
+        wait?: string | undefined;
+    } | undefined;
+    lockTimeoutMs?: number | undefined;
+    statementTimeoutMs?: number | undefined;
+    stack?: string | undefined;
+    ownershipEnv?: string | undefined;
+    cwd?: string | undefined;
+}, {
+    state: "done" | "migrate" | "switched";
+    batches: number;
+    filled: number;
+    skipped: number;
+    rows: number;
+    pausedMs: number;
+}>;
+export declare const postgresMigrationCarryContract: import("@intentius/chant/op").ActivityContract<{
+    table: string;
+    column: string;
+    buildPath: string;
+    environment?: string | undefined;
+    using?: string | undefined;
+    retain?: string | undefined;
+    batchSize?: number | undefined;
+    replicationLag?: false | {
+        max?: string | undefined;
+        wait?: string | undefined;
+    } | undefined;
+    lockTimeoutMs?: number | undefined;
+    statementTimeoutMs?: number | undefined;
+    stack?: string | undefined;
+    ownershipEnv?: string | undefined;
+    cwd?: string | undefined;
+}, {
+    state: "done" | "migrate" | "switched";
+    built: number;
+    ready: number;
+    views: number;
+    carried: string[];
+}>;
+export declare const postgresMigrationVerifyContract: import("@intentius/chant/op").ActivityContract<{
+    table: string;
+    column: string;
+    buildPath: string;
+    environment?: string | undefined;
+    using?: string | undefined;
+    retain?: string | undefined;
+    batchSize?: number | undefined;
+    replicationLag?: false | {
+        max?: string | undefined;
+        wait?: string | undefined;
+    } | undefined;
+    lockTimeoutMs?: number | undefined;
+    statementTimeoutMs?: number | undefined;
+    stack?: string | undefined;
+    ownershipEnv?: string | undefined;
+    cwd?: string | undefined;
+}, {
+    state: "done" | "migrate" | "switched";
+    rows: number;
+    mismatched: number;
+    nulls: number;
+    checksum: string;
+    expected: string;
+    summary: string;
+    planDigest?: string | undefined;
+}>;
+export declare const postgresMigrationSwitchContract: import("@intentius/chant/op").ActivityContract<{
+    table: string;
+    column: string;
+    buildPath: string;
+    environment?: string | undefined;
+    using?: string | undefined;
+    retain?: string | undefined;
+    batchSize?: number | undefined;
+    replicationLag?: false | {
+        max?: string | undefined;
+        wait?: string | undefined;
+    } | undefined;
+    lockTimeoutMs?: number | undefined;
+    statementTimeoutMs?: number | undefined;
+    stack?: string | undefined;
+    ownershipEnv?: string | undefined;
+    cwd?: string | undefined;
+}, {
+    state: "done" | "migrate" | "switched";
+    switched: boolean;
+    oldColumn?: string | undefined;
+    retainUntil?: string | undefined;
+}>;
+export declare const postgresMigrationRetainContract: import("@intentius/chant/op").ActivityContract<{
+    table: string;
+    column: string;
+    buildPath: string;
+    environment?: string | undefined;
+    using?: string | undefined;
+    retain?: string | undefined;
+    batchSize?: number | undefined;
+    replicationLag?: false | {
+        max?: string | undefined;
+        wait?: string | undefined;
+    } | undefined;
+    lockTimeoutMs?: number | undefined;
+    statementTimeoutMs?: number | undefined;
+    stack?: string | undefined;
+    ownershipEnv?: string | undefined;
+    cwd?: string | undefined;
+}, {
+    state: "done" | "migrate" | "switched";
+    due: boolean;
+    oldColumn?: string | undefined;
+    retainUntil?: string | undefined;
+    contractDigest?: string | undefined;
+}>;
+export declare const postgresMigrationContractContract: import("@intentius/chant/op").ActivityContract<{
+    table: string;
+    column: string;
+    buildPath: string;
+    environment?: string | undefined;
+    using?: string | undefined;
+    retain?: string | undefined;
+    batchSize?: number | undefined;
+    replicationLag?: false | {
+        max?: string | undefined;
+        wait?: string | undefined;
+    } | undefined;
+    lockTimeoutMs?: number | undefined;
+    statementTimeoutMs?: number | undefined;
+    stack?: string | undefined;
+    ownershipEnv?: string | undefined;
+    cwd?: string | undefined;
+}, {
+    state: "done" | "migrate" | "switched";
+    dropped: boolean;
+    oldColumn?: string | undefined;
+    retainUntil?: string | undefined;
+}>;
+export declare const postgresMigrationCompensateContract: import("@intentius/chant/op").ActivityContract<{
+    table: string;
+    column: string;
+    buildPath: string;
+    environment?: string | undefined;
+    using?: string | undefined;
+    retain?: string | undefined;
+    batchSize?: number | undefined;
+    replicationLag?: false | {
+        max?: string | undefined;
+        wait?: string | undefined;
+    } | undefined;
+    lockTimeoutMs?: number | undefined;
+    statementTimeoutMs?: number | undefined;
+    stack?: string | undefined;
+    ownershipEnv?: string | undefined;
+    cwd?: string | undefined;
+}, {
+    dropped: string[];
+}>;
+//# sourceMappingURL=activity-contracts.d.ts.map

package/dist/op/activity-contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity-contracts.d.ts","sourceRoot":"","sources":["../../src/op/activity-contracts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AA2BH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;EAKzC,CAAC;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;EAK3C,CAAC;AAEF,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;EAK9C,CAAC;AAEF,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;EAK7C,CAAC;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAY3C,CAAC;AAEF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;EAKzC,CAAC;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;EAK3C,CAAC;AAEF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;EAKzC,CAAC;AAEF,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;EAK/C,CAAC;AAuBF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;EAKzC,CAAC;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;EAK3C,CAAC;AAEF,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;EAK9C,CAAC;AAEF,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;EAK7C,CAAC;AAEF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;EAK1C,CAAC;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;EAc3C,CAAC;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;EAK3C,CAAC;AAEF,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;EAK3C,CAAC;AAEF,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;EAK7C,CAAC;AAEF,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;EAK/C,CAAC"}

package/dist/package-cli.d.ts

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

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

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

package/dist/plugin.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The sql lexicon plugin.
+ *
+ * One lexicon, a subpath per database dialect (#3047, "Packaging"): ClickHouse
+ * at `@intentius/chant-lexicon-sql/clickhouse`, Postgres at
+ * `@intentius/chant-lexicon-sql/postgres` (#3289). Generation reads
+ * the pinned ClickHouse server's catalog (src/spec/), and the rest of the
+ * plugin is the shared machinery every dialect plugs into.
+ */
+import type { LexiconPlugin } from "@intentius/chant/lexicon";
+export declare const sqlPlugin: LexiconPlugin;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAgB,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAwB5E,eAAO,MAAM,SAAS,EAAE,aA+MvB,CAAC"}

package/dist/postgres/apply/apply.d.ts

@@ -0,0 +1,163 @@
+/**
+ * The Postgres applier (#3280): make a server hold what a build declares, for
+ * every change the classifier (`../plan/rules.ts`) does not refuse, and
+ * refuse the rest.
+ *
+ * Per declared object, exactly one verdict (lexicon-authoring/applying.mdx):
+ *
+ * - APPLIED `created`: absent on the server; created from its declared
+ *   statements, with chant's ownership marker set by `COMMENT ON`.
+ * - APPLIED `updated`: present, and the statements for its changes ran and
+ *   committed.
+ * - APPLIED `unchanged`: present, nothing to change, the marker in place.
+ * - NOT-ATTEMPTED `unsupported-kind`: a change only expand and contract
+ *   makes (a column rename, a type change across kinds, a NOT NULL column
+ *   with no default), or one with no in-place statement. Nothing is sent for
+ *   the object; the detail names each rule, the restriction and the
+ *   expand-and-contract migration Op (#3281).
+ * - NOT-ATTEMPTED `filtered`: the change drops a column, which destroys its
+ *   data, and the apply was not allowed to delete; or another tool keeps the
+ *   object (an ORM's revision table, a managed provider's schema).
+ * - NOT-ATTEMPTED `dependency-failed`: an object it references is not on the
+ *   server, or its statements ran in a transaction that rolled back because
+ *   another object's statement failed. The detail names that statement.
+ * - NOT-ATTEMPTED with the binding's reason: no server to apply to.
+ *
+ * A statement the server refuses fails its object, which was attempted and
+ * did not converge. Its transaction rolls back, the rest of the apply goes on,
+ * and the applier then throws {@link PostgresApplyError}, which carries the
+ * outcome so far.
+ *
+ * ## Transactions
+ *
+ * Statements run in the build's order, each object's in the order its
+ * changes need, and are grouped:
+ *
+ * 1. Consecutive statements that change only the catalog (create, metadata,
+ *    drop) share one transaction, across objects, so they land together or
+ *    not at all.
+ * 2. A statement that reads or rewrites a table's rows (an `ACCESS
+ *    EXCLUSIVE` rewrite or scan, a validation, a non-concurrent index build)
+ *    runs in a transaction of its own object, so a long scan holds locks on
+ *    that one table and the changes before it have committed.
+ * 3. A statement that refuses a transaction block (`CREATE INDEX
+ *    CONCURRENTLY`, `DROP INDEX CONCURRENTLY`) runs alone, outside any
+ *    transaction, and so does `ALTER TYPE ... ADD VALUE`, whose new label
+ *    cannot be used in the transaction that adds it.
+ *
+ * ## Timeouts
+ *
+ * Every statement runs with its own `lock_timeout` and `statement_timeout`
+ * (`SET LOCAL` in a transaction, `SET` before one outside), so a statement
+ * blocked behind another session's lock fails fast instead of queueing every
+ * query behind it. Defaults: a lock is waited for 5 s; a catalog-only
+ * statement may run 60 s; a statement that reads or rewrites rows has no
+ * limit. `sql.profiles.<env>` sets them (`lockTimeoutMs`,
+ * `statementTimeoutMs`, `scanTimeoutMs`), and the outcome records the values
+ * each statement ran with.
+ *
+ * ## Prune
+ *
+ * When asked for, prune drops the objects in the declared schemas that the
+ * build no longer declares and whose comment carries this project's marker
+ * (stack and env): views first, schemas last, never `CASCADE`, so an object
+ * something else still depends on is kept and reported. An object without
+ * the marker is not chant's and is never touched; one another tool keeps is
+ * never read as an orphan at all.
+ */
+import type { OwnershipMarker } from "@intentius/chant/ownership";
+import type { ApplyRef } from "@intentius/chant/apply";
+import { SqlApplyError, type SqlApplyOutcome } from "../../core/apply.js";
+import { type PostgresClient } from "../live/client.js";
+import type { PostgresTarget } from "../live/bind.js";
+import type { readLiveSchema } from "../live/catalog.js";
+import type { serverNormalized } from "../plan/server-normalize.js";
+import type { PgChangeClass } from "../plan/rules.js";
+import type { CanonicalKind } from "../plan/normalize.js";
+import { type DeclaredPgObject } from "./statements.js";
+/** The timeouts a statement runs with, in milliseconds; 0 is no limit. */
+export interface PostgresApplyTimeouts {
+    /** `lock_timeout` for every statement. */
+    lockTimeoutMs: number;
+    /** `statement_timeout` for a statement that changes only the catalog. */
+    statementTimeoutMs: number;
+    /** `statement_timeout` for a statement that reads or rewrites rows. */
+    scanTimeoutMs: number;
+}
+export declare const DEFAULT_POSTGRES_APPLY_TIMEOUTS: PostgresApplyTimeouts;
+/** One statement as it ran: its object, the timeouts it ran with, and the transaction it was in. */
+export interface RanStatement {
+    /** The object it was for, as an apply result names it. */
+    object: string;
+    sql: string;
+    class: PgChangeClass;
+    lockTimeoutMs: number;
+    statementTimeoutMs: number;
+    /** The transaction's number in {@link PostgresApplyOutcome.transactions}, or undefined for a statement run outside one. */
+    transaction?: number;
+}
+/** A transaction as it ended. */
+export interface TransactionRecord {
+    /** The objects with statements in it. */
+    objects: string[];
+    result: "committed" | "rolled-back";
+    /** The statement that failed it, and the server's message. */
+    failedAt?: {
+        sql: string;
+        error: string;
+    };
+}
+/**
+ * The shared core's outcome, with what a Postgres apply adds: the timeouts it
+ * ran with, every statement it sent in order, and how each transaction ended.
+ * `target` is the server's URL (no password), `source` where the binding came
+ * from.
+ */
+export interface PostgresApplyOutcome extends SqlApplyOutcome {
+    timeouts: PostgresApplyTimeouts;
+    statements: RanStatement[];
+    transactions: TransactionRecord[];
+}
+/** An apply in which the server refused a statement. The outcome says what did and did not happen. */
+export declare class PostgresApplyError extends SqlApplyError<PostgresApplyOutcome> {
+    constructor(outcome: PostgresApplyOutcome);
+}
+/** The name an apply result gives an object: `schema.name`, or a schema's or extension's own name. */
+export declare const refName: (o: {
+    kind: CanonicalKind;
+    schema?: string;
+    name: string;
+}) => string;
+/**
+ * The objects a Postgres `chant build` output declares, in creation order,
+ * each parsed with its tag and in canonical form. Takes the sql lexicon's
+ * primary output, or a multi-lexicon output holding it under `sql`.
+ */
+export declare function declaredObjects(json: string, defaultSchema?: string): DeclaredPgObject[];
+/** The plan axis: one ref per declared object, by its type and its name on the server. */
+export declare const planRefs: (declared: readonly DeclaredPgObject[]) => ApplyRef[];
+export interface PostgresApplyOptions {
+    /** The marker to stamp, and the identity a prune matches. Without a stack, prune declines. */
+    marker?: OwnershipMarker;
+    /** Drop owned objects the build no longer declares, and allow column drops. Default: off. */
+    prune?: boolean;
+    /** The timeouts; each one left out is the target's (`sql.profiles.<env>`), else the default. */
+    timeouts?: Partial<PostgresApplyTimeouts>;
+    /** The server's major (`sql.postgresMajor`); the newest pinned one when omitted. */
+    major?: number;
+    signal?: AbortSignal;
+    /** Where to report each statement. Default: nowhere. */
+    log?: (line: string) => void;
+    /** Read the server's schema with this instead of the catalog reader (tests). */
+    readLive?: typeof readLiveSchema;
+    /** Ask the server about expressions with this instead (tests). */
+    serverNormalize?: typeof serverNormalized;
+}
+/**
+ * Apply the declarations to the server `client` is connected to. Returns
+ * every declared object in exactly one of applied or not attempted, and every
+ * pruned orphan; throws {@link PostgresApplyError} when the server refused a
+ * statement. The client is left open; the caller ends it.
+ */
+export declare function applyPostgres(client: PostgresClient, target: PostgresTarget, declared: readonly DeclaredPgObject[], opts?: PostgresApplyOptions): Promise<PostgresApplyOutcome>;
+//# sourceMappingURL=apply.d.ts.map

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

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