tablinum 0.2.0 → 0.5.0

package/dist/svelte/index.svelte.js

@@ -7,19 +7,20 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/schema/field.ts
-function make(kind, isOptional, isArray) {
-  return { _tag: "FieldDef", kind, isOptional, isArray };
+function make(kind, isOptional, isArray, fields) {
+  return { _tag: "FieldDef", kind, isOptional, isArray, ...fields !== undefined && { fields } };
 }
 var field = {
   string: () => make("string", false, false),
   number: () => make("number", false, false),
   boolean: () => make("boolean", false, false),
   json: () => make("json", false, false),
-  optional: (inner) => make(inner.kind, true, inner.isArray),
-  array: (inner) => make(inner.kind, inner.isOptional, true)
+  object: (fields) => make("object", false, false, fields),
+  optional: (inner) => make(inner.kind, true, inner.isArray, inner.fields),
+  array: (inner) => make(inner.kind, inner.isOptional, true, inner.fields)
 };
 // src/schema/collection.ts
-var RESERVED_NAMES = new Set(["id", "_deleted", "_createdAt", "_updatedAt"]);
+var RESERVED_NAMES = new Set(["id", "_d", "_u", "_e", "_a"]);
 function collection(name, fields, options) {
   if (!name || name.trim().length === 0) {
     throw new Error("Collection name must not be empty");
@@ -40,13 +41,17 @@ function collection(name, fields, options) {
       if (!fieldDef) {
         throw new Error(`Index field "${idx}" does not exist in collection "${name}"`);
       }
-      if (fieldDef.kind === "json" || fieldDef.isArray) {
+      if (fieldDef.kind === "json" || fieldDef.kind === "object" || fieldDef.isArray) {
         throw new Error(`Field "${idx}" cannot be indexed (type: ${fieldDef.kind}${fieldDef.isArray ? "[]" : ""})`);
       }
       indices.push(idx);
     }
   }
-  return { _tag: "CollectionDef", name, fields, indices };
+  const eventRetention = options?.eventRetention ?? 1;
+  if (eventRetention < 0 || !Number.isInteger(eventRetention)) {
+    throw new Error(`eventRetention must be a non-negative integer, got ${eventRetention}`);
+  }
+  return { _tag: "CollectionDef", name, fields, indices, eventRetention };
 }
 // src/db/invite.ts
 import { Schema as Schema2 } from "effect";
@@ -212,10 +217,10 @@ class NotFoundError extends Data.TaggedError("NotFoundError") {
 class ClosedError extends Data.TaggedError("ClosedError") {
 }
 // src/svelte/tablinum.svelte.ts
-import { Effect as Effect25, Exit as Exit2, Scope as Scope6 } from "effect";
+import { Effect as Effect25, Exit as Exit2, References as References6, Scope as Scope6 } from "effect";
 
 // src/db/create-tablinum.ts
-import { Effect as Effect22, Layer as Layer9, ServiceMap as ServiceMap10 } from "effect";
+import { Effect as Effect22, Layer as Layer10, References as References4, ServiceMap as ServiceMap10 } from "effect";
 
 // src/db/runtime-config.ts
 import { Effect, Schema as Schema3 } from "effect";
@@ -250,13 +255,13 @@ class Tablinum extends ServiceMap2.Service()("tablinum/Tablinum") {
 }
 
 // src/layers/TablinumLive.ts
-import { Effect as Effect21, Exit, Layer as Layer8, Option as Option9, PubSub as PubSub2, Ref as Ref5, Scope as Scope4 } from "effect";
+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";
 function watchCollection(ctx, storage, collectionName, filter, mapRecord) {
   const query = () => Effect2.map(storage.getAllRecords(collectionName), (all) => {
-    const filtered = all.filter((r) => !r._deleted && (filter ? filter(r) : true));
+    const filtered = all.filter((r) => !r._d && (filter ? filter(r) : true));
     return mapRecord ? filtered.map(mapRecord) : filtered;
   });
   const changes = Stream.fromPubSub(ctx.pubsub).pipe(Stream.filter((event) => event.collection === collectionName), Stream.mapEffect(() => Effect2.gen(function* () {
@@ -301,14 +306,56 @@ function resolveWinner(existing, incoming) {
   return incoming.id < existing.id ? incoming : existing;
 }
 
+// src/utils/diff.ts
+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)) {
+    const t = target[key];
+    const s = source[key];
+    if (isPlainObject(t) && isPlainObject(s)) {
+      result[key] = deepMerge(t, s);
+    } else {
+      result[key] = s;
+    }
+  }
+  return result;
+}
+
 // src/storage/records-store.ts
 function buildRecord(event) {
   return {
     id: event.recordId,
-    _deleted: event.kind === "delete",
-    _updatedAt: event.createdAt,
-    _eventId: event.id,
-    _author: event.author,
+    _d: event.kind === "d",
+    _u: event.createdAt,
+    _e: event.id,
+    _a: event.author,
     ...event.data ?? {}
   };
 }
@@ -317,15 +364,19 @@ function applyEvent(storage, event) {
     const existing = yield* storage.getRecord(event.collection, event.recordId);
     if (existing) {
       const existingMeta = {
-        id: existing._eventId,
-        createdAt: existing._updatedAt
+        id: existing._e,
+        createdAt: existing._u
       };
       const incomingMeta = { id: event.id, createdAt: event.createdAt };
       const winner = resolveWinner(existingMeta, incomingMeta);
       if (winner.id !== event.id)
         return false;
     }
-    yield* storage.putRecord(event.collection, buildRecord(event));
+    if (existing && event.kind === "u") {
+      yield* storage.putRecord(event.collection, deepMerge(existing, buildRecord(event)));
+    } else {
+      yield* storage.putRecord(event.collection, buildRecord(event));
+    }
     return true;
   });
 }
@@ -335,15 +386,11 @@ function rebuild(storage, collections) {
       yield* storage.clearRecords(col);
     }
     const allEvents = yield* storage.getAllEvents();
-    const sorted = [...allEvents].sort((a, b) => a.createdAt - b.createdAt);
-    const winners = new Map;
+    const sorted = [...allEvents].sort((a, b) => a.createdAt - b.createdAt || (a.id < b.id ? -1 : 1));
     for (const event of sorted) {
-      const key = `${event.collection}:${event.recordId}`;
-      const current = winners.get(key) ?? null;
-      winners.set(key, resolveWinner(current, event));
-    }
-    for (const event of winners.values()) {
-      yield* storage.putRecord(event.collection, buildRecord(event));
+      if (event.data === null && event.kind !== "d")
+        continue;
+      yield* applyEvent(storage, event);
     }
   });
 }
