@voltro/database 0.70.0 → 0.71.1

package/dist/{frameworkLiveTables-CWbTSnjk.js → frameworkLiveTables-D53uncZH.js}

@@ -800,11 +800,11 @@ var me = () => new s({
 }, qe = (e) => e === "sqlite" || e === "turso", Je = (e) => e === "mysql" || e === "mariadb", R = (e, t) => {
 	switch (t) {
 		case "mysql":
-		case "mariadb": return `\`${e}\``;
-		case "mssql": return `[${e}]`;
+		case "mariadb": return `\`${e.replace(/`/g, "``")}\``;
+		case "mssql": return `[${e.replace(/\]/g, "]]")}]`;
 		case "postgres":
 		case "sqlite":
-		case "turso": return `"${e}"`;
+		case "turso": return `"${e.replace(/"/g, "\"\"")}"`;
 	}
 }, Ye = 1e4, z = Symbol.for("@voltro/database/tableRegistry"), B = globalThis, V = B[z] ?? (B[z] = /* @__PURE__ */ new Map()), H = (e) => {
 	let t = V.get(e.tableName);

package/dist/index.d.ts

@@ -1825,6 +1825,9 @@ export declare const columnsPerRow: (rows: ReadonlyArray<Record<string, unknown>
 
 export declare type ColumnType = 'id' | 'text' | 'integer' | 'real' | 'decimal' | 'bigint' | 'boolean' | 'timestamp' | 'date' | 'json' | 'bytes' | 'reference' | 'vector' | 'enum' | 'array' | 'interval' | 'raw';
 
+/** Exact comparison of fixed-point decimal strings, without a floating-point conversion. */
+export declare const compareDecimal: (left: unknown, right: unknown) => number | null;
+
 /**
  * Try to compile a `QueryDescriptor` with `eager` populated into a
  * single-roundtrip JSON-agg query for the given dialect.
@@ -2396,20 +2399,15 @@ export declare interface DataStore {
      * `insertIgnore`, plus the one thing it cannot report: whether the row was
      * INSERTED or already there.
      *
-     * On the ignore path `insertIgnore` returns the existing row, which looks
-     * exactly like a freshly inserted one — so a loop that plants missing rows
-     * counts every row it visited as planted, unless it reads the destination
-     * first. Same shape and same answer as `upsertWithOutcome`: the wrapper
-     * mints the id before the statement, the ignore path hands back the EXISTING
-     * row's id, and two ids that differ are the answer. Where that comparison
-     * cannot decide (the caller supplied the id, or the id is database-assigned)
-     * the destination is read first, so `'inserted'` is exact, never a guess.
-     *
-     * Optional and wrapper-provided for the same reason as `upsertWithOutcome`:
-     * present on `ctx.store`, not required of a hand-written `DataStore`. The
-     * typed helper is `insertIgnoreRowOutcome`.
+     * The store's actual insert decision supplies the outcome, including for
+     * caller-supplied and database-generated IDs. A pre-read or comparison of
+     * IDs cannot establish which concurrent caller inserted. Every raw store,
+     * namespace view and transaction view implements this method; wrappers
+     * preserve its outcome while encoding/decoding the row. Inside a transaction
+     * the result is provisional until commit. The typed helper is
+     * `insertIgnoreRowOutcome`.
      */
-    insertIgnoreWithOutcome?(table: string, row: Row, options: {
+    insertIgnoreWithOutcome(table: string, row: Row, options: {
         conflictColumns: ReadonlyArray<string>;
     }): Promise<InsertIgnoreResult>;
     /**
@@ -2417,7 +2415,8 @@ export declare interface DataStore {
      * made via `work`'s store reference (passed as argument) are:
      *
      *   - atomic — the dialect's native BEGIN/COMMIT/ROLLBACK wraps the
-     *     writes; the memory store serialises trivially.
+     *     writes; memory validates snapshot read/write-table revisions before
+     *     committing and retries conflicting attempts with a fresh snapshot.
      *   - delta-deferred — ChangeEvents queue inside the transaction and
      *     are emitted ONLY after a successful commit. A throw triggers
      *     rollback AND drops every queued event so no subscriber ever
@@ -2425,6 +2424,10 @@ export declare interface DataStore {
      *
      * Reads (`query()`) inside the transaction see the in-flight write
      * set (read-your-own-writes within the transaction).
+     * Transient contention can replay the whole callback (at most four attempts,
+     * exponential delay starting at 10 ms). Do not perform external side effects
+     * in the callback. Memory validation is table-granular and process-local;
+     * `forUpdate` does not acquire a blocking row lock there.
      *
      * `transactional()` MUST NOT be nested — nested invocations throw to
      * surface design mistakes (transactions are atomic units, not
@@ -3388,7 +3391,7 @@ declare type EmptyMerge = unknown;
 export declare const encodeFieldValue: (cipher: FieldCipher, value: unknown, binding?: FieldBinding) => string;
 
 /**
- * Serialize a row's json()/array() cells to JSON strings so they can be
+ * Serialize selected json()/array()/vector() cells to JSON strings so they can be
  * bound as scalar SQL parameters. Symmetric to `decodeRowsFromSchema`.
  * No-op for tables with no json/array columns (cost: one map build +
  * a per-cell type lookup). Unknown tables pass through unchanged.
@@ -3458,7 +3461,9 @@ export declare const eq: <RowOf = Record<string, unknown>, K extends keyof RowOf
  *  explicit `ESCAPE '\'` clause at the call site. */
 export declare const escapeLike: (value: string) => string;
 
-export declare const evaluatePredicate: (predicate: Predicate, row: Row | null, subqueries?: SubqueryResults | null) => boolean;
+export declare const evaluatePredicate: (predicate: Predicate, row: Row | null, subqueries?: SubqueryResults | null, columns?: Readonly<Record<string, {
+    readonly type: string;
+}>>) => boolean;
 
 /** `EXCEPT` — rows in the FIRST input not present in any subsequent input. */
 export declare const except: (...queries: ReadonlyArray<QueryWithDescriptorAny>) => Query<Row, string>;
@@ -4023,14 +4028,14 @@ export declare interface IndexKindOptions {
          *   - `'inner'`  → `vector_ip_ops` (negative inner product)
          * The opclass MUST match the metric the query orders by, or the
          * index can't accelerate the search. Set `opclass` directly only to
-         * override the mapping (e.g. `halfvec_cosine_ops`).
+         * override the mapping. Half-precision columns select `halfvec_*` automatically.
          */
         readonly distance?: VectorDistance;
         /**
          * pgvector opclass token spliced into `USING hnsw (col <opclass>)`.
-         * When unset, derived from `distance` (default `vector_cosine_ops`).
-         * Set explicitly to override (e.g. `'halfvec_cosine_ops'` for a
-         * `vector(n, { precision: 'half' })` column).
+         * When unset, derived from `distance` and the column's precision
+         * (default `vector_cosine_ops`, or `halfvec_cosine_ops` for half precision).
+         * An explicit override is an unquoted, optionally schema-qualified identifier.
          */
         readonly opclass?: string;
     };
@@ -4103,19 +4108,16 @@ export declare interface InsertIgnoreResult {
  * `insertIgnore`, plus whether the row was INSERTED or was already there.
  *
  * `insertIgnore` returns the existing row on the ignore path, and that row is
- * indistinguishable from one it just wrote — so a loop that plants missing
- * rows reports every row it visited as planted unless it reads first. The
- * store knows the answer the same way `upsertRowOutcome` does: the id it
- * minted before the statement is not the id the ignore path hands back.
+ * indistinguishable from one it just wrote. The native store's insert
+ * decision supplies the outcome; wrappers preserve it without a pre-read.
  *
  *     const { row, outcome } = await insertIgnoreRowOutcome(ctx.store, actors, actor, {
  *       conflictColumns: ['id'],
  *     })
  *     if (outcome === 'inserted') planted++
  *
- * `'inserted'` is never a stand-in for "could not tell". Where the id cannot
- * decide it — the caller supplied one, or the table's id is database-assigned
- * — the store reads the destination first and answers exactly.
+ * Caller-supplied and database-assigned IDs obey the same contract. Inside
+ * a transaction the decision becomes durable only when that transaction commits.
  */
 export declare const insertIgnoreRowOutcome: <T extends AnyTable>(store: TypedInsertIgnoreOutcomeStore, table: T, row: InferInsertRow<T>, options: {
     readonly conflictColumns: ReadonlyArray<keyof InferRow<T> & string>;
@@ -6064,9 +6066,8 @@ declare interface QueryWithDescriptorAny {
  *                         in ANSI_QUOTES mode)
  *   - mssql:              `[name]` (T-SQL bracketed identifier)
  *
- * Identifier names in the schema DSL are restricted to
- * `[a-zA-Z][a-zA-Z0-9_]*`, so the inner quote character never needs
- * escaping — but the dialect MUST match the engine to avoid syntax errors.
+ * Catalog-derived identifiers can contain quote characters even when the
+ * schema DSL restricts its own names. Escape them at this shared boundary.
  */
 export declare const quoteIdent: (name: string, dialect: DialectId) => string;
 
@@ -8197,6 +8198,9 @@ export declare interface TransactionalViewHandle {
  */
 export declare type TransactionConnectionContext = Context.Tag.Service<typeof TransactionConnection>;
 
+/** Shared bounded contention policy, including stores without a SQL connection. */
+export declare const transactionRetrySchedule: (isRetryable: (error: unknown) => boolean) => Schedule.Schedule<number, unknown, never>;
+
 /** Turso's MVCC conflicts arrive as messages, not codes. */
 export declare const TURSO_TRANSIENT_MESSAGE: RegExp;
 
@@ -8222,7 +8226,7 @@ export declare interface TxnRecorderPort {
 
 /** The minimal store surface `insertIgnoreRowOutcome` needs. */
 export declare interface TypedInsertIgnoreOutcomeStore {
-    readonly insertIgnoreWithOutcome?: (table: string, row: Row, options: {
+    readonly insertIgnoreWithOutcome: (table: string, row: Row, options: {
         readonly conflictColumns: ReadonlyArray<string>;
     }) => Promise<{
         readonly row: Row;