@voltro/database 0.83.0 → 0.84.0

package/dist/sql.d.ts

@@ -1,4 +1,5 @@
 import { ConfigError } from 'effect';
+import { Connection } from '@effect/sql/SqlConnection';
 import { Effect } from 'effect';
 import { Fragment } from '@effect/sql/Statement';
 import { Layer } from 'effect';
@@ -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
@@ -964,6 +969,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 +1034,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 —
@@ -1386,6 +1400,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 +1465,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 +1726,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
@@ -3315,6 +3342,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;
 
@@ -3776,6 +3809,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.
  *
@@ -4675,6 +4710,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>;
@@ -4704,6 +4743,15 @@ export declare const previewMigrationSquash: (options: Pick<SquashOptions, "befo
  */
 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>;
 
+/** 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
  * the matcher consume.
@@ -5407,6 +5455,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 +5516,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 +5632,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
@@ -5779,6 +5840,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";
 
 /**
@@ -6004,6 +6070,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 */
 
 /**
@@ -6905,6 +7096,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