@voltro/database 0.83.1 → 0.85.0

package/dist/sql.d.ts

@@ -1,12 +1,13 @@
-import { ConfigError } from 'effect';
+import { Config } from 'effect';
+import { Connection } from 'effect/sql/SqlConnection';
 import { Effect } from 'effect';
-import { Fragment } from '@effect/sql/Statement';
+import { Fragment } from 'effect/sql/Statement';
 import { Layer } from 'effect';
 import { Schema } from 'effect';
-import { SqlClient } from '@effect/sql';
-import { SqlError } from '@effect/sql/SqlError';
-import { SqlError as SqlError_2 } from '@effect/sql';
-import { Statement } from '@effect/sql';
+import { SqlClient } from 'effect/sql';
+import { SqlError } from 'effect/sql/SqlError';
+import { SqlError as SqlError_2 } from 'effect/sql';
+import { Statement } from 'effect/sql';
 
 /** Every hash this source may have been recorded under: its own, and the body
  *  before each framework edit in {@link FRAMEWORK_MIGRATION_EDITS}. */
@@ -719,6 +720,10 @@ export declare const chunkTables: <T>(xs: ReadonlyArray<T>, n: number) => T[][];
  */
 export declare const classifyRollingDeploySafety: (op: MigrationOperation, context?: RollingDeployContext) => RollingDeploySafety;
 
+/** Explicit finalization removes verified retained artifacts, never the receipt.
+ * Finalizing a published conversion permanently closes its rollback window. */
+export declare const cleanupSqliteDecimalPublication: (sql: SqlClient.SqlClient, request: SqliteRetainedSourceRequest, target: TableSnapshot, triggers?: ReadonlyArray<SqliteDecimalTargetTrigger>) => Effect.Effect<void, SqlError>;
+
 /**
  * Every resume-ledger row, gone — for a caller that has just UNDONE the run
  * the rows describe. A ledger that outlives the work it recorded would make
@@ -805,7 +810,8 @@ declare interface ColumnDefinition<TsType, Type extends ColumnType = ColumnType,
      */
     readonly fkAutoIndex?: boolean;
     /**
-     * This id-shaped scalar names something outside the local relational graph.
+     * This id-shaped scalar deliberately has no single foreign key target,
+     * including external-system ids and local polymorphic targets.
      * Set by `.externalId()` so schema audits do not guess a local FK from the
      * column name. Metadata only; it emits no constraint or DDL.
      */
@@ -964,6 +970,14 @@ declare interface ColumnDefinition<TsType, Type extends ColumnType = ColumnType,
      * column is just `bytes` with server-merge semantics.
      */
     readonly crdtManaged?: boolean;
+    /**
+     * End-to-end-sealed CRDT marker, set by `crdtSealed()`. The column holds an
+     * append-only LOG of encrypted CRDT updates the server cannot read: the
+     * write path appends an incoming frame (or applies a client's snapshot
+     * frame) and never decodes or merges — clients holding the key do. Same
+     * `bytes` storage and zero DDL churn as `crdtManaged`.
+     */
+    readonly crdtSealed?: boolean;
     /**
      * Optimistic-concurrency marker, set by `.version()`.
      *
@@ -1021,6 +1035,7 @@ declare interface ColumnDefinition<TsType, Type extends ColumnType = ColumnType,
      * MUST be `<= precision`. See {@link ColumnDefinition.precision}.
      */
     readonly scale?: number;
+    /* Excluded from this release type: sqliteDecimalEncoding */
     /**
      * Vector dimensionality. Populated only when `type === 'vector'`.
      * The migration emitter uses it to size the column DDL —
@@ -1227,7 +1242,8 @@ declare interface ColumnDefinition_2<TsType, Type extends ColumnType_2 = ColumnT
      */
     readonly fkAutoIndex?: boolean;
     /**
-     * This id-shaped scalar names something outside the local relational graph.
+     * This id-shaped scalar deliberately has no single foreign key target,
+     * including external-system ids and local polymorphic targets.
      * Set by `.externalId()` so schema audits do not guess a local FK from the
      * column name. Metadata only; it emits no constraint or DDL.
      */
@@ -1386,6 +1402,14 @@ declare interface ColumnDefinition_2<TsType, Type extends ColumnType_2 = ColumnT
      * column is just `bytes` with server-merge semantics.
      */
     readonly crdtManaged?: boolean;
