tablinum 0.6.4 → 0.8.0

package/dist/index.js

@@ -224,6 +224,257 @@ function resolveRuntimeConfig(source) {
   );
 }
 
+// src/storage/idb.ts
+import { Effect as Effect2 } from "effect";
+import { openDB, deleteDB } from "idb";
+
+// src/sync/compact-event.ts
+import { bytesToHex as bytesToHex2, hexToBytes as hexToBytes2 } from "@noble/hashes/utils.js";
+var VERSION = 1;
+var HEADER_SIZE = 133;
+function base64ToBytes(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function bytesToBase64(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function packEvent(event) {
+  const pubkey = hexToBytes2(event.pubkey);
+  const sig = hexToBytes2(event.sig);
+  const recipientTag = event.tags.find((t) => t[0] === "p");
+  if (!recipientTag) throw new Error("Gift wrap missing #p tag");
+  if (event.tags.some((t) => t[0] !== "p")) {
+    throw new Error("Gift wrap has unexpected non-p tags; compact encoding would lose them");
+  }
+  const recipient = hexToBytes2(recipientTag[1]);
+  const createdAtBuf = new Uint8Array(4);
+  new DataView(createdAtBuf.buffer).setUint32(0, event.created_at, false);
+  const content = base64ToBytes(event.content);
+  const result = new Uint8Array(HEADER_SIZE + content.length);
+  result[0] = VERSION;
+  result.set(pubkey, 1);
+  result.set(sig, 33);
+  result.set(recipient, 97);
+  result.set(createdAtBuf, 129);
+  result.set(content, HEADER_SIZE);
+  return result;
+}
+function unpackEvent(id, compact) {
+  const version = compact[0];
+  if (version !== VERSION) throw new Error(`Unknown compact event version: ${version}`);
+  const pubkey = bytesToHex2(compact.slice(1, 33));
+  const sig = bytesToHex2(compact.slice(33, 97));
+  const recipient = bytesToHex2(compact.slice(97, 129));
+  const dv = new DataView(compact.buffer, compact.byteOffset + 129, 4);
+  const createdAt = dv.getUint32(0, false);
+  const content = bytesToBase64(compact.slice(HEADER_SIZE));
+  return {
+    id,
+    pubkey,
+    sig,
+    created_at: createdAt,
+    kind: 1059,
+    tags: [["p", recipient]],
+    content
+  };
+}
+
+// src/storage/idb.ts
+var DB_NAME = "tablinum";
+function storeName(collection2) {
+  return `col_${collection2}`;
+}
+function computeSchemaSig(schema) {
+  return Object.entries(schema).sort(([a], [b]) => a.localeCompare(b)).map(([name, def]) => {
+    const indices = [...def.indices ?? []].sort().join(",");
+    return `${name}:${indices}`;
+  }).join("|");
+}
+function wrap(label, fn) {
+  return Effect2.tryPromise({
+    try: fn,
+    catch: (e) => new StorageError({
+      message: `IndexedDB ${label} failed: ${e instanceof Error ? e.message : String(e)}`,
+      cause: e
+    })
+  });
+}
+function upgradeSchema(database, schema, tx) {
+  if (!database.objectStoreNames.contains("_meta")) {
+    database.createObjectStore("_meta");
+  }
+  if (!database.objectStoreNames.contains("events")) {
+    const events = database.createObjectStore("events", { keyPath: "id" });
+    events.createIndex("by-record", ["collection", "recordId"]);
+  }
+  if (!database.objectStoreNames.contains("giftwraps")) {
+    database.createObjectStore("giftwraps", { keyPath: "id" });
+  }
+  const expectedStores = /* @__PURE__ */ new Set();
+  for (const [, def] of Object.entries(schema)) {
+    const sn = storeName(def.name);
+    expectedStores.add(sn);
+    if (!database.objectStoreNames.contains(sn)) {
+      const store = database.createObjectStore(sn, { keyPath: "id" });
+      for (const idx of def.indices ?? []) {
+        store.createIndex(idx, idx);
+      }
+    } else {
+      const store = tx.objectStore(sn);
+      const existingIndices = new Set(Array.from(store.indexNames));
+      const wantedIndices = new Set(def.indices ?? []);
+      for (const idx of existingIndices) {
+        if (!wantedIndices.has(idx)) store.deleteIndex(idx);
+      }
+      for (const idx of wantedIndices) {
+        if (!existingIndices.has(idx)) store.createIndex(idx, idx);
+      }
+    }
+  }
+  for (const existing of Array.from(database.objectStoreNames)) {
+    if (existing.startsWith("col_") && !expectedStores.has(existing)) {
+      database.deleteObjectStore(existing);
+    }
+  }
+  tx.objectStore("_meta").put(computeSchemaSig(schema), "schema_sig");
+}
+function deleteIDBStorage(dbName) {
+  if (typeof indexedDB === "undefined") {
+    return Effect2.fail(
+      new StorageError({
+        message: "IndexedDB is not available in this environment"
+      })
+    );
+  }
+  return wrap("deleteDatabase", () => deleteDB(dbName));
+}
+function openIDBStorage(dbName, schema) {
+  return Effect2.gen(function* () {
+    const name = dbName ?? DB_NAME;
+    const schemaSig = computeSchemaSig(schema);
+    if (typeof indexedDB === "undefined") {
+      return yield* Effect2.fail(
+        new StorageError({
+          message: "IndexedDB is not available in this environment"
+        })
+      );
+    }
+    const probeDb = yield* Effect2.tryPromise({
+      try: () => openDB(name),
+      catch: (e) => new StorageError({ message: "Failed to open IndexedDB", cause: e })
+    });
+    const currentVersion = probeDb.version;
+    let needsUpgrade = true;
+    if (probeDb.objectStoreNames.contains("_meta")) {
+      const storedSig = yield* Effect2.tryPromise({
+        try: () => probeDb.get("_meta", "schema_sig"),
+        catch: () => new StorageError({ message: "Failed to read schema meta" })
+      }).pipe(Effect2.catch(() => Effect2.succeed(void 0)));
+      needsUpgrade = storedSig !== schemaSig;
+    }
+    probeDb.close();
+    const db = needsUpgrade ? yield* Effect2.tryPromise({
+      try: () => openDB(name, currentVersion + 1, {
+        upgrade(database, _oldVersion, _newVersion, transaction) {
+          upgradeSchema(database, schema, transaction);
+        }
+      }),
+      catch: (e) => new StorageError({ message: "Failed to open IndexedDB", cause: e })
+    }) : yield* Effect2.tryPromise({
+      try: () => openDB(name),
+      catch: (e) => new StorageError({ message: "Failed to open IndexedDB", cause: e })
+    });
+    yield* Effect2.addFinalizer(() => Effect2.sync(() => db.close()));
+    const handle = {
+      putRecord: (collection2, record) => wrap("putRecord", () => db.put(storeName(collection2), record).then(() => void 0)),
+      getRecord: (collection2, id) => wrap("getRecord", () => db.get(storeName(collection2), id)),
+      getAllRecords: (collection2) => wrap("getAllRecords", () => db.getAll(storeName(collection2))),
+      countRecords: (collection2) => wrap("countRecords", () => db.count(storeName(collection2))),
+      clearRecords: (collection2) => wrap("clearRecords", () => db.clear(storeName(collection2))),
+      getByIndex: (collection2, indexName, value) => wrap("getByIndex", () => db.getAllFromIndex(storeName(collection2), indexName, value)),
+      getByIndexRange: (collection2, indexName, range) => wrap("getByIndexRange", () => db.getAllFromIndex(storeName(collection2), indexName, range)),
+      getAllSorted: (collection2, indexName, direction) => wrap("getAllSorted", async () => {
+        const sn = storeName(collection2);
+        const tx = db.transaction(sn, "readonly");
+        const store = tx.objectStore(sn);
+        const index = store.index(indexName);
+        const results = [];
+        let cursor = await index.openCursor(null, direction ?? "next");
+        while (cursor) {
+          results.push(cursor.value);
+          cursor = await cursor.continue();
+        }
+        return results;
+      }),
+      putEvent: (event) => wrap("putEvent", () => db.put("events", event).then(() => void 0)),
+      getEvent: (id) => wrap("getEvent", () => db.get("events", id)),
+      getAllEvents: () => wrap("getAllEvents", () => db.getAll("events")),
+      getEventsByRecord: (collection2, recordId) => wrap(
+        "getEventsByRecord",
+        () => db.getAllFromIndex("events", "by-record", [collection2, recordId])
+      ),
+      putGiftWrap: (gw) => wrap("putGiftWrap", async () => {
+        if (gw.event) {
+          const compact = packEvent(gw.event);
+          await db.put("giftwraps", { id: gw.id, compact, createdAt: gw.createdAt });
+        } else {
+          await db.put("giftwraps", { id: gw.id, createdAt: gw.createdAt });
+        }
+      }),
+      getGiftWrap: (id) => wrap("getGiftWrap", async () => {
+        const raw = await db.get("giftwraps", id);
+        if (!raw) return void 0;
+        if (raw.compact) {
+          return { id: raw.id, event: unpackEvent(raw.id, raw.compact), createdAt: raw.createdAt };
+        }
+        if (raw.event) {
+          const compact = packEvent(raw.event);
+          await db.put("giftwraps", { id: raw.id, compact, createdAt: raw.createdAt });
+          return { id: raw.id, event: raw.event, createdAt: raw.createdAt };
+        }
+        return { id: raw.id, createdAt: raw.createdAt };
+      }),
+      getAllGiftWraps: () => wrap("getAllGiftWraps", async () => {
+        const raws = await db.getAll("giftwraps");
+        const results = [];
+        for (const raw of raws) {
+          if (raw.compact) {
+            results.push({ id: raw.id, event: unpackEvent(raw.id, raw.compact), createdAt: raw.createdAt });
+          } else if (raw.event) {
+            const compact = packEvent(raw.event);
+            await db.put("giftwraps", { id: raw.id, compact, createdAt: raw.createdAt });
+            results.push({ id: raw.id, event: raw.event, createdAt: raw.createdAt });
+          } else {
+            results.push({ id: raw.id, createdAt: raw.createdAt });
+          }
+        }
+        return results;
+      }),
+      deleteGiftWrap: (id) => wrap("deleteGiftWrap", () => db.delete("giftwraps", id).then(() => void 0)),
+      deleteEvent: (id) => wrap("deleteEvent", () => db.delete("events", id).then(() => void 0)),
+      stripEventData: (id) => wrap("stripEventData", async () => {
+        const existing = await db.get("events", id);
+        if (existing) {
+          await db.put("events", { ...existing, data: null });
+        }
+      }),
+      getMeta: (key) => wrap("getMeta", () => db.get("_meta", key)),
+      putMeta: (key, value) => wrap("putMeta", () => db.put("_meta", value, key).then(() => void 0)),
+      close: () => Effect2.sync(() => db.close())
+    };
+    return handle;
+  });
+}
+
 // src/services/Config.ts
 import { ServiceMap } from "effect";
 var Config = class extends ServiceMap.Service()("tablinum/Config") {
@@ -240,16 +491,16 @@ var Tablinum = class extends ServiceMap2.Service()(
 import { Effect as Effect21, Exit, Layer as Layer9, Option as Option9, PubSub as PubSub2, References as References3, Ref as Ref5, Scope as Scope4 } from "effect";
 
 // src/crud/watch.ts
-import { Effect as Effect2, PubSub, Ref, Stream } from "effect";
+import { Effect as Effect3, PubSub, Ref, Stream } from "effect";
 function watchCollection(ctx, storage, collectionName, filter, mapRecord2) {
-  const query = () => Effect2.map(storage.getAllRecords(collectionName), (all) => {
+  const query = () => Effect3.map(storage.getAllRecords(collectionName), (all) => {
     const filtered = all.filter((r) => !r._d && (filter ? filter(r) : true));
     return mapRecord2 ? filtered.map(mapRecord2) : filtered;
   });
   const changes = Stream.fromPubSub(ctx.pubsub).pipe(
     Stream.filter((event) => event.collection === collectionName),
     Stream.mapEffect(
-      () => Effect2.gen(function* () {
+      () => Effect3.gen(function* () {
         const replaying = yield* Ref.get(ctx.replayingRef);
         if (replaying) return void 0;
         return yield* query();
@@ -258,18 +509,18 @@ function watchCollection(ctx, storage, collectionName, filter, mapRecord2) {
     Stream.filter((result) => result !== void 0)
   );
   return Stream.unwrap(
-    Effect2.gen(function* () {
-      yield* Effect2.sleep(0);
+    Effect3.gen(function* () {
+      yield* Effect3.sleep(0);
       const initial = yield* query();
       return Stream.concat(Stream.make(initial), changes);
     })
   );
 }
 function notifyChange(ctx, event) {
-  return PubSub.publish(ctx.pubsub, event).pipe(Effect2.asVoid);
+  return PubSub.publish(ctx.pubsub, event).pipe(Effect3.asVoid);
 }
 function notifyReplayComplete(ctx, collections) {
-  return Effect2.gen(function* () {
+  return Effect3.gen(function* () {
     yield* Ref.set(ctx.replayingRef, false);
     for (const collection2 of collections) {
       yield* notifyChange(ctx, {
@@ -282,7 +533,7 @@ function notifyReplayComplete(ctx, collections) {
 }
 
 // src/storage/records-store.ts
-import { Effect as Effect3 } from "effect";
+import { Effect as Effect4 } from "effect";
 
 // src/storage/lww.ts
 function resolveWinner(existing, incoming) {
@@ -296,30 +547,6 @@ function resolveWinner(existing, incoming) {
 function isPlainObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function deepDiff(before, after) {
-  const result = {};
-  let hasChanges = false;
-  for (const key of Object.keys(after)) {
-    const a = before[key];
-    const b = after[key];
-    if (isPlainObject(a) && isPlainObject(b)) {
-      const nested = deepDiff(a, b);
-      if (nested !== null) {
-        result[key] = nested;
-        hasChanges = true;
-      }
-    } else if (Array.isArray(a) && Array.isArray(b)) {
-      if (JSON.stringify(a) !== JSON.stringify(b)) {
-        result[key] = b;
-        hasChanges = true;
-      }
-    } else if (a !== b) {
-      result[key] = b;
-      hasChanges = true;
-    }
-  }
-  return hasChanges ? result : null;
-}
 function deepMerge(target, source) {
   const result = { ...target };
   for (const key of Object.keys(source)) {
@@ -346,7 +573,7 @@ function buildRecord(event) {
   };
 }
 function applyEvent(storage, event) {
-  return Effect3.gen(function* () {
+  return Effect4.gen(function* () {
     const existing = yield* storage.getRecord(event.collection, event.recordId);
     if (existing) {
       const existingMeta = {
@@ -366,7 +593,7 @@ function applyEvent(storage, event) {
   });
 }
 function rebuild(storage, collections) {
-  return Effect3.gen(function* () {
+  return Effect4.gen(function* () {
     for (const col of collections) {
       yield* storage.clearRecords(col);
     }
@@ -382,7 +609,7 @@ function rebuild(storage, collections) {
 }
 
 // src/schema/validate.ts
-import { Effect as Effect4, Schema as Schema3 } from "effect";
+import { Effect as Effect5, Schema as Schema3 } from "effect";
 function fieldDefToSchema(fd) {
   let base;
   switch (fd.kind) {
@@ -430,10 +657,10 @@ function buildStructSchema(def, options = {}) {
 function buildValidator(collectionName, def) {
   const decode = Schema3.decodeUnknownEffect(buildStructSchema(def, { includeId: true }));
   return (input) => decode(input).pipe(
-    Effect4.map(
+    Effect5.map(
       (result) => result
     ),
-    Effect4.mapError(
+    Effect5.mapError(
       (e) => new ValidationError({
         message: `Validation failed for collection "${collectionName}": ${e.message}`
       })
@@ -442,7 +669,7 @@ function buildValidator(collectionName, def) {
 }
 function buildPartialValidator(collectionName, def) {
   const decode = Schema3.decodeUnknownEffect(buildStructSchema(def, { allOptional: true }));
-  return (input) => Effect4.gen(function* () {
+  return (input) => Effect5.gen(function* () {
     if (typeof input !== "object" || input === null) {
       return yield* new ValidationError({
         message: `Validation failed for collection "${collectionName}": expected an object`
@@ -457,8 +684,8 @@ function buildPartialValidator(collectionName, def) {
       });
     }
     return yield* decode(record).pipe(
-      Effect4.map((result) => result),
-      Effect4.mapError(
+      Effect5.map((result) => result),
+      Effect5.mapError(
         (e) => new ValidationError({
           message: `Validation failed for collection "${collectionName}": ${e.message}`
         })
@@ -468,7 +695,7 @@ function buildPartialValidator(collectionName, def) {
 }
 
 // src/crud/collection-handle.ts
-import { Effect as Effect6, Option as Option3, References } from "effect";
+import { Effect as Effect7, Option as Option3, References } from "effect";
 
 // src/utils/uuid.ts
 var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
@@ -501,12 +728,12 @@ function uuidv7() {
 }
 
 // src/crud/query-builder.ts
-import { Effect as Effect5, Option as Option2, Ref as Ref2, Stream as Stream2 } from "effect";
+import { Effect as Effect6, Option as Option2, Ref as Ref2, Stream as Stream2 } from "effect";
 function emptyPlan() {
   return { filters: [] };
 }
 function executeQuery(ctx, plan) {
-  return Effect5.gen(function* () {
+  return Effect6.gen(function* () {
     if (plan.fieldName) {
       const fieldDef = ctx.def.fields[plan.fieldName];
       if (!fieldDef) {
@@ -582,7 +809,7 @@ function watchQuery(ctx, plan) {
   const changes = Stream2.fromPubSub(ctx.watchCtx.pubsub).pipe(
     Stream2.filter((event) => event.collection === ctx.collectionName),
     Stream2.mapEffect(
-      () => Effect5.gen(function* () {
+      () => Effect6.gen(function* () {
         const replaying = yield* Ref2.get(ctx.watchCtx.replayingRef);
         if (replaying) return void 0;
         return yield* query();
@@ -591,7 +818,7 @@ function watchQuery(ctx, plan) {
     Stream2.filter((result) => result !== void 0)
   );
   return Stream2.unwrap(
-    Effect5.gen(function* () {
+    Effect6.gen(function* () {
       const initial = yield* query();
       return Stream2.concat(Stream2.make(initial), changes);
     })
@@ -617,11 +844,11 @@ function makeQueryBuilder(ctx, plan) {
     offset: (n) => makeQueryBuilder(ctx, { ...plan, offset: n }),
     limit: (n) => makeQueryBuilder(ctx, { ...plan, limit: n }),
     get: () => executeQuery(ctx, plan),
-    first: () => Effect5.map(
+    first: () => Effect6.map(
       executeQuery(ctx, { ...plan, limit: 1 }),
       (results) => results.length > 0 ? Option2.some(results[0]) : Option2.none()
     ),
-    count: () => Effect5.map(executeQuery(ctx, plan), (results) => results.length),
+    count: () => Effect6.map(executeQuery(ctx, plan), (results) => results.length),
     watch: () => watchQuery(ctx, plan)
   };
 }
@@ -727,7 +954,7 @@ function replayState(recordId, events, stopAtId) {
   return state;
 }
 function promoteToSnapshot(storage, collection2, recordId, target, allSorted) {
-  return Effect6.gen(function* () {
+  return Effect7.gen(function* () {
     const chronological = sortChronologically(allSorted);
     const state = replayState(recordId, chronological, target.id);
     if (state) {
@@ -736,7 +963,7 @@ function promoteToSnapshot(storage, collection2, recordId, target, allSorted) {
   });
 }
 function pruneEvents(storage, collection2, recordId, retention) {
-  return Effect6.gen(function* () {
+  return Effect7.gen(function* () {
     const events = yield* storage.getEventsByRecord(collection2, recordId);
     if (events.length <= retention) return;
     const sorted = [...events].sort((a, b) => b.createdAt - a.createdAt || (a.id < b.id ? 1 : -1));
@@ -757,8 +984,8 @@ function mapRecord(record) {
 }
 function createCollectionHandle(def, storage, watchCtx, validator, partialValidator, makeEventId, localAuthor, onWrite, logLevel = "None") {
   const collectionName = def.name;
-  const withLog = (effect) => Effect6.provideService(effect, References.MinimumLogLevel, logLevel);
-  const commitEvent = (event) => Effect6.gen(function* () {
+  const withLog = (effect) => Effect7.provideService(effect, References.MinimumLogLevel, logLevel);
+  const commitEvent = (event) => Effect7.gen(function* () {
     yield* storage.putEvent(event);
     yield* applyEvent(storage, event);
     if (onWrite) yield* onWrite(event);
@@ -770,7 +997,7 @@ function createCollectionHandle(def, storage, watchCtx, validator, partialValida
   });
   const handle = {
     add: (data) => withLog(
-      Effect6.gen(function* () {
+      Effect7.gen(function* () {
         const id = uuidv7();
         const fullRecord = { id, ...data };
         yield* validator(fullRecord);
@@ -784,7 +1011,7 @@ function createCollectionHandle(def, storage, watchCtx, validator, partialValida
           author: localAuthor
         };
         yield* commitEvent(event);
-        yield* Effect6.logDebug("Record added", {
+        yield* Effect7.logDebug("Record added", {
           collection: collectionName,
           recordId: id,
           data: fullRecord
@@ -793,7 +1020,7 @@ function createCollectionHandle(def, storage, watchCtx, validator, partialValida
       })
     ),
     update: (id, data) => withLog(
-      Effect6.gen(function* () {
+      Effect7.gen(function* () {
         const existing = yield* storage.getRecord(collectionName, id);
         if (!existing || existing._d) {
           return yield* new NotFoundError({
@@ -805,27 +1032,26 @@ function createCollectionHandle(def, storage, watchCtx, validator, partialValida
         const { _d, _u, _a, _e, ...existingFields } = existing;
         const merged = { ...existingFields, ...data, id };
         yield* validator(merged);
-        const diff = deepDiff(existingFields, merged);
         const event = {
           id: makeEventId(),
           collection: collectionName,
           recordId: id,
           kind: "u",
-          data: diff ?? { id },
+          data: merged,
           createdAt: Date.now(),
           author: localAuthor
         };
         yield* commitEvent(event);
-        yield* Effect6.logDebug("Record updated", {
+        yield* Effect7.logDebug("Record updated", {
           collection: collectionName,
           recordId: id,
-          data: diff
+          data: merged
         });
         yield* pruneEvents(storage, collectionName, id, def.eventRetention);
       })
     ),
     delete: (id) => withLog(
-      Effect6.gen(function* () {
+      Effect7.gen(function* () {
         const existing = yield* storage.getRecord(collectionName, id);
         if (!existing || existing._d) {
           return yield* new NotFoundError({
@@ -843,11 +1069,11 @@ function createCollectionHandle(def, storage, watchCtx, validator, partialValida
           author: localAuthor
         };
         yield* commitEvent(event);
-        yield* Effect6.logDebug("Record deleted", { collection: collectionName, recordId: id });
+        yield* Effect7.logDebug("Record deleted", { collection: collectionName, recordId: id });
         yield* pruneEvents(storage, collectionName, id, def.eventRetention);
       })
     ),
-    undo: (id) => Effect6.gen(function* () {
+    undo: (id) => Effect7.gen(function* () {
       const existing = yield* storage.getRecord(collectionName, id);
       if (!existing) {
         return yield* new NotFoundError({ collection: collectionName, id });
@@ -872,7 +1098,7 @@ function createCollectionHandle(def, storage, watchCtx, validator, partialValida
       yield* commitEvent(event);
       yield* pruneEvents(storage, collectionName, id, def.eventRetention);
     }),
-    get: (id) => Effect6.gen(function* () {
+    get: (id) => Effect7.gen(function* () {
       const record = yield* storage.getRecord(collectionName, id);
       if (!record || record._d) {
         return yield* new NotFoundError({
@@ -882,11 +1108,11 @@ function createCollectionHandle(def, storage, watchCtx, validator, partialValida
       }
       return mapRecord(record);
     }),
-    first: () => Effect6.map(storage.getAllRecords(collectionName), (all) => {
+    first: () => Effect7.map(storage.getAllRecords(collectionName), (all) => {
       const found = all.find((r) => !r._d);
       return found ? Option3.some(mapRecord(found)) : Option3.none();
     }),
-    count: () => Effect6.map(storage.getAllRecords(collectionName), (all) => all.filter((r) => !r._d).length),
+    count: () => Effect7.map(storage.getAllRecords(collectionName), (all) => all.filter((r) => !r._d).length),
     watch: () => watchCollection(watchCtx, storage, collectionName, void 0, mapRecord),
     where: (fieldName) => createWhereClause(
       storage,
@@ -909,12 +1135,12 @@ function createCollectionHandle(def, storage, watchCtx, validator, partialValida
 }
 
 // src/sync/sync-service.ts
-import { Duration, Effect as Effect8, Layer, Option as Option5, References as References2, Ref as Ref3, Schedule } from "effect";
+import { Duration, Effect as Effect9, Layer, Option as Option5, References as References2, Ref as Ref3, Schedule } from "effect";
 import { unwrapEvent } from "nostr-tools/nip59";
 import { GiftWrap as GiftWrap2 } from "nostr-tools/kinds";
 
 // src/sync/negentropy.ts
-import { Effect as Effect7 } from "effect";
+import { Effect as Effect8 } from "effect";
 
 // src/vendor/negentropy.js
 var PROTOCOL_VERSION = 97;
@@ -1401,14 +1627,14 @@ function itemCompare(a, b) {
 }
 
 // src/sync/negentropy.ts
-import { hexToBytes as hexToBytes2 } from "@noble/hashes/utils.js";
+import { hexToBytes as hexToBytes3 } from "@noble/hashes/utils.js";
 import { GiftWrap } from "nostr-tools/kinds";
 function reconcileWithRelay(storage, relay, relayUrl, publicKeys) {
-  return Effect7.gen(function* () {
+  return Effect8.gen(function* () {
     const allGiftWraps = yield* storage.getAllGiftWraps();
     const storageVector = new NegentropyStorageVector();
     for (const gw of allGiftWraps) {
-      storageVector.insert(gw.createdAt, hexToBytes2(gw.id));
+      storageVector.insert(gw.createdAt, hexToBytes3(gw.id));
     }
     storageVector.seal();
     const neg = new Negentropy(storageVector, 0);
@@ -1419,7 +1645,7 @@ function reconcileWithRelay(storage, relay, relayUrl, publicKeys) {
     const allHaveIds = [];
     const allNeedIds = [];
     const subId = `neg-${Date.now()}`;
-    const initialMsg = yield* Effect7.tryPromise({
+    const initialMsg = yield* Effect8.tryPromise({
       try: () => neg.initiate(),
       catch: (e) => new SyncError({
         message: `Negentropy initiate failed: ${e instanceof Error ? e.message : String(e)}`,
@@ -1431,7 +1657,7 @@ function reconcileWithRelay(storage, relay, relayUrl, publicKeys) {
     while (currentMsg !== null) {
       const response = yield* relay.sendNegMsg(relayUrl, subId, filter, currentMsg);
       if (response.msgHex === null) break;
-      const reconcileResult = yield* Effect7.tryPromise({
+      const reconcileResult = yield* Effect8.tryPromise({
         try: () => neg.reconcile(response.msgHex),
         catch: (e) => new SyncError({
           message: `Negentropy reconcile failed: ${e instanceof Error ? e.message : String(e)}`,
@@ -1444,13 +1670,13 @@ function reconcileWithRelay(storage, relay, relayUrl, publicKeys) {
       for (const id of needIds) allNeedIds.push(id);
       currentMsg = nextMsg;
     }
-    yield* Effect7.logDebug("Negentropy reconciliation complete", {
+    yield* Effect8.logDebug("Negentropy reconciliation complete", {
       relay: relayUrl,
       have: allHaveIds.length,
       need: allNeedIds.length
     });
     return { haveIds: allHaveIds, needIds: allNeedIds };
-  }).pipe(Effect7.withLogSpan("tablinum.negentropy"));
+  }).pipe(Effect8.withLogSpan("tablinum.negentropy"));
 }
 
 // src/db/key-rotation.ts
@@ -1544,52 +1770,52 @@ function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStat
     kind: "create"
   });
   const forkHandled = (effect) => {
-    Effect8.runFork(
+    Effect9.runFork(
       effect.pipe(
-        Effect8.tapError((e) => Effect8.sync(() => onSyncError?.(e))),
-        Effect8.ignore,
-        Effect8.provide(logLayer),
-        Effect8.forkIn(scope)
+        Effect9.tapError((e) => Effect9.sync(() => onSyncError?.(e))),
+        Effect9.ignore,
+        Effect9.provide(logLayer),
+        Effect9.forkIn(scope)
       )
     );
   };
   let autoFlushActive = false;
-  const autoFlushEffect = Effect8.gen(function* () {
+  const autoFlushEffect = Effect9.gen(function* () {
     const size = yield* publishQueue.size();
     if (size === 0) return;
     yield* syncStatus.set("syncing");
     yield* publishQueue.flush(relayUrls);
     const remaining = yield* publishQueue.size();
-    if (remaining > 0) yield* Effect8.fail("pending");
+    if (remaining > 0) yield* Effect9.fail("pending");
   }).pipe(
-    Effect8.ensuring(syncStatus.set("idle")),
-    Effect8.retry({ schedule: Schedule.exponential(5e3).pipe(Schedule.jittered), times: 10 }),
-    Effect8.ignore
+    Effect9.ensuring(syncStatus.set("idle")),
+    Effect9.retry({ schedule: Schedule.exponential(5e3).pipe(Schedule.jittered), times: 10 }),
+    Effect9.ignore
   );
   const scheduleAutoFlush = () => {
     if (autoFlushActive) return;
     autoFlushActive = true;
     forkHandled(
       autoFlushEffect.pipe(
-        Effect8.ensuring(
-          Effect8.sync(() => {
+        Effect9.ensuring(
+          Effect9.sync(() => {
             autoFlushActive = false;
           })
         )
       )
     );
   };
-  const shouldRejectWrite = (authorPubkey) => Effect8.gen(function* () {
+  const shouldRejectWrite = (authorPubkey) => Effect9.gen(function* () {
     const memberRecord = yield* storage.getRecord("_members", authorPubkey);
     if (!memberRecord) return false;
     return !!memberRecord.removedAt;
   });
   const storeGiftWrapShell = (gw) => storage.putGiftWrap({ id: gw.id, event: gw, createdAt: gw.created_at });
-  const unwrapGiftWrap = (remoteGw) => Effect8.gen(function* () {
+  const unwrapGiftWrap = (remoteGw) => Effect9.gen(function* () {
     const existing = yield* storage.getGiftWrap(remoteGw.id);
     if (existing) return null;
     const rumor = yield* giftWrapHandle.unwrap(remoteGw).pipe(
-      Effect8.orElseSucceed(() => null)
+      Effect9.orElseSucceed(() => null)
     );
     if (!rumor) {
       yield* storeGiftWrapShell(remoteGw);
@@ -1617,7 +1843,7 @@ function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStat
       recordId: dTag.substring(colonIdx + 1)
     };
   });
-  const applyUnwrappedEvent = (uw) => Effect8.gen(function* () {
+  const applyUnwrappedEvent = (uw) => Effect9.gen(function* () {
     const { giftWrap: remoteGw, rumor, collection: collectionName, recordId } = uw;
     const retention = knownCollections.get(collectionName);
     if (retention === void 0) {
@@ -1627,17 +1853,17 @@ function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStat
     if (rumor.pubkey) {
       const reject = yield* shouldRejectWrite(rumor.pubkey);
       if (reject) {
-        yield* Effect8.logWarning("Rejected write from removed member", {
+        yield* Effect9.logWarning("Rejected write from removed member", {
           author: rumor.pubkey.slice(0, 12)
         });
         yield* storeGiftWrapShell(remoteGw);
         return null;
       }
     }
-    const parsed = yield* Effect8.try({
+    const parsed = yield* Effect9.try({
       try: () => JSON.parse(rumor.content),
       catch: () => void 0
-    }).pipe(Effect8.orElseSucceed(() => void 0));
+    }).pipe(Effect9.orElseSucceed(() => void 0));
     if (parsed === void 0) {
       yield* storeGiftWrapShell(remoteGw);
       return null;
@@ -1669,7 +1895,7 @@ function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStat
     if (didApply && (kind === "u" || kind === "d")) {
       yield* pruneEvents(storage, collectionName, recordId, retention);
     }
-    yield* Effect8.logDebug("Processed gift wrap", {
+    yield* Effect9.logDebug("Processed gift wrap", {
       collection: collectionName,
       recordId,
       kind,
@@ -1680,33 +1906,33 @@ function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStat
     }
     return collectionName;
   });
-  const reconcileRelay = (url, pubKeys) => Effect8.gen(function* () {
-    yield* Effect8.logDebug("Syncing relay", { relay: url });
+  const reconcileRelay = (url, pubKeys) => Effect9.gen(function* () {
+    yield* Effect9.logDebug("Syncing relay", { relay: url });
     const { haveIds, needIds } = yield* reconcileWithRelay(
       storage,
       relay,
       url,
       Array.from(pubKeys)
     ).pipe(
-      Effect8.tapError((err) => Effect8.sync(() => onSyncError?.(err))),
-      Effect8.orElseSucceed(() => ({ haveIds: [], needIds: [] }))
+      Effect9.tapError((err) => Effect9.sync(() => onSyncError?.(err))),
+      Effect9.orElseSucceed(() => ({ haveIds: [], needIds: [] }))
     );
-    yield* Effect8.logDebug("Relay reconciliation result", {
+    yield* Effect9.logDebug("Relay reconciliation result", {
       relay: url,
       need: needIds.length,
       have: haveIds.length
     });
     const events = needIds.length > 0 ? yield* relay.fetchEvents(needIds, url).pipe(
-      Effect8.tapError((err) => Effect8.sync(() => onSyncError?.(err))),
-      Effect8.orElseSucceed(() => [])
+      Effect9.tapError((err) => Effect9.sync(() => onSyncError?.(err))),
+      Effect9.orElseSucceed(() => [])
     ) : [];
     return {
       events,
       haveIds: haveIds.map((id) => ({ id, url }))
     };
-  }).pipe(Effect8.withLogSpan("tablinum.reconcileRelay"));
-  const syncAllRelays = (pubKeys, changedCollections) => Effect8.gen(function* () {
-    const results = yield* Effect8.forEach(
+  }).pipe(Effect9.withLogSpan("tablinum.reconcileRelay"));
+  const syncAllRelays = (pubKeys, changedCollections) => Effect9.gen(function* () {
+    const results = yield* Effect9.forEach(
       relayUrls,
       (url) => reconcileRelay(url, pubKeys),
       { concurrency: "unbounded" }
@@ -1723,44 +1949,44 @@ function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStat
     }
     const unwrapped = [];
     for (const gw of allGiftWraps) {
-      const result = yield* unwrapGiftWrap(gw).pipe(Effect8.orElseSucceed(() => null));
+      const result = yield* unwrapGiftWrap(gw).pipe(Effect9.orElseSucceed(() => null));
       if (result) unwrapped.push(result);
     }
     unwrapped.sort((a, b) => a.rumor.created_at - b.rumor.created_at || (a.rumor.id < b.rumor.id ? -1 : 1));
     for (const event of unwrapped) {
       const collection2 = yield* applyUnwrappedEvent(event).pipe(
-        Effect8.orElseSucceed(() => null)
+        Effect9.orElseSucceed(() => null)
       );
       if (collection2) changedCollections.add(collection2);
     }
     const allHaveIds = results.flatMap((r) => r.haveIds);
-    yield* Effect8.forEach(
+    yield* Effect9.forEach(
       allHaveIds,
-      ({ id, url }) => Effect8.gen(function* () {
+      ({ id, url }) => Effect9.gen(function* () {
         const gw = yield* storage.getGiftWrap(id);
         if (!gw?.event) return;
         yield* relay.publish(gw.event, [url]).pipe(
-          Effect8.tapError((err) => Effect8.sync(() => onSyncError?.(err))),
-          Effect8.ignore
+          Effect9.tapError((err) => Effect9.sync(() => onSyncError?.(err))),
+          Effect9.ignore
         );
       }),
       { concurrency: "unbounded", discard: true }
     );
-  }).pipe(Effect8.withLogSpan("tablinum.syncAllRelays"));
-  const processGiftWrap = (remoteGw) => Effect8.gen(function* () {
+  }).pipe(Effect9.withLogSpan("tablinum.syncAllRelays"));
+  const processGiftWrap = (remoteGw) => Effect9.gen(function* () {
     const uw = yield* unwrapGiftWrap(remoteGw);
     if (!uw) return null;
     return yield* applyUnwrappedEvent(uw);
   });
-  const processRealtimeGiftWrap = (remoteGw) => Effect8.gen(function* () {
-    const collection2 = yield* processGiftWrap(remoteGw).pipe(Effect8.orElseSucceed(() => null));
+  const processRealtimeGiftWrap = (remoteGw) => Effect9.gen(function* () {
+    const collection2 = yield* processGiftWrap(remoteGw).pipe(Effect9.orElseSucceed(() => null));
     if (collection2) {
       yield* notifyCollectionUpdated(collection2);
     }
   });
-  const processRotationGiftWrap = (remoteGw) => Effect8.gen(function* () {
-    const unwrapResult = yield* Effect8.result(
-      Effect8.try({
+  const processRotationGiftWrap = (remoteGw) => Effect9.gen(function* () {
+    const unwrapResult = yield* Effect9.result(
+      Effect9.try({
         try: () => unwrapEvent(remoteGw, personalPrivateKey),
         catch: (e) => new CryptoError({
           message: `Rotation unwrap failed: ${e instanceof Error ? e.message : String(e)}`,
@@ -1810,73 +2036,73 @@ function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStat
     yield* handle.addEpochSubscription(epoch.publicKey);
     return true;
   });
-  const subscribeAcrossRelays = (filter, onEvent) => Effect8.forEach(
+  const subscribeAcrossRelays = (filter, onEvent) => Effect9.forEach(
     relayUrls,
-    (url) => Effect8.gen(function* () {
+    (url) => Effect9.gen(function* () {
       yield* relay.subscribe(filter, url, (event) => {
         forkHandled(onEvent(event));
       }).pipe(
-        Effect8.tapError((err) => Effect8.sync(() => onSyncError?.(err))),
-        Effect8.ignore
+        Effect9.tapError((err) => Effect9.sync(() => onSyncError?.(err))),
+        Effect9.ignore
       );
     }),
     { concurrency: "unbounded", discard: true }
   );
   let healingActive = false;
-  const healingEffect = Effect8.gen(function* () {
+  const healingEffect = Effect9.gen(function* () {
     if (!healingActive) return;
     const status = yield* syncStatus.get();
     if (status === "syncing") return;
     yield* syncStatus.set("syncing");
-    yield* Effect8.gen(function* () {
+    yield* Effect9.gen(function* () {
       const pubKeys = getSubscriptionPubKeys();
       const changedCollections = /* @__PURE__ */ new Set();
       yield* syncAllRelays(pubKeys, changedCollections);
       if (changedCollections.size > 0) {
         yield* notifyReplayComplete(watchCtx, [...changedCollections]);
       }
-    }).pipe(Effect8.ensuring(syncStatus.set("idle")));
-  }).pipe(Effect8.ignore);
+    }).pipe(Effect9.ensuring(syncStatus.set("idle")));
+  }).pipe(Effect9.ignore);
   const handle = {
-    sync: () => Effect8.gen(function* () {
-      yield* Effect8.logInfo("Sync started");
+    sync: () => Effect9.gen(function* () {
+      yield* Effect9.logInfo("Sync started");
       yield* syncStatus.set("syncing");
       yield* Ref3.set(watchCtx.replayingRef, true);
       const changedCollections = /* @__PURE__ */ new Set();
-      yield* Effect8.gen(function* () {
+      yield* Effect9.gen(function* () {
         const pubKeys = getSubscriptionPubKeys();
         yield* syncAllRelays(pubKeys, changedCollections);
-        yield* publishQueue.flush(relayUrls).pipe(Effect8.ignore);
+        yield* publishQueue.flush(relayUrls).pipe(Effect9.ignore);
       }).pipe(
-        Effect8.ensuring(
-          Effect8.gen(function* () {
+        Effect9.ensuring(
+          Effect9.gen(function* () {
             yield* notifyReplayComplete(watchCtx, [...changedCollections]);
             yield* syncStatus.set("idle");
           })
         )
       );
-      yield* Effect8.logInfo("Sync complete", { changed: [...changedCollections] });
-    }).pipe(Effect8.withLogSpan("tablinum.sync")),
-    publishLocal: (giftWrap) => Effect8.gen(function* () {
+      yield* Effect9.logInfo("Sync complete", { changed: [...changedCollections] });
+    }).pipe(Effect9.withLogSpan("tablinum.sync")),
+    publishLocal: (giftWrap) => Effect9.gen(function* () {
       if (!giftWrap.event) return;
       yield* relay.publish(giftWrap.event, relayUrls).pipe(
-        Effect8.tapError(
+        Effect9.tapError(
           () => storage.putGiftWrap(giftWrap).pipe(
-            Effect8.andThen(publishQueue.enqueue(giftWrap.id)),
-            Effect8.andThen(Effect8.sync(() => scheduleAutoFlush()))
+            Effect9.andThen(publishQueue.enqueue(giftWrap.id)),
+            Effect9.andThen(Effect9.sync(() => scheduleAutoFlush()))
           )
         ),
-        Effect8.tapError((err) => Effect8.sync(() => onSyncError?.(err))),
-        Effect8.ignore
+        Effect9.tapError((err) => Effect9.sync(() => onSyncError?.(err))),
+        Effect9.ignore
       );
     }),
-    startSubscription: () => Effect8.gen(function* () {
+    startSubscription: () => Effect9.gen(function* () {
       const pubKeys = getSubscriptionPubKeys();
       yield* subscribeAcrossRelays({ kinds: [GiftWrap2], "#p": pubKeys }, processRealtimeGiftWrap);
       if (!pubKeys.includes(personalPublicKey)) {
         yield* subscribeAcrossRelays(
           { kinds: [GiftWrap2], "#p": [personalPublicKey] },
-          (event) => Effect8.result(processRotationGiftWrap(event)).pipe(Effect8.asVoid)
+          (event) => Effect9.result(processRotationGiftWrap(event)).pipe(Effect9.asVoid)
         );
       }
     }),
@@ -1885,10 +2111,10 @@ function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStat
       if (healingActive) return;
       healingActive = true;
       forkHandled(
-        Effect8.sleep(Duration.minutes(5)).pipe(
-          Effect8.andThen(healingEffect),
-          Effect8.repeat(Schedule.spaced(Duration.minutes(5))),
-          Effect8.ensuring(Effect8.sync(() => {
+        Effect9.sleep(Duration.minutes(5)).pipe(
+          Effect9.andThen(healingEffect),
+          Effect9.repeat(Schedule.spaced(Duration.minutes(5))),
+          Effect9.ensuring(Effect9.sync(() => {
             healingActive = false;
           }))
         )
@@ -1900,8 +2126,8 @@ function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStat
   };
   forkHandled(
     publishQueue.size().pipe(
-      Effect8.flatMap(
-        (size) => Effect8.sync(() => {
+      Effect9.flatMap(
+        (size) => Effect9.sync(() => {
           if (size > 0) scheduleAutoFlush();
         })
       )
@@ -1911,7 +2137,7 @@ function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStat
 }
 
 // src/db/members.ts
-import { Effect as Effect9, Option as Option6, Schema as Schema5 } from "effect";
+import { Effect as Effect10, Option as Option6, Schema as Schema5 } from "effect";
 var optionalString = {
   _tag: "FieldDef",
   kind: "string",
@@ -1960,15 +2186,15 @@ var AuthorProfileSchema = Schema5.Struct({
 });
 var decodeAuthorProfile = Schema5.decodeUnknownEffect(Schema5.fromJsonString(AuthorProfileSchema));
 function fetchAuthorProfile(relay, relayUrls, pubkey) {
-  return Effect9.gen(function* () {
+  return Effect10.gen(function* () {
     for (const url of relayUrls) {
-      const result = yield* Effect9.result(
+      const result = yield* Effect10.result(
         relay.fetchByFilter({ kinds: [0], authors: [pubkey], limit: 1 }, url)
       );
       if (result._tag === "Success" && result.success.length > 0) {
         return yield* decodeAuthorProfile(result.success[0].content).pipe(
-          Effect9.map(Option6.some),
-          Effect9.orElseSucceed(() => Option6.none())
+          Effect10.map(Option6.some),
+          Effect10.orElseSucceed(() => Option6.none())
         );
       }
     }
@@ -1976,6 +2202,20 @@ function fetchAuthorProfile(relay, relayUrls, pubkey) {
   });
 }
 
+// src/sync/deletion.ts
+import { finalizeEvent } from "nostr-tools/pure";
+function createDeletionEvent(targetEventIds, signingKey) {
+  return finalizeEvent(
+    {
+      kind: 5,
+      content: "",
+      tags: targetEventIds.map((id) => ["e", id]),
+      created_at: Math.floor(Date.now() / 1e3)
+    },
+    signingKey
+  );
+}
+
 // src/services/Identity.ts
 import { ServiceMap as ServiceMap3 } from "effect";
 var Identity = class extends ServiceMap3.Service()("tablinum/Identity") {
@@ -2018,15 +2258,15 @@ var SyncStatus = class extends ServiceMap9.Service()(
 };
 
 // src/layers/IdentityLive.ts
-import { Effect as Effect11, Layer as Layer2 } from "effect";
-import { hexToBytes as hexToBytes3 } from "@noble/hashes/utils.js";
+import { Effect as Effect12, Layer as Layer2 } from "effect";
+import { hexToBytes as hexToBytes4 } from "@noble/hashes/utils.js";
 
 // src/db/identity.ts
-import { Effect as Effect10 } from "effect";
+import { Effect as Effect11 } from "effect";
 import { getPublicKey as getPublicKey2 } from "nostr-tools/pure";
-import { bytesToHex as bytesToHex2 } from "@noble/hashes/utils.js";
+import { bytesToHex as bytesToHex3 } from "@noble/hashes/utils.js";
 function createIdentity(suppliedKey) {
-  return Effect10.gen(function* () {
+  return Effect11.gen(function* () {
     let privateKey;
     if (suppliedKey) {
       if (suppliedKey.length !== 32) {
@@ -2039,8 +2279,8 @@ function createIdentity(suppliedKey) {
       privateKey = new Uint8Array(32);
       crypto.getRandomValues(privateKey);
     }
-    const privateKeyHex = bytesToHex2(privateKey);
-    const publicKey = yield* Effect10.try({
+    const privateKeyHex = bytesToHex3(privateKey);
+    const publicKey = yield* Effect11.try({
       try: () => getPublicKey2(privateKey),
       catch: (e) => new CryptoError({
         message: `Failed to derive public key: ${e instanceof Error ? e.message : String(e)}`,
@@ -2058,14 +2298,14 @@ function createIdentity(suppliedKey) {
 // src/layers/IdentityLive.ts
 var IdentityLive = Layer2.effect(
   Identity,
-  Effect11.gen(function* () {
+  Effect12.gen(function* () {
     const config = yield* Config;
     const storage = yield* Storage;
     const idbKey = yield* storage.getMeta("identity_key");
-    const resolvedKey = config.privateKey ?? (typeof idbKey === "string" && idbKey.length === 64 ? hexToBytes3(idbKey) : void 0);
+    const resolvedKey = config.privateKey ?? (typeof idbKey === "string" && idbKey.length === 64 ? hexToBytes4(idbKey) : void 0);
     const identity = yield* createIdentity(resolvedKey);
     yield* storage.putMeta("identity_key", identity.exportKey());
-    yield* Effect11.logInfo("Identity loaded", {
+    yield* Effect12.logInfo("Identity loaded", {
       publicKey: identity.publicKey.slice(0, 12) + "...",
       source: config.privateKey ? "config" : resolvedKey ? "storage" : "generated"
     });
@@ -2074,12 +2314,12 @@ var IdentityLive = Layer2.effect(
 );
 
 // src/layers/EpochStoreLive.ts
-import { Effect as Effect12, Layer as Layer3, Option as Option7 } from "effect";
+import { Effect as Effect13, Layer as Layer3, Option as Option7 } from "effect";
 import { generateSecretKey as generateSecretKey2 } from "nostr-tools/pure";
-import { bytesToHex as bytesToHex3 } from "@noble/hashes/utils.js";
+import { bytesToHex as bytesToHex4 } from "@noble/hashes/utils.js";
 var EpochStoreLive = Layer3.effect(
   EpochStore,
-  Effect12.gen(function* () {
+  Effect13.gen(function* () {
     const config = yield* Config;
     const identity = yield* Identity;
     const storage = yield* Storage;
@@ -2098,7 +2338,7 @@ var EpochStoreLive = Layer3.effect(
           return existing !== void 0 && existing.privateKey === ek.key;
         });
         if (configIsSubset) {
-          yield* Effect12.logInfo("Epoch store loaded", {
+          yield* Effect13.logInfo("Epoch store loaded", {
             source: "storage",
             epochs: idbStore.epochs.size
           });
@@ -2107,271 +2347,28 @@ var EpochStoreLive = Layer3.effect(
       }
       const store2 = createEpochStoreFromInputs(config.epochKeys);
       yield* storage.putMeta("epochs", stringifyEpochStore(store2));
-      yield* Effect12.logInfo("Epoch store loaded", { source: "config", epochs: store2.epochs.size });
+      yield* Effect13.logInfo("Epoch store loaded", { source: "config", epochs: store2.epochs.size });
       return store2;
     }
     if (idbStore) {
-      yield* Effect12.logInfo("Epoch store loaded", {
+      yield* Effect13.logInfo("Epoch store loaded", {
         source: "storage",
         epochs: idbStore.epochs.size
       });
       return idbStore;
     }
     const store = createEpochStoreFromInputs(
-      [{ epochId: EpochId("epoch-0"), key: bytesToHex3(generateSecretKey2()) }],
+      [{ epochId: EpochId("epoch-0"), key: bytesToHex4(generateSecretKey2()) }],
       { createdBy: identity.publicKey }
     );
     yield* storage.putMeta("epochs", stringifyEpochStore(store));
-    yield* Effect12.logInfo("Epoch store loaded", { source: "generated", epochs: store.epochs.size });
+    yield* Effect13.logInfo("Epoch store loaded", { source: "generated", epochs: store.epochs.size });
     return store;
   })
 );
 
 // src/layers/StorageLive.ts
 import { Effect as Effect14, Layer as Layer4 } from "effect";
-
-// src/storage/idb.ts
-import { Effect as Effect13 } from "effect";
-import { openDB } from "idb";
-
-// src/sync/compact-event.ts
-import { bytesToHex as bytesToHex4, hexToBytes as hexToBytes4 } from "@noble/hashes/utils.js";
-var VERSION = 1;
-var HEADER_SIZE = 133;
-function base64ToBytes(base64) {
-  const binary = atob(base64);
-  const bytes = new Uint8Array(binary.length);
-  for (let i = 0; i < binary.length; i++) {
-    bytes[i] = binary.charCodeAt(i);
-  }
-  return bytes;
-}
-function bytesToBase64(bytes) {
-  let binary = "";
-  for (let i = 0; i < bytes.length; i++) {
-    binary += String.fromCharCode(bytes[i]);
-  }
-  return btoa(binary);
-}
-function packEvent(event) {
-  const pubkey = hexToBytes4(event.pubkey);
-  const sig = hexToBytes4(event.sig);
-  const recipientTag = event.tags.find((t) => t[0] === "p");
-  if (!recipientTag) throw new Error("Gift wrap missing #p tag");
-  if (event.tags.some((t) => t[0] !== "p")) {
-    throw new Error("Gift wrap has unexpected non-p tags; compact encoding would lose them");
-  }
-  const recipient = hexToBytes4(recipientTag[1]);
-  const createdAtBuf = new Uint8Array(4);
-  new DataView(createdAtBuf.buffer).setUint32(0, event.created_at, false);
-  const content = base64ToBytes(event.content);
-  const result = new Uint8Array(HEADER_SIZE + content.length);
-  result[0] = VERSION;
-  result.set(pubkey, 1);
-  result.set(sig, 33);
-  result.set(recipient, 97);
-  result.set(createdAtBuf, 129);
-  result.set(content, HEADER_SIZE);
-  return result;
-}
-function unpackEvent(id, compact) {
-  const version = compact[0];
-  if (version !== VERSION) throw new Error(`Unknown compact event version: ${version}`);
-  const pubkey = bytesToHex4(compact.slice(1, 33));
-  const sig = bytesToHex4(compact.slice(33, 97));
-  const recipient = bytesToHex4(compact.slice(97, 129));
-  const dv = new DataView(compact.buffer, compact.byteOffset + 129, 4);
-  const createdAt = dv.getUint32(0, false);
-  const content = bytesToBase64(compact.slice(HEADER_SIZE));
-  return {
-    id,
-    pubkey,
-    sig,
-    created_at: createdAt,
-    kind: 1059,
-    tags: [["p", recipient]],
-    content
-  };
-}
-
-// src/storage/idb.ts
-var DB_NAME = "tablinum";
-function storeName(collection2) {
-  return `col_${collection2}`;
-}
-function computeSchemaSig(schema) {
-  return Object.entries(schema).sort(([a], [b]) => a.localeCompare(b)).map(([name, def]) => {
-    const indices = [...def.indices ?? []].sort().join(",");
-    return `${name}:${indices}`;
-  }).join("|");
-}
-function wrap(label, fn) {
-  return Effect13.tryPromise({
-    try: fn,
-    catch: (e) => new StorageError({
-      message: `IndexedDB ${label} failed: ${e instanceof Error ? e.message : String(e)}`,
-      cause: e
-    })
-  });
-}
-function upgradeSchema(database, schema, tx) {
-  if (!database.objectStoreNames.contains("_meta")) {
-    database.createObjectStore("_meta");
-  }
-  if (!database.objectStoreNames.contains("events")) {
-    const events = database.createObjectStore("events", { keyPath: "id" });
-    events.createIndex("by-record", ["collection", "recordId"]);
-  }
-  if (!database.objectStoreNames.contains("giftwraps")) {
-    database.createObjectStore("giftwraps", { keyPath: "id" });
-  }
-  const expectedStores = /* @__PURE__ */ new Set();
-  for (const [, def] of Object.entries(schema)) {
-    const sn = storeName(def.name);
-    expectedStores.add(sn);
-    if (!database.objectStoreNames.contains(sn)) {
-      const store = database.createObjectStore(sn, { keyPath: "id" });
-      for (const idx of def.indices ?? []) {
-        store.createIndex(idx, idx);
-      }
-    } else {
-      const store = tx.objectStore(sn);
-      const existingIndices = new Set(Array.from(store.indexNames));
-      const wantedIndices = new Set(def.indices ?? []);
-      for (const idx of existingIndices) {
-        if (!wantedIndices.has(idx)) store.deleteIndex(idx);
-      }
-      for (const idx of wantedIndices) {
-        if (!existingIndices.has(idx)) store.createIndex(idx, idx);
-      }
-    }
-  }
-  for (const existing of Array.from(database.objectStoreNames)) {
-    if (existing.startsWith("col_") && !expectedStores.has(existing)) {
-      database.deleteObjectStore(existing);
-    }
-  }
-  tx.objectStore("_meta").put(computeSchemaSig(schema), "schema_sig");
-}
-function openIDBStorage(dbName, schema) {
-  return Effect13.gen(function* () {
-    const name = dbName ?? DB_NAME;
-    const schemaSig = computeSchemaSig(schema);
-    if (typeof indexedDB === "undefined") {
-      return yield* Effect13.fail(
-        new StorageError({
-          message: "IndexedDB is not available in this environment"
-        })
-      );
-    }
-    const probeDb = yield* Effect13.tryPromise({
-      try: () => openDB(name),
-      catch: (e) => new StorageError({ message: "Failed to open IndexedDB", cause: e })
-    });
-    const currentVersion = probeDb.version;
-    let needsUpgrade = true;
-    if (probeDb.objectStoreNames.contains("_meta")) {
-      const storedSig = yield* Effect13.tryPromise({
-        try: () => probeDb.get("_meta", "schema_sig"),
-        catch: () => new StorageError({ message: "Failed to read schema meta" })
-      }).pipe(Effect13.catch(() => Effect13.succeed(void 0)));
-      needsUpgrade = storedSig !== schemaSig;
-    }
-    probeDb.close();
-    const db = needsUpgrade ? yield* Effect13.tryPromise({
-      try: () => openDB(name, currentVersion + 1, {
-        upgrade(database, _oldVersion, _newVersion, transaction) {
-          upgradeSchema(database, schema, transaction);
-        }
-      }),
-      catch: (e) => new StorageError({ message: "Failed to open IndexedDB", cause: e })
-    }) : yield* Effect13.tryPromise({
-      try: () => openDB(name),
-      catch: (e) => new StorageError({ message: "Failed to open IndexedDB", cause: e })
-    });
-    yield* Effect13.addFinalizer(() => Effect13.sync(() => db.close()));
-    const handle = {
-      putRecord: (collection2, record) => wrap("putRecord", () => db.put(storeName(collection2), record).then(() => void 0)),
-      getRecord: (collection2, id) => wrap("getRecord", () => db.get(storeName(collection2), id)),
-      getAllRecords: (collection2) => wrap("getAllRecords", () => db.getAll(storeName(collection2))),
-      countRecords: (collection2) => wrap("countRecords", () => db.count(storeName(collection2))),
-      clearRecords: (collection2) => wrap("clearRecords", () => db.clear(storeName(collection2))),
-      getByIndex: (collection2, indexName, value) => wrap("getByIndex", () => db.getAllFromIndex(storeName(collection2), indexName, value)),
-      getByIndexRange: (collection2, indexName, range) => wrap("getByIndexRange", () => db.getAllFromIndex(storeName(collection2), indexName, range)),
-      getAllSorted: (collection2, indexName, direction) => wrap("getAllSorted", async () => {
-        const sn = storeName(collection2);
-        const tx = db.transaction(sn, "readonly");
-        const store = tx.objectStore(sn);
-        const index = store.index(indexName);
-        const results = [];
-        let cursor = await index.openCursor(null, direction ?? "next");
-        while (cursor) {
-          results.push(cursor.value);
-          cursor = await cursor.continue();
-        }
-        return results;
-      }),
-      putEvent: (event) => wrap("putEvent", () => db.put("events", event).then(() => void 0)),
-      getEvent: (id) => wrap("getEvent", () => db.get("events", id)),
-      getAllEvents: () => wrap("getAllEvents", () => db.getAll("events")),
-      getEventsByRecord: (collection2, recordId) => wrap(
-        "getEventsByRecord",
-        () => db.getAllFromIndex("events", "by-record", [collection2, recordId])
-      ),
-      putGiftWrap: (gw) => wrap("putGiftWrap", async () => {
-        if (gw.event) {
-          const compact = packEvent(gw.event);
-          await db.put("giftwraps", { id: gw.id, compact, createdAt: gw.createdAt });
-        } else {
-          await db.put("giftwraps", { id: gw.id, createdAt: gw.createdAt });
-        }
-      }),
-      getGiftWrap: (id) => wrap("getGiftWrap", async () => {
-        const raw = await db.get("giftwraps", id);
-        if (!raw) return void 0;
-        if (raw.compact) {
-          return { id: raw.id, event: unpackEvent(raw.id, raw.compact), createdAt: raw.createdAt };
-        }
-        if (raw.event) {
-          const compact = packEvent(raw.event);
-          await db.put("giftwraps", { id: raw.id, compact, createdAt: raw.createdAt });
-          return { id: raw.id, event: raw.event, createdAt: raw.createdAt };
-        }
-        return { id: raw.id, createdAt: raw.createdAt };
-      }),
-      getAllGiftWraps: () => wrap("getAllGiftWraps", async () => {
-        const raws = await db.getAll("giftwraps");
-        const results = [];
-        for (const raw of raws) {
-          if (raw.compact) {
-            results.push({ id: raw.id, event: unpackEvent(raw.id, raw.compact), createdAt: raw.createdAt });
-          } else if (raw.event) {
-            const compact = packEvent(raw.event);
-            await db.put("giftwraps", { id: raw.id, compact, createdAt: raw.createdAt });
-            results.push({ id: raw.id, event: raw.event, createdAt: raw.createdAt });
-          } else {
-            results.push({ id: raw.id, createdAt: raw.createdAt });
-          }
-        }
-        return results;
-      }),
-      deleteGiftWrap: (id) => wrap("deleteGiftWrap", () => db.delete("giftwraps", id).then(() => void 0)),
-      deleteEvent: (id) => wrap("deleteEvent", () => db.delete("events", id).then(() => void 0)),
-      stripEventData: (id) => wrap("stripEventData", async () => {
-        const existing = await db.get("events", id);
-        if (existing) {
-          await db.put("events", { ...existing, data: null });
-        }
-      }),
-      getMeta: (key) => wrap("getMeta", () => db.get("_meta", key)),
-      putMeta: (key, value) => wrap("putMeta", () => db.put("_meta", value, key).then(() => void 0)),
-      close: () => Effect13.sync(() => db.close())
-    };
-    return handle;
-  });
-}
-
-// src/layers/StorageLive.ts
 var StorageLive = Layer4.effect(
   Storage,
   Effect14.gen(function* () {
@@ -2908,6 +2905,12 @@ var TablinumLive = Layer9.effect(
       }
       const gw = wrapResult.success;
       yield* storage.putGiftWrap({ id: gw.id, event: gw, createdAt: gw.created_at });
+      const metaKey = `gw_record:${event.collection}:${event.recordId}`;
+      const prevMapping = yield* storage.getMeta(metaKey).pipe(
+        Effect21.orElseSucceed(() => void 0)
+      );
+      const epochPubKey = gw.tags.find((t) => t[0] === "p")?.[1];
+      yield* storage.putMeta(metaKey, { gwId: gw.id, epochPubKey });
       yield* Effect21.forkIn(
         Effect21.gen(function* () {
           const publishResult = yield* Effect21.result(
@@ -2920,10 +2923,80 @@ var TablinumLive = Layer9.effect(
           if (publishResult._tag === "Failure") {
             reportSyncError(config.onSyncError, publishResult.failure);
           }
+          if (prevMapping?.epochPubKey) {
+            const signingKey = getDecryptionKey(epochStore, prevMapping.epochPubKey);
+            if (signingKey) {
+              const deletionEvent = createDeletionEvent(
+                [prevMapping.gwId],
+                signingKey
+              );
+              yield* relay.publish(deletionEvent, [...config.relays]).pipe(
+                Effect21.tapError(
+                  (e) => Effect21.sync(() => reportSyncError(config.onSyncError, e))
+                ),
+                Effect21.ignore
+              );
+            }
+            yield* storage.deleteGiftWrap(prevMapping.gwId).pipe(Effect21.ignore);
+          }
         }),
         scope
       );
     });
+    const republishAllUnderCurrentEpoch = () => Effect21.gen(function* () {
+      const oldGwDeletions = [];
+      for (const [, def] of allSchemaEntries) {
+        const collectionName = def.name;
+        const allRecords = yield* storage.getAllRecords(collectionName);
+        for (const record of allRecords) {
+          const recordId = record.id;
+          const { _d, _u, _a, _e, ...fields } = record;
+          const content = _d ? JSON.stringify(null) : JSON.stringify(fields);
+          const dTag = `${collectionName}:${recordId}`;
+          const wrapResult = yield* Effect21.result(
+            giftWrap.wrap({
+              kind: 1,
+              content,
+              tags: [["d", dTag]],
+              created_at: Math.floor(Date.now() / 1e3)
+            })
+          );
+          if (wrapResult._tag === "Failure") continue;
+          const gw = wrapResult.success;
+          yield* storage.putGiftWrap({ id: gw.id, event: gw, createdAt: gw.created_at });
+          const metaKey = `gw_record:${collectionName}:${recordId}`;
+          const prevMapping = yield* storage.getMeta(metaKey).pipe(
+            Effect21.orElseSucceed(() => void 0)
+          );
+          if (prevMapping) oldGwDeletions.push(prevMapping);
+          const epochPubKey = gw.tags.find((t) => t[0] === "p")?.[1];
+          yield* storage.putMeta(metaKey, { gwId: gw.id, epochPubKey });
+          yield* relay.publish(gw, [...config.relays]).pipe(
+            Effect21.tapError((e) => Effect21.sync(() => reportSyncError(config.onSyncError, e))),
+            Effect21.ignore
+          );
+        }
+      }
+      const byEpoch = /* @__PURE__ */ new Map();
+      for (const { gwId, epochPubKey } of oldGwDeletions) {
+        const ids = byEpoch.get(epochPubKey) ?? [];
+        ids.push(gwId);
+        byEpoch.set(epochPubKey, ids);
+      }
+      for (const [epochPubKey, gwIds] of byEpoch) {
+        const signingKey = getDecryptionKey(epochStore, epochPubKey);
+        if (signingKey) {
+          const deletionEvent = createDeletionEvent(gwIds, signingKey);
+          yield* relay.publish(deletionEvent, [...config.relays]).pipe(
+            Effect21.tapError((e) => Effect21.sync(() => reportSyncError(config.onSyncError, e))),
+            Effect21.ignore
+          );
+        }
+        for (const gwId of gwIds) {
+          yield* storage.deleteGiftWrap(gwId).pipe(Effect21.ignore);
+        }
+      }
+    });
     const knownAuthors = /* @__PURE__ */ new Set();
     const putMemberRecord = (record) => Effect21.gen(function* () {
       const existing = yield* storage.getRecord("_members", record.id);
@@ -3011,6 +3084,13 @@ var TablinumLive = Layer9.effect(
         addedInEpoch: getCurrentEpoch(epochStore).id
       });
     }
+    const migrated = yield* storage.getMeta("migration_gw_republish").pipe(
+      Effect21.orElseSucceed(() => void 0)
+    );
+    if (!migrated) {
+      yield* republishAllUnderCurrentEpoch().pipe(Effect21.ignore);
+      yield* storage.putMeta("migration_gw_republish", true);
+    }
     const withLog = (effect) => Effect21.provideService(effect, References3.MinimumLogLevel, config.logLevel);
     const ensureOpen = (effect) => withLog(
       Effect21.gen(function* () {
@@ -3050,6 +3130,61 @@ var TablinumLive = Layer9.effect(
           yield* Scope4.close(scope, Exit.void);
         })
       ),
+      destroy: () => withLog(
+        Effect21.gen(function* () {
+          if (!(yield* Ref5.get(closedRef))) {
+            yield* Ref5.set(closedRef, true);
+            syncHandle.stopHealing();
+            yield* Scope4.close(scope, Exit.void);
+          }
+          yield* deleteIDBStorage(config.dbName);
+        })
+      ),
+      leave: () => withLog(
+        Effect21.gen(function* () {
+          if (yield* Ref5.get(closedRef)) {
+            return yield* new SyncError({ message: "Database is closed", phase: "leave" });
+          }
+          const allMembers = yield* storage.getAllRecords("_members");
+          const activeMembers = allMembers.filter(
+            (member) => !member.removedAt && member.id !== identity.publicKey
+          );
+          const activePubkeys = activeMembers.map((member) => member.id);
+          const result = createRotation(
+            epochStore,
+            identity.privateKey,
+            identity.publicKey,
+            activePubkeys,
+            [identity.publicKey]
+          );
+          addEpoch(epochStore, result.epoch);
+          epochStore.currentEpochId = result.epoch.id;
+          yield* storage.putMeta("epochs", stringifyEpochStore(epochStore));
+          const memberRecord = yield* storage.getRecord("_members", identity.publicKey);
+          yield* putMemberRecord({
+            ...memberRecord ?? {
+              id: identity.publicKey,
+              addedAt: 0,
+              addedInEpoch: EpochId("epoch-0")
+            },
+            removedAt: Date.now(),
+            removedInEpoch: result.epoch.id
+          });
+          yield* republishAllUnderCurrentEpoch();
+          yield* Effect21.forEach(
+            result.wrappedEvents,
+            (wrappedEvent) => relay.publish(wrappedEvent, [...config.relays]).pipe(
+              Effect21.tapError((e) => Effect21.sync(() => reportSyncError(config.onSyncError, e))),
+              Effect21.ignore
+            ),
+            { discard: true }
+          );
+          yield* Ref5.set(closedRef, true);
+          syncHandle.stopHealing();
+          yield* Scope4.close(scope, Exit.void);
+          yield* deleteIDBStorage(config.dbName);
+        })
+      ),
       rebuild: () => ensureOpen(
         rebuild(
           storage,
@@ -3110,6 +3245,7 @@ var TablinumLive = Layer9.effect(
             removedAt: Date.now(),
             removedInEpoch: result.epoch.id
           });
+          yield* republishAllUnderCurrentEpoch();
           yield* Effect21.forEach(
             result.wrappedEvents,
             (wrappedEvent) => relay.publish(wrappedEvent, [...config.relays]).pipe(
@@ -3187,6 +3323,9 @@ function validateConfig(config) {
     }
   });
 }
+function deleteDatabase(dbName) {
+  return deleteIDBStorage(DatabaseName(dbName ?? "tablinum"));
+}
 function createTablinum(config) {
   return Effect22.gen(function* () {
     yield* validateConfig(config);
@@ -3259,6 +3398,7 @@ export {
   collection,
   createTablinum,
   decodeInvite,
+  deleteDatabase,
   encodeInvite,
   field
 };