reflectdb 0.1.3 → 0.3.0

package/dist/cjs/server/storage/object/index.cjs

@@ -0,0 +1,2284 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/server/storage/object/index.ts
+var exports_object = {};
+__export(exports_object, {
+  BackpressureError: () => BackpressureError,
+  IncompleteStateError: () => IncompleteStateError,
+  MemoryLimitExceededError: () => MemoryLimitExceededError,
+  NotWriterError: () => NotWriterError,
+  OBJECT_STORAGE_DEFAULTS: () => OBJECT_STORAGE_DEFAULTS,
+  PreconditionFailedError: () => PreconditionFailedError,
+  createFilesystemDriver: () => createFilesystemDriver,
+  createMemoryDriver: () => createMemoryDriver,
+  createObjectStorage: () => createObjectStorage,
+  createS3Driver: () => createS3Driver,
+  resolveObjectStorageConfig: () => resolveObjectStorageConfig,
+  roomPrefix: () => roomPrefix
+});
+module.exports = __toCommonJS(exports_object);
+
+// src/server/storage/object/types.ts
+class PreconditionFailedError extends Error {
+  key;
+  constructor(key, message) {
+    super(message ?? `Conditional write failed for "${key}" (etag mismatch)`);
+    this.name = "PreconditionFailedError";
+    this.key = key;
+  }
+}
+
+class BackpressureError extends Error {
+  bufferedBytes;
+  limitBytes;
+  constructor(bufferedBytes, limitBytes) {
+    super(`Object storage write buffer is full (${bufferedBytes} > ${limitBytes} bytes). ` + `The object store is not keeping up; the write was rejected so backpressure ` + `reaches the client. Set batch.onBackpressure to "degrade" to accept writes ` + `without a durability guarantee instead.`);
+    this.name = "BackpressureError";
+    this.bufferedBytes = bufferedBytes;
+    this.limitBytes = limitBytes;
+  }
+}
+
+class MemoryLimitExceededError extends Error {
+  usedBytes;
+  limitBytes;
+  constructor(usedBytes, limitBytes) {
+    super(`Object storage room state exceeded its memory budget ` + `(${usedBytes} > ${limitBytes} bytes). State is authoritative in memory, so ` + `this is a hard ceiling rather than a slowdown. Raise memory.maxRoomBytes, ` + `shard the room, or wait for memory.onExceeded: "spill".`);
+    this.name = "MemoryLimitExceededError";
+    this.usedBytes = usedBytes;
+    this.limitBytes = limitBytes;
+  }
+}
+
+class IncompleteStateError extends Error {
+  roomId;
+  key;
+  constructor(roomId, key, detail) {
+    super(`Object storage: object "${key}" named by the manifest for room "${roomId}" is ` + `missing. ${detail}`);
+    this.name = "IncompleteStateError";
+    this.roomId = roomId;
+    this.key = key;
+  }
+}
+
+class NotWriterError extends Error {
+  roomId;
+  constructor(roomId, detail) {
+    super(`Not the writer for room "${roomId}"${detail ? `: ${detail}` : ""}`);
+    this.name = "NotWriterError";
+    this.roomId = roomId;
+  }
+}
+var OBJECT_STORAGE_DEFAULTS = {
+  durability: "durable",
+  retentionMs: Number.POSITIVE_INFINITY,
+  concurrency: "single-writer",
+  batch: {
+    maxBytes: 4 * 1024 * 1024,
+    minLingerMs: 5,
+    maxBufferBytes: 64 * 1024 * 1024,
+    onBackpressure: "reject"
+  },
+  compaction: {
+    afterSegments: 200,
+    afterBytes: 64 * 1024 * 1024,
+    gcGraceMs: 60 * 60 * 1000
+  },
+  lease: {
+    ttlMs: 5 * 60 * 1000,
+    renewMs: 2 * 60 * 1000,
+    mode: "on-write"
+  },
+  memory: {
+    maxTotalBytes: Number.POSITIVE_INFINITY,
+    maxRoomBytes: Number.POSITIVE_INFINITY,
+    onExceeded: "reject",
+    idleEvictMs: 5 * 60 * 1000
+  },
+  shutdownFlushMs: 5000
+};
+
+// src/server/storage/object/state.ts
+var systemClock = {
+  now: () => Date.now(),
+  delay: (ms) => new Promise((resolve) => {
+    unref(setTimeout(resolve, ms));
+  }),
+  setTimer: (fn, ms) => {
+    const id = setTimeout(fn, ms);
+    unref(id);
+    return () => {
+      clearTimeout(id);
+    };
+  }
+};
+function unref(id) {
+  id.unref?.();
+}
+
+class ProcessMemoryBudget {
+  limitBytes = Number.POSITIVE_INFINITY;
+  usedBytes = 0;
+  get used() {
+    return this.usedBytes;
+  }
+  get limit() {
+    return this.limitBytes;
+  }
+  constrain(limit) {
+    if (limit < this.limitBytes)
+      this.limitBytes = limit;
+  }
+  add(delta) {
+    this.usedBytes += delta;
+    if (this.usedBytes < 0)
+      this.usedBytes = 0;
+  }
+}
+var processMemoryBudget = new ProcessMemoryBudget;
+function approxBytes(value) {
+  if (value === undefined)
+    return 0;
+  return JSON.stringify(value)?.length ?? 0;
+}
+function reservationBytes(opId) {
+  return opId.length + 24;
+}
+function recordHlc(record) {
+  if (record.k === "reserve")
+    return "";
+  return record.k === "op" ? record.op.hlc : record.row.hlc;
+}
+var OP_ID_RETENTION_MS = 24 * 60 * 60 * 1000;
+var OP_ID_SWEEP_INTERVAL_MS = 60000;
+
+class RoomState {
+  memory;
+  clock;
+  budget;
+  rows = new Map;
+  ops = [];
+  reserved = new Map;
+  meta = new Map;
+  roomBytes = 0;
+  highestHlc = null;
+  lastSweepAt = 0;
+  constructor(options) {
+    this.memory = options.memory;
+    this.clock = options.clock ?? systemClock;
+    this.budget = options.budget ?? processMemoryBudget;
+    this.budget.constrain(this.memory.maxTotalBytes);
+  }
+  get bytes() {
+    return this.roomBytes;
+  }
+  get maxHlc() {
+    return this.highestHlc;
+  }
+  getRow(table, rowId) {
+    const entry = this.rows.get(table)?.get(rowId);
+    if (!entry)
+      return { row: null, rowHlc: null, colClocks: {} };
+    return { row: { ...entry.row }, rowHlc: entry.hlc, colClocks: { ...entry.colClocks } };
+  }
+  getRowsByIds(table, rowIds) {
+    const out = {};
+    const tableRows = this.rows.get(table);
+    if (!tableRows)
+      return out;
+    for (const rowId of rowIds) {
+      const entry = tableRows.get(rowId);
+      if (entry) {
+        out[rowId] = {
+          row: { ...entry.row },
+          rowHlc: entry.hlc,
+          colClocks: { ...entry.colClocks }
+        };
+      }
+    }
+    return out;
+  }
+  getRows(table, filter) {
+    const rows = [];
+    const colClocks = {};
+    const tableRows = this.rows.get(table);
+    if (!tableRows)
+      return { rows, colClocks };
+    const filterKeys = filter ? Object.keys(filter) : [];
+    for (const [rowId, entry] of tableRows) {
+      if (filterKeys.length > 0) {
+        let matches = true;
+        for (const key of filterKeys) {
+          if (entry.row[key] !== filter[key]) {
+            matches = false;
+            break;
+          }
+        }
+        if (!matches)
+          continue;
+      }
+      rows.push({ ...entry.row });
+      colClocks[rowId] = { ...entry.colClocks };
+    }
+    return { rows, colClocks };
+  }
+  getOpsSince(since, tables) {
+    if (tables.length === 0)
+      return [];
+    const wanted = new Set(tables);
+    const out = [];
+    for (let i = this.indexAfter(since);i < this.ops.length; i++) {
+      const op = this.ops[i];
+      if (wanted.has(op.entry.table))
+        out.push({ ...op.entry });
+    }
+    return out;
+  }
+  getChangedTablesSince(since, tables) {
+    if (tables.length === 0)
+      return [];
+    const wanted = new Set(tables);
+    const changed = new Set;
+    for (let i = this.indexAfter(since);i < this.ops.length; i++) {
+      const table = this.ops[i].entry.table;
+      if (wanted.has(table))
+        changed.add(table);
+      if (changed.size === wanted.size)
+        break;
+    }
+    return [...changed];
+  }
+  getOplogHead(tables) {
+    if (tables.length === 0)
+      return null;
+    const wanted = new Set(tables);
+    for (let i = this.ops.length - 1;i >= 0; i--) {
+      const op = this.ops[i];
+      if (wanted.has(op.entry.table))
+        return op.entry.hlc;
+    }
+    return null;
+  }
+  getMeta(key) {
+    return this.meta.get(key) ?? null;
+  }
+  metaSnapshot() {
+    return Object.fromEntries(this.meta);
+  }
+  putRow(table, rowId, row, colClocks, hlc) {
+    let tableRows = this.rows.get(table);
+    const previous = tableRows?.get(rowId);
+    if (row === null) {
+      if (previous && tableRows) {
+        this.addBytes(-previous.bytes);
+        tableRows.delete(rowId);
+        if (tableRows.size === 0)
+          this.rows.delete(table);
+      }
+      this.noteHlc(hlc);
+      return;
+    }
+    const bytes = table.length + rowId.length + hlc.length + approxBytes(row) + approxBytes(colClocks);
+    this.addBytes(bytes - (previous?.bytes ?? 0));
+    if (!tableRows) {
+      tableRows = new Map;
+      this.rows.set(table, tableRows);
+    }
+    tableRows.set(rowId, { row: { ...row }, colClocks: { ...colClocks }, hlc, bytes });
+    this.noteHlc(hlc);
+  }
+  assertCanAdmitApply(mutation, op) {
+    const previous = this.rows.get(mutation.table)?.get(mutation.rowId);
+    const rowBytes = mutation.row === null ? 0 : mutation.table.length + mutation.rowId.length + mutation.hlc.length + approxBytes(mutation.row) + approxBytes(mutation.colClocks);
+    const delta = rowBytes - (previous?.bytes ?? 0) + (op ? approxBytes(op) : 0);
+    if (delta > 0)
+      this.checkBytes(delta);
+  }
+  appendOp(entry) {
+    const bytes = approxBytes(entry);
+    this.addBytes(bytes);
+    const item = { entry, bytes };
+    const last = this.ops[this.ops.length - 1];
+    if (!last || last.entry.hlc <= entry.hlc) {
+      this.ops.push(item);
+    } else {
+      this.ops.splice(this.indexAfter(entry.hlc), 0, item);
+    }
+    this.noteHlc(entry.hlc);
+  }
+  deleteOpsBefore(hlc) {
+    const cut = this.indexBefore(hlc);
+    if (cut === 0)
+      return 0;
+    const removed = this.ops.slice(0, cut);
+    let freed = 0;
+    for (const op of removed)
+      freed += op.bytes;
+    this.ops = this.ops.slice(cut);
+    this.addBytes(-freed);
+    return removed.length;
+  }
+  reserveOp(opId) {
+    this.sweepReservedOps();
+    if (this.reserved.has(opId))
+      return false;
+    this.reserved.set(opId, this.clock.now());
+    this.addBytes(reservationBytes(opId));
+    return true;
+  }
+  reserveOps(opIds) {
+    if (opIds.length === 0)
+      return [];
+    this.sweepReservedOps();
+    const now = this.clock.now();
+    const fresh = [];
+    for (const opId of opIds) {
+      if (this.reserved.has(opId))
+        continue;
+      this.reserved.set(opId, now);
+      this.addBytes(reservationBytes(opId));
+      fresh.push(opId);
+    }
+    return fresh;
+  }
+  setMeta(key, value) {
+    this.meta.set(key, value);
+  }
+  loadMeta(meta) {
+    this.meta.clear();
+    for (const [key, value] of Object.entries(meta))
+      this.meta.set(key, value);
+  }
+  applyRecord(record) {
+    if (record.k === "reserve") {
+      this.restoreReservations(record.opIds, record.at);
+      return;
+    }
+    if (record.k === "row" || record.k === "apply") {
+      const { table, rowId, row, colClocks, hlc } = record.row;
+      this.putRow(table, rowId, row, colClocks, hlc);
+    }
+    if (record.k === "op" || record.k === "apply") {
+      this.appendOp(record.op);
+    }
+  }
+  restoreReservations(opIds, at) {
+    const cutoff = this.clock.now() - OP_ID_RETENTION_MS;
+    if (at < cutoff)
+      return;
+    for (const opId of opIds) {
+      const existing = this.reserved.get(opId);
+      if (existing === undefined) {
+        this.reserved.set(opId, at);
+        this.addBytes(reservationBytes(opId));
+      } else if (at < existing) {
+        this.reserved.set(opId, at);
+      }
+    }
+  }
+  applyRecords(records) {
+    for (const record of records)
+      this.applyRecord(record);
+  }
+  toSnapshot() {
+    const rows = [];
+    for (const [table, tableRows] of this.rows) {
+      for (const [rowId, entry] of tableRows) {
+        rows.push({ table, rowId, row: entry.row, colClocks: entry.colClocks, hlc: entry.hlc });
+      }
+    }
+    const cutoff = this.clock.now() - OP_ID_RETENTION_MS;
+    const reservedOps = [];
+    for (const [opId, at] of this.reserved) {
+      if (at >= cutoff)
+        reservedOps.push([opId, at]);
+    }
+    return { version: 1, hlc: this.highestHlc, rows, reservedOps };
+  }
+  loadSnapshot(record) {
+    this.reset();
+    for (const row of record.rows) {
+      this.putRow(row.table, row.rowId, row.row, row.colClocks, row.hlc);
+    }
+    const cutoff = this.clock.now() - OP_ID_RETENTION_MS;
+    for (const [opId, at] of record.reservedOps) {
+      if (at < cutoff)
+        continue;
+      this.reserved.set(opId, at);
+      this.addBytes(reservationBytes(opId));
+    }
+    if (record.hlc && (!this.highestHlc || record.hlc > this.highestHlc)) {
+      this.highestHlc = record.hlc;
+    }
+  }
+  dispose() {
+    this.reset();
+  }
+  reset() {
+    this.addBytes(-this.roomBytes);
+    this.rows.clear();
+    this.ops = [];
+    this.reserved.clear();
+    this.highestHlc = null;
+  }
+  noteHlc(hlc) {
+    if (!this.highestHlc || hlc > this.highestHlc)
+      this.highestHlc = hlc;
+  }
+  checkBytes(delta) {
+    const roomTotal = this.roomBytes + delta;
+    if (roomTotal > this.memory.maxRoomBytes) {
+      this.refuse(roomTotal, this.memory.maxRoomBytes);
+    }
+    const processTotal = this.budget.used + delta;
+    if (processTotal > this.budget.limit) {
+      this.refuse(processTotal, this.budget.limit);
+    }
+  }
+  addBytes(delta) {
+    if (delta > 0)
+      this.checkBytes(delta);
+    this.roomBytes += delta;
+    if (this.roomBytes < 0)
+      this.roomBytes = 0;
+    this.budget.add(delta);
+  }
+  refuse(used, limit) {
+    const policy = this.memory.onExceeded;
+    if (policy !== "reject") {
+      throw new Error(`memory.onExceeded: "${policy}" is not implemented in phase 1 ` + `(state exceeded ${limit} bytes). "evict" lands in phase 2 and "spill" ` + `— DuckDB-over-Parquet reads — in phase 3, because it needs the Parquet ` + `layer. Use "reject" and raise memory.maxRoomBytes / maxTotalBytes, or ` + `shard the room. See docs/object-storage.md.`);
+    }
+    throw new MemoryLimitExceededError(used, limit);
+  }
+  indexAfter(hlc) {
+    let lo = 0;
+    let hi = this.ops.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (this.ops[mid].entry.hlc > hlc)
+        hi = mid;
+      else
+        lo = mid + 1;
+    }
+    return lo;
+  }
+  indexBefore(hlc) {
+    let lo = 0;
+    let hi = this.ops.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      if (this.ops[mid].entry.hlc >= hlc)
+        hi = mid;
+      else
+        lo = mid + 1;
+    }
+    return lo;
+  }
+  sweepReservedOps() {
+    const now = this.clock.now();
+    if (now - this.lastSweepAt < OP_ID_SWEEP_INTERVAL_MS)
+      return;
+    this.lastSweepAt = now;
+    const cutoff = now - OP_ID_RETENTION_MS;
+    let freed = 0;
+    for (const [opId, at] of this.reserved) {
+      if (at < cutoff) {
+        this.reserved.delete(opId);
+        freed += reservationBytes(opId);
+      }
+    }
+    if (freed > 0)
+      this.addBytes(-freed);
+  }
+}
+
+// src/server/storage/object/manifest.ts
+var MANIFEST_KEY = "_manifest";
+var LEASE_KEY = "_lease";
+function roomPrefix(roomId) {
+  return `rooms/${encodeURIComponent(roomId)}/`;
+}
+function emptyManifest() {
+  return {
+    version: 1,
+    epoch: 0,
+    commitSeq: 0,
+    lastWriter: "",
+    snapshotKey: null,
+    snapshotHlc: null,
+    walSegs: [],
+    oplogHead: null,
+    meta: {},
+    pendingGc: []
+  };
+}
+var encoder = new TextEncoder;
+var decoder = new TextDecoder;
+function encodeJson(value) {
+  return encoder.encode(JSON.stringify(value));
+}
+function decodeJson(body, key) {
+  try {
+    return JSON.parse(decoder.decode(body));
+  } catch (error) {
+    throw new Error(`Object storage: "${key}" is not valid JSON and cannot be recovered automatically. ` + `Refusing to continue rather than overwrite live room state. (${String(error)})`);
+  }
+}
+var OPTIMISTIC_MAX_ATTEMPTS = 6;
+
+class ManifestStore {
+  driver;
+  roomId;
+  writerId;
+  leaseConfig;
+  concurrency;
+  clock;
+  manifestKey;
+  leaseKey;
+  cached = emptyManifest();
+  cachedEtag = null;
+  loaded = false;
+  leaseEtag = null;
+  leaseEpoch = 0;
+  leaseExpiresAt = 0;
+  held = false;
+  cancelRenew = null;
+  wroteSinceRenew = false;
+  fenceReason = null;
+  stopped = false;
+  chain = Promise.resolve();
+  constructor(options) {
+    this.driver = options.driver;
+    this.roomId = options.roomId;
+    this.writerId = options.writerId;
+    this.leaseConfig = options.lease;
+    this.concurrency = options.concurrency ?? "single-writer";
+    this.clock = options.clock ?? systemClock;
+    const prefix = roomPrefix(options.roomId);
+    this.manifestKey = `${prefix}${MANIFEST_KEY}`;
+    this.leaseKey = `${prefix}${LEASE_KEY}`;
+  }
+  get manifest() {
+    return this.cached;
+  }
+  get epoch() {
+    return this.leaseEpoch;
+  }
+  get isWriter() {
+    return this.held && !this.fenceReason;
+  }
+  get fenced() {
+    return this.fenceReason !== null;
+  }
+  async init() {
+    if (this.driver.caps.casWildcard)
+      return;
+    if (!await this.driver.get(this.manifestKey)) {
+      await this.driver.put(this.manifestKey, encodeJson(emptyManifest()));
+    }
+    if (!await this.driver.get(this.leaseKey)) {
+      const unowned = { owner: "", epoch: 0, expiresAt: 0 };
+      await this.driver.put(this.leaseKey, encodeJson(unowned));
+    }
+  }
+  async load() {
+    const record = await this.driver.get(this.manifestKey);
+    if (!record) {
+      this.cached = emptyManifest();
+      this.cachedEtag = null;
+    } else {
+      this.cached = decodeJson(record.body, this.manifestKey);
+      this.cachedEtag = record.etag;
+      if (typeof this.cached.commitSeq !== "number")
+        this.cached.commitSeq = 0;
+      if (typeof this.cached.lastWriter !== "string")
+        this.cached.lastWriter = "";
+      if (this.cached.epoch > this.leaseEpoch)
+        this.leaseEpoch = this.cached.epoch;
+    }
+    this.loaded = true;
+    return this.cached;
+  }
+  async start() {
+    if (this.concurrency === "optimistic")
+      return;
+    if (this.leaseConfig.mode === "always")
+      await this.acquire();
+  }
+  async acquire() {
+    this.assertNotFenced();
+    const current = await this.driver.get(this.leaseKey);
+    const record = current ? decodeJson(current.body, this.leaseKey) : null;
+    const now = this.clock.now();
+    if (record && record.owner !== this.writerId && record.expiresAt > now) {
+      throw new NotWriterError(this.roomId, `lease held by "${record.owner}" for another ${record.expiresAt - now}ms`);
+    }
+    const ours = record?.owner === this.writerId && record.expiresAt > now && this.leaseEtag !== null;
+    const epoch = ours ? record.epoch : Math.max(record?.epoch ?? 0, this.leaseEpoch) + 1;
+    const next = { owner: this.writerId, epoch, expiresAt: now + this.leaseConfig.ttlMs };
+    try {
+      this.leaseEtag = await this.driver.put(this.leaseKey, encodeJson(next), current ? { ifMatch: current.etag } : this.createOptions());
+    } catch (error) {
+      if (error instanceof PreconditionFailedError) {
+        throw new NotWriterError(this.roomId, "lost the lease CAS to a concurrent writer");
+      }
+      throw error;
+    }
+    this.leaseEpoch = epoch;
+    this.leaseExpiresAt = next.expiresAt;
+    this.held = true;
+    this.armRenew();
+  }
+  async ensureWriter() {
+    if (this.concurrency === "optimistic")
+      return;
+    this.assertNotFenced();
+    if (this.held)
+      return;
+    await this.acquire();
+  }
+  async release() {
+    this.disarmRenew();
+    if (!this.held || !this.leaseEtag)
+      return;
+    this.held = false;
+    const unowned = { owner: "", epoch: this.leaseEpoch, expiresAt: 0 };
+    try {
+      await this.driver.put(this.leaseKey, encodeJson(unowned), { ifMatch: this.leaseEtag });
+    } catch (error) {
+      if (!(error instanceof PreconditionFailedError))
+        throw error;
+    }
+    this.leaseEtag = null;
+  }
+  stop() {
+    this.stopped = true;
+    this.disarmRenew();
+  }
+  commit(mutate) {
+    const apply = this.concurrency === "optimistic" ? () => this.doCommitOptimistic(mutate) : () => this.doCommit(mutate);
+    const run = this.chain.then(apply, apply);
+    this.chain = run.catch(() => {
+      return;
+    });
+    return run;
+  }
+  async doCommitOptimistic(mutate) {
+    for (let attempt = 1;; attempt++) {
+      if (!this.loaded)
+        await this.load();
+      const next = this.buildNext();
+      mutate(next);
+      try {
+        const etag = await this.driver.put(this.manifestKey, encodeJson(next), this.cachedEtag ? { ifMatch: this.cachedEtag } : this.createOptions());
+        this.cached = next;
+        this.cachedEtag = etag;
+        return next;
+      } catch (error) {
+        if (!(error instanceof PreconditionFailedError))
+          throw error;
+        if (await this.adoptOwnCommit(next))
+          return next;
+        if (attempt >= OPTIMISTIC_MAX_ATTEMPTS) {
+          throw new Error(`Object storage: room "${this.roomId}" lost the manifest CAS ` + `${OPTIMISTIC_MAX_ATTEMPTS} times in a row. That is sustained write ` + `contention on one room, which more retries will not fix — route the ` + `room to fewer writers, or use concurrency: "single-writer".`);
+        }
+        await this.load();
+      }
+    }
+  }
+  buildNext() {
+    return {
+      ...this.cached,
+      epoch: this.concurrency === "optimistic" ? this.cached.epoch : this.leaseEpoch,
+      commitSeq: this.cached.commitSeq + 1,
+      lastWriter: this.writerId,
+      walSegs: [...this.cached.walSegs],
+      meta: { ...this.cached.meta },
+      pendingGc: [...this.cached.pendingGc]
+    };
+  }
+  async refresh() {
+    const record = await this.driver.get(this.manifestKey);
+    if (!record)
+      return this.cached;
+    const stored = decodeJson(record.body, this.manifestKey);
+    if (typeof stored.commitSeq !== "number")
+      stored.commitSeq = 0;
+    if (typeof stored.lastWriter !== "string")
+      stored.lastWriter = "";
+    this.cached = stored;
+    this.cachedEtag = record.etag;
+    this.loaded = true;
+    return stored;
+  }
+  async doCommit(mutate) {
+    this.assertNotFenced();
+    if (this.stopped) {
+      throw new Error(`Object storage: room "${this.roomId}" is closed; refusing to commit its manifest.`);
+    }
+    if (!this.loaded)
+      await this.load();
+    if (!this.held)
+      await this.acquire();
+    const next = this.buildNext();
+    mutate(next);
+    let etag;
+    try {
+      etag = await this.driver.put(this.manifestKey, encodeJson(next), this.cachedEtag ? { ifMatch: this.cachedEtag } : this.createOptions());
+    } catch (error) {
+      if (error instanceof PreconditionFailedError) {
+        const adopted = await this.adoptOwnCommit(next);
+        if (adopted)
+          return next;
+        this.fence("the manifest CAS was lost — another writer owns this room");
+        throw new NotWriterError(this.roomId, "manifest CAS failed; another writer committed against this etag");
+      }
+      throw error;
+    }
+    this.cached = next;
+    this.cachedEtag = etag;
+    this.wroteSinceRenew = true;
+    return next;
+  }
+  createOptions() {
+    if (this.driver.caps.casWildcard)
+      return { ifNoneMatch: "*" };
+    throw new Error(`Object storage: this driver does not support create-if-absent ` + `(caps.casWildcard === false, e.g. MinIO), and room "${this.roomId}" has not ` + `been seeded. Run the adapter's init() once as a deploy step before starting ` + `writers. See docs/object-storage.md#the-minio-gotcha.`);
+  }
+  async adoptOwnCommit(attempted) {
+    let current;
+    try {
+      current = await this.driver.get(this.manifestKey);
+    } catch {
+      return false;
+    }
+    if (!current)
+      return false;
+    let stored;
+    try {
+      stored = decodeJson(current.body, this.manifestKey);
+    } catch {
+      return false;
+    }
+    if (stored.lastWriter !== this.writerId || stored.commitSeq !== attempted.commitSeq || stored.epoch !== attempted.epoch) {
+      return false;
+    }
+    this.cached = stored;
+    this.cachedEtag = current.etag;
+    this.wroteSinceRenew = true;
+    return true;
+  }
+  assertNotFenced() {
+    if (this.fenceReason)
+      throw new NotWriterError(this.roomId, this.fenceReason);
+  }
+  fence(reason) {
+    if (this.fenceReason)
+      return;
+    this.fenceReason = reason;
+    this.held = false;
+    this.disarmRenew();
+  }
+  armRenew() {
+    this.disarmRenew();
+    if (this.stopped)
+      return;
+    this.wroteSinceRenew = false;
+    this.cancelRenew = this.clock.setTimer(() => {
+      this.onRenewTick();
+    }, this.leaseConfig.renewMs);
+  }
+  disarmRenew() {
+    this.cancelRenew?.();
+    this.cancelRenew = null;
+  }
+  async onRenewTick() {
+    this.cancelRenew = null;
+    if (this.stopped || !this.held || this.fenceReason)
+      return;
+    if (this.leaseConfig.mode === "on-write" && !this.wroteSinceRenew) {
+      this.held = false;
+      return;
+    }
+    try {
+      await this.renew();
+      this.armRenew();
+    } catch (error) {
+      if (error instanceof PreconditionFailedError || error instanceof NotWriterError) {
+        this.fence("lease renewal lost the CAS — another writer took this room");
+        return;
+      }
+      if (this.clock.now() >= this.leaseExpiresAt) {
+        this.fence("lease expired while renewals were failing");
+        return;
+      }
+      this.cancelRenew = this.clock.setTimer(() => {
+        this.onRenewTick();
+      }, Math.max(1, Math.floor(this.leaseConfig.renewMs / 4)));
+    }
+  }
+  async renew() {
+    const now = this.clock.now();
+    const next = {
+      owner: this.writerId,
+      epoch: this.leaseEpoch,
+      expiresAt: now + this.leaseConfig.ttlMs
+    };
+    const etag = await this.driver.put(this.leaseKey, encodeJson(next), this.leaseEtag ? { ifMatch: this.leaseEtag } : this.createOptions());
+    this.leaseEtag = etag;
+    this.leaseExpiresAt = next.expiresAt;
+    this.wroteSinceRenew = false;
+  }
+}
+
+// src/server/storage/object/wal.ts
+var UNAVAILABLE_AFTER_FAILURES = 3;
+var RETRY_BASE_MS = 100;
+var RETRY_MAX_MS = 1e4;
+var encoder2 = new TextEncoder;
+var decoder2 = new TextDecoder;
+function encodeSegment(lines) {
+  return encoder2.encode(lines.join(`
+`));
+}
+function decodeSegment(body, key) {
+  const text = decoder2.decode(body);
+  const records = [];
+  for (const line of text.split(`
+`)) {
+    if (line.length === 0)
+      continue;
+    try {
+      records.push(JSON.parse(line));
+    } catch (error) {
+      throw new Error(`Object storage: WAL segment "${key}" contains an unparsable record. ` + `Refusing to boot with a partial log. (${String(error)})`);
+    }
+  }
+  return records;
+}
+
+class WalWriter {
+  driver;
+  manifest;
+  batch;
+  durability;
+  concurrency;
+  writerId;
+  clock;
+  prefix;
+  onCommitted;
+  buffer = [];
+  bufferedBytes = 0;
+  seq = 0;
+  seqEpoch = -1;
+  running = false;
+  stopped = false;
+  loop = null;
+  wakeWaiter = null;
+  stopSignal;
+  releaseStopSignal = () => {};
+  forced = false;
+  flushWaiters = [];
+  failures = 0;
+  backpressured = false;
+  currentHealth = "healthy";
+  terminal = null;
+  durableHead = null;
+  durableListeners = [];
+  healthListeners = [];
+  constructor(options) {
+    this.driver = options.driver;
+    this.manifest = options.manifest;
+    this.batch = options.batch;
+    this.durability = options.durability;
+    this.concurrency = options.concurrency ?? "single-writer";
+    this.writerId = options.writerId ?? "writer";
+    this.clock = options.clock ?? systemClock;
+    this.prefix = roomPrefix(options.roomId);
+    this.onCommitted = options.onCommitted;
+    this.stopSignal = new Promise((resolve) => {
+      this.releaseStopSignal = resolve;
+    });
+  }
+  get health() {
+    return this.currentHealth;
+  }
+  get durableHlc() {
+    return this.durableHead;
+  }
+  get bufferBytes() {
+    return this.bufferedBytes;
+  }
+  onDurable(callback) {
+    this.durableListeners.push(callback);
+  }
+  onHealthChange(callback) {
+    this.healthListeners.push(callback);
+  }
+  start() {
+    if (this.running || this.stopped)
+      return;
+    this.running = true;
+    this.loop = this.run().catch((error) => {
+      console.warn("[reflectdb] object storage: the WAL flush loop exited abnormally:", error);
+    });
+  }
+  prepare(record) {
+    this.assertWritable();
+    const line = JSON.stringify(record);
+    const bytes = line.length + 1;
+    let durable = this.durability === "durable";
+    if (this.bufferedBytes + bytes > this.batch.maxBufferBytes) {
+      if (this.batch.onBackpressure === "reject") {
+        throw new BackpressureError(this.bufferedBytes + bytes, this.batch.maxBufferBytes);
+      }
+      this.setBackpressured(true);
+      durable = false;
+    }
+    return { record, line, bytes, hlc: recordHlc(record), durable };
+  }
+  append(prepared) {
+    this.assertWritable();
+    this.bufferedBytes += prepared.bytes;
+    let resolve = () => {};
+    let reject = () => {};
+    const settled = !prepared.durable;
+    const promise = settled ? Promise.resolve() : new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    this.buffer.push({ ...prepared, resolve, reject, settled });
+    this.start();
+    this.wake();
+    return promise;
+  }
+  enqueue(record) {
+    return this.append(this.prepare(record));
+  }
+  flush() {
+    if (this.terminal)
+      return Promise.reject(this.terminal);
+    if (this.buffer.length === 0)
+      return Promise.resolve();
+    if (this.stopped) {
+      return Promise.reject(new Error(`Object storage: flush() called after the adapter was closed, with ` + `${this.buffer.length} record(s) still buffered. They were not made durable.`));
+    }
+    this.forced = true;
+    this.start();
+    this.wake();
+    return new Promise((resolve, reject) => {
+      this.flushWaiters.push({ resolve, reject });
+    });
+  }
+  async stop(timeoutMs) {
+    this.stopped = true;
+    if (!this.running && !this.loop)
+      return;
+    this.running = false;
+    this.releaseStopSignal();
+    this.wake();
+    const settled = this.loop?.catch(() => {
+      return;
+    });
+    if (settled) {
+      await (timeoutMs === undefined ? settled : Promise.race([settled, this.clock.delay(timeoutMs)]));
+    }
+    this.loop = null;
+    if (this.buffer.length > 0 && this.flushWaiters.length > 0) {
+      const error = this.terminal ?? new Error(`Object storage: the adapter was closed with ${this.buffer.length} record(s) still ` + `buffered; they were not made durable. Increase shutdownFlushMs, or check ` + `storage health — the store was not accepting writes.`);
+      const waiters = this.flushWaiters;
+      this.flushWaiters = [];
+      for (const waiter of waiters)
+        waiter.reject(error);
+    }
+  }
+  async run() {
+    while (this.running) {
+      if (this.buffer.length === 0) {
+        this.settleFlushWaiters();
+        await this.waitNonEmpty();
+        if (!this.running)
+          break;
+        if (this.buffer.length === 0)
+          continue;
+      }
+      if (this.batch.minLingerMs > 0 && !this.forced) {
+        await this.interruptibleDelay(this.batch.minLingerMs);
+      }
+      await this.flushOnce();
+    }
+    this.settleFlushWaiters();
+  }
+  async flushOnce() {
+    if (this.buffer.length === 0)
+      return;
+    let epoch;
+    try {
+      await this.manifest.ensureWriter();
+      epoch = this.manifest.epoch;
+    } catch (error) {
+      await this.onFlushError(error);
+      return;
+    }
+    if (epoch !== this.seqEpoch) {
+      this.seqEpoch = epoch;
+      this.seq = 0;
+    }
+    let count = 0;
+    let bytes = 0;
+    let maxHlc = "";
+    const lines = [];
+    for (const item of this.buffer) {
+      if (count > 0 && bytes + item.bytes > this.batch.maxBytes)
+        break;
+      bytes += item.bytes;
+      lines.push(item.line);
+      if (item.hlc > maxHlc)
+        maxHlc = item.hlc;
+      count++;
+    }
+    const seq = this.seq;
+    const token = this.concurrency === "optimistic" ? this.writerId : String(epoch);
+    const key = `${this.prefix}wal/${token}-${seq}.jsonl`;
+    const body = encodeSegment(lines);
+    const ref = { key, epoch, seq, bytes: body.length, maxHlc };
+    this.seq++;
+    try {
+      await this.driver.put(key, body);
+      await this.manifest.commit((manifest) => {
+        manifest.walSegs.push(ref);
+        if (maxHlc && (!manifest.oplogHead || maxHlc > manifest.oplogHead)) {
+          manifest.oplogHead = maxHlc;
+        }
+      });
+    } catch (error) {
+      await this.onFlushError(error);
+      return;
+    }
+    const committed = this.buffer.splice(0, count);
+    this.bufferedBytes -= bytes;
+    if (this.bufferedBytes <= this.batch.maxBufferBytes)
+      this.setBackpressured(false);
+    for (const item of committed) {
+      if (!item.settled) {
+        item.settled = true;
+        item.resolve();
+      }
+    }
+    this.failures = 0;
+    this.setHealth(this.backpressured ? "degraded" : "healthy");
+    if (maxHlc && (!this.durableHead || maxHlc > this.durableHead)) {
+      this.durableHead = maxHlc;
+      for (const listener of this.durableListeners)
+        listener(maxHlc);
+    }
+    if (this.buffer.length === 0) {
+      this.forced = false;
+      this.settleFlushWaiters();
+    }
+    if (this.onCommitted) {
+      try {
+        await this.onCommitted();
+      } catch (error) {
+        console.warn("[reflectdb] object storage: post-commit maintenance failed:", error);
+      }
+    }
+  }
+  async onFlushError(error) {
+    if (error instanceof NotWriterError) {
+      this.fail(error);
+      return;
+    }
+    this.failures++;
+    this.setHealth(this.failures >= UNAVAILABLE_AFTER_FAILURES ? "unavailable" : "degraded");
+    const backoff = Math.min(RETRY_MAX_MS, RETRY_BASE_MS * 2 ** (this.failures - 1));
+    await this.interruptibleDelay(backoff);
+  }
+  fail(error) {
+    this.terminal = error;
+    this.running = false;
+    this.setHealth("unavailable");
+    const pending = this.buffer;
+    this.buffer = [];
+    this.bufferedBytes = 0;
+    for (const item of pending) {
+      if (!item.settled) {
+        item.settled = true;
+        item.reject(error);
+      }
+    }
+    const waiters = this.flushWaiters;
+    this.flushWaiters = [];
+    for (const waiter of waiters)
+      waiter.reject(error);
+    this.releaseStopSignal();
+    this.wake();
+  }
+  assertWritable() {
+    if (this.terminal)
+      throw this.terminal;
+    if (this.stopped) {
+      throw new Error("Object storage: the WAL writer is stopped; the adapter was closed.");
+    }
+  }
+  wake() {
+    const waiter = this.wakeWaiter;
+    this.wakeWaiter = null;
+    waiter?.();
+  }
+  waitNonEmpty() {
+    if (this.buffer.length > 0 || !this.running)
+      return Promise.resolve();
+    return new Promise((resolve) => {
+      this.wakeWaiter = resolve;
+    });
+  }
+  async interruptibleDelay(ms) {
+    await Promise.race([this.clock.delay(ms), this.stopSignal]);
+  }
+  settleFlushWaiters() {
+    if (this.buffer.length > 0)
+      return;
+    this.forced = false;
+    const waiters = this.flushWaiters;
+    this.flushWaiters = [];
+    for (const waiter of waiters)
+      waiter.resolve();
+  }
+  setBackpressured(value) {
+    if (this.backpressured === value)
+      return;
+    this.backpressured = value;
+    if (this.failures === 0)
+      this.setHealth(value ? "degraded" : "healthy");
+  }
+  setHealth(health) {
+    if (this.currentHealth === health)
+      return;
+    this.currentHealth = health;
+    for (const listener of this.healthListeners)
+      listener(health);
+  }
+}
+
+// src/server/storage/object/sigv4.ts
+var ALGORITHM = "AWS4-HMAC-SHA256";
+var EMPTY_PAYLOAD_SHA256 = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
+var UNRESERVED = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~";
+var textEncoder = new TextEncoder;
+function subtle() {
+  const webCrypto = globalThis.crypto;
+  if (!webCrypto?.subtle) {
+    throw new Error("The S3 driver needs WebCrypto (globalThis.crypto.subtle) to sign requests, and this runtime does not expose it. It is available on Bun, Node >= 18, Deno, Cloudflare Workers and browsers; on Node 18 outside a secure context it may need --experimental-global-webcrypto.");
+  }
+  return webCrypto.subtle;
+}
+function toHex(bytes) {
+  let out = "";
+  for (const byte of bytes)
+    out += byte.toString(16).padStart(2, "0");
+  return out;
+}
+async function hexSha256(data) {
+  const bytes = typeof data === "string" ? textEncoder.encode(data) : data;
+  return toHex(new Uint8Array(await subtle().digest("SHA-256", bytes)));
+}
+async function hmacSha256(key, data) {
+  const bytes = typeof data === "string" ? textEncoder.encode(data) : data;
+  const cryptoKey = await subtle().importKey("raw", key, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  return new Uint8Array(await subtle().sign("HMAC", cryptoKey, bytes));
+}
+function percentEncode(value) {
+  let out = "";
+  for (const byte of textEncoder.encode(value)) {
+    const char = String.fromCharCode(byte);
+    out += byte < 128 && UNRESERVED.includes(char) ? char : `%${byte.toString(16).toUpperCase().padStart(2, "0")}`;
+  }
+  return out;
+}
+function encodeUriPath(path) {
+  return path.split("/").map(percentEncode).join("/");
+}
+function canonicalQueryString(params) {
+  const encoded = [...params].map(([key, value]) => [percentEncode(key), percentEncode(value)]);
+  encoded.sort((a, b) => {
+    if (a[0] !== b[0])
+      return a[0] < b[0] ? -1 : 1;
+    if (a[1] !== b[1])
+      return a[1] < b[1] ? -1 : 1;
+    return 0;
+  });
+  return encoded.map(([key, value]) => `${key}=${value}`).join("&");
+}
+function canonicalHeaders(headers) {
+  const entries = Object.entries(headers).map(([name, value]) => [name.toLowerCase(), value.trim().replace(/\s+/g, " ")]).sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0);
+  return {
+    canonical: entries.map(([name, value]) => `${name}:${value}
+`).join(""),
+    signedHeaders: entries.map(([name]) => name).join(";")
+  };
+}
+function canonicalRequest(input) {
+  const { canonical: headerBlock, signedHeaders } = canonicalHeaders(input.headers);
+  const canonicalUri = input.url.pathname || "/";
+  const canonical = [
+    input.method.toUpperCase(),
+    canonicalUri,
+    canonicalQueryString(input.url.searchParams),
+    headerBlock,
+    signedHeaders,
+    input.payloadHash
+  ].join(`
+`);
+  return { canonical, signedHeaders };
+}
+function formatAmzDate(now) {
+  return now.toISOString().replace(/[:-]/g, "").replace(/\.\d+/, "");
+}
+async function deriveSigningKey(secret, dateStamp, region, service) {
+  const dateKey = await hmacSha256(textEncoder.encode(`AWS4${secret}`), dateStamp);
+  const regionKey = await hmacSha256(dateKey, region);
+  const serviceKey = await hmacSha256(regionKey, service);
+  return hmacSha256(serviceKey, "aws4_request");
+}
+async function signRequest(input) {
+  const { method, url, credentials, region, service, now } = input;
+  const headers = {};
+  for (const [name, value] of Object.entries(input.headers))
+    headers[name.toLowerCase()] = value;
+  headers.host = url.host;
+  const payloadHash = input.body ? await hexSha256(input.body) : EMPTY_PAYLOAD_SHA256;
+  headers["x-amz-content-sha256"] = payloadHash;
+  const amzDate = formatAmzDate(now);
+  headers["x-amz-date"] = amzDate;
+  if (credentials.sessionToken)
+    headers["x-amz-security-token"] = credentials.sessionToken;
+  const { canonical, signedHeaders } = canonicalRequest({ method, url, headers, payloadHash });
+  const dateStamp = amzDate.slice(0, 8);
+  const scope = `${dateStamp}/${region}/${service}/aws4_request`;
+  const stringToSign = [ALGORITHM, amzDate, scope, await hexSha256(canonical)].join(`
+`);
+  const signingKey = await deriveSigningKey(credentials.secret, dateStamp, region, service);
+  const signature = toHex(await hmacSha256(signingKey, stringToSign));
+  headers.authorization = `${ALGORITHM} Credential=${credentials.keyId}/${scope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+  return headers;
+}
+
+// src/server/storage/object/drivers/s3.ts
+var textEncoder2 = new TextEncoder;
+var MAX_KEYS_PER_DELETE = 1000;
+var MAX_RETRIES = 3;
+var RETRY_BASE_MS2 = 100;
+var MAX_RETRY_AFTER_MS = 20000;
+var DELETE_CONCURRENCY = 8;
+function missingEndpoint(provider) {
+  throw new Error(`store.endpoint is required for provider "${provider}": there is no well-known endpoint to default to. Pass the URL of your ${provider} server, e.g. { provider: "${provider}", endpoint: "http://localhost:9000", bucket: "..." }.`);
+}
+var PROVIDER_PRESETS = {
+  aws: {
+    endpoint: (config) => `https://s3.${config.region ?? "us-east-1"}.amazonaws.com`,
+    region: "us-east-1",
+    urlStyle: "vhost",
+    casWildcard: true,
+    batchDelete: true
+  },
+  r2: {
+    endpoint: (config) => {
+      if (!config.accountId) {
+        throw new Error(`store.accountId is required for provider "r2": the R2 endpoint is https://<accountId>.r2.cloudflarestorage.com and cannot be derived from the bucket name. Find it in the Cloudflare dashboard under R2 > Overview, or pass store.endpoint explicitly.`);
+      }
+      return `https://${config.accountId}.r2.cloudflarestorage.com`;
+    },
+    region: "auto",
+    urlStyle: "vhost",
+    casWildcard: true,
+    batchDelete: true
+  },
+  tigris: {
+    endpoint: () => "https://t3.storage.dev",
+    region: "auto",
+    urlStyle: "vhost",
+    casWildcard: true,
+    batchDelete: true
+  },
+  minio: {
+    endpoint: () => missingEndpoint("minio"),
+    region: "us-east-1",
+    urlStyle: "path",
+    casWildcard: false,
+    batchDelete: true
+  },
+  gcs: {
+    endpoint: () => "https://storage.googleapis.com",
+    region: "auto",
+    urlStyle: "path",
+    casWildcard: true,
+    batchDelete: false
+  }
+};
+var GENERIC_PRESET = {
+  endpoint: () => {
+    throw new Error(`store.endpoint is required when store.provider is not set. Either name a provider ("aws" | "r2" | "tigris" | "minio" | "gcs") so the endpoint can be derived, or pass the endpoint URL explicitly.`);
+  },
+  region: "auto",
+  urlStyle: "path",
+  casWildcard: true,
+  batchDelete: true
+};
+function isRetryable(status) {
+  if (status === null)
+    return true;
+  if (status === 412 || status === 409)
+    return false;
+  if (status === 429)
+    return true;
+  return status >= 500;
+}
+function retryDelayMs(attempt, response) {
+  const retryAfter = response?.headers.get("retry-after");
+  if (retryAfter) {
+    const seconds = Number(retryAfter);
+    if (Number.isFinite(seconds) && seconds >= 0) {
+      return Math.min(seconds * 1000, MAX_RETRY_AFTER_MS);
+    }
+  }
+  return Math.random() * RETRY_BASE_MS2 * 2 ** attempt;
+}
+var CONTENTS_RE = /<Contents>([\s\S]*?)<\/Contents>/g;
+var KEY_RE = /<Key>([\s\S]*?)<\/Key>/;
+var SIZE_RE = /<Size>\s*(\d+)\s*<\/Size>/;
+var TRUNCATED_RE = /<IsTruncated>\s*true\s*<\/IsTruncated>/i;
+var NEXT_TOKEN_RE = /<NextContinuationToken>([\s\S]*?)<\/NextContinuationToken>/;
+var DELETE_ERROR_RE = /<Error>([\s\S]*?)<\/Error>/g;
+var CODE_RE = /<Code>([\s\S]*?)<\/Code>/;
+var MESSAGE_RE = /<Message>([\s\S]*?)<\/Message>/;
+function xmlUnescape(value) {
+  return value.replace(/&(#x?[0-9a-fA-F]+|amp|lt|gt|quot|apos);/g, (entity, name) => {
+    switch (name) {
+      case "amp":
+        return "&";
+      case "lt":
+        return "<";
+      case "gt":
+        return ">";
+      case "quot":
+        return '"';
+      case "apos":
+        return "'";
+      default: {
+        const code = name.startsWith("#x") ? Number.parseInt(name.slice(2), 16) : Number.parseInt(name.slice(1), 10);
+        return Number.isFinite(code) ? String.fromCodePoint(code) : entity;
+      }
+    }
+  });
+}
+function xmlEscape(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+var crcTable;
+function crc32(bytes) {
+  if (!crcTable) {
+    crcTable = new Uint32Array(256);
+    for (let i = 0;i < 256; i++) {
+      let value = i;
+      for (let bit = 0;bit < 8; bit++) {
+        value = value & 1 ? 3988292384 ^ value >>> 1 : value >>> 1;
+      }
+      crcTable[i] = value >>> 0;
+    }
+  }
+  let crc = 4294967295;
+  for (const byte of bytes)
+    crc = crcTable[(crc ^ byte) & 255] ^ crc >>> 8;
+  return (crc ^ 4294967295) >>> 0;
+}
+function base64Crc32(bytes) {
+  const crc = crc32(bytes);
+  return btoa(String.fromCharCode(crc >>> 24 & 255, crc >>> 16 & 255, crc >>> 8 & 255, crc & 255));
+}
+function searchString(query) {
+  return [...query].map(([key, value]) => [percentEncode(key), percentEncode(value)]).sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0).map(([key, value]) => value === "" ? key : `${key}=${value}`).join("&");
+}
+function createS3Driver(config) {
+  const preset = config.provider ? PROVIDER_PRESETS[config.provider] : GENERIC_PRESET;
+  const providerName = config.provider ?? "custom";
+  const region = config.region ?? preset.region;
+  const urlStyle = config.urlStyle ?? preset.urlStyle;
+  const endpoint = parseEndpoint(config.endpoint ?? preset.endpoint(config));
+  const bucket = config.bucket;
+  const credentials = config.credentials;
+  const doFetch = config.fetch ?? globalThis.fetch;
+  const now = config.now ?? (() => new Date);
+  const sleep = config.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const caps = { casWildcard: preset.casWildcard };
+  const prefixRoot = (config.prefix ?? "").replace(/^\/+|\/+$/g, "");
+  function toStoreKey(key) {
+    const trimmed = key.replace(/^\/+/, "");
+    return prefixRoot ? `${prefixRoot}/${trimmed}` : trimmed;
+  }
+  function fromStoreKey(key) {
+    if (!prefixRoot)
+      return key;
+    return key.startsWith(`${prefixRoot}/`) ? key.slice(prefixRoot.length + 1) : key;
+  }
+  function buildUrl(key, query = []) {
+    const host = urlStyle === "vhost" ? `${bucket}.${endpoint.host}` : endpoint.host;
+    let path = endpoint.basePath;
+    if (urlStyle === "path")
+      path += `/${encodeUriPath(bucket)}`;
+    if (key !== null)
+      path += `/${encodeUriPath(toStoreKey(key))}`;
+    const url = new URL(`${endpoint.protocol}//${host}${path || "/"}`);
+    if (query.length > 0)
+      url.search = searchString(query);
+    return url;
+  }
+  async function send(spec) {
+    let lastError;
+    for (let attempt = 0;; attempt++) {
+      let response;
+      try {
+        const headers = await signRequest({
+          method: spec.method,
+          url: spec.url,
+          headers: spec.headers ?? {},
+          body: spec.body,
+          region,
+          service: "s3",
+          credentials,
+          now: now()
+        });
+        response = await doFetch(spec.url.toString(), {
+          method: spec.method,
+          headers,
+          body: spec.body
+        });
+      } catch (error) {
+        lastError = error;
+        if (attempt >= MAX_RETRIES) {
+          throw new Error(`S3 ${spec.method} ${spec.url.pathname} failed after ${attempt + 1} attempts: ${String(error)}`, { cause: lastError });
+        }
+        await sleep(retryDelayMs(attempt, null));
+        continue;
+      }
+      if (response.ok || !isRetryable(response.status) || attempt >= MAX_RETRIES)
+        return response;
+      await response.text().catch(() => "");
+      await sleep(retryDelayMs(attempt, response));
+    }
+  }
+  async function failure(operation, subject, response) {
+    const body = await response.text().catch(() => "");
+    const detail = body.trim().slice(0, 512);
+    return new Error(`S3 ${operation} failed for "${subject}": ${response.status} ${response.statusText}${detail ? ` — ${detail}` : ""}`);
+  }
+  async function deleteBatch(keys) {
+    const xml = `<?xml version="1.0" encoding="UTF-8"?><Delete><Quiet>true</Quiet>${keys.map((key) => `<Object><Key>${xmlEscape(toStoreKey(key))}</Key></Object>`).join("")}</Delete>`;
+    const body = textEncoder2.encode(xml);
+    const response = await send({
+      method: "POST",
+      url: buildUrl(null, [["delete", ""]]),
+      headers: {
+        "content-type": "application/xml",
+        "x-amz-sdk-checksum-algorithm": "CRC32",
+        "x-amz-checksum-crc32": base64Crc32(body)
+      },
+      body
+    });
+    if (!response.ok)
+      throw await failure("DELETE (batch)", keys[0] ?? "", response);
+    const text = await response.text();
+    const failures = [...text.matchAll(DELETE_ERROR_RE)].map((match) => {
+      const block = match[1] ?? "";
+      const key = xmlUnescape(KEY_RE.exec(block)?.[1] ?? "?");
+      const code = CODE_RE.exec(block)?.[1] ?? "Unknown";
+      const message = MESSAGE_RE.exec(block)?.[1] ?? "";
+      return `${key}: ${code}${message ? ` (${message})` : ""}`;
+    });
+    if (failures.length > 0) {
+      throw new Error(`S3 batch delete reported ${failures.length} failure(s) — ${failures.join("; ")}`);
+    }
+  }
+  async function deleteIndividually(keys) {
+    for (let i = 0;i < keys.length; i += DELETE_CONCURRENCY) {
+      const window = keys.slice(i, i + DELETE_CONCURRENCY);
+      await Promise.all(window.map(async (key) => {
+        const response = await send({ method: "DELETE", url: buildUrl(key) });
+        if (response.ok || response.status === 404) {
+          await response.text().catch(() => "");
+          return;
+        }
+        throw await failure("DELETE", key, response);
+      }));
+    }
+  }
+  return {
+    caps,
+    async get(key) {
+      const response = await send({ method: "GET", url: buildUrl(key) });
+      if (response.status === 404) {
+        await response.text().catch(() => "");
+        return null;
+      }
+      if (!response.ok)
+        throw await failure("GET", key, response);
+      const etag = response.headers.get("etag");
+      if (!etag) {
+        throw new Error(`S3 GET of "${key}" returned no ETag header. The etag is the CAS token for every later conditional write, so continuing without one would turn a lost race into a silent overwrite.`);
+      }
+      return { body: new Uint8Array(await response.arrayBuffer()), etag };
+    },
+    async put(key, body, opts) {
+      if (opts?.ifNoneMatch === "*" && !caps.casWildcard) {
+        throw new Error(`Provider "${providerName}" does not support create-if-absent (If-None-Match: *); it requires an exact etag. Seed "_lease" and "_manifest" once with init() as a deploy step — not from N racing servers — after which every write is a plain ifMatch, which this store handles fine. See docs/object-storage.md, "The MinIO gotcha".`);
+      }
+      const headers = {};
+      if (opts?.ifMatch)
+        headers["if-match"] = opts.ifMatch;
+      if (opts?.ifNoneMatch)
+        headers["if-none-match"] = opts.ifNoneMatch;
+      const response = await send({ method: "PUT", url: buildUrl(key), headers, body });
+      if (response.status === 412 || response.status === 409) {
+        await response.text().catch(() => "");
+        throw new PreconditionFailedError(key);
+      }
+      if (!response.ok)
+        throw await failure("PUT", key, response);
+      const etag = response.headers.get("etag");
+      if (!etag) {
+        throw new Error(`S3 PUT of "${key}" returned no ETag header, so the next conditional write has nothing to CAS against.`);
+      }
+      await response.text().catch(() => "");
+      return etag;
+    },
+    async list(prefix) {
+      const fullPrefix = prefixRoot ? prefix ? `${prefixRoot}/${prefix.replace(/^\/+/, "")}` : `${prefixRoot}/` : prefix.replace(/^\/+/, "");
+      const entries = [];
+      let continuationToken;
+      do {
+        const query = [["list-type", "2"]];
+        if (fullPrefix)
+          query.push(["prefix", fullPrefix]);
+        if (continuationToken)
+          query.push(["continuation-token", continuationToken]);
+        const response = await send({ method: "GET", url: buildUrl(null, query) });
+        if (!response.ok)
+          throw await failure("LIST", fullPrefix, response);
+        const xml = await response.text();
+        for (const match of xml.matchAll(CONTENTS_RE)) {
+          const block = match[1] ?? "";
+          const rawKey = KEY_RE.exec(block)?.[1];
+          if (rawKey === undefined)
+            continue;
+          entries.push({
+            key: fromStoreKey(xmlUnescape(rawKey)),
+            size: Number(SIZE_RE.exec(block)?.[1] ?? 0)
+          });
+        }
+        if (TRUNCATED_RE.test(xml)) {
+          continuationToken = xmlUnescape(NEXT_TOKEN_RE.exec(xml)?.[1] ?? "");
+          if (!continuationToken) {
+            throw new Error(`S3 LIST of "${fullPrefix}" reported IsTruncated with no NextContinuationToken; refusing to loop on a malformed response.`);
+          }
+        } else {
+          continuationToken = undefined;
+        }
+      } while (continuationToken);
+      entries.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+      return entries;
+    },
+    async delete(keys) {
+      if (keys.length === 0)
+        return;
+      if (!preset.batchDelete)
+        return deleteIndividually(keys);
+      for (let i = 0;i < keys.length; i += MAX_KEYS_PER_DELETE) {
+        await deleteBatch(keys.slice(i, i + MAX_KEYS_PER_DELETE));
+      }
+    }
+  };
+}
+function parseEndpoint(raw) {
+  const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(raw) ? raw : `https://${raw}`;
+  let url;
+  try {
+    url = new URL(withScheme);
+  } catch {
+    throw new Error(`store.endpoint is not a valid URL: ${JSON.stringify(raw)}`);
+  }
+  return {
+    protocol: url.protocol,
+    host: url.host,
+    basePath: url.pathname.replace(/\/+$/, "")
+  };
+}
+
+// src/server/storage/object/drivers/memory.ts
+function compareKeys(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function createMemoryDriver(options = {}) {
+  const casWildcard = options.casWildcard ?? true;
+  const store = new Map;
+  let etagCounter = 0;
+  let calls = 0;
+  const stats = { get: 0, put: 0, list: 0, delete: 0 };
+  async function enter(op, key) {
+    calls += 1;
+    stats[op] += 1;
+    const fault = options.faults?.before?.({ op, key, call: calls });
+    if (!fault)
+      return;
+    if ("delayMs" in fault && fault.delayMs > 0)
+      await delay(fault.delayMs);
+    if ("throw" in fault)
+      throw fault.throw;
+  }
+  return {
+    caps: { casWildcard },
+    stats,
+    dump() {
+      const out = new Map;
+      const sorted = [...store].sort((a, b) => compareKeys(a[0], b[0]));
+      for (const [key, record] of sorted)
+        out.set(key, new Uint8Array(record.body));
+      return out;
+    },
+    async get(key) {
+      await enter("get", key);
+      const record = store.get(key);
+      if (!record)
+        return null;
+      return { body: new Uint8Array(record.body), etag: record.etag };
+    },
+    async put(key, body, opts) {
+      await enter("put", key);
+      const wantsIfMatch = opts?.ifMatch !== undefined;
+      const wantsIfNoneMatch = opts?.ifNoneMatch !== undefined;
+      if (wantsIfMatch && wantsIfNoneMatch) {
+        throw new Error(`put("${key}") passed both ifMatch and ifNoneMatch. A conditional write is either create-if-absent or overwrite-if-unchanged, never both.`);
+      }
+      if (wantsIfNoneMatch) {
+        if (!casWildcard) {
+          throw new Error(`put("${key}") used ifNoneMatch: "*", but this driver reports caps.casWildcard === false. Stores without wildcard CAS (MinIO) need a one-time init() that seeds _lease and _manifest unconditionally; every later write is a plain ifMatch.`);
+        }
+        if (store.has(key)) {
+          throw new PreconditionFailedError(key, `Conditional write failed for "${key}": ifNoneMatch: "*" but the key already exists`);
+        }
+      }
+      if (wantsIfMatch) {
+        const current = store.get(key);
+        if (!current || current.etag !== opts?.ifMatch) {
+          throw new PreconditionFailedError(key, `Conditional write failed for "${key}": ifMatch ${opts?.ifMatch} but stored etag is ${current ? current.etag : "(absent)"}`);
+        }
+      }
+      etagCounter += 1;
+      const etag = `"${etagCounter}"`;
+      store.set(key, { body: new Uint8Array(body), etag });
+      return etag;
+    },
+    async list(prefix) {
+      await enter("list", prefix);
+      const entries = [];
+      for (const [key, record] of store) {
+        if (key.startsWith(prefix))
+          entries.push({ key, size: record.body.byteLength });
+      }
+      entries.sort((a, b) => compareKeys(a.key, b.key));
+      return entries;
+    },
+    async delete(keys) {
+      await enter("delete", keys.join(","));
+      for (const key of keys)
+        store.delete(key);
+    }
+  };
+}
+// src/server/node-require.ts
+var cached;
+function nodeRequire(id) {
+  if (!cached) {
+    const proc = globalThis.process;
+    const mod = proc?.getBuiltinModule?.("node:module");
+    if (!mod?.createRequire) {
+      throw new Error(`Cannot resolve "${id}": this runtime has no CommonJS resolver (process.getBuiltinModule is unavailable). reflectdb requires Node >= 22.3 or Bun >= 1.1.30 on the server.`);
+    }
+    cached = mod.createRequire(module.filename);
+  }
+  return cached(id);
+}
+
+// src/server/storage/object/drivers/filesystem.ts
+function loadFs() {
+  try {
+    return nodeRequire("node:fs");
+  } catch {
+    throw new Error("createFilesystemDriver requires a Node-compatible runtime (node:fs is unavailable). Use createMemoryDriver where there is no filesystem.");
+  }
+}
+var TEMP_PREFIX = ".reflectdb-tmp-";
+function isNotFound(error) {
+  const code = error?.code;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+function contentEtag(bytes) {
+  let h0 = 8997;
+  let h1 = 33826;
+  let h2 = 40164;
+  let h3 = 52210;
+  for (const byte of bytes) {
+    h0 ^= byte;
+    const t0 = h0 * 435;
+    const t1 = h1 * 435 + (t0 >>> 16);
+    const t2 = h2 * 435 + h0 * 256 + (t1 >>> 16);
+    const t3 = h3 * 435 + h1 * 256 + (t2 >>> 16);
+    h0 = t0 & 65535;
+    h1 = t1 & 65535;
+    h2 = t2 & 65535;
+    h3 = t3 & 65535;
+  }
+  const limb = (value) => value.toString(16).padStart(4, "0");
+  return `"${limb(h3)}${limb(h2)}${limb(h1)}${limb(h0)}"`;
+}
+function compareKeys2(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function rejectKey(key, reason) {
+  throw new Error(`Invalid object key ${JSON.stringify(key)}: ${reason}. Keys are store-relative paths; the filesystem driver maps them under its root and refuses anything that could escape it.`);
+}
+function checkSegments(key, segments, allowEmpty) {
+  for (const segment of segments) {
+    if (segment === "" && !allowEmpty)
+      rejectKey(key, "it contains an empty path segment");
+    if (segment === "." || segment === "..") {
+      rejectKey(key, `it contains a "${segment}" segment, which escapes or re-roots the path`);
+    }
+    if (segment.includes("\\"))
+      rejectKey(key, "it contains a backslash");
+  }
+}
+function resolveKeyPath(root, key) {
+  if (key === "")
+    rejectKey(key, "it is empty");
+  if (key.startsWith("/"))
+    rejectKey(key, "it is an absolute path");
+  if (/^[a-zA-Z]:/.test(key))
+    rejectKey(key, "it starts with a drive letter");
+  checkSegments(key, key.split("/"), false);
+  return `${root}/${key}`;
+}
+function dirnameOf(path) {
+  return path.slice(0, path.lastIndexOf("/"));
+}
+function walk(fs, dir, base, out) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch (error) {
+    if (isNotFound(error))
+      return;
+    throw error;
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith(TEMP_PREFIX))
+      continue;
+    const path = `${dir}/${entry.name}`;
+    const key = base === "" ? entry.name : `${base}/${entry.name}`;
+    if (entry.isDirectory()) {
+      walk(fs, path, key, out);
+    } else if (entry.isFile()) {
+      out.push({ key, size: fs.statSync(path).size });
+    }
+  }
+}
+function createFilesystemDriver(rootDir) {
+  const fs = loadFs();
+  const root = rootDir.replace(/[/\\]+$/, "");
+  if (root === "") {
+    throw new Error("createFilesystemDriver requires a non-empty rootDir. Refusing to treat the filesystem root as an object store.");
+  }
+  fs.mkdirSync(root, { recursive: true });
+  let tempCounter = 0;
+  function readEtag(path) {
+    try {
+      return contentEtag(fs.readFileSync(path));
+    } catch (error) {
+      if (isNotFound(error))
+        return null;
+      throw error;
+    }
+  }
+  return {
+    caps: { casWildcard: true },
+    async get(key) {
+      const path = resolveKeyPath(root, key);
+      let body;
+      try {
+        body = fs.readFileSync(path);
+      } catch (error) {
+        if (isNotFound(error) || error?.code === "EISDIR")
+          return null;
+        throw error;
+      }
+      return {
+        body: new Uint8Array(body.buffer, body.byteOffset, body.byteLength),
+        etag: contentEtag(body)
+      };
+    },
+    async put(key, body, opts) {
+      const path = resolveKeyPath(root, key);
+      const wantsIfMatch = opts?.ifMatch !== undefined;
+      const wantsIfNoneMatch = opts?.ifNoneMatch !== undefined;
+      if (wantsIfMatch && wantsIfNoneMatch) {
+        throw new Error(`put("${key}") passed both ifMatch and ifNoneMatch. A conditional write is either create-if-absent or overwrite-if-unchanged, never both.`);
+      }
+      if (wantsIfNoneMatch && fs.existsSync(path)) {
+        throw new PreconditionFailedError(key, `Conditional write failed for "${key}": ifNoneMatch: "*" but the key already exists`);
+      }
+      if (wantsIfMatch) {
+        const current = readEtag(path);
+        if (current === null || current !== opts?.ifMatch) {
+          throw new PreconditionFailedError(key, `Conditional write failed for "${key}": ifMatch ${opts?.ifMatch} but stored etag is ${current ?? "(absent)"}`);
+        }
+      }
+      const dir = dirnameOf(path);
+      try {
+        fs.mkdirSync(dir, { recursive: true });
+      } catch (error) {
+        if (error?.code === "EEXIST") {
+          throw new Error(`Cannot write object "${key}": a prefix of that key already exists as an object. Object stores allow "a" and "a/b" to coexist; a filesystem cannot, so the filesystem driver rejects the collision instead of losing one of them. Use createMemoryDriver or a real bucket if you need a key that is also a prefix.`, { cause: error });
+        }
+        throw error;
+      }
+      tempCounter += 1;
+      const temp = `${dir}/${TEMP_PREFIX}${tempCounter}-${Math.random().toString(36).slice(2)}`;
+      try {
+        fs.writeFileSync(temp, body);
+        fs.renameSync(temp, path);
+      } catch (error) {
+        try {
+          fs.unlinkSync(temp);
+        } catch {}
+        throw error;
+      }
+      return contentEtag(body);
+    },
+    async list(prefix) {
+      if (prefix.startsWith("/"))
+        rejectKey(prefix, "it is an absolute path");
+      if (/^[a-zA-Z]:/.test(prefix))
+        rejectKey(prefix, "it starts with a drive letter");
+      checkSegments(prefix, prefix.split("/"), true);
+      const cut = prefix.lastIndexOf("/");
+      const base = cut === -1 ? "" : prefix.slice(0, cut);
+      const entries = [];
+      walk(fs, base === "" ? root : `${root}/${base}`, base, entries);
+      const matched = entries.filter((entry) => entry.key.startsWith(prefix));
+      matched.sort((a, b) => compareKeys2(a.key, b.key));
+      return matched;
+    },
+    async delete(keys) {
+      for (const key of keys) {
+        const path = resolveKeyPath(root, key);
+        try {
+          fs.unlinkSync(path);
+        } catch (error) {
+          if (isNotFound(error))
+            continue;
+          throw error;
+        }
+      }
+    }
+  };
+}
+
+// src/server/storage/object/index.ts
+function applyOverrides(target, overrides) {
+  if (!overrides)
+    return;
+  for (const [key, value] of Object.entries(overrides)) {
+    if (value !== undefined)
+      target[key] = value;
+  }
+}
+function resolveObjectStorageConfig(config) {
+  const batch = { ...OBJECT_STORAGE_DEFAULTS.batch };
+  applyOverrides(batch, config.batch);
+  const compaction = { ...OBJECT_STORAGE_DEFAULTS.compaction };
+  applyOverrides(compaction, config.compaction);
+  const lease = { ...OBJECT_STORAGE_DEFAULTS.lease };
+  applyOverrides(lease, config.lease);
+  const memory = { ...OBJECT_STORAGE_DEFAULTS.memory };
+  applyOverrides(memory, config.memory);
+  return {
+    roomId: config.roomId,
+    writerId: config.writerId ?? `writer-${crypto.randomUUID()}`,
+    durability: config.durability ?? OBJECT_STORAGE_DEFAULTS.durability,
+    concurrency: config.concurrency ?? OBJECT_STORAGE_DEFAULTS.concurrency,
+    retentionMs: config.retentionMs ?? OBJECT_STORAGE_DEFAULTS.retentionMs,
+    batch,
+    compaction,
+    lease,
+    memory,
+    shutdownFlushMs: config.shutdownFlushMs ?? OBJECT_STORAGE_DEFAULTS.shutdownFlushMs
+  };
+}
+function resolveDriver(config) {
+  if (config.driver && config.store) {
+    throw new Error("createObjectStorage: pass either `driver` or `store`, not both. `store` builds " + "the S3 driver for you; `driver` is for a pre-built or custom one.");
+  }
+  if (config.driver)
+    return config.driver;
+  if (config.store)
+    return createS3Driver(config.store);
+  throw new Error("createObjectStorage: one of `driver` or `store` is required — there is no " + "default object store to fall back to.");
+}
+function createObjectStorage(config, options = {}) {
+  const resolved = resolveObjectStorageConfig(config);
+  const driver = resolveDriver(config);
+  const clock = options.clock ?? systemClock;
+  const prefix = roomPrefix(resolved.roomId);
+  const state = new RoomState({ memory: resolved.memory, clock, budget: options.budget });
+  const manifest = new ManifestStore({
+    driver,
+    roomId: resolved.roomId,
+    writerId: resolved.writerId,
+    lease: resolved.lease,
+    concurrency: resolved.concurrency,
+    clock
+  });
+  const wal = new WalWriter({
+    driver,
+    manifest,
+    roomId: resolved.roomId,
+    batch: resolved.batch,
+    durability: resolved.durability,
+    concurrency: resolved.concurrency,
+    writerId: resolved.writerId,
+    clock,
+    onCommitted: () => maintain()
+  });
+  if (config.onDurable)
+    wal.onDurable(config.onDurable);
+  if (config.onHealthChange)
+    wal.onHealthChange(config.onHealthChange);
+  let snapshotSeq = 0;
+  let appliedSegments = new Set;
+  let appliedSnapshotKey = null;
+  let closed = false;
+  let closing = null;
+  let bootPromise = null;
+  function isOwnSegment(key) {
+    return resolved.concurrency === "optimistic" && key.startsWith(`${prefix}wal/${resolved.writerId}-`);
+  }
+  async function applySegment(key) {
+    const object = await driver.get(key);
+    if (!object) {
+      throw new Error(`Object storage: WAL segment "${key}" named by the manifest for room ` + `"${resolved.roomId}" is missing. Refusing to serve a truncated log.`);
+    }
+    state.applyRecords(decodeSegment(object.body, key));
+  }
+  async function boot() {
+    await manifest.init();
+    const record = await manifest.load();
+    state.loadMeta(record.meta);
+    if (record.snapshotKey) {
+      const object = await driver.get(record.snapshotKey);
+      if (!object) {
+        throw new IncompleteStateError(resolved.roomId, record.snapshotKey, "Refusing to boot with incomplete state.");
+      }
+      state.loadSnapshot(decodeJson(object.body, record.snapshotKey));
+      appliedSnapshotKey = record.snapshotKey;
+    }
+    for (const segment of record.walSegs)
+      await applySegment(segment.key);
+    appliedSegments = new Set(record.walSegs.map((segment) => segment.key));
+    await manifest.start();
+  }
+  function ready() {
+    if (!bootPromise) {
+      bootPromise = boot().catch((error) => {
+        bootPromise = null;
+        throw error;
+      });
+    }
+    return bootPromise;
+  }
+  function assertOpen() {
+    if (closed) {
+      throw new Error(`Object storage: room "${resolved.roomId}" is closed and no longer accepts writes.`);
+    }
+  }
+  function submit(record, mutate) {
+    const prepared = wal.prepare(record);
+    mutate();
+    return wal.append(prepared);
+  }
+  function persistReservations(opIds) {
+    try {
+      wal.append(wal.prepare({ k: "reserve", opIds, at: clock.now() })).catch(() => {
+        return;
+      });
+    } catch {}
+  }
+  async function maintain() {
+    await compactIfDue();
+    await collectGarbage();
+  }
+  async function compactIfDue() {
+    const current = manifest.manifest;
+    let bytes = 0;
+    for (const segment of current.walSegs)
+      bytes += segment.bytes;
+    if (current.walSegs.length < resolved.compaction.afterSegments && bytes < resolved.compaction.afterBytes) {
+      return;
+    }
+    const snapshot = state.toSnapshot();
+    const token = resolved.concurrency === "optimistic" ? resolved.writerId : String(manifest.epoch);
+    const key = `${prefix}snap/${token}-${snapshotSeq++}.json`;
+    await driver.put(key, encodeJson(snapshot));
+    const deletableAt = clock.now() + resolved.compaction.gcGraceMs;
+    const committed = await manifest.commit((next) => {
+      for (const segment of next.walSegs)
+        next.pendingGc.push({ key: segment.key, deletableAt });
+      if (next.snapshotKey)
+        next.pendingGc.push({ key: next.snapshotKey, deletableAt });
+      next.walSegs = [];
+      next.snapshotKey = key;
+      next.snapshotHlc = snapshot.hlc;
+      const cutoff = snapshot.hlc;
+      if (cutoff && (!next.meta.compactionCutoff || cutoff > next.meta.compactionCutoff)) {
+        next.meta.compactionCutoff = cutoff;
+      }
+    });
+    const committedCutoff = committed.meta.compactionCutoff;
+    if (committedCutoff)
+      state.setMeta("compactionCutoff", committedCutoff);
+    appliedSegments = new Set;
+    appliedSnapshotKey = key;
+  }
+  async function collectGarbage() {
+    const now = clock.now();
+    const due = manifest.manifest.pendingGc.filter((entry) => entry.deletableAt <= now);
+    if (due.length === 0)
+      return;
+    const live = new Set;
+    if (manifest.manifest.snapshotKey)
+      live.add(manifest.manifest.snapshotKey);
+    for (const segment of manifest.manifest.walSegs)
+      live.add(segment.key);
+    const deletable = due.filter((entry) => !live.has(entry.key));
+    if (deletable.length > 0)
+      await driver.delete(deletable.map((entry) => entry.key));
+    await manifest.commit((next) => {
+      next.pendingGc = next.pendingGc.filter((entry) => entry.deletableAt > now);
+    });
+  }
+  const adapter = {
+    async init() {
+      await ready();
+    },
+    async getRow(table, rowId) {
+      await ready();
+      return state.getRow(table, rowId);
+    },
+    async getRowsByIds(table, rowIds) {
+      await ready();
+      if (rowIds.length === 0)
+        return {};
+      return state.getRowsByIds(table, rowIds);
+    },
+    async putRow(table, rowId, row, colClocks, hlc) {
+      await ready();
+      assertOpen();
+      const mutation = { table, rowId, row, colClocks, hlc };
+      await submit({ k: "row", row: mutation }, () => state.putRow(table, rowId, row, colClocks, hlc));
+    },
+    async getRows(table, filter) {
+      await ready();
+      return state.getRows(table, filter);
+    },
+    async appendOp(entry) {
+      await ready();
+      assertOpen();
+      await submit({ k: "op", op: entry }, () => state.appendOp(entry));
+    },
+    async applyOp(table, rowId, row, colClocks, hlc, opType, payload) {
+      await ready();
+      assertOpen();
+      const mutation = { table, rowId, row, colClocks, hlc };
+      const op = { table, op: opType, rowId, payload, hlc, colClocks };
+      state.assertCanAdmitApply(mutation, op);
+      await submit({ k: "apply", row: mutation, op }, () => {
+        state.putRow(table, rowId, row, colClocks, hlc);
+        state.appendOp(op);
+      });
+    },
+    async getOpsSince(since, tables) {
+      await ready();
+      return state.getOpsSince(since, tables);
+    },
+    async getChangedTablesSince(since, tables) {
+      await ready();
+      return state.getChangedTablesSince(since, tables);
+    },
+    async getOplogHead(tables) {
+      await ready();
+      return state.getOplogHead(tables);
+    },
+    async deleteOpsBefore(hlc) {
+      await ready();
+      return state.deleteOpsBefore(hlc);
+    },
+    async reserveOp(opId) {
+      await ready();
+      const fresh = state.reserveOp(opId);
+      if (fresh)
+        persistReservations([opId]);
+      return fresh;
+    },
+    async reserveOps(opIds) {
+      await ready();
+      const fresh = state.reserveOps(opIds);
+      if (fresh.length > 0)
+        persistReservations(fresh);
+      return fresh;
+    },
+    async getMeta(key) {
+      await ready();
+      return state.getMeta(key);
+    },
+    async refresh() {
+      if (resolved.concurrency !== "optimistic")
+        return false;
+      await ready();
+      const next = await manifest.refresh();
+      if (next.snapshotKey && next.snapshotKey !== appliedSnapshotKey) {
+        const object = await driver.get(next.snapshotKey);
+        if (!object) {
+          throw new IncompleteStateError(resolved.roomId, next.snapshotKey, "Refusing to serve incomplete state.");
+        }
+        state.loadSnapshot(decodeJson(object.body, next.snapshotKey));
+        state.loadMeta(next.meta);
+        appliedSnapshotKey = next.snapshotKey;
+        appliedSegments = new Set;
+        for (const segment of next.walSegs) {
+          await applySegment(segment.key);
+          appliedSegments.add(segment.key);
+        }
+        return true;
+      }
+      let applied = false;
+      for (const segment of next.walSegs) {
+        if (appliedSegments.has(segment.key) || isOwnSegment(segment.key))
+          continue;
+        await applySegment(segment.key);
+        appliedSegments.add(segment.key);
+        applied = true;
+      }
+      if (applied)
+        state.loadMeta(next.meta);
+      return applied;
+    },
+    async setMeta(key, value) {
+      await ready();
+      assertOpen();
+      state.setMeta(key, value);
+      await manifest.commit((next) => {
+        next.meta[key] = value;
+      });
+    },
+    get health() {
+      return wal.health;
+    },
+    get durableHlc() {
+      return wal.durableHlc;
+    },
+    onDurable(callback) {
+      wal.onDurable(callback);
+    },
+    onHealthChange(callback) {
+      wal.onHealthChange(callback);
+    },
+    async flush() {
+      await ready();
+      await wal.flush();
+    },
+    close() {
+      if (closing)
+        return closing;
+      closed = true;
+      closing = (async () => {
+        const outcome = await Promise.race([
+          wal.flush().then(() => null, (error) => ({ error })),
+          clock.delay(resolved.shutdownFlushMs).then(() => "timeout")
+        ]);
+        if (outcome === "timeout") {
+          console.warn(`[reflectdb] object storage: room "${resolved.roomId}" did not finish ` + `flushing within shutdownFlushMs (${resolved.shutdownFlushMs}ms); ` + `buffered writes were not made durable.`);
+        } else if (outcome) {
+          console.warn(`[reflectdb] object storage: the final drain for room "${resolved.roomId}" ` + `failed; buffered writes were not made durable:`, outcome.error);
+        }
+        await wal.stop(resolved.shutdownFlushMs);
+        manifest.stop();
+        try {
+          await Promise.race([
+            manifest.release(),
+            clock.delay(resolved.shutdownFlushMs).then(() => {
+              console.warn(`[reflectdb] object storage: releasing the lease for room ` + `"${resolved.roomId}" timed out; the next writer will wait out ` + `lease.ttlMs (${resolved.lease.ttlMs}ms) instead.`);
+            })
+          ]);
+        } catch (error) {
+          console.warn("[reflectdb] object storage: releasing the lease failed:", error);
+        }
+        state.dispose();
+        try {
+          await driver.close?.();
+        } catch (error) {
+          console.warn("[reflectdb] object storage: closing the driver failed:", error);
+        }
+      })();
+      return closing;
+    }
+  };
+  return adapter;
+}