@markwasfy/loko 0.1.0

package/dist/index.js

@@ -0,0 +1,840 @@
+// src/background.ts
+var BackgroundSync = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.onlineHandler = () => this.opts.onOnline();
+    this.offlineHandler = () => this.opts.onOffline();
+  }
+  start() {
+    if (typeof window !== "undefined" && typeof window.addEventListener === "function") {
+      window.addEventListener("online", this.onlineHandler);
+      window.addEventListener("offline", this.offlineHandler);
+    }
+    if (this.opts.intervalMs > 0) {
+      this.timer = setInterval(() => {
+        if (this.opts.shouldTick()) this.opts.tick();
+      }, this.opts.intervalMs);
+      this.timer.unref?.();
+    }
+  }
+  /** Current network status, defaulting to online where unknown. */
+  isOnline() {
+    const nav = globalThis.navigator;
+    return nav ? nav.onLine : true;
+  }
+  stop() {
+    if (typeof window !== "undefined" && typeof window.removeEventListener === "function") {
+      window.removeEventListener("online", this.onlineHandler);
+      window.removeEventListener("offline", this.offlineHandler);
+    }
+    if (this.timer !== void 0) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+  }
+};
+async function registerBackgroundSync(tag = "loko-sync") {
+  try {
+    const nav = globalThis.navigator;
+    if (!nav?.serviceWorker) return false;
+    const reg = await nav.serviceWorker.ready;
+    if (!reg.sync) return false;
+    await reg.sync.register(tag);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/collection.ts
+var Collection = class {
+  constructor(name, ctx) {
+    this.subscribers = /* @__PURE__ */ new Set();
+    this.oneSubscribers = /* @__PURE__ */ new Map();
+    this.refreshScheduled = false;
+    this.name = name;
+    this.ctx = ctx;
+  }
+  idOf(record) {
+    const id = record[this.ctx.primaryKey];
+    if (id === void 0 || id === null || id === "") {
+      throw new Error(
+        `Collection "${this.name}": record is missing primary key "${this.ctx.primaryKey}".`
+      );
+    }
+    return String(id);
+  }
+  /** Read a single live record by id (tombstones return `undefined`). */
+  async get(id) {
+    await this.ctx.ready;
+    const doc = await this.ctx.storage.get(this.name, id);
+    if (!doc || doc.deletedAt !== null) return void 0;
+    return doc.data;
+  }
+  /** All live records in the collection (tombstones excluded). */
+  async all() {
+    await this.ctx.ready;
+    const docs = await this.ctx.storage.getAll(this.name);
+    return docs.filter((d) => d.deletedAt === null).map((d) => d.data);
+  }
+  /** Insert or update a record. Returns the stored record. */
+  async put(record) {
+    await this.ctx.ready;
+    const id = this.idOf(record);
+    const existing = await this.ctx.storage.get(this.name, id);
+    const doc = this.nextDoc(id, record, false, existing);
+    await this.ctx.storage.put(doc);
+    this.ctx.onLocalWrite(doc);
+    return record;
+  }
+  /** Insert or update many records atomically (one transaction). */
+  async bulkPut(records) {
+    if (records.length === 0) return;
+    await this.ctx.ready;
+    const docs = await Promise.all(
+      records.map(async (record) => {
+        const id = this.idOf(record);
+        const existing = await this.ctx.storage.get(this.name, id);
+        return this.nextDoc(id, record, false, existing);
+      })
+    );
+    await this.ctx.storage.transact((tx) => {
+      for (const doc of docs) tx.put(doc);
+    });
+    for (const doc of docs) this.ctx.onLocalWrite(doc);
+  }
+  /** Soft-delete a record (writes a tombstone so the deletion syncs). */
+  async delete(id) {
+    await this.ctx.ready;
+    const existing = await this.ctx.storage.get(this.name, id);
+    if (!existing || existing.deletedAt !== null) return;
+    const doc = {
+      ...existing,
+      data: existing.data,
+      deletedAt: Date.now(),
+      updatedAt: Date.now(),
+      localRev: existing.localRev + 1
+    };
+    await this.ctx.storage.put(doc);
+    this.ctx.onLocalWrite(doc);
+  }
+  /** Build the next StoredDoc for a local write, bumping `localRev`. */
+  nextDoc(id, record, deleted, existing) {
+    const now = Date.now();
+    return {
+      id,
+      collection: this.name,
+      data: record,
+      updatedAt: now,
+      deletedAt: deleted ? now : null,
+      localRev: (existing?.localRev ?? 0) + 1,
+      lastPushedLocalRev: existing?.lastPushedLocalRev ?? 0,
+      remoteVersion: existing?.remoteVersion ?? 0,
+      syncedAt: existing?.syncedAt ?? null
+    };
+  }
+  /**
+   * Subscribe to the whole collection. The callback fires immediately with the
+   * current records, then on every change (local, sync, or other tab).
+   * Returns an unsubscribe function.
+   */
+  subscribe(cb) {
+    this.subscribers.add(cb);
+    void this.all().then(cb);
+    return () => {
+      this.subscribers.delete(cb);
+    };
+  }
+  /** Subscribe to a single record by id. */
+  subscribeOne(id, cb) {
+    let set = this.oneSubscribers.get(id);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.oneSubscribers.set(id, set);
+    }
+    set.add(cb);
+    void this.get(id).then(cb);
+    return () => {
+      const s = this.oneSubscribers.get(id);
+      s?.delete(cb);
+      if (s && s.size === 0) this.oneSubscribers.delete(id);
+    };
+  }
+  /**
+   * Notify subscribers that this collection changed. Coalesces bursts (e.g.
+   * bulkPut, a sync batch) into a single refresh per microtask. Called by the
+   * Sync engine for local writes, pulled changes, and cross-tab updates.
+   */
+  notify() {
+    if (this.refreshScheduled) return;
+    this.refreshScheduled = true;
+    queueMicrotask(() => {
+      this.refreshScheduled = false;
+      if (this.subscribers.size > 0) {
+        void this.all().then((items) => {
+          for (const cb of [...this.subscribers]) cb(items);
+        });
+      }
+      for (const [id, set] of this.oneSubscribers) {
+        void this.get(id).then((item) => {
+          for (const cb of [...set]) cb(item);
+        });
+      }
+    });
+  }
+};
+
+// src/conflict/lww.ts
+function docFromRemote(remote, now = Date.now()) {
+  return {
+    id: remote.id,
+    collection: remote.collection,
+    // For a deletion the payload is null; the tombstone (`deletedAt`) carries meaning.
+    data: remote.data,
+    updatedAt: remote.updatedAt,
+    deletedAt: remote.deleted ? now : null,
+    localRev: 0,
+    lastPushedLocalRev: 0,
+    remoteVersion: remote.version,
+    syncedAt: now
+  };
+}
+function lastWriteWins() {
+  return (local, remote) => {
+    const now = Date.now();
+    if (!local) return docFromRemote(remote, now);
+    const remoteWins = remote.updatedAt >= local.updatedAt;
+    if (remoteWins) return docFromRemote(remote, now);
+    return { ...local, remoteVersion: remote.version };
+  };
+}
+
+// src/emitter.ts
+var Emitter = class {
+  constructor() {
+    this.listeners = {};
+  }
+  /** Subscribe to an event. Returns an unsubscribe function. */
+  on(event, fn) {
+    let set = this.listeners[event];
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners[event] = set;
+    }
+    set.add(fn);
+    return () => {
+      set?.delete(fn);
+    };
+  }
+  /** Subscribe to an event for a single emission. */
+  once(event, fn) {
+    const off = this.on(event, (payload) => {
+      off();
+      fn(payload);
+    });
+    return off;
+  }
+  /** Emit an event to all current listeners. Listener errors are isolated. */
+  emit(event, payload) {
+    const set = this.listeners[event];
+    if (!set) return;
+    for (const fn of [...set]) {
+      try {
+        fn(payload);
+      } catch {
+      }
+    }
+  }
+  /** Remove all listeners (optionally for a single event). */
+  clear(event) {
+    if (event === void 0) {
+      this.listeners = {};
+    } else {
+      delete this.listeners[event];
+    }
+  }
+};
+
+// src/tabs.ts
+var TabCoordinator = class {
+  constructor(name, onMessage) {
+    this.name = name;
+    this.leader = false;
+    if (typeof BroadcastChannel !== "undefined") {
+      this.channel = new BroadcastChannel("loko:" + name);
+      this.channel.onmessage = (e) => onMessage(e.data);
+    }
+  }
+  broadcast(msg) {
+    this.channel?.postMessage(msg);
+  }
+  /** `true` once this tab has won leadership (or when no Web Locks API exists). */
+  get isLeader() {
+    return this.leader;
+  }
+  /**
+   * Acquire leadership. The exclusive lock is held until the tab closes; when it
+   * does, another tab automatically takes over. Resolves once leadership is won.
+   */
+  electLeader(onBecomeLeader) {
+    const locks = globalThis.navigator?.locks;
+    if (!locks) {
+      this.leader = true;
+      onBecomeLeader?.();
+      return;
+    }
+    void locks.request("loko-leader:" + this.name, () => {
+      this.leader = true;
+      onBecomeLeader?.();
+      return new Promise(() => {
+      });
+    });
+  }
+  close() {
+    this.channel?.close();
+    this.channel = void 0;
+  }
+};
+
+// src/types.ts
+function isDirty(doc) {
+  return doc.localRev > doc.lastPushedLocalRev;
+}
+
+// src/sync.ts
+var CURSOR_KEY = "__cursor";
+var CLIENT_ID_KEY = "__clientId";
+var KV_COLLECTION = "_kv";
+function docToChange(doc) {
+  const deleted = doc.deletedAt !== null;
+  return {
+    collection: doc.collection,
+    id: doc.id,
+    data: deleted ? null : doc.data,
+    version: doc.remoteVersion,
+    updatedAt: doc.updatedAt,
+    deleted
+  };
+}
+var Sync = class {
+  constructor(config) {
+    this.emitter = new Emitter();
+    this.collections = /* @__PURE__ */ new Map();
+    this.options = /* @__PURE__ */ new Map();
+    this._status = "idle";
+    this.clientId = "";
+    this.storage = config.storage;
+    this.adapter = config.adapter;
+    this.resolver = config.conflict ?? lastWriteWins();
+    this.autoSync = config.autoSync !== false && config.adapter !== void 0;
+    const intervalMs = typeof config.autoSync === "number" ? config.autoSync : this.autoSync ? 3e4 : 0;
+    this.tabs = new TabCoordinator(config.name, (msg) => this.onTabMessage(msg));
+    this.background = new BackgroundSync({
+      intervalMs,
+      onOnline: () => {
+        this.setStatus("idle");
+        if (this.autoSync) void this.sync().catch(() => {
+        });
+      },
+      onOffline: () => this.setStatus("offline"),
+      tick: () => void this.sync().catch(() => {
+      }),
+      // Only the leader tab polls.
+      shouldTick: () => this.tabs.isLeader && this.background.isOnline()
+    });
+    this.ready = this.init(config.name);
+  }
+  async init(name) {
+    await this.storage.init(name);
+    let id = await this.storage.getMeta(CLIENT_ID_KEY);
+    if (!id) {
+      id = globalThis.crypto?.randomUUID?.() ?? Math.random().toString(36).slice(2) + Date.now().toString(36);
+      await this.storage.setMeta(CLIENT_ID_KEY, id);
+    }
+    this.clientId = id;
+    if (!this.background.isOnline()) this.setStatus("offline");
+    this.tabs.electLeader();
+    this.background.start();
+  }
+  // ── Collections ────────────────────────────────────────────────────────────
+  /** Declare a collection's options once (at init). Returns the collection. */
+  defineCollection(name, options = {}) {
+    const resolved = {
+      primaryKey: options.primaryKey ?? "id",
+      indexes: options.indexes ?? []
+    };
+    this.options.set(name, resolved);
+    return this.getOrCreate(name, resolved);
+  }
+  /** Access a collection. Auto-defines with defaults if not yet declared. */
+  collection(name) {
+    const opts = this.options.get(name);
+    return this.getOrCreate(
+      name,
+      opts ?? { primaryKey: "id", indexes: [] }
+    );
+  }
+  getOrCreate(name, opts) {
+    const existing = this.collections.get(name);
+    if (existing) return existing;
+    const ctx = {
+      storage: this.storage,
+      primaryKey: opts.primaryKey,
+      indexes: opts.indexes,
+      ready: this.ready,
+      onLocalWrite: (doc) => this.handleLocalWrite(doc)
+    };
+    const collection = new Collection(name, ctx);
+    this.collections.set(name, collection);
+    return collection;
+  }
+  // ── Key/value sugar (over the reserved `_kv` collection) ─────────────────────
+  /**
+   * Convenience for simple key -> value cases. Stored as a SINGLE record in the
+   * reserved `_kv` collection, so it syncs as one coarse record. Not smart
+   * per-item sync — use real collections (`collection().put`) for that.
+   */
+  async store(key2, value) {
+    await this.ready;
+    await this.collection(KV_COLLECTION).put({ id: key2, value });
+  }
+  /** Read a value previously written with {@link store}. */
+  async get(key2) {
+    await this.ready;
+    const rec = await this.collection(KV_COLLECTION).get(key2);
+    return rec?.value;
+  }
+  // ── Sync engine ──────────────────────────────────────────────────────────────
+  get status() {
+    return this._status;
+  }
+  /** Resolves once storage is initialized (clientId loaded, leader elected). */
+  whenReady() {
+    return this.ready;
+  }
+  /** Subscribe to a lifecycle event. Returns an unsubscribe function. */
+  on(event, fn) {
+    return this.emitter.on(event, fn);
+  }
+  /**
+   * Run a full sync cycle: push local changes, then pull remote ones. Concurrent
+   * calls share the same in-flight run. No-op when no adapter is configured.
+   */
+  async sync() {
+    await this.ready;
+    if (!this.adapter) return { pushed: 0, pulled: 0 };
+    if (this.inFlight) return this.inFlight;
+    this.inFlight = (async () => {
+      this.setStatus("syncing");
+      try {
+        const pushed = await this.push();
+        const pulled = await this.pull();
+        this.setStatus(this.background.isOnline() ? "idle" : "offline");
+        this.emitter.emit("sync", { pushed, pulled });
+        return { pushed, pulled };
+      } catch (error) {
+        this.setStatus("error");
+        this.emitter.emit("error", { error });
+        throw error;
+      } finally {
+        this.inFlight = void 0;
+      }
+    })();
+    return this.inFlight;
+  }
+  async push() {
+    const dirty = await this.storage.getDirty();
+    if (dirty.length === 0) return 0;
+    const pushedRev = /* @__PURE__ */ new Map();
+    for (const doc of dirty) pushedRev.set(doc.collection + " " + doc.id, doc.localRev);
+    const result = await this.adapter.push(dirty.map(docToChange));
+    const affected = /* @__PURE__ */ new Set();
+    for (const ack of result.acked) {
+      const current = await this.storage.get(ack.collection, ack.id);
+      if (!current) continue;
+      const rev = pushedRev.get(ack.collection + " " + ack.id) ?? current.localRev;
+      await this.storage.put({
+        ...current,
+        remoteVersion: ack.version,
+        // If the record was edited again mid-push it stays dirty.
+        lastPushedLocalRev: Math.max(current.lastPushedLocalRev, rev),
+        syncedAt: Date.now()
+      });
+      affected.add(ack.collection);
+    }
+    for (const conflict of result.conflicts ?? []) {
+      await this.applyRemote(conflict);
+      affected.add(conflict.collection);
+    }
+    this.notifyAndBroadcast(affected, true);
+    return result.acked.length;
+  }
+  async pull() {
+    const cursor = await this.storage.getMeta(CURSOR_KEY) ?? 0;
+    const result = await this.adapter.pull(cursor);
+    const affected = /* @__PURE__ */ new Set();
+    const writes = [];
+    for (const change of result.changes) {
+      const resolved = await this.resolveRemote(change);
+      if (resolved) {
+        writes.push(resolved);
+        affected.add(change.collection);
+      }
+    }
+    await this.storage.transact((tx) => {
+      for (const doc of writes) tx.put(doc);
+      tx.setMeta(CURSOR_KEY, result.cursor);
+    });
+    this.notifyAndBroadcast(affected, true);
+    return writes.length;
+  }
+  /** Apply one remote change, returning the StoredDoc to write, or `undefined` to skip. */
+  async resolveRemote(remote) {
+    const local = await this.storage.get(remote.collection, remote.id);
+    if (local && remote.version <= local.remoteVersion) return void 0;
+    let resolved;
+    if (local && isDirty(local)) {
+      resolved = this.resolver(local, remote);
+    } else {
+      resolved = docFromRemote(remote);
+    }
+    return { ...resolved, remoteVersion: remote.version, syncedAt: Date.now() };
+  }
+  async applyRemote(remote) {
+    const resolved = await this.resolveRemote(remote);
+    if (resolved) await this.storage.put(resolved);
+  }
+  // ── Internal plumbing ────────────────────────────────────────────────────────
+  handleLocalWrite(doc) {
+    this.emitter.emit("change", { collection: doc.collection, id: doc.id, doc });
+    this.collections.get(doc.collection)?.notify();
+    this.tabs.broadcast({ type: "write", collection: doc.collection, id: doc.id });
+    if (this.autoSync && this.background.isOnline()) {
+      void this.sync().catch(() => {
+      });
+    }
+  }
+  notifyAndBroadcast(collections, broadcast) {
+    for (const name of collections) {
+      this.collections.get(name)?.notify();
+      this.emitter.emit("change", { collection: name, id: "*", doc: void 0 });
+    }
+    if (broadcast && collections.size > 0) this.tabs.broadcast({ type: "sync" });
+  }
+  onTabMessage(msg) {
+    if (msg.type === "write") {
+      this.collections.get(msg.collection)?.notify();
+      this.emitter.emit("change", { collection: msg.collection, id: msg.id, doc: void 0 });
+    } else {
+      for (const collection of this.collections.values()) collection.notify();
+    }
+  }
+  setStatus(status) {
+    if (this._status === status) return;
+    this._status = status;
+    this.emitter.emit("status", { status });
+  }
+  /** Opt into Service Worker Background Sync (no-op if unsupported). */
+  registerBackgroundSync(tag) {
+    return registerBackgroundSync(tag);
+  }
+  /** Tear down listeners, timers, and channels, and close storage. */
+  async close() {
+    this.background.stop();
+    this.tabs.close();
+    this.emitter.clear();
+    await this.storage.close();
+  }
+};
+function createSync(config) {
+  return new Sync(config);
+}
+
+// src/storage/indexeddb.ts
+var DOCS = "docs";
+var META = "meta";
+function req(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+}
+function txDone(tx) {
+  return new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onerror = () => reject(tx.error);
+    tx.onabort = () => reject(tx.error ?? new Error("IndexedDB transaction aborted"));
+  });
+}
+function indexedDBStorage(options = {}) {
+  const idb = options.indexedDB ?? (typeof indexedDB !== "undefined" ? indexedDB : void 0);
+  if (!idb) {
+    throw new Error(
+      "indexedDBStorage(): no IndexedDB available. Pass `{ indexedDB }` (e.g. fake-indexeddb) or use memoryStorage()."
+    );
+  }
+  let db;
+  function open(name) {
+    return new Promise((resolve, reject) => {
+      const request = idb.open(name, 1);
+      request.onupgradeneeded = () => {
+        const database2 = request.result;
+        if (!database2.objectStoreNames.contains(DOCS)) {
+          const store = database2.createObjectStore(DOCS, { keyPath: ["collection", "id"] });
+          store.createIndex("collection", "collection", { unique: false });
+        }
+        if (!database2.objectStoreNames.contains(META)) {
+          database2.createObjectStore(META);
+        }
+      };
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  function database() {
+    if (!db) throw new Error("indexedDBStorage(): init() was not called.");
+    return db;
+  }
+  return {
+    async init(name) {
+      if (!db) db = await open(name);
+    },
+    async get(collection, id) {
+      const tx = database().transaction(DOCS, "readonly");
+      const result = await req(
+        tx.objectStore(DOCS).get([collection, id])
+      );
+      return result;
+    },
+    async getAll(collection) {
+      const tx = database().transaction(DOCS, "readonly");
+      const index = tx.objectStore(DOCS).index("collection");
+      return req(index.getAll(collection));
+    },
+    async put(doc) {
+      const tx = database().transaction(DOCS, "readwrite");
+      tx.objectStore(DOCS).put(doc);
+      await txDone(tx);
+    },
+    async bulkPut(docs) {
+      await this.transact((tx) => {
+        for (const doc of docs) tx.put(doc);
+      });
+    },
+    async transact(fn) {
+      const puts = [];
+      const deletes = [];
+      const metaWrites = [];
+      const tx = {
+        put: (doc) => void puts.push(doc),
+        delete: (collection, id) => void deletes.push([collection, id]),
+        setMeta: (key2, value) => void metaWrites.push([key2, value])
+      };
+      await fn(tx);
+      const stores = metaWrites.length > 0 ? [DOCS, META] : [DOCS];
+      const idbTx = database().transaction(stores, "readwrite");
+      const docStore = idbTx.objectStore(DOCS);
+      for (const doc of puts) docStore.put(doc);
+      for (const [collection, id] of deletes) docStore.delete([collection, id]);
+      if (metaWrites.length > 0) {
+        const metaStore = idbTx.objectStore(META);
+        for (const [key2, value] of metaWrites) metaStore.put(value, key2);
+      }
+      await txDone(idbTx);
+    },
+    async getDirty() {
+      const tx = database().transaction(DOCS, "readonly");
+      const all = await req(tx.objectStore(DOCS).getAll());
+      return all.filter(isDirty);
+    },
+    async getMeta(key2) {
+      const tx = database().transaction(META, "readonly");
+      return req(tx.objectStore(META).get(key2));
+    },
+    async setMeta(key2, value) {
+      const tx = database().transaction(META, "readwrite");
+      tx.objectStore(META).put(value, key2);
+      await txDone(tx);
+    },
+    async close() {
+      db?.close();
+      db = void 0;
+    }
+  };
+}
+
+// src/storage/memory.ts
+function key(collection, id) {
+  return collection + "\0" + id;
+}
+function clone(doc) {
+  return structuredClone(doc);
+}
+function memoryStorage() {
+  const docs = /* @__PURE__ */ new Map();
+  const meta = /* @__PURE__ */ new Map();
+  function commit(staged) {
+    for (const k of staged.deletes) docs.delete(k);
+    for (const [k, v] of staged.puts) docs.set(k, v);
+    for (const [k, v] of staged.meta) meta.set(k, v);
+  }
+  return {
+    async init() {
+    },
+    async get(collection, id) {
+      const doc = docs.get(key(collection, id));
+      return doc ? clone(doc) : void 0;
+    },
+    async getAll(collection) {
+      const out = [];
+      for (const doc of docs.values()) {
+        if (doc.collection === collection) out.push(clone(doc));
+      }
+      return out;
+    },
+    async put(doc) {
+      docs.set(key(doc.collection, doc.id), clone(doc));
+    },
+    async bulkPut(input) {
+      await this.transact((tx) => {
+        for (const doc of input) tx.put(doc);
+      });
+    },
+    async transact(fn) {
+      const staged = {
+        puts: /* @__PURE__ */ new Map(),
+        deletes: /* @__PURE__ */ new Set(),
+        meta: /* @__PURE__ */ new Map()
+      };
+      const tx = {
+        put(doc) {
+          const k = key(doc.collection, doc.id);
+          staged.puts.set(k, clone(doc));
+          staged.deletes.delete(k);
+        },
+        delete(collection, id) {
+          const k = key(collection, id);
+          staged.deletes.add(k);
+          staged.puts.delete(k);
+        },
+        setMeta(metaKey, value) {
+          staged.meta.set(metaKey, value);
+        }
+      };
+      await fn(tx);
+      commit(staged);
+    },
+    async getDirty() {
+      const out = [];
+      for (const doc of docs.values()) {
+        if (isDirty(doc)) out.push(clone(doc));
+      }
+      return out;
+    },
+    async getMeta(metaKey) {
+      return meta.has(metaKey) ? structuredClone(meta.get(metaKey)) : void 0;
+    },
+    async setMeta(metaKey, value) {
+      meta.set(metaKey, structuredClone(value));
+    },
+    async close() {
+      docs.clear();
+      meta.clear();
+    }
+  };
+}
+
+// src/adapters/rest.ts
+function restAdapter(options) {
+  const base = options.url.replace(/\/$/, "");
+  const doFetch = options.fetch ?? globalThis.fetch;
+  if (!doFetch) {
+    throw new Error("restAdapter(): no global fetch available. Pass `{ fetch }`.");
+  }
+  async function headers() {
+    const extra = options.headers ? await options.headers() : {};
+    return { "content-type": "application/json", ...extra };
+  }
+  return {
+    async push(changes) {
+      const res = await doFetch(`${base}/push`, {
+        method: "POST",
+        headers: await headers(),
+        body: JSON.stringify({ changes })
+      });
+      if (!res.ok) throw new Error(`loko push failed: ${res.status} ${res.statusText}`);
+      return await res.json();
+    },
+    async pull(since) {
+      const res = await doFetch(`${base}/pull?since=${encodeURIComponent(String(since))}`, {
+        method: "GET",
+        headers: await headers()
+      });
+      if (!res.ok) throw new Error(`loko pull failed: ${res.status} ${res.statusText}`);
+      return await res.json();
+    }
+  };
+}
+
+// src/adapters/memory.ts
+var MemoryServer = class {
+  constructor() {
+    this.records = /* @__PURE__ */ new Map();
+    this.seq = 0;
+  }
+  key(collection, id) {
+    return collection + " " + id;
+  }
+  commit(changes) {
+    const acked = [];
+    const conflicts = [];
+    for (const change of changes) {
+      const k = this.key(change.collection, change.id);
+      const current = this.records.get(k);
+      if (current && current.version > change.version) {
+        conflicts.push(this.toChange(current));
+        continue;
+      }
+      const version = ++this.seq;
+      this.records.set(k, {
+        collection: change.collection,
+        id: change.id,
+        data: change.data,
+        deleted: change.deleted,
+        updatedAt: change.updatedAt,
+        version
+      });
+      acked.push({ id: change.id, collection: change.collection, version });
+    }
+    return { acked, conflicts, cursor: this.seq };
+  }
+  changesSince(since) {
+    const sinceNum = Number(since) || 0;
+    const changes = [...this.records.values()].filter((r) => r.version > sinceNum).sort((a, b) => a.version - b.version).map((r) => this.toChange(r));
+    return { changes, cursor: this.seq };
+  }
+  toChange(r) {
+    return {
+      collection: r.collection,
+      id: r.id,
+      data: r.deleted ? null : r.data,
+      version: r.version,
+      updatedAt: r.updatedAt,
+      deleted: r.deleted
+    };
+  }
+};
+function memoryAdapter(server = new MemoryServer()) {
+  return {
+    async push(changes) {
+      return server.commit(changes);
+    },
+    async pull(since) {
+      return server.changesSince(since);
+    }
+  };
+}
+
+export { Collection, MemoryServer, Sync, createSync, docFromRemote, indexedDBStorage, isDirty, lastWriteWins, memoryAdapter, memoryStorage, registerBackgroundSync, restAdapter };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map