@starkeep/storage-sqlite 0.1.0

package/dist/index.cjs

@@ -0,0 +1,702 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SqliteAppSyncableApplier: () => SqliteAppSyncableApplier,
+  SqliteAppSyncableNamespaceStore: () => SqliteAppSyncableNamespaceStore,
+  SqliteDatabaseAdapter: () => SqliteDatabaseAdapter,
+  appSyncableTableName: () => appSyncableTableName,
+  createSqliteAccessPolicyStore: () => createSqliteAccessPolicyStore,
+  deleteAppSyncableNamespace: () => deleteAppSyncableNamespace,
+  getAppSyncableNamespace: () => getAppSyncableNamespace,
+  initializeLocalSchema: () => initializeLocalSchema,
+  listAppSyncableNamespaces: () => listAppSyncableNamespaces,
+  upsertAppSyncableNamespace: () => upsertAppSyncableNamespace
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/adapter.ts
+var import_node_sqlite = require("sqlite");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_protocol_primitives3 = require("@starkeep/protocol-primitives");
+var import_storage_adapter = require("@starkeep/storage-adapter");
+
+// src/serialization.ts
+var import_protocol_primitives = require("@starkeep/protocol-primitives");
+function recordToRow(record) {
+  return {
+    id: record.id,
+    type: record.type,
+    created_at: (0, import_protocol_primitives.serializeHLC)(record.createdAt),
+    updated_at: (0, import_protocol_primitives.serializeHLC)(record.updatedAt),
+    owner_id: record.ownerId,
+    deleted_at: record.deletedAt ? (0, import_protocol_primitives.serializeHLC)(record.deletedAt) : null,
+    version: record.version,
+    content_hash: record.contentHash,
+    object_storage_key: record.objectStorageKey,
+    mime_type: record.mimeType,
+    size_bytes: record.sizeBytes,
+    original_filename: record.originalFilename,
+    origin_app_id: record.originAppId,
+    parent_id: record.parentId
+  };
+}
+function rowToRecord(row) {
+  return {
+    id: (0, import_protocol_primitives.createStarkeepId)(row.id),
+    kind: "data",
+    type: row.type,
+    createdAt: (0, import_protocol_primitives.deserializeHLC)(row.created_at),
+    updatedAt: (0, import_protocol_primitives.deserializeHLC)(row.updated_at),
+    ownerId: row.owner_id,
+    deletedAt: row.deleted_at ? (0, import_protocol_primitives.deserializeHLC)(row.deleted_at) : null,
+    version: row.version,
+    contentHash: row.content_hash,
+    objectStorageKey: row.object_storage_key,
+    mimeType: row.mime_type,
+    sizeBytes: row.size_bytes,
+    originalFilename: row.original_filename,
+    originAppId: row.origin_app_id,
+    parentId: row.parent_id ? (0, import_protocol_primitives.createStarkeepId)(row.parent_id) : null
+  };
+}
+
+// src/query-builder.ts
+var import_kysely = require("kysely");
+var FIELD_MAP = {
+  id: "id",
+  type: "type",
+  createdAt: "created_at",
+  updatedAt: "updated_at",
+  ownerId: "owner_id",
+  deletedAt: "deleted_at",
+  version: "version",
+  contentHash: "content_hash",
+  objectStorageKey: "object_storage_key",
+  mimeType: "mime_type",
+  sizeBytes: "size_bytes",
+  originAppId: "origin_app_id",
+  parentId: "parent_id",
+  originalFilename: "original_filename"
+};
+function mapField(field) {
+  return FIELD_MAP[field] ?? field;
+}
+var compiler = new import_kysely.Kysely({
+  dialect: {
+    createAdapter: () => new import_kysely.SqliteAdapter(),
+    createDriver: () => new import_kysely.DummyDriver(),
+    createIntrospector: (db) => new import_kysely.SqliteIntrospector(db),
+    createQueryCompiler: () => new import_kysely.SqliteQueryCompiler()
+  }
+});
+function buildSelectQuery(query) {
+  let qb = compiler.selectFrom("shared_records").selectAll();
+  if (query.type) {
+    qb = qb.where("type", "=", query.type);
+  }
+  if (query.filters) {
+    for (const filter of query.filters) {
+      qb = applyFilter(qb, filter);
+    }
+  }
+  if (query.cursor) {
+    qb = qb.where("id", ">", query.cursor);
+  }
+  if (query.sort && query.sort.length > 0) {
+    for (const s of query.sort) {
+      qb = qb.orderBy(mapField(s.field), s.direction === "desc" ? "desc" : "asc");
+    }
+  } else {
+    qb = qb.orderBy("id", "asc");
+  }
+  if (query.limit) {
+    qb = qb.limit(query.limit + 1);
+  }
+  const compiled = qb.compile();
+  return { sql: compiled.sql, params: [...compiled.parameters] };
+}
+function applyFilter(qb, filter) {
+  const col = mapField(filter.field);
+  switch (filter.operator) {
+    case "eq":
+      return qb.where(col, "=", filter.value);
+    case "neq":
+      return qb.where(col, "!=", filter.value);
+    case "gt":
+      return qb.where(col, ">", filter.value);
+    case "gte":
+      return qb.where(col, ">=", filter.value);
+    case "lt":
+      return qb.where(col, "<", filter.value);
+    case "lte":
+      return qb.where(col, "<=", filter.value);
+    case "in":
+      return qb.where(col, "in", filter.value);
+    case "like":
+      return qb.where(col, "like", `%${filter.value}%`);
+    case "isNull":
+      return qb.where((eb) => eb(col, "is", null));
+    case "isNotNull":
+      return qb.where((eb) => eb(col, "is not", null));
+    default:
+      return qb;
+  }
+}
+
+// src/schema/bootstrap.ts
+var import_protocol_primitives2 = require("@starkeep/protocol-primitives");
+function initializeLocalSchema(db) {
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA foreign_keys = ON");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS shared_records (
+      id TEXT PRIMARY KEY,
+      type TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      owner_id TEXT NOT NULL,
+      deleted_at TEXT,
+      version INTEGER NOT NULL DEFAULT 1,
+      content_hash TEXT NOT NULL,
+      object_storage_key TEXT NOT NULL,
+      mime_type TEXT NOT NULL,
+      size_bytes INTEGER NOT NULL,
+      original_filename TEXT,
+      origin_app_id TEXT NOT NULL,
+      parent_id TEXT
+    )
+  `);
+  db.exec("CREATE INDEX IF NOT EXISTS idx_shared_records_type ON shared_records(type)");
+  db.exec("CREATE INDEX IF NOT EXISTS idx_shared_records_origin_app ON shared_records(origin_app_id)");
+  db.exec("CREATE INDEX IF NOT EXISTS idx_shared_records_parent_id ON shared_records(parent_id)");
+  db.exec(
+    "CREATE UNIQUE INDEX IF NOT EXISTS uq_shared_records_owner_filename_hash ON shared_records(owner_id, original_filename, content_hash) WHERE deleted_at IS NULL AND original_filename IS NOT NULL"
+  );
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS shared_access_grants (
+      app_id TEXT NOT NULL,
+      type_id TEXT NOT NULL,
+      access TEXT NOT NULL CHECK (access IN ('read', 'readwrite')),
+      metadata_write INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      PRIMARY KEY (app_id, type_id)
+    )
+  `);
+  db.exec("CREATE INDEX IF NOT EXISTS idx_shared_access_grants_app ON shared_access_grants(app_id)");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS shared_app_registry (
+      app_id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      version TEXT NOT NULL,
+      tier TEXT NOT NULL DEFAULT 'app',
+      manifest TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'installing',
+      hmac_secret TEXT NOT NULL,
+      installed_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS shared_app_install_steps (
+      app_id TEXT NOT NULL,
+      operation TEXT NOT NULL CHECK (operation IN ('install', 'uninstall')),
+      step TEXT NOT NULL,
+      status TEXT NOT NULL CHECK (status IN ('pending', 'done', 'failed')),
+      error TEXT,
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      PRIMARY KEY (app_id, operation, step)
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS app_syncable_namespaces (
+      app_id        TEXT PRIMARY KEY,
+      tables_json   TEXT NOT NULL,
+      files_enabled INTEGER NOT NULL DEFAULT 0,
+      created_at    TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS access_policies (
+      policy_id     TEXT PRIMARY KEY,
+      subject_type  TEXT NOT NULL,
+      subject_id    TEXT NOT NULL,
+      resource_type TEXT NOT NULL,
+      resource_id   TEXT NOT NULL,
+      permissions   TEXT NOT NULL,
+      granted_at    TEXT NOT NULL,
+      expires_at    TEXT
+    )
+  `);
+  db.exec("CREATE INDEX IF NOT EXISTS idx_access_policies_subject ON access_policies(subject_type, subject_id)");
+  for (const c of import_protocol_primitives2.CATEGORIES) {
+    if (c.id === "other") continue;
+    db.exec((0, import_protocol_primitives2.sqliteMetadataDdl)(c));
+  }
+}
+
+// src/adapter.ts
+var SqliteDatabaseAdapter = class {
+  database = null;
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  async init() {
+    if (this.database) return;
+    if (this.options.path !== ":memory:") {
+      const dir = (0, import_node_path.dirname)(this.options.path);
+      if (!(0, import_node_fs.existsSync)(dir)) {
+        (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+      }
+    }
+    this.database = new import_node_sqlite.DatabaseSync(this.options.path);
+    initializeLocalSchema(this.database);
+  }
+  async close() {
+    this.database?.close();
+    this.database = null;
+  }
+  async healthCheck() {
+    if (!this.database) return false;
+    try {
+      this.database.prepare("SELECT 1").get();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getDatabase() {
+    if (!this.database) throw new import_storage_adapter.StorageError("Database not initialized. Call init() first.");
+    return this.database;
+  }
+  /**
+   * Returns the raw SQLite connection so sibling subsystems (e.g. the sync
+   * engine's change log + state store) can create side tables in the same
+   * database file. Callers must only use this after `init()`.
+   */
+  getRawDatabase() {
+    return this.getDatabase();
+  }
+  runStmt(sql, ...params) {
+    this.getDatabase().prepare(sql).run(...params);
+  }
+  getRow(sql, ...params) {
+    return this.getDatabase().prepare(sql).get(
+      ...params
+    );
+  }
+  allRows(sql, ...params) {
+    return this.getDatabase().prepare(sql).all(
+      ...params
+    );
+  }
+  async put(record) {
+    const row = recordToRow(record);
+    const columns = Object.keys(row);
+    const placeholders = columns.map(() => "?").join(", ");
+    const updates = columns.filter((column) => column !== "id").map((column) => `${column} = excluded.${column}`).join(", ");
+    const sql = `INSERT INTO shared_records (${columns.join(", ")}) VALUES (${placeholders}) ON CONFLICT(id) DO UPDATE SET ${updates}`;
+    this.runStmt(sql, ...Object.values(row));
+  }
+  async get(id) {
+    const row = this.getRow("SELECT * FROM shared_records WHERE id = ?", id);
+    return row ? rowToRecord(row) : null;
+  }
+  async delete(id, hlc) {
+    const ts = (0, import_protocol_primitives3.serializeHLC)(hlc);
+    this.runStmt(
+      "UPDATE shared_records SET deleted_at = ?, updated_at = ? WHERE id = ?",
+      ts,
+      ts,
+      id
+    );
+  }
+  async query(query) {
+    const { sql, params } = buildSelectQuery(query);
+    const rows = this.allRows(sql, ...params);
+    const limit = query.limit;
+    const hasMore = limit ? rows.length > limit : false;
+    const resultRows = hasMore ? rows.slice(0, limit) : rows;
+    return {
+      records: resultRows.map(rowToRecord),
+      nextCursor: hasMore ? resultRows[resultRows.length - 1].id : null,
+      hasMore
+    };
+  }
+  async batch(operations) {
+    this.getDatabase().exec("BEGIN");
+    try {
+      for (const operation of operations) {
+        if (operation.type === "put") {
+          await this.put(operation.record);
+        } else {
+          await this.delete(operation.id, operation.hlc);
+        }
+      }
+      this.getDatabase().exec("COMMIT");
+    } catch (error) {
+      this.getDatabase().exec("ROLLBACK");
+      throw error;
+    }
+  }
+  async transaction(callback) {
+    this.getDatabase().exec("SAVEPOINT starkeep_tx");
+    try {
+      const transaction = {
+        put: async (record) => this.put(record),
+        get: async (id) => this.get(id),
+        delete: async (id, hlc) => this.delete(id, hlc),
+        query: async (query) => this.query(query)
+      };
+      const result = await callback(transaction);
+      this.getDatabase().exec("RELEASE SAVEPOINT starkeep_tx");
+      return result;
+    } catch (error) {
+      this.getDatabase().exec("ROLLBACK TO SAVEPOINT starkeep_tx");
+      this.getDatabase().exec("RELEASE SAVEPOINT starkeep_tx");
+      throw new import_storage_adapter.TransactionError("Transaction failed", error);
+    }
+  }
+  async putMetadata(typeId, row) {
+    const table = (0, import_protocol_primitives3.sqliteMetadataTableName)(typeId);
+    const cols = ["record_id"];
+    const values = [row.recordId];
+    for (const [key, value] of Object.entries(row)) {
+      if (key === "recordId") continue;
+      cols.push(key);
+      values.push(value);
+    }
+    const placeholders = cols.map(() => "?").join(", ");
+    const updates = cols.filter((c) => c !== "record_id").map((c) => `${c} = excluded.${c}`).join(", ");
+    const sql = updates ? `INSERT INTO ${table} (${cols.join(", ")}) VALUES (${placeholders}) ON CONFLICT(record_id) DO UPDATE SET ${updates}` : `INSERT INTO ${table} (${cols.join(", ")}) VALUES (${placeholders}) ON CONFLICT(record_id) DO NOTHING`;
+    this.runStmt(sql, ...values);
+  }
+  async getMetadata(typeId, recordId) {
+    const table = (0, import_protocol_primitives3.sqliteMetadataTableName)(typeId);
+    const row = this.getRow(
+      `SELECT * FROM ${table} WHERE record_id = ?`,
+      recordId
+    );
+    if (!row) return null;
+    return columnsToMetadataRow(recordId, row);
+  }
+  async getMetadataByIds(typeId, recordIds) {
+    const result = /* @__PURE__ */ new Map();
+    if (recordIds.length === 0) return result;
+    const table = (0, import_protocol_primitives3.sqliteMetadataTableName)(typeId);
+    const placeholders = recordIds.map(() => "?").join(", ");
+    const rows = this.allRows(
+      `SELECT * FROM ${table} WHERE record_id IN (${placeholders})`,
+      ...recordIds
+    );
+    for (const row of rows) {
+      const recordId = row["record_id"];
+      result.set(recordId, columnsToMetadataRow(recordId, row));
+    }
+    return result;
+  }
+  async deleteMetadata(typeId, recordId) {
+    const table = (0, import_protocol_primitives3.sqliteMetadataTableName)(typeId);
+    this.runStmt(`DELETE FROM ${table} WHERE record_id = ?`, recordId);
+  }
+};
+function columnsToMetadataRow(recordId, columns) {
+  const row = { recordId };
+  for (const [key, value] of Object.entries(columns)) {
+    if (key === "record_id") continue;
+    row[key] = value;
+  }
+  return row;
+}
+
+// src/control-plane-stores.ts
+var import_protocol_primitives4 = require("@starkeep/protocol-primitives");
+function createSqliteAccessPolicyStore(db) {
+  return {
+    async putPolicy(policy) {
+      db.prepare(
+        `INSERT INTO access_policies (
+           policy_id, subject_type, subject_id, resource_type, resource_id,
+           permissions, granted_at, expires_at
+         ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(policy_id) DO UPDATE SET
+           subject_type = excluded.subject_type,
+           subject_id = excluded.subject_id,
+           resource_type = excluded.resource_type,
+           resource_id = excluded.resource_id,
+           permissions = excluded.permissions,
+           granted_at = excluded.granted_at,
+           expires_at = excluded.expires_at`
+      ).run(
+        policy.policyId,
+        policy.subjectType,
+        policy.subjectId,
+        policy.resourceType,
+        policy.resourceId,
+        policy.permissions.join(","),
+        (0, import_protocol_primitives4.serializeHLC)(policy.grantedAt),
+        policy.expiresAt ? (0, import_protocol_primitives4.serializeHLC)(policy.expiresAt) : null
+      );
+    },
+    async getPolicy(policyId) {
+      const row = db.prepare("SELECT * FROM access_policies WHERE policy_id = ?").get(policyId);
+      return row ? rowToPolicy(row) : null;
+    },
+    async listPolicies() {
+      const rows = db.prepare("SELECT * FROM access_policies").all();
+      return rows.map(rowToPolicy);
+    },
+    async deletePolicy(policyId) {
+      db.prepare("DELETE FROM access_policies WHERE policy_id = ?").run(policyId);
+    }
+  };
+}
+function rowToPolicy(row) {
+  return {
+    policyId: (0, import_protocol_primitives4.createStarkeepId)(row.policy_id),
+    subjectType: row.subject_type,
+    subjectId: row.subject_id,
+    resourceType: row.resource_type,
+    resourceId: row.resource_id,
+    permissions: row.permissions.split(",").filter(Boolean),
+    grantedAt: (0, import_protocol_primitives4.deserializeHLC)(row.granted_at),
+    expiresAt: row.expires_at ? (0, import_protocol_primitives4.deserializeHLC)(row.expires_at) : null
+  };
+}
+
+// src/app-syncable/namespace.ts
+function normalizeAppId(appId) {
+  return appId.toLowerCase().replace(/-/g, "_");
+}
+function appSyncableTableName(appId, tableName) {
+  return `${normalizeAppId(appId)}_syncable_${tableName}`;
+}
+function rowToNamespace(r) {
+  const tables = JSON.parse(r.tables_json);
+  return {
+    appId: r.app_id,
+    tables,
+    filesEnabled: r.files_enabled === 1,
+    tableNames: tables.map((t) => t.name)
+  };
+}
+function upsertAppSyncableNamespace(db, appId, tables, filesEnabled) {
+  db.prepare(
+    `INSERT INTO app_syncable_namespaces (app_id, tables_json, files_enabled)
+     VALUES (?, ?, ?)
+     ON CONFLICT(app_id) DO UPDATE SET
+       tables_json = excluded.tables_json,
+       files_enabled = excluded.files_enabled`
+  ).run(appId, JSON.stringify(tables), filesEnabled ? 1 : 0);
+}
+function deleteAppSyncableNamespace(db, appId) {
+  db.prepare("DELETE FROM app_syncable_namespaces WHERE app_id = ?").run(appId);
+}
+function getAppSyncableNamespace(db, appId) {
+  const row = db.prepare(
+    "SELECT app_id, tables_json, files_enabled FROM app_syncable_namespaces WHERE app_id = ?"
+  ).get(appId);
+  if (!row) return null;
+  return rowToNamespace(row);
+}
+function listAppSyncableNamespaces(db) {
+  const rows = db.prepare(
+    "SELECT app_id, tables_json, files_enabled FROM app_syncable_namespaces"
+  ).all();
+  return rows.map(rowToNamespace);
+}
+var SqliteAppSyncableNamespaceStore = class {
+  constructor(db) {
+    this.db = db;
+  }
+  get(appId) {
+    return getAppSyncableNamespace(this.db, appId);
+  }
+  list() {
+    return listAppSyncableNamespaces(this.db);
+  }
+};
+
+// src/app-syncable/apply.ts
+var import_protocol_primitives5 = require("@starkeep/protocol-primitives");
+var SqliteAppSyncableApplier = class {
+  constructor(db, namespace) {
+    this.db = db;
+    this.namespace = namespace;
+  }
+  apply(entry) {
+    const ns = this.namespace.get(entry.appId);
+    if (!ns) {
+      throw new Error(
+        `SqliteAppSyncableApplier: app "${entry.appId}" not installed`
+      );
+    }
+    const tableInfo = ns.tables.find((t) => t.name === entry.table);
+    if (!tableInfo) {
+      throw new Error(
+        `SqliteAppSyncableApplier: table "${entry.table}" not declared for app "${entry.appId}"`
+      );
+    }
+    const fullName = appSyncableTableName(entry.appId, entry.table);
+    const { pkColumns } = tableInfo;
+    if (entry.op === "insert") {
+      this.applyInsert(fullName, pkColumns, entry);
+    } else if (entry.op === "update") {
+      this.applyUpdate(fullName, entry);
+    } else {
+      this.applyDelete(fullName, entry);
+    }
+  }
+  applyInsert(fullName, pkColumns, entry) {
+    const row = entry.row ?? {};
+    const cols = Object.keys(row);
+    if (cols.length === 0) return;
+    const colList = cols.map(q).join(", ");
+    const placeholders = cols.map(() => "?").join(", ");
+    const values = cols.map((c) => row[c]);
+    if (pkColumns.length === 0) {
+      this.db.prepare(`INSERT OR IGNORE INTO ${q(fullName)} (${colList}) VALUES (${placeholders})`).run(...values);
+      return;
+    }
+    const conflictTarget = pkColumns.map(q).join(", ");
+    const updateCols = cols.filter((c) => !pkColumns.includes(c));
+    if (updateCols.length === 0) {
+      this.db.prepare(
+        `INSERT OR IGNORE INTO ${q(fullName)} (${colList}) VALUES (${placeholders})`
+      ).run(...values);
+      return;
+    }
+    const setClause = updateCols.map((c) => `${q(c)} = excluded.${q(c)}`).join(", ");
+    this.db.prepare(
+      `INSERT INTO ${q(fullName)} (${colList}) VALUES (${placeholders})
+         ON CONFLICT(${conflictTarget}) DO UPDATE SET ${setClause}
+         WHERE excluded.updated_at > ${q(fullName)}.updated_at`
+    ).run(...values);
+  }
+  applyUpdate(fullName, entry) {
+    const patch = entry.row ?? {};
+    const where = entry.where ?? {};
+    const patchCols = Object.keys(patch);
+    const whereCols = Object.keys(where);
+    if (patchCols.length === 0) return;
+    const setClause = patchCols.map((c) => `${q(c)} = ?`).join(", ");
+    const incomingUpdatedAt = patch["updated_at"];
+    const conditions = whereCols.map((c) => `${q(c)} = ?`);
+    if (incomingUpdatedAt) conditions.push(`updated_at < ?`);
+    const whereClause = conditions.length ? " WHERE " + conditions.join(" AND ") : "";
+    const params = [
+      ...patchCols.map((c) => patch[c]),
+      ...whereCols.map((c) => where[c])
+    ];
+    if (incomingUpdatedAt) params.push(incomingUpdatedAt);
+    this.db.prepare(`UPDATE ${q(fullName)} SET ${setClause}${whereClause}`).run(...params);
+  }
+  applyDelete(fullName, entry) {
+    const where = entry.where ?? {};
+    const whereCols = Object.keys(where);
+    const incomingUpdatedAt = entry.row?.["updated_at"];
+    const ts = incomingUpdatedAt ?? (0, import_protocol_primitives5.serializeHLC)(entry.timestamp);
+    const conditions = [
+      ...whereCols.map((c) => `${q(c)} = ?`),
+      `(updated_at IS NULL OR updated_at < ?)`
+    ];
+    const whereClause = " WHERE " + conditions.join(" AND ");
+    const params = [
+      ts,
+      ts,
+      ...whereCols.map((c) => where[c]),
+      ts
+      // for the LWW updated_at < ? condition
+    ];
+    this.db.prepare(
+      `UPDATE ${q(fullName)} SET deleted_at = ?, updated_at = ?${whereClause}`
+    ).run(...params);
+  }
+  /**
+   * Pull-side synthesis: return rows updated after `sinceHlcStr` (or `cursor`
+   * if higher) in HLC order, paginated. `updated_at` is a serialized HLC
+   * whose lexicographic order matches HLC order (fixed-width hex), and each
+   * row's HLC is unique per node, so it doubles as the cursor — no separate
+   * tiebreaker column is needed.
+   */
+  async scanSince(appId, table, sinceHlcStr, options) {
+    const fullName = appSyncableTableName(appId, table);
+    const floor = options?.cursor !== void 0 && options.cursor > sinceHlcStr ? options.cursor : sinceHlcStr;
+    const limit = options?.limit;
+    let rows;
+    try {
+      if (limit !== void 0) {
+        rows = this.db.prepare(
+          `SELECT * FROM ${q(fullName)} WHERE updated_at > ? ORDER BY updated_at ASC LIMIT ?`
+        ).all(floor, limit + 1);
+      } else {
+        rows = this.db.prepare(
+          `SELECT * FROM ${q(fullName)} WHERE updated_at > ? ORDER BY updated_at ASC`
+        ).all(floor);
+      }
+    } catch {
+      return { rows: [], nextCursor: null, hasMore: false };
+    }
+    const hasMore = limit !== void 0 && rows.length > limit;
+    const pageRows = hasMore ? rows.slice(0, limit) : rows;
+    const entries = pageRows.map((row) => rowToEntry(appId, table, row));
+    const nextCursor = hasMore && pageRows.length > 0 ? pageRows[pageRows.length - 1]["updated_at"] : null;
+    return { rows: entries, nextCursor, hasMore };
+  }
+  /** Support read path from the factory's queryRows. */
+  queryRows(appId, table, where) {
+    const fullName = appSyncableTableName(appId, table);
+    const whereCols = where ? Object.keys(where) : [];
+    const whereClause = [
+      "deleted_at IS NULL",
+      ...whereCols.map((c) => `${q(c)} = ?`)
+    ].join(" AND ");
+    return this.db.prepare(`SELECT * FROM ${q(fullName)} WHERE ${whereClause}`).all(...whereCols.map((c) => where[c]));
+  }
+};
+function q(name) {
+  return `"${name}"`;
+}
+function rowToEntry(appId, table, row) {
+  const updatedAtStr = row["updated_at"];
+  const deletedAtStr = row["deleted_at"];
+  const timestamp = (0, import_protocol_primitives5.deserializeHLC)(updatedAtStr);
+  if (deletedAtStr) {
+    return { timestamp, appId, table, op: "delete", row };
+  }
+  return { timestamp, appId, table, op: "insert", row };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SqliteAppSyncableApplier,
+  SqliteAppSyncableNamespaceStore,
+  SqliteDatabaseAdapter,
+  appSyncableTableName,
+  createSqliteAccessPolicyStore,
+  deleteAppSyncableNamespace,
+  getAppSyncableNamespace,
+  initializeLocalSchema,
+  listAppSyncableNamespaces,
+  upsertAppSyncableNamespace
+});
+//# sourceMappingURL=index.cjs.map