tablinum 0.4.0 → 0.6.0

package/dist/svelte/index.svelte.js

@@ -1,14 +1,13 @@
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
-  if (typeof require !== "undefined")
-    return require.apply(this, arguments);
+  if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
 // src/schema/field.ts
 function make(kind, isOptional, isArray, fields) {
-  return { _tag: "FieldDef", kind, isOptional, isArray, ...fields !== undefined && { fields } };
+  return { _tag: "FieldDef", kind, isOptional, isArray, ...fields !== void 0 && { fields } };
 }
 var field = {
   string: () => make("string", false, false),
@@ -19,8 +18,9 @@ var field = {
   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", "_d", "_u", "_e", "_a"]);
+var RESERVED_NAMES = /* @__PURE__ */ 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");
@@ -42,7 +42,9 @@ function collection(name, fields, options) {
         throw new Error(`Index field "${idx}" does not exist in collection "${name}"`);
       }
       if (fieldDef.kind === "json" || fieldDef.kind === "object" || fieldDef.isArray) {
-        throw new Error(`Field "${idx}" cannot be indexed (type: ${fieldDef.kind}${fieldDef.isArray ? "[]" : ""})`);
+        throw new Error(
+          `Field "${idx}" cannot be indexed (type: ${fieldDef.kind}${fieldDef.isArray ? "[]" : ""})`
+        );
       }
       indices.push(idx);
     }
@@ -53,6 +55,7 @@ function collection(name, fields, options) {
   }
   return { _tag: "CollectionDef", name, fields, indices, eventRetention };
 }
+
 // src/db/invite.ts
 import { Schema as Schema2 } from "effect";
 
@@ -82,15 +85,17 @@ var PersistedEpochStoreSchema = Schema.Struct({
   epochs: Schema.Array(PersistedEpochSchema),
   currentEpochId: Schema.String
 });
-var decodePersistedEpochStore = Schema.decodeUnknownSync(Schema.fromJsonString(PersistedEpochStoreSchema));
+var decodePersistedEpochStore = Schema.decodeUnknownSync(
+  Schema.fromJsonString(PersistedEpochStoreSchema)
+);
 function createEpochKey(id, privateKeyHex, createdBy, parentEpoch) {
   const publicKey = getPublicKey(hexToBytes(privateKeyHex));
   const base = { id, privateKey: privateKeyHex, publicKey, createdBy };
-  return parentEpoch !== undefined ? { ...base, parentEpoch } : base;
+  return parentEpoch !== void 0 ? { ...base, parentEpoch } : base;
 }
 function createEpochStore(initialEpoch) {
-  const epochs = new Map;
-  const keysByPublicKey = new Map;
+  const epochs = /* @__PURE__ */ new Map();
+  const keysByPublicKey = /* @__PURE__ */ new Map();
   epochs.set(initialEpoch.id, initialEpoch);
   keysByPublicKey.set(initialEpoch.publicKey, hexToBytes(initialEpoch.privateKey));
   return { epochs, keysByPublicKey, currentEpochId: initialEpoch.id };
@@ -100,7 +105,14 @@ function addEpoch(store, epoch) {
   store.keysByPublicKey.set(epoch.publicKey, hexToBytes(epoch.privateKey));
 }
 function hydrateEpochStore(snapshot) {
-  const [firstEpoch, ...remainingEpochs] = snapshot.epochs.map((epoch) => createEpochKey(EpochId(epoch.id), epoch.privateKey, epoch.createdBy, epoch.parentEpoch !== undefined ? EpochId(epoch.parentEpoch) : undefined));
+  const [firstEpoch, ...remainingEpochs] = snapshot.epochs.map(
+    (epoch) => createEpochKey(
+      EpochId(epoch.id),
+      epoch.privateKey,
+      epoch.createdBy,
+      epoch.parentEpoch !== void 0 ? EpochId(epoch.parentEpoch) : void 0
+    )
+  );
   if (!firstEpoch) {
     throw new Error("Epoch snapshot must contain at least one epoch");
   }
@@ -116,9 +128,16 @@ function createEpochStoreFromInputs(epochKeys, options = {}) {
     throw new Error("Epoch input must contain at least one key");
   }
   const createdBy = options.createdBy ?? "";
-  const epochs = epochKeys.map((epochKey, index) => createEpochKey(epochKey.epochId, epochKey.key, createdBy, index > 0 ? epochKeys[index - 1].epochId : undefined));
+  const epochs = epochKeys.map(
+    (epochKey, index) => createEpochKey(
+      epochKey.epochId,
+      epochKey.key,
+      createdBy,
+      index > 0 ? epochKeys[index - 1].epochId : void 0
+    )
+  );
   const store = createEpochStore(epochs[0]);
-  for (let i = 1;i < epochs.length; i++) {
+  for (let i = 1; i < epochs.length; i++) {
     addEpoch(store, epochs[i]);
   }
   store.currentEpochId = epochs[epochs.length - 1].id;
@@ -145,7 +164,7 @@ function serializeEpochStore(store) {
       id: epoch.id,
       privateKey: epoch.privateKey,
       createdBy: epoch.createdBy,
-      ...epoch.parentEpoch !== undefined ? { parentEpoch: epoch.parentEpoch } : {}
+      ...epoch.parentEpoch !== void 0 ? { parentEpoch: epoch.parentEpoch } : {}
     })),
     currentEpochId: store.currentEpochId
   };
@@ -193,34 +212,29 @@ function decodeInvite(encoded) {
     throw new Error("Invalid invite: unexpected shape");
   }
 }
+
 // src/errors.ts
 import { Data } from "effect";
+var ValidationError = class extends Data.TaggedError("ValidationError") {
+};
+var StorageError = class extends Data.TaggedError("StorageError") {
+};
+var CryptoError = class extends Data.TaggedError("CryptoError") {
+};
+var RelayError = class extends Data.TaggedError("RelayError") {
+};
+var SyncError = class extends Data.TaggedError("SyncError") {
+};
+var NotFoundError = class extends Data.TaggedError("NotFoundError") {
+};
+var ClosedError = class extends Data.TaggedError("ClosedError") {
+};
 
-class ValidationError extends Data.TaggedError("ValidationError") {
-}
-
-class StorageError extends Data.TaggedError("StorageError") {
-}
-
-class CryptoError extends Data.TaggedError("CryptoError") {
-}
-
-class RelayError extends Data.TaggedError("RelayError") {
-}
-
-class SyncError extends Data.TaggedError("SyncError") {
-}
-
-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";
@@ -232,49 +246,61 @@ var RuntimeConfigSchema = Schema3.Struct({
   epochKeys: Schema3.optional(Schema3.Array(EpochKeyInputSchema))
 });
 function resolveRuntimeConfig(source) {
-  return Schema3.decodeUnknownEffect(RuntimeConfigSchema)(source).pipe(Effect.map((config) => ({
-    relays: [...config.relays],
-    privateKey: config.privateKey,
-    epochKeys: config.epochKeys?.map((ek) => ({ epochId: EpochId(ek.epochId), key: ek.key })),
-    dbName: DatabaseName(config.dbName ?? "tablinum")
-  })), Effect.mapError((error) => new ValidationError({
-    message: `Invalid Tablinum configuration: ${error.message}`
-  })));
+  return Schema3.decodeUnknownEffect(RuntimeConfigSchema)(source).pipe(
+    Effect.map((config) => ({
+      relays: [...config.relays],
+      privateKey: config.privateKey,
+      epochKeys: config.epochKeys?.map((ek) => ({ epochId: EpochId(ek.epochId), key: ek.key })),
+      dbName: DatabaseName(config.dbName ?? "tablinum")
+    })),
+    Effect.mapError(
+      (error) => new ValidationError({
+        message: `Invalid Tablinum configuration: ${error.message}`
+      })
+    )
+  );
 }
 
 // src/services/Config.ts
 import { ServiceMap } from "effect";
-
-class Config extends ServiceMap.Service()("tablinum/Config") {
-}
+var Config = class extends ServiceMap.Service()("tablinum/Config") {
+};
 
 // src/services/Tablinum.ts
 import { ServiceMap as ServiceMap2 } from "effect";
-
-class Tablinum extends ServiceMap2.Service()("tablinum/Tablinum") {
-}
+var Tablinum = class 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) {
+function watchCollection(ctx, storage, collectionName, filter, mapRecord2) {
   const query = () => Effect2.map(storage.getAllRecords(collectionName), (all) => {
     const filtered = all.filter((r) => !r._d && (filter ? filter(r) : true));
-    return mapRecord ? filtered.map(mapRecord) : filtered;
+    return mapRecord2 ? filtered.map(mapRecord2) : filtered;
   });
-  const changes = Stream.fromPubSub(ctx.pubsub).pipe(Stream.filter((event) => event.collection === collectionName), Stream.mapEffect(() => Effect2.gen(function* () {
-    const replaying = yield* Ref.get(ctx.replayingRef);
-    if (replaying)
-      return;
-    return yield* query();
-  })), Stream.filter((result) => result !== undefined));
-  return Stream.unwrap(Effect2.gen(function* () {
-    yield* Effect2.sleep(0);
-    const initial = yield* query();
-    return Stream.concat(Stream.make(initial), changes);
-  }));
+  const changes = Stream.fromPubSub(ctx.pubsub).pipe(
+    Stream.filter((event) => event.collection === collectionName),
+    Stream.mapEffect(
+      () => Effect2.gen(function* () {
+        const replaying = yield* Ref.get(ctx.replayingRef);
+        if (replaying) return void 0;
+        return yield* query();
+      })
+    ),
+    Stream.filter((result) => result !== void 0)
+  );
+  return Stream.unwrap(
+    Effect2.gen(function* () {
+      yield* Effect2.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);
@@ -297,12 +323,9 @@ import { Effect as Effect3 } from "effect";
 
 // src/storage/lww.ts
 function resolveWinner(existing, incoming) {
-  if (existing === null)
-    return incoming;
-  if (incoming.createdAt > existing.createdAt)
-    return incoming;
-  if (incoming.createdAt < existing.createdAt)
-    return existing;
+  if (existing === null) return incoming;
+  if (incoming.createdAt > existing.createdAt) return incoming;
+  if (incoming.createdAt < existing.createdAt) return existing;
   return incoming.id < existing.id ? incoming : existing;
 }
 
@@ -369,8 +392,7 @@ function applyEvent(storage, event) {
       };
       const incomingMeta = { id: event.id, createdAt: event.createdAt };
       const winner = resolveWinner(existingMeta, incomingMeta);
-      if (winner.id !== event.id)
-        return false;
+      if (winner.id !== event.id) return false;
     }
     if (existing && event.kind === "u") {
       yield* storage.putRecord(event.collection, deepMerge(existing, buildRecord(event)));
@@ -386,10 +408,11 @@ function rebuild(storage, collections) {
       yield* storage.clearRecords(col);
     }
     const allEvents = yield* storage.getAllEvents();
-    const sorted = [...allEvents].sort((a, b) => a.createdAt - b.createdAt || (a.id < b.id ? -1 : 1));
+    const sorted = [...allEvents].sort(
+      (a, b) => a.createdAt - b.createdAt || (a.id < b.id ? -1 : 1)
+    );
     for (const event of sorted) {
-      if (event.data === null && event.kind !== "d")
-        continue;
+      if (event.data === null && event.kind !== "d") continue;
       yield* applyEvent(storage, event);
     }
   });
@@ -442,9 +465,16 @@ function buildStructSchema(def, options = {}) {
 }
 function buildValidator(collectionName, def) {
   const decode = Schema4.decodeUnknownEffect(buildStructSchema(def, { includeId: true }));
-  return (input) => decode(input).pipe(Effect4.map((result) => result), Effect4.mapError((e) => new ValidationError({
-    message: `Validation failed for collection "${collectionName}": ${e.message}`
-  })));
+  return (input) => decode(input).pipe(
+    Effect4.map(
+      (result) => result
+    ),
+    Effect4.mapError(
+      (e) => new ValidationError({
+        message: `Validation failed for collection "${collectionName}": ${e.message}`
+      })
+    )
+  );
 }
 function buildPartialValidator(collectionName, def) {
   const decode = Schema4.decodeUnknownEffect(buildStructSchema(def, { allOptional: true }));
@@ -456,35 +486,38 @@ function buildPartialValidator(collectionName, def) {
     }
     const record = input;
     const unknownField = Object.keys(record).find((key) => !Object.hasOwn(def.fields, key));
-    if (unknownField !== undefined) {
+    if (unknownField !== void 0) {
       return yield* new ValidationError({
         message: `Unknown field "${unknownField}" in collection "${collectionName}"`,
         field: unknownField
       });
     }
-    return yield* decode(record).pipe(Effect4.map((result) => result), Effect4.mapError((e) => new ValidationError({
-      message: `Validation failed for collection "${collectionName}": ${e.message}`
-    })));
+    return yield* decode(record).pipe(
+      Effect4.map((result) => result),
+      Effect4.mapError(
+        (e) => new ValidationError({
+          message: `Validation failed for collection "${collectionName}": ${e.message}`
+        })
+      )
+    );
   });
 }
 
 // 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) {
+  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];
+    if (i + 1 < bytes.length) result += alphabet[(b1 & 15) << 2 | b2 >> 6];
+    if (i + 2 < bytes.length) result += alphabet[b2 & 63];
   }
   return result;
 }
