@bitcobblers/wod-wiki-storage 0.35.2129 → 0.36.2133

package/dist/sql/index.d.cts

@@ -1,5 +1,7 @@
-import { Client } from '@libsql/client';
+import { S as SqlConnection, D as Database } from '../connection-DxuCLpRc.cjs';
+export { L as LibsqlClient, a as SqlRow, b as SqlStatement, c as SqlValue, l as libsqlDatabase } from '../connection-DxuCLpRc.cjs';
 import { a as StoreDef, R as RangeDTO, K as KeyDTO, e as DomainQueryResult, T as TxOp, I as IStorage, S as StoreName, b as IReadOnlyStore, c as StoreType, d as IReadWriteStore, D as DomainQuery, f as IStorageTransaction } from '../wire-CiFcjo6_.cjs';
+import '@libsql/client';
 import '@bitcobblers/wod-wiki-core';
 import '@bitcobblers/wod-wiki-lang';
 
@@ -15,41 +17,6 @@ declare class StorageError extends Error {
     constructor(status: number, message: string, code?: string | undefined);
 }
 
-/**
- * Connection contracts + a generic libsql adapter. The adapter takes a
- * *structural* client so the browser passes @libsql/client/web and the server
- * passes @libsql/client (node) — this module never imports either, keeping
- * the browser graph free of native drivers.
- *
- * All operations are serialized through one promise chain: the underlying
- * client shares a single connection, so concurrent transactions/reads could
- * otherwise interleave on it. Transactions run on a transaction-owned
- * connection (libsql interactive transaction), so writes inside a transaction
- * commit or roll back atomically and are not visible outside it.
- */
-
-type SqlValue = string | number | null;
-type SqlRow = Record<string, unknown>;
-interface SqlStatement {
-    sql: string;
-    params?: SqlValue[];
-}
-interface SqlConnection {
-    query(sql: string, params?: SqlValue[]): Promise<SqlRow[]>;
-    exec(sql: string, params?: SqlValue[]): Promise<void>;
-    batch?(statements: SqlStatement[]): Promise<SqlRow[][]>;
-}
-interface Database extends SqlConnection {
-    readonly dialect: 'sqlite' | 'postgres';
-    transaction<T>(fn: (tx: SqlConnection) => Promise<T>): Promise<T>;
-    close(): Promise<void>;
-}
-/** Minimal surface used from a libsql client (node or web build) — the real
- * @libsql/client types, type-only so the browser graph stays driver-free. */
-type LibsqlClient = Pick<Client, 'execute' | 'transaction' | 'close'>;
-/** Wrap a libsql client (node or web build) into the shared Database surface. */
-declare function libsqlDatabase(client: LibsqlClient): Database;
-
 /**
  * Row codec for the SQL `data` column. Plain JSON.stringify destroys
  * ArrayBuffer values ({}); attachment rows carry raw blobs, so encoding tags
@@ -116,6 +83,13 @@ declare function rebuildProjections(conn: SqlConnection): Promise<void>;
 /** Boot-time derived state: DDL + rebuild only when the guard is incompatible
  * (first run, projection version bump, or an interrupted prior rebuild). */
 declare function initializeDomain(db: Database): Promise<void>;
+/** Read-only readiness check (no DDL, no writes): both real guards — the
+ * store schema version row and the domain projection version row — must be
+ * current, and every store/projection table must exist. Missing table →
+ * db_not_initialized; version drift or corrupt guards → schema_incompatible;
+ * auth/network errors propagate untouched. Used by
+ * openCliDb(…, { initialize: false }). */
+declare function verifyReadiness(db: Database): Promise<void>;
 /** Clears derived tables after a data wipe (empty is a consistent state). */
 declare function wipeDomain(conn: SqlConnection): Promise<void>;
 declare const MAX_BODY: number;
@@ -327,4 +301,4 @@ declare function readRawSyncOps(db: Database): Promise<RawSyncOp[]>;
  */
 declare function readLegacyRows(db: Database, table: string): Promise<unknown[]>;
 