@@ -365,6 +412,14 @@ function fieldDefToSchema(fd) {
     case "json":
       base = Schema4.Unknown;
       break;
+    case "object": {
+      const nested = {};
+      for (const [k, v] of Object.entries(fd.fields)) {
+        nested[k] = fieldDefToSchema(v);
+      }
+      base = Schema4.Struct(nested);
+      break;
+    }
   }
   if (fd.isArray) {
     base = Schema4.Array(base);
@@ -414,9 +469,25 @@ function buildPartialValidator(collectionName, def) {
 }
 
 // src/crud/collection-handle.ts
-import { Effect as Effect6, Option as Option3 } from "effect";
+import { Effect as Effect6, Option as Option3, References } from "effect";
 
 // src/utils/uuid.ts
+var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+function toBase64url(bytes) {
+  let result = "";
+  for (let i = 0;i < bytes.length; i += 3) {
+    const b0 = bytes[i];
+    const b1 = bytes[i + 1] ?? 0;
+    const b2 = bytes[i + 2] ?? 0;
+    result += alphabet[b0 >> 2];
+    result += alphabet[(b0 & 3) << 4 | b1 >> 4];
+    if (i + 1 < bytes.length)
+      result += alphabet[(b1 & 15) << 2 | b2 >> 6];
+    if (i + 2 < bytes.length)
+      result += alphabet[b2 & 63];
+  }
+  return result;
+}
 function uuidv7() {
   const now = Date.now();
   const bytes = new Uint8Array(16);
@@ -429,8 +500,7 @@ function uuidv7() {
   bytes[5] = now & 255;
   bytes[6] = bytes[6] & 15 | 112;
   bytes[8] = bytes[8] & 63 | 128;
-  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+  return toBase64url(bytes);
 }
 
 // src/crud/query-builder.ts
@@ -448,7 +518,7 @@ function executeQuery(ctx, plan) {
           field: plan.fieldName
         });
       }
-      if (fieldDef.kind === "json" || fieldDef.isArray) {
+      if (fieldDef.kind === "json" || fieldDef.kind === "object" || fieldDef.isArray) {
         return yield* new ValidationError({
           message: `Field "${plan.fieldName}" does not support filtering (type: ${fieldDef.kind}${fieldDef.isArray ? "[]" : ""})`,
           field: plan.fieldName
@@ -473,7 +543,7 @@ function executeQuery(ctx, plan) {
     } else {
       results = [...yield* ctx.storage.getAllRecords(ctx.collectionName)];
     }
-    results = results.filter((r) => !r._deleted);
+    results = results.filter((r) => !r._d);
     for (const f of plan.filters) {
       results = results.filter(f);
     }
@@ -594,12 +664,62 @@ function createOrderByBuilder(storage, watchCtx, collectionName, def, fieldName,
 }
 
 // src/crud/collection-handle.ts
+var KIND_FULL = { c: "create", u: "update", d: "delete" };
+function sortChronologically(events) {
+  return [...events].sort((a, b) => a.createdAt - b.createdAt || (a.id < b.id ? -1 : 1));
+}
+function replayState(recordId, events, stopAtId) {
+  let state = null;
+  for (const e of events) {
+    if (e.kind === "d") {
+      state = null;
+    } else if (e.data !== null) {
+      if (state === null) {
+        state = { id: recordId, ...e.data };
+      } else {
+        state = deepMerge(state, e.data);
+      }
+    }
+    if (stopAtId !== undefined && e.id === stopAtId) {
+      break;
+    }
+  }
+  return state;
+}
+function promoteToSnapshot(storage, collection2, recordId, target, allSorted) {
+  return Effect6.gen(function* () {
+    const chronological = sortChronologically(allSorted);
+    const state = replayState(recordId, chronological, target.id);
+    if (state) {
+      yield* storage.putEvent({ ...target, data: state });
+    }
+  });
+}
+function pruneEvents(storage, collection2, recordId, retention) {
+  return Effect6.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));
+    const retained = sorted.slice(0, retention);
+    const toStrip = sorted.slice(retention);
+    const oldestRetained = retained[retained.length - 1];
+    if (retention > 0 && oldestRetained?.kind === "u" && oldestRetained.data !== null) {
+      yield* promoteToSnapshot(storage, collection2, recordId, oldestRetained, sorted);
+    }
+    for (const e of toStrip) {
+      if (e.data !== null)
+        yield* storage.stripEventData(e.id);
+    }
+  });
+}
 function mapRecord(record) {
-  const { _deleted, _updatedAt, _author, ...fields } = record;
+  const { _d, _u, _a, _e, ...fields } = record;
   return fields;
 }
