@neetru/sdk 1.2.0 → 2.1.0

package/dist/db.cjs

@@ -1,27 +1,48 @@
 'use strict';
 
+var idb = require('idb');
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
 // src/errors.ts
-var NeetruError = class _NeetruError extends Error {
-  code;
-  status;
-  requestId;
-  constructor(code, message, status, requestId) {
-    super(message);
-    this.name = "NeetruError";
-    this.code = code;
-    this.status = status;
-    this.requestId = requestId;
-    Object.setPrototypeOf(this, _NeetruError.prototype);
+var NeetruError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    NeetruError = class _NeetruError extends Error {
+      code;
+      status;
+      requestId;
+      constructor(code, message, status, requestId) {
+        super(message);
+        this.name = "NeetruError";
+        this.code = code;
+        this.status = status;
+        this.requestId = requestId;
+        Object.setPrototypeOf(this, _NeetruError.prototype);
+      }
+    };
   }
-};
+});
 
 // src/http.ts
-var DEFAULT_RETRIES = 2;
-var RETRYABLE_CODES = /* @__PURE__ */ new Set([
-  "rate_limited",
-  "server_error",
-  "network_error"
-]);
+var http_exports = {};
+__export(http_exports, {
+  httpRequest: () => httpRequest
+});
 function backoffMs(attempt) {
   const base = 200 * Math.pow(4, attempt);
   const jitter = base * 0.2 * (Math.random() * 2 - 1);
@@ -128,7 +149,7 @@ async function httpRequest(config, opts) {
     }
     const err = new NeetruError(code, message, res.status, requestId);
     lastError = err;
-    const isRetryable = RETRYABLE_CODES.has(code);
+    const isRetryable = RETRYABLE_CODES2.has(code);
     if (isRetryable && attempt < maxRetries) {
       const retryAfter = parseRetryAfter(res.headers.get("retry-after"));
       const delay = retryAfter ?? backoffMs(attempt);
@@ -139,139 +160,3586 @@ async function httpRequest(config, opts) {
   }
   throw lastError ?? new NeetruError("unknown", "unexpected httpRequest exit");
 }
+var DEFAULT_RETRIES, RETRYABLE_CODES2;
+var init_http = __esm({
+  "src/http.ts"() {
+    init_errors();
+    DEFAULT_RETRIES = 2;
+    RETRYABLE_CODES2 = /* @__PURE__ */ new Set([
+      "rate_limited",
+      "server_error",
+      "network_error"
+    ]);
+  }
+});
 
-// src/db.ts
-var COLL_RE = /^[a-z0-9][a-z0-9_-]{0,62}$/;
-function assertValidCollection(name) {
-  if (!COLL_RE.test(name)) {
-    throw new NeetruError(
-      "validation_failed",
-      `Invalid collection name: "${name}". Must match ${COLL_RE}.`
-    );
+// src/db-errors.ts
+init_errors();
+var RETRYABLE_CODES = /* @__PURE__ */ new Set([
+  "db_unavailable",
+  "db_conflict",
+  "db_timeout"
+]);
+var NeetruDbError = class _NeetruDbError extends NeetruError {
+  /** Código de erro fechado — específico de DB. */
+  code;
+  /**
+   * `true` para erros transientes que o produto pode tentar novamente.
+   * São retryable: `db_unavailable`, `db_conflict`, `db_timeout`.
+   */
+  retryable;
+  /**
+   * ID opaco do banco lógico — só para correlação com logs do Core.
+   * Nunca deve ser exibido ao usuário final.
+   */
+  dbId;
+  constructor(code, message, dbId) {
+    super(code, message);
+    this.name = "NeetruDbError";
+    this.code = code;
+    this.retryable = RETRYABLE_CODES.has(code);
+    this.dbId = dbId;
+    Object.setPrototypeOf(this, _NeetruDbError.prototype);
   }
+};
+
+// src/db/offline/query-engine.ts
+function typeRank(v) {
+  if (v === null || v === void 0) return 0;
+  if (typeof v === "number") return 1;
+  if (typeof v === "string") return 2;
+  if (typeof v === "boolean") return 3;
+  return 4;
 }
-function serializeWhere(filter) {
-  const { field, op, value } = filter;
-  if (op === "in") {
-    if (!Array.isArray(value)) {
-      throw new NeetruError(
-        "validation_failed",
-        `where op="in" requer value array (recebido: ${typeof value})`
+function compareValues(a, b) {
+  const ra = typeRank(a);
+  const rb = typeRank(b);
+  if (ra !== rb) return ra - rb;
+  if (a === null || a === void 0) return 0;
+  if (typeof a === "number" && typeof b === "number") return a - b;
+  if (typeof a === "string" && typeof b === "string") return a < b ? -1 : a > b ? 1 : 0;
+  if (typeof a === "boolean" && typeof b === "boolean") return a === b ? 0 : a ? 1 : -1;
+  const sa = String(a);
+  const sb = String(b);
+  return sa < sb ? -1 : sa > sb ? 1 : 0;
+}
+function getField(data, field) {
+  const parts = field.split(".");
+  let current = data;
+  for (const part of parts) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
+    }
+    current = current[part];
+  }
+  return current;
+}
+function evaluateFilter(data, filter) {
+  const fieldValue = getField(data, filter.field);
+  if (fieldValue === void 0) return false;
+  const { op, value } = filter;
+  switch (op) {
+    case "==":
+      return fieldValue === value;
+    case "!=":
+      return fieldValue !== value;
+    case "<":
+      return compareValues(fieldValue, value) < 0;
+    case "<=":
+      return compareValues(fieldValue, value) <= 0;
+    case ">":
+      return compareValues(fieldValue, value) > 0;
+    case ">=":
+      return compareValues(fieldValue, value) >= 0;
+    case "array-contains":
+      return Array.isArray(fieldValue) && fieldValue.includes(value);
+    case "in":
+      if (!Array.isArray(value)) return false;
+      return value.includes(fieldValue);
+    case "not-in":
+      if (!Array.isArray(value)) return true;
+      return !value.includes(fieldValue);
+    default:
+      return false;
+  }
+}
+function matchesAllFilters(data, filters) {
+  return filters.every((f) => evaluateFilter(data, f));
+}
+function buildComparator(orderBy) {
+  return (a, b) => {
+    if (orderBy) {
+      const aVal = getField(a.data, orderBy.field);
+      const bVal = getField(b.data, orderBy.field);
+      const cmp = compareValues(aVal, bVal);
+      if (cmp !== 0) {
+        return orderBy.direction === "desc" ? -cmp : cmp;
+      }
+    }
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+  };
+}
+function applyCursor(sorted, cursor) {
+  const idx = sorted.findIndex((d) => d.id === cursor.docId);
+  if (idx === -1) {
+    return sorted;
+  }
+  if (cursor.type === "startAfter") {
+    return sorted.slice(idx + 1);
+  } else {
+    return sorted.slice(0, idx);
+  }
+}
+var QueryEngine = class _QueryEngine {
+  /**
+   * Avalia um `QueryDescriptor` contra um array de `OfflineDoc`.
+   *
+   * Pipeline (I3 §5.3):
+   * 1. Filtra docs com `deleted:false`.
+   * 2. Aplica `where` (AND de todos os filtros).
+   * 3. Ordena por `orderBy` + tie-break por docId.
+   * 4. Aplica cursor (`startAfter` / `endBefore`).
+   * 5. Corta em `limit`.
+   */
+  evaluate(docs, query) {
+    let filtered = docs.filter((d) => !d.meta.deleted);
+    const filters = query.where ?? [];
+    if (filters.length > 0) {
+      filtered = filtered.filter(
+        (d) => matchesAllFilters(d.data, filters)
       );
     }
-    return `${field}:in:${value.map((v) => String(v)).join(",")}`;
+    const comparator = buildComparator(query.orderBy);
+    const sorted = [...filtered].sort(comparator);
+    const afterCursor = query.cursor ? applyCursor(sorted, query.cursor) : sorted;
+    const limitN = Math.min(query.limit ?? 20, 500);
+    const limited = afterCursor.slice(0, limitN);
+    return {
+      docs: limited.map((d) => ({ id: d.id, data: d.data })),
+      // `incomplete` é sempre true aqui — o QueryEngine não sabe se o cache
+      // tem todos os docs da coleção. É responsabilidade do chamador (LocalStore)
+      // injetar o flag de completude baseado nos metadados do query_cache.
+      incomplete: true
+    };
+  }
+  // ─── Static helper ─────────────────────────────────────────────────────────
+  /**
+   * Helper estático para uso sem instanciar a classe.
+   * Equivalente a `new QueryEngine().evaluate(docs, query)`.
+   */
+  static evaluate(docs, query) {
+    return new _QueryEngine().evaluate(docs, query);
+  }
+};
+
+// src/db/offline/local-store.ts
+var SCHEMA_VERSION = 1;
+var STORE_DOCUMENTS = "documents";
+var STORE_MUTATIONS = "mutations";
+var STORE_QUERY_CACHE = "query_cache";
+var STORE_SYNC_META = "sync_meta";
+var STORE_CONFLICT_LOG = "conflict_log";
+var LocalStore = class {
+  db = null;
+  dbName;
+  constructor(dbName) {
+    this.dbName = dbName;
+  }
+  // ─── Ciclo de vida ──────────────────────────────────────────────────────────
+  /**
+   * Abre (ou reabre) o banco IndexedDB e executa o upgrade de schema se necessário.
+   * Idempotente — chamadas subsequentes são no-ops se o banco já está aberto.
+   */
+  async open() {
+    if (this.db !== null) return;
+    this.db = await idb.openDB(this.dbName, SCHEMA_VERSION, {
+      upgrade(db) {
+        if (!db.objectStoreNames.contains(STORE_DOCUMENTS)) {
+          const docsStore = db.createObjectStore(STORE_DOCUMENTS, {
+            keyPath: ["collection", "id"]
+          });
+          docsStore.createIndex("by_collection", "collection");
+          docsStore.createIndex("by_collection_state", ["collection", "meta.state"]);
+          docsStore.createIndex("by_updatedAtServer", "meta.updatedAtServer");
+        }
+        if (!db.objectStoreNames.contains(STORE_MUTATIONS)) {
+          const mutStore = db.createObjectStore(STORE_MUTATIONS, {
+            keyPath: "mutationId"
+          });
+          mutStore.createIndex("by_seq", "seq");
+          mutStore.createIndex("by_status", "status");
+          mutStore.createIndex("by_doc", ["collection", "docId"]);
+          mutStore.createIndex("by_batch", "batchId");
+        }
+        if (!db.objectStoreNames.contains(STORE_QUERY_CACHE)) {
+          db.createObjectStore(STORE_QUERY_CACHE, { keyPath: "queryHash" });
+        }
+        if (!db.objectStoreNames.contains(STORE_SYNC_META)) {
+          db.createObjectStore(STORE_SYNC_META, { keyPath: "key" });
+        }
+        if (!db.objectStoreNames.contains(STORE_CONFLICT_LOG)) {
+          const conflictStore = db.createObjectStore(STORE_CONFLICT_LOG, {
+            keyPath: "id",
+            autoIncrement: true
+          });
+          conflictStore.createIndex("by_delivered", "delivered");
+          conflictStore.createIndex("by_doc", ["collection", "docId"]);
+        }
+      }
+    });
+  }
+  /** Fecha o banco IndexedDB. */
+  async close() {
+    this.db?.close();
+    this.db = null;
+  }
+  assertOpen() {
+    if (this.db === null) {
+      throw new Error("LocalStore: banco n\xE3o est\xE1 aberto. Chame open() primeiro.");
+    }
+    return this.db;
+  }
+  // ─── Documents ──────────────────────────────────────────────────────────────
+  /**
+   * Retorna um documento pelo [collection, id], ou `null` se não existir.
+   * Retorna tombstones (deleted: true) — o chamador decide se deve mostrá-los.
+   */
+  async getDoc(collection, id) {
+    const db = this.assertOpen();
+    const result = await db.get(STORE_DOCUMENTS, [collection, id]);
+    return result ?? null;
+  }
+  /**
+   * Insere ou atualiza um documento na store `documents`.
+   * O documento é identificado pelo keyPath composto `[collection, id]`.
+   */
+  async putDoc(doc) {
+    const db = this.assertOpen();
+    await db.put(STORE_DOCUMENTS, doc);
+  }
+  /**
+   * Marca um documento como tombstone (`deleted: true`).
+   * Não remove fisicamente — o tombstone é necessário para reconciliação.
+   * No-op se o documento não existir.
+   */
+  async deleteDoc(collection, id) {
+    const db = this.assertOpen();
+    const existing = await db.get(STORE_DOCUMENTS, [collection, id]);
+    if (!existing) return;
+    await db.put(STORE_DOCUMENTS, {
+      ...existing,
+      meta: {
+        ...existing.meta,
+        deleted: true,
+        updatedAtLocal: Date.now()
+      }
+    });
+  }
+  /**
+   * Lista documentos de uma coleção, aplicando o QueryDescriptor via QueryEngine.
+   *
+   * I3 §5.3: a listagem lê todos os docs da coleção pelo índice `by_collection`
+   * e delega a filtragem/ordenação/paginação ao QueryEngine (que opera em memória).
+   */
+  async listDocs(collection, query) {
+    const db = this.assertOpen();
+    const rawDocs = await db.getAllFromIndex(STORE_DOCUMENTS, "by_collection", collection);
+    return QueryEngine.evaluate(rawDocs, query);
+  }
+  // ─── Sync meta (key-value) ──────────────────────────────────────────────────
+  /**
+   * Retorna o valor de uma chave da store `sync_meta`, ou `null` se não existir.
+   *
+   * Chaves conhecidas (I3 §3.3):
+   *   'lastSyncWatermark', 'resumeToken:<col>', 'schemaVersion',
+   *   'lastFullResyncAt', 'leaderTabId'.
+   */
+  async getMeta(key) {
+    const db = this.assertOpen();
+    const entry = await db.get(STORE_SYNC_META, key);
+    if (!entry) return null;
+    return entry.value;
+  }
+  /**
+   * Armazena ou atualiza um valor na store `sync_meta`.
+   */
+  async setMeta(key, value) {
+    const db = this.assertOpen();
+    await db.put(STORE_SYNC_META, { key, value });
+  }
+  // ─── Conflict log ───────────────────────────────────────────────────────────
+  /**
+   * Adiciona um registro de conflito ao `conflict_log`.
+   * O `id` é autoIncrement — não deve ser fornecido pelo chamador.
+   */
+  async appendConflict(record) {
+    const db = this.assertOpen();
+    const id = await db.add(STORE_CONFLICT_LOG, record);
+    return { ...record, id };
+  }
+  /**
+   * Lista registros do `conflict_log`.
+   * Filtra por `delivered` se a opção for fornecida.
+   */
+  async listConflicts(options) {
+    const db = this.assertOpen();
+    const all = await db.getAll(STORE_CONFLICT_LOG);
+    if (options?.delivered !== void 0) {
+      return all.filter((r) => r.delivered === options.delivered);
+    }
+    return all;
+  }
+  /**
+   * Marca um registro do `conflict_log` como entregue ao produto.
+   */
+  async markConflictDelivered(id) {
+    const db = this.assertOpen();
+    const existing = await db.get(STORE_CONFLICT_LOG, id);
+    if (!existing) return;
+    await db.put(STORE_CONFLICT_LOG, { ...existing, delivered: true });
+  }
+  // ─── Mutations (acessores usados pelo MutationQueue) ────────────────────────
+  /**
+   * Insere ou atualiza uma mutação na store `mutations`.
+   * Key: `mutationId`.
+   */
+  async putMutation(mutation) {
+    const db = this.assertOpen();
+    await db.put(STORE_MUTATIONS, mutation);
+  }
+  /**
+   * Retorna uma mutação pelo `mutationId`, ou `null` se não existir.
+   */
+  async getMutation(mutationId) {
+    const db = this.assertOpen();
+    const result = await db.get(STORE_MUTATIONS, mutationId);
+    return result ?? null;
+  }
+  /**
+   * Lista mutações com filtros opcionais.
+   * Resultado ordenado por `seq` crescente.
+   */
+  async listMutations(options) {
+    const db = this.assertOpen();
+    let mutations;
+    if (options?.status !== void 0) {
+      mutations = await db.getAllFromIndex(STORE_MUTATIONS, "by_status", options.status);
+    } else if (options?.collection !== void 0 && options.docId !== void 0) {
+      mutations = await db.getAllFromIndex(STORE_MUTATIONS, "by_doc", [options.collection, options.docId]);
+    } else {
+      mutations = await db.getAllFromIndex(STORE_MUTATIONS, "by_seq");
+    }
+    return mutations.sort((a, b) => a.seq - b.seq);
+  }
+  /**
+   * Remove uma mutação pelo `mutationId`.
+   * No-op se não existir.
+   */
+  async deleteMutation(mutationId) {
+    const db = this.assertOpen();
+    await db.delete(STORE_MUTATIONS, mutationId);
+  }
+  // ─── Collection discovery ────────────────────────────────────────────────────
+  /**
+   * Retorna a lista de coleções únicas presentes na store `documents`.
+   *
+   * Usado pelo SyncEngine no full resync para descobrir coleções cujos docs
+   * precisam ser verificados contra a resposta do servidor (tombstone detection).
+   *
+   * Implementação: itera o índice `by_collection` com `openKeyCursor` para
+   * coletar os valores únicos de forma eficiente (sem carregar os docs completos).
+   */
+  async listCollections() {
+    const db = this.assertOpen();
+    const allDocs = await db.getAllFromIndex(STORE_DOCUMENTS, "by_collection");
+    const collections = /* @__PURE__ */ new Set();
+    for (const doc of allDocs) {
+      collections.add(doc.collection);
+    }
+    return Array.from(collections);
+  }
+  // ─── Query cache ─────────────────────────────────────────────────────────────
+  /**
+   * Retorna a entrada de `query_cache` para um hash de query, ou `null`.
+   */
+  async getQueryCache(queryHash) {
+    const db = this.assertOpen();
+    const result = await db.get(STORE_QUERY_CACHE, queryHash);
+    return result ?? null;
   }
-  return `${field}:${op}:${String(value)}`;
+  /**
+   * Insere ou atualiza uma entrada de `query_cache`.
+   */
+  async putQueryCache(entry) {
+    const db = this.assertOpen();
+    await db.put(STORE_QUERY_CACHE, entry);
+  }
+  /**
+   * Remove uma entrada de `query_cache` pelo queryHash.
+   */
+  async deleteQueryCache(queryHash) {
+    const db = this.assertOpen();
+    await db.delete(STORE_QUERY_CACHE, queryHash);
+  }
+};
+
+// src/db/offline/mutation-queue.ts
+function generateUUIDv4() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
 }
-function createDbNamespace(config) {
-  return {
-    collection(name) {
-      assertValidCollection(name);
-      const headers = {};
-      if (config.tenantId) headers["x-neetru-tenant"] = config.tenantId;
+var MutationQueue = class {
+  store;
+  /**
+   * Ponteiro de sequência local.
+   * Inicializado com 0 — o primeiro enqueue sincroniza o valor real do banco
+   * (`_syncSeq`), garantindo que nunca sobreponha um seq existente.
+   */
+  seqCounter = 0;
+  seqSynced = false;
+  constructor(store) {
+    this.store = store;
+  }
+  // ─── Seq management ─────────────────────────────────────────────────────────
+  /**
+   * Sincroniza o ponteiro de seq com o maior seq existente no banco.
+   * Chamado lazy no primeiro enqueue.
+   */
+  async syncSeq() {
+    if (this.seqSynced) return;
+    const all = await this.store.listMutations();
+    if (all.length > 0) {
+      const maxSeq = Math.max(...all.map((m) => m.seq));
+      this.seqCounter = maxSeq;
+    }
+    this.seqSynced = true;
+  }
+  nextSeq() {
+    this.seqCounter += 1;
+    return this.seqCounter;
+  }
+  // ─── Coalescing ─────────────────────────────────────────────────────────────
+  /**
+   * Tenta coalescir `newOp`/`newPayload` com a mutação existente `existing`.
+   *
+   * Regras de coalescing (I3 §4.4):
+   *   - update + update → update com merge dos campos (segundo vence nos conflitos)
+   *   - add + update    → add com campos mesclados
+   *   - add + remove    → nada (remove a mutação existente, retorna null para remove)
+   *   - set + update    → set com campos mesclados
+   *   - any + remove (base servidor) → remove
+   *
+   * Retorna:
+   *   - `{ coalesced: Mutation }` — substitui a mutação existente (update in-place)
+   *   - `{ removed: true }`       — a mutação existente deve ser deletada (add+remove)
+   *   - `null`                    — não é possível coalescir
+   */
+  tryCoalesce(existing, newOp, newPayload, newBatchId) {
+    if (existing.batchId !== newBatchId) return null;
+    if (existing.status === "inflight") return null;
+    const existingOp = existing.op;
+    if (existingOp === "add" && newOp === "remove") {
+      return { removed: true };
+    }
+    if (existingOp === "update" && newOp === "update") {
       return {
-        async list(opts) {
-          let path = `/api/sdk/v1/datastore/${name}`;
-          const params = new URLSearchParams();
-          if (opts?.limit !== void 0) params.set("limit", String(opts.limit));
-          if (opts?.where && opts.where.length > 0) {
-            for (const f of opts.where) {
-              params.append("where", serializeWhere(f));
-            }
-          }
-          if (config.tenantId) params.set("tenantId", config.tenantId);
-          const qs = params.toString();
-          if (qs) path += `?${qs}`;
-          const raw = await httpRequest(config, {
-            method: "GET",
-            path,
-            requireAuth: true,
-            headers
-          });
-          if (!raw || !Array.isArray(raw.items)) {
-            throw new NeetruError(
-              "invalid_response",
-              "datastore.list missing items[]"
-            );
-          }
-          return raw.items;
-        },
-        async get(id) {
-          if (!id || typeof id !== "string") {
-            throw new NeetruError("validation_failed", "id required");
+        coalesced: {
+          ...existing,
+          payload: { ...existing.payload ?? {}, ...newPayload ?? {} }
+        }
+      };
+    }
+    if (existingOp === "add" && newOp === "update") {
+      return {
+        coalesced: {
+          ...existing,
+          op: "add",
+          payload: { ...existing.payload ?? {}, ...newPayload ?? {} }
+        }
+      };
+    }
+    if (existingOp === "set" && newOp === "update") {
+      return {
+        coalesced: {
+          ...existing,
+          op: "set",
+          payload: { ...existing.payload ?? {}, ...newPayload ?? {} }
+        }
+      };
+    }
+    if (newOp === "remove") {
+      return {
+        coalesced: {
+          ...existing,
+          op: "remove",
+          payload: null
+        }
+      };
+    }
+    return null;
+  }
+  // ─── Enqueue ─────────────────────────────────────────────────────────────────
+  /**
+   * Enfileira uma nova mutação.
+   *
+   * Processo (I3 §4.1):
+   * 1. Gera docId se op=add e não fornecido.
+   * 2. Sincroniza seq (lazy).
+   * 3. Tenta coalescir com a última mutação queued do mesmo [collection, docId].
+   * 4. Se coalescing:
+   *    - `removed` → deleta mutação existente; retorna sem enfileirar nova.
+   *    - `coalesced` → substitui a mutação existente (mesmo seq, mesmo mutationId).
+   * 5. Se não coalesce → enfileira nova mutação (novo seq, novo mutationId).
+   *
+   * Atômico: a persistência final é uma única operação putMutation.
+   */
+  async enqueue(params) {
+    const { collection, op, payload, baseVersion, batchId } = params;
+    const docId = params.docId ?? (op === "add" ? generateUUIDv4() : "");
+    await this.syncSeq();
+    const existingMutations = await this.store.listMutations({ collection, docId });
+    const lastQueued = existingMutations.filter((m) => m.status === "queued").sort((a, b) => b.seq - a.seq)[0];
+    if (lastQueued !== void 0) {
+      const coalesceResult = this.tryCoalesce(lastQueued, op, payload, batchId);
+      if (coalesceResult !== null) {
+        if ("removed" in coalesceResult) {
+          await this.store.deleteMutation(lastQueued.mutationId);
+          const phantomMut = {
+            seq: lastQueued.seq,
+            mutationId: generateUUIDv4(),
+            collection,
+            docId,
+            op: "remove",
+            payload: null,
+            baseVersion,
+            enqueuedAt: Date.now(),
+            attempts: 0,
+            lastError: null,
+            status: "queued",
+            batchId
+          };
+          return phantomMut;
+        }
+        const { coalesced } = coalesceResult;
+        await this.store.putMutation(coalesced);
+        return coalesced;
+      }
+    }
+    const seq = this.nextSeq();
+    const mutation = {
+      seq,
+      mutationId: generateUUIDv4(),
+      collection,
+      docId,
+      op,
+      payload,
+      baseVersion,
+      enqueuedAt: Date.now(),
+      attempts: 0,
+      lastError: null,
+      status: "queued",
+      batchId
+    };
+    await this.store.putMutation(mutation);
+    return mutation;
+  }
+  // ─── Leitura da fila ─────────────────────────────────────────────────────────
+  /**
+   * Retorna a primeira mutação com status `queued` (menor seq), ou `null`.
+   */
+  async peek() {
+    const pending = await this.listPending();
+    return pending[0] ?? null;
+  }
+  /**
+   * Retorna todas as mutações com status `queued`, ordenadas por seq crescente.
+   */
+  async listPending() {
+    return this.store.listMutations({ status: "queued" });
+  }
+  /**
+   * Retorna TODAS as mutações (qualquer status), ordenadas por seq crescente.
+   * Útil para inspeção e testes.
+   */
+  async listAll() {
+    return this.store.listMutations();
+  }
+  /**
+   * Conta o número de mutações com status `queued`.
+   */
+  async countPending() {
+    const pending = await this.listPending();
+    return pending.length;
+  }
+  /**
+   * Retorna um lote de mutações `queued` para drenagem (I3 §6.2 FASE 1).
+   * Ordena por seq crescente. O SyncEngine chama drain(), itera, e marca
+   * cada mutação como applied/failed.
+   */
+  async drain(options) {
+    const pending = await this.listPending();
+    if (options?.maxBatch !== void 0 && options.maxBatch > 0) {
+      return pending.slice(0, options.maxBatch);
+    }
+    return pending;
+  }
+  // ─── Ciclo de vida de mutações ────────────────────────────────────────────────
+  /**
+   * Marca uma mutação como `inflight` (está sendo enviada ao Core).
+   * Chamado pelo SyncEngine antes de enviar o request.
+   */
+  async markInflight(mutationId) {
+    const mut = await this.store.getMutation(mutationId);
+    if (!mut) return;
+    await this.store.putMutation({ ...mut, status: "inflight" });
+  }
+  /**
+   * Remove a mutação da fila (sucesso de replay).
+   * Chamado pelo SyncEngine ao receber confirmação do Core.
+   */
+  async markApplied(mutationId) {
+    await this.store.deleteMutation(mutationId);
+  }
+  /**
+   * Marca uma mutação como `failed` e registra o erro.
+   * Incrementa `attempts`. Chamado pelo SyncEngine em falha permanente.
+   */
+  async markFailed(mutationId, error) {
+    const mut = await this.store.getMutation(mutationId);
+    if (!mut) return;
+    await this.store.putMutation({
+      ...mut,
+      status: "failed",
+      lastError: error,
+      attempts: mut.attempts + 1
+    });
+  }
+  /**
+   * Incrementa `attempts` e volta para `queued` (falha transiente com backoff).
+   * Chamado pelo SyncEngine em falha transiente (5xx, timeout).
+   */
+  async markRetry(mutationId, error) {
+    const mut = await this.store.getMutation(mutationId);
+    if (!mut) return;
+    await this.store.putMutation({
+      ...mut,
+      status: "queued",
+      lastError: error,
+      attempts: mut.attempts + 1
+    });
+  }
+};
+
+// src/db/offline/sync-engine.ts
+var SyncEngine = class {
+  _store;
+  _queue;
+  _resolver;
+  _bus;
+  _transport;
+  _tabCoordinator;
+  _connectivity;
+  /** `true` se um sync está atualmente em progresso — guarda re-entrância. */
+  _syncing = false;
+  /** `true` se destroy() foi chamado. */
+  _destroyed = false;
+  /**
+   * Conjunto de coleções "conhecidas" pelo engine.
+   * Populado ao aplicar docs do servidor (Fase 1 e 2) e ao ler do cache.
+   * Persiste em sync_meta['activeCollections'] para sobreviver a reloads.
+   */
+  _activeCollections = /* @__PURE__ */ new Set();
+  /** Estado de sync atual (fonte de verdade em RAM). */
+  _state;
+  /** Listeners de mudança de SyncState. */
+  _stateListeners = /* @__PURE__ */ new Set();
+  /** Cleanup functions dos listeners externos. */
+  _cleanups = [];
+  /** Timer de resync periódico. */
+  _periodicTimer = null;
+  constructor(opts) {
+    this._store = opts.store;
+    this._queue = opts.queue;
+    this._resolver = opts.resolver;
+    this._bus = opts.bus;
+    this._transport = opts.transport;
+    this._tabCoordinator = opts.tabCoordinator;
+    this._connectivity = opts.connectivity;
+    this._state = this._buildInitialState();
+    this._wireListeners();
+    const intervalMs = opts.periodicSyncIntervalMs ?? 5 * 60 * 1e3;
+    if (intervalMs > 0) {
+      this._periodicTimer = setInterval(() => {
+        this._triggerSync("periodic");
+      }, intervalMs);
+    }
+  }
+  // ─── API pública ─────────────────────────────────────────────────────────────
+  /**
+   * Expõe o transporte de sync para acesso direto por `DbCollectionRefImpl`.
+   * Necessário para que `onSnapshot` possa chamar `subscribeCollection` no
+   * transport nosql-vm (HIGH-1 fix — realtime deltas).
+   */
+  get transport() {
+    return this._transport;
+  }
+  /**
+   * Retorna o estado de sync atual (snapshot síncrono).
+   * Equivale a `client.db.syncState` na API pública do SDK (I3 §10.3).
+   *
+   * `pendingWrites` reflete o valor mais recente calculado de forma assíncrona.
+   * Para garantir o valor mais atualizado, aguarde `refreshPendingWrites()` antes.
+   */
+  getSyncState() {
+    return { ...this._state };
+  }
+  /**
+   * Força a atualização de `pendingWrites` e retorna o estado atualizado.
+   * Útil quando o chamador precisa do pendingWrites fresco sem aguardar um sync.
+   */
+  async refreshPendingWrites() {
+    await this._refreshPendingWrites();
+    return { ...this._state };
+  }
+  /**
+   * Registra um listener de mudanças no SyncState.
+   * Retorna uma função de unsubscribe.
+   */
+  onSyncStateChange(cb) {
+    this._stateListeners.add(cb);
+    return () => {
+      this._stateListeners.delete(cb);
+    };
+  }
+  /**
+   * Força um sync imediato (I3 §10.3 `flush()`).
+   * Resolve quando a fila esvazia OU rejeita se o engine estiver destruído.
+   */
+  async flush() {
+    if (this._destroyed) return;
+    await this.sync();
+  }
+  /**
+   * Executa as 3 fases de sincronização.
+   *
+   * Guarda re-entrância: se já está em progresso, retorna imediatamente.
+   * NÃO executa se esta aba não é líder ou se está offline.
+   */
+  async sync() {
+    if (this._destroyed) return;
+    if (!this._tabCoordinator.isLeader()) return;
+    if (!this._connectivity.isOnline) return;
+    if (this._syncing) return;
+    this._syncing = true;
+    this._updateState({ status: "syncing" });
+    try {
+      const phase1Ok = await this._phase1Push();
+      if (!phase1Ok) {
+        this._updateState({ status: "idle" });
+        this._syncing = false;
+        return;
+      }
+      await this._phase2Pull();
+      this._phase3Realtime();
+      this._updateState({ status: "idle", lastSyncedAt: Date.now() });
+    } catch (err) {
+      this._updateState({ status: "idle" });
+    } finally {
+      this._syncing = false;
+    }
+  }
+  /**
+   * Teardown: para timers, remove listeners, marca como destroyed.
+   */
+  destroy() {
+    if (this._destroyed) return;
+    this._destroyed = true;
+    if (this._periodicTimer !== null) {
+      clearInterval(this._periodicTimer);
+      this._periodicTimer = null;
+    }
+    for (const cleanup of this._cleanups) {
+      try {
+        cleanup();
+      } catch {
+      }
+    }
+    this._cleanups.length = 0;
+    this._stateListeners.clear();
+  }
+  // ─── FASE 1 — push (drenar a fila) ───────────────────────────────────────────
+  /**
+   * Drena a MutationQueue, enviando mutações em ordem de seq.
+   *
+   * Retorna `true` se a fase completou sem falhas transientes.
+   * Retorna `false` se houve falha transiente (ciclo deve ser abortado).
+   */
+  async _phase1Push() {
+    const mutations = await this._queue.drain();
+    if (mutations.length === 0) return true;
+    for (const mut of mutations) {
+      await this._queue.markInflight(mut.mutationId);
+    }
+    let result;
+    try {
+      result = await this._transport.pushMutations(mutations);
+    } catch (err) {
+      for (const mut of mutations) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        await this._queue.markRetry(mut.mutationId, errMsg);
+      }
+      return false;
+    }
+    const busChanges = [];
+    for (const res of result.results) {
+      const mut = mutations.find((m) => m.mutationId === res.mutationId);
+      if (!mut) continue;
+      if (res.outcome === "confirmed") {
+        await this._queue.markApplied(mut.mutationId);
+        await this._applySyncedDoc(
+          mut.collection,
+          mut.docId,
+          res.serverVersion,
+          res.serverTimestamp,
+          mut,
+          busChanges
+        );
+      } else if (res.outcome === "superseded") {
+        await this._queue.markApplied(mut.mutationId);
+        await this._applySuperseded(mut, res, busChanges);
+      } else if (res.outcome === "rejected") {
+        await this._queue.markApplied(mut.mutationId);
+        await this._applyRejected(mut, res, busChanges);
+      }
+    }
+    if (busChanges.length > 0) {
+      this._bus.emit(busChanges);
+    }
+    return true;
+  }
+  /** Atualiza o cache após confirmação de escrita (outcome=confirmed). */
+  async _applySyncedDoc(collection, docId, serverVersion, serverTimestamp, mut, busChanges) {
+    const existing = await this._store.getDoc(collection, docId);
+    if (mut.op === "remove") {
+      if (existing) {
+        await this._store.putDoc({
+          ...existing,
+          meta: {
+            ...existing.meta,
+            serverVersion,
+            updatedAtServer: serverTimestamp,
+            updatedAtLocal: Date.now(),
+            state: "synced",
+            deleted: true,
+            pendingMutationIds: []
           }
-          try {
-            const raw = await httpRequest(config, {
-              method: "GET",
-              path: `/api/sdk/v1/datastore/${name}/${encodeURIComponent(id)}`,
-              requireAuth: true,
-              headers
+        });
+        busChanges.push({ type: "removed", collection, doc: { id: docId, data: existing.data } });
+      }
+      return;
+    }
+    const newData = mut.payload ?? (existing?.data ?? {});
+    const updatedDoc = {
+      collection,
+      id: docId,
+      data: mut.op === "update" ? { ...existing?.data ?? {}, ...newData } : newData,
+      meta: {
+        serverVersion,
+        updatedAtServer: serverTimestamp,
+        updatedAtLocal: Date.now(),
+        state: "synced",
+        pendingMutationIds: [],
+        deleted: false,
+        ownerId: existing?.meta.ownerId ?? null
+      }
+    };
+    await this._store.putDoc(updatedDoc);
+    busChanges.push({
+      type: existing ? "modified" : "added",
+      collection,
+      doc: { id: docId, data: updatedDoc.data }
+    });
+  }
+  /** Processa resultado 'superseded' (LWW: servidor venceu). */
+  async _applySuperseded(mut, res, busChanges) {
+    const localDoc = await this._store.getDoc(mut.collection, mut.docId);
+    const serverDocEnvelope = {
+      collection: mut.collection,
+      id: mut.docId,
+      data: res.serverData,
+      meta: {
+        serverVersion: res.serverVersion,
+        updatedAtServer: res.serverTimestamp,
+        updatedAtLocal: Date.now(),
+        state: "synced",
+        pendingMutationIds: [],
+        deleted: false,
+        ownerId: localDoc?.meta.ownerId ?? null
+      }
+    };
+    const localDocForResolver = localDoc ?? {
+      collection: mut.collection,
+      id: mut.docId,
+      data: mut.payload ?? {},
+      meta: {
+        serverVersion: mut.baseVersion,
+        updatedAtServer: res.serverTimestamp - 1,
+        // garante server é mais novo
+        updatedAtLocal: mut.enqueuedAt,
+        state: "pending",
+        pendingMutationIds: [mut.mutationId],
+        deleted: false,
+        ownerId: null
+      }
+    };
+    const resolveResult = this._resolver.resolve(
+      localDocForResolver,
+      serverDocEnvelope,
+      mut
+    );
+    const conflictRecord = resolveResult.conflictRecord ?? {
+      collection: mut.collection,
+      docId: mut.docId,
+      mutationId: mut.mutationId,
+      losingData: mut.payload ?? {},
+      winningData: res.serverData,
+      reason: "lww_server_newer",
+      detectedAt: Date.now(),
+      delivered: false
+    };
+    await this._store.appendConflict(conflictRecord);
+    const updatedDoc = {
+      collection: mut.collection,
+      id: mut.docId,
+      data: res.serverData,
+      meta: {
+        serverVersion: res.serverVersion,
+        updatedAtServer: res.serverTimestamp,
+        updatedAtLocal: Date.now(),
+        state: "synced",
+        pendingMutationIds: [],
+        deleted: false,
+        ownerId: localDoc?.meta.ownerId ?? null
+      }
+    };
+    await this._store.putDoc(updatedDoc);
+    busChanges.push({
+      type: localDoc ? "modified" : "added",
+      collection: mut.collection,
+      doc: { id: mut.docId, data: res.serverData }
+    });
+  }
+  /** Processa resultado 'rejected' (permissão/validação negada). */
+  async _applyRejected(mut, res, busChanges) {
+    const storedDoc = await this._store.getDoc(mut.collection, mut.docId);
+    const localDoc = storedDoc ?? {
+      collection: mut.collection,
+      id: mut.docId,
+      data: mut.payload ?? {},
+      meta: {
+        serverVersion: mut.baseVersion,
+        updatedAtServer: null,
+        updatedAtLocal: mut.enqueuedAt,
+        state: "pending",
+        pendingMutationIds: [mut.mutationId],
+        deleted: false,
+        ownerId: null
+      }
+    };
+    const serverDocEnvelope = res.serverData ? {
+      ...localDoc,
+      data: res.serverData,
+      meta: {
+        ...localDoc.meta,
+        serverVersion: res.serverVersion ?? localDoc.meta.serverVersion
+      }
+    } : null;
+    const resolveResult = this._resolver.resolveRejected(
+      localDoc,
+      serverDocEnvelope,
+      mut,
+      res.reason
+    );
+    const conflictRecord = resolveResult.conflictRecord ?? {
+      collection: mut.collection,
+      docId: mut.docId,
+      mutationId: mut.mutationId,
+      losingData: mut.payload ?? {},
+      winningData: res.serverData ?? {},
+      reason: res.reason,
+      detectedAt: Date.now(),
+      delivered: false
+    };
+    await this._store.appendConflict(conflictRecord);
+    if (res.serverData) {
+      await this._store.putDoc({
+        ...localDoc,
+        data: res.serverData,
+        meta: {
+          ...localDoc.meta,
+          state: "synced",
+          pendingMutationIds: []
+        }
+      });
+      busChanges.push({
+        type: "modified",
+        collection: mut.collection,
+        doc: { id: mut.docId, data: res.serverData }
+      });
+    } else {
+      await this._store.putDoc({
+        ...localDoc,
+        meta: {
+          ...localDoc.meta,
+          state: "synced",
+          pendingMutationIds: []
+        }
+      });
+    }
+  }
+  // ─── FASE 2 — pull (reconciliar o cache) ─────────────────────────────────────
+  /**
+   * Busca mudanças do servidor e aplica ao cache via ConflictResolver.
+   *
+   * Se `resyncRequired === true`, faz full resync em vez de pull incremental.
+   */
+  async _phase2Pull() {
+    const watermark = await this._store.getMeta("lastSyncWatermark");
+    const resumeToken = await this._store.getMeta("lastResumeToken");
+    let pullResult;
+    try {
+      pullResult = await this._transport.pullChanges(watermark, resumeToken);
+    } catch {
+      return;
+    }
+    if (pullResult.resyncRequired) {
+      await this._phase2FullResync();
+      return;
+    }
+    const busChanges = [];
+    await this._applyServerDocs(pullResult.docs, busChanges, false);
+    if (pullResult.newWatermark !== null) {
+      await this._store.setMeta("lastSyncWatermark", pullResult.newWatermark);
+    }
+    if (busChanges.length > 0) {
+      this._bus.emit(busChanges);
+    }
+  }
+  /** Full resync: lista completa + detecta deleções por ausência. */
+  async _phase2FullResync() {
+    const collections = await this._getActiveCollections();
+    let resyncResult;
+    try {
+      resyncResult = await this._transport.fullResync(collections);
+    } catch {
+      return;
+    }
+    const busChanges = [];
+    await this._applyServerDocs(resyncResult.docs, busChanges, true);
+    const returnedKeys = new Set(
+      resyncResult.docs.map((d) => `${d.collection}::${d.id}`)
+    );
+    for (const col of collections) {
+      const queryResult = await this._store.listDocs(col, {});
+      for (const { id } of queryResult.docs) {
+        const key = `${col}::${id}`;
+        if (!returnedKeys.has(key)) {
+          const fullDoc = await this._store.getDoc(col, id);
+          if (fullDoc && !fullDoc.meta.deleted) {
+            await this._store.putDoc({
+              ...fullDoc,
+              meta: {
+                ...fullDoc.meta,
+                deleted: true,
+                updatedAtLocal: Date.now(),
+                state: "synced"
+              }
+            });
+            busChanges.push({
+              type: "removed",
+              collection: col,
+              doc: { id, data: fullDoc.data }
             });
-            return raw?.item ?? null;
-          } catch (err) {
-            if (err instanceof NeetruError && err.code === "not_found") return null;
-            throw err;
-          }
-        },
-        async add(data) {
-          if (!data || typeof data !== "object") {
-            throw new NeetruError("validation_failed", "data object required");
           }
-          const raw = await httpRequest(config, {
-            method: "POST",
-            path: `/api/sdk/v1/datastore/${name}`,
-            body: { data },
-            requireAuth: true,
-            headers
+        }
+      }
+    }
+    if (resyncResult.newWatermark !== null) {
+      await this._store.setMeta("lastSyncWatermark", resyncResult.newWatermark);
+    }
+    await this._store.setMeta("lastFullResyncAt", Date.now());
+    if (busChanges.length > 0) {
+      this._bus.emit(busChanges);
+    }
+  }
+  /**
+   * Aplica uma lista de ServerDoc ao cache local via ConflictResolver.
+   *
+   * `isFullResync = true` indica que o conjunto é completo — usamos isso para
+   * otimizar a path (sempre sobrescreve docs synced; pending passam pelo LWW).
+   */
+  async _applyServerDocs(docs, busChanges, _isFullResync) {
+    for (const serverDoc of docs) {
+      const localDoc = await this._store.getDoc(serverDoc.collection, serverDoc.id);
+      if (serverDoc.deleted) {
+        if (localDoc && !localDoc.meta.deleted) {
+          await this._store.putDoc({
+            ...localDoc,
+            meta: {
+              ...localDoc.meta,
+              deleted: true,
+              serverVersion: serverDoc.serverVersion,
+              updatedAtServer: serverDoc.serverTimestamp,
+              updatedAtLocal: Date.now(),
+              state: "synced"
+            }
           });
-          if (!raw || typeof raw.id !== "string") {
-            throw new NeetruError("invalid_response", "datastore.add missing id");
-          }
-          return { ok: true, id: raw.id };
-        },
-        async set(id, data) {
-          if (!id || typeof id !== "string") {
-            throw new NeetruError("validation_failed", "id required");
-          }
-          await httpRequest(config, {
-            method: "PUT",
-            path: `/api/sdk/v1/datastore/${name}/${encodeURIComponent(id)}`,
-            body: { data },
-            requireAuth: true,
-            headers
+          busChanges.push({
+            type: "removed",
+            collection: serverDoc.collection,
+            doc: { id: serverDoc.id, data: localDoc.data }
           });
-          return { ok: true };
-        },
-        async update(id, data) {
-          if (!id || typeof id !== "string") {
-            throw new NeetruError("validation_failed", "id required");
+        }
+        continue;
+      }
+      if (localDoc && localDoc.meta.state === "pending") {
+        const serverEnvelope = {
+          collection: serverDoc.collection,
+          id: serverDoc.id,
+          data: serverDoc.data,
+          meta: {
+            serverVersion: serverDoc.serverVersion,
+            updatedAtServer: serverDoc.serverTimestamp,
+            updatedAtLocal: Date.now(),
+            state: "synced",
+            pendingMutationIds: [],
+            deleted: false,
+            ownerId: localDoc.meta.ownerId
           }
-          await httpRequest(config, {
-            method: "PATCH",
-            path: `/api/sdk/v1/datastore/${name}/${encodeURIComponent(id)}`,
-            body: { data },
-            requireAuth: true,
-            headers
-          });
-          return { ok: true };
-        },
-        async remove(id) {
-          if (!id || typeof id !== "string") {
-            throw new NeetruError("validation_failed", "id required");
+        };
+        const pendingMuts = await this._queue.drain();
+        const docMut = pendingMuts.find(
+          (m) => m.collection === serverDoc.collection && m.docId === serverDoc.id
+        );
+        if (docMut) {
+          const result = this._resolver.resolve(localDoc, serverEnvelope, docMut);
+          if (result.conflictRecord) {
+            await this._store.appendConflict(result.conflictRecord);
           }
-          await httpRequest(config, {
-            method: "DELETE",
-            path: `/api/sdk/v1/datastore/${name}/${encodeURIComponent(id)}`,
-            requireAuth: true,
-            headers
+          await this._store.putDoc({
+            ...localDoc,
+            meta: { ...localDoc.meta, state: "conflict" }
+          });
+          continue;
+        }
+      }
+      const isNew = !localDoc;
+      const newDoc = {
+        collection: serverDoc.collection,
+        id: serverDoc.id,
+        data: serverDoc.data,
+        meta: {
+          serverVersion: serverDoc.serverVersion,
+          updatedAtServer: serverDoc.serverTimestamp,
+          updatedAtLocal: Date.now(),
+          state: "synced",
+          pendingMutationIds: [],
+          deleted: false,
+          ownerId: localDoc?.meta.ownerId ?? null
+        }
+      };
+      await this._store.putDoc(newDoc);
+      busChanges.push({
+        type: isNew ? "added" : "modified",
+        collection: serverDoc.collection,
+        doc: { id: serverDoc.id, data: serverDoc.data }
+      });
+    }
+  }
+  // ─── FASE 3 — reabre listeners (realtime) ─────────────────────────────────────
+  /**
+   * Fase 3: sinaliza que o cache está reconciliado.
+   *
+   * O transporte de tempo real (Firestore onSnapshot / WebSocket) é gerido
+   * pela camada superior — aqui apenas garantimos que o SyncState reflita
+   * o término do sync, o que notifica os listeners `onSyncStateChange` e
+   * transitivamente os `onSnapshot` da UI.
+   */
+  _phase3Realtime() {
+  }
+  // ─── Helpers ──────────────────────────────────────────────────────────────────
+  /**
+   * Retorna a lista de coleções com documentos no cache local.
+   * Usado pelo full resync para saber quais coleções checar.
+   *
+   * Combina:
+   *   1. Set em memória `_activeCollections` (populado ao aplicar docs)
+   *   2. Coleções de mutações pendentes
+   *   3. Coleções de conflict_log
+   *   4. Coleções persistas em sync_meta['activeCollections']
+   */
+  async _getActiveCollections() {
+    const collectionSet = new Set(this._activeCollections);
+    const mutations = await this._queue.listAll();
+    for (const m of mutations) collectionSet.add(m.collection);
+    const conflicts = await this._store.listConflicts();
+    for (const c of conflicts) collectionSet.add(c.collection);
+    const persistedRaw = await this._store.getMeta("activeCollections");
+    if (persistedRaw) {
+      for (const col of persistedRaw) collectionSet.add(col);
+    }
+    const storedCollections = await this._store.listCollections();
+    for (const col of storedCollections) collectionSet.add(col);
+    return Array.from(collectionSet);
+  }
+  /** Constrói o estado inicial com base no estado atual dos colaboradores. */
+  _buildInitialState() {
+    const isOnline = this._connectivity.isOnline;
+    return {
+      status: isOnline ? "idle" : "offline",
+      pendingWrites: 0,
+      lastSyncedAt: null,
+      isLeaderTab: this._tabCoordinator.isLeader()
+    };
+  }
+  /**
+   * Atualiza o SyncState em RAM e notifica os listeners.
+   * Só emite se algo realmente mudou.
+   */
+  _updateState(partial) {
+    const prev = this._state;
+    const next = { ...prev, ...partial };
+    const changed = prev.status !== next.status || prev.pendingWrites !== next.pendingWrites || prev.lastSyncedAt !== next.lastSyncedAt || prev.isLeaderTab !== next.isLeaderTab;
+    this._state = next;
+    if (changed) {
+      this._emitState(next);
+    }
+  }
+  _emitState(state) {
+    for (const listener of this._stateListeners) {
+      try {
+        listener({ ...state });
+      } catch {
+      }
+    }
+  }
+  /**
+   * Atualiza `pendingWrites` no estado.
+   * Chamado de forma assíncrona quando necessário.
+   */
+  async _refreshPendingWrites() {
+    if (this._destroyed) return;
+    try {
+      const count = await this._queue.countPending();
+      if (count !== this._state.pendingWrites) {
+        this._updateState({ pendingWrites: count });
+      }
+    } catch {
+    }
+  }
+  /** Dispara um sync de forma fire-and-forget (para gatilhos externos). */
+  _triggerSync(_reason) {
+    if (this._destroyed) return;
+    this._refreshPendingWrites().catch(() => {
+    });
+    this.sync().catch(() => {
+    });
+  }
+  /** Carrega activeCollections do sync_meta e popula o Set em memória. */
+  _loadActiveCollections() {
+    this._store.getMeta("activeCollections").then((raw) => {
+      const cols = raw;
+      if (cols) {
+        for (const c of cols) this._activeCollections.add(c);
+      }
+    }).catch(() => {
+    });
+  }
+  /** Conecta os listeners de ConnectivityMonitor e TabCoordinator. */
+  _wireListeners() {
+    this._loadActiveCollections();
+    const unsubConn = this._connectivity.subscribe((state) => {
+      if (state === "offline") {
+        this._updateState({ status: "offline" });
+      } else {
+        if (this._state.status === "offline") {
+          this._updateState({ status: "idle" });
+        }
+        this._triggerSync("connectivity:online");
+      }
+    });
+    this._cleanups.push(unsubConn);
+    const unsubRole = this._tabCoordinator.onRoleChange((role) => {
+      const isLeader = role === "leader";
+      this._updateState({ isLeaderTab: isLeader });
+      if (isLeader) {
+        this._triggerSync("role:leader");
+      }
+    });
+    this._cleanups.push(unsubRole);
+  }
+};
+
+// src/db/offline/conflict-resolver.ts
+function isServerNewer(localUpdatedAtServer, remoteUpdatedAtServer) {
+  if (remoteUpdatedAtServer === null) return false;
+  if (localUpdatedAtServer === null) return true;
+  return remoteUpdatedAtServer > localUpdatedAtServer;
+}
+var ConflictResolver = class _ConflictResolver {
+  /**
+   * Resolve um conflito com base na operação da mutação (auto-dispatch).
+   *
+   * - `add` / `set`   → `resolveDocLevel`
+   * - `update`        → `resolveFieldRestricted`
+   * - `remove`        → a remoção sempre vence (LWW: operação mais recente é a destruição)
+   */
+  resolve(localDoc, serverDoc, pendingMutation) {
+    switch (pendingMutation.op) {
+      case "remove":
+        return this.resolveRemove(localDoc, serverDoc, pendingMutation);
+      case "update":
+        return this.resolveFieldRestricted(localDoc, serverDoc, pendingMutation);
+      case "add":
+      case "set":
+      default:
+        return this.resolveDocLevel(localDoc, serverDoc, pendingMutation);
+    }
+  }
+  /**
+   * LWW documento-nível (para `set` e `add`).
+   *
+   * O documento inteiro com o timestamp de servidor mais recente vence.
+   * Se o servidor for mais novo, a escrita local é descartada e um
+   * `ConflictRecord` é emitido.
+   */
+  resolveDocLevel(localDoc, serverDoc, pendingMutation) {
+    if (serverDoc === null) {
+      const data = pendingMutation.payload ?? {};
+      return { outcome: "no_conflict", resolvedData: data, conflictRecord: null };
+    }
+    if (localDoc === null) {
+      return {
+        outcome: "server_wins",
+        resolvedData: serverDoc.data,
+        conflictRecord: null
+      };
+    }
+    const serverNewer = isServerNewer(
+      localDoc.meta.updatedAtServer,
+      serverDoc.meta.updatedAtServer
+    );
+    if (!serverNewer) {
+      return {
+        outcome: "local_wins",
+        resolvedData: localDoc.data,
+        conflictRecord: null
+      };
+    }
+    const conflictRecord = {
+      collection: pendingMutation.collection,
+      docId: pendingMutation.docId,
+      mutationId: pendingMutation.mutationId,
+      losingData: localDoc.data,
+      winningData: serverDoc.data,
+      reason: "lww_server_newer",
+      detectedAt: Date.now(),
+      delivered: false
+    };
+    return {
+      outcome: "server_wins",
+      resolvedData: serverDoc.data,
+      conflictRecord
+    };
+  }
+  /**
+   * LWW campo-restrito (para `update`).
+   *
+   * Apenas os campos declarados no payload da mutação são comparados.
+   * Campos não tocados pela mutação são preservados do estado do servidor
+   * (se disponível) ou do estado local (I3 §7.2).
+   *
+   * Resultado:
+   * - Se o servidor for mais novo nos campos conflitantes → `server_wins`
+   *   para esses campos; o doc resultante é uma mescla de server (campos
+   *   conflitantes) + estado antes da mutação para os demais.
+   * - Se o local for mais recente → `local_wins`; os campos do update são
+   *   aplicados sobre o server.
+   * - Campos do server não tocados pelo update sempre preservados → `merged`.
+   */
+  resolveFieldRestricted(localDoc, serverDoc, pendingMutation) {
+    const mutatedFields = Object.keys(pendingMutation.payload ?? {});
+    if (serverDoc === null) {
+      const base = localDoc?.data ?? {};
+      const resolved = { ...base, ...pendingMutation.payload ?? {} };
+      return { outcome: "no_conflict", resolvedData: resolved, conflictRecord: null };
+    }
+    const serverData = serverDoc.data;
+    if (localDoc === null) {
+      const resolved = { ...serverData, ...pendingMutation.payload ?? {} };
+      return { outcome: "no_conflict", resolvedData: resolved, conflictRecord: null };
+    }
+    const serverNewer = isServerNewer(
+      localDoc.meta.updatedAtServer,
+      serverDoc.meta.updatedAtServer
+    );
+    if (!serverNewer) {
+      const resolved = { ...serverData, ...pendingMutation.payload ?? {} };
+      return { outcome: "local_wins", resolvedData: resolved, conflictRecord: null };
+    }
+    const losingFields = {};
+    for (const field of mutatedFields) {
+      losingFields[field] = localDoc.data[field];
+    }
+    const conflictRecord = {
+      collection: pendingMutation.collection,
+      docId: pendingMutation.docId,
+      mutationId: pendingMutation.mutationId,
+      losingData: losingFields,
+      winningData: serverData,
+      reason: "lww_server_newer",
+      detectedAt: Date.now(),
+      delivered: false
+    };
+    return {
+      outcome: "server_wins",
+      resolvedData: serverData,
+      conflictRecord
+    };
+  }
+  /**
+   * Resolve uma operação `remove`.
+   *
+   * A remoção sempre vence no LWW (I3 §7.4: "a última operação é a destruição").
+   * Se o servidor modificou o doc depois que o cliente enfileirou o remove, a
+   * remoção ainda prevalece — comportamento documentado.
+   */
+  resolveRemove(_localDoc, serverDoc, _pendingMutation) {
+    const emptyDoc = {};
+    if (serverDoc !== null && serverDoc.meta.updatedAtServer !== null) {
+      const conflictRecord = {
+        collection: _pendingMutation.collection,
+        docId: _pendingMutation.docId,
+        mutationId: _pendingMutation.mutationId,
+        losingData: serverDoc.data,
+        winningData: {},
+        reason: "lww_server_newer",
+        detectedAt: Date.now(),
+        delivered: false
+      };
+      return { outcome: "local_wins", resolvedData: emptyDoc, conflictRecord };
+    }
+    return { outcome: "local_wins", resolvedData: emptyDoc, conflictRecord: null };
+  }
+  /**
+   * Resolve conflito com razão de rejeição explícita (servidor retornou
+   * `rejected_permission` ou `rejected_validation`).
+   *
+   * Usado pelo SyncEngine quando o Core rejeita o replay por motivo não-LWW.
+   */
+  resolveRejected(localDoc, serverDoc, pendingMutation, reason) {
+    const winningData = serverDoc?.data ?? {};
+    const conflictRecord = {
+      collection: pendingMutation.collection,
+      docId: pendingMutation.docId,
+      mutationId: pendingMutation.mutationId,
+      losingData: localDoc.data,
+      winningData,
+      reason,
+      detectedAt: Date.now(),
+      delivered: false
+    };
+    return {
+      outcome: "server_wins",
+      resolvedData: serverDoc?.data ?? localDoc.data,
+      conflictRecord
+    };
+  }
+  // ─── Static helpers ─────────────────────────────────────────────────────────
+  static resolve(localDoc, serverDoc, pendingMutation) {
+    return new _ConflictResolver().resolve(localDoc, serverDoc, pendingMutation);
+  }
+};
+
+// src/db/offline/change-bus.ts
+function dedupeKey(c) {
+  return `${c.collection}::${c.doc.id}`;
+}
+var ChangeBus = class {
+  /** Listeners filtrados por coleção. */
+  _collectionListeners = /* @__PURE__ */ new Map();
+  /** Listeners globais (todas as coleções). */
+  _globalListeners = /* @__PURE__ */ new Set();
+  /**
+   * Subscreve a eventos de uma coleção específica.
+   *
+   * @param collection - Nome da coleção a filtrar.
+   * @param listener   - Callback que recebe os changes da coleção.
+   * @returns Função de unsubscribe.
+   */
+  subscribe(collection, listener) {
+    if (!this._collectionListeners.has(collection)) {
+      this._collectionListeners.set(collection, /* @__PURE__ */ new Set());
+    }
+    this._collectionListeners.get(collection).add(listener);
+    return () => {
+      const set = this._collectionListeners.get(collection);
+      if (set) {
+        set.delete(listener);
+        if (set.size === 0) {
+          this._collectionListeners.delete(collection);
+        }
+      }
+    };
+  }
+  /**
+   * Subscreve a eventos de TODAS as coleções.
+   *
+   * @param listener - Callback que recebe todos os changes, de qualquer coleção.
+   * @returns Função de unsubscribe.
+   */
+  subscribeAll(listener) {
+    this._globalListeners.add(listener);
+    return () => {
+      this._globalListeners.delete(listener);
+    };
+  }
+  /**
+   * Emite um array de `Change` events para todos os listeners relevantes.
+   *
+   * Agrupa os changes por coleção antes de despachar, para que cada listener
+   * receba apenas os events da sua coleção.
+   *
+   * Deduplicação: events com o mesmo `[collection, id]` dentro do mesmo `emit()`
+   * são compactados: apenas o último do array é mantido (o mais recente vence).
+   * Isso cobre o caso Fase 1 + Fase 2 do SyncEngine emitindo o mesmo doc.
+   *
+   * Erros em listeners individuais são capturados e não interrompem os demais.
+   */
+  emit(changes) {
+    if (changes.length === 0) return;
+    const deduped = /* @__PURE__ */ new Map();
+    for (const c of changes) {
+      deduped.set(dedupeKey(c), c);
+    }
+    const uniqueChanges = Array.from(deduped.values());
+    const byCollection = /* @__PURE__ */ new Map();
+    for (const c of uniqueChanges) {
+      if (!byCollection.has(c.collection)) {
+        byCollection.set(c.collection, []);
+      }
+      byCollection.get(c.collection).push(c);
+    }
+    for (const [collection, collChanges] of byCollection) {
+      const listeners = this._collectionListeners.get(collection);
+      if (listeners) {
+        for (const listener of listeners) {
+          this._safeCall(listener, collChanges);
+        }
+      }
+    }
+    for (const listener of this._globalListeners) {
+      this._safeCall(listener, uniqueChanges);
+    }
+  }
+  /**
+   * Número de listeners ativos (útil em testes).
+   */
+  get listenerCount() {
+    let count = this._globalListeners.size;
+    for (const set of this._collectionListeners.values()) {
+      count += set.size;
+    }
+    return count;
+  }
+  /**
+   * Remove todos os listeners registrados.
+   * Útil para teardown em testes ou no shutdown do SDK.
+   */
+  clear() {
+    this._collectionListeners.clear();
+    this._globalListeners.clear();
+  }
+  // ─── Privado ────────────────────────────────────────────────────────────────
+  _safeCall(listener, changes) {
+    try {
+      listener(changes);
+    } catch {
+    }
+  }
+};
+
+// src/db/offline/connectivity-monitor.ts
+var ConnectivityMonitor = class {
+  _state;
+  _listeners = /* @__PURE__ */ new Set();
+  _nav;
+  _target;
+  _debounceMs;
+  _debounceTimer = null;
+  _started = false;
+  // Handlers bound para remoção correta em removeEventListener
+  _onOnline;
+  _onOffline;
+  constructor(options = {}) {
+    this._nav = options.navigator ?? (typeof navigator !== "undefined" ? navigator : void 0);
+    this._target = options.eventTarget ?? (typeof window !== "undefined" ? window : void 0);
+    this._debounceMs = options.debounceMs ?? 300;
+    this._state = this._nav?.onLine === false ? "offline" : "online";
+    this._onOnline = () => this._handleNativeEvent("online");
+    this._onOffline = () => this._handleNativeEvent("offline");
+  }
+  // ─── Ciclo de vida ──────────────────────────────────────────────────────────
+  /**
+   * Inicia a escuta de eventos. Deve ser chamado após instanciar.
+   * Sem efeito se já foi iniciado.
+   */
+  start() {
+    if (this._started) return;
+    this._started = true;
+    this._target?.addEventListener("online", this._onOnline);
+    this._target?.addEventListener("offline", this._onOffline);
+  }
+  /**
+   * Para a escuta e remove todos os listeners.
+   * Deve ser chamado no shutdown para evitar memory leaks.
+   */
+  destroy() {
+    this._started = false;
+    this._target?.removeEventListener("online", this._onOnline);
+    this._target?.removeEventListener("offline", this._onOffline);
+    if (this._debounceTimer !== null) {
+      clearTimeout(this._debounceTimer);
+      this._debounceTimer = null;
+    }
+    this._listeners.clear();
+  }
+  // ─── Estado atual ───────────────────────────────────────────────────────────
+  /**
+   * Retorna o estado de conectividade atual.
+   */
+  getState() {
+    return this._state;
+  }
+  /**
+   * True se o estado atual é `'online'`.
+   */
+  get isOnline() {
+    return this._state === "online";
+  }
+  /**
+   * True se o estado atual é `'offline'`.
+   */
+  get isOffline() {
+    return this._state === "offline";
+  }
+  // ─── Subscrições ────────────────────────────────────────────────────────────
+  /**
+   * Subscreve a mudanças de estado de conectividade.
+   *
+   * @param listener - Callback chamado ao mudar o estado.
+   * @returns Função de unsubscribe (sem memory leak).
+   */
+  subscribe(listener) {
+    this._listeners.add(listener);
+    return () => {
+      this._listeners.delete(listener);
+    };
+  }
+  /**
+   * Número de listeners ativos (útil em testes).
+   */
+  get listenerCount() {
+    return this._listeners.size;
+  }
+  // ─── Força de estado (para testes e heartbeat externo) ─────────────────────
+  /**
+   * Força o estado para um valor específico, ignorando eventos nativos.
+   * Útil para o SyncEngine injetar o resultado de um heartbeat real ao Core.
+   * Respeita o debounce.
+   */
+  forceState(state) {
+    this._scheduleTransition(state);
+  }
+  // ─── Privado ────────────────────────────────────────────────────────────────
+  _handleNativeEvent(type) {
+    const newState = type === "online" ? "online" : "offline";
+    this._scheduleTransition(newState);
+  }
+  _scheduleTransition(newState) {
+    if (this._debounceTimer !== null) {
+      clearTimeout(this._debounceTimer);
+      this._debounceTimer = null;
+    }
+    if (this._debounceMs <= 0) {
+      this._applyTransition(newState);
+      return;
+    }
+    this._debounceTimer = setTimeout(() => {
+      this._debounceTimer = null;
+      this._applyTransition(newState);
+    }, this._debounceMs);
+  }
+  _applyTransition(newState) {
+    if (newState === this._state) return;
+    this._state = newState;
+    this._notifyListeners(newState);
+  }
+  _notifyListeners(state) {
+    for (const listener of this._listeners) {
+      try {
+        listener(state);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/db/offline/tab-coordinator.ts
+var TabCoordinator = class {
+  _lockName;
+  _channelName;
+  _lockManager;
+  _channel;
+  _channelFactory;
+  /** ID único desta aba (para debug e `sync_state`). */
+  _tabId;
+  /** Estado de papel atual. */
+  _role = "follower";
+  /** Promise resolve que libera o lock perpétuo. */
+  _releaseLock = null;
+  /** `true` se destroy() já foi chamado. */
+  _destroyed = false;
+  /** `true` se start() já foi chamado. */
+  _started = false;
+  /** Listeners de mudança de papel. */
+  _roleListeners = /* @__PURE__ */ new Set();
+  /** Listeners de mensagem recebida. */
+  _messageListeners = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this._lockName = options.lockName;
+    this._channelName = options.channelName;
+    this._tabId = `tab-${Math.random().toString(36).slice(2, 10)}-${Date.now()}`;
+    this._lockManager = options.lockManager !== void 0 ? options.lockManager : typeof navigator !== "undefined" && "locks" in navigator && navigator.locks != null ? navigator.locks : void 0;
+    if (options.broadcastChannel !== void 0) {
+      this._channel = options.broadcastChannel;
+    } else if (typeof BroadcastChannel !== "undefined") {
+      const channelName = this._channelName;
+      this._channelFactory = () => {
+        const bc = new BroadcastChannel(channelName);
+        const wrapper = {
+          get onmessage() {
+            return bc.onmessage;
+          },
+          set onmessage(cb) {
+            bc.onmessage = cb ? (event) => cb(event.data) : null;
+          },
+          postMessage: (msg) => bc.postMessage(msg),
+          close: () => bc.close()
+        };
+        return wrapper;
+      };
+    }
+  }
+  // ─── Ciclo de vida ───────────────────────────────────────────────────────────
+  /**
+   * Inicia o processo de eleição de líder.
+   * Idempotente: sem efeito se já foi chamado.
+   */
+  start() {
+    if (this._started || this._destroyed) return;
+    this._started = true;
+    if (!this._channel && this._channelFactory) {
+      this._channel = this._channelFactory();
+    }
+    if (this._channel) {
+      this._channel.onmessage = (msg) => {
+        this._handleIncomingMessage(msg);
+      };
+    }
+    if (this._lockManager) {
+      this._electWithLocks();
+    } else {
+      this._becomeLeader();
+    }
+  }
+  /**
+   * Para o TabCoordinator: libera o lock, fecha o canal.
+   * Idempotente: pode ser chamado múltiplas vezes.
+   */
+  destroy() {
+    if (this._destroyed) return;
+    this._destroyed = true;
+    this._started = false;
+    if (this._releaseLock) {
+      this._releaseLock();
+      this._releaseLock = null;
+    }
+    if (this._channel) {
+      this._channel.onmessage = null;
+      this._channel.close();
+      this._channel = void 0;
+    }
+    this._role = "follower";
+    this._roleListeners.clear();
+    this._messageListeners.clear();
+  }
+  // ─── Estado ──────────────────────────────────────────────────────────────────
+  /**
+   * Retorna `true` se esta aba é atualmente a líder.
+   */
+  isLeader() {
+    return !this._destroyed && this._role === "leader";
+  }
+  /**
+   * Retorna o papel atual desta aba.
+   */
+  getRole() {
+    return this._destroyed ? "follower" : this._role;
+  }
+  /**
+   * ID único desta aba (para diagnóstico).
+   */
+  get tabId() {
+    return this._tabId;
+  }
+  // ─── Subscrições ─────────────────────────────────────────────────────────────
+  /**
+   * Registra um listener para mudanças de papel (`'leader'` | `'follower'`).
+   *
+   * @returns Função de unsubscribe.
+   */
+  onRoleChange(listener) {
+    this._roleListeners.add(listener);
+    return () => {
+      this._roleListeners.delete(listener);
+    };
+  }
+  /**
+   * Registra um listener para mensagens recebidas de outras abas via
+   * BroadcastChannel. O remetente NÃO recebe suas próprias mensagens.
+   *
+   * @returns Função de unsubscribe.
+   */
+  onMessage(listener) {
+    this._messageListeners.add(listener);
+    return () => {
+      this._messageListeners.delete(listener);
+    };
+  }
+  // ─── Comunicação ─────────────────────────────────────────────────────────────
+  /**
+   * Transmite uma mensagem para todas as outras abas via BroadcastChannel.
+   * Sem efeito se o canal não estiver disponível ou o coordinator foi destroyed.
+   */
+  broadcast(msg) {
+    if (this._destroyed) return;
+    try {
+      this._channel?.postMessage(msg);
+    } catch {
+    }
+  }
+  // ─── Privado — eleição ───────────────────────────────────────────────────────
+  /**
+   * Inicia a disputa pelo lock Web Locks.
+   *
+   * `navigator.locks.request` com uma Promise-interna que nunca resolve:
+   * enquanto a aba vive e o lock está ativo, a callback não retorna.
+   * Ao chamar `destroy()` a Promise interna resolve → lock liberado.
+   */
+  _electWithLocks() {
+    const lockPromise = new Promise((resolve) => {
+      this._releaseLock = resolve;
+    });
+    Promise.resolve().then(() => {
+      if (!this._destroyed && this._role === "follower") {
+        this._notifyRoleChange("follower");
+      }
+    });
+    this._lockManager.request(this._lockName, (_lock) => {
+      if (this._destroyed) {
+        return Promise.resolve();
+      }
+      this._becomeLeader();
+      return lockPromise;
+    }).catch(() => {
+    });
+  }
+  /**
+   * Transição para o papel de líder.
+   */
+  _becomeLeader() {
+    if (this._destroyed) return;
+    this._setRole("leader");
+    Promise.resolve().then(() => {
+      if (!this._destroyed) this._broadcastSyncState();
+    });
+  }
+  /**
+   * Muda o papel e notifica os listeners.
+   */
+  _setRole(role) {
+    const previous = this._role;
+    this._role = role;
+    if (previous !== role) {
+      this._notifyRoleChange(role);
+    }
+  }
+  /**
+   * Transmite o estado de sync atual (chamado ao se tornar líder).
+   */
+  _broadcastSyncState() {
+    this.broadcast({
+      type: "sync_state",
+      leaderTabId: this._tabId,
+      syncing: false,
+      pendingWrites: 0
+    });
+  }
+  // ─── Privado — mensagens ─────────────────────────────────────────────────────
+  /**
+   * Processa mensagem recebida de outra aba.
+   * Mensagens de tipo desconhecido são ignoradas silenciosamente.
+   */
+  _handleIncomingMessage(msg) {
+    if (this._destroyed) return;
+    if (!msg || typeof msg.type !== "string") return;
+    for (const listener of this._messageListeners) {
+      try {
+        listener(msg);
+      } catch {
+      }
+    }
+  }
+  // ─── Privado — notificações ───────────────────────────────────────────────────
+  _notifyRoleChange(role) {
+    for (const listener of this._roleListeners) {
+      try {
+        listener(role);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/db/collection-ref.ts
+var COLL_RE = /^[a-z0-9][a-z0-9_-]{0,62}$/;
+function assertValidCollection(name) {
+  if (!COLL_RE.test(name)) {
+    throw new NeetruDbError(
+      "db_invalid_query",
+      `Nome de cole\xE7\xE3o inv\xE1lido: "${name}". Deve seguir o padr\xE3o ${COLL_RE}.`
+    );
+  }
+}
+function assertValidId(id, label = "id") {
+  if (!id || typeof id !== "string" || id.trim() === "") {
+    throw new NeetruDbError(
+      "db_invalid_query",
+      `${label} \xE9 obrigat\xF3rio e deve ser uma string n\xE3o-vazia.`
+    );
+  }
+}
+function toQueryDescriptor(query) {
+  const desc = {};
+  if (query?.where) {
+    desc.where = query.where.map((f) => ({
+      field: f.field,
+      op: f.op,
+      value: f.value
+    }));
+  }
+  if (query?.orderBy) {
+    desc.orderBy = {
+      field: query.orderBy.field,
+      direction: query.orderBy.direction
+    };
+  }
+  if (query?.limit !== void 0) {
+    desc.limit = query.limit;
+  }
+  if (query?.cursor) {
+    try {
+      const cursorObj = JSON.parse(atob(query.cursor));
+      desc.cursor = { type: cursorObj.type ?? "startAfter", docId: cursorObj.docId };
+    } catch {
+    }
+  }
+  return desc;
+}
+function buildNextCursor(docs, limit) {
+  if (docs.length < limit) return null;
+  const lastDoc = docs[docs.length - 1];
+  if (!lastDoc) return null;
+  return btoa(JSON.stringify({ type: "startAfter", docId: lastDoc.id }));
+}
+var DbCollectionRefImpl = class {
+  constructor(_collection, _store, _queue, _bus, _engine, _connectivity) {
+    this._collection = _collection;
+    this._store = _store;
+    this._queue = _queue;
+    this._bus = _bus;
+    this._engine = _engine;
+    this._connectivity = _connectivity;
+  }
+  _collection;
+  _store;
+  _queue;
+  _bus;
+  _engine;
+  _connectivity;
+  // ── helpers ────────────────────────────────────────────────────────────────
+  /** Verifica se há mutações pendentes para esta coleção. */
+  async _hasPendingWrites() {
+    const pending = await this._queue.listPending();
+    return pending.some((m) => m.collection === this._collection);
+  }
+  /** Verifica se há mutações pendentes para um doc específico. */
+  async _docHasPendingWrites(id) {
+    const pending = await this._queue.listPending();
+    return pending.some((m) => m.collection === this._collection && m.docId === id);
+  }
+  _isOnline() {
+    return this._connectivity.isOnline;
+  }
+  /** Constrói um DbGetResult para um doc específico, ou null se tombstoned/ausente. */
+  async _buildGetResult(id) {
+    const doc = await this._store.getDoc(this._collection, id);
+    if (!doc || doc.meta.deleted) return null;
+    const hasPending = await this._docHasPendingWrites(id);
+    const isOnline = this._isOnline();
+    const syncState = this._engine.getSyncState();
+    const staleGet = !isOnline || syncState.status === "offline";
+    const fromCacheGet = hasPending || syncState.lastSyncedAt === null || staleGet;
+    return {
+      docs: [{ id: doc.id, data: doc.data }],
+      fromCache: fromCacheGet,
+      stale: staleGet,
+      hasPendingWrites: hasPending,
+      changes: []
+    };
+  }
+  /** Constrói um DbListResult para a coleção com query opcional. */
+  async _buildListResult(q) {
+    const desc = toQueryDescriptor(q);
+    const effectiveLimit = desc.limit ?? 20;
+    const result = await this._store.listDocs(this._collection, desc);
+    const hasPending = await this._hasPendingWrites();
+    const isOnline = this._isOnline();
+    const syncState = this._engine.getSyncState();
+    const nextCursor = buildNextCursor(result.docs, effectiveLimit);
+    const stale = !isOnline || syncState.status === "offline";
+    const fromCache = hasPending || syncState.lastSyncedAt === null || stale;
+    return {
+      docs: result.docs.map((d) => ({ id: d.id, data: d.data })),
+      nextCursor,
+      fromCache,
+      stale,
+      hasPendingWrites: hasPending,
+      changes: []
+    };
+  }
+  // ── CRUD ────────────────────────────────────────────────────────────────────
+  async get(id) {
+    assertValidId(id);
+    return this._buildGetResult(id);
+  }
+  async list(q) {
+    return this._buildListResult(q);
+  }
+  async add(data) {
+    const mutation = await this._queue.enqueue({
+      collection: this._collection,
+      op: "add",
+      payload: data,
+      baseVersion: null,
+      batchId: null
+    });
+    const docId = mutation.docId;
+    await this._store.putDoc({
+      collection: this._collection,
+      id: docId,
+      data,
+      meta: {
+        serverVersion: null,
+        updatedAtServer: null,
+        updatedAtLocal: Date.now(),
+        state: "pending",
+        pendingMutationIds: [mutation.mutationId],
+        deleted: false,
+        ownerId: null
+      }
+    });
+    this._bus.emit([{
+      type: "added",
+      collection: this._collection,
+      doc: { id: docId, data }
+    }]);
+    return { ok: true, id: docId };
+  }
+  async set(id, data) {
+    assertValidId(id);
+    const existing = await this._store.getDoc(this._collection, id);
+    const mutation = await this._queue.enqueue({
+      collection: this._collection,
+      docId: id,
+      op: "set",
+      payload: data,
+      baseVersion: existing?.meta.serverVersion ?? null,
+      batchId: null
+    });
+    await this._store.putDoc({
+      collection: this._collection,
+      id,
+      data,
+      meta: {
+        serverVersion: existing?.meta.serverVersion ?? null,
+        updatedAtServer: existing?.meta.updatedAtServer ?? null,
+        updatedAtLocal: Date.now(),
+        state: "pending",
+        pendingMutationIds: [mutation.mutationId],
+        deleted: false,
+        ownerId: null
+      }
+    });
+    this._bus.emit([{
+      type: existing && !existing.meta.deleted ? "modified" : "added",
+      collection: this._collection,
+      doc: { id, data }
+    }]);
+    return { ok: true };
+  }
+  async update(id, data) {
+    assertValidId(id);
+    const existing = await this._store.getDoc(this._collection, id);
+    const mergedData = existing?.meta.deleted ? { ...data } : { ...existing?.data ?? {}, ...data };
+    const mutation = await this._queue.enqueue({
+      collection: this._collection,
+      docId: id,
+      op: "update",
+      payload: data,
+      baseVersion: existing?.meta.serverVersion ?? null,
+      batchId: null
+    });
+    await this._store.putDoc({
+      collection: this._collection,
+      id,
+      data: mergedData,
+      meta: {
+        serverVersion: existing?.meta.serverVersion ?? null,
+        updatedAtServer: existing?.meta.updatedAtServer ?? null,
+        updatedAtLocal: Date.now(),
+        state: "pending",
+        pendingMutationIds: [
+          ...existing?.meta.pendingMutationIds ?? [],
+          mutation.mutationId
+        ],
+        deleted: false,
+        ownerId: existing?.meta.ownerId ?? null
+      }
+    });
+    this._bus.emit([{
+      type: "modified",
+      collection: this._collection,
+      doc: { id, data: mergedData }
+    }]);
+    return { ok: true };
+  }
+  async remove(id) {
+    assertValidId(id);
+    const existing = await this._store.getDoc(this._collection, id);
+    if (!existing || existing.meta.deleted) ;
+    await this._queue.enqueue({
+      collection: this._collection,
+      docId: id,
+      op: "remove",
+      payload: null,
+      baseVersion: existing?.meta.serverVersion ?? null,
+      batchId: null
+    });
+    await this._store.deleteDoc(this._collection, id);
+    if (existing && !existing.meta.deleted) {
+      this._bus.emit([{
+        type: "removed",
+        collection: this._collection,
+        doc: { id, data: existing.data }
+      }]);
+    }
+    return { ok: true };
+  }
+  async batch(ops) {
+    const batchId = `batch-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    const busChanges = [];
+    for (const op of ops) {
+      const id = op.id ?? `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+      const data = op.data ?? {};
+      const collection = op.collection;
+      if (op.op === "add") {
+        const mutation = await this._queue.enqueue({
+          collection,
+          op: "add",
+          payload: data,
+          baseVersion: null,
+          batchId
+        });
+        const docId = mutation.docId;
+        await this._store.putDoc({
+          collection,
+          id: docId,
+          data,
+          meta: {
+            serverVersion: null,
+            updatedAtServer: null,
+            updatedAtLocal: Date.now(),
+            state: "pending",
+            pendingMutationIds: [mutation.mutationId],
+            deleted: false,
+            ownerId: null
+          }
+        });
+        busChanges.push({ type: "added", collection, doc: { id: docId, data } });
+      } else if (op.op === "set") {
+        const existing = await this._store.getDoc(collection, id);
+        const mutation = await this._queue.enqueue({
+          collection,
+          docId: id,
+          op: "set",
+          payload: data,
+          baseVersion: existing?.meta.serverVersion ?? null,
+          batchId
+        });
+        await this._store.putDoc({
+          collection,
+          id,
+          data,
+          meta: {
+            serverVersion: existing?.meta.serverVersion ?? null,
+            updatedAtServer: existing?.meta.updatedAtServer ?? null,
+            updatedAtLocal: Date.now(),
+            state: "pending",
+            pendingMutationIds: [mutation.mutationId],
+            deleted: false,
+            ownerId: null
+          }
+        });
+        busChanges.push({
+          type: existing && !existing.meta.deleted ? "modified" : "added",
+          collection,
+          doc: { id, data }
+        });
+      } else if (op.op === "update") {
+        const existing = await this._store.getDoc(collection, id);
+        const merged = { ...existing?.data ?? {}, ...data };
+        const mutation = await this._queue.enqueue({
+          collection,
+          docId: id,
+          op: "update",
+          payload: data,
+          baseVersion: existing?.meta.serverVersion ?? null,
+          batchId
+        });
+        await this._store.putDoc({
+          collection,
+          id,
+          data: merged,
+          meta: {
+            serverVersion: existing?.meta.serverVersion ?? null,
+            updatedAtServer: existing?.meta.updatedAtServer ?? null,
+            updatedAtLocal: Date.now(),
+            state: "pending",
+            pendingMutationIds: [
+              ...existing?.meta.pendingMutationIds ?? [],
+              mutation.mutationId
+            ],
+            deleted: false,
+            ownerId: existing?.meta.ownerId ?? null
+          }
+        });
+        busChanges.push({ type: "modified", collection, doc: { id, data: merged } });
+      } else if (op.op === "remove") {
+        const existing = await this._store.getDoc(collection, id);
+        await this._queue.enqueue({
+          collection,
+          docId: id,
+          op: "remove",
+          payload: null,
+          baseVersion: existing?.meta.serverVersion ?? null,
+          batchId
+        });
+        await this._store.deleteDoc(collection, id);
+        if (existing && !existing.meta.deleted) {
+          busChanges.push({ type: "removed", collection, doc: { id, data: existing.data } });
+        }
+      }
+    }
+    if (busChanges.length > 0) {
+      this._bus.emit(busChanges);
+    }
+    return { ok: true };
+  }
+  // ── Realtime ─────────────────────────────────────────────────────────────────
+  onDoc(id, cb) {
+    assertValidId(id);
+    this._buildGetResult(id).then((r) => {
+      cb(r ? r.docs[0]?.data ?? null : null);
+    }).catch(() => cb(null));
+    return this._bus.subscribe(this._collection, (changes) => {
+      const relevant = changes.find((c) => c.doc.id === id);
+      if (!relevant) return;
+      if (relevant.type === "removed") {
+        cb(null);
+      } else {
+        cb(relevant.doc.data);
+      }
+    });
+  }
+  onSnapshot(q, cb) {
+    this._buildListResult(q).then((snap) => cb(snap)).catch(() => {
+    });
+    const unsubBus = this._bus.subscribe(this._collection, async (_changes) => {
+      try {
+        const snap = await this._buildListResult(q);
+        const delta = _changes.map((c) => ({
+          type: c.type,
+          doc: { id: c.doc.id, data: c.doc.data }
+        }));
+        cb({ ...snap, changes: delta });
+      } catch {
+      }
+    });
+    const unsubSync = this._engine.onSyncStateChange(async () => {
+      try {
+        const snap = await this._buildListResult(q);
+        cb(snap);
+      } catch {
+      }
+    });
+    let unsubRealtime;
+    if (typeof this._engine.transport.subscribeCollection === "function") {
+      unsubRealtime = this._engine.transport.subscribeCollection(
+        this._collection,
+        async (remoteChanges, needsResync) => {
+          if (needsResync) {
+            return;
+          }
+          for (const rc of remoteChanges) {
+            if (rc.type === "removed" || rc.data === null) {
+              await this._store.deleteDoc(this._collection, rc.docId);
+              this._bus.emit([{
+                type: "removed",
+                collection: this._collection,
+                doc: { id: rc.docId, data: {} }
+              }]);
+            } else {
+              await this._store.putDoc({
+                collection: this._collection,
+                id: rc.docId,
+                data: rc.data,
+                meta: {
+                  serverVersion: `rt_${Date.now()}`,
+                  updatedAtServer: Date.now(),
+                  updatedAtLocal: Date.now(),
+                  state: "synced",
+                  pendingMutationIds: [],
+                  deleted: false,
+                  ownerId: null
+                }
+              });
+              this._bus.emit([{
+                type: rc.type,
+                collection: this._collection,
+                doc: { id: rc.docId, data: rc.data }
+              }]);
+            }
+          }
+        }
+      );
+    }
+    return () => {
+      unsubBus();
+      unsubSync();
+      unsubRealtime?.();
+    };
+  }
+  doc(id) {
+    assertValidId(id);
+    const self = this;
+    return {
+      async get() {
+        return self._buildGetResult(id);
+      },
+      async set(data) {
+        return self.set(id, data);
+      },
+      async update(data) {
+        return self.update(id, data);
+      },
+      async remove() {
+        return self.remove(id);
+      },
+      onSnapshot(cb) {
+        self._buildGetResult(id).then((r) => cb(r)).catch(() => cb(null));
+        const unsubBus = self._bus.subscribe(self._collection, async (changes) => {
+          const relevant = changes.find((c) => c.doc.id === id);
+          if (!relevant) return;
+          try {
+            if (relevant.type === "removed") {
+              cb(null);
+            } else {
+              const result = await self._buildGetResult(id);
+              cb(result);
+            }
+          } catch {
+            cb(null);
+          }
+        });
+        const unsubSync = self._engine.onSyncStateChange(async () => {
+          try {
+            const result = await self._buildGetResult(id);
+            cb(result);
+          } catch {
+            cb(null);
+          }
+        });
+        return () => {
+          unsubBus();
+          unsubSync();
+        };
+      }
+    };
+  }
+};
+var NeetruDbDocumentsImpl = class {
+  _store;
+  _queue;
+  _bus;
+  _engine;
+  _connectivity;
+  constructor(opts) {
+    this._store = opts.store;
+    this._queue = opts.queue;
+    this._bus = opts.bus;
+    this._engine = opts.engine;
+    this._connectivity = opts.connectivity;
+  }
+  collection(name) {
+    assertValidCollection(name);
+    return new DbCollectionRefImpl(
+      name,
+      this._store,
+      this._queue,
+      this._bus,
+      this._engine,
+      this._connectivity
+    );
+  }
+  get syncState() {
+    return this._engine.getSyncState();
+  }
+  onSyncStateChanged(cb) {
+    return this._engine.onSyncStateChange(cb);
+  }
+  async flush() {
+    return this._engine.flush();
+  }
+  async clearCache() {
+    await this._store.close();
+    await this._store.open();
+  }
+  async getConflicts() {
+    return this._store.listConflicts();
+  }
+};
+async function createOfflineDocumentsNamespace(opts) {
+  const store = new LocalStore(opts.dbName);
+  await store.open();
+  const queue = new MutationQueue(store);
+  const resolver = new ConflictResolver();
+  const bus = new ChangeBus();
+  const connectivity = new ConnectivityMonitor({
+    // Se startOnline=false, injeta um navigator falso
+    navigator: opts.startOnline === false ? { onLine: false } : typeof navigator !== "undefined" ? navigator : void 0
+  });
+  const tabCoordinatorLike = opts.singleTab ? (
+    // Fake tab coordinator para single-tab mode (sempre líder)
+    {
+      isLeader: () => true,
+      onRoleChange: (_cb) => {
+        return () => {
+        };
+      }
+    }
+  ) : new TabCoordinator({
+    lockName: `neetru-offline:${opts.dbName}`,
+    channelName: `neetru-offline:${opts.dbName}`
+  });
+  const engine = new SyncEngine({
+    store,
+    queue,
+    resolver,
+    bus,
+    transport: opts.transport,
+    tabCoordinator: tabCoordinatorLike,
+    connectivity,
+    periodicSyncIntervalMs: opts.periodicSyncIntervalMs ?? 5 * 60 * 1e3
+  });
+  return new NeetruDbDocumentsImpl({
+    store,
+    queue,
+    bus,
+    engine,
+    connectivity
+  });
+}
+
+// src/db/sql/lease.ts
+var RENEWAL_THRESHOLD = 0.8;
+var MIN_RENEWAL_DELAY_MS = 3e4;
+var SqlLeaseManager = class {
+  _lease;
+  _pool;
+  _orm;
+  _renewalTimer = null;
+  _closed = false;
+  _deps;
+  constructor(lease, pool, orm, deps) {
+    this._lease = lease;
+    this._pool = pool;
+    this._orm = orm;
+    this._deps = {
+      ...deps,
+      now: deps.now ?? (() => Date.now())
+    };
+    this._scheduleRenewal();
+  }
+  // ─── Superfície pública (NeetruSqlClient) ──────────────────────────────────
+  get orm() {
+    this._assertOpen();
+    return this._orm;
+  }
+  async transaction(fn, opts) {
+    this._assertOpen();
+    try {
+      if (opts?.isolationLevel) {
+        return await this._orm.transaction(fn, {
+          isolationLevel: opts.isolationLevel
+        });
+      }
+      return await this._orm.transaction(fn);
+    } catch (err) {
+      throw mapPoolError(err);
+    }
+  }
+  async close() {
+    if (this._closed) return;
+    this._closed = true;
+    this._cancelRenewal();
+    await this._pool.end().catch(() => {
+    });
+  }
+  // ─── Renovação proativa ────────────────────────────────────────────────────
+  /**
+   * Calcula o delay de renovação: momento de ~80% do TTL restante.
+   *
+   * Fórmula: `renewAt = issuedAt + TTL * RENEWAL_THRESHOLD`
+   *   = `expiresAt - TTL * (1 - RENEWAL_THRESHOLD)`
+   *
+   * Se o lease já está além do ponto de renovação (ou TTL não calculável),
+   * usa `MIN_RENEWAL_DELAY_MS` como fallback seguro.
+   */
+  _calcRenewalDelayMs() {
+    const expiresAtMs = Date.parse(this._lease.expiresAt);
+    if (!Number.isFinite(expiresAtMs)) return MIN_RENEWAL_DELAY_MS;
+    const now = this._deps.now();
+    const remainingMs = expiresAtMs - now;
+    if (remainingMs <= 0) return MIN_RENEWAL_DELAY_MS;
+    const renewInMs = remainingMs * (1 - RENEWAL_THRESHOLD);
+    return Math.max(MIN_RENEWAL_DELAY_MS, Math.round(renewInMs));
+  }
+  _scheduleRenewal() {
+    if (this._closed) return;
+    const delayMs = this._calcRenewalDelayMs();
+    this._renewalTimer = setTimeout(() => {
+      void this._doRenew();
+    }, delayMs);
+  }
+  _cancelRenewal() {
+    if (this._renewalTimer !== null) {
+      clearTimeout(this._renewalTimer);
+      this._renewalTimer = null;
+    }
+  }
+  async _doRenew() {
+    if (this._closed) return;
+    try {
+      const renewOpts = {
+        leaseId: this._lease.leaseId
+      };
+      if (this._deps.database !== void 0) {
+        renewOpts.database = this._deps.database;
+      }
+      const newLease = await this._deps.fetchLease(renewOpts);
+      await this._swapPool(newLease);
+    } catch (err) {
+      this._renewalTimer = setTimeout(() => {
+        void this._doRenew();
+      }, MIN_RENEWAL_DELAY_MS);
+      if (process.env["NODE_ENV"] !== "production") {
+        console.warn("[SqlLeaseManager] Lease renewal failed, will retry:", err);
+      }
+      return;
+    }
+    this._scheduleRenewal();
+  }
+  /**
+   * Hot-swap do pool: cria pool novo, atualiza ponteiros, drena pool antigo.
+   *
+   * Exposto como método protegido para testes.
+   */
+  async _swapPool(newLease) {
+    const credRotated = newLease.credentialVersion !== this._lease.credentialVersion;
+    if (!credRotated && newLease.leaseId === this._lease.leaseId) {
+      this._lease = newLease;
+      return;
+    }
+    const newPool = this._deps.createPool(newLease);
+    const newOrm = this._deps.createDrizzle(newPool, this._deps.schema);
+    const oldPool = this._pool;
+    this._lease = newLease;
+    this._pool = newPool;
+    this._orm = newOrm;
+    void oldPool.end().catch(() => {
+    });
+  }
+  // ─── Helpers ───────────────────────────────────────────────────────────────
+  _assertOpen() {
+    if (this._closed) {
+      throw new NeetruDbError(
+        "db_unavailable",
+        "SqlLeaseManager foi fechado \u2014 chame close() apenas no shutdown."
+      );
+    }
+  }
+};
+function mapPoolError(err) {
+  if (err instanceof NeetruDbError) return err;
+  const message = err instanceof Error ? err.message : String(err);
+  const code = err instanceof Error ? err.code : void 0;
+  if (typeof code === "string" && (code === "ECONNREFUSED" || code === "ENOTFOUND" || code === "ETIMEDOUT")) {
+    return new NeetruDbError(
+      "db_unavailable",
+      `Pool connection failed (${code}): ${message}`
+    );
+  }
+  if (message.includes("statement timeout") || message.includes("lock timeout")) {
+    return new NeetruDbError("db_timeout", `Query timeout: ${message}`);
+  }
+  if (message.includes("40001") || message.includes("40P01") || message.includes("deadlock")) {
+    return new NeetruDbError("db_conflict", `Transaction conflict: ${message}`);
+  }
+  if (message.includes("42501") || message.toLowerCase().includes("permission denied")) {
+    return new NeetruDbError("db_permission_denied", `Permission denied: ${message}`);
+  }
+  return new NeetruDbError("db_unavailable", `Database error: ${message}`);
+}
+
+// src/db/sql/sql-client.ts
+var LEASE_ENDPOINT = "/api/sdk/v1/db/lease";
+var LEASE_RENEW_ENDPOINT = "/api/sdk/v1/db/lease/renew";
+function mapEnvToCore(sdkEnv) {
+  if (sdkEnv === "workspace") return "staging";
+  if (sdkEnv === "prod") return "production";
+  return "dev";
+}
+function createHttpLeaseFetcher(config) {
+  return async (opts) => {
+    const { httpRequest: httpRequest2 } = await Promise.resolve().then(() => (init_http(), http_exports));
+    const isRenewal = Boolean(opts?.leaseId);
+    const path = isRenewal ? LEASE_RENEW_ENDPOINT : LEASE_ENDPOINT;
+    let body;
+    if (isRenewal) {
+      body = { leaseId: opts.leaseId };
+    } else {
+      body = {
+        productId: config.productId ?? "",
+        environment: mapEnvToCore(config.env ?? "prod")
+      };
+      if (opts?.database !== void 0) {
+        body["database"] = opts.database;
+      }
+    }
+    let raw;
+    try {
+      raw = await httpRequest2(config, {
+        method: "POST",
+        path,
+        body,
+        requireAuth: true,
+        // Lease fetch é idempotente do ponto de vista de segurança — retries OK.
+        retries: 2
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new NeetruDbError(
+        "db_unavailable",
+        `Falha ao ${isRenewal ? "renovar" : "obter"} lease SQL: ${msg}`
+      );
+    }
+    return parseLease(raw);
+  };
+}
+function parseLease(raw) {
+  if (!raw || typeof raw !== "object") {
+    throw new NeetruDbError("db_unavailable", "Resposta de lease inv\xE1lida (n\xE3o \xE9 objeto).");
+  }
+  const envelope = raw;
+  const leaseObj = envelope["lease"];
+  if (!leaseObj || typeof leaseObj !== "object") {
+    throw new NeetruDbError(
+      "db_unavailable",
+      'Resposta de lease inv\xE1lida: campo "lease" ausente ou n\xE3o \xE9 objeto. O Core retorna { kind, lease: { leaseId, host, ... } }.'
+    );
+  }
+  const r = leaseObj;
+  function req(field, type) {
+    if (typeof r[field] !== type) {
+      throw new NeetruDbError(
+        "db_unavailable",
+        `Campo obrigat\xF3rio "${field}" ausente ou tipo inv\xE1lido na resposta de lease.`
+      );
+    }
+    return r[field];
+  }
+  return {
+    leaseId: req("leaseId", "string"),
+    host: req("host", "string"),
+    port: typeof r["port"] === "number" ? r["port"] : 5433,
+    dbName: req("dbName", "string"),
+    user: req("user", "string"),
+    password: req("password", "string"),
+    sslca: typeof r["sslca"] === "string" ? r["sslca"] : null,
+    clientCert: typeof r["clientCert"] === "string" ? r["clientCert"] : null,
+    clientKey: typeof r["clientKey"] === "string" ? r["clientKey"] : null,
+    credentialVersion: typeof r["credentialVersion"] === "number" ? r["credentialVersion"] : 1,
+    expiresAt: req("expiresAt", "string")
+  };
+}
+async function createSqlClientWithDeps(deps, options) {
+  const depsWithDb = options?.database !== void 0 ? { ...deps, database: options.database } : deps;
+  let lease;
+  try {
+    if (options?.database !== void 0) {
+      lease = await depsWithDb.fetchLease({ database: options.database });
+    } else {
+      lease = await depsWithDb.fetchLease();
+    }
+  } catch (err) {
+    if (err instanceof NeetruDbError) throw err;
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new NeetruDbError("db_unavailable", `Falha ao obter lease inicial: ${msg}`);
+  }
+  let pool;
+  try {
+    pool = depsWithDb.createPool(lease);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new NeetruDbError("db_unavailable", `Falha ao abrir pool: ${msg}`);
+  }
+  let orm;
+  try {
+    orm = depsWithDb.createDrizzle(pool, depsWithDb.schema);
+  } catch (err) {
+    await pool.end().catch(() => {
+    });
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new NeetruDbError("db_unavailable", `Falha ao criar handle Drizzle: ${msg}`);
+  }
+  return new SqlLeaseManager(lease, pool, orm, depsWithDb);
+}
+async function createSqlClientFromConfig(config, schema, options) {
+  const fetchLease = createHttpLeaseFetcher(config);
+  const createPool = (lease) => {
+    const { Pool } = __require("pg");
+    const ssl = lease.sslca ? {
+      ca: lease.sslca,
+      cert: lease.clientCert ?? void 0,
+      key: lease.clientKey ?? void 0,
+      rejectUnauthorized: true
+    } : false;
+    return new Pool({
+      host: lease.host,
+      port: lease.port,
+      database: lease.dbName,
+      user: lease.user,
+      password: lease.password,
+      ssl,
+      max: 3,
+      idleTimeoutMillis: 3e4,
+      connectionTimeoutMillis: 1e4
+    });
+  };
+  const createDrizzle = (pool, s) => {
+    const { drizzle } = __require("drizzle-orm/node-postgres");
+    return drizzle(pool, { schema: s });
+  };
+  return createSqlClientWithDeps(
+    {
+      fetchLease,
+      createPool,
+      createDrizzle,
+      schema
+    },
+    options
+  );
+}
+
+// src/db/realtime/realtime-client.ts
+var WS_OPEN = 1;
+var WS_CLOSED = 3;
+var JITTER_MIN = 0.5;
+var JITTER_MAX = 1.5;
+var DEFAULT_BACKOFF_BASE_MS = 1e3;
+var DEFAULT_BACKOFF_MAX_MS = 3e4;
+var DEFAULT_HEARTBEAT_INTERVAL_MS = 25e3;
+var _idCounter = 0;
+function generateId() {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
+  }
+  return `nrt-sub-${Date.now()}-${++_idCounter}-${Math.random().toString(36).slice(2)}`;
+}
+var NeetruRealtimeClient = class {
+  // ── configuração ──────────────────────────────────────────────────────────
+  _gatewayUrl;
+  _wsFactory;
+  _setTimeout;
+  _clearTimeout;
+  _backoffBaseMs;
+  _backoffMaxMs;
+  _heartbeatIntervalMs;
+  _ticketProvider;
+  /** ID do banco lógico (BL-8) — embutido em query.filter._dbId de cada subscribe. */
+  _dbId;
+  /** Ticket atual — obtido antes de cada abertura de WS e embutido nos frames. */
+  _currentTicket = null;
+  // ── estado interno ────────────────────────────────────────────────────────
+  /** Subscriptions ativas: id → entry */
+  _subscriptions = /* @__PURE__ */ new Map();
+  /** Listeners do estado da conexão. */
+  _stateListeners = [];
+  /** Estado atual da conexão. */
+  _connectionState = "connecting";
+  /** Socket atual (pode ser null entre tentativas). */
+  _ws = null;
+  /** Número da tentativa de reconexão corrente (reseta após conexão bem-sucedida). */
+  _reconnectAttempt = 0;
+  /** Handle do timer de backoff pendente. */
+  _reconnectTimer = null;
+  /** Handle do timer de heartbeat. */
+  _heartbeatTimer = null;
+  /** Indica que o cliente foi encerrado via `close()`. Não reconecta mais. */
+  _closed = false;
+  /**
+   * Frames de subscribe que precisam ser enviados mas a socket ainda não
+   * está aberta (estado CONNECTING). Drenados no onopen.
+   */
+  _pendingFrames = [];
+  // ── construtor ────────────────────────────────────────────────────────────
+  constructor(options) {
+    this._gatewayUrl = options.gatewayUrl;
+    this._wsFactory = options.webSocketFactory ?? defaultWebSocketFactory;
+    this._setTimeout = options.setTimeoutFn ?? globalThis.setTimeout.bind(globalThis);
+    this._clearTimeout = options.clearTimeoutFn ?? globalThis.clearTimeout.bind(globalThis);
+    this._backoffBaseMs = options.backoffBaseMs ?? DEFAULT_BACKOFF_BASE_MS;
+    this._backoffMaxMs = options.backoffMaxMs ?? DEFAULT_BACKOFF_MAX_MS;
+    this._heartbeatIntervalMs = options.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
+    this._ticketProvider = options.ticketProvider;
+    this._dbId = options.dbId;
+    this._connect();
+  }
+  // ── API pública ───────────────────────────────────────────────────────────
+  /**
+   * Registra uma subscription em `collection` com `query` opcional.
+   *
+   * Envia um frame `subscribe` ao gateway (ou enfileira se o socket ainda
+   * não está aberto). O `callback` é invocado com cada frame `delta`,
+   * `resync`, `stale` ou `error` roteado para esta subscription.
+   *
+   * @returns O `subscriptionId` opaco — usar para cancelar via `unsubscribe()`.
+   */
+  subscribe(collection, query, callback) {
+    if (this._closed) {
+      return generateId();
+    }
+    const subscriptionId = generateId();
+    this._subscriptions.set(subscriptionId, {
+      subscriptionId,
+      collection,
+      query: Object.keys(query).length > 0 ? query : void 0,
+      callback
+    });
+    const frame = {
+      op: "subscribe",
+      subscriptionId,
+      collection,
+      query: this._buildSubscribeQuery(query)
+    };
+    this._sendOrBuffer(frame);
+    return subscriptionId;
+  }
+  /**
+   * Cancela uma subscription.
+   *
+   * Envia um frame `unsubscribe` ao gateway e remove o listener local.
+   * Frames subsequentes com este `subscriptionId` são silenciosamente descartados.
+   */
+  unsubscribe(subscriptionId) {
+    if (!this._subscriptions.has(subscriptionId)) {
+      return;
+    }
+    this._subscriptions.delete(subscriptionId);
+    const frame = { op: "unsubscribe", subscriptionId };
+    this._sendOrBuffer(frame);
+  }
+  /**
+   * Registra um listener de mudanças no estado da conexão.
+   *
+   * O listener é invocado imediatamente com o estado atual e depois a cada
+   * transição. Retorna uma função `unsubscribe`.
+   */
+  onConnectionState(listener) {
+    this._stateListeners.push(listener);
+    listener(this._connectionState);
+    return () => {
+      this._stateListeners = this._stateListeners.filter((l) => l !== listener);
+    };
+  }
+  /**
+   * Encerra o cliente definitivamente.
+   *
+   * Fecha o socket ativo, cancela timers pendentes e marca o cliente como
+   * encerrado (sem mais reconexões).
+   */
+  close() {
+    this._closed = true;
+    this._cancelReconnectTimer();
+    this._cancelHeartbeatTimer();
+    if (this._ws) {
+      this._detachHandlers(this._ws);
+      if (this._ws.readyState !== WS_CLOSED) {
+        this._ws.close(1e3, "client closed");
+      }
+      this._ws = null;
+    }
+    this._setState("disconnected");
+  }
+  // ── Conexão ───────────────────────────────────────────────────────────────
+  /**
+   * Busca um ticket de autenticação e, em seguida, cria um novo WebSocket e
+   * instala os handlers de evento.
+   *
+   * A busca de ticket é obrigatória antes de abrir qualquer WS (primeira
+   * conexão e reconexões). Se a busca falhar, a conexão é abortada com
+   * estado `'connecting'` e o backoff reconectará em seguida.
+   *
+   * Fail-closed: o WebSocket NUNCA é aberto sem um ticket válido.
+   */
+  _connect() {
+    if (this._closed) return;
+    this._setState("connecting");
+    void this._connectWithTicket();
+  }
+  /** Implementação assíncrona de _connect — busca ticket e abre WS. */
+  async _connectWithTicket() {
+    if (this._closed) return;
+    let ticket;
+    try {
+      ticket = await this._ticketProvider();
+    } catch (err) {
+      if (this._closed) return;
+      const delay = this._computeBackoffDelay(this._reconnectAttempt);
+      this._reconnectAttempt++;
+      this._reconnectTimer = this._setTimeout(() => {
+        this._reconnectTimer = null;
+        if (!this._closed) this._connect();
+      }, delay);
+      return;
+    }
+    if (this._closed) return;
+    this._currentTicket = ticket;
+    const ws = this._wsFactory(this._gatewayUrl);
+    this._ws = ws;
+    ws.onopen = this._handleOpen.bind(this);
+    ws.onmessage = this._handleMessage.bind(this);
+    ws.onclose = this._handleClose.bind(this);
+    ws.onerror = this._handleError.bind(this);
+  }
+  // ── Handlers de WebSocket ─────────────────────────────────────────────────
+  _handleOpen(_event) {
+    if (this._closed) return;
+    this._reconnectAttempt = 0;
+    this._setState("connected");
+    for (const frame of this._pendingFrames) {
+      this._sendNow(frame);
+    }
+    this._pendingFrames = [];
+    this._resubscribeAll();
+    this._scheduleHeartbeat();
+  }
+  _handleMessage(event) {
+    if (this._closed) return;
+    let frame;
+    try {
+      frame = JSON.parse(event.data);
+    } catch {
+      return;
+    }
+    switch (frame.op) {
+      case "delta":
+      case "resync":
+      case "stale":
+      case "error":
+        this._routeToSubscription(frame);
+        break;
+      case "pong":
+        break;
+      case "drain":
+        this._handleDrain();
+        break;
+    }
+  }
+  _handleClose(_event) {
+    if (this._closed) return;
+    this._cancelHeartbeatTimer();
+    this._ws = null;
+    this._scheduleReconnect();
+  }
+  _handleError(_event) {
+    if (this._closed) return;
+    this._setState("connecting");
+  }
+  // ── Drain (graceful shutdown do gateway) ─────────────────────────────────
+  _handleDrain() {
+    if (this._closed) return;
+    this._setState("draining");
+    this._cancelHeartbeatTimer();
+    if (this._ws) {
+      this._detachHandlers(this._ws);
+      if (this._ws.readyState !== WS_CLOSED) {
+        this._ws.close(1001, "drain");
+      }
+      this._ws = null;
+    }
+    this._scheduleReconnect();
+  }
+  // ── Roteamento de frames ──────────────────────────────────────────────────
+  _routeToSubscription(frame) {
+    const entry = this._subscriptions.get(frame.subscriptionId);
+    if (!entry) {
+      return;
+    }
+    try {
+      entry.callback(frame);
+    } catch {
+    }
+  }
+  // ── Resubscrição ──────────────────────────────────────────────────────────
+  /**
+   * Reenvía frames `subscribe` para todas as subscriptions ativas.
+   * Chamado no `onopen` de reconexões para restaurar o estado remoto.
+   *
+   * Durante a PRIMEIRA conexão: _pendingFrames já foi drenado com os
+   * subscribes iniciais acima. ResubscribeAll envia novamente — como a
+   * lista de subscriptions foi populada pelos `subscribe()` calls anteriores
+   * ao open, e os frames drenados também os incluem, teríamos duplicatas.
+   *
+   * Solução: resubscribeAll só é invocado após drenar _pendingFrames, e
+   * como o gateway é idempotente para o mesmo subscriptionId (segundo o
+   * design do componente #19), a duplicata é inócua. Em reconexões, onde
+   * _pendingFrames está vazio, os frames são os únicos enviados.
+   *
+   * Para o caso do primeiro open com subscribes anteriores ao open, os
+   * frames já foram drenados de _pendingFrames — não chamamos resubscribeAll
+   * se era a primeira conexão (_reconnectAttempt era 0 antes de resetar).
+   * Rastreamos isso com _hasConnectedOnce.
+   */
+  _hasConnectedOnce = false;
+  _resubscribeAll() {
+    if (!this._hasConnectedOnce) {
+      this._hasConnectedOnce = true;
+      return;
+    }
+    for (const entry of this._subscriptions.values()) {
+      const frame = {
+        op: "subscribe",
+        subscriptionId: entry.subscriptionId,
+        collection: entry.collection,
+        query: this._buildSubscribeQuery(entry.query ?? {})
+      };
+      this._sendNow(frame);
+    }
+  }
+  // ── Ticket embedding ──────────────────────────────────────────────────────
+  /**
+   * Constrói o descriptor `query` para um frame `subscribe`, embutindo o
+   * `token` do ticket corrente em `query.filter._ticket` e o `_dbId` do
+   * banco lógico em `query.filter._dbId` (BL-8 fix).
+   *
+   * O gateway extrai `filter._ticket` do primeiro frame `subscribe` e valida
+   * contra `POST /api/sdk/v1/db/realtime/validate`. `filter._dbId` é exigido
+   * pelo `@neetru/realtime-changestream._extractDbId` para rotear a
+   * subscription ao banco correto — sem ele a subscription é rejeitada.
+   *
+   * Retorna `undefined` se a query seria vazia E não há ticket (estado
+   * transitório antes do primeiro ticket — não deve ocorrer normalmente pois
+   * `_connect` só abre o WS após obter o ticket).
+   */
+  _buildSubscribeQuery(query) {
+    const ticket = this._currentTicket;
+    const hasUserQuery = Object.keys(query).length > 0;
+    if (!ticket) {
+      return hasUserQuery ? query : void 0;
+    }
+    const mergedFilter = {
+      ...query.filter ?? {},
+      _ticket: ticket.token
+    };
+    if (this._dbId !== void 0) {
+      mergedFilter["_dbId"] = this._dbId;
+    }
+    return {
+      ...query,
+      filter: mergedFilter
+    };
+  }
+  // ── Backoff e reconexão ───────────────────────────────────────────────────
+  /** Agenda uma tentativa de reconexão com backoff exponencial + jitter. */
+  _scheduleReconnect() {
+    if (this._closed) return;
+    this._cancelReconnectTimer();
+    this._setState("connecting");
+    this._currentTicket = null;
+    const delayMs = this._computeBackoffDelay(this._reconnectAttempt);
+    this._reconnectAttempt++;
+    this._reconnectTimer = this._setTimeout(() => {
+      this._reconnectTimer = null;
+      if (!this._closed) {
+        this._connect();
+      }
+    }, delayMs);
+  }
+  /**
+   * Calcula o delay de backoff para o attempt N.
+   *
+   * Fórmula: `min(baseMs * 2^N, maxMs) * jitter`
+   * onde `jitter ∈ [JITTER_MIN, JITTER_MAX]` (±50%).
+   */
+  _computeBackoffDelay(attempt) {
+    const exponential = this._backoffBaseMs * Math.pow(2, attempt);
+    const capped = Math.min(exponential, this._backoffMaxMs);
+    const jitter = JITTER_MIN + Math.random() * (JITTER_MAX - JITTER_MIN);
+    return Math.round(capped * jitter);
+  }
+  _cancelReconnectTimer() {
+    if (this._reconnectTimer !== null) {
+      this._clearTimeout(this._reconnectTimer);
+      this._reconnectTimer = null;
+    }
+  }
+  // ── Heartbeat ─────────────────────────────────────────────────────────────
+  /** Agenda o próximo ping. Não-operacional se heartbeatIntervalMs === 0. */
+  _scheduleHeartbeat() {
+    if (this._heartbeatIntervalMs === 0) return;
+    this._cancelHeartbeatTimer();
+    this._heartbeatTimer = this._setTimeout(() => {
+      this._heartbeatTimer = null;
+      this._sendPing();
+      this._scheduleHeartbeat();
+    }, this._heartbeatIntervalMs);
+  }
+  _cancelHeartbeatTimer() {
+    if (this._heartbeatTimer !== null) {
+      this._clearTimeout(this._heartbeatTimer);
+      this._heartbeatTimer = null;
+    }
+  }
+  _sendPing() {
+    const frame = { op: "ping", subscriptionId: "" };
+    this._sendOrBuffer(frame);
+  }
+  // ── Envio de frames ───────────────────────────────────────────────────────
+  /**
+   * Envia o frame imediatamente se o socket está aberto; caso contrário,
+   * enfileira em `_pendingFrames` para envio no próximo `onopen`.
+   */
+  _sendOrBuffer(frame) {
+    if (this._ws !== null && this._ws.readyState === WS_OPEN) {
+      this._sendNow(frame);
+    } else {
+      if (frame.op !== "unsubscribe") {
+        this._pendingFrames.push(frame);
+      }
+    }
+  }
+  /** Serializa e envia o frame imediatamente via WebSocket. */
+  _sendNow(frame) {
+    if (!this._ws || this._ws.readyState !== WS_OPEN) return;
+    try {
+      this._ws.send(JSON.stringify(frame));
+    } catch {
+    }
+  }
+  // ── Estado da conexão ─────────────────────────────────────────────────────
+  _setState(state) {
+    if (this._connectionState === state) return;
+    this._connectionState = state;
+    for (const listener of this._stateListeners) {
+      try {
+        listener(state);
+      } catch {
+      }
+    }
+  }
+  // ── Desvinculação de handlers ─────────────────────────────────────────────
+  /** Remove todos os handlers de um WebSocket (evita disparo após close()). */
+  _detachHandlers(ws) {
+    ws.onopen = null;
+    ws.onmessage = null;
+    ws.onclose = null;
+    ws.onerror = null;
+  }
+};
+var defaultWebSocketFactory = (url) => {
+  if (typeof WebSocket === "undefined") {
+    throw new Error(
+      "[NeetruRealtimeClient] WebSocket n\xE3o dispon\xEDvel neste ambiente. Injete uma implementa\xE7\xE3o via `webSocketFactory` nas op\xE7\xF5es."
+    );
+  }
+  return new WebSocket(url);
+};
+
+// src/db/client-db.ts
+var DATASTORE_COLLECTION_ENDPOINT = (collection) => `/api/sdk/v1/datastore/${encodeURIComponent(collection)}`;
+var DATASTORE_DOC_ENDPOINT = (collection, docId) => `/api/sdk/v1/datastore/${encodeURIComponent(collection)}/${encodeURIComponent(docId)}`;
+function resolveTransport(engine, opts, config) {
+  if (opts._transport) {
+    return opts._transport;
+  }
+  if (engine === "firestore") {
+    if (opts.firestoreTransport) {
+      return opts.firestoreTransport;
+    }
+  }
+  if (engine === "nosql-vm" && opts.realtimeGatewayUrl) {
+    return createWebSocketSyncTransport(opts.realtimeGatewayUrl, config, opts);
+  }
+  return createRestSyncTransport(config);
+}
+function createRestSyncTransport(config) {
+  return {
+    async pushMutations(mutations) {
+      if (!config) {
+        throw new NeetruDbError(
+          "db_unavailable",
+          "[RestSyncTransport] config n\xE3o dispon\xEDvel \u2014 n\xE3o \xE9 poss\xEDvel enviar ao Core. Inicialize o transporte via createNeetruDb."
+        );
+      }
+      const { httpRequest: httpRequest2 } = await Promise.resolve().then(() => (init_http(), http_exports));
+      const results = [];
+      const tenantScopeId = config.tenantId ?? config.productId;
+      const tenantHeaders = tenantScopeId ? { "x-neetru-tenant": tenantScopeId } : void 0;
+      for (const m of mutations) {
+        try {
+          let raw;
+          if (m.op === "add") {
+            raw = await httpRequest2(config, {
+              method: "POST",
+              path: DATASTORE_COLLECTION_ENDPOINT(m.collection),
+              body: { data: m.payload ?? {} },
+              requireAuth: true,
+              retries: 0,
+              headers: tenantHeaders
+            });
+          } else if (m.op === "set") {
+            raw = await httpRequest2(config, {
+              method: "PUT",
+              path: DATASTORE_DOC_ENDPOINT(m.collection, m.docId),
+              body: { data: m.payload ?? {} },
+              requireAuth: true,
+              retries: 2,
+              headers: tenantHeaders
+            });
+          } else if (m.op === "update") {
+            raw = await httpRequest2(config, {
+              method: "PATCH",
+              path: DATASTORE_DOC_ENDPOINT(m.collection, m.docId),
+              body: { data: m.payload ?? {} },
+              requireAuth: true,
+              retries: 2,
+              headers: tenantHeaders
+            });
+          } else {
+            raw = await httpRequest2(config, {
+              method: "DELETE",
+              path: DATASTORE_DOC_ENDPOINT(m.collection, m.docId),
+              requireAuth: true,
+              retries: 2,
+              headers: tenantHeaders
+            });
+          }
+          const resp = raw;
+          results.push({
+            mutationId: m.mutationId,
+            outcome: "confirmed",
+            serverVersion: resp?.serverVersion ?? resp?.id ?? `rest_${Date.now()}`,
+            serverTimestamp: Date.now()
+          });
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          throw new NeetruDbError("db_unavailable", `pushMutations falhou: ${msg}`);
+        }
+      }
+      return { results };
+    },
+    async pullChanges(_watermark, _resumeToken) {
+      if (!config) {
+        return { docs: [], newWatermark: Date.now(), resyncRequired: false };
+      }
+      return { docs: [], newWatermark: Date.now(), resyncRequired: false };
+    },
+    async fullResync(_collections) {
+      if (!config) {
+        return { docs: [], newWatermark: Date.now() };
+      }
+      return { docs: [], newWatermark: Date.now() };
+    }
+  };
+}
+function createWebSocketSyncTransport(gatewayUrl, config, opts) {
+  const restTransport = createRestSyncTransport(config);
+  const realtimeClient = new NeetruRealtimeClient({
+    gatewayUrl,
+    ticketProvider: buildTicketProvider(config, opts),
+    dbId: opts.dbId,
+    webSocketFactory: opts._wsFactory
+  });
+  return {
+    pushMutations: restTransport.pushMutations.bind(restTransport),
+    pullChanges: restTransport.pullChanges.bind(restTransport),
+    fullResync: restTransport.fullResync.bind(restTransport),
+    // HIGH-1: subscribeCollection — chamado por DbCollectionRefImpl.onSnapshot
+    // quando o engine é nosql-vm. Registra a subscription no NeetruRealtimeClient
+    // e traduz os frames inbound para o contrato de `onChange`.
+    subscribeCollection(collection, onChange) {
+      const subId = realtimeClient.subscribe(collection, {}, (frame) => {
+        if (frame.op === "resync") {
+          onChange([], true);
+          return;
+        }
+        if (frame.op === "stale") {
+          onChange([], true);
+          return;
+        }
+        if (frame.op === "delta" && frame.changes) {
+          const changes = frame.changes.map((c) => ({
+            type: c.type === "insert" ? "added" : c.type === "delete" ? "removed" : "modified",
+            docId: c.documentId,
+            data: c.data ?? null
+          }));
+          if (changes.length > 0) {
+            onChange(changes, false);
+          }
+        }
+      });
+      return () => {
+        realtimeClient.unsubscribe(subId);
+      };
+    }
+  };
+}
+function buildTicketProvider(config, opts) {
+  return async () => {
+    const { httpRequest: httpRequest2 } = await Promise.resolve().then(() => (init_http(), http_exports));
+    const ticket = await httpRequest2(config, {
+      method: "POST",
+      path: "/api/sdk/v1/db/realtime/ticket",
+      body: {
+        productId: config.productId ?? "",
+        collections: opts.collections ?? ["*"]
+      },
+      requireAuth: true,
+      retries: 1
+    });
+    return ticket;
+  };
+}
+function getWebSocketRealtimeClient(gatewayUrl, ticketProvider, dbId, wsFactory) {
+  return new NeetruRealtimeClient({ gatewayUrl, ticketProvider, dbId, webSocketFactory: wsFactory });
+}
+function createNeetruDb(config, dbOpts = {}) {
+  const engine = dbOpts.engine ?? "rest";
+  const transport = resolveTransport(engine, dbOpts, config);
+  const dbId = dbOpts.dbId ?? "default";
+  const dbName = dbOpts.dbName ?? `neetru-db__${config.productId ?? "sdk"}__${dbId}__${config.env}`;
+  let _docsPromise = null;
+  let _docsResolved = null;
+  function getDocsPromise() {
+    if (!_docsPromise) {
+      _docsPromise = createOfflineDocumentsNamespace({
+        dbName,
+        transport,
+        singleTab: dbOpts.singleTab ?? config.env !== "prod"
+      }).then((docs) => {
+        _docsResolved = docs;
+        return docs;
+      });
+    }
+    return _docsPromise;
+  }
+  return {
+    collection(name) {
+      if (_docsResolved) return _docsResolved.collection(name);
+      return createLazyCollectionRef(name, getDocsPromise);
+    },
+    async sql(schema, options) {
+      if (config.env === "dev") {
+        throw new NeetruDbError(
+          "db_unavailable",
+          "[SDK] db.sql() n\xE3o dispon\xEDvel em NEETRU_ENV=dev. Use `neetru dev` para subir o container Postgres local."
+        );
+      }
+      return createSqlClientFromConfig(config, schema, options);
+    },
+    get syncState() {
+      return _docsResolved?.syncState ?? {
+        status: "idle",
+        pendingWrites: 0,
+        lastSyncedAt: null,
+        isLeaderTab: false
+      };
+    },
+    onSyncStateChanged(cb) {
+      if (_docsResolved) return _docsResolved.onSyncStateChanged(cb);
+      let unsub = null;
+      let cancelled = false;
+      getDocsPromise().then((docs) => {
+        if (!cancelled) {
+          unsub = docs.onSyncStateChanged(cb);
+        }
+      });
+      return () => {
+        cancelled = true;
+        unsub?.();
+      };
+    },
+    async flush() {
+      const docs = await getDocsPromise();
+      return docs.flush();
+    },
+    async clearCache() {
+      const docs = await getDocsPromise();
+      return docs.clearCache();
+    },
+    async getConflicts() {
+      const docs = await getDocsPromise();
+      return docs.getConflicts();
+    }
+  };
+}
+function createLazyCollectionRef(name, getDocsPromise) {
+  async function getRef() {
+    const docs = await getDocsPromise();
+    return docs.collection(name);
+  }
+  return {
+    async get(id) {
+      return (await getRef()).get(id);
+    },
+    async list(q) {
+      return (await getRef()).list(q);
+    },
+    async add(data) {
+      return (await getRef()).add(data);
+    },
+    async set(id, data) {
+      return (await getRef()).set(id, data);
+    },
+    async update(id, data) {
+      return (await getRef()).update(id, data);
+    },
+    async remove(id) {
+      return (await getRef()).remove(id);
+    },
+    async batch(ops) {
+      return (await getRef()).batch(ops);
+    },
+    onDoc(id, cb) {
+      let unsub = null;
+      let cancelled = false;
+      getRef().then((ref) => {
+        if (!cancelled) {
+          unsub = ref.onDoc(id, cb);
+        }
+      });
+      return () => {
+        cancelled = true;
+        unsub?.();
+      };
+    },
+    onSnapshot(q, cb) {
+      let unsub = null;
+      let cancelled = false;
+      getRef().then((ref) => {
+        if (!cancelled) {
+          unsub = ref.onSnapshot(q, cb);
+        }
+      });
+      return () => {
+        cancelled = true;
+        unsub?.();
+      };
+    },
+    doc(id) {
+      return {
+        async get() {
+          return (await getRef()).doc(id).get();
+        },
+        async set(data) {
+          return (await getRef()).doc(id).set(data);
+        },
+        async update(data) {
+          return (await getRef()).doc(id).update(data);
+        },
+        async remove() {
+          return (await getRef()).doc(id).remove();
+        },
+        onSnapshot(cb) {
+          let unsub = null;
+          let cancelled = false;
+          getRef().then((ref) => {
+            if (!cancelled) {
+              unsub = ref.doc(id).onSnapshot(cb);
+            }
           });
-          return { ok: true };
+          return () => {
+            cancelled = true;
+            unsub?.();
+          };
         }
       };
     }
   };
 }
 
-exports.createDbNamespace = createDbNamespace;
+exports.NeetruDbError = NeetruDbError;
+exports.createNeetruDb = createNeetruDb;
+exports.createRestSyncTransport = createRestSyncTransport;
+exports.getWebSocketRealtimeClient = getWebSocketRealtimeClient;
 //# sourceMappingURL=db.cjs.map
 //# sourceMappingURL=db.cjs.map