-export { type ApplySyncBatchOptions, BrowserTursoStorage, type Database, type LibsqlClient, MAX_BODY, type RawSyncOp, SCHEMA_TABLE, SYNC_ARCHIVE_TABLE, SYNC_OPS_TABLE, SYNC_STATE_TABLE, type SqlConnection, type SqlRow, type SqlStatement, SqlStorage, type SqlStorageOptions, type SqlValue, StorageError, type StoredSyncOp, type SyncEntry, type SyncMutation, type SyncTargetKind, type TursoSettings, applySyncBatch, clearRows, countRows, decodeRowJson, deleteRows, encodeRowJson, fetchSyncOps, getRow, getRows, handleDomainQuery, initSyncTarget, initializeDomain, initializeStore, libsqlDatabase, listRows, listRowsFromIndexMany, probeSyncTarget, putRow, putRows, readLegacyRows, readRawSyncOps, rebuildProjections, refreshDomain, replaceSyncLog, storeDefinition, validateTursoUrl, wipeDomain, wipeRows };
+export { type ApplySyncBatchOptions, BrowserTursoStorage, Database, MAX_BODY, type RawSyncOp, SCHEMA_TABLE, SYNC_ARCHIVE_TABLE, SYNC_OPS_TABLE, SYNC_STATE_TABLE, SqlConnection, SqlStorage, type SqlStorageOptions, StorageError, type StoredSyncOp, type SyncEntry, type SyncMutation, type SyncTargetKind, type TursoSettings, applySyncBatch, clearRows, countRows, decodeRowJson, deleteRows, encodeRowJson, fetchSyncOps, getRow, getRows, handleDomainQuery, initSyncTarget, initializeDomain, initializeStore, listRows, listRowsFromIndexMany, probeSyncTarget, putRow, putRows, readLegacyRows, readRawSyncOps, rebuildProjections, refreshDomain, replaceSyncLog, storeDefinition, validateTursoUrl, verifyReadiness, wipeDomain, wipeRows };

package/dist/sql/index.d.ts

@@ -1,5 +1,7 @@
-import { Client } from '@libsql/client';
+import { S as SqlConnection, D as Database } from '../connection-DxuCLpRc.js';
+export { L as LibsqlClient, a as SqlRow, b as SqlStatement, c as SqlValue, l as libsqlDatabase } from '../connection-DxuCLpRc.js';
 import { a as StoreDef, R as RangeDTO, K as KeyDTO, e as DomainQueryResult, T as TxOp, I as IStorage, S as StoreName, b as IReadOnlyStore, c as StoreType, d as IReadWriteStore, D as DomainQuery, f as IStorageTransaction } from '../wire-CiFcjo6_.js';
+import '@libsql/client';
 import '@bitcobblers/wod-wiki-core';
 import '@bitcobblers/wod-wiki-lang';
 
@@ -15,41 +17,6 @@ declare class StorageError extends Error {
     constructor(status: number, message: string, code?: string | undefined);
 }
 
-/**
- * Connection contracts + a generic libsql adapter. The adapter takes a
- * *structural* client so the browser passes @libsql/client/web and the server
- * passes @libsql/client (node) — this module never imports either, keeping
- * the browser graph free of native drivers.
- *
- * All operations are serialized through one promise chain: the underlying
- * client shares a single connection, so concurrent transactions/reads could
- * otherwise interleave on it. Transactions run on a transaction-owned
- * connection (libsql interactive transaction), so writes inside a transaction
- * commit or roll back atomically and are not visible outside it.
- */
-
-type SqlValue = string | number | null;
-type SqlRow = Record<string, unknown>;
-interface SqlStatement {
-    sql: string;
-    params?: SqlValue[];
-}
-interface SqlConnection {
-    query(sql: string, params?: SqlValue[]): Promise<SqlRow[]>;
-    exec(sql: string, params?: SqlValue[]): Promise<void>;
-    batch?(statements: SqlStatement[]): Promise<SqlRow[][]>;
-}
-interface Database extends SqlConnection {
-    readonly dialect: 'sqlite' | 'postgres';
-    transaction<T>(fn: (tx: SqlConnection) => Promise<T>): Promise<T>;
-    close(): Promise<void>;
-}
-/** Minimal surface used from a libsql client (node or web build) — the real
- * @libsql/client types, type-only so the browser graph stays driver-free. */
-type LibsqlClient = Pick<Client, 'execute' | 'transaction' | 'close'>;
-/** Wrap a libsql client (node or web build) into the shared Database surface. */
-declare function libsqlDatabase(client: LibsqlClient): Database;
-
 /**
  * Row codec for the SQL `data` column. Plain JSON.stringify destroys
  * ArrayBuffer values ({}); attachment rows carry raw blobs, so encoding tags
@@ -116,6 +83,13 @@ declare function rebuildProjections(conn: SqlConnection): Promise<void>;
 /** Boot-time derived state: DDL + rebuild only when the guard is incompatible
  * (first run, projection version bump, or an interrupted prior rebuild). */
 declare function initializeDomain(db: Database): Promise<void>;