-function createCollectionHandle(def, storage, watchCtx, validator, partialValidator, makeEventId, onWrite) {
+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* () {
     yield* storage.putEvent(event);
     yield* applyEvent(storage, event);
@@ -608,11 +728,11 @@ function createCollectionHandle(def, storage, watchCtx, validator, partialValida
     yield* notifyChange(watchCtx, {
       collection: collectionName,
       recordId: event.recordId,
-      kind: event.kind
+      kind: KIND_FULL[event.kind]
     });
   });
   const handle = {
-    add: (data) => Effect6.gen(function* () {
+    add: (data) => withLog(Effect6.gen(function* () {
       const id = uuidv7();
       const fullRecord = { id, ...data };
       yield* validator(fullRecord);
@@ -620,38 +740,44 @@ function createCollectionHandle(def, storage, watchCtx, validator, partialValida
         id: makeEventId(),
         collection: collectionName,
         recordId: id,
-        kind: "create",
+        kind: "c",
         data: fullRecord,
-        createdAt: Date.now()
+        createdAt: Date.now(),
+        author: localAuthor
       };
       yield* commitEvent(event);
+      yield* Effect6.logDebug("Record added", { collection: collectionName, recordId: id, data: fullRecord });
       return id;
-    }),
-    update: (id, data) => Effect6.gen(function* () {
+    })),
+    update: (id, data) => withLog(Effect6.gen(function* () {
       const existing = yield* storage.getRecord(collectionName, id);
-      if (!existing || existing._deleted) {
+      if (!existing || existing._d) {
         return yield* new NotFoundError({
           collection: collectionName,
           id
         });
       }
       yield* partialValidator(data);
-      const { _deleted, _updatedAt, _author, ...existingFields } = existing;
+      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: "update",
-        data: merged,
-        createdAt: Date.now()
+        kind: "u",
+        data: diff ?? { id },
+        createdAt: Date.now(),
+        author: localAuthor
       };
       yield* commitEvent(event);
-    }),
-    delete: (id) => Effect6.gen(function* () {
+      yield* Effect6.logDebug("Record updated", { collection: collectionName, recordId: id, data: diff });
+      yield* pruneEvents(storage, collectionName, id, def.eventRetention);
+    })),
+    delete: (id) => withLog(Effect6.gen(function* () {
       const existing = yield* storage.getRecord(collectionName, id);
-      if (!existing || existing._deleted) {
+      if (!existing || existing._d) {
         return yield* new NotFoundError({
           collection: collectionName,
           id
@@ -661,17 +787,43 @@ function createCollectionHandle(def, storage, watchCtx, validator, partialValida
         id: makeEventId(),
         collection: collectionName,
         recordId: id,
-        kind: "delete",
+        kind: "d",
         data: null,
-        createdAt: Date.now()
+        createdAt: Date.now(),
+        author: localAuthor
+      };
+      yield* commitEvent(event);
+      yield* Effect6.logDebug("Record deleted", { collection: collectionName, recordId: id });
+      yield* pruneEvents(storage, collectionName, id, def.eventRetention);
+    })),
+    undo: (id) => Effect6.gen(function* () {
+      const existing = yield* storage.getRecord(collectionName, id);
+      if (!existing) {
+        return yield* new NotFoundError({ collection: collectionName, id });
+      }
+      const events = sortChronologically(yield* storage.getEventsByRecord(collectionName, id));
+      if (events.length < 2) {
+        return yield* new NotFoundError({ collection: collectionName, id });
+      }
+      const state = replayState(id, events.slice(0, -1));
+      if (!state) {
+        return yield* new NotFoundError({ collection: collectionName, id });
+      }
+      const event = {
+        id: makeEventId(),
+        collection: collectionName,
+        recordId: id,
+        kind: "u",
+        data: state,
+        createdAt: Date.now(),
+        author: localAuthor
       };
       yield* commitEvent(event);
-      const oldEvents = yield* storage.getEventsByRecord(collectionName, id);
-      yield* Effect6.forEach(oldEvents.filter((e) => e.id !== event.id), (e) => storage.deleteEvent(e.id), { discard: true });
+      yield* pruneEvents(storage, collectionName, id, def.eventRetention);
     }),
     get: (id) => Effect6.gen(function* () {
       const record = yield* storage.getRecord(collectionName, id);
-      if (!record || record._deleted) {
+      if (!record || record._d) {
         return yield* new NotFoundError({
           collection: collectionName,
           id
@@ -680,10 +832,10 @@ function createCollectionHandle(def, storage, watchCtx, validator, partialValida
       return mapRecord(record);
     }),
     first: () => Effect6.map(storage.getAllRecords(collectionName), (all) => {
-      const found = all.find((r) => !r._deleted);
+      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._deleted).length),
+    count: () => Effect6.map(storage.getAllRecords(collectionName), (all) => all.filter((r) => !r._d).length),
     watch: () => watchCollection(watchCtx, storage, collectionName, undefined, mapRecord),
     where: (fieldName) => createWhereClause(storage, watchCtx, collectionName, def, fieldName, mapRecord),
     orderBy: (fieldName) => createOrderByBuilder(storage, watchCtx, collectionName, def, fieldName, mapRecord)
@@ -692,7 +844,7 @@ function createCollectionHandle(def, storage, watchCtx, validator, partialValida
 }
 
 // src/sync/sync-service.ts
-import { Effect as Effect8, Option as Option5, Ref as Ref3, Schedule } from "effect";
+import { Effect as Effect8, 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";
 
@@ -1263,8 +1415,13 @@ function reconcileWithRelay(storage, relay, relayUrl, publicKeys) {
         allNeedIds.push(id);
       currentMsg = nextMsg;
     }
+    yield* Effect7.logDebug("Negentropy reconciliation complete", {
+      relay: relayUrl,
+      have: allHaveIds.length,
+      need: allNeedIds.length
+    });
     return { haveIds: allHaveIds, needIds: allNeedIds };
-  });
+  }).pipe(Effect7.withLogSpan("tablinum.negentropy"));
 }
 
 // src/db/key-rotation.ts
@@ -1350,7 +1507,8 @@ function parseRemovalNotice(content, dTag) {
 }
 
 // src/sync/sync-service.ts
-function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStatus, watchCtx, relayUrls, knownCollections, epochStore, personalPrivateKey, personalPublicKey, scope, onSyncError, onNewAuthor, onRemoved, onMembersChanged) {
+function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStatus, watchCtx, relayUrls, knownCollections, epochStore, personalPrivateKey, personalPublicKey, scope, logLevel, onSyncError, onNewAuthor, onRemoved, onMembersChanged) {
+  const logLayer = Layer.succeed(References2.MinimumLogLevel, logLevel);
   const getSubscriptionPubKeys = () => {
     return getAllPublicKeys(epochStore);
   };
@@ -1360,7 +1518,7 @@ function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStat
     kind: "create"
   });
   const forkHandled = (effect) => {
-    Effect8.runFork(effect.pipe(Effect8.tapError((e) => Effect8.sync(() => onSyncError?.(e))), Effect8.ignore, Effect8.forkIn(scope)));
+    Effect8.runFork(effect.pipe(Effect8.tapError((e) => Effect8.sync(() => onSyncError?.(e))), Effect8.ignore, Effect8.provide(logLayer), Effect8.forkIn(scope)));
   };
   let autoFlushActive = false;
   const autoFlushEffect = Effect8.gen(function* () {
@@ -1409,19 +1567,21 @@ function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStat
     }
     const collectionName = dTag.substring(0, colonIdx);
     const recordId = dTag.substring(colonIdx + 1);
-    if (!knownCollections.has(collectionName)) {
+    const retention = knownCollections.get(collectionName);
+    if (retention === undefined) {
       yield* storage.putGiftWrap({ id: remoteGw.id, createdAt: remoteGw.created_at });
       return null;
     }
     if (rumor.pubkey) {
       const reject = yield* shouldRejectWrite(rumor.pubkey);
       if (reject) {
+        yield* Effect8.logWarning("Rejected write from removed member", { author: rumor.pubkey.slice(0, 12) });
         yield* storage.putGiftWrap({ id: remoteGw.id, createdAt: remoteGw.created_at });
         return null;
       }
     }
     let data = null;
-    let kind = "update";
+    let kind = "u";
     const parsed = yield* Effect8.try({
       try: () => JSON.parse(rumor.content),
       catch: () => {
@@ -1435,7 +1595,7 @@ function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStat
       return null;
     }
     if (parsed === null || parsed._deleted) {
-      kind = "delete";
+      kind = "d";
     } else {
       data = parsed;
     }
@@ -1451,15 +1611,14 @@ function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStat
     };
     yield* storage.putGiftWrap({
       id: remoteGw.id,
-      eventId: event.id,
       createdAt: remoteGw.created_at
     });
     yield* storage.putEvent(event);
     const didApply = yield* applyEvent(storage, event);
-    if (kind === "delete" && didApply) {
-      const oldEvents = yield* storage.getEventsByRecord(collectionName, recordId);
-      yield* Effect8.forEach(oldEvents.filter((e) => e.id !== event.id), (e) => storage.deleteEvent(e.id), { discard: true });
+    if (didApply && (kind === "u" || kind === "d")) {
+      yield* pruneEvents(storage, collectionName, recordId, retention);
     }
+    yield* Effect8.logDebug("Processed gift wrap", { collection: collectionName, recordId, kind, author: author?.slice(0, 12) });
     if (author && onNewAuthor) {
       onNewAuthor(author);
     }
@@ -1528,15 +1687,18 @@ function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStat
     }).pipe(Effect8.tapError((err) => Effect8.sync(() => onSyncError?.(err))), Effect8.ignore);
   }), { discard: true });
   const syncRelay = (url, pubKeys, changedCollections) => Effect8.gen(function* () {
+    yield* Effect8.logDebug("Syncing relay", { relay: url });
     const reconcileResult = yield* Effect8.result(reconcileWithRelay(storage, relay, url, Array.from(pubKeys)));
     if (reconcileResult._tag === "Failure") {
       onSyncError?.(reconcileResult.failure);
       return;
     }
     const { haveIds, needIds } = reconcileResult.success;
+    yield* Effect8.logDebug("Relay reconciliation result", { relay: url, need: needIds.length, have: haveIds.length });
     if (needIds.length > 0) {
       const fetched = yield* relay.fetchEvents(needIds, url).pipe(Effect8.tapError((err) => Effect8.sync(() => onSyncError?.(err))), Effect8.orElseSucceed(() => []));
-      yield* Effect8.forEach(fetched, (remoteGw) => Effect8.gen(function* () {
+      const sorted = [...fetched].sort((a, b) => a.created_at - b.created_at);
+      yield* Effect8.forEach(sorted, (remoteGw) => Effect8.gen(function* () {
         const collection2 = yield* processGiftWrap(remoteGw).pipe(Effect8.orElseSucceed(() => null));
         if (collection2)
           changedCollections.add(collection2);
@@ -1550,9 +1712,10 @@ function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStat
         yield* relay.publish(gw.event, [url]).pipe(Effect8.andThen(storage.stripGiftWrapBlob(id)), Effect8.tapError((err) => Effect8.sync(() => onSyncError?.(err))), Effect8.ignore);
       }), { discard: true });
     }
-  });
+  }).pipe(Effect8.withLogSpan("tablinum.syncRelay"));
   const handle = {
     sync: () => Effect8.gen(function* () {
+      yield* Effect8.logInfo("Sync started");
       yield* syncStatus.set("syncing");
       yield* Ref3.set(watchCtx.replayingRef, true);
       const changedCollections = new Set;
@@ -1566,7 +1729,8 @@ function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStat
         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* () {
       if (!giftWrap.event)
         return;
@@ -1627,7 +1791,8 @@ var membersCollectionDef = {
     removedAt: optionalNumber,
     removedInEpoch: optionalString
   },
-  indices: []
+  indices: [],
+  eventRetention: 1
 };
 var AuthorProfileSchema = Schema6.Struct({
   name: Schema6.optionalKey(Schema6.String),
@@ -1691,7 +1856,7 @@ class SyncStatus extends ServiceMap9.Service()("tablinum/SyncStatus") {
 }
 
 // src/layers/IdentityLive.ts
-import { Effect as Effect11, Layer } from "effect";
+import { Effect as Effect11, Layer as Layer2 } from "effect";
 import { hexToBytes as hexToBytes3 } from "@noble/hashes/utils.js";
 
 // src/db/identity.ts
@@ -1729,21 +1894,25 @@ function createIdentity(suppliedKey) {
 }
 
 // src/layers/IdentityLive.ts
-var IdentityLive = Layer.effect(Identity, Effect11.gen(function* () {
+var IdentityLive = Layer2.effect(Identity, Effect11.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) : undefined);
   const identity = yield* createIdentity(resolvedKey);
   yield* storage.putMeta("identity_key", identity.exportKey());
+  yield* Effect11.logInfo("Identity loaded", {
+    publicKey: identity.publicKey.slice(0, 12) + "...",
+    source: config.privateKey ? "config" : resolvedKey ? "storage" : "generated"
+  });
   return identity;
 }));
 
 // src/layers/EpochStoreLive.ts
-import { Effect as Effect12, Layer as Layer2, Option as Option7 } from "effect";
+import { Effect as Effect12, 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";
-var EpochStoreLive = Layer2.effect(EpochStore, Effect12.gen(function* () {
+var EpochStoreLive = Layer3.effect(EpochStore, Effect12.gen(function* () {
   const config = yield* Config;
   const identity = yield* Identity;
   const storage = yield* Storage;
@@ -1751,21 +1920,24 @@ var EpochStoreLive = Layer2.effect(EpochStore, Effect12.gen(function* () {
   if (typeof idbRaw === "string") {
     const idbStore = deserializeEpochStore(idbRaw);
     if (Option7.isSome(idbStore)) {
+      yield* Effect12.logInfo("Epoch store loaded", { source: "storage", epochs: idbStore.value.epochs.size });
       return idbStore.value;
     }
   }
   if (config.epochKeys && config.epochKeys.length > 0) {
     const store2 = createEpochStoreFromInputs(config.epochKeys);
     yield* storage.putMeta("epochs", stringifyEpochStore(store2));
+    yield* Effect12.logInfo("Epoch store loaded", { source: "config", epochs: store2.epochs.size });
     return store2;
   }
   const store = createEpochStoreFromInputs([{ epochId: EpochId("epoch-0"), key: bytesToHex3(generateSecretKey2()) }], { createdBy: identity.publicKey });
   yield* storage.putMeta("epochs", stringifyEpochStore(store));
+  yield* Effect12.logInfo("Epoch store loaded", { source: "generated", epochs: store.epochs.size });
   return store;
 }));
 
 // src/layers/StorageLive.ts
-import { Effect as Effect14, Layer as Layer3 } from "effect";
+import { Effect as Effect14, Layer as Layer4 } from "effect";
 
 // src/storage/idb.ts
 import { Effect as Effect13 } from "effect";
@@ -1900,13 +2072,18 @@ function openIDBStorage(dbName, schema) {
       stripGiftWrapBlob: (id) => wrap("stripGiftWrapBlob", async () => {
         const existing = await db.get("giftwraps", id);
         if (existing) {
-          const { event: _, ...tombstone } = existing;
-          await db.put("giftwraps", tombstone);
+          await db.put("giftwraps", { id: existing.id, createdAt: existing.createdAt });
         }
       }),
       deleteEvent: (id) => wrap("deleteEvent", () => db.delete("events", id).then(() => {
         return;
       })),
+      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(() => {
         return;
@@ -1918,16 +2095,18 @@ function openIDBStorage(dbName, schema) {
 }
 
 // src/layers/StorageLive.ts
-var StorageLive = Layer3.effect(Storage, Effect14.gen(function* () {
+var StorageLive = Layer4.effect(Storage, Effect14.gen(function* () {
   const config = yield* Config;
-  return yield* openIDBStorage(config.dbName, {
+  const handle = yield* openIDBStorage(config.dbName, {
     ...config.schema,
     _members: membersCollectionDef
   });
+  yield* Effect14.logInfo("Storage opened", { dbName: config.dbName });
+  return handle;
 }));
 
 // src/layers/RelayLive.ts
-import { Layer as Layer4 } from "effect";
+import { Layer as Layer5 } from "effect";
 
 // src/sync/relay.ts
 import { Effect as Effect15, Option as Option8, Schema as Schema7, ScopedCache, Scope as Scope3 } from "effect";
@@ -2140,10 +2319,10 @@ function createRelayHandle() {
 }
 
 // src/layers/RelayLive.ts
-var RelayLive = Layer4.effect(Relay, createRelayHandle());
+var RelayLive = Layer5.effect(Relay, createRelayHandle());
 
 // src/layers/GiftWrapLive.ts
-import { Effect as Effect17, Layer as Layer5 } from "effect";
+import { Effect as Effect17, Layer as Layer6 } from "effect";
 
 // src/sync/gift-wrap.ts
 import { Effect as Effect16 } from "effect";
@@ -2180,14 +2359,14 @@ function createEpochGiftWrapHandle(senderPrivateKey, epochStore) {
 }
 
 // src/layers/GiftWrapLive.ts
-var GiftWrapLive = Layer5.effect(GiftWrap3, Effect17.gen(function* () {
+var GiftWrapLive = Layer6.effect(GiftWrap3, Effect17.gen(function* () {
   const identity = yield* Identity;
   const epochStore = yield* EpochStore;
   return createEpochGiftWrapHandle(identity.privateKey, epochStore);
 }));
 
 // src/layers/PublishQueueLive.ts
-import { Effect as Effect19, Layer as Layer6 } from "effect";
+import { Effect as Effect19, Layer as Layer7 } from "effect";
 
 // src/sync/publish-queue.ts
 import { Effect as Effect18, Ref as Ref4 } from "effect";
@@ -2261,14 +2440,14 @@ function createPublishQueue(storage, relay) {
 }
 
 // src/layers/PublishQueueLive.ts
-var PublishQueueLive = Layer6.effect(PublishQueue, Effect19.gen(function* () {
+var PublishQueueLive = Layer7.effect(PublishQueue, Effect19.gen(function* () {
   const storage = yield* Storage;
   const relay = yield* Relay;
   return yield* createPublishQueue(storage, relay);
 }));
 
 // src/layers/SyncStatusLive.ts
-import { Layer as Layer7 } from "effect";
+import { Layer as Layer8 } from "effect";
 
 // src/sync/sync-status.ts
 import { Effect as Effect20, SubscriptionRef } from "effect";
@@ -2292,7 +2471,7 @@ function createSyncStatusHandle() {
 }
 
 // src/layers/SyncStatusLive.ts
-var SyncStatusLive = Layer7.effect(SyncStatus, createSyncStatusHandle());
+var SyncStatusLive = Layer8.effect(SyncStatus, createSyncStatusHandle());
 
 // src/layers/TablinumLive.ts
 function reportSyncError(onSyncError, error) {
@@ -2313,12 +2492,12 @@ function mapMemberRecord(record) {
     ...record.removedInEpoch !== undefined ? { removedInEpoch: record.removedInEpoch } : {}
   };
 }
-var IdentityWithDeps = IdentityLive.pipe(Layer8.provide(StorageLive));
-var EpochStoreWithDeps = EpochStoreLive.pipe(Layer8.provide(IdentityWithDeps), Layer8.provide(StorageLive));
-var GiftWrapWithDeps = GiftWrapLive.pipe(Layer8.provide(IdentityWithDeps), Layer8.provide(EpochStoreWithDeps));
-var PublishQueueWithDeps = PublishQueueLive.pipe(Layer8.provide(StorageLive), Layer8.provide(RelayLive));
-var AllServicesLive = Layer8.mergeAll(IdentityWithDeps, EpochStoreWithDeps, StorageLive, RelayLive, GiftWrapWithDeps, PublishQueueWithDeps, SyncStatusLive);
-var TablinumLive = Layer8.effect(Tablinum, Effect21.gen(function* () {
+var IdentityWithDeps = IdentityLive.pipe(Layer9.provide(StorageLive));
+var EpochStoreWithDeps = EpochStoreLive.pipe(Layer9.provide(IdentityWithDeps), Layer9.provide(StorageLive));
+var GiftWrapWithDeps = GiftWrapLive.pipe(Layer9.provide(IdentityWithDeps), Layer9.provide(EpochStoreWithDeps));
+var PublishQueueWithDeps = PublishQueueLive.pipe(Layer9.provide(StorageLive), Layer9.provide(RelayLive));
+var AllServicesLive = Layer9.mergeAll(IdentityWithDeps, EpochStoreWithDeps, StorageLive, RelayLive, GiftWrapWithDeps, PublishQueueWithDeps, SyncStatusLive);
+var TablinumLive = Layer9.effect(Tablinum, Effect21.gen(function* () {
   const config = yield* Config;
   const identity = yield* Identity;
   const epochStore = yield* EpochStore;
@@ -2328,17 +2507,18 @@ var TablinumLive = Layer8.effect(Tablinum, Effect21.gen(function* () {
   const publishQueue = yield* PublishQueue;
   const syncStatus = yield* SyncStatus;
   const scope = yield* Effect21.scope;
+  const logLayer = Layer9.succeed(References3.MinimumLogLevel, config.logLevel);
   const pubsub = yield* PubSub2.unbounded();
   const replayingRef = yield* Ref5.make(false);
   const closedRef = yield* Ref5.make(false);
   const watchCtx = { pubsub, replayingRef };
   const schemaEntries = Object.entries(config.schema);
   const allSchemaEntries = [...schemaEntries, ["_members", membersCollectionDef]];
-  const knownCollections = new Set(allSchemaEntries.map(([, def]) => def.name));
+  const knownCollections = new Map(allSchemaEntries.map(([, def]) => [def.name, def.eventRetention]));
   let notifyAuthor;
-  const syncHandle = createSyncHandle(storage, giftWrap, relay, publishQueue, syncStatus, watchCtx, config.relays, knownCollections, epochStore, identity.privateKey, identity.publicKey, scope, config.onSyncError ? (error) => reportSyncError(config.onSyncError, error) : undefined, (pubkey) => notifyAuthor?.(pubkey), config.onRemoved, config.onMembersChanged);
+  const syncHandle = createSyncHandle(storage, giftWrap, relay, publishQueue, syncStatus, watchCtx, config.relays, knownCollections, epochStore, identity.privateKey, identity.publicKey, scope, config.logLevel, config.onSyncError ? (error) => reportSyncError(config.onSyncError, error) : undefined, (pubkey) => notifyAuthor?.(pubkey), config.onRemoved, config.onMembersChanged);
   const onWrite = (event) => Effect21.gen(function* () {
-    const content = event.kind === "delete" ? JSON.stringify({ _deleted: true }) : JSON.stringify(event.data);
+    const content = event.kind === "d" ? JSON.stringify(null) : JSON.stringify(event.data);
     const dTag = `${event.collection}:${event.recordId}`;
     const wrapResult = yield* Effect21.result(giftWrap.wrap({
       kind: 1,
@@ -2351,11 +2531,10 @@ var TablinumLive = Layer8.effect(Tablinum, Effect21.gen(function* () {
       return;
     }
     const gw = wrapResult.success;
-    yield* storage.putGiftWrap({ id: gw.id, eventId: event.id, createdAt: gw.created_at });
+    yield* storage.putGiftWrap({ id: gw.id, createdAt: gw.created_at });
     yield* Effect21.forkIn(Effect21.gen(function* () {
       const publishResult = yield* Effect21.result(syncHandle.publishLocal({
         id: gw.id,
-        eventId: event.id,
         event: gw,
         createdAt: gw.created_at
       }));
@@ -2371,9 +2550,10 @@ var TablinumLive = Layer8.effect(Tablinum, Effect21.gen(function* () {
       id: uuidv7(),
       collection: "_members",
       recordId: record.id,
-      kind: existing ? "update" : "create",
+      kind: existing ? "u" : "c",
       data: record,
-      createdAt: Date.now()
+      createdAt: Date.now(),
+      author: identity.publicKey
     };
     yield* storage.putEvent(event);
     yield* applyEvent(storage, event);
@@ -2414,16 +2594,21 @@ var TablinumLive = Layer8.effect(Tablinum, Effect21.gen(function* () {
           config.onMembersChanged?.();
         }
       }
-    }).pipe(Effect21.ignore, Effect21.forkIn(scope)));
+    }).pipe(Effect21.ignore, Effect21.provide(logLayer), Effect21.forkIn(scope)));
   };
   const handles = new Map;
   for (const [, def] of allSchemaEntries) {
     const validator = buildValidator(def.name, def);
     const partialValidator = buildPartialValidator(def.name, def);
-    const handle = createCollectionHandle(def, storage, watchCtx, validator, partialValidator, uuidv7, onWrite);
+    const handle = createCollectionHandle(def, storage, watchCtx, validator, partialValidator, uuidv7, identity.publicKey, onWrite, config.logLevel);
     handles.set(def.name, handle);
   }
   yield* syncHandle.startSubscription();
+  yield* Effect21.logInfo("Tablinum ready", {
+    dbName: config.dbName,
+    collections: schemaEntries.map(([name]) => name),
+    relays: config.relays
+  });
   const selfMember = yield* storage.getRecord("_members", identity.publicKey);
   if (!selfMember) {
     yield* putMemberRecord({
@@ -2432,18 +2617,19 @@ var TablinumLive = Layer8.effect(Tablinum, Effect21.gen(function* () {
       addedInEpoch: getCurrentEpoch(epochStore).id
     });
   }
-  const ensureOpen = (effect) => Effect21.gen(function* () {
+  const withLog = (effect) => Effect21.provideService(effect, References3.MinimumLogLevel, config.logLevel);
+  const ensureOpen = (effect) => withLog(Effect21.gen(function* () {
     if (yield* Ref5.get(closedRef)) {
       return yield* new StorageError({ message: "Database is closed" });
     }
     return yield* effect;
-  });
-  const ensureSyncOpen = (effect) => Effect21.gen(function* () {
+  }));
+  const ensureSyncOpen = (effect) => withLog(Effect21.gen(function* () {
     if (yield* Ref5.get(closedRef)) {
       return yield* new SyncError({ message: "Database is closed", phase: "init" });
     }
     return yield* effect;
-  });
+  }));
   const dbHandle = {
     collection: (name) => {
       const handle = handles.get(name);
@@ -2459,12 +2645,12 @@ var TablinumLive = Layer8.effect(Tablinum, Effect21.gen(function* () {
       relays: [...config.relays],
       dbName: config.dbName
     }),
-    close: () => Effect21.gen(function* () {
+    close: () => withLog(Effect21.gen(function* () {
       if (yield* Ref5.get(closedRef))
         return;
       yield* Ref5.set(closedRef, true);
       yield* Scope4.close(scope, Exit.void);
-    }),
+    })),
     rebuild: () => ensureOpen(rebuild(storage, allSchemaEntries.map(([, def]) => def.name))),
     sync: () => ensureSyncOpen(syncHandle.sync()),
     getSyncStatus: () => syncStatus.get(),
@@ -2508,20 +2694,52 @@ var TablinumLive = Layer8.effect(Tablinum, Effect21.gen(function* () {
     })),
     getMembers: () => ensureOpen(Effect21.gen(function* () {
       const allRecords = yield* storage.getAllRecords("_members");
-      return allRecords.filter((record) => !record._deleted).map(mapMemberRecord);
+      return allRecords.filter((record) => !record._d).map(mapMemberRecord);
+    })),
+    getProfile: () => ensureOpen(Effect21.gen(function* () {
+      const record = yield* storage.getRecord("_members", identity.publicKey);
+      if (!record)
+        return {};
+      const profile = {};
+      if (record.name !== undefined)
+        profile.name = record.name;
+      if (record.picture !== undefined)
+        profile.picture = record.picture;
+      if (record.about !== undefined)
+        profile.about = record.about;
+      if (record.nip05 !== undefined)
+        profile.nip05 = record.nip05;
+      return profile;
     })),
     setProfile: (profile) => ensureOpen(Effect21.gen(function* () {
       const existing = yield* storage.getRecord("_members", identity.publicKey);
       if (!existing) {
         return yield* new ValidationError({ message: "Current user is not a member" });
       }
-      yield* putMemberRecord({ ...existing, ...profile });
+      const { _d, _u, _a, _e, ...memberFields } = existing;
+      yield* putMemberRecord({ ...memberFields, ...profile });
     }))
   };
   return dbHandle;
-})).pipe(Layer8.provide(AllServicesLive));
+}).pipe(Effect21.withLogSpan("tablinum.init"))).pipe(Layer9.provide(AllServicesLive));
 
 // src/db/create-tablinum.ts
+function resolveLogLevel(input) {
+  if (input === undefined || input === "none")
+    return "None";
+  switch (input) {
+    case "debug":
+      return "Debug";
+    case "info":
+      return "Info";
+    case "warning":
+      return "Warn";
+    case "error":
+      return "Error";
+    default:
+      return input;
+  }
+}
 function validateConfig(config) {
   return Effect22.gen(function* () {
     if (Object.keys(config.schema).length === 0) {
@@ -2535,22 +2753,25 @@ function createTablinum(config) {
   return Effect22.gen(function* () {
     yield* validateConfig(config);
     const runtimeConfig = yield* resolveRuntimeConfig(config);
+    const logLevel = resolveLogLevel(config.logLevel);
     const configValue = {
       ...runtimeConfig,
       schema: config.schema,
+      logLevel,
       onSyncError: config.onSyncError,
       onRemoved: config.onRemoved,
       onMembersChanged: config.onMembersChanged
     };
-    const configLayer = Layer9.succeed(Config, configValue);
-    const fullLayer = TablinumLive.pipe(Layer9.provide(configLayer));
-    const ctx = yield* Layer9.build(fullLayer);
+    const configLayer = Layer10.succeed(Config, configValue);
+    const logLayer = Layer10.succeed(References4.MinimumLogLevel, logLevel);
+    const fullLayer = TablinumLive.pipe(Layer10.provide(configLayer), Layer10.provide(logLayer));
+    const ctx = yield* Layer10.build(fullLayer);
     return ServiceMap10.get(ctx, Tablinum);
   });
 }
 
 // src/svelte/collection.svelte.ts
-import { Effect as Effect24, Fiber, Option as Option11, Stream as Stream4 } from "effect";
+import { Effect as Effect24, Fiber, Option as Option11, References as References5, Stream as Stream4 } from "effect";
 
 // src/svelte/deferred.ts
 function createDeferred() {
@@ -2643,10 +2864,12 @@ class Collection {
   #version = $state(0);
   #watchAbort = null;
   #watchFiber = null;
-  _bind(handle) {
+  #logLevel = "None";
+  _bind(handle, logLevel = "None") {
     if (this.#handle)
       return;
     this.#handle = handle;
+    this.#logLevel = logLevel;
     this.error = null;
     this.#settleReady();
     this.#startWatch();
@@ -2675,7 +2898,7 @@ class Collection {
       if (!abort.signal.aborted) {
         this.error = e instanceof Error ? e : new Error(String(e));
       }
-    }))));
+    })), Effect24.provideService(References5.MinimumLogLevel, this.#logLevel)));
   }
   #touchVersion = () => {
     this.#version;
@@ -2687,7 +2910,7 @@ class Collection {
   };
   #run = async (getEffect) => {
     await this.#ready.promise;
-    return Effect24.runPromise(getEffect());
+    return Effect24.runPromise(getEffect().pipe(Effect24.provideService(References5.MinimumLogLevel, this.#logLevel)));
   };
   add = (data) => {
     return this.#run(() => this.#handleOrThrow().add(data));
@@ -2698,6 +2921,9 @@ class Collection {
   delete = (id) => {
     return this.#run(() => this.#handleOrThrow().delete(id));
   };
+  undo = (id) => {
+    return this.#run(() => this.#handleOrThrow().undo(id));
+  };
   get(id) {
     if (typeof id === "string") {
       return this.#run(() => this.#handleOrThrow().get(id));
@@ -2751,8 +2977,10 @@ class Tablinum2 {
   #unsubscribeRelayStatus = null;
   #closed = false;
   #readyState = createDeferred();
+  #logLevel;
   constructor(config) {
     this.ready = this.#readyState.promise;
+    this.#logLevel = resolveLogLevel(config.logLevel);
     this.#init(config);
   }
   #settleReady(err) {
@@ -2763,16 +2991,16 @@ class Tablinum2 {
     }
   }
   #bindCollections(handle) {
-    this.#members._bind(handle.members);
+    this.#members._bind(handle.members, this.#logLevel);
     for (const [name, collection2] of this.#collections) {
-      collection2._bind(handle.collection(name));
+      collection2._bind(handle.collection(name), this.#logLevel);
     }
   }
   #runHandleEffect = async (run) => {
     const handle = this.#requireReady();
     try {
       this.error = null;
-      return await Effect25.runPromise(run(handle));
+      return await Effect25.runPromise(run(handle).pipe(Effect25.provideService(References6.MinimumLogLevel, this.#logLevel)));
     } catch (e) {
       this.error = e instanceof Error ? e : new Error(String(e));
       throw this.error;
@@ -2830,7 +3058,7 @@ class Tablinum2 {
       col = new Collection;
       this.#collections.set(name, col);
       if (this.#handle) {
-        col._bind(this.#handle.collection(name));
+        col._bind(this.#handle.collection(name), this.#logLevel);
       }
     }
     return col;
@@ -2889,6 +3117,7 @@ class Tablinum2 {
   addMember = async (pubkey) => this.#runHandleEffect((handle) => handle.addMember(pubkey));
   removeMember = async (pubkey) => this.#runHandleEffect((handle) => handle.removeMember(pubkey));
   getMembers = async () => this.#runHandleEffect((handle) => handle.getMembers());
+  getProfile = async () => this.#runHandleEffect((handle) => handle.getProfile());
   setProfile = async (profile) => this.#runHandleEffect((handle) => handle.setProfile(profile));
 }
 export {