@@ -529,16 +562,28 @@ function executeQuery(ctx, plan) {
     if (plan.indexQuery && ctx.def.indices.includes(plan.indexQuery.field)) {
       if (plan.indexQuery.type === "value") {
         results = [
-          ...yield* ctx.storage.getByIndex(ctx.collectionName, plan.indexQuery.field, plan.indexQuery.range)
+          ...yield* ctx.storage.getByIndex(
+            ctx.collectionName,
+            plan.indexQuery.field,
+            plan.indexQuery.range
+          )
         ];
       } else {
         results = [
-          ...yield* ctx.storage.getByIndexRange(ctx.collectionName, plan.indexQuery.field, plan.indexQuery.range)
+          ...yield* ctx.storage.getByIndexRange(
+            ctx.collectionName,
+            plan.indexQuery.field,
+            plan.indexQuery.range
+          )
         ];
       }
     } else if (plan.orderBy && ctx.def.indices.includes(plan.orderBy.field) && plan.filters.length === 0) {
       results = [
-        ...yield* ctx.storage.getAllSorted(ctx.collectionName, plan.orderBy.field, plan.orderBy.direction === "desc" ? "prev" : "next")
+        ...yield* ctx.storage.getAllSorted(
+          ctx.collectionName,
+          plan.orderBy.field,
+          plan.orderBy.direction === "desc" ? "prev" : "next"
+        )
       ];
     } else {
       results = [...yield* ctx.storage.getAllRecords(ctx.collectionName)];
@@ -562,7 +607,7 @@ function executeQuery(ctx, plan) {
     if (plan.offset) {
       results = results.slice(plan.offset);
     }
-    if (plan.limit !== null && plan.limit !== undefined) {
+    if (plan.limit !== null && plan.limit !== void 0) {
       results = results.slice(0, plan.limit);
     }
     return results.map(ctx.mapRecord);
@@ -570,16 +615,23 @@ function executeQuery(ctx, plan) {
 }
 function watchQuery(ctx, plan) {
   const query = () => executeQuery(ctx, plan);
-  const changes = Stream2.fromPubSub(ctx.watchCtx.pubsub).pipe(Stream2.filter((event) => event.collection === ctx.collectionName), Stream2.mapEffect(() => Effect5.gen(function* () {
-    const replaying = yield* Ref2.get(ctx.watchCtx.replayingRef);
-    if (replaying)
-      return;
-    return yield* query();
-  })), Stream2.filter((result) => result !== undefined));
-  return Stream2.unwrap(Effect5.gen(function* () {
-    const initial = yield* query();
-    return Stream2.concat(Stream2.make(initial), changes);
-  }));
+  const changes = Stream2.fromPubSub(ctx.watchCtx.pubsub).pipe(
+    Stream2.filter((event) => event.collection === ctx.collectionName),
+    Stream2.mapEffect(
+      () => Effect5.gen(function* () {
+        const replaying = yield* Ref2.get(ctx.watchCtx.replayingRef);
+        if (replaying) return void 0;
+        return yield* query();
+      })
+    ),
+    Stream2.filter((result) => result !== void 0)
+  );
+  return Stream2.unwrap(
+    Effect5.gen(function* () {
+      const initial = yield* query();
+      return Stream2.concat(Stream2.make(initial), changes);
+    })
+  );
 }
 function makeQueryBuilder(ctx, plan) {
   return {
@@ -601,15 +653,18 @@ 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(executeQuery(ctx, { ...plan, limit: 1 }), (results) => results.length > 0 ? Option2.some(results[0]) : Option2.none()),
+    first: () => Effect5.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),
     watch: () => watchQuery(ctx, plan)
   };
 }
-function createWhereClause(storage, watchCtx, collectionName, def, fieldName, mapRecord) {
-  const ctx = { storage, watchCtx, collectionName, def, mapRecord };
+function createWhereClause(storage, watchCtx, collectionName, def, fieldName, mapRecord2) {
+  const ctx = { storage, watchCtx, collectionName, def, mapRecord: mapRecord2 };
   const fieldDef = def.fields[fieldName];
-  const isIndexed = def.indices.includes(fieldName) && fieldDef !== null && fieldDef !== undefined && fieldDef.kind !== "boolean";
+  const isIndexed = def.indices.includes(fieldName) && fieldDef !== null && fieldDef !== void 0 && fieldDef.kind !== "boolean";
   const withFilter = (filterFn, indexQuery) => {
     const plan = {
       ...emptyPlan(),
@@ -620,30 +675,51 @@ function createWhereClause(storage, watchCtx, collectionName, def, fieldName, ma
     return makeQueryBuilder(ctx, plan);
   };
   return {
-    equals: (value) => withFilter((r) => r[fieldName] === value, isIndexed ? { field: fieldName, range: value, type: "value" } : undefined),
-    above: (value) => withFilter((r) => r[fieldName] > value, isIndexed ? { field: fieldName, range: IDBKeyRange.lowerBound(value, true), type: "range" } : undefined),
-    aboveOrEqual: (value) => withFilter((r) => r[fieldName] >= value, isIndexed ? { field: fieldName, range: IDBKeyRange.lowerBound(value, false), type: "range" } : undefined),
-    below: (value) => withFilter((r) => r[fieldName] < value, isIndexed ? { field: fieldName, range: IDBKeyRange.upperBound(value, true), type: "range" } : undefined),
-    belowOrEqual: (value) => withFilter((r) => r[fieldName] <= value, isIndexed ? { field: fieldName, range: IDBKeyRange.upperBound(value, false), type: "range" } : undefined),
+    equals: (value) => withFilter(
+      (r) => r[fieldName] === value,
+      isIndexed ? { field: fieldName, range: value, type: "value" } : void 0
+    ),
+    above: (value) => withFilter(
+      (r) => r[fieldName] > value,
+      isIndexed ? { field: fieldName, range: IDBKeyRange.lowerBound(value, true), type: "range" } : void 0
+    ),
+    aboveOrEqual: (value) => withFilter(
+      (r) => r[fieldName] >= value,
+      isIndexed ? { field: fieldName, range: IDBKeyRange.lowerBound(value, false), type: "range" } : void 0
+    ),
+    below: (value) => withFilter(
+      (r) => r[fieldName] < value,
+      isIndexed ? { field: fieldName, range: IDBKeyRange.upperBound(value, true), type: "range" } : void 0
+    ),
+    belowOrEqual: (value) => withFilter(
+      (r) => r[fieldName] <= value,
+      isIndexed ? { field: fieldName, range: IDBKeyRange.upperBound(value, false), type: "range" } : void 0
+    ),
     between: (lower, upper, options) => {
       const includeLower = options?.includeLower ?? true;
       const includeUpper = options?.includeUpper ?? true;
-      return withFilter((r) => {
-        const v = r[fieldName];
-        const aboveLower = includeLower ? v >= lower : v > lower;
-        const belowUpper = includeUpper ? v <= upper : v < upper;
-        return aboveLower && belowUpper;
-      }, isIndexed ? {
+      return withFilter(
+        (r) => {
+          const v = r[fieldName];
+          const aboveLower = includeLower ? v >= lower : v > lower;
+          const belowUpper = includeUpper ? v <= upper : v < upper;
+          return aboveLower && belowUpper;
+        },
+        isIndexed ? {
+          field: fieldName,
+          range: IDBKeyRange.bound(lower, upper, !includeLower, !includeUpper),
+          type: "range"
+        } : void 0
+      );
+    },
+    startsWith: (prefix) => withFilter(
+      (r) => typeof r[fieldName] === "string" && r[fieldName].startsWith(prefix),
+      isIndexed ? {
         field: fieldName,
-        range: IDBKeyRange.bound(lower, upper, !includeLower, !includeUpper),
+        range: IDBKeyRange.bound(prefix, prefix + "\uFFFF", false, false),
         type: "range"
-      } : undefined);
-    },
-    startsWith: (prefix) => withFilter((r) => typeof r[fieldName] === "string" && r[fieldName].startsWith(prefix), isIndexed ? {
-      field: fieldName,
-      range: IDBKeyRange.bound(prefix, prefix + "￿", false, false),
-      type: "range"
-    } : undefined),
+      } : void 0
+    ),
     anyOf: (values) => {
       const set = new Set(values);
       return withFilter((r) => set.has(r[fieldName]));
@@ -654,8 +730,8 @@ function createWhereClause(storage, watchCtx, collectionName, def, fieldName, ma
     }
   };
 }
-function createOrderByBuilder(storage, watchCtx, collectionName, def, fieldName, mapRecord) {
-  const ctx = { storage, watchCtx, collectionName, def, mapRecord };
+function createOrderByBuilder(storage, watchCtx, collectionName, def, fieldName, mapRecord2) {
+  const ctx = { storage, watchCtx, collectionName, def, mapRecord: mapRecord2 };
   const plan = {
     ...emptyPlan(),
     orderBy: { field: fieldName, direction: "asc" }
@@ -680,7 +756,7 @@ function replayState(recordId, events, stopAtId) {
         state = deepMerge(state, e.data);
       }
     }
-    if (stopAtId !== undefined && e.id === stopAtId) {
+    if (stopAtId !== void 0 && e.id === stopAtId) {
       break;
     }
   }
@@ -698,8 +774,7 @@ function promoteToSnapshot(storage, collection2, recordId, target, allSorted) {
 function pruneEvents(storage, collection2, recordId, retention) {
   return Effect6.gen(function* () {
     const events = yield* storage.getEventsByRecord(collection2, recordId);
-    if (events.length <= retention)
-      return;
+    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);
@@ -708,8 +783,7 @@ function pruneEvents(storage, collection2, recordId, retention) {
       yield* promoteToSnapshot(storage, collection2, recordId, oldestRetained, sorted);
     }
     for (const e of toStrip) {
-      if (e.data !== null)
-        yield* storage.stripEventData(e.id);
+      if (e.data !== null) yield* storage.stripEventData(e.id);
     }
   });
 }
@@ -717,13 +791,13 @@ function mapRecord(record) {
   const { _d, _u, _a, _e, ...fields } = record;
   return fields;
 }
-function createCollectionHandle(def, storage, watchCtx, validator, partialValidator, makeEventId, localAuthor, 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);
-    if (onWrite)
-      yield* onWrite(event);
+    if (onWrite) yield* onWrite(event);
     yield* notifyChange(watchCtx, {
       collection: collectionName,
       recordId: event.recordId,
@@ -731,67 +805,84 @@ function createCollectionHandle(def, storage, watchCtx, validator, partialValida
     });
   });
   const handle = {
-    add: (data) => Effect6.gen(function* () {
-      const id = uuidv7();
-      const fullRecord = { id, ...data };
-      yield* validator(fullRecord);
-      const event = {
-        id: makeEventId(),
-        collection: collectionName,
-        recordId: id,
-        kind: "c",
-        data: fullRecord,
-        createdAt: Date.now(),
-        author: localAuthor
-      };
-      yield* commitEvent(event);
-      return id;
-    }),
-    update: (id, data) => Effect6.gen(function* () {
-      const existing = yield* storage.getRecord(collectionName, id);
-      if (!existing || existing._d) {
-        return yield* new NotFoundError({
+    add: (data) => withLog(
+      Effect6.gen(function* () {
+        const id = uuidv7();
+        const fullRecord = { id, ...data };
+        yield* validator(fullRecord);
+        const event = {
+          id: makeEventId(),
           collection: collectionName,
-          id
+          recordId: id,
+          kind: "c",
+          data: fullRecord,
+          createdAt: Date.now(),
+          author: localAuthor
+        };
+        yield* commitEvent(event);
+        yield* Effect6.logDebug("Record added", {
+          collection: collectionName,
+          recordId: id,
+          data: fullRecord
         });
-      }
-      yield* partialValidator(data);
-      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 },
-        createdAt: Date.now(),
-        author: localAuthor
-      };
-      yield* commitEvent(event);
-      yield* pruneEvents(storage, collectionName, id, def.eventRetention);
-    }),
-    delete: (id) => Effect6.gen(function* () {
-      const existing = yield* storage.getRecord(collectionName, id);
-      if (!existing || existing._d) {
-        return yield* new NotFoundError({
+        return id;
+      })
+    ),
+    update: (id, data) => withLog(
+      Effect6.gen(function* () {
+        const existing = yield* storage.getRecord(collectionName, id);
+        if (!existing || existing._d) {
+          return yield* new NotFoundError({
+            collection: collectionName,
+            id
+          });
+        }
+        yield* partialValidator(data);
+        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,
-          id
+          recordId: id,
+          kind: "u",
+          data: diff ?? { id },
+          createdAt: Date.now(),
+          author: localAuthor
+        };
+        yield* commitEvent(event);
+        yield* Effect6.logDebug("Record updated", {
+          collection: collectionName,
+          recordId: id,
+          data: diff
         });
-      }
-      const event = {
-        id: makeEventId(),
-        collection: collectionName,
-        recordId: id,
-        kind: "d",
-        data: null,
-        createdAt: Date.now(),
-        author: localAuthor
-      };
-      yield* commitEvent(event);
-      yield* pruneEvents(storage, collectionName, id, def.eventRetention);
-    }),
+        yield* pruneEvents(storage, collectionName, id, def.eventRetention);
+      })
+    ),
+    delete: (id) => withLog(
+      Effect6.gen(function* () {
+        const existing = yield* storage.getRecord(collectionName, id);
+        if (!existing || existing._d) {
+          return yield* new NotFoundError({
+            collection: collectionName,
+            id
+          });
+        }
+        const event = {
+          id: makeEventId(),
+          collection: collectionName,
+          recordId: id,
+          kind: "d",
+          data: null,
+          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) {
@@ -832,15 +923,29 @@ function createCollectionHandle(def, storage, watchCtx, validator, partialValida
       return found ? Option3.some(mapRecord(found)) : Option3.none();
     }),
     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)
+    watch: () => watchCollection(watchCtx, storage, collectionName, void 0, mapRecord),
+    where: (fieldName) => createWhereClause(
+      storage,
+      watchCtx,
+      collectionName,
+      def,
+      fieldName,
+      mapRecord
+    ),
+    orderBy: (fieldName) => createOrderByBuilder(
+      storage,
+      watchCtx,
+      collectionName,
+      def,
+      fieldName,
+      mapRecord
+    )
   };
   return handle;
 }
 
 // src/sync/sync-service.ts
-import { Effect as Effect8, Option as Option5, Ref as Ref3, Schedule } from "effect";
+import { Duration, 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";
 
@@ -856,8 +961,7 @@ var Mode = {
   Fingerprint: 1,
   IdList: 2
 };
-
-class WrappedBuffer {
+var WrappedBuffer = class {
   constructor(buffer) {
     this._raw = new Uint8Array(buffer || 512);
     this.length = buffer ? buffer.length : 0;
@@ -869,10 +973,8 @@ class WrappedBuffer {
     return this._raw.byteLength;
   }
   extend(buf) {
-    if (buf._raw)
-      buf = buf.unwrap();
-    if (typeof buf.length !== "number")
-      throw Error("bad length");
+    if (buf._raw) buf = buf.unwrap();
+    if (typeof buf.length !== "number") throw Error("bad length");
     const targetSize = buf.length + this.length;
     if (this.capacity < targetSize) {
       const oldRaw = this._raw;
@@ -895,42 +997,36 @@ class WrappedBuffer {
     this.length -= n;
     return firstSubarray;
   }
-}
+};
 function decodeVarInt(buf) {
   let res = 0;
-  while (true) {
-    if (buf.length === 0)
-      throw Error("parse ends prematurely");
+  while (1) {
+    if (buf.length === 0) throw Error("parse ends prematurely");
     let byte = buf.shift();
     res = res << 7 | byte & 127;
-    if ((byte & 128) === 0)
-      break;
+    if ((byte & 128) === 0) break;
   }
   return res;
 }
 function encodeVarInt(n) {
-  if (n === 0)
-    return new WrappedBuffer([0]);
+  if (n === 0) return new WrappedBuffer([0]);
   let o = [];
   while (n !== 0) {
     o.push(n & 127);
     n >>>= 7;
   }
   o.reverse();
-  for (let i = 0;i < o.length - 1; i++)
-    o[i] |= 128;
+  for (let i = 0; i < o.length - 1; i++) o[i] |= 128;
   return new WrappedBuffer(o);
 }
 function getByte(buf) {
   return getBytes(buf, 1)[0];
 }
 function getBytes(buf, n) {
-  if (buf.length < n)
-    throw Error("parse ends prematurely");
+  if (buf.length < n) throw Error("parse ends prematurely");
   return buf.shiftN(n);
 }
-
-class Accumulator {
+var Accumulator = class {
   constructor() {
     this.setToZero();
     if (typeof window === "undefined") {
@@ -947,15 +1043,14 @@ class Accumulator {
     let currCarry = 0, nextCarry = 0;
     let p = new DataView(this.buf.buffer);
     let po = new DataView(otherBuf.buffer);
-    for (let i = 0;i < 8; i++) {
+    for (let i = 0; i < 8; i++) {
       let offset = i * 4;
       let orig = p.getUint32(offset, true);
       let otherV = po.getUint32(offset, true);
       let next = orig;
       next += currCarry;
       next += otherV;
-      if (next > 4294967295)
-        nextCarry = 1;
+      if (next > 4294967295) nextCarry = 1;
       p.setUint32(offset, next & 4294967295, true);
       currCarry = nextCarry;
       nextCarry = 0;
@@ -963,7 +1058,7 @@ class Accumulator {
   }
   negate() {
     let p = new DataView(this.buf.buffer);
-    for (let i = 0;i < 8; i++) {
+    for (let i = 0; i < 8; i++) {
       let offset = i * 4;
       p.setUint32(offset, ~p.getUint32(offset, true));
     }
@@ -972,33 +1067,29 @@ class Accumulator {
     this.add(one);
   }
   async getFingerprint(n) {
-    let input = new WrappedBuffer;
+    let input = new WrappedBuffer();
     input.extend(this.buf);
     input.extend(encodeVarInt(n));
     let hash = await this.sha256(input.unwrap());
     return hash.subarray(0, FINGERPRINT_SIZE);
   }
-}
-
-class NegentropyStorageVector {
+};
+var NegentropyStorageVector = class {
   constructor() {
     this.items = [];
     this.sealed = false;
   }
   insert(timestamp, id) {
-    if (this.sealed)
-      throw Error("already sealed");
+    if (this.sealed) throw Error("already sealed");
     id = loadInputBuffer(id);
-    if (id.byteLength !== ID_SIZE)
-      throw Error("bad id size for added item");
+    if (id.byteLength !== ID_SIZE) throw Error("bad id size for added item");
     this.items.push({ timestamp, id });
   }
   seal() {
-    if (this.sealed)
-      throw Error("already sealed");
+    if (this.sealed) throw Error("already sealed");
     this.sealed = true;
     this.items.sort(itemCompare);
-    for (let i = 1;i < this.items.length; i++) {
+    for (let i = 1; i < this.items.length; i++) {
       if (itemCompare(this.items[i - 1], this.items[i]) === 0)
         throw Error("duplicate item inserted");
     }
@@ -1012,16 +1103,14 @@ class NegentropyStorageVector {
   }
   getItem(i) {
     this._checkSealed();
-    if (i >= this.items.length)
-      throw Error("out of range");
+    if (i >= this.items.length) throw Error("out of range");
     return this.items[i];
   }
   iterate(begin, end, cb) {
     this._checkSealed();
     this._checkBounds(begin, end);
-    for (let i = begin;i < end; ++i) {
-      if (!cb(this.items[i], i))
-        break;
+    for (let i = begin; i < end; ++i) {
+      if (!cb(this.items[i], i)) break;
     }
   }
   findLowerBound(begin, end, bound) {
@@ -1030,7 +1119,7 @@ class NegentropyStorageVector {
     return this._binarySearch(this.items, begin, end, (a) => itemCompare(a, bound) < 0);
   }
   async fingerprint(begin, end) {
-    let out = new Accumulator;
+    let out = new Accumulator();
     out.setToZero();
     this.iterate(begin, end, (item, i) => {
       out.add(item.id);
@@ -1039,12 +1128,10 @@ class NegentropyStorageVector {
     return await out.getFingerprint(end - begin);
   }
   _checkSealed() {
-    if (!this.sealed)
-      throw Error("not sealed");
+    if (!this.sealed) throw Error("not sealed");
   }
   _checkBounds(begin, end) {
-    if (begin > end || end > this.items.length)
-      throw Error("bad range");
+    if (begin > end || end > this.items.length) throw Error("bad range");
   }
   _binarySearch(arr, first, last, cmp) {
     let count = last - first;
@@ -1061,12 +1148,10 @@ class NegentropyStorageVector {
     }
     return first;
   }
-}
-
-class Negentropy {
+};
+var Negentropy = class {
   constructor(storage, frameSizeLimit = 0) {
-    if (frameSizeLimit !== 0 && frameSizeLimit < 4096)
-      throw Error("frameSizeLimit too small");
+    if (frameSizeLimit !== 0 && frameSizeLimit < 4096) throw Error("frameSizeLimit too small");
     this.storage = storage;
     this.frameSizeLimit = frameSizeLimit;
     this.lastTimestampIn = 0;
@@ -1076,10 +1161,9 @@ class Negentropy {
     return { timestamp, id: id ? id : new Uint8Array(0) };
   }
   async initiate() {
-    if (this.isInitiator)
-      throw Error("already initiated");
+    if (this.isInitiator) throw Error("already initiated");
     this.isInitiator = true;
-    let output = new WrappedBuffer;
+    let output = new WrappedBuffer();
     output.extend([PROTOCOL_VERSION]);
     await this.splitRange(0, this.storage.size(), this._bound(Number.MAX_VALUE), output);
     return this._renderOutput(output);
@@ -1091,23 +1175,24 @@ class Negentropy {
     let haveIds = [], needIds = [];
     query = new WrappedBuffer(loadInputBuffer(query));
     this.lastTimestampIn = this.lastTimestampOut = 0;
-    let fullOutput = new WrappedBuffer;
+    let fullOutput = new WrappedBuffer();
     fullOutput.extend([PROTOCOL_VERSION]);
     let protocolVersion = getByte(query);
     if (protocolVersion < 96 || protocolVersion > 111)
       throw Error("invalid negentropy protocol version byte");
     if (protocolVersion !== PROTOCOL_VERSION) {
       if (this.isInitiator)
-        throw Error("unsupported negentropy protocol version requested: " + (protocolVersion - 96));
-      else
-        return [this._renderOutput(fullOutput), haveIds, needIds];
+        throw Error(
+          "unsupported negentropy protocol version requested: " + (protocolVersion - 96)
+        );
+      else return [this._renderOutput(fullOutput), haveIds, needIds];
     }
     let storageSize = this.storage.size();
     let prevBound = this._bound(0);
     let prevIndex = 0;
     let skip = false;
     while (query.length !== 0) {
-      let o = new WrappedBuffer;
+      let o = new WrappedBuffer();
       let doSkip = () => {
         if (skip) {
           skip = false;
@@ -1133,10 +1218,9 @@ class Negentropy {
       } else if (mode === Mode.IdList) {
         let numIds = decodeVarInt(query);
         let theirElems = {};
-        for (let i = 0;i < numIds; i++) {
+        for (let i = 0; i < numIds; i++) {
           let e = getBytes(query, ID_SIZE);
-          if (this.isInitiator)
-            theirElems[e] = e;
+          if (this.isInitiator) theirElems[e] = e;
         }
         if (this.isInitiator) {
           skip = true;
@@ -1155,7 +1239,7 @@ class Negentropy {
           }
         } else {
           doSkip();
-          let responseIds = new WrappedBuffer;
+          let responseIds = new WrappedBuffer();
           let numResponseIds = 0;
           let endBound = currBound;
           this.storage.iterate(lower, upper, (item, index) => {
@@ -1173,7 +1257,7 @@ class Negentropy {
           o.extend(encodeVarInt(numResponseIds));
           o.extend(responseIds);
           fullOutput.extend(o);
-          o = new WrappedBuffer;
+          o = new WrappedBuffer();
         }
       } else {
         throw Error("unexpected mode");
@@ -1211,7 +1295,7 @@ class Negentropy {
       let itemsPerBucket = Math.floor(numElems / buckets);
       let bucketsWithExtra = numElems % buckets;
       let curr = lower;
-      for (let i = 0;i < buckets; i++) {
+      for (let i = 0; i < buckets; i++) {
         let bucketSize = itemsPerBucket + (i < bucketsWithExtra ? 1 : 0);
         let ourFingerprint = await this.storage.fingerprint(curr, curr + bucketSize);
         curr += bucketSize;
@@ -1221,10 +1305,8 @@ class Negentropy {
         } else {
           let prevItem, currItem;
           this.storage.iterate(curr - 1, curr + 1, (item, index) => {
-            if (index === curr - 1)
-              prevItem = item;
-            else
-              currItem = item;
+            if (index === curr - 1) prevItem = item;
+            else currItem = item;
             return true;
           });
           nextBound = this.getMinimalBound(prevItem, currItem);
@@ -1237,13 +1319,13 @@ class Negentropy {
   }
   _renderOutput(o) {
     o = o.unwrap();
-    if (!this.wantUint8ArrayOutput)
-      o = uint8ArrayToHex(o);
+    if (!this.wantUint8ArrayOutput) o = uint8ArrayToHex(o);
     return o;
   }
   exceededFrameSizeLimit(n) {
     return this.frameSizeLimit && n > this.frameSizeLimit - 200;
   }
+  // Decoding
   decodeTimestampIn(encoded) {
     let timestamp = decodeVarInt(encoded);
     timestamp = timestamp === 0 ? Number.MAX_VALUE : timestamp - 1;
@@ -1258,11 +1340,11 @@ class Negentropy {
   decodeBound(encoded) {
     let timestamp = this.decodeTimestampIn(encoded);
     let len = decodeVarInt(encoded);
-    if (len > ID_SIZE)
-      throw Error("bound key too long");
+    if (len > ID_SIZE) throw Error("bound key too long");
     let id = getBytes(encoded, len);
     return { timestamp, id };
   }
+  // Encoding
   encodeTimestampOut(timestamp) {
     if (timestamp === Number.MAX_VALUE) {
       this.lastTimestampOut = Number.MAX_VALUE;
@@ -1274,7 +1356,7 @@ class Negentropy {
     return encodeVarInt(timestamp + 1);
   }
   encodeBound(key) {
-    let output = new WrappedBuffer;
+    let output = new WrappedBuffer();
     output.extend(this.encodeTimestampOut(key.timestamp));
     output.extend(encodeVarInt(key.id.length));
     output.extend(key.id);
@@ -1287,30 +1369,24 @@ class Negentropy {
       let sharedPrefixBytes = 0;
       let currKey = curr.id;
       let prevKey = prev.id;
-      for (let i = 0;i < ID_SIZE; i++) {
-        if (currKey[i] !== prevKey[i])
-          break;
+      for (let i = 0; i < ID_SIZE; i++) {
+        if (currKey[i] !== prevKey[i]) break;
         sharedPrefixBytes++;
       }
       return this._bound(curr.timestamp, curr.id.subarray(0, sharedPrefixBytes + 1));
     }
   }
-}
+};
 function loadInputBuffer(inp) {
-  if (typeof inp === "string")
-    inp = hexToUint8Array(inp);
-  else if (__proto__ !== Uint8Array.prototype)
-    inp = new Uint8Array(inp);
+  if (typeof inp === "string") inp = hexToUint8Array(inp);
+  else if (__proto__ !== Uint8Array.prototype) inp = new Uint8Array(inp);
   return inp;
 }
 function hexToUint8Array(h) {
-  if (h.startsWith("0x"))
-    h = h.substr(2);
-  if (h.length % 2 === 1)
-    throw Error("odd length of hex string");
+  if (h.startsWith("0x")) h = h.substr(2);
+  if (h.length % 2 === 1) throw Error("odd length of hex string");
   let arr = new Uint8Array(h.length / 2);
-  for (let i = 0;i < arr.length; i++)
-    arr[i] = parseInt(h.substr(i * 2, 2), 16);
+  for (let i = 0; i < arr.length; i++) arr[i] = parseInt(h.substr(i * 2, 2), 16);
   return arr;
 }
 var uint8ArrayToHexLookupTable = new Array(256);
@@ -1333,28 +1409,24 @@ var uint8ArrayToHexLookupTable = new Array(256);
     "e",
     "f"
   ];
-  for (let i = 0;i < 256; i++) {
+  for (let i = 0; i < 256; i++) {
     uint8ArrayToHexLookupTable[i] = hexAlphabet[i >>> 4 & 15] + hexAlphabet[i & 15];
   }
 }
 function uint8ArrayToHex(arr) {
   let out = "";
-  for (let i = 0, edx = arr.length;i < edx; i++) {
+  for (let i = 0, edx = arr.length; i < edx; i++) {
     out += uint8ArrayToHexLookupTable[arr[i]];
   }
   return out;
 }
 function compareUint8Array(a, b) {
-  for (let i = 0;i < a.byteLength; i++) {
-    if (a[i] < b[i])
-      return -1;
-    if (a[i] > b[i])
-      return 1;
-  }
-  if (a.byteLength > b.byteLength)
-    return 1;
-  if (a.byteLength < b.byteLength)
-    return -1;
+  for (let i = 0; i < a.byteLength; i++) {
+    if (a[i] < b[i]) return -1;
+    if (a[i] > b[i]) return 1;
+  }
+  if (a.byteLength > b.byteLength) return 1;
+  if (a.byteLength < b.byteLength) return -1;
   return 0;
 }
 function itemCompare(a, b) {
@@ -1370,7 +1442,7 @@ import { GiftWrap } from "nostr-tools/kinds";
 function reconcileWithRelay(storage, relay, relayUrl, publicKeys) {
   return Effect7.gen(function* () {
     const allGiftWraps = yield* storage.getAllGiftWraps();
-    const storageVector = new NegentropyStorageVector;
+    const storageVector = new NegentropyStorageVector();
     for (const gw of allGiftWraps) {
       storageVector.insert(gw.createdAt, hexToBytes2(gw.id));
     }
@@ -1394,8 +1466,7 @@ function reconcileWithRelay(storage, relay, relayUrl, publicKeys) {
     let currentMsg = initialMsg;
     while (currentMsg !== null) {
       const response = yield* relay.sendNegMsg(relayUrl, subId, filter, currentMsg);
-      if (response.msgHex === null)
-        break;
+      if (response.msgHex === null) break;
       const reconcileResult = yield* Effect7.try({
         try: () => neg.reconcile(response.msgHex),
         catch: (e) => new SyncError({
@@ -1405,14 +1476,17 @@ function reconcileWithRelay(storage, relay, relayUrl, publicKeys) {
         })
       });
       const [nextMsg, haveIds, needIds] = reconcileResult;
-      for (const id of haveIds)
-        allHaveIds.push(id);
-      for (const id of needIds)
-        allNeedIds.push(id);
+      for (const id of haveIds) allHaveIds.push(id);
+      for (const id of needIds) 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
@@ -1451,12 +1525,11 @@ function createRotation(epochStore, senderPrivateKey, senderPublicKey, remaining
     kind: 1,
     content: JSON.stringify(rotationData),
     tags: [["d", `_system:rotation:${epochId}`]],
-    created_at: Math.floor(Date.now() / 1000)
+    created_at: Math.floor(Date.now() / 1e3)
   };
   const wrappedEvents = [];
   for (const memberPubkey of remainingMemberPubkeys) {
-    if (memberPubkey === senderPublicKey)
-      continue;
+    if (memberPubkey === senderPublicKey) continue;
     const wrapped = wrapEvent(rumor, senderPrivateKey, memberPubkey);
     wrappedEvents.push(wrapped);
   }
@@ -1469,7 +1542,7 @@ function createRotation(epochStore, senderPrivateKey, senderPublicKey, remaining
     kind: 1,
     content: JSON.stringify(removalData),
     tags: [["d", `_system:removed:${epochId}`]],
-    created_at: Math.floor(Date.now() / 1000)
+    created_at: Math.floor(Date.now() / 1e3)
   };
   const removalNotices = [];
   for (const removedPubkey of removedMemberPubkeys) {
@@ -1479,8 +1552,7 @@ function createRotation(epochStore, senderPrivateKey, senderPublicKey, remaining
   return { epoch, wrappedEvents, removalNotices };
 }
 function parseRotationEvent(content, dTag) {
-  if (!dTag.startsWith("_system:rotation:"))
-    return Option4.none();
+  if (!dTag.startsWith("_system:rotation:")) return Option4.none();
   try {
     return Option4.some(decodeRotationData(content));
   } catch {
@@ -1488,8 +1560,7 @@ function parseRotationEvent(content, dTag) {
   }
 }
 function parseRemovalNotice(content, dTag) {
-  if (!dTag.startsWith("_system:removed:"))
-    return Option4.none();
+  if (!dTag.startsWith("_system:removed:")) return Option4.none();
   try {
     return Option4.some(decodeRemovalNotice(content));
   } catch {
@@ -1498,7 +1569,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);
   };
@@ -1508,64 +1580,79 @@ 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* () {
     const size = yield* publishQueue.size();
-    if (size === 0)
-      return;
+    if (size === 0) return;
     yield* syncStatus.set("syncing");
     yield* publishQueue.flush(relayUrls);
     const remaining = yield* publishQueue.size();
-    if (remaining > 0)
-      yield* Effect8.fail("pending");
-  }).pipe(Effect8.ensuring(syncStatus.set("idle")), Effect8.retry({ schedule: Schedule.exponential(5000).pipe(Schedule.jittered), times: 10 }), Effect8.ignore);
+    if (remaining > 0) yield* Effect8.fail("pending");
+  }).pipe(
+    Effect8.ensuring(syncStatus.set("idle")),
+    Effect8.retry({ schedule: Schedule.exponential(5e3).pipe(Schedule.jittered), times: 10 }),
+    Effect8.ignore
+  );
   const scheduleAutoFlush = () => {
-    if (autoFlushActive)
-      return;
+    if (autoFlushActive) return;
     autoFlushActive = true;
-    forkHandled(autoFlushEffect.pipe(Effect8.ensuring(Effect8.sync(() => {
-      autoFlushActive = false;
-    }))));
+    forkHandled(
+      autoFlushEffect.pipe(
+        Effect8.ensuring(
+          Effect8.sync(() => {
+            autoFlushActive = false;
+          })
+        )
+      )
+    );
   };
   const shouldRejectWrite = (authorPubkey) => Effect8.gen(function* () {
     const memberRecord = yield* storage.getRecord("_members", authorPubkey);
-    if (!memberRecord)
-      return false;
+    if (!memberRecord) return false;
     return !!memberRecord.removedAt;
   });
   const processGiftWrap = (remoteGw) => Effect8.gen(function* () {
     const existing = yield* storage.getGiftWrap(remoteGw.id);
-    if (existing)
-      return null;
+    if (existing) return null;
     const unwrapResult = yield* Effect8.result(giftWrapHandle.unwrap(remoteGw));
     if (unwrapResult._tag === "Failure") {
-      yield* storage.putGiftWrap({ id: remoteGw.id, createdAt: remoteGw.created_at });
+      yield* storage.putGiftWrap({ id: remoteGw.id, event: remoteGw, createdAt: remoteGw.created_at });
       return null;
     }
     const rumor = unwrapResult.success;
     const dTag = rumor.tags.find((t) => t[0] === "d")?.[1];
     if (!dTag) {
-      yield* storage.putGiftWrap({ id: remoteGw.id, createdAt: remoteGw.created_at });
+      yield* storage.putGiftWrap({ id: remoteGw.id, event: remoteGw, createdAt: remoteGw.created_at });
       return null;
     }
     const colonIdx = dTag.indexOf(":");
     if (colonIdx === -1) {
-      yield* storage.putGiftWrap({ id: remoteGw.id, createdAt: remoteGw.created_at });
+      yield* storage.putGiftWrap({ id: remoteGw.id, event: remoteGw, createdAt: remoteGw.created_at });
       return null;
     }
     const collectionName = dTag.substring(0, colonIdx);
     const recordId = dTag.substring(colonIdx + 1);
     const retention = knownCollections.get(collectionName);
-    if (retention === undefined) {
-      yield* storage.putGiftWrap({ id: remoteGw.id, createdAt: remoteGw.created_at });
+    if (retention === void 0) {
+      yield* storage.putGiftWrap({ id: remoteGw.id, event: remoteGw, createdAt: remoteGw.created_at });
       return null;
     }
     if (rumor.pubkey) {
       const reject = yield* shouldRejectWrite(rumor.pubkey);
       if (reject) {
-        yield* storage.putGiftWrap({ id: remoteGw.id, createdAt: remoteGw.created_at });
+        yield* Effect8.logWarning("Rejected write from removed member", {
+          author: rumor.pubkey.slice(0, 12)
+        });
+        yield* storage.putGiftWrap({ id: remoteGw.id, event: remoteGw, createdAt: remoteGw.created_at });
         return null;
       }
     }
@@ -1573,14 +1660,10 @@ function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStat
     let kind = "u";
     const parsed = yield* Effect8.try({
       try: () => JSON.parse(rumor.content),
-      catch: () => {
-        return;
-      }
-    }).pipe(Effect8.orElseSucceed(() => {
-      return;
-    }));
-    if (parsed === undefined) {
-      yield* storage.putGiftWrap({ id: remoteGw.id, createdAt: remoteGw.created_at });
+      catch: () => void 0
+    }).pipe(Effect8.orElseSucceed(() => void 0));
+    if (parsed === void 0) {
+      yield* storage.putGiftWrap({ id: remoteGw.id, event: remoteGw, createdAt: remoteGw.created_at });
       return null;
     }
     if (parsed === null || parsed._deleted) {
@@ -1588,18 +1671,19 @@ function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStat
     } else {
       data = parsed;
     }
-    const author = rumor.pubkey || undefined;
+    const author = rumor.pubkey || void 0;
     const event = {
       id: rumor.id,
       collection: collectionName,
       recordId,
       kind,
       data,
-      createdAt: rumor.created_at * 1000,
+      createdAt: rumor.created_at * 1e3,
       author
     };
     yield* storage.putGiftWrap({
       id: remoteGw.id,
+      event: remoteGw,
       createdAt: remoteGw.created_at
     });
     yield* storage.putEvent(event);
@@ -1607,6 +1691,12 @@ 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", {
+      collection: collectionName,
+      recordId,
+      kind,
+      author: author?.slice(0, 12)
+    });
     if (author && onNewAuthor) {
       onNewAuthor(author);
     }
@@ -1619,32 +1709,34 @@ function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStat
     }
   });
   const processRotationGiftWrap = (remoteGw) => Effect8.gen(function* () {
-    const unwrapResult = yield* Effect8.result(Effect8.try({
-      try: () => unwrapEvent(remoteGw, personalPrivateKey),
-      catch: (e) => new CryptoError({
-        message: `Rotation unwrap failed: ${e instanceof Error ? e.message : String(e)}`,
-        cause: e
+    const unwrapResult = yield* Effect8.result(
+      Effect8.try({
+        try: () => unwrapEvent(remoteGw, personalPrivateKey),
+        catch: (e) => new CryptoError({
+          message: `Rotation unwrap failed: ${e instanceof Error ? e.message : String(e)}`,
+          cause: e
+        })
       })
-    }));
-    if (unwrapResult._tag === "Failure")
-      return false;
+    );
+    if (unwrapResult._tag === "Failure") return false;
     const rumor = unwrapResult.success;
     const dTag = rumor.tags.find((t) => t[0] === "d")?.[1];
-    if (!dTag)
-      return false;
+    if (!dTag) return false;
     const removalNoticeOpt = parseRemovalNotice(rumor.content, dTag);
     if (Option5.isSome(removalNoticeOpt)) {
-      if (onRemoved)
-        onRemoved(removalNoticeOpt.value);
+      if (onRemoved) onRemoved(removalNoticeOpt.value);
       return true;
     }
     const rotationDataOpt = parseRotationEvent(rumor.content, dTag);
-    if (Option5.isNone(rotationDataOpt))
-      return false;
+    if (Option5.isNone(rotationDataOpt)) return false;
     const rotationData = rotationDataOpt.value;
-    if (epochStore.epochs.has(rotationData.epochId))
-      return false;
-    const epoch = createEpochKey(rotationData.epochId, rotationData.epochKey, rumor.pubkey || "", rotationData.parentEpoch);
+    if (epochStore.epochs.has(rotationData.epochId)) return false;
+    const epoch = createEpochKey(
+      rotationData.epochId,
+      rotationData.epochKey,
+      rumor.pubkey || "",
+      rotationData.parentEpoch
+    );
     addEpoch(epochStore, epoch);
     epochStore.currentEpochId = epoch.id;
     let membersChanged = false;
@@ -1664,75 +1756,158 @@ function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStat
         membersChanged = true;
       }
     }
-    if (membersChanged && onMembersChanged)
-      onMembersChanged();
+    if (membersChanged && onMembersChanged) onMembersChanged();
     yield* handle.addEpochSubscription(epoch.publicKey);
     return true;
   });
-  const subscribeAcrossRelays = (filter, onEvent) => Effect8.forEach(relayUrls, (url) => Effect8.gen(function* () {
-    yield* relay.subscribe(filter, url, (event) => {
-      forkHandled(onEvent(event));
-    }).pipe(Effect8.tapError((err) => Effect8.sync(() => onSyncError?.(err))), Effect8.ignore);
-  }), { discard: true });
+  const subscribeAcrossRelays = (filter, onEvent) => Effect8.forEach(
+    relayUrls,
+    (url) => Effect8.gen(function* () {
+      yield* relay.subscribe(filter, url, (event) => {
+        forkHandled(onEvent(event));
+      }).pipe(
+        Effect8.tapError((err) => Effect8.sync(() => onSyncError?.(err))),
+        Effect8.ignore
+      );
+    }),
+    { discard: true }
+  );
   const syncRelay = (url, pubKeys, changedCollections) => Effect8.gen(function* () {
-    const reconcileResult = yield* Effect8.result(reconcileWithRelay(storage, relay, url, Array.from(pubKeys)));
+    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(() => []));
+      const fetched = yield* relay.fetchEvents(needIds, url).pipe(
+        Effect8.tapError((err) => Effect8.sync(() => onSyncError?.(err))),
+        Effect8.orElseSucceed(() => [])
+      );
       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);
-      }), { discard: true });
+      yield* Effect8.forEach(
+        sorted,
+        (remoteGw) => Effect8.gen(function* () {
+          const collection2 = yield* processGiftWrap(remoteGw).pipe(
+            Effect8.orElseSucceed(() => null)
+          );
+          if (collection2) changedCollections.add(collection2);
+        }),
+        { discard: true }
+      );
     }
     if (haveIds.length > 0) {
-      yield* Effect8.forEach(haveIds, (id) => Effect8.gen(function* () {
-        const gw = yield* storage.getGiftWrap(id);
-        if (!gw?.event)
-          return;
-        yield* relay.publish(gw.event, [url]).pipe(Effect8.andThen(storage.stripGiftWrapBlob(id)), Effect8.tapError((err) => Effect8.sync(() => onSyncError?.(err))), Effect8.ignore);
-      }), { discard: true });
-    }
-  });
+      yield* Effect8.forEach(
+        haveIds,
+        (id) => Effect8.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
+          );
+        }),
+        { discard: true }
+      );
+    }
+  }).pipe(Effect8.withLogSpan("tablinum.syncRelay"));
+  let healingActive = false;
+  const healingEffect = Effect8.gen(function* () {
+    if (!healingActive) return;
+    const status = yield* syncStatus.get();
+    if (status === "syncing") return;
+    yield* syncStatus.set("syncing");
+    yield* Effect8.gen(function* () {
+      const pubKeys = getSubscriptionPubKeys();
+      const changedCollections = /* @__PURE__ */ new Set();
+      yield* Effect8.forEach(relayUrls, (url) => syncRelay(url, pubKeys, changedCollections), {
+        discard: true
+      });
+      if (changedCollections.size > 0) {
+        yield* notifyReplayComplete(watchCtx, [...changedCollections]);
+      }
+    }).pipe(Effect8.ensuring(syncStatus.set("idle")));
+  }).pipe(Effect8.ignore);
   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;
+      const changedCollections = /* @__PURE__ */ new Set();
       yield* Effect8.gen(function* () {
         const pubKeys = getSubscriptionPubKeys();
         yield* Effect8.forEach(relayUrls, (url) => syncRelay(url, pubKeys, changedCollections), {
           discard: true
         });
         yield* publishQueue.flush(relayUrls).pipe(Effect8.ignore);
-      }).pipe(Effect8.ensuring(Effect8.gen(function* () {
-        yield* notifyReplayComplete(watchCtx, [...changedCollections]);
-        yield* syncStatus.set("idle");
-      })));
-    }),
+      }).pipe(
+        Effect8.ensuring(
+          Effect8.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* () {
-      if (!giftWrap.event)
-        return;
-      yield* relay.publish(giftWrap.event, relayUrls).pipe(Effect8.tapError(() => storage.putGiftWrap(giftWrap).pipe(Effect8.andThen(publishQueue.enqueue(giftWrap.id)), Effect8.andThen(Effect8.sync(() => scheduleAutoFlush())))), Effect8.tapError((err) => Effect8.sync(() => onSyncError?.(err))), Effect8.ignore);
+      if (!giftWrap.event) return;
+      yield* relay.publish(giftWrap.event, relayUrls).pipe(
+        Effect8.tapError(
+          () => storage.putGiftWrap(giftWrap).pipe(
+            Effect8.andThen(publishQueue.enqueue(giftWrap.id)),
+            Effect8.andThen(Effect8.sync(() => scheduleAutoFlush()))
+          )
+        ),
+        Effect8.tapError((err) => Effect8.sync(() => onSyncError?.(err))),
+        Effect8.ignore
+      );
     }),
     startSubscription: () => Effect8.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));
+        yield* subscribeAcrossRelays(
+          { kinds: [GiftWrap2], "#p": [personalPublicKey] },
+          (event) => Effect8.result(processRotationGiftWrap(event)).pipe(Effect8.asVoid)
+        );
       }
     }),
-    addEpochSubscription: (publicKey) => subscribeAcrossRelays({ kinds: [GiftWrap2], "#p": [publicKey] }, processRealtimeGiftWrap)
+    addEpochSubscription: (publicKey) => subscribeAcrossRelays({ kinds: [GiftWrap2], "#p": [publicKey] }, processRealtimeGiftWrap),
+    startHealing: () => {
+      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(() => {
+            healingActive = false;
+          }))
+        )
+      );
+    },
+    stopHealing: () => {
+      healingActive = false;
+    }
   };
-  forkHandled(publishQueue.size().pipe(Effect8.flatMap((size) => Effect8.sync(() => {
-    if (size > 0)
-      scheduleAutoFlush();
-  }))));
+  forkHandled(
+    publishQueue.size().pipe(
+      Effect8.flatMap(
+        (size) => Effect8.sync(() => {
+          if (size > 0) scheduleAutoFlush();
+        })
+      )
+    )
+  );
   return handle;
 }
 
@@ -1788,9 +1963,14 @@ var decodeAuthorProfile = Schema6.decodeUnknownEffect(Schema6.fromJsonString(Aut
 function fetchAuthorProfile(relay, relayUrls, pubkey) {
   return Effect9.gen(function* () {
     for (const url of relayUrls) {
-      const result = yield* Effect9.result(relay.fetchByFilter({ kinds: [0], authors: [pubkey], limit: 1 }, url));
+      const result = yield* Effect9.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()));
+        return yield* decodeAuthorProfile(result.success[0].content).pipe(
+          Effect9.map(Option6.some),
+          Effect9.orElseSucceed(() => Option6.none())
+        );
       }
     }
     return Option6.none();
@@ -1799,48 +1979,47 @@ function fetchAuthorProfile(relay, relayUrls, pubkey) {
 
 // src/services/Identity.ts
 import { ServiceMap as ServiceMap3 } from "effect";
-
-class Identity extends ServiceMap3.Service()("tablinum/Identity") {
-}
+var Identity = class extends ServiceMap3.Service()("tablinum/Identity") {
+};
 
 // src/services/EpochStore.ts
 import { ServiceMap as ServiceMap4 } from "effect";
-
-class EpochStore extends ServiceMap4.Service()("tablinum/EpochStore") {
-}
+var EpochStore = class extends ServiceMap4.Service()(
+  "tablinum/EpochStore"
+) {
+};
 
 // src/services/Storage.ts
 import { ServiceMap as ServiceMap5 } from "effect";
-
-class Storage extends ServiceMap5.Service()("tablinum/Storage") {
-}
+var Storage = class extends ServiceMap5.Service()("tablinum/Storage") {
+};
 
 // src/services/Relay.ts
 import { ServiceMap as ServiceMap6 } from "effect";
-
-class Relay extends ServiceMap6.Service()("tablinum/Relay") {
-}
+var Relay = class extends ServiceMap6.Service()("tablinum/Relay") {
+};
 
 // src/services/GiftWrap.ts
 import { ServiceMap as ServiceMap7 } from "effect";
-
-class GiftWrap3 extends ServiceMap7.Service()("tablinum/GiftWrap") {
-}
+var GiftWrap3 = class extends ServiceMap7.Service()("tablinum/GiftWrap") {
+};
 
 // src/services/PublishQueue.ts
 import { ServiceMap as ServiceMap8 } from "effect";
-
-class PublishQueue extends ServiceMap8.Service()("tablinum/PublishQueue") {
-}
+var PublishQueue = class extends ServiceMap8.Service()(
+  "tablinum/PublishQueue"
+) {
+};
 
 // src/services/SyncStatus.ts
 import { ServiceMap as ServiceMap9 } from "effect";
-
-class SyncStatus extends ServiceMap9.Service()("tablinum/SyncStatus") {
-}
+var SyncStatus = class 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
@@ -1878,47 +2057,128 @@ function createIdentity(suppliedKey) {
 }
 
 // src/layers/IdentityLive.ts
-var IdentityLive = Layer.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());
-  return identity;
-}));
+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) : void 0);
+    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* () {
-  const config = yield* Config;
-  const identity = yield* Identity;
-  const storage = yield* Storage;
-  const idbRaw = yield* storage.getMeta("epochs");
-  if (typeof idbRaw === "string") {
-    const idbStore = deserializeEpochStore(idbRaw);
-    if (Option7.isSome(idbStore)) {
-      return idbStore.value;
-    }
-  }
-  if (config.epochKeys && config.epochKeys.length > 0) {
-    const store2 = createEpochStoreFromInputs(config.epochKeys);
-    yield* storage.putMeta("epochs", stringifyEpochStore(store2));
-    return store2;
-  }
-  const store = createEpochStoreFromInputs([{ epochId: EpochId("epoch-0"), key: bytesToHex3(generateSecretKey2()) }], { createdBy: identity.publicKey });
-  yield* storage.putMeta("epochs", stringifyEpochStore(store));
-  return store;
-}));
+var EpochStoreLive = Layer3.effect(
+  EpochStore,
+  Effect12.gen(function* () {
+    const config = yield* Config;
+    const identity = yield* Identity;
+    const storage = yield* Storage;
+    const idbRaw = yield* storage.getMeta("epochs");
+    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";
 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}`;
@@ -1949,7 +2209,7 @@ function upgradeSchema(database, schema, tx) {
   if (!database.objectStoreNames.contains("giftwraps")) {
     database.createObjectStore("giftwraps", { keyPath: "id" });
   }
-  const expectedStores = new Set;
+  const expectedStores = /* @__PURE__ */ new Set();
   for (const [, def] of Object.entries(schema)) {
     const sn = storeName(def.name);
     expectedStores.add(sn);
@@ -1963,12 +2223,10 @@ function upgradeSchema(database, schema, tx) {
       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);
+        if (!wantedIndices.has(idx)) store.deleteIndex(idx);
       }
       for (const idx of wantedIndices) {
-        if (!existingIndices.has(idx))
-          store.createIndex(idx, idx);
+        if (!existingIndices.has(idx)) store.createIndex(idx, idx);
       }
     }
   }
@@ -1983,6 +2241,13 @@ 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 })
@@ -1993,7 +2258,7 @@ function openIDBStorage(dbName, schema) {
       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(undefined)));
+      }).pipe(Effect13.catch(() => Effect13.succeed(void 0)));
       needsUpgrade = storedSig !== schemaSig;
     }
     probeDb.close();
@@ -2010,9 +2275,7 @@ function openIDBStorage(dbName, schema) {
     });
     yield* Effect13.addFinalizer(() => Effect13.sync(() => db.close()));
     const handle = {
-      putRecord: (collection2, record) => wrap("putRecord", () => db.put(storeName(collection2), record).then(() => {
-        return;
-      })),
+      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))),
@@ -2032,29 +2295,52 @@ function openIDBStorage(dbName, schema) {
         }
         return results;
       }),
-      putEvent: (event) => wrap("putEvent", () => db.put("events", event).then(() => {
-        return;
-      })),
+      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", () => db.put("giftwraps", gw).then(() => {
-        return;
-      })),
-      getGiftWrap: (id) => wrap("getGiftWrap", () => db.get("giftwraps", id)),
-      getAllGiftWraps: () => wrap("getAllGiftWraps", () => db.getAll("giftwraps")),
-      deleteGiftWrap: (id) => wrap("deleteGiftWrap", () => db.delete("giftwraps", id).then(() => {
-        return;
-      })),
-      stripGiftWrapBlob: (id) => wrap("stripGiftWrapBlob", async () => {
-        const existing = await db.get("giftwraps", id);
-        if (existing) {
-          await db.put("giftwraps", { id: existing.id, createdAt: existing.createdAt });
+      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 });
         }
       }),
-      deleteEvent: (id) => wrap("deleteEvent", () => db.delete("events", id).then(() => {
-        return;
-      })),
+      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) {
@@ -2062,9 +2348,7 @@ function openIDBStorage(dbName, schema) {
         }
       }),
       getMeta: (key) => wrap("getMeta", () => db.get("_meta", key)),
-      putMeta: (key, value) => wrap("putMeta", () => db.put("_meta", value, key).then(() => {
-        return;
-      })),
+      putMeta: (key, value) => wrap("putMeta", () => db.put("_meta", value, key).then(() => void 0)),
       close: () => Effect13.sync(() => db.close())
     };
     return handle;
@@ -2072,16 +2356,21 @@ function openIDBStorage(dbName, schema) {
 }
 
 // src/layers/StorageLive.ts
-var StorageLive = Layer3.effect(Storage, Effect14.gen(function* () {
-  const config = yield* Config;
-  return yield* openIDBStorage(config.dbName, {
-    ...config.schema,
-    _members: membersCollectionDef
-  });
-}));
+var StorageLive = Layer4.effect(
+  Storage,
+  Effect14.gen(function* () {
+    const config = yield* Config;
+    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";
@@ -2092,32 +2381,41 @@ var NegMessageFrameSchema = Schema7.Tuple([
   Schema7.String
 ]);
 var NegErrorFrameSchema = Schema7.Tuple([Schema7.Literal("NEG-ERR"), Schema7.String, Schema7.String]);
-var decodeNegFrame = Schema7.decodeUnknownEffect(Schema7.fromJsonString(Schema7.Union([NegMessageFrameSchema, NegErrorFrameSchema])));
+var decodeNegFrame = Schema7.decodeUnknownEffect(
+  Schema7.fromJsonString(Schema7.Union([NegMessageFrameSchema, NegErrorFrameSchema]))
+);
 function parseNegMessageFrame(data) {
-  return Effect15.runSync(decodeNegFrame(data).pipe(Effect15.map(Option8.some), Effect15.orElseSucceed(() => Option8.none())));
+  return Effect15.runSync(
+    decodeNegFrame(data).pipe(
+      Effect15.map(Option8.some),
+      Effect15.orElseSucceed(() => Option8.none())
+    )
+  );
 }
 function createRelayHandle() {
   return Effect15.gen(function* () {
     const relayScope = yield* Effect15.scope;
     const connections = yield* ScopedCache.make({
       capacity: 64,
-      lookup: (url) => Effect15.acquireRelease(Effect15.tryPromise({
-        try: () => Relay2.connect(url),
-        catch: (e) => new RelayError({
-          message: `Connect to ${url} failed: ${e instanceof Error ? e.message : String(e)}`,
-          url,
-          cause: e
+      lookup: (url) => Effect15.acquireRelease(
+        Effect15.tryPromise({
+          try: () => Relay2.connect(url),
+          catch: (e) => new RelayError({
+            message: `Connect to ${url} failed: ${e instanceof Error ? e.message : String(e)}`,
+            url,
+            cause: e
+          })
+        }),
+        (relay) => Effect15.sync(() => {
+          relay.close();
         })
-      }), (relay) => Effect15.sync(() => {
-        relay.close();
-      }))
+      )
     });
-    const connectedUrls = new Set;
-    const statusListeners = new Set;
+    const connectedUrls = /* @__PURE__ */ new Set();
+    const statusListeners = /* @__PURE__ */ new Set();
     const notifyStatus = () => {
       const status = { connectedUrls: [...connectedUrls] };
-      for (const listener of statusListeners)
-        listener(status);
+      for (const listener of statusListeners) listener(status);
     };
     const markConnected = (url) => {
       if (!connectedUrls.has(url)) {
@@ -2131,66 +2429,98 @@ function createRelayHandle() {
         notifyStatus();
       }
     };
-    const getRelay = (url) => ScopedCache.get(connections, url).pipe(Effect15.flatMap((relay) => relay.connected === false ? ScopedCache.invalidate(connections, url).pipe(Effect15.andThen(ScopedCache.get(connections, url))) : Effect15.succeed(relay)));
-    const withRelay = (url, run) => getRelay(url).pipe(Effect15.tap(() => Effect15.sync(() => markConnected(url))), Effect15.flatMap((relay) => run(relay)), Effect15.tapError(() => ScopedCache.invalidate(connections, url).pipe(Effect15.tap(() => Effect15.sync(() => markDisconnected(url))))));
-    const collectEvents = (url, filters) => withRelay(url, (relay) => Effect15.callback((resume) => {
-      const events = [];
-      let settled = false;
-      let timer;
-      let sub;
-      const cleanup = () => {
-        settled = true;
-        if (timer !== undefined) {
-          clearTimeout(timer);
-          timer = undefined;
-        }
-        sub?.close();
-        sub = undefined;
-      };
-      const fail = (e) => resume(Effect15.fail(new RelayError({
-        message: `Fetch from ${url} failed: ${e instanceof Error ? e.message : String(e)}`,
-        url,
-        cause: e
-      })));
-      try {
-        sub = relay.subscribe([...filters], {
-          onevent(evt) {
-            if (!settled) {
-              events.push(evt);
+    const getRelay = (url) => ScopedCache.get(connections, url).pipe(
+      Effect15.flatMap(
+        (relay) => relay.connected === false ? ScopedCache.invalidate(connections, url).pipe(
+          Effect15.andThen(ScopedCache.get(connections, url))
+        ) : Effect15.succeed(relay)
+      )
+    );
+    const withRelay = (url, run) => getRelay(url).pipe(
+      Effect15.tap(() => Effect15.sync(() => markConnected(url))),
+      Effect15.flatMap((relay) => run(relay)),
+      Effect15.tapError(
+        () => ScopedCache.invalidate(connections, url).pipe(
+          Effect15.tap(() => Effect15.sync(() => markDisconnected(url)))
+        )
+      )
+    );
+    const collectEvents = (url, filters) => withRelay(
+      url,
+      (relay) => Effect15.callback((resume) => {
+        const events = [];
+        let settled = false;
+        let timer;
+        let sub;
+        const cleanup = () => {
+          settled = true;
+          if (timer !== void 0) {
+            clearTimeout(timer);
+            timer = void 0;
+          }
+          sub?.close();
+          sub = void 0;
+        };
+        const fail = (e) => resume(
+          Effect15.fail(
+            new RelayError({
+              message: `Fetch from ${url} failed: ${e instanceof Error ? e.message : String(e)}`,
+              url,
+              cause: e
+            })
+          )
+        );
+        try {
+          sub = relay.subscribe([...filters], {
+            onevent(evt) {
+              if (!settled) {
+                events.push(evt);
+              }
+            },
+            oneose() {
+              if (settled) return;
+              cleanup();
+              resume(Effect15.succeed(events));
             }
-          },
-          oneose() {
-            if (settled)
-              return;
+          });
+          timer = setTimeout(() => {
+            if (settled) return;
             cleanup();
             resume(Effect15.succeed(events));
-          }
-        });
-        timer = setTimeout(() => {
-          if (settled)
-            return;
+          }, 1e4);
+        } catch (e) {
           cleanup();
-          resume(Effect15.succeed(events));
-        }, 1e4);
-      } catch (e) {
-        cleanup();
-        fail(e);
-      }
-      return Effect15.sync(cleanup);
-    }));
+          fail(e);
+        }
+        return Effect15.sync(cleanup);
+      })
+    );
     return {
       publish: (event, urls) => Effect15.gen(function* () {
-        const results = yield* Effect15.forEach(urls, (url) => Effect15.result(withRelay(url, (relay) => Effect15.tryPromise({
-          try: () => relay.publish(event),
-          catch: (e) => new RelayError({
-            message: `Publish to ${url} failed: ${e instanceof Error ? e.message : String(e)}`,
-            url,
-            cause: e
-          })
-        }).pipe(Effect15.timeoutOrElse({
-          duration: "10 seconds",
-          onTimeout: () => Effect15.fail(new RelayError({ message: `Publish to ${url} timed out`, url }))
-        })))), { concurrency: "unbounded" });
+        const results = yield* Effect15.forEach(
+          urls,
+          (url) => Effect15.result(
+            withRelay(
+              url,
+              (relay) => Effect15.tryPromise({
+                try: () => relay.publish(event),
+                catch: (e) => new RelayError({
+                  message: `Publish to ${url} failed: ${e instanceof Error ? e.message : String(e)}`,
+                  url,
+                  cause: e
+                })
+              }).pipe(
+                Effect15.timeoutOrElse({
+                  duration: "10 seconds",
+                  onTimeout: () => Effect15.fail(
+                    new RelayError({ message: `Publish to ${url} timed out`, url })
+                  )
+                })
+              )
+            )
+          ),
+          { concurrency: "unbounded" }
+        );
         const failures = results.filter((r) => r._tag === "Failure");
         if (failures.length === urls.length && urls.length > 0) {
           return yield* new RelayError({
@@ -2199,90 +2529,104 @@ function createRelayHandle() {
         }
       }),
       fetchEvents: (ids, url) => Effect15.gen(function* () {
-        if (ids.length === 0)
-          return [];
+        if (ids.length === 0) return [];
         return yield* collectEvents(url, [{ ids }]);
       }),
       fetchByFilter: (filter, url) => collectEvents(url, [filter]),
-      subscribe: (filter, url, onEvent) => withRelay(url, (relay) => Effect15.acquireRelease(Effect15.try({
-        try: () => relay.subscribe([filter], {
-          onevent(evt) {
-            onEvent(evt);
-          },
-          oneose() {}
-        }),
-        catch: (e) => new RelayError({
-          message: `Subscribe to ${url} failed: ${e instanceof Error ? e.message : String(e)}`,
-          url,
-          cause: e
-        })
-      }), (sub) => Effect15.sync(() => {
-        sub.close();
-      })).pipe(Effect15.provideService(Scope3.Scope, relayScope), Effect15.asVoid)),
-      sendNegMsg: (url, subId, filter, msgHex) => withRelay(url, (relay) => Effect15.callback((resume) => {
-        let settled = false;
-        let timer;
-        let sub;
-        let ws;
-        const cleanup = () => {
-          settled = true;
-          if (timer !== undefined) {
-            clearTimeout(timer);
-            timer = undefined;
-          }
-          sub?.close();
-          sub = undefined;
-          ws?.removeEventListener("message", handler);
-          ws = undefined;
-        };
-        const fail = (e) => resume(Effect15.fail(new RelayError({
-          message: `NIP-77 negotiation with ${url} failed: ${e instanceof Error ? e.message : String(e)}`,
-          url,
-          cause: e
-        })));
-        const handler = (msg) => {
-          if (settled || typeof msg.data !== "string")
-            return;
-          const frameOpt = parseNegMessageFrame(msg.data);
-          if (Option8.isNone(frameOpt) || frameOpt.value[1] !== subId)
-            return;
-          const frame = frameOpt.value;
-          cleanup();
-          if (frame[0] === "NEG-MSG") {
-            resume(Effect15.succeed({
-              msgHex: frame[2],
-              haveIds: [],
-              needIds: []
-            }));
-            return;
-          }
-          fail(new Error(`NEG-ERR: ${frame[2]}`));
-        };
-        try {
-          sub = relay.subscribe([filter], {
-            onevent() {},
-            oneose() {}
-          });
-          ws = relay._ws || relay.ws;
-          if (!ws) {
+      subscribe: (filter, url, onEvent) => withRelay(
+        url,
+        (relay) => Effect15.acquireRelease(
+          Effect15.try({
+            try: () => relay.subscribe([filter], {
+              onevent(evt) {
+                onEvent(evt);
+              },
+              oneose() {
+              }
+            }),
+            catch: (e) => new RelayError({
+              message: `Subscribe to ${url} failed: ${e instanceof Error ? e.message : String(e)}`,
+              url,
+              cause: e
+            })
+          }),
+          (sub) => Effect15.sync(() => {
+            sub.close();
+          })
+        ).pipe(Effect15.provideService(Scope3.Scope, relayScope), Effect15.asVoid)
+      ),
+      sendNegMsg: (url, subId, filter, msgHex) => withRelay(
+        url,
+        (relay) => Effect15.callback((resume) => {
+          let settled = false;
+          let timer;
+          let sub;
+          let ws;
+          const cleanup = () => {
+            settled = true;
+            if (timer !== void 0) {
+              clearTimeout(timer);
+              timer = void 0;
+            }
+            sub?.close();
+            sub = void 0;
+            ws?.removeEventListener("message", handler);
+            ws = void 0;
+          };
+          const fail = (e) => resume(
+            Effect15.fail(
+              new RelayError({
+                message: `NIP-77 negotiation with ${url} failed: ${e instanceof Error ? e.message : String(e)}`,
+                url,
+                cause: e
+              })
+            )
+          );
+          const handler = (msg) => {
+            if (settled || typeof msg.data !== "string") return;
+            const frameOpt = parseNegMessageFrame(msg.data);
+            if (Option8.isNone(frameOpt) || frameOpt.value[1] !== subId) return;
+            const frame = frameOpt.value;
             cleanup();
-            fail(new Error("Cannot access relay WebSocket"));
-            return Effect15.succeed(undefined);
-          }
-          timer = setTimeout(() => {
-            if (settled)
+            if (frame[0] === "NEG-MSG") {
+              resume(
+                Effect15.succeed({
+                  msgHex: frame[2],
+                  haveIds: [],
+                  needIds: []
+                })
+              );
               return;
+            }
+            fail(new Error(`NEG-ERR: ${frame[2]}`));
+          };
+          try {
+            sub = relay.subscribe([filter], {
+              onevent() {
+              },
+              oneose() {
+              }
+            });
+            ws = relay._ws || relay.ws;
+            if (!ws) {
+              cleanup();
+              fail(new Error("Cannot access relay WebSocket"));
+              return Effect15.succeed(void 0);
+            }
+            timer = setTimeout(() => {
+              if (settled) return;
+              cleanup();
+              fail(new Error("NIP-77 negotiation timeout"));
+            }, 3e4);
+            ws.addEventListener("message", handler);
+            ws.send(JSON.stringify(["NEG-OPEN", subId, filter, msgHex]));
+          } catch (e) {
             cleanup();
-            fail(new Error("NIP-77 negotiation timeout"));
-          }, 30000);
-          ws.addEventListener("message", handler);
-          ws.send(JSON.stringify(["NEG-OPEN", subId, filter, msgHex]));
-        } catch (e) {
-          cleanup();
-          fail(e);
-        }
-        return Effect15.sync(cleanup);
-      })),
+            fail(e);
+          }
+          return Effect15.sync(cleanup);
+        })
+      ),
       closeAll: () => ScopedCache.invalidateAll(connections),
       getStatus: () => ({ connectedUrls: [...connectedUrls] }),
       subscribeStatus: (callback) => {
@@ -2294,10 +2638,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";
@@ -2334,14 +2678,17 @@ function createEpochGiftWrapHandle(senderPrivateKey, epochStore) {
 }
 
 // src/layers/GiftWrapLive.ts
-var GiftWrapLive = Layer5.effect(GiftWrap3, Effect17.gen(function* () {
-  const identity = yield* Identity;
-  const epochStore = yield* EpochStore;
-  return createEpochGiftWrapHandle(identity.privateKey, epochStore);
-}));
+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";
@@ -2352,12 +2699,11 @@ function persist(storage, pending) {
 function createPublishQueue(storage, relay) {
   return Effect18.gen(function* () {
     const stored = yield* storage.getMeta(META_KEY);
-    const initial = Array.isArray(stored) ? new Set(stored) : new Set;
+    const initial = Array.isArray(stored) ? new Set(stored) : /* @__PURE__ */ new Set();
     const pendingRef = yield* Ref4.make(initial);
-    const listeners = new Set;
+    const listeners = /* @__PURE__ */ new Set();
     const notify = (pending) => {
-      for (const listener of listeners)
-        listener(pending.size);
+      for (const listener of listeners) listener(pending.size);
     };
     return {
       enqueue: (eventId) => Effect18.gen(function* () {
@@ -2371,13 +2717,11 @@ function createPublishQueue(storage, relay) {
       }),
       flush: (relayUrls) => Effect18.gen(function* () {
         const pending = yield* Ref4.get(pendingRef);
-        if (pending.size === 0)
-          return;
-        const succeeded = new Set;
+        if (pending.size === 0) return;
+        const succeeded = /* @__PURE__ */ new Set();
         let consecutiveFailures = 0;
         for (const eventId of pending) {
-          if (consecutiveFailures >= 3)
-            break;
+          if (consecutiveFailures >= 3) break;
           const gw = yield* storage.getGiftWrap(eventId);
           if (!gw || !gw.event) {
             succeeded.add(eventId);
@@ -2387,7 +2731,6 @@ function createPublishQueue(storage, relay) {
           const result = yield* Effect18.result(relay.publish(gw.event, relayUrls));
           if (result._tag === "Success") {
             succeeded.add(eventId);
-            yield* storage.stripGiftWrapBlob(eventId);
             consecutiveFailures = 0;
           } else {
             consecutiveFailures++;
@@ -2415,27 +2758,29 @@ function createPublishQueue(storage, relay) {
 }
 
 // src/layers/PublishQueueLive.ts
-var PublishQueueLive = Layer6.effect(PublishQueue, Effect19.gen(function* () {
-  const storage = yield* Storage;
-  const relay = yield* Relay;
-  return yield* createPublishQueue(storage, relay);
-}));
+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";
 function createSyncStatusHandle() {
   return Effect20.gen(function* () {
     const ref = yield* SubscriptionRef.make("idle");
-    const listeners = new Set;
+    const listeners = /* @__PURE__ */ new Set();
     return {
       get: () => SubscriptionRef.get(ref),
       set: (status) => Effect20.gen(function* () {
         yield* SubscriptionRef.set(ref, status);
-        for (const listener of listeners)
-          listener(status);
+        for (const listener of listeners) listener(status);
       }),
       subscribe: (callback) => {
         listeners.add(callback);
@@ -2446,12 +2791,11 @@ 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) {
-  if (!onSyncError)
-    return;
+  if (!onSyncError) return;
   onSyncError(error instanceof Error ? error : new Error(String(error)));
 }
 function mapMemberRecord(record) {
@@ -2459,239 +2803,365 @@ function mapMemberRecord(record) {
     id: record.id,
     addedAt: record.addedAt,
     addedInEpoch: record.addedInEpoch,
-    ...record.name !== undefined ? { name: record.name } : {},
-    ...record.picture !== undefined ? { picture: record.picture } : {},
-    ...record.about !== undefined ? { about: record.about } : {},
-    ...record.nip05 !== undefined ? { nip05: record.nip05 } : {},
-    ...record.removedAt !== undefined ? { removedAt: record.removedAt } : {},
-    ...record.removedInEpoch !== undefined ? { removedInEpoch: record.removedInEpoch } : {}
+    ...record.name !== void 0 ? { name: record.name } : {},
+    ...record.picture !== void 0 ? { picture: record.picture } : {},
+    ...record.about !== void 0 ? { about: record.about } : {},
+    ...record.nip05 !== void 0 ? { nip05: record.nip05 } : {},
+    ...record.removedAt !== void 0 ? { removedAt: record.removedAt } : {},
+    ...record.removedInEpoch !== void 0 ? { 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* () {
-  const config = yield* Config;
-  const identity = yield* Identity;
-  const epochStore = yield* EpochStore;
-  const storage = yield* Storage;
-  const relay = yield* Relay;
-  const giftWrap = yield* GiftWrap3;
-  const publishQueue = yield* PublishQueue;
-  const syncStatus = yield* SyncStatus;
-  const scope = yield* Effect21.scope;
-  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 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 onWrite = (event) => Effect21.gen(function* () {
-    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,
-      content,
-      tags: [["d", dTag]],
-      created_at: Math.floor(event.createdAt / 1000)
-    }));
-    if (wrapResult._tag === "Failure") {
-      reportSyncError(config.onSyncError, wrapResult.failure);
-      return;
-    }
-    const gw = wrapResult.success;
-    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,
-        event: gw,
-        createdAt: gw.created_at
-      }));
-      if (publishResult._tag === "Failure") {
-        reportSyncError(config.onSyncError, publishResult.failure);
+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;
+    const storage = yield* Storage;
+    const relay = yield* Relay;
+    const giftWrap = yield* GiftWrap3;
+    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 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.logLevel,
+      config.onSyncError ? (error) => reportSyncError(config.onSyncError, error) : void 0,
+      (pubkey) => notifyAuthor?.(pubkey),
+      config.onRemoved,
+      config.onMembersChanged
+    );
+    const onWrite = (event) => Effect21.gen(function* () {
+      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,
+          content,
+          tags: [["d", dTag]],
+          created_at: Math.floor(event.createdAt / 1e3)
+        })
+      );
+      if (wrapResult._tag === "Failure") {
+        reportSyncError(config.onSyncError, wrapResult.failure);
+        return;
       }
-    }), scope);
-  });
-  const knownAuthors = new Set;
-  const putMemberRecord = (record) => Effect21.gen(function* () {
-    const existing = yield* storage.getRecord("_members", record.id);
-    const event = {
-      id: uuidv7(),
-      collection: "_members",
-      recordId: record.id,
-      kind: existing ? "u" : "c",
-      data: record,
-      createdAt: Date.now(),
-      author: identity.publicKey
-    };
-    yield* storage.putEvent(event);
-    yield* applyEvent(storage, event);
-    yield* onWrite(event);
-    yield* notifyChange(watchCtx, {
-      collection: "_members",
-      recordId: record.id,
-      kind: existing ? "update" : "create"
+      const gw = wrapResult.success;
+      yield* storage.putGiftWrap({ id: gw.id, event: gw, createdAt: gw.created_at });
+      yield* Effect21.forkIn(
+        Effect21.gen(function* () {
+          const publishResult = yield* Effect21.result(
+            syncHandle.publishLocal({
+              id: gw.id,
+              event: gw,
+              createdAt: gw.created_at
+            })
+          );
+          if (publishResult._tag === "Failure") {
+            reportSyncError(config.onSyncError, publishResult.failure);
+          }
+        }),
+        scope
+      );
     });
-    config.onMembersChanged?.();
-  });
-  notifyAuthor = (pubkey) => {
-    if (knownAuthors.has(pubkey))
-      return;
-    knownAuthors.add(pubkey);
-    Effect21.runFork(Effect21.gen(function* () {
-      const existing = yield* storage.getRecord("_members", pubkey);
-      if (!existing) {
-        yield* putMemberRecord({
-          id: pubkey,
-          addedAt: Date.now(),
-          addedInEpoch: getCurrentEpoch(epochStore).id
-        });
-      }
-      const profileOpt = yield* fetchAuthorProfile(relay, config.relays, pubkey).pipe(Effect21.catchTag("RelayError", () => Effect21.succeed(Option9.none())));
-      if (Option9.isSome(profileOpt)) {
-        const current = yield* storage.getRecord("_members", pubkey);
-        if (current) {
-          yield* storage.putRecord("_members", {
-            ...current,
-            ...profileOpt.value
-          });
-          yield* notifyChange(watchCtx, {
-            collection: "_members",
-            recordId: pubkey,
-            kind: "update"
-          });
-          config.onMembersChanged?.();
-        }
-      }
-    }).pipe(Effect21.ignore, 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, identity.publicKey, onWrite);
-    handles.set(def.name, handle);
-  }
-  yield* syncHandle.startSubscription();
-  const selfMember = yield* storage.getRecord("_members", identity.publicKey);
-  if (!selfMember) {
-    yield* putMemberRecord({
-      id: identity.publicKey,
-      addedAt: Date.now(),
-      addedInEpoch: getCurrentEpoch(epochStore).id
+    const knownAuthors = /* @__PURE__ */ new Set();
+    const putMemberRecord = (record) => Effect21.gen(function* () {
+      const existing = yield* storage.getRecord("_members", record.id);
+      const event = {
+        id: uuidv7(),
+        collection: "_members",
+        recordId: record.id,
+        kind: existing ? "u" : "c",
+        data: record,
+        createdAt: Date.now(),
+        author: identity.publicKey
+      };
+      yield* storage.putEvent(event);
+      yield* applyEvent(storage, event);
+      yield* onWrite(event);
+      yield* notifyChange(watchCtx, {
+        collection: "_members",
+        recordId: record.id,
+        kind: existing ? "update" : "create"
+      });
+      config.onMembersChanged?.();
     });
-  }
-  const ensureOpen = (effect) => 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* () {
-    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);
-      if (!handle)
-        throw new Error(`Collection "${name}" not found in schema`);
-      return handle;
-    },
-    publicKey: identity.publicKey,
-    members: handles.get("_members"),
-    exportKey: () => identity.exportKey(),
-    exportInvite: () => ({
-      epochKeys: [...exportEpochKeys(epochStore)],
-      relays: [...config.relays],
-      dbName: config.dbName
-    }),
-    close: () => 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(),
-    subscribeSyncStatus: (callback) => syncStatus.subscribe(callback),
-    pendingCount: () => publishQueue.size(),
-    subscribePendingCount: (callback) => publishQueue.subscribe(callback),
-    getRelayStatus: () => relay.getStatus(),
-    subscribeRelayStatus: (callback) => relay.subscribeStatus(callback),
-    addMember: (pubkey) => ensureOpen(Effect21.gen(function* () {
-      const existing = yield* storage.getRecord("_members", pubkey);
-      if (existing && !existing.removedAt)
-        return;
+    notifyAuthor = (pubkey) => {
+      if (knownAuthors.has(pubkey)) return;
+      knownAuthors.add(pubkey);
+      Effect21.runFork(
+        Effect21.gen(function* () {
+          const existing = yield* storage.getRecord("_members", pubkey);
+          if (!existing) {
+            yield* putMemberRecord({
+              id: pubkey,
+              addedAt: Date.now(),
+              addedInEpoch: getCurrentEpoch(epochStore).id
+            });
+          }
+          const profileOpt = yield* fetchAuthorProfile(relay, config.relays, pubkey).pipe(
+            Effect21.catchTag("RelayError", () => Effect21.succeed(Option9.none()))
+          );
+          if (Option9.isSome(profileOpt)) {
+            const current = yield* storage.getRecord("_members", pubkey);
+            if (current) {
+              yield* storage.putRecord("_members", {
+                ...current,
+                ...profileOpt.value
+              });
+              yield* notifyChange(watchCtx, {
+                collection: "_members",
+                recordId: pubkey,
+                kind: "update"
+              });
+              config.onMembersChanged?.();
+            }
+          }
+        }).pipe(Effect21.ignore, Effect21.provide(logLayer), Effect21.forkIn(scope))
+      );
+    };
+    const handles = /* @__PURE__ */ 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,
+        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({
-        id: pubkey,
+        id: identity.publicKey,
         addedAt: Date.now(),
-        addedInEpoch: getCurrentEpoch(epochStore).id,
-        ...existing ? { removedAt: undefined, removedInEpoch: undefined } : {}
-      });
-    })),
-    removeMember: (pubkey) => ensureOpen(Effect21.gen(function* () {
-      const allMembers = yield* storage.getAllRecords("_members");
-      const activeMembers = allMembers.filter((member) => !member.removedAt && member.id !== pubkey);
-      const activePubkeys = activeMembers.map((member) => member.id);
-      const result = createRotation(epochStore, identity.privateKey, identity.publicKey, activePubkeys, [pubkey]);
-      addEpoch(epochStore, result.epoch);
-      epochStore.currentEpochId = result.epoch.id;
-      yield* storage.putMeta("epochs", stringifyEpochStore(epochStore));
-      const memberRecord = yield* storage.getRecord("_members", pubkey);
-      yield* putMemberRecord({
-        ...memberRecord ?? {
-          id: pubkey,
-          addedAt: 0,
-          addedInEpoch: EpochId("epoch-0")
-        },
-        removedAt: Date.now(),
-        removedInEpoch: result.epoch.id
+        addedInEpoch: getCurrentEpoch(epochStore).id
       });
-      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* Effect21.forEach(result.removalNotices, (notice) => relay.publish(notice, [...config.relays]).pipe(Effect21.tapError((e) => Effect21.sync(() => reportSyncError(config.onSyncError, e))), Effect21.ignore), { discard: true });
-      yield* syncHandle.addEpochSubscription(result.epoch.publicKey);
-    })),
-    getMembers: () => ensureOpen(Effect21.gen(function* () {
-      const allRecords = yield* storage.getAllRecords("_members");
-      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" });
-      }
-      const { _d, _u, _a, _e, ...memberFields } = existing;
-      yield* putMemberRecord({ ...memberFields, ...profile });
-    }))
-  };
-  return dbHandle;
-})).pipe(Layer8.provide(AllServicesLive));
+    }
+    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) => 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);
+        if (!handle) throw new Error(`Collection "${name}" not found in schema`);
+        return handle;
+      },
+      publicKey: identity.publicKey,
+      members: handles.get("_members"),
+      exportKey: () => identity.exportKey(),
+      exportInvite: () => ({
+        epochKeys: [...exportEpochKeys(epochStore)],
+        relays: [...config.relays],
+        dbName: config.dbName
+      }),
+      close: () => withLog(
+        Effect21.gen(function* () {
+          if (yield* Ref5.get(closedRef)) return;
+          yield* Ref5.set(closedRef, true);
+          syncHandle.stopHealing();
+          yield* Scope4.close(scope, Exit.void);
+        })
+      ),
+      rebuild: () => ensureOpen(
+        rebuild(
+          storage,
+          allSchemaEntries.map(([, def]) => def.name)
+        )
+      ),
+      sync: () => ensureSyncOpen(
+        syncHandle.sync().pipe(
+          Effect21.tap(
+            () => Effect21.sync(() => {
+              syncHandle.startHealing();
+            })
+          )
+        )
+      ),
+      getSyncStatus: () => syncStatus.get(),
+      subscribeSyncStatus: (callback) => syncStatus.subscribe(callback),
+      pendingCount: () => publishQueue.size(),
+      subscribePendingCount: (callback) => publishQueue.subscribe(callback),
+      getRelayStatus: () => relay.getStatus(),
+      subscribeRelayStatus: (callback) => relay.subscribeStatus(callback),
+      addMember: (pubkey) => ensureOpen(
+        Effect21.gen(function* () {
+          const existing = yield* storage.getRecord("_members", pubkey);
+          if (existing && !existing.removedAt) return;
+          yield* putMemberRecord({
+            id: pubkey,
+            addedAt: Date.now(),
+            addedInEpoch: getCurrentEpoch(epochStore).id,
+            ...existing ? { removedAt: void 0, removedInEpoch: void 0 } : {}
+          });
+        })
+      ),
+      removeMember: (pubkey) => ensureOpen(
+        Effect21.gen(function* () {
+          const allMembers = yield* storage.getAllRecords("_members");
+          const activeMembers = allMembers.filter(
+            (member) => !member.removedAt && member.id !== pubkey
+          );
+          const activePubkeys = activeMembers.map((member) => member.id);
+          const result = createRotation(
+            epochStore,
+            identity.privateKey,
+            identity.publicKey,
+            activePubkeys,
+            [pubkey]
+          );
+          addEpoch(epochStore, result.epoch);
+          epochStore.currentEpochId = result.epoch.id;
+          yield* storage.putMeta("epochs", stringifyEpochStore(epochStore));
+          const memberRecord = yield* storage.getRecord("_members", pubkey);
+          yield* putMemberRecord({
+            ...memberRecord ?? {
+              id: pubkey,
+              addedAt: 0,
+              addedInEpoch: EpochId("epoch-0")
+            },
+            removedAt: Date.now(),
+            removedInEpoch: result.epoch.id
+          });
+          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* Effect21.forEach(
+            result.removalNotices,
+            (notice) => relay.publish(notice, [...config.relays]).pipe(
+              Effect21.tapError((e) => Effect21.sync(() => reportSyncError(config.onSyncError, e))),
+              Effect21.ignore
+            ),
+            { discard: true }
+          );
+          yield* syncHandle.addEpochSubscription(result.epoch.publicKey);
+        })
+      ),
+      getMembers: () => ensureOpen(
+        Effect21.gen(function* () {
+          const allRecords = yield* storage.getAllRecords("_members");
+          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 !== void 0) profile.name = record.name;
+          if (record.picture !== void 0) profile.picture = record.picture;
+          if (record.about !== void 0) profile.about = record.about;
+          if (record.nip05 !== void 0) 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" });
+          }
+          const { _d, _u, _a, _e, ...memberFields } = existing;
+          yield* putMemberRecord({ ...memberFields, ...profile });
+        })
+      )
+    };
+    return dbHandle;
+  }).pipe(Effect21.withLogSpan("tablinum.init"))
+).pipe(Layer9.provide(AllServicesLive));
 
 // src/db/create-tablinum.ts
+function resolveLogLevel(input) {
+  if (input === void 0 || 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) {
@@ -2705,22 +3175,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() {
@@ -2735,14 +3208,12 @@ function createDeferred() {
     promise,
     settled: () => settled,
     resolve: (value) => {
-      if (settled)
-        return;
+      if (settled) return;
       settled = true;
       resolvePromise(value);
     },
     reject: (reason) => {
-      if (settled)
-        return;
+      if (settled) return;
       settled = true;
       rejectPromise(reason);
     }
@@ -2764,7 +3235,9 @@ function wrapQueryBuilder(getBuilder, touchVersion, ready) {
     },
     first: () => {
       touchVersion();
-      return ready.then(() => Effect23.runPromise(Effect23.map(getBuilder().first(), Option10.getOrNull)));
+      return ready.then(
+        () => Effect23.runPromise(Effect23.map(getBuilder().first(), Option10.getOrNull))
+      );
     },
     count: () => {
       touchVersion();
@@ -2796,7 +3269,9 @@ function wrapOrderByBuilder(getBuilder, touchVersion, ready) {
     },
     first: () => {
       touchVersion();
-      return ready.then(() => Effect23.runPromise(Effect23.map(getBuilder().first(), Option10.getOrNull)));
+      return ready.then(
+        () => Effect23.runPromise(Effect23.map(getBuilder().first(), Option10.getOrNull))
+      );
     },
     count: () => {
       touchVersion();
@@ -2806,21 +3281,24 @@ function wrapOrderByBuilder(getBuilder, touchVersion, ready) {
 }
 
 // src/svelte/collection.svelte.ts
-class Collection {
+var Collection = class {
   error = $state(null);
   #handle = null;
   #ready = createDeferred();
   #version = $state(0);
   #watchAbort = null;
   #watchFiber = null;
-  _bind(handle) {
-    if (this.#handle)
-      return;
+  #logLevel = "None";
+  /** @internal */
+  _bind(handle, logLevel = "None") {
+    if (this.#handle) return;
     this.#handle = handle;
+    this.#logLevel = logLevel;
     this.error = null;
     this.#settleReady();
     this.#startWatch();
   }
+  /** @internal */
   _fail(err) {
     this.error = err;
     this.#settleReady(err);
@@ -2833,31 +3311,41 @@ class Collection {
     }
   }
   #startWatch() {
-    if (!this.#handle)
-      return;
-    const abort = new AbortController;
+    if (!this.#handle) return;
+    const abort = new AbortController();
     this.#watchAbort = abort;
-    this.#watchFiber = Effect24.runFork(Stream4.runForEach(this.#handle.watch(), (_records) => Effect24.sync(() => {
-      if (!abort.signal.aborted) {
-        this.#version++;
-      }
-    })).pipe(Effect24.catch((e) => Effect24.sync(() => {
-      if (!abort.signal.aborted) {
-        this.error = e instanceof Error ? e : new Error(String(e));
-      }
-    }))));
+    this.#watchFiber = Effect24.runFork(
+      Stream4.runForEach(
+        this.#handle.watch(),
+        (_records) => Effect24.sync(() => {
+          if (!abort.signal.aborted) {
+            this.#version++;
+          }
+        })
+      ).pipe(
+        Effect24.catch(
+          (e) => Effect24.sync(() => {
+            if (!abort.signal.aborted) {
+              this.error = e instanceof Error ? e : new Error(String(e));
+            }
+          })
+        ),
+        Effect24.provideService(References5.MinimumLogLevel, this.#logLevel)
+      )
+    );
   }
   #touchVersion = () => {
-    this.#version;
+    void this.#version;
   };
   #handleOrThrow = () => {
-    if (this.#handle)
-      return this.#handle;
+    if (this.#handle) return this.#handle;
     throw this.error ?? new ClosedError({ message: "Collection is not ready" });
   };
   #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));
@@ -2876,7 +3364,11 @@ class Collection {
       return this.#run(() => this.#handleOrThrow().get(id));
     }
     this.#touchVersion();
-    return this.#run(() => Stream4.runHead(this.#handleOrThrow().watch()).pipe(Effect24.map((opt) => Option11.getOrElse(opt, () => []))));
+    return this.#run(
+      () => Stream4.runHead(this.#handleOrThrow().watch()).pipe(
+        Effect24.map((opt) => Option11.getOrElse(opt, () => []))
+      )
+    );
   }
   first = () => {
     this.#touchVersion();
@@ -2887,11 +3379,20 @@ class Collection {
     return this.#run(() => this.#handleOrThrow().count());
   };
   where = (field2) => {
-    return wrapWhereClause(() => this.#handleOrThrow().where(field2), this.#touchVersion, this.#ready.promise);
+    return wrapWhereClause(
+      () => this.#handleOrThrow().where(field2),
+      this.#touchVersion,
+      this.#ready.promise
+    );
   };
   orderBy = (field2) => {
-    return wrapOrderByBuilder(() => this.#handleOrThrow().orderBy(field2), this.#touchVersion, this.#ready.promise);
+    return wrapOrderByBuilder(
+      () => this.#handleOrThrow().orderBy(field2),
+      this.#touchVersion,
+      this.#ready.promise
+    );
   };
+  /** @internal */
   _destroy(reason = new ClosedError({ message: "Collection is closed" })) {
     if (this.#watchAbort) {
       this.#watchAbort.abort();
@@ -2905,10 +3406,10 @@ class Collection {
     this.error ??= reason;
     this.#settleReady(this.error);
   }
-}
+};
 
 // src/svelte/tablinum.svelte.ts
-class Tablinum2 {
+var Tablinum2 = class {
   status = $state("initializing");
   syncStatus = $state("idle");
   pendingCount = $state(0);
@@ -2917,15 +3418,17 @@ class Tablinum2 {
   ready;
   #handle = null;
   #scope = null;
-  #collections = new Map;
-  #members = new Collection;
+  #collections = /* @__PURE__ */ new Map();
+  #members = new Collection();
   #unsubscribeSyncStatus = null;
   #unsubscribePendingCount = null;
   #unsubscribeRelayStatus = null;
   #closed = false;
   #readyState = createDeferred();
+  #logLevel;
   constructor(config) {
     this.ready = this.#readyState.promise;
+    this.#logLevel = resolveLogLevel(config.logLevel);
     this.#init(config);
   }
   #settleReady(err) {
@@ -2936,25 +3439,29 @@ 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;
     }
   };
-  async#init(config) {
+  async #init(config) {
     const scope = Effect25.runSync(Scope6.make());
     try {
-      const handle = await Effect25.runPromise(createTablinum(config).pipe(Effect25.provideService(Scope6.Scope, scope)));
+      const handle = await Effect25.runPromise(
+        createTablinum(config).pipe(Effect25.provideService(Scope6.Scope, scope))
+      );
       if (this.#closed) {
         await Effect25.runPromise(Scope6.close(scope, Exit2.void));
         this.#scope = null;
@@ -2977,7 +3484,8 @@ class Tablinum2 {
       this.status = "ready";
       this.#settleReady();
     } catch (e) {
-      await Effect25.runPromise(Scope6.close(scope, Exit2.fail(e))).catch(() => {});
+      await Effect25.runPromise(Scope6.close(scope, Exit2.fail(e))).catch(() => {
+      });
       const err = e instanceof Error ? e : new Error(String(e));
       this.error = err;
       this.status = "error";
@@ -3000,10 +3508,10 @@ class Tablinum2 {
     }
     let col = this.#collections.get(name);
     if (!col) {
-      col = new Collection;
+      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;
@@ -3021,8 +3529,7 @@ class Tablinum2 {
     return this.#requireReady().exportInvite();
   }
   close = async () => {
-    if (this.#closed)
-      return;
+    if (this.#closed) return;
     this.#closed = true;
     const closeError = new ClosedError({
       message: this.#readyState.settled() ? "Tablinum is closed" : "Tablinum was closed before initialization completed"
@@ -3040,8 +3547,7 @@ class Tablinum2 {
       this.#unsubscribeRelayStatus = null;
     }
     this.#members._destroy(closeError);
-    for (const col of this.#collections.values())
-      col._destroy(closeError);
+    for (const col of this.#collections.values()) col._destroy(closeError);
     this.#collections.clear();
     const handle = this.#handle;
     const scope = this.#scope;
@@ -3064,19 +3570,19 @@ class Tablinum2 {
   getMembers = async () => this.#runHandleEffect((handle) => handle.getMembers());
   getProfile = async () => this.#runHandleEffect((handle) => handle.getProfile());
   setProfile = async (profile) => this.#runHandleEffect((handle) => handle.setProfile(profile));
-}
+};
 export {
-  field,
-  encodeInvite,
-  decodeInvite,
-  collection,
-  ValidationError,
-  Tablinum2 as Tablinum,
-  SyncError,
-  StorageError,
-  RelayError,
-  NotFoundError,
-  CryptoError,
+  ClosedError,
   Collection,
-  ClosedError
+  CryptoError,
+  NotFoundError,
+  RelayError,
+  StorageError,
+  SyncError,
+  Tablinum2 as Tablinum,
+  ValidationError,
+  collection,
+  decodeInvite,
+  encodeInvite,
+  field
 };