+/** Read-only readiness check (no DDL, no writes): both real guards — the
+ * store schema version row and the domain projection version row — must be
+ * current, and every store/projection table must exist. Missing table →
+ * db_not_initialized; version drift or corrupt guards → schema_incompatible;
+ * auth/network errors propagate untouched. Used by
+ * openCliDb(…, { initialize: false }). */
+declare function verifyReadiness(db: Database): Promise<void>;
 /** Clears derived tables after a data wipe (empty is a consistent state). */
 declare function wipeDomain(conn: SqlConnection): Promise<void>;
 declare const MAX_BODY: number;
@@ -327,4 +301,4 @@ declare function readRawSyncOps(db: Database): Promise<RawSyncOp[]>;
  */
 declare function readLegacyRows(db: Database, table: string): Promise<unknown[]>;
 
-export { type ApplySyncBatchOptions, BrowserTursoStorage, type Database, type LibsqlClient, MAX_BODY, type RawSyncOp, SCHEMA_TABLE, SYNC_ARCHIVE_TABLE, SYNC_OPS_TABLE, SYNC_STATE_TABLE, type SqlConnection, type SqlRow, type SqlStatement, SqlStorage, type SqlStorageOptions, type SqlValue, StorageError, type StoredSyncOp, type SyncEntry, type SyncMutation, type SyncTargetKind, type TursoSettings, applySyncBatch, clearRows, countRows, decodeRowJson, deleteRows, encodeRowJson, fetchSyncOps, getRow, getRows, handleDomainQuery, initSyncTarget, initializeDomain, initializeStore, libsqlDatabase, listRows, listRowsFromIndexMany, probeSyncTarget, putRow, putRows, readLegacyRows, readRawSyncOps, rebuildProjections, refreshDomain, replaceSyncLog, storeDefinition, validateTursoUrl, wipeDomain, wipeRows };
+export { type ApplySyncBatchOptions, BrowserTursoStorage, Database, MAX_BODY, type RawSyncOp, SCHEMA_TABLE, SYNC_ARCHIVE_TABLE, SYNC_OPS_TABLE, SYNC_STATE_TABLE, SqlConnection, SqlStorage, type SqlStorageOptions, StorageError, type StoredSyncOp, type SyncEntry, type SyncMutation, type SyncTargetKind, type TursoSettings, applySyncBatch, clearRows, countRows, decodeRowJson, deleteRows, encodeRowJson, fetchSyncOps, getRow, getRows, handleDomainQuery, initSyncTarget, initializeDomain, initializeStore, listRows, listRowsFromIndexMany, probeSyncTarget, putRow, putRows, readLegacyRows, readRawSyncOps, rebuildProjections, refreshDomain, replaceSyncLog, storeDefinition, validateTursoUrl, verifyReadiness, wipeDomain, wipeRows };

package/dist/sql/index.mjs

@@ -1,61 +1,11 @@
-import { STORE_DEFS, StorageError, extractKeyPart, validateStorageRow, isRange, DB_VERSION, rowsEqual, validateStoredPins, DOMAIN_PROJECTION_VERSION, bufferToOps, stampUserOwned, bufferedGet, overlayRows, rangeFromIDB, isDirty, keyFromValue, bufferSlot, COLUMN_TYPES, keyInRange, compareKeys } from '../chunk-7ZCBM5NS.mjs';
-export { StorageError } from '../chunk-7ZCBM5NS.mjs';
+import { STORE_DEFS, extractKeyPart, validateStorageRow, isRange, DB_VERSION, rowsEqual, validateStoredPins, DOMAIN_PROJECTION_VERSION, bufferToOps, stampUserOwned, bufferedGet, overlayRows, rangeFromIDB, isDirty, keyFromValue, bufferSlot, COLUMN_TYPES, keyInRange, compareKeys } from '../chunk-YESCCCRF.mjs';
+import { libsqlDatabase } from '../chunk-6ZTAWTAP.mjs';
+export { libsqlDatabase } from '../chunk-6ZTAWTAP.mjs';
+import { StorageError } from '../chunk-XRQKLSOT.mjs';
+export { StorageError } from '../chunk-XRQKLSOT.mjs';
 import { catalogOfItem, sourceMatches } from '@bitcobblers/wod-wiki-wql';
 import { createClient } from '@libsql/client/web';
 