+    /**
+     * End-to-end-sealed CRDT marker, set by `crdtSealed()`. The column holds an
+     * append-only LOG of encrypted CRDT updates the server cannot read: the
+     * write path appends an incoming frame (or applies a client's snapshot
+     * frame) and never decodes or merges — clients holding the key do. Same
+     * `bytes` storage and zero DDL churn as `crdtManaged`.
+     */
+    readonly crdtSealed?: boolean;
     /**
      * Optimistic-concurrency marker, set by `.version()`.
      *
@@ -1443,6 +1467,7 @@ declare interface ColumnDefinition_2<TsType, Type extends ColumnType_2 = ColumnT
      * MUST be `<= precision`. See {@link ColumnDefinition.precision}.
      */
     readonly scale?: number;
+    /* Excluded from this release type: sqliteDecimalEncoding */
     /**
      * Vector dimensionality. Populated only when `type === 'vector'`.
      * The migration emitter uses it to size the column DDL —
@@ -1703,6 +1728,10 @@ export declare interface ColumnSnapshot {
      */
     readonly precision?: number;
     readonly scale?: number;
+    /** Physical SQLite-family exact-decimal representation. Absent on ordinary
+     * NUMERIC columns. The marker is observable schema state, not a DSL hint:
+     * changing it requires data conversion, never a plain SQL type cast. */
+    readonly sqliteDecimalEncoding?: 'sortable-v1';
     /**
      * Id-generation scheme for `type: 'id'` columns. Mirrors
      * `ColumnDefinition.idScheme.kind` so the applier can tell a numeric
@@ -2549,7 +2578,7 @@ declare type DialectId = 'postgres' | 'mysql' | 'mariadb' | 'mssql' | 'sqlite' |
  * Resolve the live dialect from the `SqlClient`.
  *
  * `sql.onDialectOrElse` collapses the six voltro dialects onto four driver
- * tokens: mysql+mariadb share `mysql` (one `@effect/sql-mysql2` client) and
+ * tokens: mysql+mariadb share `mysql` (one `effect/sql-mysql2` client) and
  * sqlite+turso share `sqlite`. That collapse is fine for every consumer here —
  * the paired dialects behave identically for everything this module decides.
  *
@@ -3116,7 +3145,7 @@ export declare interface FileMigration {
 export declare interface FileMigrationContext {
     /**
      * The escape hatch, and it asks for a reason. `raw('why')` returns the
-     * `@effect/sql` client — `sql.unsafe(...)`, `sql\`...\``,
+     * `effect/sql` client — `sql.unsafe(...)`, `sql\`...\``,
      * `sql.onDialectOrElse({...})` — for the one thing neither `store` nor
      * `schema` expresses. The reason is required (an empty one throws), it is
      * what `voltro doctor` lists beside every migration that reaches for raw
@@ -3315,6 +3344,12 @@ export declare const fingerprintSchema: (snapshot: SchemaSnapshot) => string;
 
 export declare const fnv1a64: (input: string) => bigint;
 
+/** Read identities and decimal observations before driver numeric conversion.
+ * Keys include storage type: text/blob use full hex (including NUL); numeric
+ * keys use the engine's SQL literal. Duplicate selected keys refuse conversion.
+ * This reads only; its caller owns exclusion and retained-artifact verification. */
+export declare const forEachSqliteDecimalSourcePage: <E, R>(connection: Pick<Connection, "executeUnprepared">, retained: string, keys: ReadonlyArray<string>, columns: ReadonlyArray<SqliteDecimalSourceColumn>, visit: (cells: ReadonlyArray<SqliteDecimalReviewedCell>) => Effect.Effect<void, E, R>) => Effect.Effect<void, SqlError | E, R>;
+
 /** The refusal a foreign claim produces — one sentence for both boot paths. */
 export declare const foreignOwnerMessage: (self: string, owner: string, claimedAt: string | undefined) => string;
 
