@starkeep/sync-engine 0.1.0

package/dist/index.cjs

@@ -0,0 +1,793 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SyncError: () => SyncError,
+  advanceWatermark: () => advanceWatermark,
+  createChangeNotifier: () => createChangeNotifier,
+  createFileSyncEngine: () => createFileSyncEngine,
+  createHttpSyncHandler: () => createHttpSyncHandler,
+  createHttpSyncTransport: () => createHttpSyncTransport,
+  createInProcessSyncTransport: () => createInProcessSyncTransport,
+  createSqliteSyncStateStore: () => createSqliteSyncStateStore,
+  createSyncEngine: () => createSyncEngine,
+  mergeWatermarks: () => mergeWatermarks,
+  residencyOf: () => residencyOf,
+  selectUnseen: () => selectUnseen,
+  watermarkFor: () => watermarkFor
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/sync-state-sqlite.ts
+var CREATE_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS sync_state (
+    key TEXT PRIMARY KEY,
+    value_json TEXT NOT NULL,
+    updated_at INTEGER NOT NULL DEFAULT (strftime('%s','now'))
+  )
+`;
+var WATERMARKS = "watermarks";
+var PEER_WATERMARKS = "peer_watermarks";
+var HLC_CLOCK = "hlc_clock";
+function createSqliteSyncStateStore(options) {
+  const { db } = options;
+  db.exec(CREATE_TABLE_SQL);
+  const getStmt = db.prepare(
+    "SELECT value_json FROM sync_state WHERE key = ?"
+  );
+  const setStmt = db.prepare(
+    `INSERT INTO sync_state (key, value_json, updated_at)
+     VALUES (?, ?, strftime('%s','now'))
+     ON CONFLICT(key) DO UPDATE SET
+       value_json = excluded.value_json,
+       updated_at = excluded.updated_at`
+  );
+  function getJson(key) {
+    const row = getStmt.get(key);
+    if (!row) return null;
+    return JSON.parse(row.value_json);
+  }
+  function setJson(key, value) {
+    setStmt.run(key, JSON.stringify(value));
+  }
+  return {
+    async getWatermarks() {
+      return getJson(WATERMARKS) ?? {};
+    },
+    async setWatermarks(watermarks) {
+      setJson(WATERMARKS, watermarks);
+    },
+    async getPeerWatermarks() {
+      return getJson(PEER_WATERMARKS) ?? {};
+    },
+    async setPeerWatermarks(watermarks) {
+      setJson(PEER_WATERMARKS, watermarks);
+    },
+    async getHlcClockState() {
+      return getJson(HLC_CLOCK);
+    },
+    async setHlcClockState(state) {
+      setJson(HLC_CLOCK, state);
+    }
+  };
+}
+
+// src/change-notifier.ts
+function createChangeNotifier() {
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    emit(event) {
+      for (const listener of listeners) {
+        listener(event);
+      }
+    }
+  };
+}
+
+// src/watermarks.ts
+var import_protocol_primitives = require("@starkeep/protocol-primitives");
+function advanceWatermark(watermarks, hlc) {
+  const node = hlc.nodeId;
+  const existing = watermarks[node];
+  if (!existing || (0, import_protocol_primitives.compareHLC)(hlc, existing) > 0) {
+    watermarks[node] = hlc;
+  }
+}
+function mergeWatermarks(into, incoming) {
+  const out = { ...into };
+  for (const [node, hlc] of Object.entries(incoming)) {
+    const existing = out[node];
+    out[node] = existing ? (0, import_protocol_primitives.maxHLC)(existing, hlc) : hlc;
+  }
+  return out;
+}
+function watermarkFor(watermarks, nodeId) {
+  return watermarks[nodeId] ?? import_protocol_primitives.ZERO_HLC;
+}
+function selectUnseen(records, peerWatermarks) {
+  return records.filter(
+    (r) => (0, import_protocol_primitives.compareHLC)(r.updatedAt, watermarkFor(peerWatermarks, r.updatedAt.nodeId)) > 0
+  );
+}
+
+// src/file-sync-engine.ts
+function createFileSyncEngine() {
+  const inFlightKeys = /* @__PURE__ */ new Set();
+  return {
+    isTransferInFlight(key) {
+      return inFlightKeys.has(key);
+    },
+    async getFilesToPush(localStorage, remoteStorage, entries) {
+      const manifests = [];
+      for (const entry of entries) {
+        const existsRemotely = await remoteStorage.has(entry.key);
+        if (!existsRemotely) {
+          const localFile = await localStorage.get(entry.key);
+          if (localFile) {
+            manifests.push({
+              fileHash: entry.key,
+              objectStorageKey: entry.key,
+              sizeBytes: localFile.size,
+              mimeType: entry.mimeType
+            });
+          }
+        }
+      }
+      return manifests;
+    },
+    async getFilesToPull(localStorage, remoteStorage, entries) {
+      const manifests = [];
+      for (const entry of entries) {
+        const existsLocally = await localStorage.has(entry.key);
+        if (!existsLocally) {
+          const remoteFile = await remoteStorage.get(entry.key);
+          if (remoteFile) {
+            manifests.push({
+              fileHash: entry.key,
+              objectStorageKey: entry.key,
+              sizeBytes: remoteFile.size,
+              mimeType: entry.mimeType
+            });
+          }
+        }
+      }
+      return manifests;
+    },
+    async transferFile(manifest, source, destination) {
+      const key = manifest.objectStorageKey;
+      if (inFlightKeys.has(key)) {
+        return false;
+      }
+      inFlightKeys.add(key);
+      try {
+        if (await destination.has(key)) {
+          return true;
+        }
+        const file = await source.get(key);
+        if (!file) {
+          return false;
+        }
+        await destination.put(key, file.data, {
+          contentType: manifest.mimeType
+        });
+        return true;
+      } finally {
+        inFlightKeys.delete(key);
+      }
+    }
+  };
+}
+
+// src/sync-engine.ts
+var import_protocol_primitives2 = require("@starkeep/protocol-primitives");
+var FILE_RECORDS_TABLE = "_starkeep_sync_records";
+function createSyncEngine(options) {
+  const {
+    localDatabaseAdapter,
+    localObjectStorage,
+    remoteObjectStorage,
+    transport,
+    clock,
+    syncState,
+    appSyncableSource,
+    syncSharedRecords = true,
+    pageLimit = 1e3,
+    scanPageSize = 500
+  } = options;
+  const changeNotifier = createChangeNotifier();
+  const fileSyncEngine = createFileSyncEngine();
+  async function loadOwnWatermarks() {
+    if (!syncState) return {};
+    return syncState.getWatermarks();
+  }
+  async function loadPeerWatermarks() {
+    if (!syncState) return {};
+    return syncState.getPeerWatermarks();
+  }
+  return {
+    async exchange() {
+      const ownWatermarks = await loadOwnWatermarks();
+      const peerWatermarks = await loadPeerWatermarks();
+      const recordCandidates = [];
+      if (syncSharedRecords) {
+        let scanCursor = void 0;
+        let scanHasMore = true;
+        while (recordCandidates.length < pageLimit && scanHasMore) {
+          const page = await localDatabaseAdapter.query({
+            limit: scanPageSize,
+            ...scanCursor !== void 0 ? { cursor: scanCursor } : {}
+          });
+          if (page.records.length === 0) break;
+          for (const r of page.records) {
+            const peerHlc = peerWatermarks[r.updatedAt.nodeId];
+            if (!peerHlc || (0, import_protocol_primitives2.compareHLC)(r.updatedAt, peerHlc) > 0) {
+              recordCandidates.push(r);
+              if (recordCandidates.length >= pageLimit) break;
+            }
+          }
+          scanHasMore = page.hasMore;
+          scanCursor = page.nextCursor ?? void 0;
+        }
+      }
+      const appRowCandidates = [];
+      if (appSyncableSource) {
+        const zeroStr = (0, import_protocol_primitives2.serializeHLC)(import_protocol_primitives2.ZERO_HLC);
+        outer: for (const ns of appSyncableSource.namespaces.list()) {
+          for (const tableInfo of ns.tables) {
+            let appScanCursor = void 0;
+            let appScanHasMore = true;
+            while (recordCandidates.length + appRowCandidates.length < pageLimit && appScanHasMore) {
+              let page;
+              try {
+                page = await appSyncableSource.applier.scanSince(
+                  ns.appId,
+                  tableInfo.name,
+                  zeroStr,
+                  {
+                    limit: scanPageSize,
+                    ...appScanCursor !== void 0 ? { cursor: appScanCursor } : {}
+                  }
+                );
+              } catch (err) {
+                console.warn(
+                  `[sync] exchange scanSince failed for ${ns.appId}.${tableInfo.name}: ${err.message}`
+                );
+                break;
+              }
+              if (page.rows.length === 0) break;
+              for (const r of page.rows) {
+                const peerHlc = peerWatermarks[r.timestamp.nodeId];
+                if (!peerHlc || (0, import_protocol_primitives2.compareHLC)(r.timestamp, peerHlc) > 0) {
+                  appRowCandidates.push(r);
+                  if (recordCandidates.length + appRowCandidates.length >= pageLimit) {
+                    break;
+                  }
+                }
+              }
+              appScanHasMore = page.hasMore;
+              appScanCursor = page.nextCursor ?? void 0;
+            }
+            if (recordCandidates.length + appRowCandidates.length >= pageLimit) {
+              break outer;
+            }
+          }
+        }
+      }
+      const cappedRecords = [];
+      const cappedAppRows = [];
+      if (recordCandidates.length + appRowCandidates.length <= pageLimit) {
+        cappedRecords.push(...recordCandidates);
+        cappedAppRows.push(...appRowCandidates);
+      } else {
+        const tagged = [
+          ...recordCandidates.map(
+            (r) => ({ kind: "r", rec: r, hlc: r.updatedAt })
+          ),
+          ...appRowCandidates.map(
+            (e) => ({ kind: "a", row: e, hlc: e.timestamp })
+          )
+        ];
+        tagged.sort((a, b) => (0, import_protocol_primitives2.compareHLC)(a.hlc, b.hlc));
+        for (const t of tagged.slice(0, pageLimit)) {
+          if (t.kind === "r") cappedRecords.push(t.rec);
+          else cappedAppRows.push(t.row);
+        }
+      }
+      const outboundByNode = groupOutboundByNodeId(
+        cappedRecords,
+        cappedAppRows
+      );
+      const outboundRecords = [];
+      const outboundAppRows = [];
+      const peerSafeAdvance = /* @__PURE__ */ new Map();
+      for (const [nodeId, items] of outboundByNode) {
+        for (const item of items) {
+          const manifest = outboundManifest(item);
+          if (manifest) {
+            const ok = await transferBlobSafe(
+              manifest,
+              localObjectStorage,
+              remoteObjectStorage,
+              fileSyncEngine,
+              "upload",
+              outboundItemId(item)
+            );
+            if (!ok) break;
+          }
+          if (item.kind === "record") {
+            outboundRecords.push(item.record);
+            peerSafeAdvance.set(nodeId, item.record.updatedAt);
+          } else {
+            outboundAppRows.push(item.entry);
+            peerSafeAdvance.set(nodeId, item.entry.timestamp);
+          }
+        }
+      }
+      const response = await transport.exchange({
+        watermarks: ownWatermarks,
+        records: outboundRecords.length > 0 ? outboundRecords : void 0,
+        appSyncableRows: outboundAppRows.length > 0 ? outboundAppRows : void 0,
+        limit: pageLimit
+      });
+      if (!syncSharedRecords && (response.records?.length ?? 0) > 0) {
+        console.warn(
+          `[sync] dropped ${response.records?.length ?? 0} shared record(s) received on a per-app channel (syncSharedRecords=false)`
+        );
+      }
+      const inboundByNode = groupInboundByNodeId(
+        syncSharedRecords ? response.records : [],
+        response.appSyncableRows
+      );
+      const appliedIds = [];
+      const ownSafeAdvance = /* @__PURE__ */ new Map();
+      for (const [nodeId, items] of inboundByNode) {
+        let contiguous = true;
+        for (const item of items) {
+          const itemHlc = inboundItemHlc(item);
+          const existing = peerSafeAdvance.get(nodeId);
+          if (!existing || (0, import_protocol_primitives2.compareHLC)(itemHlc, existing) > 0) {
+            peerSafeAdvance.set(nodeId, itemHlc);
+          }
+          if (item.kind === "record") {
+            const snapshot = item.record;
+            const current = await localDatabaseAdapter.get(snapshot.id);
+            const metadataAlreadyApplied = current !== null && (0, import_protocol_primitives2.compareHLC)(current.updatedAt, snapshot.updatedAt) >= 0;
+            if (!metadataAlreadyApplied) {
+              clock.receive(snapshot.updatedAt);
+              await localDatabaseAdapter.put(snapshot);
+            }
+            const manifest = manifestForRecord(snapshot);
+            const blobOk = await transferBlobSafe(
+              manifest,
+              remoteObjectStorage,
+              localObjectStorage,
+              fileSyncEngine,
+              "download",
+              snapshot.id
+            );
+            if (!blobOk) {
+              contiguous = false;
+              continue;
+            }
+            if (!metadataAlreadyApplied) appliedIds.push(snapshot.id);
+            if (contiguous) ownSafeAdvance.set(nodeId, snapshot.updatedAt);
+          } else {
+            const entry = item.entry;
+            if (!appSyncableSource) {
+              contiguous = false;
+              continue;
+            }
+            clock.receive(entry.timestamp);
+            try {
+              await appSyncableSource.applier.apply(entry);
+            } catch (err) {
+              console.warn(
+                `[sync] appSyncableRow apply failed (app=${entry.appId} table=${entry.table}): ${err.message}`
+              );
+              contiguous = false;
+              continue;
+            }
+            const manifest = manifestForAppRow(entry);
+            const blobOk = await transferBlobSafe(
+              manifest,
+              remoteObjectStorage,
+              localObjectStorage,
+              fileSyncEngine,
+              "download",
+              `${entry.appId}.${entry.table}`
+            );
+            if (!blobOk) {
+              contiguous = false;
+              continue;
+            }
+            if (contiguous) ownSafeAdvance.set(nodeId, entry.timestamp);
+          }
+        }
+      }
+      if (syncState) {
+        const nextOwnWatermarks = { ...ownWatermarks };
+        for (const hlc of ownSafeAdvance.values()) {
+          advanceWatermark(nextOwnWatermarks, hlc);
+        }
+        await syncState.setWatermarks(nextOwnWatermarks);
+        const nextPeerWatermarks = { ...peerWatermarks };
+        for (const hlc of peerSafeAdvance.values()) {
+          advanceWatermark(nextPeerWatermarks, hlc);
+        }
+        await syncState.setPeerWatermarks(nextPeerWatermarks);
+      }
+      if (appliedIds.length > 0) {
+        changeNotifier.emit({
+          eventType: "local-data-synced",
+          recordIds: appliedIds,
+          timestamp: clock.now()
+        });
+      }
+      return {
+        applied: appliedIds.length,
+        shipped: outboundRecords.length + outboundAppRows.length,
+        hasMore: response.hasMore
+      };
+    },
+    changeNotifier
+  };
+}
+function outboundItemHlc(item) {
+  return item.kind === "record" ? item.record.updatedAt : item.entry.timestamp;
+}
+function inboundItemHlc(item) {
+  return item.kind === "record" ? item.record.updatedAt : item.entry.timestamp;
+}
+function outboundItemId(item) {
+  return item.kind === "record" ? item.record.id : `${item.entry.appId}.${item.entry.table}`;
+}
+function groupOutboundByNodeId(records, appRows) {
+  const out = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    pushToBucket(out, r.updatedAt.nodeId, { kind: "record", record: r });
+  }
+  for (const e of appRows) {
+    pushToBucket(out, e.timestamp.nodeId, { kind: "appRow", entry: e });
+  }
+  for (const arr of out.values()) {
+    arr.sort((a, b) => (0, import_protocol_primitives2.compareHLC)(outboundItemHlc(a), outboundItemHlc(b)));
+  }
+  return out;
+}
+function groupInboundByNodeId(records, appRows) {
+  const out = /* @__PURE__ */ new Map();
+  for (const r of records) {
+    pushToBucket(out, r.updatedAt.nodeId, { kind: "record", record: r });
+  }
+  for (const e of appRows) {
+    pushToBucket(out, e.timestamp.nodeId, { kind: "appRow", entry: e });
+  }
+  for (const arr of out.values()) {
+    arr.sort((a, b) => (0, import_protocol_primitives2.compareHLC)(inboundItemHlc(a), inboundItemHlc(b)));
+  }
+  return out;
+}
+function pushToBucket(map, key, value) {
+  const arr = map.get(key) ?? [];
+  arr.push(value);
+  map.set(key, arr);
+}
+function outboundManifest(item) {
+  return item.kind === "record" ? manifestForRecord(item.record) : manifestForAppRow(item.entry);
+}
+function manifestForRecord(record) {
+  if (!record.objectStorageKey || record.deletedAt) return null;
+  return {
+    fileHash: record.contentHash || record.objectStorageKey,
+    objectStorageKey: record.objectStorageKey,
+    sizeBytes: record.sizeBytes,
+    mimeType: record.mimeType
+  };
+}
+function manifestForAppRow(entry) {
+  if (entry.table !== FILE_RECORDS_TABLE) return null;
+  if (entry.op === "delete") return null;
+  const row = entry.row;
+  if (!row) return null;
+  const key = row["object_storage_key"];
+  if (typeof key !== "string" || key.length === 0) return null;
+  const contentHash = row["content_hash"];
+  const mimeType = row["mime_type"];
+  const sizeBytes = row["size_bytes"];
+  return {
+    fileHash: typeof contentHash === "string" && contentHash.length > 0 ? contentHash : key,
+    objectStorageKey: key,
+    sizeBytes: typeof sizeBytes === "number" ? sizeBytes : Number(sizeBytes) || 0,
+    mimeType: typeof mimeType === "string" ? mimeType : void 0
+  };
+}
+async function transferBlobSafe(manifest, source, destination, fileSyncEngine, direction, itemId) {
+  if (!manifest) return true;
+  try {
+    return await fileSyncEngine.transferFile(manifest, source, destination);
+  } catch (err) {
+    console.warn(
+      `[sync] blob ${direction} failed for ${itemId} (${manifest.objectStorageKey}): ${err.message}`
+    );
+    return false;
+  }
+}
+
+// src/residency.ts
+async function residencyOf(recordRow, localStorage) {
+  if (!recordRow) return "absent";
+  if (recordRow.deleted_at) return "tombstoned";
+  const blobHere = await localStorage.has(recordRow.object_storage_key);
+  return blobHere ? "resident" : "staged";
+}
+
+// src/transports/in-process-transport.ts
+var import_protocol_primitives3 = require("@starkeep/protocol-primitives");
+function createInProcessSyncTransport(options) {
+  const { databaseAdapter, clock, appSyncableSource, syncSharedRecords = true } = options;
+  return {
+    async exchange(request) {
+      if (syncSharedRecords) {
+        for (const snapshot of request.records ?? []) {
+          const current = await databaseAdapter.get(snapshot.id);
+          if (current && (0, import_protocol_primitives3.compareHLC)(current.updatedAt, snapshot.updatedAt) >= 0) {
+            continue;
+          }
+          clock.receive(snapshot.updatedAt);
+          await databaseAdapter.put(snapshot);
+        }
+      } else if ((request.records?.length ?? 0) > 0) {
+        console.warn(
+          `[sync] in-process transport dropped ${request.records?.length ?? 0} shared record(s) on a per-app channel (syncSharedRecords=false)`
+        );
+      }
+      for (const entry of request.appSyncableRows ?? []) {
+        if (!appSyncableSource) continue;
+        const ns = appSyncableSource.namespaces.get(entry.appId);
+        if (!ns) continue;
+        clock.receive(entry.timestamp);
+        try {
+          await appSyncableSource.applier.apply(entry);
+        } catch (err) {
+          console.warn(
+            `[sync] exchange apply appSyncableRow failed (app=${entry.appId} table=${entry.table}): ${err.message}`
+          );
+        }
+      }
+      const limit = request.limit ?? 1e3;
+      const SCAN_PAGE = 500;
+      const collected = [];
+      let cursor = void 0;
+      let scanHasMore = syncSharedRecords;
+      let overflowed = false;
+      while (!overflowed && scanHasMore) {
+        const page = await databaseAdapter.query({
+          limit: SCAN_PAGE,
+          ...cursor !== void 0 ? { cursor } : {}
+        });
+        if (page.records.length === 0) break;
+        for (const r of page.records) {
+          const peerHlc = request.watermarks[r.updatedAt.nodeId];
+          if (!peerHlc || (0, import_protocol_primitives3.compareHLC)(r.updatedAt, peerHlc) > 0) {
+            if (collected.length >= limit) {
+              overflowed = true;
+              break;
+            }
+            collected.push(r);
+          }
+        }
+        if (overflowed) break;
+        scanHasMore = page.hasMore;
+        cursor = page.nextCursor ?? void 0;
+      }
+      const records = collected;
+      const appSyncableRows = [];
+      if (appSyncableSource && records.length < limit) {
+        const scanCapable = appSyncableSource.applier;
+        if (typeof scanCapable.scanSince === "function") {
+          const zeroStr = (0, import_protocol_primitives3.serializeHLC)(import_protocol_primitives3.ZERO_HLC);
+          outer: for (const ns of appSyncableSource.namespaces.list()) {
+            for (const tableInfo of ns.tables) {
+              let appCursor = void 0;
+              let appHasMore = true;
+              while (records.length + appSyncableRows.length < limit && appHasMore) {
+                let page;
+                try {
+                  page = await scanCapable.scanSince(
+                    ns.appId,
+                    tableInfo.name,
+                    zeroStr,
+                    {
+                      limit: SCAN_PAGE,
+                      ...appCursor !== void 0 ? { cursor: appCursor } : {}
+                    }
+                  );
+                } catch (err) {
+                  console.warn(
+                    `[sync] in-process transport scanSince failed for ${ns.appId}.${tableInfo.name}: ${err.message}`
+                  );
+                  break;
+                }
+                if (page.rows.length === 0) break;
+                for (const r of page.rows) {
+                  const peerHlc = request.watermarks[r.timestamp.nodeId];
+                  if (!peerHlc || (0, import_protocol_primitives3.compareHLC)(r.timestamp, peerHlc) > 0) {
+                    appSyncableRows.push(r);
+                    if (records.length + appSyncableRows.length >= limit) break;
+                  }
+                }
+                appHasMore = page.hasMore;
+                appCursor = page.nextCursor ?? void 0;
+              }
+              if (records.length + appSyncableRows.length >= limit) break outer;
+            }
+          }
+        }
+      }
+      const hasMore = overflowed || records.length + appSyncableRows.length >= limit;
+      return { records, appSyncableRows, hasMore };
+    }
+  };
+}
+
+// src/errors.ts
+var import_protocol_primitives4 = require("@starkeep/protocol-primitives");
+var SyncError = class extends import_protocol_primitives4.StarkeepError {
+  constructor(message, cause) {
+    super(message, "SYNC_ERROR", cause);
+    this.name = "SyncError";
+  }
+};
+
+// src/transports/http-transport.ts
+function createHttpSyncTransport(options) {
+  const { baseUrl, fetch: fetchImpl = globalThis.fetch, getAuthHeader } = options;
+  const trimmed = baseUrl.replace(/\/+$/, "");
+  async function postJson(path, body) {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    const auth = getAuthHeader?.();
+    if (auth) headers["Authorization"] = auth;
+    const response = await fetchImpl(`${trimmed}${path}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "");
+      throw new SyncError(
+        `${path} failed: ${response.status} ${response.statusText} ${text}`
+      );
+    }
+    return await response.json();
+  }
+  return {
+    async exchange(request) {
+      return postJson(
+        "/sync/exchange",
+        request
+      );
+    }
+  };
+}
+
+// src/transports/http-server.ts
+function createHttpSyncHandler(options) {
+  const transport = options.transport ?? createInProcessSyncTransport({
+    databaseAdapter: options.databaseAdapter,
+    clock: options.clock,
+    objectStorage: options.objectStorageAdapter
+  });
+  return async (req, res) => {
+    const url = new URL(
+      req.url || "/",
+      `http://${req.headers.host ?? "localhost"}`
+    );
+    if (req.method === "POST" && url.pathname === "/sync/exchange") {
+      const body = await readJson(req);
+      const response = await transport.exchange(body);
+      sendJson(res, 200, response);
+      return true;
+    }
+    const fileMatch = url.pathname.match(/^\/files\/(.+)$/);
+    if (fileMatch) {
+      const key = decodeURIComponent(fileMatch[1]);
+      const storage = options.objectStorageAdapter;
+      if (req.method === "HEAD") {
+        const exists = await storage.has(key);
+        res.writeHead(exists ? 200 : 404);
+        res.end();
+        return true;
+      }
+      if (req.method === "GET") {
+        const file = await storage.get(key);
+        if (!file) {
+          res.writeHead(404);
+          res.end();
+          return true;
+        }
+        res.writeHead(200, {
+          "Content-Type": file.contentType ?? "application/octet-stream",
+          "Content-Length": String(file.size)
+        });
+        res.end(Buffer.from(file.data));
+        return true;
+      }
+      if (req.method === "PUT") {
+        const bytes = await readBinary(req);
+        const contentType = req.headers["content-type"];
+        await storage.put(key, bytes, {
+          contentType: typeof contentType === "string" ? contentType : void 0
+        });
+        res.writeHead(200);
+        res.end();
+        return true;
+      }
+      if (req.method === "DELETE") {
+        await storage.delete(key);
+        res.writeHead(204);
+        res.end();
+        return true;
+      }
+    }
+    return false;
+  };
+}
+function sendJson(res, status, body) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(body));
+}
+async function readJson(req) {
+  const buf = await readBinary(req);
+  return JSON.parse(buf.toString("utf-8"));
+}
+function readBinary(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks)));
+    req.on("error", reject);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SyncError,
+  advanceWatermark,
+  createChangeNotifier,
+  createFileSyncEngine,
+  createHttpSyncHandler,
+  createHttpSyncTransport,
+  createInProcessSyncTransport,
+  createSqliteSyncStateStore,
+  createSyncEngine,
+  mergeWatermarks,
+  residencyOf,
+  selectUnseen,
+  watermarkFor
+});
+//# sourceMappingURL=index.cjs.map