-// src/sql/connection.ts
-function libsqlRows(result) {
-  return result.rows;
-}
-function libsqlDatabase(client) {
-  let chain = Promise.resolve();
-  const serialize = (fn) => {
-    const next = chain.then(fn, fn);
-    chain = next.then(() => void 0, () => void 0);
-    return next;
-  };
-  return {
-    dialect: "sqlite",
-    query: (sql, params = []) => serialize(() => client.execute({ sql, args: params }).then(libsqlRows)),
-    exec: async (sql, params = []) => {
-      await serialize(() => client.execute({ sql, args: params }));
-    },
-    transaction(fn) {
-      return serialize(async () => {
-        const tx = await client.transaction("write");
-        try {
-          const txConn = {
-            query: (sql, params = []) => tx.execute({ sql, args: params }).then(libsqlRows),
-            exec: async (sql, params = []) => {
-              await tx.execute({ sql, args: params });
-            },
-            batch: async (statements) => (await tx.batch(statements.map(({ sql, params = [] }) => ({ sql, args: params })))).map(libsqlRows)
-          };
-          const result = await fn(txConn);
-          await tx.commit();
-          return result;
-        } catch (err) {
-          try {
-            await tx.rollback();
-          } catch {
-          }
-          const message = err instanceof Error ? err.message : String(err);
-          for (const code of ["revision_conflict", "transaction_conflict", "invalid_session_pin"]) {
-            if (message.includes(code)) throw new StorageError(409, message, code);
-          }
-          throw err;
-        } finally {
-          tx.close();
-        }
-      });
-    },
-    close: async () => {
-      await chain;
-      client.close();
-    }
-  };
-}
-
 // src/sql/codec.ts
 var TAG = "$binary";
 var LEN = "$bytes";