@@ -3382,6 +3417,11 @@ export declare interface HeldMigrationLock {
     /** Release the lock and return its connection to the pool. Idempotent only
      *  in the sense that the dialect statements are; call it once. */
     readonly release: Effect.Effect<void, SqlError>;
+    /** The reserved connection holding the lock (none on sqlite). Idle between
+     *  its keep-alive touches, so work that needs a connection OTHER than its
+     *  transaction's — a visibility probe — reads through this one instead of
+     *  reserving a third: the migration's contract is two connections. */
+    readonly connection: Connection | undefined;
 }
 
 /**
@@ -3776,6 +3816,8 @@ export declare type MigrationAtomicity = 'plan-transactional' | 'per-operation';
 
 export declare const migrationAtomicityFor: (dialect: DialectId) => MigrationAtomicity;
 
+declare type MigrationBatch = (statements: ReadonlyArray<string>) => Effect.Effect<void, SqlError>;
+
 /**
  * The hash of a migration file's SOURCE, recorded beside its ledger row.
  *
@@ -3854,7 +3896,7 @@ export declare type MigrationModuleImporter = (file: string) => Promise<Record<s
  * `log` and the two probes the store can answer about its own shape
  * (`tableExists`, `columnExists`) work without one; each refusal names what to
  * do instead. Also raised at construction when what was handed in as `sql` is not
- * an `@effect/sql` client, or when a SQL-backed store arrives without the
+ * an `effect/sql` client, or when a SQL-backed store arrives without the
  * client it executes on — both are refused before a body can run rather
  * than surfacing as a TypeError from inside the first helper that touches
  * the client.
@@ -4675,6 +4717,10 @@ declare interface PredicateLeaf_2 {
     readonly path?: ReadonlyArray<string | number>;
 }
 
+/** Internal encoded stage. The reviewed target is bound into retained ownership;
+ * source publication and artifact cleanup remain separate operations. */
+export declare const prepareSqliteDecimalStage: (sql: SqlClient.SqlClient, request: SqliteRetainedSourceRequest, target: TableSnapshot) => Effect.Effect<SqliteDecimalStage, SqlError>;
+
 /** Read the complete eligible history, independent of the dashboard's recent
  * history limit. The token must be rechecked by squashMigrationPlans on write. */
 export declare const previewMigrationSquash: (options: Pick<SquashOptions, "before" | "fingerprint">) => Effect.Effect<MigrationSquashPreview, Error, SqlClient.SqlClient>;
@@ -4702,7 +4748,16 @@ export declare const previewMigrationSquash: (options: Pick<SquashOptions, "befo
  * Eager provisioning is the APP's move (call this from a seed/startup over its
  * own tenant table); the framework has no tenant registry to enumerate.
  */
-export declare const provisionTenantNamespace: (tables: ReadonlyArray<AnyTable>, namespace: string, sqlLayer: Layer.Layer<SqlClient.SqlClient, ConfigError.ConfigError | SqlError_2.SqlError, never>, dialect?: DialectId, options?: SchemaApplyOptions) => Promise<void>;
+export declare const provisionTenantNamespace: (tables: ReadonlyArray<AnyTable>, namespace: string, sqlLayer: Layer.Layer<SqlClient.SqlClient, Config.ConfigError | SqlError_2.SqlError, never>, dialect?: DialectId, options?: SchemaApplyOptions) => Promise<void>;
+
+/** Internal offline publication. Receipt and published image share the same
+ * commit as table replacement. Retry verifies receipt/schema/retained artifacts
+ * without requiring live rows to remain unchanged after successful publication. */
+export declare const publishSqliteDecimalStage: (sql: SqlClient.SqlClient, request: SqliteRetainedSourceRequest, target: TableSnapshot, triggers?: ReadonlyArray<SqliteDecimalTargetTrigger>) => Effect.Effect<{
+    readonly marker: string;
+    readonly image: string;
+    readonly sourceCopy: string;
+}, SqlError>;
 
 /**
  * The runtime-facing materialized query — a plain bag of strings the store and
@@ -5407,6 +5462,12 @@ export declare const reactiveTriggerRepairSql: (input: {
 
 export declare const readMigrationSnapshotCandidates: (sql: SqlClient.SqlClient, live: SchemaSnapshot) => Effect.Effect<ReadonlyArray<MigrationSnapshotCandidate>, SqlError>;
 
+/** Collect observations for callers that explicitly need a complete review.
+ * Retained-source validation consumes pages directly instead. */
+export declare const readSqliteDecimalSource: (connection: Pick<Connection, "executeUnprepared">, retained: string, keys: ReadonlyArray<string>, columns: ReadonlyArray<SqliteDecimalSourceColumn>) => Effect.Effect<ReadonlyArray<SqliteDecimalReviewedCell>, SqlError>;
+
+export declare const readSqliteTableSchema: (connection: Pick<Connection, "executeUnprepared">, table: string) => Effect.Effect<SqliteTableSchema, SqlError>;
+
 /** Every string column of a base table in the connected database. */
 export declare const readUndeclaredCharsetColumns: (sql: SqlClient.SqlClient) => Effect.Effect<ReadonlyArray<UndeclaredCharsetColumn>, SqlError>;
 
