@voltro/database 0.79.1 → 0.81.0

package/dist/{replaceInProgress-BmSjNTp0.js → replaceInProgress-C_aXxOIX.js}

@@ -2132,7 +2132,13 @@ var Qt = (e, t, n) => $t(e, "id", t, n), $t = (e, t, n, r, i = "asc") => {
 	workflowRunId: p().nullable(),
 	createdAt: _().default("now"),
 	updatedAt: _().default("now").onUpdate("now")
-}).index(["lifecycle"]).index(["nextRunAt"]), Xr = I("_voltro_migration_plans", {
+}).index(["lifecycle"]).index(["nextRunAt"]), Xr = I("_voltro_schema_owner", {
+	id: f({ prefix: "own" }),
+	appName: p(),
+	projectName: p().nullable(),
+	frameworkVersion: p().nullable(),
+	claimedAt: _().default("now")
+}), Zr = I("_voltro_migration_plans", {
 	id: f({ prefix: "plan" }),
 	fingerprint: p(),
 	liveFingerprint: p().nullable(),
@@ -2148,14 +2154,14 @@ var Qt = (e, t, n) => $t(e, "id", t, n), $t = (e, t, n, r, i = "asc") => {
 	appliedAt: _().default("now"),
 	createdAt: _().default("now"),
 	updatedAt: _().default("now").onUpdate("now")
-}).index(["fingerprint"]).index(["environment"]), Zr = I("_voltro_idempotency", {
+}).index(["fingerprint"]).index(["environment"]), Qr = I("_voltro_idempotency", {
 	id: f({ prefix: "idem" }),
 	scope: p(),
 	key: p(),
 	status: p(),
 	response: v().nullable(),
 	createdAt: _().default("now")
-}).unique(["scope", "key"]).index(["createdAt"]), Qr = I("_voltro_devices", {
+}).unique(["scope", "key"]).index(["createdAt"]), $r = I("_voltro_devices", {
 	id: f({ prefix: "device" }),
 	tenantId: p(),
 	name: p(),
@@ -2175,20 +2181,20 @@ var Qt = (e, t, n) => $t(e, "id", t, n), $t = (e, t, n, r, i = "asc") => {
 	createdBy: p().nullable(),
 	metadata: v().nullable(),
 	createdAt: _()
-}).index(["tenantId"]).index(["pairingHash"]).index(["accessHash"]).index(["refreshHash"]).index(["previousRefreshHash"]), $r = I("_voltro_tenant_selections", {
+}).index(["tenantId"]).index(["pairingHash"]).index(["accessHash"]).index(["refreshHash"]).index(["previousRefreshHash"]), ei = I("_voltro_tenant_selections", {
 	id: f({ prefix: "tsel" }),
 	subjectType: p().maxLength(32),
 	subjectId: p(),
 	tenantId: p(),
 	selectedAt: _()
-}).primaryKey(["id"]).nonReactive(), ei = I("_voltro_kv", {
+}).primaryKey(["id"]).nonReactive(), ti = I("_voltro_kv", {
 	id: f({ prefix: "kv" }),
 	key: p().unique(),
 	value: p().nullable(),
 	expiresAt: _().nullable(),
 	createdAt: _().default("now"),
 	updatedAt: _().default("now").onUpdate("now")
-}).index(["expiresAt"]), ti = I("_voltro_api_keys", {
+}).index(["expiresAt"]), ni = I("_voltro_api_keys", {
 	id: f({ prefix: "apikey" }),
 	tenantId: p().nullable(),
 	name: p(),
@@ -2203,7 +2209,7 @@ var Qt = (e, t, n) => $t(e, "id", t, n), $t = (e, t, n, r, i = "asc") => {
 	onBehalfOf: p().nullable(),
 	metadata: v().nullable(),
 	createdAt: _().default("now")
-}).index("byApiKeyTenant", ["tenantId"]), ni = I("_voltro_replica_observations", {
+}).index("byApiKeyTenant", ["tenantId"]), ri = I("_voltro_replica_observations", {
 	id: f({ prefix: "robs" }),
 	replicaId: p().maxLength(191),
 	startedAt: _(),
@@ -2212,11 +2218,11 @@ var Qt = (e, t, n) => $t(e, "id", t, n), $t = (e, t, n, r, i = "asc") => {
 	payload: p().nullable(),
 	reachableAt: p().maxLength(255).nullable(),
 	writtenAt: _().default("now").onUpdate("now")
-}).unique(["replicaId", "kind"]).index(["kind"]), ri = [
+}).unique(["replicaId", "kind"]).index(["kind"]), ii = [
 	Jr,
 	Yr,
-	Xr
-], ii = "_voltro_replace_in_progress", ai = I(ii, {
+	Zr
+], ai = "_voltro_replace_in_progress", oi = I(ai, {
 	id: f({ prefix: "repl" }),
 	startedAt: _().default("now"),
 	kind: p().default("replace"),
@@ -2226,10 +2232,10 @@ var Qt = (e, t, n) => $t(e, "id", t, n), $t = (e, t, n, r, i = "asc") => {
 	staging: p().nullable(),
 	heartbeatAt: _().nullable(),
 	resumable: g().nullable()
-}), oi = 30, si = (e, t) => {
+}), si = 30, ci = (e, t) => {
 	let n = typeof t == "number" && Number.isFinite(t) && t > 0 ? t : 30, r = Number(e.VOLTRO_STAGING_STALE_MINUTES);
 	return (Number.isFinite(r) && r > 0 ? r : n) * 6e4;
-}, ci = (e) => e == null || String(e).length === 0 ? [] : String(e).split(",").map((e) => e.trim()).filter((e) => e.length > 0), li = (e) => {
+}, li = (e) => e == null || String(e).length === 0 ? [] : String(e).split(",").map((e) => e.trim()).filter((e) => e.length > 0), ui = (e) => {
 	let t = e.filter((e) => e.kind !== "staging");
 	if (t.length !== 0) return `refusing to start: a destructive data operation did not finish.
 ${t.map((e) => {
@@ -2244,7 +2250,7 @@ ${t.map((e) => {
 
   When the data is back, or you have decided the current state is correct, clear the marker:
       voltro data clear-replace-marker --yes`;
-}, ui = (e, t, n) => {
+}, di = (e, t, n) => {
 	let r = e.filter((e) => e.kind === "staging");
 	return {
 		all: r,
@@ -2254,7 +2260,7 @@ ${t.map((e) => {
 			return Number.isFinite(r) ? t - r >= n : !1;
 		})
 	};
-}, di = (e, t) => {
+}, fi = (e, t) => {
 	if (e.all.length === 0) return;
 	let n = new Set(e.droppable.map((e) => e.id));
 	return `staged data-import leftovers:
@@ -2265,4 +2271,4 @@ ${e.all.map((e) => {
   a reason to refuse the boot — it is a reason to know the disk is holding a copy of a bundle.`;
 };
 //#endregion
-export { qn as $, Ee as $n, Lt as $t, Dr as A, dt as An, ee as Ar, G as At, Tr as B, M as Bn, nn as Bt, Kr as C, L as Cn, m as Cr, On as Ct, qr as D, pt as Dn, te as Dr, Dn as Dt, Br as E, I as En, S as Er, En as Et, Pr as F, nt as Fn, _ as Fr, fn as Ft, xr as G, w as Gn, Mt as Gt, Cr as H, N as Hn, Ft as Ht, Mr as I, Ve as In, le as Ir, dn as It, nr as J, Re as Jn, Gt as Jt, br as K, Pe as Kn, Nt as Kt, Or as L, He as Ln, mn as Lt, jr as M, ct as Mn, oe as Mr, Sn as Mt, Nr as N, st as Nn, o as Nr, W as Nt, Wr as O, ut as On, me as Or, yn as Ot, Ar as P, at as Pn, p as Pr, un as Pt, Q, Ie as Qn, qt as Qt, kr as R, Ue as Rn, tn as Rt, Gr as S, bt as Sn, f as Sr, q as St, Hr as T, ft as Tn, v as Tr, K as Tt, Sr as U, T as Un, Yt as Ut, gr as V, A as Vn, an as Vt, _r as W, Oe as Wn, Rt as Wt, Zn as X, Te as Xn, Vt as Xt, Yn as Y, ze as Yn, Ht as Yt, Xn as Z, Fe as Zn, Kt as Zt, $r as _, Tt as _n, re as _r, rr as _t, di as a, Wt as an, ge as ar, Gn as at, Lr as b, St as bn, fe as br, $ as bt, si as c, Pt as cn, ue as cr, $n as ct, Zr as d, Bt as dn, y as dr, Wn as dt, It as en, be as er, zn as et, ei as f, Ot as fn, ae as fr, Bn as ft, Yr as g, jt as gn, ie as gr, sr as gt, ni as h, z as hn, b as hr, Kn as ht, li as i, Zt as in, _e as ir, Hn as it, wr as j, ot as jn, se as jr, Cn as jt, Fr as k, lt as kn, c as kr, vn as kt, ti as l, Jt as ln, ne as lr, ar as lt, Jr as m, Et as mn, s as mr, lr as mt, oi as n, $t as nn, ve as nr, cr as nt, ui as o, Xt as on, u as or, or as ot, Xr as p, At as pn, l as pr, ir as pt, Qn as q, Le as qn, en as qt, ai as r, Qt as rn, ye as rr, Vn as rt, ci as s, Ut as sn, x as sr, er as st, ii as t, B as tn, xe as tr, Z as tt, Qr as u, zt as un, g as ur, Un as ut, ri as v, Dt as vn, h as vr, tr as vt, Rr as w, mt as wn, de as wr, J as wt, zr as x, xt as xn, pe as xr, Y as xt, Ur as y, kt as yn, ce as yr, Jn as yt, Ir as z, j as zn, rn as zt };
+export { Q as $, Ie as $n, qt as $t, Fr as A, lt as An, c as Ar, vn as At, Ir as B, j as Bn, rn as Bt, Gr as C, bt as Cn, f as Cr, q as Ct, Br as D, I as Dn, S as Dr, En as Dt, Hr as E, ft as En, v as Er, K as Et, Ar as F, at as Fn, p as Fr, un as Ft, _r as G, Oe as Gn, Rt as Gt, gr as H, A as Hn, an as Ht, Pr as I, nt as In, _ as Ir, fn as It, Qn as J, Le as Jn, en as Jt, xr as K, w as Kn, Mt as Kt, Mr as L, Ve as Ln, le as Lr, dn as Lt, wr as M, ot as Mn, se as Mr, Cn as Mt, jr as N, ct as Nn, oe as Nr, Sn as Nt, qr as O, pt as On, te as Or, Dn as Ot, Nr as P, st as Pn, o as Pr, W as Pt, Xn as Q, Fe as Qn, Kt as Qt, Or as R, He as Rn, mn as Rt, zr as S, xt as Sn, pe as Sr, Y as St, Rr as T, mt as Tn, de as Tr, J as Tt, Cr as U, N as Un, Ft as Ut, Tr as V, M as Vn, nn as Vt, Sr as W, T as Wn, Yt as Wt, Yn as X, ze as Xn, Ht as Xt, nr as Y, Re as Yn, Gt as Yt, Zn as Z, Te as Zn, Vt as Zt, Yr as _, jt as _n, ie as _r, sr as _t, fi as a, Zt as an, _e as ar, Hn as at, Ur as b, kt as bn, ce as br, Jn as bt, ci as c, Ut as cn, x as cr, er as ct, Qr as d, zt as dn, g as dr, Un as dt, Lt as en, Ee as er, qn as et, ti as f, Bt as fn, y as fr, Wn as ft, Xr as g, z as gn, b as gr, Kn as gt, ri as h, Et as hn, s as hr, lr as ht, ui as i, Qt as in, ye as ir, Vn as it, Dr as j, dt as jn, ee as jr, G as jt, Wr as k, ut as kn, me as kr, yn as kt, ni as l, Pt as ln, ue as lr, $n as lt, Jr as m, At as mn, l as mr, ir as mt, si as n, B as nn, xe as nr, Z as nt, di as o, Wt as on, ge as or, Gn as ot, Zr as p, Ot as pn, ae as pr, Bn as pt, br as q, Pe as qn, Nt as qt, oi as r, $t as rn, ve as rr, cr as rt, li as s, Xt as sn, u as sr, or as st, ai as t, It as tn, be as tr, zn as tt, $r as u, Jt as un, ne as ur, ar as ut, ei as v, Tt as vn, re as vr, rr as vt, Kr as w, L as wn, m as wr, On as wt, Lr as x, St as xn, fe as xr, $ as xt, ii as y, Dt as yn, h as yr, tr as yt, kr as z, Ue as zn, tn as zt };

package/dist/sql.d.ts

@@ -320,6 +320,12 @@ export declare interface ApplyPlanCtx {
      * releases while `voltro dev`'s boot diff, which uses this parameter, did not.
      */
     readonly replan: (sql: SqlClient.SqlClient) => Effect.Effect<MigrationPlan, SqlError_2, SqlClient.SqlClient>;
+    /**
+     * The declared store charset — the one `replan` plans with. Here only for
+     * the resume ledger this creates before the first statement: nothing declares
+     * it, so without this it is created in the database default.
+     */
+    readonly charset?: MysqlCharset | undefined;
 }
 
 export declare const applySchema: (tables: ReadonlyArray<AnyTable>, dialect?: DialectId, 
@@ -330,6 +336,14 @@ export declare const applySchema: (tables: ReadonlyArray<AnyTable>, dialect?: Di
  *  raised nothing. */
 cdcChannel?: string, options?: SchemaApplyOptions) => Effect.Effect<void, never, SqlClient.SqlClient>;
 
+/**
+ * Run the work. No lock of its own — the caller holds the one that fits:
+ * `convergeUndeclaredCharset` the migration lock, the cluster gate its own.
+ * `.unprepared`, the text protocol, like every DDL statement a prepared
+ * protocol may refuse on one of the two engines.
+ */
+export declare const applyUndeclaredCharsetWork: (sql: SqlClient.SqlClient, work: UndeclaredCharsetWork) => Effect.Effect<void, SqlError_2>;
+
 /**
  * The OPT-IN refuse gate over the advisory. By default (`VOLTRO_ROLLING_DEPLOY`
  * unset) this never fires — the classifier stays a `db plan` advisory, because
@@ -609,6 +623,21 @@ export declare const charsetColumnsOf: (table: TableSnapshot) => ReadonlyArray<{
     readonly charset: string;
 }>;
 
+/**
+ * Check — and, when `mayWrite`, establish — which app owns this schema.
+ *
+ * With `mayWrite` the owner table is bootstrapped and an unclaimed schema is
+ * claimed for `claim.appName`. Two apps racing for an unclaimed database both
+ * try the INSERT; the loser's fails on the primary key and it re-reads, so
+ * exactly one of them owns it and the other is told so.
+ *
+ * Without `mayWrite` nothing is created or written: a missing table or row is
+ * `unclaimed`, and only an existing FOREIGN claim is reported.
+ */
+export declare const checkSchemaOwner: (sql: SqlClient.SqlClient, claim: SchemaOwnerClaim, options: {
+    readonly mayWrite: boolean;
+}) => Effect.Effect<SchemaOwnership, SqlError_2>;
+
 /** Partition into ≤`n`-sized chunks (disjoint, complete). Exported for the
  *  batching regression test — the introspection's correctness reduces to this
  *  producing a complete, non-overlapping partition of the table list. */
@@ -1504,6 +1533,28 @@ export declare type ColumnInput = {
     __definition(): ColumnDefinition<unknown>;
 } | ColumnDefinition<unknown>;
 
+/**
+ * A table's COLUMN-level CHECKs on MariaDB, by column — what a `MODIFY COLUMN`
+ * has to restate so that it keeps them.
+ *
+ * MariaDB records a CHECK written inline on a column (the bring-up path writes
+ * every enum CHECK that way) as part of the column definition
+ * (`check_constraints.level = 'Column'`, named after the column), and `MODIFY
+ * COLUMN` REDEFINES the column: a definition without the CHECK removes it.
+ * Measured on 11.8 — plain MODIFY: gone; MODIFY with the CHECK inline: kept,
+ * still column-level. A table-level CHECK (what `add-check` writes) survives
+ * either way, and MySQL has no column-level constraints in its catalog, so this
+ * is empty there.
+ *
+ * Without it every operation that renders MODIFY — a character-set conversion,
+ * a nullability or type change — removed the CHECK as a side effect, the re-plan
+ * proposed `add-check`, and the apply refused as "did not converge". A declared
+ * charset over a real schema produced 67 of them at once. The planner's own
+ * `drop-check` still removes a CHECK the declaration no longer has: it runs
+ * after the column changes and reads the catalog again.
+ */
+export declare const columnLevelChecksMysql: (sql: SqlClient.SqlClient, table: string) => Effect.Effect<ReadonlyMap<string, string>, SqlError_2>;
+
 /**
  * A column as seen by the planner: either declared in code (extracted
  * from `ColumnDefinition`) or live in the DB (extracted via introspection).
@@ -1764,6 +1815,17 @@ declare type ColumnType = 'id' | 'text' | 'integer' | 'real' | 'decimal' | 'bigi
 
 declare type ColumnType_2 = 'id' | 'text' | 'integer' | 'real' | 'decimal' | 'bigint' | 'boolean' | 'timestamp' | 'date' | 'json' | 'bytes' | 'reference' | 'vector' | 'enum' | 'array' | 'interval' | 'raw';
 
+/**
+ * Carry a `utf8mb4` declaration to the undeclared framework tables that
+ * already exist, under the migration lock. Idempotent: a second run reads a
+ * converged catalog and does nothing.
+ */
+export declare const convergeUndeclaredCharset: (sql: SqlClient.SqlClient, options: {
+    readonly declaredNames: ReadonlySet<string>;
+    readonly charset: MysqlCharset | undefined;
+    readonly lockSchema?: string | undefined;
+}) => Effect.Effect<UndeclaredCharsetWork, SqlError_2>;
+
 /** A live foreign key a charset conversion has to carry across the rewrite. */
 export declare interface ConvertCharsetForeignKey {
     /** Catalog name of the constraint. */
@@ -2393,6 +2455,9 @@ export declare const describeProbe: (probe: SchemaProbe) => string;
 /** One line per finding, for the CLI and the doctor. */
 export declare const describeStoreCharsetFinding: (f: StoreCharsetFinding) => string;
 
+/** The lines `db plan` prints and `db apply` logs — one per table. */
+export declare const describeUndeclaredCharsetWork: (w: UndeclaredCharsetWork) => ReadonlyArray<string>;
+
 /**
  * Parse `VOLTRO_DESTRUCTIVE_OK`.
  *
@@ -2746,7 +2811,7 @@ declare type EmptyMerge = unknown;
 export declare const engineFromVersion: (version: string) => MysqlEngine;
 
 /** The deploy ledger (`_voltro_deploys`) — same bootstrap, same reason: it has to exist before the first plan. */
-export declare const ensureDeployLedgerTable: (sql: SqlClient.SqlClient, dialect: DialectId) => Effect.Effect<void, SqlError_2>;
+export declare const ensureDeployLedgerTable: (sql: SqlClient.SqlClient, dialect: DialectId, charset?: MysqlCharset) => Effect.Effect<void, SqlError_2>;
 
 /**
  * Create `_voltro_migration_ops` if it isn't there yet.
@@ -2761,7 +2826,7 @@ export declare const ensureDeployLedgerTable: (sql: SqlClient.SqlClient, dialect
  * framework-table set because it has to exist before the FIRST plan — and the
  * first plan is the one that creates the framework tables.
  */
-export declare const ensureLedgerTable: (sql: SqlClient.SqlClient, dialect: DialectId) => Effect.Effect<void, SqlError_2>;
+export declare const ensureLedgerTable: (sql: SqlClient.SqlClient, dialect: DialectId, charset?: MysqlCharset) => Effect.Effect<void, SqlError_2>;
 
 /**
  * The PLAN ledger (`_voltro_migration_plans`) — same bootstrap, one caller.
@@ -2794,6 +2859,10 @@ export declare const ensurePlanLedgerTable: (sql: SqlClient.SqlClient, dialect:
  */
 export declare const ensureReplaceMarkerTable: (sql: SqlClient.SqlClient, dialect: DialectId) => Effect.Effect<void, SqlError_2>;
 
+/** The schema-owner row's table (`_voltro_schema_owner`) — bootstrapped so the
+ *  ownership check can run BEFORE the first plan, which is the plan it guards. */
+export declare const ensureSchemaOwnerTable: (sql: SqlClient.SqlClient, dialect: DialectId) => Effect.Effect<void, SqlError_2>;
+
 /** Exported for the same reason as {@link enumTypeBlocks}, and it MUST run
  *  before it — see that function's note on ordering. */
 export declare const enumRenameBlocks: (tables: ReadonlyArray<AnyTable>, dialect: DialectId) => string;
@@ -3144,6 +3213,9 @@ export declare const fingerprintSchema: (snapshot: SchemaSnapshot) => string;
 
 export declare const fnv1a64: (input: string) => bigint;
 
+/** The refusal a foreign claim produces — one sentence for both boot paths. */
+export declare const foreignOwnerMessage: (self: string, owner: string, claimedAt: string | undefined) => string;
+
 /** Human/PR-comment rendering. Markdown-free on purpose — the CI job that posts
  *  it to a PR wraps it, and a terminal reader gets the same text. */
 export declare const formatBranchRehearsal: (report: BranchRehearsalReport) => string;
@@ -3433,6 +3505,16 @@ export declare const isRawSqlFragment: (value: unknown) => value is RawSqlFragme
  */
 export declare const isReRunSafeDdl: (statement: string, dialect: DialectId) => boolean;
 
+/**
+ * The tables this step owns: created by the framework or its engines, not
+ * declared by the app. A soft-drop snapshot and a `--mode replace` staging copy
+ * are data the operator is handling, and `_cloud_*` / `__turso_internal_*`
+ * belong to another product and another engine.
+ */
+export declare const isUndeclaredCharsetTable: (name: string, declaredNames: ReadonlySet<string>) => boolean;
+
+export declare const isUndeclaredCharsetWorkEmpty: (w: UndeclaredCharsetWork) => boolean;
+
 /**
  * A json-path index entry, produced by {@link jsonIndex}. Unlike a plain
  * `{ expr }` (verbatim, dialect-specific) this carries the column + path
@@ -5114,6 +5196,9 @@ export declare const reactiveTriggerRepairSql: (input: {
     readonly channel?: string;
 }) => ReadonlyArray<string>;
 
+/** Every string column of a base table in the connected database. */
+export declare const readUndeclaredCharsetColumns: (sql: SqlClient.SqlClient) => Effect.Effect<ReadonlyArray<UndeclaredCharsetColumn>, SqlError_2>;
+
 /**
  * Record that a schema was applied even though there was nothing to DO.
  *
@@ -5463,6 +5548,8 @@ export declare const runSchemaOp: (sql: SqlClient.SqlClient, op: MigrationSchema
 /** Runs one Effect over the connection — the shape `ManagedRuntime.runPromise` and a store's `run` share. */
 export declare type RunSql = <A>(effect: Effect.Effect<A, SqlError_2, SqlClient.SqlClient>) => Promise<A>;
 
+export declare const SCHEMA_OWNER_TABLE = "_voltro_schema_owner";
+
 /**
  * Effect that applies the emitted DDL to the provided SqlClient. Splits
  * on `;` only outside dollar-quoted blocks (the postgres NOTIFY trigger
@@ -5507,6 +5594,34 @@ export declare interface SchemaEmitOptions {
 /** What a schema operation on the migration context found to do. */
 export declare type SchemaOpOutcome = 'applied' | 'already-absent' | 'already-present';
 
+/** Who is claiming the schema. */
+export declare interface SchemaOwnerClaim {
+    /** The app's `name` — the identity compared on every boot. */
+    readonly appName: string;
+    readonly projectName?: string;
+    readonly frameworkVersion?: string;
+}
+
+export declare type SchemaOwnership = 
+/** This app already owned the schema. */
+    {
+    readonly kind: 'owned';
+}
+/** Unclaimed until now; this app's claim was written. */
+| {
+    readonly kind: 'claimed';
+}
+/** ANOTHER app owns it — the boot must refuse. */
+| {
+    readonly kind: 'foreign';
+    readonly owner: string;
+    readonly claimedAt: string | undefined;
+}
+/** Read-only mode found no claim (or no table) to compare against. */
+| {
+    readonly kind: 'unclaimed';
+};
+
 /** A schema object a body asked about, in the vocabulary a user writes. */
 export declare type SchemaProbe = {
     readonly kind: 'table';
@@ -5645,6 +5760,8 @@ declare interface SpatialClause_2 {
  */
 export declare const sql: (strings: TemplateStringsArray, ...values: ReadonlyArray<unknown>) => RawSqlFragment;
 
+/* Excluded from this release type: sqlPoolCapacity */
+
 /**
  * Map a logical column type to its dialect-specific DDL keyword.
  *
@@ -6418,8 +6535,52 @@ export declare class TransactionBrokenByBodyError extends Error {
     constructor(migrationId: string, dialect: DialectId);
 }
 
+/**
+ * Hand the schema to a different app name — `voltro db claim`. The one
+ * deliberate way to change the owner: an app was RENAMED, not replaced.
+ */
+export declare const transferSchemaOwner: (sql: SqlClient.SqlClient, claim: SchemaOwnerClaim) => Effect.Effect<{
+    readonly previous: string | undefined;
+}, SqlError_2>;
+
 export declare const unblockLossy: (plan: MigrationPlan, scope?: ReturnType<typeof destructiveScope>) => MigrationPlan;
 
+/** One string column of an undeclared framework table, as the catalog reports it. */
+export declare interface UndeclaredCharsetColumn {
+    readonly table: string;
+    readonly column: string;
+    readonly charset: string;
+    /** `information_schema.columns.column_type`, e.g. `varchar(255)`, `text`. */
+    readonly columnType: string;
+    readonly nullable: boolean;
+    /** Raw `column_default`; `null` (or the text `NULL` on MariaDB) when there is none. */
+    readonly columnDefault: string | null;
+    readonly generated: boolean;
+}
+
+/**
+ * One `ALTER TABLE` per table of the work. `checks` is each table's
+ * column-level CHECKs (`columnLevelChecksMysql`): MariaDB stores such a CHECK
+ * in the column definition, and a MODIFY that does not restate it deletes it.
+ */
+export declare const undeclaredCharsetStatements: (w: UndeclaredCharsetWork, checks?: ReadonlyMap<string, ReadonlyMap<string, string>>) => ReadonlyArray<string>;
+
+export declare interface UndeclaredCharsetWork {
+    readonly tables: ReadonlyArray<{
+        readonly table: string;
+        readonly columns: ReadonlyArray<UndeclaredCharsetColumn>;
+    }>;
+    /** Columns that are off but carry a default or a generation expression — named, not rewritten. */
+    readonly left: ReadonlyArray<UndeclaredCharsetColumn>;
+}
+
+/**
+ * What a declaration asks of the undeclared framework tables. Pure, so `db
+ * plan` can print it and `db apply` can do it from the same reading. `only`
+ * narrows it to named tables — the ones the cluster gate has just created.
+ */
+export declare const undeclaredCharsetWork: (columns: ReadonlyArray<UndeclaredCharsetColumn>, declaredNames: ReadonlySet<string>, charset: MysqlCharset | undefined, only?: ReadonlySet<string>) => UndeclaredCharsetWork;
+
 /** Every deploy that did not finish — `running` (the process died) or `failed` (its undo did not complete). An absent table is an empty ledger. */
 export declare const unfinishedDeploys: (sql: SqlClient.SqlClient) => Effect.Effect<ReadonlyArray<DeployLedgerRow>, never>;