@@ -581,7 +531,7 @@ async function ensureStoreTables(conn, dialect, def) {
       BEGIN SELECT RAISE(ABORT, 'invalid_session_pin: Session pin is immutable'); END`);
   }
   if (dialect === "postgres" && ["notes", "block_revisions", "sessions"].includes(def.name)) {
-    const condition = def.name === "block_revisions" ? `EXISTS (SELECT 1 FROM "block_revisions" old WHERE old."k0" = NEW."k0" AND old."k1" = NEW."k1" AND old."k2" = NEW."k2" AND old."data" <> NEW."data")` : def.name === "notes" ? `(NEW."data"::jsonb->>'sourceRevision')::bigint < (OLD."data"::jsonb->>'sourceRevision')::bigint OR ((NEW."data"::jsonb->'rawContent' IS DISTINCT FROM OLD."data"::jsonb->'rawContent' OR NEW."data"::jsonb->'blocks' IS DISTINCT FROM OLD."data"::jsonb->'blocks') AND (NEW."data"::jsonb->>'sourceRevision')::bigint <= (OLD."data"::jsonb->>'sourceRevision')::bigint)` : `NEW."data"::jsonb->'noteId' IS DISTINCT FROM OLD."data"::jsonb->'noteId' OR NEW."data"::jsonb->'blockId' IS DISTINCT FROM OLD."data"::jsonb->'blockId' OR NEW."data"::jsonb->'blockVersion' IS DISTINCT FROM OLD."data"::jsonb->'blockVersion'`;
+    const condition = def.name === "block_revisions" ? `EXISTS (SELECT 1 FROM "block_revisions" saved WHERE saved."k0" = NEW."k0" AND saved."k1" = NEW."k1" AND saved."k2" = NEW."k2" AND saved."data" <> NEW."data")` : def.name === "notes" ? `(NEW."data"::jsonb->>'sourceRevision')::bigint < (OLD."data"::jsonb->>'sourceRevision')::bigint OR ((NEW."data"::jsonb->'rawContent' IS DISTINCT FROM OLD."data"::jsonb->'rawContent' OR NEW."data"::jsonb->'blocks' IS DISTINCT FROM OLD."data"::jsonb->'blocks') AND (NEW."data"::jsonb->>'sourceRevision')::bigint <= (OLD."data"::jsonb->>'sourceRevision')::bigint)` : `NEW."data"::jsonb->'noteId' IS DISTINCT FROM OLD."data"::jsonb->'noteId' OR NEW."data"::jsonb->'blockId' IS DISTINCT FROM OLD."data"::jsonb->'blockId' OR NEW."data"::jsonb->'blockVersion' IS DISTINCT FROM OLD."data"::jsonb->'blockVersion'`;
     const code = def.name === "block_revisions" ? "revision_conflict" : def.name === "notes" ? "transaction_conflict" : "invalid_session_pin";
     const guard = `${def.name}_guard`;
     await conn.exec(`CREATE OR REPLACE FUNCTION "${guard}"() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN IF ${condition} THEN RAISE EXCEPTION '${code}'; END IF; RETURN NEW; END; $$`);
@@ -681,7 +631,7 @@ function ensureDdl(db) {
 }
 var DOMAIN_NOTE_COLS = ["note_id", "note_type", "catalog", "source_id", "source_path", "title", "title_search", "created_at", "date", "text_search", "journal", "payload"];
 var QUERY_BLOCK_COLS = ["occurrence_id", "source_note_id", "parent_note_id", "content_id", "section_key", "ordinal", "data_type", "source_id", "source_path", "catalog", "effective_date", "created_at", "note_title", "normalized_text", "journal", "payload"];
-var conflictUpdate = (cols, keys) => `ON CONFLICT (${keys.map((k) => `"${k}"`).join(", ")}) DO UPDATE SET ` + cols.filter((c) => !keys.includes(c)).map((c) => `"${c}" = excluded."${c}"`).join(",") + ` WHERE ` + cols.filter((col) => !keys.includes(col)).map((col) => `"${col}" IS DISTINCT FROM excluded."${col}"`).join(" OR ");
+var conflictUpdate = (table, cols, keys) => `ON CONFLICT (${keys.map((k) => `"${k}"`).join(", ")}) DO UPDATE SET ` + cols.filter((c) => !keys.includes(c)).map((c) => `"${c}" = excluded."${c}"`).join(",") + ` WHERE ` + cols.filter((col) => !keys.includes(col)).map((col) => `"${table}"."${col}" IS DISTINCT FROM excluded."${col}"`).join(" OR ");
 function domainNoteRow(note) {
   const id = text(note.id);
   if (!id) return void 0;
@@ -703,7 +653,7 @@ function domainNoteRow(note) {
 }
 async function upsertDomainNotes(conn, notes) {
   const rows = notes.map(domainNoteRow).filter((r) => r !== void 0);
-  await batchInsert(conn, "domain_note", [...DOMAIN_NOTE_COLS], rows, conflictUpdate(DOMAIN_NOTE_COLS, ["note_id"]));
+  await batchInsert(conn, "domain_note", [...DOMAIN_NOTE_COLS], rows, conflictUpdate("domain_note", DOMAIN_NOTE_COLS, ["note_id"]));
 }
 function queryBlockRow(block, parent) {
   const id = text(block.id);
@@ -732,7 +682,7 @@ function queryBlockRow(block, parent) {
 }
 async function upsertQueryBlocks(conn, blocks) {
   const rows = blocks.map(([b, p]) => queryBlockRow(b, p)).filter((r) => r !== void 0);
-  await batchInsert(conn, "query_block", [...QUERY_BLOCK_COLS], rows, conflictUpdate(QUERY_BLOCK_COLS, ["occurrence_id"]));
+  await batchInsert(conn, "query_block", [...QUERY_BLOCK_COLS], rows, conflictUpdate("query_block", QUERY_BLOCK_COLS, ["occurrence_id"]));
 }
 function indexNoteIdentities(notes) {
   const byNoteId = /* @__PURE__ */ new Map();
@@ -932,6 +882,73 @@ async function initializeDomain(db) {
     await rebuildProjections(tx);
   });
 }
+async function verifyReadiness(db) {
+  const isMissingRelation = (error) => {
+    if (typeof error !== "object" || error === null) return false;
+    if ("errno" in error && error.errno === "42P01") return true;
+    if ("code" in error && error.code === "42P01") return true;
+    return "code" in error && error.code === "SQLITE_ERROR" && /no such table/i.test(error instanceof Error ? error.message : String(error));
+  };
+  const readGuard = async (key) => {
+    const rows = await db.query(`SELECT "value" FROM "${SCHEMA_TABLE}" WHERE "key" = ?`, [key]);
+    if (!rows.length || typeof rows[0].value !== "string") return void 0;
+    try {
+      return JSON.parse(rows[0].value);
+    } catch {
+      throw new StorageError(500, `database guard "${key}" is corrupt; re-run initialization`, "schema_incompatible");
+    }
+  };
+  let schemaGuard;
+  let projectionGuard;
+  try {
+    schemaGuard = await readGuard("schema");
+    projectionGuard = await readGuard(PROJECTION_GUARD_KEY);
+  } catch (error) {
+    if (isMissingRelation(error)) {
+      throw new StorageError(500, "database is not initialized (schema guard table missing)", "db_not_initialized");
+    }
+    throw error;
+  }
+  const schemaVersion = schemaGuard?.version;
+  const projectionVersion = projectionGuard?.version;
+  if (typeof schemaVersion !== "number") {
+    throw new StorageError(500, "database is not initialized (no schema guard row)", "db_not_initialized");
+  }
+  if (typeof projectionVersion !== "number") {
+    throw new StorageError(500, "database is not initialized (projections never built)", "db_not_initialized");
+  }
+  if (schemaVersion > DB_VERSION) {
+    throw new StorageError(
+      500,
+      `database schema v${schemaVersion} is newer than this server supports (v${DB_VERSION}); refusing to downgrade`,
+      "schema_incompatible"
+    );
+  }
+  if (schemaVersion !== DB_VERSION) {
+    throw new StorageError(
+      500,
+      `database schema v${schemaVersion} is incompatible with v${DB_VERSION}; re-run initialization`,
+      "schema_incompatible"
+    );
+  }
+  if (projectionVersion !== DOMAIN_PROJECTION_VERSION) {
+    throw new StorageError(
+      500,
+      `database projections v${projectionVersion} are incompatible with v${DOMAIN_PROJECTION_VERSION}; re-run initialization`,
+      "schema_incompatible"
+    );
+  }
+  for (const table of [...STORE_DEFS.map((def) => def.name), ...TABLES]) {
+    try {
+      await db.query(`SELECT * FROM "${table}" LIMIT 0`);
+    } catch (error) {
+      if (isMissingRelation(error)) {
+        throw new StorageError(500, `database is not initialized (missing table: ${table})`, "db_not_initialized");
+      }
+      throw error;
+    }
+  }
+}
 async function wipeDomain(conn) {
   for (const t of TABLES) await conn.exec(`DELETE FROM "${t}"`);
 }
@@ -1857,6 +1874,6 @@ async function readLegacyRows(db, table) {
   return rows.map((row) => decodeRowJson(String(row.data), BINARY_FIELD2[table]));
 }
 
-export { BrowserTursoStorage, MAX_BODY, SCHEMA_TABLE, SYNC_ARCHIVE_TABLE, SYNC_OPS_TABLE, SYNC_STATE_TABLE, SqlStorage, applySyncBatch, clearRows, countRows, decodeRowJson, deleteRows, encodeRowJson, fetchSyncOps, getRow, getRows, handleDomainQuery, initSyncTarget, initializeDomain, initializeStore, libsqlDatabase, listRows, listRowsFromIndexMany, probeSyncTarget, putRow, putRows, readLegacyRows, readRawSyncOps, rebuildProjections, refreshDomain, replaceSyncLog, storeDefinition, validateTursoUrl, wipeDomain, wipeRows };
+export { BrowserTursoStorage, MAX_BODY, SCHEMA_TABLE, SYNC_ARCHIVE_TABLE, SYNC_OPS_TABLE, SYNC_STATE_TABLE, SqlStorage, applySyncBatch, clearRows, countRows, decodeRowJson, deleteRows, encodeRowJson, fetchSyncOps, getRow, getRows, handleDomainQuery, initSyncTarget, initializeDomain, initializeStore, listRows, listRowsFromIndexMany, probeSyncTarget, putRow, putRows, readLegacyRows, readRawSyncOps, rebuildProjections, refreshDomain, replaceSyncLog, storeDefinition, validateTursoUrl, verifyReadiness, wipeDomain, wipeRows };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map