@@ -5462,6 +5523,8 @@ export declare const recordUpToDate: (sql: SqlClient.SqlClient, plan: MigrationP
     readonly source: string;
 }) => Effect.Effect<"recorded" | "already-current", never>;
 
+/* Excluded from this release type: registerSqliteMigrationBatch */
+
 /* Excluded from this release type: registerSqlPoolCapacity */
 
 export declare type RehearsalOutcome = 
@@ -5576,6 +5639,11 @@ export declare const rollbackFileBasedMigration: (sql: SqlClient.SqlClient, ctx:
     durationMs: number;
 }, unknown>;
 
+/** Restore original declared values only while the published rows are unchanged.
+ * The receipt changes in the same commit, so a retry preserves subsequent writes.
+ * Retained copies remain owned until a separate explicit cleanup. */
+export declare const rollbackSqliteDecimalPublication: (sql: SqlClient.SqlClient, request: SqliteRetainedSourceRequest, target: TableSnapshot, triggers?: ReadonlyArray<SqliteDecimalTargetTrigger>) => Effect.Effect<void, SqlError>;
+
 /**
  * What the plan already knows that a single operation does not: the tables it
  * creates. Optional — without it nothing is known to be new and every verdict
@@ -5715,7 +5783,7 @@ export declare interface RunFileBasedMigrationsCtx {
  * `voltro_isr_cache` so framework releases that grow new columns
  * don't crash old DBs at boot.
  */
-export declare const runFrameworkBootstrap: (tables: ReadonlyArray<AnyTable>, sqlLayer: Layer.Layer<SqlClient.SqlClient, ConfigError.ConfigError | SqlError_2.SqlError, never>, dialect?: DialectId, options?: SchemaApplyOptions) => Promise<void>;
+export declare const runFrameworkBootstrap: (tables: ReadonlyArray<AnyTable>, sqlLayer: Layer.Layer<SqlClient.SqlClient, Config.ConfigError | SqlError_2.SqlError, never>, dialect?: DialectId, options?: SchemaApplyOptions) => Promise<void>;
 
 /**
  * Run `applySchema` against a fresh SqlClient from the provided sqlLayer.
@@ -5725,7 +5793,7 @@ export declare const runFrameworkBootstrap: (tables: ReadonlyArray<AnyTable>, sq
  * `dialect` is passed through to the DDL emitter so SQL types + reactive
  * trigger emission match the underlying engine.
  */
-export declare const runMigrate: (tables: ReadonlyArray<AnyTable>, sqlLayer: Layer.Layer<SqlClient.SqlClient, ConfigError.ConfigError | SqlError_2.SqlError, never>, dialect?: DialectId, options?: SchemaApplyOptions) => Promise<void>;
+export declare const runMigrate: (tables: ReadonlyArray<AnyTable>, sqlLayer: Layer.Layer<SqlClient.SqlClient, Config.ConfigError | SqlError_2.SqlError, never>, dialect?: DialectId, options?: SchemaApplyOptions) => Promise<void>;
 
 /**
  * Execute ONE planned operation with the applier's own per-dialect
@@ -5779,6 +5847,11 @@ 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, SqlClient.SqlClient>) => Promise<A>;
 
+/** Execute one SQLite-family schema rewrite atomically. This is an operation
+ * boundary, not a transaction over the complete migration plan. Call outside
+ * existing transactions so FK enforcement can be changed before BEGIN. */
+export declare const runSqliteMigrationBatch: (sql: SqlClient.SqlClient, statements: ReadonlyArray<string>) => Effect.Effect<void, SqlError>;
+
 export declare const SCHEMA_OWNER_TABLE = "_voltro_schema_owner";
 
 /**
@@ -5987,6 +6060,8 @@ declare interface SpatialClause_2 {
     readonly order?: 'asc' | 'desc';
 }
 
+export declare const splitStatements: (sql: string) => ReadonlyArray<string>;
+
 /**
  * The `sql` template tag — captures a tagged-template literal into a
  * {@link RawSqlFragment} descriptor without binding it to any client.
@@ -6004,6 +6079,131 @@ declare interface SpatialClause_2 {
  */
 export declare const sql: (strings: TemplateStringsArray, ...values: ReadonlyArray<unknown>) => RawSqlFragment;
 
+/** Internal conversion input. NUMERIC affinity may already have rounded even
+ * integer-looking values. Its driver result is never an exact decimal source. */
+export declare type SqliteDecimalConversionSource = {
+    readonly kind: 'text';
+    readonly value: unknown;
+} | {
+    readonly kind: 'sortable-v1';
+    readonly value: unknown;
+    readonly shape: SqliteDecimalShape;
+} | {
+    readonly kind: 'numeric';
+    readonly value: unknown;
+    /** An explicit per-value decision, not an automatic String(number) cast.
+     * Supply an authoritative decimal or deliberately accept a rounded value.
+     * Acknowledging possible prior loss does not recover the original digits. */
+    readonly resolution?: {
+        readonly decimal: string;
+        readonly acknowledgePriorRounding: true;
+    };
+};
+
+declare interface SqliteDecimalDecision {
+    readonly rowIdentity: string;
+    readonly column: string;
+    readonly encoded: string | null;
+    readonly sourceIdentity: string;
+    readonly target: SqliteDecimalShape;
+}
+
+/** Canonical identity order shared by array reviews and streamed witnesses. */
+export declare const sqliteDecimalDecisionIdentity: (cell: Pick<SqliteDecimalDecision, "rowIdentity" | "column">) => string;
+
+/** Internal reviewed cell input. Row identities come from the retained source,
+ * not positional array indexes or driver-rounded numeric primary keys. */
+export declare interface SqliteDecimalReviewedCell {
+    readonly rowIdentity: string;
+    readonly column: string;
+    readonly source: SqliteDecimalConversionSource;
+    readonly target: SqliteDecimalShape;
+}
+
+/** Internal candidate storage codec. Not yet connected to DDL or store writes. */
+export declare interface SqliteDecimalShape {
+    readonly precision: number;
+    readonly scale: number;
+}
+
+export declare interface SqliteDecimalSourceColumn {
+    readonly name: string;
+    readonly source: 'text' | 'numeric' | {
+        readonly encoding: 'sortable-v1';
+        readonly shape: SqliteDecimalShape;
+    };
+    readonly target: SqliteDecimalShape;
+}
+
+export declare interface SqliteDecimalStage {
+    readonly stage: string;
+    readonly marker: string;
+    readonly sourceCopy: string;
+    readonly sourceMarker: string;
+    readonly sourceManifest: string;
+    readonly sourceContents: SqliteTableContents;
+    readonly sourceRowIdentity: SqliteRowIdentity;
+    readonly manifest: string;
+    readonly schema: SqliteTableSchema;
+    /** Captured before final source/stage validation. Publication must assert
+     * this epoch rather than recapturing it after validation has completed. */
+    readonly validationEpoch: number;
+    readonly indexes: ReadonlyArray<string>;
+}
+
+export declare interface SqliteDecimalTargetTrigger {
+    readonly name: string;
+    readonly sql: string;
+}
+
+/* Excluded from this release type: sqliteMigrationBatchStatements */
+
+/** Internal preparation input from an existing file migration. The caller owns
+ * offline exclusion; this is artifact metadata, not a second migration runner. */
+export declare interface SqliteRetainedSourceRequest {
+    readonly migrationId: string;
+    readonly source: string;
+    readonly targetIdentity: string;
+    readonly reviewedSchema: SqliteTableSchema;
+    readonly decimalReview?: {
+        readonly keys: ReadonlyArray<string>;
+        readonly columns: ReadonlyArray<SqliteDecimalSourceColumn>;
+        /** Repeatable input in unique canonical decision order; may stream from disk. */
+        readonly cells: Iterable<SqliteDecimalReviewedCell>;
+    };
+}
+
+/** Physical identity retained separately from declared row values. Integer
+ * identities and sequence watermarks never pass through JavaScript numbers. */
+declare interface SqliteRowIdentity {
+    readonly alias: string | null;
+    readonly columns: ReadonlyArray<string>;
+    readonly rowCount: number;
+    readonly digest: string;
+    readonly sequence: string | null;
+    readonly autoincrement: boolean;
+    readonly sequenceBackend: 'sqlite' | 'turso';
+}
+
+/** Internal multiset witness: includes storage classes and duplicate counts,
+ * with values formatted in SQL before the driver can narrow integer/real data.
+ * Independent of row order; not a lock or protection against a forged manifest. */
+declare interface SqliteTableContents {
+    readonly columns: ReadonlyArray<string>;
+    readonly digest: string;
+}
+
+/** Internal, serializable schema witness for one ordinary main-schema table.
+ * SQL is retained exactly: even semantically equivalent DDL changes require a
+ * new review. This is neither artifact ownership nor a writer exclusion lock. */
+export declare interface SqliteTableSchema {
+    readonly objects: ReadonlyArray<{
+        readonly type: string;
+        readonly name: string;
+        readonly sql: string | null;
+    }>;
+}
+
 /* Excluded from this release type: sqlPoolCapacity */
 
 /**
@@ -6169,10 +6369,9 @@ declare interface Table<Name extends string, Fields extends Record<string, Colum
     /**
      * The plugin references DECLARED on this table, surviving `table()`.
      *
-     * `pluginRefSpecOf` reads a column BUILDER, and materialisation replaces it
-     * with a plain field descriptor — so without this the declaration is
-     * unreadable the moment the table exists, and any tool deriving structure
-     * from the schema sees an ordinary `text()` column.
+     * Derived from column metadata on every table rebuild, including columns
+     * contributed by mixins. Consumers can inspect these rules without knowing
+     * the private metadata on each materialized scalar definition.
      */
     readonly appliedPluginRefs?: ReadonlyArray<{
         readonly column: string;
@@ -6219,7 +6418,7 @@ declare interface Table<Name extends string, Fields extends Record<string, Colum
      * BEFORE every INSERT. Populated by `.validate(schema)`. Set
      * per-table at table-construction time; immutable thereafter.
      */
-    readonly insertSchema?: Schema.Schema.Any;
+    readonly insertSchema?: Schema.Top;
     /**
      * Optional `effect/Schema` the framework decodes a patch against
      * BEFORE every UPDATE. Populated by `.validatePatch(schema)`. The
@@ -6228,7 +6427,7 @@ declare interface Table<Name extends string, Fields extends Record<string, Colum
      * are checked. Set per-table at table-construction time; immutable
      * thereafter.
      */
-    readonly validatePatchSchema?: Schema.Schema.Any;
+    readonly validatePatchSchema?: Schema.Top;
     with: <const Mixins extends ReadonlyArray<AnyMixin>>(...mixins: Mixins) => Table<Name, Fields & MergeMixinFields<Mixins>, Reactive, IxNames>;
     /**
      * Attach an effect/Schema that validates EVERY insert against the
@@ -6256,7 +6455,7 @@ declare interface Table<Name extends string, Fields extends Record<string, Colum
      * `id` and `createdAt` are already filled in by the time the
      * decoder sees the row.
      */
-    validate: <S extends Schema.Schema.Any>(schema: S) => Table<Name, Fields, Reactive, IxNames>;
+    validate: <S extends Schema.Top>(schema: S) => Table<Name, Fields, Reactive, IxNames>;
     /**
      * Attach an effect/Schema that validates UPDATE patches against the
      * table. The framework wraps the schema in `Schema.partial`, so a
@@ -6287,7 +6486,7 @@ declare interface Table<Name extends string, Fields extends Record<string, Colum
      * wrapping is applied for you, so don't pre-wrap fields in
      * `Schema.optional`.
      */
-    validatePatch: <S extends Schema.Schema.Any>(schema: S) => Table<Name, Fields, Reactive, IxNames>;
+    validatePatch: <S extends Schema.Struct<Schema.Struct.Fields>>(schema: S) => Table<Name, Fields, Reactive, IxNames>;
     /**
      * Declare a (possibly composite) secondary index on the table.
      *
@@ -6905,6 +7104,11 @@ declare type VectorDistance = 'cosine' | 'l2' | 'inner';
  */
 declare type VectorDistance_2 = 'cosine' | 'l2' | 'inner';
 
+/** A matching recorded fingerprint cannot certify a partially converted table.
+ * Read physical markers before accepting a SQLite-family boot. No data or DDL
+ * is touched, and ordinary schemas do not incur per-table catalog queries. */
+export declare const verifySqliteDecimalStorage: (sql: SqlClient.SqlClient, declared: ReadonlyArray<TableLike>) => Effect.Effect<void, SqlError>;
+
 /**
  * A read-only SQL view descriptor. Structurally a `TableLike` (carries
  * `tableName` + `fields`) so the query builder + row decoder + by-name