tablinum 0.1.3 → 0.2.0

package/dist/svelte/index.svelte.js

@@ -6,15 +6,188 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
-// src/svelte/index.svelte.ts
-import { Effect as Effect19, Exit as Exit2, Scope as Scope4 } from "effect";
+// src/schema/field.ts
+function make(kind, isOptional, isArray) {
+  return { _tag: "FieldDef", kind, isOptional, isArray };
+}
+var field = {
+  string: () => make("string", false, false),
+  number: () => make("number", false, false),
+  boolean: () => make("boolean", false, false),
+  json: () => make("json", false, false),
+  optional: (inner) => make(inner.kind, true, inner.isArray),
+  array: (inner) => make(inner.kind, inner.isOptional, true)
+};
+// src/schema/collection.ts
+var RESERVED_NAMES = new Set(["id", "_deleted", "_createdAt", "_updatedAt"]);
+function collection(name, fields, options) {
+  if (!name || name.trim().length === 0) {
+    throw new Error("Collection name must not be empty");
+  }
+  const fieldNames = Object.keys(fields);
+  if (fieldNames.length === 0) {
+    throw new Error(`Collection "${name}" must have at least one field`);
+  }
+  for (const fieldName of fieldNames) {
+    if (RESERVED_NAMES.has(fieldName)) {
+      throw new Error(`Field name "${fieldName}" is reserved`);
+    }
+  }
+  const indices = [];
+  if (options?.indices) {
+    for (const idx of options.indices) {
+      const fieldDef = fields[idx];
+      if (!fieldDef) {
+        throw new Error(`Index field "${idx}" does not exist in collection "${name}"`);
+      }
+      if (fieldDef.kind === "json" || fieldDef.isArray) {
+        throw new Error(`Field "${idx}" cannot be indexed (type: ${fieldDef.kind}${fieldDef.isArray ? "[]" : ""})`);
+      }
+      indices.push(idx);
+    }
+  }
+  return { _tag: "CollectionDef", name, fields, indices };
+}
+// src/db/invite.ts
+import { Schema as Schema2 } from "effect";
 
-// src/db/create-tablinum.ts
-import { Effect as Effect14, PubSub as PubSub2, Ref as Ref5 } from "effect";
+// src/db/epoch.ts
+import { Option, Schema } from "effect";
+import { getPublicKey } from "nostr-tools/pure";
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils.js";
 
-// src/schema/validate.ts
-import { Effect, Schema } from "effect";
+// src/brands.ts
+import { Brand } from "effect";
+var EpochId = Brand.nominal();
+var DatabaseName = Brand.nominal();
+
+// src/db/epoch.ts
+var HexKeySchema = Schema.String.check(Schema.isPattern(/^[0-9a-f]{64}$/i));
+var EpochKeyInputSchema = Schema.Struct({
+  epochId: Schema.String,
+  key: HexKeySchema
+});
+var PersistedEpochSchema = Schema.Struct({
+  id: Schema.String,
+  privateKey: HexKeySchema,
+  createdBy: Schema.String,
+  parentEpoch: Schema.optionalKey(Schema.String)
+});
+var PersistedEpochStoreSchema = Schema.Struct({
+  epochs: Schema.Array(PersistedEpochSchema),
+  currentEpochId: Schema.String
+});
+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;
+}
+function createEpochStore(initialEpoch) {
+  const epochs = new Map;
+  const keysByPublicKey = new Map;
+  epochs.set(initialEpoch.id, initialEpoch);
+  keysByPublicKey.set(initialEpoch.publicKey, hexToBytes(initialEpoch.privateKey));
+  return { epochs, keysByPublicKey, currentEpochId: initialEpoch.id };
+}
+function addEpoch(store, epoch) {
+  store.epochs.set(epoch.id, 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));
+  if (!firstEpoch) {
+    throw new Error("Epoch snapshot must contain at least one epoch");
+  }
+  const store = createEpochStore(firstEpoch);
+  for (const epoch of remainingEpochs) {
+    addEpoch(store, epoch);
+  }
+  store.currentEpochId = EpochId(snapshot.currentEpochId);
+  return store;
+}
+function createEpochStoreFromInputs(epochKeys, options = {}) {
+  if (epochKeys.length === 0) {
+    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 store = createEpochStore(epochs[0]);
+  for (let i = 1;i < epochs.length; i++) {
+    addEpoch(store, epochs[i]);
+  }
+  store.currentEpochId = epochs[epochs.length - 1].id;
+  return store;
+}
+function getCurrentEpoch(store) {
+  return store.epochs.get(store.currentEpochId);
+}
+function getCurrentPublicKey(store) {
+  return getCurrentEpoch(store).publicKey;
+}
+function getAllPublicKeys(store) {
+  return Array.from(store.keysByPublicKey.keys());
+}
+function getDecryptionKey(store, publicKey) {
+  return store.keysByPublicKey.get(publicKey);
+}
+function exportEpochKeys(store) {
+  return Array.from(store.epochs.values()).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0).map((epoch) => ({ epochId: epoch.id, key: epoch.privateKey }));
+}
+function serializeEpochStore(store) {
+  return {
+    epochs: Array.from(store.epochs.values()).map((epoch) => ({
+      id: epoch.id,
+      privateKey: epoch.privateKey,
+      createdBy: epoch.createdBy,
+      ...epoch.parentEpoch !== undefined ? { parentEpoch: epoch.parentEpoch } : {}
+    })),
+    currentEpochId: store.currentEpochId
+  };
+}
+function stringifyEpochStore(store) {
+  return JSON.stringify(serializeEpochStore(store));
+}
+function deserializeEpochStore(raw) {
+  try {
+    return Option.some(hydrateEpochStore(decodePersistedEpochStore(raw)));
+  } catch {
+    return Option.none();
+  }
+}
 
+// src/db/invite.ts
+var InviteSchema = Schema2.Struct({
+  epochKeys: Schema2.Array(EpochKeyInputSchema),
+  relays: Schema2.Array(Schema2.String),
+  dbName: Schema2.String
+});
+var decodeInviteJson = Schema2.decodeUnknownSync(Schema2.UnknownFromJsonString);
+var decodeInvitePayload = Schema2.decodeUnknownSync(InviteSchema);
+function encodeInvite(invite) {
+  return btoa(JSON.stringify(invite));
+}
+function decodeInvite(encoded) {
+  let raw;
+  try {
+    raw = decodeInviteJson(atob(encoded));
+  } catch {
+    throw new Error("Invalid invite: failed to decode");
+  }
+  try {
+    const invite = decodeInvitePayload(raw);
+    return {
+      epochKeys: invite.epochKeys.map((epoch) => ({
+        epochId: EpochId(epoch.epochId),
+        key: epoch.key
+      })),
+      relays: [...invite.relays],
+      dbName: DatabaseName(invite.dbName)
+    };
+  } catch {
+    throw new Error("Invalid invite: unexpected shape");
+  }
+}
 // src/errors.ts
 import { Data } from "effect";
 
@@ -38,211 +211,79 @@ 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";
 
-// src/schema/validate.ts
-function fieldDefToSchema(fd) {
-  let base;
-  switch (fd.kind) {
-    case "string":
-      base = Schema.String;
-      break;
-    case "number":
-      base = Schema.Number;
-      break;
-    case "boolean":
-      base = Schema.Boolean;
-      break;
-    case "json":
-      base = Schema.Unknown;
-      break;
-  }
-  if (fd.isArray) {
-    base = Schema.Array(base);
-  }
-  if (fd.isOptional) {
-    base = Schema.UndefinedOr(base);
-  }
-  return base;
-}
-function buildValidator(collectionName, def) {
-  const schemaFields = {
-    id: Schema.String
-  };
-  for (const [name, fieldDef] of Object.entries(def.fields)) {
-    schemaFields[name] = fieldDefToSchema(fieldDef);
-  }
-  const recordSchema = Schema.Struct(schemaFields);
-  const decode = Schema.decodeUnknownSync(recordSchema);
-  return (input) => Effect.gen(function* () {
-    try {
-      const result = decode(input);
-      return result;
-    } catch (e) {
-      return yield* new ValidationError({
-        message: `Validation failed for collection "${collectionName}": ${e instanceof Error ? e.message : String(e)}`
-      });
-    }
-  });
-}
-function buildPartialValidator(collectionName, def) {
-  return (input) => Effect.gen(function* () {
-    if (typeof input !== "object" || input === null) {
-      return yield* new ValidationError({
-        message: `Validation failed for collection "${collectionName}": expected an object`
-      });
-    }
-    const record = input;
-    for (const [key, value] of Object.entries(record)) {
-      const fieldDef = def.fields[key];
-      if (!fieldDef) {
-        return yield* new ValidationError({
-          message: `Unknown field "${key}" in collection "${collectionName}"`,
-          field: key
-        });
-      }
-      if (value === undefined && fieldDef.isOptional) {
-        continue;
-      }
-      const fieldSchema = fieldDefToSchema(fieldDef);
-      const decode = Schema.decodeUnknownSync(fieldSchema);
-      try {
-        decode(value);
-      } catch (e) {
-        return yield* new ValidationError({
-          message: `Validation failed for field "${key}" in collection "${collectionName}": ${e instanceof Error ? e.message : String(e)}`,
-          field: key
-        });
-      }
-    }
-    return record;
-  });
+// src/db/create-tablinum.ts
+import { Effect as Effect22, Layer as Layer9, ServiceMap as ServiceMap10 } from "effect";
+
+// src/db/runtime-config.ts
+import { Effect, Schema as Schema3 } from "effect";
+var PrivateKeySchema = Schema3.Uint8Array.check(Schema3.isMinLength(32), Schema3.isMaxLength(32));
+var RuntimeConfigSchema = Schema3.Struct({
+  relays: Schema3.NonEmptyArray(Schema3.String),
+  dbName: Schema3.optional(Schema3.String),
+  privateKey: Schema3.optional(PrivateKeySchema),
+  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}`
+  })));
 }
 
-// src/storage/idb.ts
-import { Effect as Effect2 } from "effect";
-import { openDB } from "idb";
-var DB_NAME = "tablinum";
-function storeName(collection) {
-  return `col_${collection}`;
+// src/services/Config.ts
+import { ServiceMap } from "effect";
+
+class Config extends ServiceMap.Service()("tablinum/Config") {
 }
-function schemaVersion(schema) {
-  const sig = Object.entries(schema).sort(([a], [b]) => a.localeCompare(b)).map(([name, def]) => {
-    const indices = [...def.indices ?? []].sort().join(",");
-    return `${name}:${indices}`;
-  }).join("|");
-  let hash = 1;
-  for (let i = 0;i < sig.length; i++) {
-    hash = hash * 31 + sig.charCodeAt(i) | 0;
-  }
-  return Math.abs(hash) + 1;
+
+// src/services/Tablinum.ts
+import { ServiceMap as ServiceMap2 } from "effect";
+
+class Tablinum extends ServiceMap2.Service()("tablinum/Tablinum") {
 }
-function wrap(label, fn) {
-  return Effect2.tryPromise({
-    try: fn,
-    catch: (e) => new StorageError({
-      message: `IndexedDB ${label} failed: ${e instanceof Error ? e.message : String(e)}`,
-      cause: e
-    })
+
+// 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";
+
+// src/crud/watch.ts
+import { Effect as Effect2, PubSub, Ref, Stream } from "effect";
+function watchCollection(ctx, storage, collectionName, filter, mapRecord) {
+  const query = () => Effect2.map(storage.getAllRecords(collectionName), (all) => {
+    const filtered = all.filter((r) => !r._deleted && (filter ? filter(r) : true));
+    return mapRecord ? filtered.map(mapRecord) : 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);
+  }));
 }
-function openIDBStorage(dbName, schema) {
+function notifyChange(ctx, event) {
+  return PubSub.publish(ctx.pubsub, event).pipe(Effect2.asVoid);
+}
+function notifyReplayComplete(ctx, collections) {
   return Effect2.gen(function* () {
-    const name = dbName ?? DB_NAME;
-    const version = schemaVersion(schema);
-    const db = yield* Effect2.tryPromise({
-      try: () => openDB(name, version, {
-        upgrade(database) {
-          if (!database.objectStoreNames.contains("events")) {
-            const events = database.createObjectStore("events", {
-              keyPath: "id"
-            });
-            events.createIndex("by-record", ["collection", "recordId"]);
-          }
-          if (!database.objectStoreNames.contains("giftwraps")) {
-            database.createObjectStore("giftwraps", {
-              keyPath: "id"
-            });
-          }
-          if (database.objectStoreNames.contains("records")) {
-            database.deleteObjectStore("records");
-          }
-          const expectedStores = new Set;
-          for (const [, def] of Object.entries(schema)) {
-            const sn = storeName(def.name);
-            expectedStores.add(sn);
-            if (!database.objectStoreNames.contains(sn)) {
-              const store = database.createObjectStore(sn, { keyPath: "id" });
-              for (const idx of def.indices ?? []) {
-                store.createIndex(idx, idx);
-              }
-            } else {
-              const tx = database.transaction;
-              const store = tx.objectStore(sn);
-              const existingIndices = new Set(Array.from(store.indexNames));
-              const wantedIndices = new Set(def.indices ?? []);
-              for (const idx of existingIndices) {
-                if (!wantedIndices.has(idx)) {
-                  store.deleteIndex(idx);
-                }
-              }
-              for (const idx of wantedIndices) {
-                if (!existingIndices.has(idx)) {
-                  store.createIndex(idx, idx);
-                }
-              }
-            }
-          }
-          const allStores = Array.from(database.objectStoreNames);
-          for (const existing of allStores) {
-            if (existing.startsWith("col_") && !expectedStores.has(existing)) {
-              database.deleteObjectStore(existing);
-            }
-          }
-        }
-      }),
-      catch: (e) => new StorageError({
-        message: "Failed to open IndexedDB",
-        cause: e
-      })
-    });
-    yield* Effect2.addFinalizer(() => Effect2.sync(() => db.close()));
-    const handle = {
-      putRecord: (collection, record) => wrap("putRecord", () => db.put(storeName(collection), record).then(() => {
-        return;
-      })),
-      getRecord: (collection, id) => wrap("getRecord", () => db.get(storeName(collection), id)),
-      getAllRecords: (collection) => wrap("getAllRecords", () => db.getAll(storeName(collection))),
-      countRecords: (collection) => wrap("countRecords", () => db.count(storeName(collection))),
-      clearRecords: (collection) => wrap("clearRecords", () => db.clear(storeName(collection))),
-      getByIndex: (collection, indexName, value) => wrap("getByIndex", () => db.getAllFromIndex(storeName(collection), indexName, value)),
-      getByIndexRange: (collection, indexName, range) => wrap("getByIndexRange", () => db.getAllFromIndex(storeName(collection), indexName, range)),
-      getAllSorted: (collection, indexName, direction) => wrap("getAllSorted", async () => {
-        const sn = storeName(collection);
-        const tx = db.transaction(sn, "readonly");
-        const store = tx.objectStore(sn);
-        const index = store.index(indexName);
-        const results = [];
-        let cursor = await index.openCursor(null, direction ?? "next");
-        while (cursor) {
-          results.push(cursor.value);
-          cursor = await cursor.continue();
-        }
-        return results;
-      }),
-      putEvent: (event) => wrap("putEvent", () => db.put("events", event).then(() => {
-        return;
-      })),
-      getEvent: (id) => wrap("getEvent", () => db.get("events", id)),
-      getAllEvents: () => wrap("getAllEvents", () => db.getAll("events")),
-      getEventsByRecord: (collection, recordId) => wrap("getEventsByRecord", () => db.getAllFromIndex("events", "by-record", [collection, 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")),
-      close: () => Effect2.sync(() => db.close())
-    };
-    return handle;
+    yield* Ref.set(ctx.replayingRef, false);
+    for (const collection2 of collections) {
+      yield* notifyChange(ctx, {
+        collection: collection2,
+        recordId: "",
+        kind: "update"
+      });
+    }
   });
 }
 
@@ -266,24 +307,26 @@ function buildRecord(event) {
     id: event.recordId,
     _deleted: event.kind === "delete",
     _updatedAt: event.createdAt,
+    _eventId: event.id,
+    _author: event.author,
     ...event.data ?? {}
   };
 }
 function applyEvent(storage, event) {
   return Effect3.gen(function* () {
-    const existingEvents = yield* storage.getEventsByRecord(event.collection, event.recordId);
-    let currentWinner = null;
-    for (const e of existingEvents) {
-      if (e.id === event.id)
-        continue;
-      currentWinner = resolveWinner(currentWinner, e);
-    }
-    const winner = resolveWinner(currentWinner, event);
-    const incomingWon = winner.id === event.id;
-    if (incomingWon) {
-      yield* storage.putRecord(event.collection, buildRecord(event));
+    const existing = yield* storage.getRecord(event.collection, event.recordId);
+    if (existing) {
+      const existingMeta = {
+        id: existing._eventId,
+        createdAt: existing._updatedAt
+      };
+      const incomingMeta = { id: event.id, createdAt: event.createdAt };
+      const winner = resolveWinner(existingMeta, incomingMeta);
+      if (winner.id !== event.id)
+        return false;
     }
-    return incomingWon;
+    yield* storage.putRecord(event.collection, buildRecord(event));
+    return true;
   });
 }
 function rebuild(storage, collections) {
@@ -305,8 +348,73 @@ function rebuild(storage, collections) {
   });
 }
 
+// src/schema/validate.ts
+import { Effect as Effect4, Schema as Schema4 } from "effect";
+function fieldDefToSchema(fd) {
+  let base;
+  switch (fd.kind) {
+    case "string":
+      base = Schema4.String;
+      break;
+    case "number":
+      base = Schema4.Number;
+      break;
+    case "boolean":
+      base = Schema4.Boolean;
+      break;
+    case "json":
+      base = Schema4.Unknown;
+      break;
+  }
+  if (fd.isArray) {
+    base = Schema4.Array(base);
+  }
+  if (fd.isOptional) {
+    base = Schema4.UndefinedOr(base);
+  }
+  return base;
+}
+function buildStructSchema(def, options = {}) {
+  const schemaFields = {};
+  if (options.includeId) {
+    schemaFields.id = Schema4.String;
+  }
+  for (const [name, fieldDef] of Object.entries(def.fields)) {
+    const fieldSchema = fieldDefToSchema(fieldDef);
+    schemaFields[name] = options.allOptional ? Schema4.optionalKey(fieldSchema) : fieldSchema;
+  }
+  return Schema4.Struct(schemaFields);
+}
+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}`
+  })));
+}
+function buildPartialValidator(collectionName, def) {
+  const decode = Schema4.decodeUnknownEffect(buildStructSchema(def, { allOptional: true }));
+  return (input) => Effect4.gen(function* () {
+    if (typeof input !== "object" || input === null) {
+      return yield* new ValidationError({
+        message: `Validation failed for collection "${collectionName}": expected an object`
+      });
+    }
+    const record = input;
+    const unknownField = Object.keys(record).find((key) => !Object.hasOwn(def.fields, key));
+    if (unknownField !== undefined) {
+      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}`
+    })));
+  });
+}
+
 // src/crud/collection-handle.ts
-import { Effect as Effect6 } from "effect";
+import { Effect as Effect6, Option as Option3 } from "effect";
 
 // src/utils/uuid.ts
 function uuidv7() {
@@ -325,43 +433,8 @@ function uuidv7() {
   return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
 }
 
-// src/crud/watch.ts
-import { Effect as Effect4, PubSub, Ref, Stream } from "effect";
-function watchCollection(ctx, storage, collectionName, filter, mapRecord) {
-  const query = () => Effect4.gen(function* () {
-    const all = yield* storage.getAllRecords(collectionName);
-    const filtered = all.filter((r) => !r._deleted && (filter ? filter(r) : true));
-    return mapRecord ? filtered.map(mapRecord) : filtered;
-  });
-  const changes = Stream.fromPubSub(ctx.pubsub).pipe(Stream.filter((event) => event.collection === collectionName), Stream.mapEffect(() => Effect4.gen(function* () {
-    const replaying = yield* Ref.get(ctx.replayingRef);
-    if (replaying)
-      return;
-    return yield* query();
-  })), Stream.filter((result) => result !== undefined));
-  return Stream.unwrap(Effect4.gen(function* () {
-    const initial = yield* query();
-    return Stream.concat(Stream.make(initial), changes);
-  }));
-}
-function notifyChange(ctx, event) {
-  return PubSub.publish(ctx.pubsub, event).pipe(Effect4.asVoid);
-}
-function notifyReplayComplete(ctx, collections) {
-  return Effect4.gen(function* () {
-    yield* Ref.set(ctx.replayingRef, false);
-    for (const collection of collections) {
-      yield* notifyChange(ctx, {
-        collection,
-        recordId: "",
-        kind: "update"
-      });
-    }
-  });
-}
-
 // src/crud/query-builder.ts
-import { Effect as Effect5, Ref as Ref2, Stream as Stream2 } from "effect";
+import { Effect as Effect5, Option as Option2, Ref as Ref2, Stream as Stream2 } from "effect";
 function emptyPlan() {
   return { filters: [] };
 }
@@ -407,10 +480,10 @@ function executeQuery(ctx, plan) {
     if (plan.orderBy) {
       const alreadySorted = ctx.def.indices.includes(plan.orderBy.field) && plan.filters.length === 0 && !plan.indexQuery;
       if (!alreadySorted) {
-        const { field, direction } = plan.orderBy;
+        const { field: field2, direction } = plan.orderBy;
         results = results.sort((a, b) => {
-          const va = a[field];
-          const vb = b[field];
+          const va = a[field2];
+          const vb = b[field2];
           const cmp = va < vb ? -1 : va > vb ? 1 : 0;
           return direction === "desc" ? -cmp : cmp;
         });
@@ -444,9 +517,9 @@ function makeQueryBuilder(ctx, plan) {
       ...plan,
       filters: [...plan.filters, (r) => fn(ctx.mapRecord(r))]
     }),
-    sortBy: (field) => makeQueryBuilder(ctx, {
+    sortBy: (field2) => makeQueryBuilder(ctx, {
       ...plan,
-      orderBy: { field, direction: plan.orderBy?.direction ?? "asc" }
+      orderBy: { field: field2, direction: plan.orderBy?.direction ?? "asc" }
     }),
     reverse: () => makeQueryBuilder(ctx, {
       ...plan,
@@ -458,39 +531,8 @@ function makeQueryBuilder(ctx, plan) {
     offset: (n) => makeQueryBuilder(ctx, { ...plan, offset: n }),
     limit: (n) => makeQueryBuilder(ctx, { ...plan, limit: n }),
     get: () => executeQuery(ctx, plan),
-    first: () => Effect5.gen(function* () {
-      const limitedPlan = { ...plan, limit: 1 };
-      const results = yield* executeQuery(ctx, limitedPlan);
-      return results[0] ?? null;
-    }),
-    count: () => Effect5.gen(function* () {
-      const results = yield* executeQuery(ctx, plan);
-      return results.length;
-    }),
-    watch: () => watchQuery(ctx, plan)
-  };
-}
-function makeOrderByBuilder(ctx, plan) {
-  return {
-    reverse: () => makeOrderByBuilder(ctx, {
-      ...plan,
-      orderBy: {
-        field: plan.orderBy.field,
-        direction: plan.orderBy.direction === "desc" ? "asc" : "desc"
-      }
-    }),
-    offset: (n) => makeOrderByBuilder(ctx, { ...plan, offset: n }),
-    limit: (n) => makeOrderByBuilder(ctx, { ...plan, limit: n }),
-    get: () => executeQuery(ctx, plan),
-    first: () => Effect5.gen(function* () {
-      const limitedPlan = { ...plan, limit: 1 };
-      const results = yield* executeQuery(ctx, limitedPlan);
-      return results[0] ?? null;
-    }),
-    count: () => Effect5.gen(function* () {
-      const results = yield* executeQuery(ctx, plan);
-      return results.length;
-    }),
+    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)
   };
 }
@@ -548,16 +590,27 @@ function createOrderByBuilder(storage, watchCtx, collectionName, def, fieldName,
     ...emptyPlan(),
     orderBy: { field: fieldName, direction: "asc" }
   };
-  return makeOrderByBuilder(ctx, plan);
+  return makeQueryBuilder(ctx, plan);
 }
 
 // src/crud/collection-handle.ts
 function mapRecord(record) {
-  const { _deleted, _updatedAt, ...fields } = record;
+  const { _deleted, _updatedAt, _author, ...fields } = record;
   return fields;
 }
 function createCollectionHandle(def, storage, watchCtx, validator, partialValidator, makeEventId, onWrite) {
   const collectionName = def.name;
+  const commitEvent = (event) => Effect6.gen(function* () {
+    yield* storage.putEvent(event);
+    yield* applyEvent(storage, event);
+    if (onWrite)
+      yield* onWrite(event);
+    yield* notifyChange(watchCtx, {
+      collection: collectionName,
+      recordId: event.recordId,
+      kind: event.kind
+    });
+  });
   const handle = {
     add: (data) => Effect6.gen(function* () {
       const id = uuidv7();
@@ -571,15 +624,7 @@ function createCollectionHandle(def, storage, watchCtx, validator, partialValida
         data: fullRecord,
         createdAt: Date.now()
       };
-      yield* storage.putEvent(event);
-      yield* applyEvent(storage, event);
-      if (onWrite)
-        yield* onWrite(event);
-      yield* notifyChange(watchCtx, {
-        collection: collectionName,
-        recordId: id,
-        kind: "create"
-      });
+      yield* commitEvent(event);
       return id;
     }),
     update: (id, data) => Effect6.gen(function* () {
@@ -591,7 +636,7 @@ function createCollectionHandle(def, storage, watchCtx, validator, partialValida
         });
       }
       yield* partialValidator(data);
-      const { _deleted, _updatedAt, ...existingFields } = existing;
+      const { _deleted, _updatedAt, _author, ...existingFields } = existing;
       const merged = { ...existingFields, ...data, id };
       yield* validator(merged);
       const event = {
@@ -602,15 +647,7 @@ function createCollectionHandle(def, storage, watchCtx, validator, partialValida
         data: merged,
         createdAt: Date.now()
       };
-      yield* storage.putEvent(event);
-      yield* applyEvent(storage, event);
-      if (onWrite)
-        yield* onWrite(event);
-      yield* notifyChange(watchCtx, {
-        collection: collectionName,
-        recordId: id,
-        kind: "update"
-      });
+      yield* commitEvent(event);
     }),
     delete: (id) => Effect6.gen(function* () {
       const existing = yield* storage.getRecord(collectionName, id);
@@ -628,15 +665,9 @@ function createCollectionHandle(def, storage, watchCtx, validator, partialValida
         data: null,
         createdAt: Date.now()
       };
-      yield* storage.putEvent(event);
-      yield* applyEvent(storage, event);
-      if (onWrite)
-        yield* onWrite(event);
-      yield* notifyChange(watchCtx, {
-        collection: collectionName,
-        recordId: id,
-        kind: "delete"
-      });
+      yield* commitEvent(event);
+      const oldEvents = yield* storage.getEventsByRecord(collectionName, id);
+      yield* Effect6.forEach(oldEvents.filter((e) => e.id !== event.id), (e) => storage.deleteEvent(e.id), { discard: true });
     }),
     get: (id) => Effect6.gen(function* () {
       const record = yield* storage.getRecord(collectionName, id);
@@ -648,15 +679,11 @@ function createCollectionHandle(def, storage, watchCtx, validator, partialValida
       }
       return mapRecord(record);
     }),
-    first: () => Effect6.gen(function* () {
-      const all = yield* storage.getAllRecords(collectionName);
+    first: () => Effect6.map(storage.getAllRecords(collectionName), (all) => {
       const found = all.find((r) => !r._deleted);
-      return found ? mapRecord(found) : null;
-    }),
-    count: () => Effect6.gen(function* () {
-      const all = yield* storage.getAllRecords(collectionName);
-      return all.filter((r) => !r._deleted).length;
+      return found ? Option3.some(mapRecord(found)) : Option3.none();
     }),
+    count: () => Effect6.map(storage.getAllRecords(collectionName), (all) => all.filter((r) => !r._deleted).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)
@@ -664,306 +691,13 @@ function createCollectionHandle(def, storage, watchCtx, validator, partialValida
   return handle;
 }
 
-// src/db/identity.ts
-import { Effect as Effect7 } from "effect";
-import { getPublicKey } from "nostr-tools/pure";
-function bytesToHex(bytes) {
-  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
-}
-function createIdentity(suppliedKey) {
-  return Effect7.gen(function* () {
-    let privateKey;
-    if (suppliedKey) {
-      if (suppliedKey.length !== 32) {
-        return yield* new CryptoError({
-          message: `Private key must be 32 bytes, got ${suppliedKey.length}`
-        });
-      }
-      privateKey = suppliedKey;
-    } else {
-      privateKey = new Uint8Array(32);
-      crypto.getRandomValues(privateKey);
-    }
-    const privateKeyHex = bytesToHex(privateKey);
-    let publicKey;
-    try {
-      publicKey = getPublicKey(privateKey);
-    } catch (e) {
-      return yield* new CryptoError({
-        message: `Failed to derive public key: ${e instanceof Error ? e.message : String(e)}`,
-        cause: e
-      });
-    }
-    return {
-      privateKey,
-      publicKey,
-      exportKey: () => privateKeyHex
-    };
-  });
-}
-
-// src/sync/gift-wrap.ts
-import { Effect as Effect8 } from "effect";
-import { wrapEvent, unwrapEvent } from "nostr-tools/nip59";
-function createGiftWrapHandle(privateKey, publicKey) {
-  return {
-    wrap: (rumor) => Effect8.try({
-      try: () => wrapEvent(rumor, privateKey, publicKey),
-      catch: (e) => new CryptoError({
-        message: `Gift wrap failed: ${e instanceof Error ? e.message : String(e)}`,
-        cause: e
-      })
-    }),
-    unwrap: (giftWrap) => Effect8.try({
-      try: () => unwrapEvent(giftWrap, privateKey),
-      catch: (e) => new CryptoError({
-        message: `Gift unwrap failed: ${e instanceof Error ? e.message : String(e)}`,
-        cause: e
-      })
-    })
-  };
-}
-
-// src/sync/relay.ts
-import { Effect as Effect9 } from "effect";
-import { Relay } from "nostr-tools/relay";
-function createRelayHandle() {
-  const connections = new Map;
-  const getRelay = (url) => Effect9.tryPromise({
-    try: async () => {
-      const existing = connections.get(url);
-      if (existing && existing.connected !== false) {
-        return existing;
-      }
-      connections.delete(url);
-      const relay = await Relay.connect(url);
-      connections.set(url, relay);
-      return relay;
-    },
-    catch: (e) => new RelayError({
-      message: `Connect to ${url} failed: ${e instanceof Error ? e.message : String(e)}`,
-      url,
-      cause: e
-    })
-  });
-  return {
-    publish: (event, urls) => Effect9.gen(function* () {
-      const errors = [];
-      for (const url of urls) {
-        const result = yield* Effect9.result(Effect9.gen(function* () {
-          const relay = yield* getRelay(url);
-          yield* Effect9.tryPromise({
-            try: () => relay.publish(event),
-            catch: (e) => {
-              connections.delete(url);
-              return new RelayError({
-                message: `Publish to ${url} failed: ${e instanceof Error ? e.message : String(e)}`,
-                url,
-                cause: e
-              });
-            }
-          });
-        }));
-        if (result._tag === "Failure") {
-          errors.push({ url, error: result });
-        }
-      }
-      if (errors.length === urls.length && urls.length > 0) {
-        return yield* new RelayError({
-          message: `Publish failed on all ${urls.length} relays`
-        });
-      }
-    }),
-    fetchEvents: (ids, url) => Effect9.gen(function* () {
-      if (ids.length === 0)
-        return [];
-      const relay = yield* getRelay(url);
-      return yield* Effect9.tryPromise({
-        try: () => new Promise((resolve) => {
-          const events = [];
-          const timer = setTimeout(() => {
-            sub.close();
-            resolve(events);
-          }, 1e4);
-          const sub = relay.subscribe([{ ids }], {
-            onevent(evt) {
-              events.push(evt);
-            },
-            oneose() {
-              clearTimeout(timer);
-              sub.close();
-              resolve(events);
-            }
-          });
-        }),
-        catch: (e) => {
-          connections.delete(url);
-          return new RelayError({
-            message: `Fetch from ${url} failed: ${e instanceof Error ? e.message : String(e)}`,
-            url,
-            cause: e
-          });
-        }
-      });
-    }),
-    fetchByFilter: (filter, url) => Effect9.gen(function* () {
-      const relay = yield* getRelay(url);
-      return yield* Effect9.tryPromise({
-        try: () => new Promise((resolve) => {
-          const events = [];
-          const timer = setTimeout(() => {
-            sub.close();
-            resolve(events);
-          }, 1e4);
-          const sub = relay.subscribe([filter], {
-            onevent(evt) {
-              events.push(evt);
-            },
-            oneose() {
-              clearTimeout(timer);
-              sub.close();
-              resolve(events);
-            }
-          });
-        }),
-        catch: (e) => {
-          connections.delete(url);
-          return new RelayError({
-            message: `Fetch from ${url} failed: ${e instanceof Error ? e.message : String(e)}`,
-            url,
-            cause: e
-          });
-        }
-      });
-    }),
-    subscribe: (filter, url, onEvent) => Effect9.gen(function* () {
-      const relay = yield* getRelay(url);
-      relay.subscribe([filter], {
-        onevent(evt) {
-          onEvent(evt);
-        },
-        oneose() {}
-      });
-    }),
-    sendNegMsg: (url, subId, filter, msgHex) => Effect9.gen(function* () {
-      const relay = yield* getRelay(url);
-      return yield* Effect9.tryPromise({
-        try: () => new Promise((resolve, reject) => {
-          const timer = setTimeout(() => {
-            reject(new Error("NIP-77 negotiation timeout"));
-          }, 30000);
-          const sub = relay.subscribe([filter], {
-            onevent() {},
-            oneose() {}
-          });
-          const ws = relay._ws || relay.ws;
-          if (!ws) {
-            clearTimeout(timer);
-            sub.close();
-            reject(new Error("Cannot access relay WebSocket"));
-            return;
-          }
-          const handler = (msg) => {
-            try {
-              const data = JSON.parse(typeof msg.data === "string" ? msg.data : "");
-              if (!Array.isArray(data))
-                return;
-              if (data[0] === "NEG-MSG" && data[1] === subId) {
-                clearTimeout(timer);
-                sub.close();
-                resolve({
-                  msgHex: data[2],
-                  haveIds: [],
-                  needIds: []
-                });
-                ws.removeEventListener("message", handler);
-              } else if (data[0] === "NEG-ERR" && data[1] === subId) {
-                clearTimeout(timer);
-                sub.close();
-                reject(new Error(`NEG-ERR: ${data[2]}`));
-                ws.removeEventListener("message", handler);
-              }
-            } catch {}
-          };
-          ws.addEventListener("message", handler);
-          ws.send(JSON.stringify(["NEG-OPEN", subId, filter, msgHex]));
-        }),
-        catch: (e) => {
-          connections.delete(url);
-          return new RelayError({
-            message: `NIP-77 negotiation with ${url} failed: ${e instanceof Error ? e.message : String(e)}`,
-            url,
-            cause: e
-          });
-        }
-      });
-    }),
-    closeAll: () => Effect9.sync(() => {
-      for (const [url, relay] of connections) {
-        relay.close();
-        connections.delete(url);
-      }
-    })
-  };
-}
-
-// src/sync/publish-queue.ts
-import { Effect as Effect10, Ref as Ref3 } from "effect";
-function createPublishQueue(storage, relay) {
-  return Effect10.gen(function* () {
-    const pendingRef = yield* Ref3.make(new Set);
-    return {
-      enqueue: (eventId) => Ref3.update(pendingRef, (set) => {
-        const next = new Set(set);
-        next.add(eventId);
-        return next;
-      }),
-      flush: (relayUrls) => Effect10.gen(function* () {
-        const pending = yield* Ref3.get(pendingRef);
-        if (pending.size === 0)
-          return;
-        const succeeded = new Set;
-        for (const eventId of pending) {
-          const gw = yield* storage.getGiftWrap(eventId);
-          if (!gw) {
-            succeeded.add(eventId);
-            continue;
-          }
-          const result = yield* Effect10.result(relay.publish(gw.event, relayUrls));
-          if (result._tag === "Success") {
-            succeeded.add(eventId);
-          }
-        }
-        yield* Ref3.update(pendingRef, (set) => {
-          const next = new Set(set);
-          for (const id of succeeded) {
-            next.delete(id);
-          }
-          return next;
-        });
-      }),
-      size: () => Ref3.get(pendingRef).pipe(Effect10.map((s) => s.size))
-    };
-  });
-}
-
-// src/sync/sync-status.ts
-import { Effect as Effect11, SubscriptionRef } from "effect";
-function createSyncStatusHandle() {
-  return Effect11.gen(function* () {
-    const ref = yield* SubscriptionRef.make("idle");
-    return {
-      get: () => SubscriptionRef.get(ref),
-      set: (status) => SubscriptionRef.set(ref, status)
-    };
-  });
-}
-
 // src/sync/sync-service.ts
-import { Effect as Effect13, Ref as Ref4 } from "effect";
+import { Effect as Effect8, Option as Option5, Ref as Ref3, Schedule } from "effect";
+import { unwrapEvent } from "nostr-tools/nip59";
+import { GiftWrap as GiftWrap2 } from "nostr-tools/kinds";
 
 // src/sync/negentropy.ts
-import { Effect as Effect12 } from "effect";
+import { Effect as Effect7 } from "effect";
 
 // src/vendor/negentropy.js
 var PROTOCOL_VERSION = 97;
@@ -1483,30 +1217,25 @@ function itemCompare(a, b) {
 }
 
 // src/sync/negentropy.ts
-function hexToBytes(hex) {
-  const bytes = new Uint8Array(hex.length / 2);
-  for (let i = 0;i < hex.length; i += 2) {
-    bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
-  }
-  return bytes;
-}
-function reconcileWithRelay(storage, relay, relayUrl, publicKey) {
-  return Effect12.gen(function* () {
+import { hexToBytes as hexToBytes2 } from "@noble/hashes/utils.js";
+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;
     for (const gw of allGiftWraps) {
-      storageVector.insert(gw.createdAt, hexToBytes(gw.id));
+      storageVector.insert(gw.createdAt, hexToBytes2(gw.id));
     }
     storageVector.seal();
     const neg = new Negentropy(storageVector, 0);
     const filter = {
-      kinds: [1059],
-      "#p": [publicKey]
+      kinds: [GiftWrap],
+      "#p": Array.isArray(publicKeys) ? publicKeys : [publicKeys]
     };
     const allHaveIds = [];
     const allNeedIds = [];
     const subId = `neg-${Date.now()}`;
-    const initialMsg = yield* Effect12.tryPromise({
+    const initialMsg = yield* Effect7.try({
       try: () => neg.initiate(),
       catch: (e) => new SyncError({
         message: `Negentropy initiate failed: ${e instanceof Error ? e.message : String(e)}`,
@@ -1519,7 +1248,7 @@ function reconcileWithRelay(storage, relay, relayUrl, publicKey) {
       const response = yield* relay.sendNegMsg(relayUrl, subId, filter, currentMsg);
       if (response.msgHex === null)
         break;
-      const reconcileResult = yield* Effect12.tryPromise({
+      const reconcileResult = yield* Effect7.try({
         try: () => neg.reconcile(response.msgHex),
         catch: (e) => new SyncError({
           message: `Negentropy reconcile failed: ${e instanceof Error ? e.message : String(e)}`,
@@ -1538,512 +1267,1641 @@ function reconcileWithRelay(storage, relay, relayUrl, publicKey) {
   });
 }
 
+// src/db/key-rotation.ts
+import { Option as Option4, Schema as Schema5 } from "effect";
+import { generateSecretKey } from "nostr-tools/pure";
+import { wrapEvent } from "nostr-tools/nip59";
+var HexKeySchema2 = Schema5.String.check(Schema5.isPattern(/^[0-9a-f]{64}$/i));
+var RotationDataSchema = Schema5.Struct({
+  _rotation: Schema5.Literal(true),
+  epochId: Schema5.String,
+  epochKey: HexKeySchema2,
+  parentEpoch: Schema5.String,
+  removedMembers: Schema5.Array(Schema5.String)
+});
+var RemovalNoticeSchema = Schema5.Struct({
+  _removed: Schema5.Literal(true),
+  epochId: Schema5.String,
+  removedBy: Schema5.String
+});
+var decodeRotationData = Schema5.decodeUnknownSync(Schema5.fromJsonString(RotationDataSchema));
+var decodeRemovalNotice = Schema5.decodeUnknownSync(Schema5.fromJsonString(RemovalNoticeSchema));
+function createRotation(epochStore, senderPrivateKey, senderPublicKey, remainingMemberPubkeys, removedMemberPubkeys) {
+  const newSk = generateSecretKey();
+  const newKeyHex = bytesToHex(newSk);
+  const currentEpoch = getCurrentEpoch(epochStore);
+  const epochId = EpochId(uuidv7());
+  const epoch = createEpochKey(epochId, newKeyHex, senderPublicKey, currentEpoch.id);
+  const rotationData = {
+    _rotation: true,
+    epochId,
+    epochKey: newKeyHex,
+    parentEpoch: currentEpoch.id,
+    removedMembers: removedMemberPubkeys
+  };
+  const rumor = {
+    kind: 1,
+    content: JSON.stringify(rotationData),
+    tags: [["d", `_system:rotation:${epochId}`]],
+    created_at: Math.floor(Date.now() / 1000)
+  };
+  const wrappedEvents = [];
+  for (const memberPubkey of remainingMemberPubkeys) {
+    if (memberPubkey === senderPublicKey)
+      continue;
+    const wrapped = wrapEvent(rumor, senderPrivateKey, memberPubkey);
+    wrappedEvents.push(wrapped);
+  }
+  const removalData = {
+    _removed: true,
+    epochId,
+    removedBy: senderPublicKey
+  };
+  const removalRumor = {
+    kind: 1,
+    content: JSON.stringify(removalData),
+    tags: [["d", `_system:removed:${epochId}`]],
+    created_at: Math.floor(Date.now() / 1000)
+  };
+  const removalNotices = [];
+  for (const removedPubkey of removedMemberPubkeys) {
+    const wrapped = wrapEvent(removalRumor, senderPrivateKey, removedPubkey);
+    removalNotices.push(wrapped);
+  }
+  return { epoch, wrappedEvents, removalNotices };
+}
+function parseRotationEvent(content, dTag) {
+  if (!dTag.startsWith("_system:rotation:"))
+    return Option4.none();
+  try {
+    return Option4.some(decodeRotationData(content));
+  } catch {
+    return Option4.none();
+  }
+}
+function parseRemovalNotice(content, dTag) {
+  if (!dTag.startsWith("_system:removed:"))
+    return Option4.none();
+  try {
+    return Option4.some(decodeRemovalNotice(content));
+  } catch {
+    return Option4.none();
+  }
+}
+
 // src/sync/sync-service.ts
-function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStatus, watchCtx, relayUrls, publicKey, onSyncError) {
-  const processGiftWrap = (remoteGw) => Effect13.gen(function* () {
+function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStatus, watchCtx, relayUrls, knownCollections, epochStore, personalPrivateKey, personalPublicKey, scope, onSyncError, onNewAuthor, onRemoved, onMembersChanged) {
+  const getSubscriptionPubKeys = () => {
+    return getAllPublicKeys(epochStore);
+  };
+  const notifyCollectionUpdated = (collection2) => notifyChange(watchCtx, {
+    collection: collection2,
+    recordId: "",
+    kind: "create"
+  });
+  const forkHandled = (effect) => {
+    Effect8.runFork(effect.pipe(Effect8.tapError((e) => Effect8.sync(() => onSyncError?.(e))), Effect8.ignore, Effect8.forkIn(scope)));
+  };
+  let autoFlushActive = false;
+  const autoFlushEffect = Effect8.gen(function* () {
+    const size = yield* publishQueue.size();
+    if (size === 0)
+      return;
+    yield* syncStatus.set("syncing");
+    yield* publishQueue.flush(relayUrls);
+    const remaining = yield* publishQueue.size();
+    if (remaining > 0)
+      yield* Effect8.fail("pending");
+  }).pipe(Effect8.ensuring(syncStatus.set("idle")), Effect8.retry({ schedule: Schedule.exponential(5000).pipe(Schedule.jittered), times: 10 }), Effect8.ignore);
+  const scheduleAutoFlush = () => {
+    if (autoFlushActive)
+      return;
+    autoFlushActive = true;
+    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;
+    return !!memberRecord.removedAt;
+  });
+  const processGiftWrap = (remoteGw) => Effect8.gen(function* () {
     const existing = yield* storage.getGiftWrap(remoteGw.id);
     if (existing)
       return null;
-    yield* storage.putGiftWrap({
-      id: remoteGw.id,
-      event: remoteGw,
-      createdAt: remoteGw.created_at
-    });
-    const unwrapResult = yield* Effect13.result(giftWrapHandle.unwrap(remoteGw));
-    if (unwrapResult._tag === "Failure")
+    const unwrapResult = yield* Effect8.result(giftWrapHandle.unwrap(remoteGw));
+    if (unwrapResult._tag === "Failure") {
+      yield* storage.putGiftWrap({ id: remoteGw.id, createdAt: remoteGw.created_at });
       return null;
+    }
     const rumor = unwrapResult.success;
     const dTag = rumor.tags.find((t) => t[0] === "d")?.[1];
-    if (!dTag)
+    if (!dTag) {
+      yield* storage.putGiftWrap({ id: remoteGw.id, createdAt: remoteGw.created_at });
       return null;
+    }
     const colonIdx = dTag.indexOf(":");
-    if (colonIdx === -1)
+    if (colonIdx === -1) {
+      yield* storage.putGiftWrap({ id: remoteGw.id, createdAt: remoteGw.created_at });
       return null;
+    }
     const collectionName = dTag.substring(0, colonIdx);
     const recordId = dTag.substring(colonIdx + 1);
+    if (!knownCollections.has(collectionName)) {
+      yield* storage.putGiftWrap({ id: remoteGw.id, 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 });
+        return null;
+      }
+    }
     let data = null;
     let kind = "update";
-    try {
-      const parsed = JSON.parse(rumor.content);
-      if (parsed === null || parsed._deleted) {
-        kind = "delete";
-      } else {
-        data = parsed;
+    const parsed = yield* Effect8.try({
+      try: () => JSON.parse(rumor.content),
+      catch: () => {
+        return;
       }
-    } catch {
+    }).pipe(Effect8.orElseSucceed(() => {
+      return;
+    }));
+    if (parsed === undefined) {
+      yield* storage.putGiftWrap({ id: remoteGw.id, createdAt: remoteGw.created_at });
       return null;
     }
+    if (parsed === null || parsed._deleted) {
+      kind = "delete";
+    } else {
+      data = parsed;
+    }
+    const author = rumor.pubkey || undefined;
     const event = {
       id: rumor.id,
       collection: collectionName,
       recordId,
       kind,
       data,
-      createdAt: rumor.created_at * 1000
+      createdAt: rumor.created_at * 1000,
+      author
     };
+    yield* storage.putGiftWrap({
+      id: remoteGw.id,
+      eventId: event.id,
+      createdAt: remoteGw.created_at
+    });
     yield* storage.putEvent(event);
-    yield* applyEvent(storage, event);
+    const didApply = yield* applyEvent(storage, event);
+    if (kind === "delete" && didApply) {
+      const oldEvents = yield* storage.getEventsByRecord(collectionName, recordId);
+      yield* Effect8.forEach(oldEvents.filter((e) => e.id !== event.id), (e) => storage.deleteEvent(e.id), { discard: true });
+    }
+    if (author && onNewAuthor) {
+      onNewAuthor(author);
+    }
     return collectionName;
   });
-  return {
-    sync: () => Effect13.gen(function* () {
-      yield* syncStatus.set("syncing");
-      yield* Ref4.set(watchCtx.replayingRef, true);
-      const changedCollections = new Set;
-      try {
-        for (const url of relayUrls) {
-          const reconcileResult = yield* Effect13.result(reconcileWithRelay(storage, relay, url, publicKey));
-          if (reconcileResult._tag === "Failure")
-            continue;
-          const { haveIds, needIds } = reconcileResult.success;
-          if (needIds.length > 0) {
-            const fetchResult = yield* Effect13.result(relay.fetchEvents(needIds, url));
-            if (fetchResult._tag === "Success") {
-              for (const remoteGw of fetchResult.success) {
-                const result = yield* Effect13.result(processGiftWrap(remoteGw));
-                if (result._tag === "Success" && result.success) {
-                  changedCollections.add(result.success);
-                }
-              }
-            }
-          }
-          if (haveIds.length > 0) {
-            for (const id of haveIds) {
-              const gw = yield* storage.getGiftWrap(id);
-              if (gw) {
-                yield* Effect13.result(relay.publish(gw.event, [url]));
-              }
-            }
-          }
-        }
-        yield* Effect13.result(publishQueue.flush(relayUrls));
-      } finally {
-        yield* notifyReplayComplete(watchCtx, [...changedCollections]);
-        yield* syncStatus.set("idle");
-      }
-    }),
-    publishLocal: (giftWrap) => Effect13.gen(function* () {
-      const result = yield* Effect13.result(relay.publish(giftWrap.event, relayUrls));
-      if (result._tag === "Failure") {
-        yield* publishQueue.enqueue(giftWrap.id);
-        console.error("[tablinum:publishLocal] relay error:", result.failure);
-        if (onSyncError)
-          onSyncError(result.failure);
+  const processRealtimeGiftWrap = (remoteGw) => Effect8.gen(function* () {
+    const collection2 = yield* processGiftWrap(remoteGw).pipe(Effect8.orElseSucceed(() => null));
+    if (collection2) {
+      yield* notifyCollectionUpdated(collection2);
+    }
+  });
+  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
+      })
+    }));
+    if (unwrapResult._tag === "Failure")
+      return false;
+    const rumor = unwrapResult.success;
+    const dTag = rumor.tags.find((t) => t[0] === "d")?.[1];
+    if (!dTag)
+      return false;
+    const removalNoticeOpt = parseRemovalNotice(rumor.content, dTag);
+    if (Option5.isSome(removalNoticeOpt)) {
+      if (onRemoved)
+        onRemoved(removalNoticeOpt.value);
+      return true;
+    }
+    const rotationDataOpt = parseRotationEvent(rumor.content, dTag);
+    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);
+    addEpoch(epochStore, epoch);
+    epochStore.currentEpochId = epoch.id;
+    let membersChanged = false;
+    for (const removedPubkey of rotationData.removedMembers) {
+      const memberRecord = yield* storage.getRecord("_members", removedPubkey);
+      if (memberRecord && !memberRecord.removedAt) {
+        yield* storage.putRecord("_members", {
+          ...memberRecord,
+          removedAt: Date.now(),
+          removedInEpoch: epoch.id
+        });
+        yield* notifyChange(watchCtx, {
+          collection: "_members",
+          recordId: removedPubkey,
+          kind: "update"
+        });
+        membersChanged = true;
       }
+    }
+    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 syncRelay = (url, pubKeys, changedCollections) => Effect8.gen(function* () {
+    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;
+    if (needIds.length > 0) {
+      const fetched = yield* relay.fetchEvents(needIds, url).pipe(Effect8.tapError((err) => Effect8.sync(() => onSyncError?.(err))), Effect8.orElseSucceed(() => []));
+      yield* Effect8.forEach(fetched, (remoteGw) => Effect8.gen(function* () {
+        const 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 });
+    }
+  });
+  const handle = {
+    sync: () => Effect8.gen(function* () {
+      yield* syncStatus.set("syncing");
+      yield* Ref3.set(watchCtx.replayingRef, true);
+      const changedCollections = 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");
+      })));
     }),
-    startSubscription: () => Effect13.gen(function* () {
-      for (const url of relayUrls) {
-        const subResult = yield* Effect13.result(relay.subscribe({ kinds: [1059], "#p": [publicKey] }, url, (evt) => {
-          Effect13.runFork(Effect13.gen(function* () {
-            const result = yield* Effect13.result(processGiftWrap(evt));
-            if (result._tag === "Success" && result.success) {
-              yield* notifyChange(watchCtx, {
-                collection: result.success,
-                recordId: "",
-                kind: "create"
-              });
-            }
-          }));
-        }));
-        if (subResult._tag === "Failure") {
-          console.error("[tablinum:subscribe] failed for", url, subResult.failure);
-          if (onSyncError)
-            onSyncError(subResult.failure);
-        } else {
-          console.log("[tablinum:subscribe] listening on", url);
-        }
+    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);
+    }),
+    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));
       }
-    })
+    }),
+    addEpochSubscription: (publicKey) => subscribeAcrossRelays({ kinds: [GiftWrap2], "#p": [publicKey] }, processRealtimeGiftWrap)
   };
+  forkHandled(publishQueue.size().pipe(Effect8.flatMap((size) => Effect8.sync(() => {
+    if (size > 0)
+      scheduleAutoFlush();
+  }))));
+  return handle;
 }
 
-// src/db/create-tablinum.ts
-function createTablinum(config) {
-  return Effect14.gen(function* () {
-    if (!config.relays || config.relays.length === 0) {
-      return yield* new ValidationError({
-        message: "At least one relay URL is required"
-      });
+// src/db/members.ts
+import { Effect as Effect9, Option as Option6, Schema as Schema6 } from "effect";
+var optionalString = {
+  _tag: "FieldDef",
+  kind: "string",
+  isOptional: true,
+  isArray: false
+};
+var optionalNumber = {
+  _tag: "FieldDef",
+  kind: "number",
+  isOptional: true,
+  isArray: false
+};
+var requiredNumber = {
+  _tag: "FieldDef",
+  kind: "number",
+  isOptional: false,
+  isArray: false
+};
+var requiredString = {
+  _tag: "FieldDef",
+  kind: "string",
+  isOptional: false,
+  isArray: false
+};
+var membersCollectionDef = {
+  _tag: "CollectionDef",
+  name: "_members",
+  fields: {
+    name: optionalString,
+    picture: optionalString,
+    about: optionalString,
+    nip05: optionalString,
+    addedAt: requiredNumber,
+    addedInEpoch: requiredString,
+    removedAt: optionalNumber,
+    removedInEpoch: optionalString
+  },
+  indices: []
+};
+var AuthorProfileSchema = Schema6.Struct({
+  name: Schema6.optionalKey(Schema6.String),
+  picture: Schema6.optionalKey(Schema6.String),
+  about: Schema6.optionalKey(Schema6.String),
+  nip05: Schema6.optionalKey(Schema6.String)
+});
+var decodeAuthorProfile = Schema6.decodeUnknownEffect(Schema6.fromJsonString(AuthorProfileSchema));
+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));
+      if (result._tag === "Success" && result.success.length > 0) {
+        return yield* decodeAuthorProfile(result.success[0].content).pipe(Effect9.map(Option6.some), Effect9.orElseSucceed(() => Option6.none()));
+      }
     }
-    const schemaEntries = Object.entries(config.schema);
-    if (schemaEntries.length === 0) {
-      return yield* new ValidationError({
-        message: "Schema must contain at least one collection"
-      });
+    return Option6.none();
+  });
+}
+
+// src/services/Identity.ts
+import { ServiceMap as ServiceMap3 } from "effect";
+
+class Identity extends ServiceMap3.Service()("tablinum/Identity") {
+}
+
+// src/services/EpochStore.ts
+import { ServiceMap as ServiceMap4 } from "effect";
+
+class EpochStore extends ServiceMap4.Service()("tablinum/EpochStore") {
+}
+
+// src/services/Storage.ts
+import { ServiceMap as ServiceMap5 } from "effect";
+
+class Storage extends ServiceMap5.Service()("tablinum/Storage") {
+}
+
+// src/services/Relay.ts
+import { ServiceMap as ServiceMap6 } from "effect";
+
+class Relay extends ServiceMap6.Service()("tablinum/Relay") {
+}
+
+// src/services/GiftWrap.ts
+import { ServiceMap as ServiceMap7 } from "effect";
+
+class GiftWrap3 extends ServiceMap7.Service()("tablinum/GiftWrap") {
+}
+
+// src/services/PublishQueue.ts
+import { ServiceMap as ServiceMap8 } from "effect";
+
+class PublishQueue extends ServiceMap8.Service()("tablinum/PublishQueue") {
+}
+
+// src/services/SyncStatus.ts
+import { ServiceMap as ServiceMap9 } from "effect";
+
+class SyncStatus extends ServiceMap9.Service()("tablinum/SyncStatus") {
+}
+
+// src/layers/IdentityLive.ts
+import { Effect as Effect11, Layer } from "effect";
+import { hexToBytes as hexToBytes3 } from "@noble/hashes/utils.js";
+
+// src/db/identity.ts
+import { Effect as Effect10 } from "effect";
+import { getPublicKey as getPublicKey2 } from "nostr-tools/pure";
+import { bytesToHex as bytesToHex2 } from "@noble/hashes/utils.js";
+function createIdentity(suppliedKey) {
+  return Effect10.gen(function* () {
+    let privateKey;
+    if (suppliedKey) {
+      if (suppliedKey.length !== 32) {
+        return yield* new CryptoError({
+          message: `Private key must be 32 bytes, got ${suppliedKey.length}`
+        });
+      }
+      privateKey = suppliedKey;
+    } else {
+      privateKey = new Uint8Array(32);
+      crypto.getRandomValues(privateKey);
     }
-    let resolvedKey = config.privateKey;
-    const storageKeyName = `tablinum-key-${config.dbName ?? "tablinum"}`;
-    if (!resolvedKey && typeof globalThis.localStorage !== "undefined") {
-      const saved = globalThis.localStorage.getItem(storageKeyName);
-      if (saved && saved.length === 64) {
-        const bytes = new Uint8Array(32);
-        for (let i = 0;i < 32; i++) {
-          bytes[i] = parseInt(saved.slice(i * 2, i * 2 + 2), 16);
-        }
-        resolvedKey = bytes;
+    const privateKeyHex = bytesToHex2(privateKey);
+    const publicKey = yield* Effect10.try({
+      try: () => getPublicKey2(privateKey),
+      catch: (e) => new CryptoError({
+        message: `Failed to derive public key: ${e instanceof Error ? e.message : String(e)}`,
+        cause: e
+      })
+    });
+    return {
+      privateKey,
+      publicKey,
+      exportKey: () => privateKeyHex
+    };
+  });
+}
+
+// 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;
+}));
+
+// src/layers/EpochStoreLive.ts
+import { Effect as Effect12, Layer as Layer2, 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;
+}));
+
+// src/layers/StorageLive.ts
+import { Effect as Effect14, Layer as Layer3 } from "effect";
+
+// src/storage/idb.ts
+import { Effect as Effect13 } from "effect";
+import { openDB } from "idb";
+var DB_NAME = "tablinum";
+function storeName(collection2) {
+  return `col_${collection2}`;
+}
+function computeSchemaSig(schema) {
+  return Object.entries(schema).sort(([a], [b]) => a.localeCompare(b)).map(([name, def]) => {
+    const indices = [...def.indices ?? []].sort().join(",");
+    return `${name}:${indices}`;
+  }).join("|");
+}
+function wrap(label, fn) {
+  return Effect13.tryPromise({
+    try: fn,
+    catch: (e) => new StorageError({
+      message: `IndexedDB ${label} failed: ${e instanceof Error ? e.message : String(e)}`,
+      cause: e
+    })
+  });
+}
+function upgradeSchema(database, schema, tx) {
+  if (!database.objectStoreNames.contains("_meta")) {
+    database.createObjectStore("_meta");
+  }
+  if (!database.objectStoreNames.contains("events")) {
+    const events = database.createObjectStore("events", { keyPath: "id" });
+    events.createIndex("by-record", ["collection", "recordId"]);
+  }
+  if (!database.objectStoreNames.contains("giftwraps")) {
+    database.createObjectStore("giftwraps", { keyPath: "id" });
+  }
+  const expectedStores = new Set;
+  for (const [, def] of Object.entries(schema)) {
+    const sn = storeName(def.name);
+    expectedStores.add(sn);
+    if (!database.objectStoreNames.contains(sn)) {
+      const store = database.createObjectStore(sn, { keyPath: "id" });
+      for (const idx of def.indices ?? []) {
+        store.createIndex(idx, idx);
+      }
+    } else {
+      const store = tx.objectStore(sn);
+      const existingIndices = new Set(Array.from(store.indexNames));
+      const wantedIndices = new Set(def.indices ?? []);
+      for (const idx of existingIndices) {
+        if (!wantedIndices.has(idx))
+          store.deleteIndex(idx);
+      }
+      for (const idx of wantedIndices) {
+        if (!existingIndices.has(idx))
+          store.createIndex(idx, idx);
       }
     }
-    const identity = yield* createIdentity(resolvedKey);
-    if (typeof globalThis.localStorage !== "undefined") {
-      globalThis.localStorage.setItem(storageKeyName, identity.exportKey());
-    }
-    const storage = yield* openIDBStorage(config.dbName, config.schema);
-    const pubsub = yield* PubSub2.unbounded();
-    const replayingRef = yield* Ref5.make(false);
-    const watchCtx = { pubsub, replayingRef };
-    const closedRef = yield* Ref5.make(false);
-    const giftWrapHandle = createGiftWrapHandle(identity.privateKey, identity.publicKey);
-    const relayHandle = createRelayHandle();
-    const publishQueue = yield* createPublishQueue(storage, relayHandle);
-    const syncStatus = yield* createSyncStatusHandle();
-    const syncHandle = createSyncHandle(storage, giftWrapHandle, relayHandle, publishQueue, syncStatus, watchCtx, config.relays, identity.publicKey, config.onSyncError);
-    const onWrite = (event) => Effect14.gen(function* () {
-      console.log("[tablinum:onWrite]", event.kind, event.collection, event.recordId);
-      const content = event.kind === "delete" ? JSON.stringify({ _deleted: true }) : JSON.stringify(event.data);
-      const dTag = `${event.collection}:${event.recordId}`;
-      const wrapResult = yield* Effect14.result(giftWrapHandle.wrap({
-        kind: 1,
-        content,
-        tags: [["d", dTag]],
-        created_at: Math.floor(event.createdAt / 1000)
-      }));
-      if (wrapResult._tag === "Success") {
-        const gw = wrapResult.success;
-        console.log("[tablinum:onWrite] gift wrap created:", gw.id, "kind:", gw.kind, "tags:", JSON.stringify(gw.tags));
-        yield* storage.putGiftWrap({
-          id: gw.id,
-          event: gw,
-          createdAt: gw.created_at
-        });
-        console.log("[tablinum:onWrite] gift wrap stored, publishing...");
-        const publishEffect = Effect14.gen(function* () {
-          const pubResult = yield* Effect14.result(syncHandle.publishLocal({
-            id: gw.id,
-            event: gw,
-            createdAt: gw.created_at
-          }));
-          if (pubResult._tag === "Failure") {
-            const err = pubResult.failure;
-            console.error("[tablinum:publish] failed:", err);
-            if (config.onSyncError)
-              config.onSyncError(err);
-          } else {
-            console.log("[tablinum:publish] success");
+  }
+  for (const existing of Array.from(database.objectStoreNames)) {
+    if (existing.startsWith("col_") && !expectedStores.has(existing)) {
+      database.deleteObjectStore(existing);
+    }
+  }
+  tx.objectStore("_meta").put(computeSchemaSig(schema), "schema_sig");
+}
+function openIDBStorage(dbName, schema) {
+  return Effect13.gen(function* () {
+    const name = dbName ?? DB_NAME;
+    const schemaSig = computeSchemaSig(schema);
+    const probeDb = yield* Effect13.tryPromise({
+      try: () => openDB(name),
+      catch: (e) => new StorageError({ message: "Failed to open IndexedDB", cause: e })
+    });
+    const currentVersion = probeDb.version;
+    let needsUpgrade = true;
+    if (probeDb.objectStoreNames.contains("_meta")) {
+      const storedSig = yield* Effect13.tryPromise({
+        try: () => probeDb.get("_meta", "schema_sig"),
+        catch: () => new StorageError({ message: "Failed to read schema meta" })
+      }).pipe(Effect13.catch(() => Effect13.succeed(undefined)));
+      needsUpgrade = storedSig !== schemaSig;
+    }
+    probeDb.close();
+    const db = needsUpgrade ? yield* Effect13.tryPromise({
+      try: () => openDB(name, currentVersion + 1, {
+        upgrade(database, _oldVersion, _newVersion, transaction) {
+          upgradeSchema(database, schema, transaction);
+        }
+      }),
+      catch: (e) => new StorageError({ message: "Failed to open IndexedDB", cause: e })
+    }) : yield* Effect13.tryPromise({
+      try: () => openDB(name),
+      catch: (e) => new StorageError({ message: "Failed to open IndexedDB", cause: e })
+    });
+    yield* Effect13.addFinalizer(() => Effect13.sync(() => db.close()));
+    const handle = {
+      putRecord: (collection2, record) => wrap("putRecord", () => db.put(storeName(collection2), record).then(() => {
+        return;
+      })),
+      getRecord: (collection2, id) => wrap("getRecord", () => db.get(storeName(collection2), id)),
+      getAllRecords: (collection2) => wrap("getAllRecords", () => db.getAll(storeName(collection2))),
+      countRecords: (collection2) => wrap("countRecords", () => db.count(storeName(collection2))),
+      clearRecords: (collection2) => wrap("clearRecords", () => db.clear(storeName(collection2))),
+      getByIndex: (collection2, indexName, value) => wrap("getByIndex", () => db.getAllFromIndex(storeName(collection2), indexName, value)),
+      getByIndexRange: (collection2, indexName, range) => wrap("getByIndexRange", () => db.getAllFromIndex(storeName(collection2), indexName, range)),
+      getAllSorted: (collection2, indexName, direction) => wrap("getAllSorted", async () => {
+        const sn = storeName(collection2);
+        const tx = db.transaction(sn, "readonly");
+        const store = tx.objectStore(sn);
+        const index = store.index(indexName);
+        const results = [];
+        let cursor = await index.openCursor(null, direction ?? "next");
+        while (cursor) {
+          results.push(cursor.value);
+          cursor = await cursor.continue();
+        }
+        return results;
+      }),
+      putEvent: (event) => wrap("putEvent", () => db.put("events", event).then(() => {
+        return;
+      })),
+      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) {
+          const { event: _, ...tombstone } = existing;
+          await db.put("giftwraps", tombstone);
+        }
+      }),
+      deleteEvent: (id) => wrap("deleteEvent", () => db.delete("events", id).then(() => {
+        return;
+      })),
+      getMeta: (key) => wrap("getMeta", () => db.get("_meta", key)),
+      putMeta: (key, value) => wrap("putMeta", () => db.put("_meta", value, key).then(() => {
+        return;
+      })),
+      close: () => Effect13.sync(() => db.close())
+    };
+    return handle;
+  });
+}
+
+// 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
+  });
+}));
+
+// src/layers/RelayLive.ts
+import { Layer as Layer4 } from "effect";
+
+// src/sync/relay.ts
+import { Effect as Effect15, Option as Option8, Schema as Schema7, ScopedCache, Scope as Scope3 } from "effect";
+import { Relay as Relay2 } from "nostr-tools/relay";
+var NegMessageFrameSchema = Schema7.Tuple([
+  Schema7.Literal("NEG-MSG"),
+  Schema7.String,
+  Schema7.String
+]);
+var NegErrorFrameSchema = Schema7.Tuple([Schema7.Literal("NEG-ERR"), Schema7.String, Schema7.String]);
+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())));
+}
+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
+        })
+      }), (relay) => Effect15.sync(() => {
+        relay.close();
+      }))
+    });
+    const connectedUrls = new Set;
+    const statusListeners = new Set;
+    const notifyStatus = () => {
+      const status = { connectedUrls: [...connectedUrls] };
+      for (const listener of statusListeners)
+        listener(status);
+    };
+    const markConnected = (url) => {
+      if (!connectedUrls.has(url)) {
+        connectedUrls.add(url);
+        notifyStatus();
+      }
+    };
+    const markDisconnected = (url) => {
+      if (connectedUrls.has(url)) {
+        connectedUrls.delete(url);
+        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);
+            }
+          },
+          oneose() {
+            if (settled)
+              return;
+            cleanup();
+            resume(Effect15.succeed(events));
           }
         });
-        yield* Effect14.forkDetach(publishEffect);
-      } else {
-        const err = wrapResult.failure;
-        console.error("[tablinum:onWrite] wrap failed:", err);
-        if (config.onSyncError)
-          config.onSyncError(err);
+        timer = setTimeout(() => {
+          if (settled)
+            return;
+          cleanup();
+          resume(Effect15.succeed(events));
+        }, 1e4);
+      } catch (e) {
+        cleanup();
+        fail(e);
       }
-    });
-    const handles = new Map;
-    for (const [, def] of schemaEntries) {
-      const validator = buildValidator(def.name, def);
-      const partialValidator = buildPartialValidator(def.name, def);
-      const handle = createCollectionHandle(def, storage, watchCtx, validator, partialValidator, uuidv7, onWrite);
-      handles.set(def.name, handle);
-    }
-    yield* syncHandle.startSubscription();
-    const dbHandle = {
-      collection: (name) => {
-        const handle = handles.get(name);
-        if (!handle) {
-          throw new Error(`Collection "${name}" not found in schema`);
+      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 failures = results.filter((r) => r._tag === "Failure");
+        if (failures.length === urls.length && urls.length > 0) {
+          return yield* new RelayError({
+            message: `Publish failed on all ${urls.length} relays`
+          });
         }
-        return handle;
-      },
-      exportKey: () => identity.exportKey(),
-      close: () => Effect14.gen(function* () {
-        yield* Ref5.set(closedRef, true);
-        yield* relayHandle.closeAll();
-        yield* storage.close();
       }),
-      rebuild: () => Effect14.gen(function* () {
-        const closed = yield* Ref5.get(closedRef);
-        if (closed) {
-          return yield* new StorageError({ message: "Database is closed" });
+      fetchEvents: (ids, url) => Effect15.gen(function* () {
+        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) {
+            cleanup();
+            fail(new Error("Cannot access relay WebSocket"));
+            return Effect15.succeed(undefined);
+          }
+          timer = setTimeout(() => {
+            if (settled)
+              return;
+            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);
         }
-        yield* rebuild(storage, schemaEntries.map(([, def]) => def.name));
+        return Effect15.sync(cleanup);
+      })),
+      closeAll: () => ScopedCache.invalidateAll(connections),
+      getStatus: () => ({ connectedUrls: [...connectedUrls] }),
+      subscribeStatus: (callback) => {
+        statusListeners.add(callback);
+        return () => statusListeners.delete(callback);
+      }
+    };
+  });
+}
+
+// src/layers/RelayLive.ts
+var RelayLive = Layer4.effect(Relay, createRelayHandle());
+
+// src/layers/GiftWrapLive.ts
+import { Effect as Effect17, Layer as Layer5 } from "effect";
+
+// src/sync/gift-wrap.ts
+import { Effect as Effect16 } from "effect";
+import { wrapEvent as wrapEvent2, unwrapEvent as unwrapEvent2 } from "nostr-tools/nip59";
+function createEpochGiftWrapHandle(senderPrivateKey, epochStore) {
+  return {
+    wrap: (rumor) => Effect16.try({
+      try: () => wrapEvent2(rumor, senderPrivateKey, getCurrentPublicKey(epochStore)),
+      catch: (e) => new CryptoError({
+        message: `Gift wrap failed: ${e instanceof Error ? e.message : String(e)}`,
+        cause: e
+      })
+    }),
+    unwrap: (giftWrap) => Effect16.gen(function* () {
+      const pTag = giftWrap.tags.find((t) => t[0] === "p")?.[1];
+      if (!pTag) {
+        return yield* new CryptoError({ message: "Gift wrap missing #p tag" });
+      }
+      const decKey = getDecryptionKey(epochStore, pTag);
+      if (!decKey) {
+        return yield* new CryptoError({
+          message: `No epoch key for public key ${pTag.slice(0, 8)}...`
+        });
+      }
+      return yield* Effect16.try({
+        try: () => unwrapEvent2(giftWrap, decKey),
+        catch: (e) => new CryptoError({
+          message: `Gift unwrap failed: ${e instanceof Error ? e.message : String(e)}`,
+          cause: e
+        })
+      });
+    })
+  };
+}
+
+// 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);
+}));
+
+// src/layers/PublishQueueLive.ts
+import { Effect as Effect19, Layer as Layer6 } from "effect";
+
+// src/sync/publish-queue.ts
+import { Effect as Effect18, Ref as Ref4 } from "effect";
+var META_KEY = "publish_queue";
+function persist(storage, pending) {
+  return storage.putMeta(META_KEY, [...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 pendingRef = yield* Ref4.make(initial);
+    const listeners = new Set;
+    const notify = (pending) => {
+      for (const listener of listeners)
+        listener(pending.size);
+    };
+    return {
+      enqueue: (eventId) => Effect18.gen(function* () {
+        const next = yield* Ref4.updateAndGet(pendingRef, (set) => {
+          const n = new Set(set);
+          n.add(eventId);
+          return n;
+        });
+        yield* persist(storage, next);
+        notify(next);
       }),
-      sync: () => Effect14.gen(function* () {
-        const closed = yield* Ref5.get(closedRef);
-        if (closed) {
-          return yield* new SyncError({ message: "Database is closed", phase: "init" });
+      flush: (relayUrls) => Effect18.gen(function* () {
+        const pending = yield* Ref4.get(pendingRef);
+        if (pending.size === 0)
+          return;
+        const succeeded = new Set;
+        let consecutiveFailures = 0;
+        for (const eventId of pending) {
+          if (consecutiveFailures >= 3)
+            break;
+          const gw = yield* storage.getGiftWrap(eventId);
+          if (!gw || !gw.event) {
+            succeeded.add(eventId);
+            consecutiveFailures = 0;
+            continue;
+          }
+          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++;
+          }
+        }
+        if (succeeded.size > 0) {
+          const updated = yield* Ref4.updateAndGet(pendingRef, (set) => {
+            const next = new Set(set);
+            for (const id of succeeded) {
+              next.delete(id);
+            }
+            return next;
+          });
+          yield* persist(storage, updated);
+          notify(updated);
         }
-        yield* syncHandle.sync();
       }),
-      getSyncStatus: () => syncStatus.get()
+      size: () => Ref4.get(pendingRef).pipe(Effect18.map((s) => s.size)),
+      subscribe: (callback) => {
+        listeners.add(callback);
+        return () => listeners.delete(callback);
+      }
     };
-    return dbHandle;
   });
 }
 
-// src/svelte/database.svelte.ts
-import { Effect as Effect18, Scope as Scope3, Exit } from "effect";
+// 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);
+}));
 
-// src/svelte/collection.svelte.ts
-import { Effect as Effect17, Fiber as Fiber2, Stream as Stream5 } from "effect";
+// src/layers/SyncStatusLive.ts
+import { Layer as Layer7 } from "effect";
 
-// src/svelte/query.svelte.ts
-import { Effect as Effect16 } 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;
+    return {
+      get: () => SubscriptionRef.get(ref),
+      set: (status) => Effect20.gen(function* () {
+        yield* SubscriptionRef.set(ref, status);
+        for (const listener of listeners)
+          listener(status);
+      }),
+      subscribe: (callback) => {
+        listeners.add(callback);
+        return () => listeners.delete(callback);
+      }
+    };
+  });
+}
 
-// src/svelte/live-query.svelte.ts
-import { Effect as Effect15, Fiber, Stream as Stream4 } from "effect";
+// src/layers/SyncStatusLive.ts
+var SyncStatusLive = Layer7.effect(SyncStatus, createSyncStatusHandle());
 
-class LiveQuery {
-  items = $state([]);
-  error = $state(null);
-  #fiber = null;
-  constructor(stream) {
-    const effect = Stream4.runForEach(stream, (records) => Effect15.sync(() => {
-      this.items = records;
-    })).pipe(Effect15.catch((e) => Effect15.sync(() => {
-      this.error = e instanceof Error ? e : new Error(String(e));
-    })));
-    this.#fiber = Effect15.runFork(effect);
-  }
-  destroy() {
-    if (this.#fiber) {
-      Effect15.runFork(Fiber.interrupt(this.#fiber));
-      this.#fiber = null;
+// src/layers/TablinumLive.ts
+function reportSyncError(onSyncError, error) {
+  if (!onSyncError)
+    return;
+  onSyncError(error instanceof Error ? error : new Error(String(error)));
+}
+function mapMemberRecord(record) {
+  return {
+    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 } : {}
+  };
+}
+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 Set(allSchemaEntries.map(([, def]) => def.name));
+  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 === "delete" ? JSON.stringify({ _deleted: true }) : 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, eventId: event.id, createdAt: gw.created_at });
+    yield* Effect21.forkIn(Effect21.gen(function* () {
+      const publishResult = yield* Effect21.result(syncHandle.publishLocal({
+        id: gw.id,
+        eventId: event.id,
+        event: gw,
+        createdAt: gw.created_at
+      }));
+      if (publishResult._tag === "Failure") {
+        reportSyncError(config.onSyncError, publishResult.failure);
+      }
+    }), 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 ? "update" : "create",
+      data: record,
+      createdAt: Date.now()
+    };
+    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?.();
+  });
+  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, 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 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;
+      yield* putMemberRecord({
+        id: pubkey,
+        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
+      });
+      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._deleted).map(mapMemberRecord);
+    })),
+    setProfile: (profile) => ensureOpen(Effect21.gen(function* () {
+      const existing = yield* storage.getRecord("_members", identity.publicKey);
+      if (!existing) {
+        return yield* new ValidationError({ message: "Current user is not a member" });
+      }
+      yield* putMemberRecord({ ...existing, ...profile });
+    }))
+  };
+  return dbHandle;
+})).pipe(Layer8.provide(AllServicesLive));
+
+// src/db/create-tablinum.ts
+function validateConfig(config) {
+  return Effect22.gen(function* () {
+    if (Object.keys(config.schema).length === 0) {
+      return yield* new ValidationError({
+        message: "Schema must contain at least one collection"
+      });
+    }
+  });
+}
+function createTablinum(config) {
+  return Effect22.gen(function* () {
+    yield* validateConfig(config);
+    const runtimeConfig = yield* resolveRuntimeConfig(config);
+    const configValue = {
+      ...runtimeConfig,
+      schema: config.schema,
+      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);
+    return ServiceMap10.get(ctx, Tablinum);
+  });
+}
+
+// src/svelte/collection.svelte.ts
+import { Effect as Effect24, Fiber, Option as Option11, Stream as Stream4 } from "effect";
+
+// src/svelte/deferred.ts
+function createDeferred() {
+  let settled = false;
+  let resolvePromise;
+  let rejectPromise;
+  const promise = new Promise((resolve, reject) => {
+    resolvePromise = resolve;
+    rejectPromise = reject;
+  });
+  return {
+    promise,
+    settled: () => settled,
+    resolve: (value) => {
+      if (settled)
+        return;
+      settled = true;
+      resolvePromise(value);
+    },
+    reject: (reason) => {
+      if (settled)
+        return;
+      settled = true;
+      rejectPromise(reason);
+    }
+  };
 }
 
 // src/svelte/query.svelte.ts
-function wrapQueryBuilder(builder, onLive) {
+import { Effect as Effect23, Option as Option10 } from "effect";
+function wrapQueryBuilder(getBuilder, touchVersion, ready) {
   return {
-    and: (fn) => wrapQueryBuilder(builder.and(fn), onLive),
-    sortBy: (field) => wrapQueryBuilder(builder.sortBy(field), onLive),
-    reverse: () => wrapQueryBuilder(builder.reverse(), onLive),
-    offset: (n) => wrapQueryBuilder(builder.offset(n), onLive),
-    limit: (n) => wrapQueryBuilder(builder.limit(n), onLive),
-    get: () => Effect16.runPromise(builder.get()),
-    first: () => Effect16.runPromise(builder.first()),
-    count: () => Effect16.runPromise(builder.count()),
-    live: () => {
-      const lq = new LiveQuery(builder.watch());
-      onLive?.(lq);
-      return lq;
+    and: (fn) => wrapQueryBuilder(() => getBuilder().and(fn), touchVersion, ready),
+    sortBy: (field2) => wrapQueryBuilder(() => getBuilder().sortBy(field2), touchVersion, ready),
+    reverse: () => wrapQueryBuilder(() => getBuilder().reverse(), touchVersion, ready),
+    offset: (n) => wrapQueryBuilder(() => getBuilder().offset(n), touchVersion, ready),
+    limit: (n) => wrapQueryBuilder(() => getBuilder().limit(n), touchVersion, ready),
+    get: () => {
+      touchVersion();
+      return ready.then(() => Effect23.runPromise(getBuilder().get()));
+    },
+    first: () => {
+      touchVersion();
+      return ready.then(() => Effect23.runPromise(Effect23.map(getBuilder().first(), Option10.getOrNull)));
+    },
+    count: () => {
+      touchVersion();
+      return ready.then(() => Effect23.runPromise(getBuilder().count()));
     }
   };
 }
-function wrapWhereClause(clause, onLive) {
+function wrapWhereClause(getClause, touchVersion, ready) {
   return {
-    equals: (value) => wrapQueryBuilder(clause.equals(value), onLive),
-    above: (value) => wrapQueryBuilder(clause.above(value), onLive),
-    aboveOrEqual: (value) => wrapQueryBuilder(clause.aboveOrEqual(value), onLive),
-    below: (value) => wrapQueryBuilder(clause.below(value), onLive),
-    belowOrEqual: (value) => wrapQueryBuilder(clause.belowOrEqual(value), onLive),
-    between: (lower, upper, options) => wrapQueryBuilder(clause.between(lower, upper, options), onLive),
-    startsWith: (prefix) => wrapQueryBuilder(clause.startsWith(prefix), onLive),
-    anyOf: (values) => wrapQueryBuilder(clause.anyOf(values), onLive),
-    noneOf: (values) => wrapQueryBuilder(clause.noneOf(values), onLive)
+    equals: (value) => wrapQueryBuilder(() => getClause().equals(value), touchVersion, ready),
+    above: (value) => wrapQueryBuilder(() => getClause().above(value), touchVersion, ready),
+    aboveOrEqual: (value) => wrapQueryBuilder(() => getClause().aboveOrEqual(value), touchVersion, ready),
+    below: (value) => wrapQueryBuilder(() => getClause().below(value), touchVersion, ready),
+    belowOrEqual: (value) => wrapQueryBuilder(() => getClause().belowOrEqual(value), touchVersion, ready),
+    between: (lower, upper, options) => wrapQueryBuilder(() => getClause().between(lower, upper, options), touchVersion, ready),
+    startsWith: (prefix) => wrapQueryBuilder(() => getClause().startsWith(prefix), touchVersion, ready),
+    anyOf: (values) => wrapQueryBuilder(() => getClause().anyOf(values), touchVersion, ready),
+    noneOf: (values) => wrapQueryBuilder(() => getClause().noneOf(values), touchVersion, ready)
   };
 }
-function wrapOrderByBuilder(builder, onLive) {
+function wrapOrderByBuilder(getBuilder, touchVersion, ready) {
   return {
-    reverse: () => wrapOrderByBuilder(builder.reverse(), onLive),
-    offset: (n) => wrapOrderByBuilder(builder.offset(n), onLive),
-    limit: (n) => wrapOrderByBuilder(builder.limit(n), onLive),
-    get: () => Effect16.runPromise(builder.get()),
-    first: () => Effect16.runPromise(builder.first()),
-    count: () => Effect16.runPromise(builder.count()),
-    live: () => {
-      const lq = new LiveQuery(builder.watch());
-      onLive?.(lq);
-      return lq;
+    reverse: () => wrapOrderByBuilder(() => getBuilder().reverse(), touchVersion, ready),
+    offset: (n) => wrapOrderByBuilder(() => getBuilder().offset(n), touchVersion, ready),
+    limit: (n) => wrapOrderByBuilder(() => getBuilder().limit(n), touchVersion, ready),
+    get: () => {
+      touchVersion();
+      return ready.then(() => Effect23.runPromise(getBuilder().get()));
+    },
+    first: () => {
+      touchVersion();
+      return ready.then(() => Effect23.runPromise(Effect23.map(getBuilder().first(), Option10.getOrNull)));
+    },
+    count: () => {
+      touchVersion();
+      return ready.then(() => Effect23.runPromise(getBuilder().count()));
     }
   };
 }
 
 // src/svelte/collection.svelte.ts
 class Collection {
-  items = $state([]);
   error = $state(null);
-  #handle;
+  #handle = null;
+  #ready = createDeferred();
+  #version = $state(0);
+  #watchAbort = null;
   #watchFiber = null;
-  #liveQueries = new Set;
-  constructor(handle) {
+  _bind(handle) {
+    if (this.#handle)
+      return;
     this.#handle = handle;
-    const watchEffect = Stream5.runForEach(handle.watch(), (records) => Effect17.sync(() => {
-      this.items = records;
-    })).pipe(Effect17.catch((e) => Effect17.sync(() => {
-      this.error = e instanceof Error ? e : new Error(String(e));
-    })));
-    this.#watchFiber = Effect17.runFork(watchEffect);
+    this.error = null;
+    this.#settleReady();
+    this.#startWatch();
   }
-  #run = async (effect) => {
-    try {
-      this.error = null;
-      return await Effect17.runPromise(effect);
-    } catch (e) {
-      this.error = e instanceof Error ? e : new Error(String(e));
-      throw this.error;
+  _fail(err) {
+    this.error = err;
+    this.#settleReady(err);
+  }
+  #settleReady(err) {
+    if (err) {
+      this.#ready.reject(err);
+    } else {
+      this.#ready.resolve();
+    }
+  }
+  #startWatch() {
+    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));
+      }
+    }))));
+  }
+  #touchVersion = () => {
+    this.#version;
+  };
+  #handleOrThrow = () => {
+    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());
+  };
+  add = (data) => {
+    return this.#run(() => this.#handleOrThrow().add(data));
+  };
+  update = (id, data) => {
+    return this.#run(() => this.#handleOrThrow().update(id, data));
+  };
+  delete = (id) => {
+    return this.#run(() => this.#handleOrThrow().delete(id));
+  };
+  get(id) {
+    if (typeof id === "string") {
+      return this.#run(() => this.#handleOrThrow().get(id));
     }
+    this.#touchVersion();
+    return this.#run(() => Stream4.runHead(this.#handleOrThrow().watch()).pipe(Effect24.map((opt) => Option11.getOrElse(opt, () => []))));
+  }
+  first = () => {
+    this.#touchVersion();
+    return this.#run(() => Effect24.map(this.#handleOrThrow().first(), Option11.getOrNull));
   };
-  #onLive = (lq) => {
-    this.#liveQueries.add(lq);
+  count = () => {
+    this.#touchVersion();
+    return this.#run(() => this.#handleOrThrow().count());
   };
-  add = (data) => this.#run(this.#handle.add(data));
-  update = (id, data) => this.#run(this.#handle.update(id, data));
-  delete = (id) => this.#run(this.#handle.delete(id));
-  get = (id) => this.#run(this.#handle.get(id));
-  first = () => this.#run(this.#handle.first());
-  count = () => this.#run(this.#handle.count());
-  where = (field) => {
-    return wrapWhereClause(this.#handle.where(field), this.#onLive);
+  where = (field2) => {
+    return wrapWhereClause(() => this.#handleOrThrow().where(field2), this.#touchVersion, this.#ready.promise);
   };
-  orderBy = (field) => {
-    return wrapOrderByBuilder(this.#handle.orderBy(field), this.#onLive);
+  orderBy = (field2) => {
+    return wrapOrderByBuilder(() => this.#handleOrThrow().orderBy(field2), this.#touchVersion, this.#ready.promise);
   };
-  _destroy() {
+  _destroy(reason = new ClosedError({ message: "Collection is closed" })) {
+    if (this.#watchAbort) {
+      this.#watchAbort.abort();
+      this.#watchAbort = null;
+    }
     if (this.#watchFiber) {
-      Effect17.runFork(Fiber2.interrupt(this.#watchFiber));
+      Effect24.runFork(Fiber.interrupt(this.#watchFiber));
       this.#watchFiber = null;
     }
-    for (const lq of this.#liveQueries) {
-      lq.destroy();
-    }
-    this.#liveQueries.clear();
+    this.#handle = null;
+    this.error ??= reason;
+    this.#settleReady(this.error);
   }
 }
 
-// src/svelte/database.svelte.ts
-class Database {
-  status = $state("idle");
+// src/svelte/tablinum.svelte.ts
+class Tablinum2 {
+  status = $state("initializing");
+  syncStatus = $state("idle");
+  pendingCount = $state(0);
+  relayStatus = $state({ connectedUrls: [] });
   error = $state(null);
-  #handle;
-  #scope;
+  ready;
+  #handle = null;
+  #scope = null;
   #collections = new Map;
-  #statusInterval = null;
+  #members = new Collection;
+  #unsubscribeSyncStatus = null;
+  #unsubscribePendingCount = null;
+  #unsubscribeRelayStatus = null;
   #closed = false;
-  constructor(handle, scope) {
-    this.#handle = handle;
-    this.#scope = scope;
-    this.#statusInterval = setInterval(() => {
-      if (this.#closed)
-        return;
-      Effect18.runPromise(this.#handle.getSyncStatus()).then((s) => {
-        this.status = s;
-      }).catch(() => {});
-    }, 1000);
+  #readyState = createDeferred();
+  constructor(config) {
+    this.ready = this.#readyState.promise;
+    this.#init(config);
   }
-  collection(name) {
-    let col = this.#collections.get(name);
-    if (!col) {
-      const handle = this.#handle.collection(name);
-      col = new Collection(handle);
-      this.#collections.set(name, col);
+  #settleReady(err) {
+    if (err) {
+      this.#readyState.reject(err);
+    } else {
+      this.#readyState.resolve();
     }
-    return col;
   }
-  exportKey() {
-    return this.#handle.exportKey();
-  }
-  close = async () => {
-    if (this.#closed)
-      return;
-    this.#closed = true;
-    if (this.#statusInterval) {
-      clearInterval(this.#statusInterval);
-      this.#statusInterval = null;
-    }
-    for (const col of this.#collections.values()) {
-      col._destroy();
+  #bindCollections(handle) {
+    this.#members._bind(handle.members);
+    for (const [name, collection2] of this.#collections) {
+      collection2._bind(handle.collection(name));
     }
-    this.#collections.clear();
-    await Effect18.runPromise(this.#handle.close());
-    await Effect18.runPromise(Scope3.close(this.#scope, Exit.void));
-  };
-  sync = async () => {
+  }
+  #runHandleEffect = async (run) => {
+    const handle = this.#requireReady();
     try {
       this.error = null;
-      await Effect18.runPromise(this.#handle.sync());
+      return await Effect25.runPromise(run(handle));
     } catch (e) {
       this.error = e instanceof Error ? e : new Error(String(e));
       throw this.error;
     }
   };
-  rebuild = async () => {
+  async#init(config) {
+    const scope = Effect25.runSync(Scope6.make());
     try {
-      this.error = null;
-      await Effect18.runPromise(this.#handle.rebuild());
+      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;
+        return;
+      }
+      this.#handle = handle;
+      this.#scope = scope;
+      this.#bindCollections(handle);
+      this.#unsubscribeSyncStatus = handle.subscribeSyncStatus((s) => {
+        this.syncStatus = s;
+      });
+      this.#unsubscribePendingCount = handle.subscribePendingCount((count) => {
+        this.pendingCount = count;
+      });
+      this.pendingCount = await Effect25.runPromise(handle.pendingCount());
+      this.#unsubscribeRelayStatus = handle.subscribeRelayStatus((s) => {
+        this.relayStatus = s;
+      });
+      this.relayStatus = handle.getRelayStatus();
+      this.status = "ready";
+      this.#settleReady();
     } catch (e) {
-      this.error = e instanceof Error ? e : new Error(String(e));
-      throw this.error;
+      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";
+      this.#members._fail(err);
+      for (const col of this.#collections.values()) {
+        col._fail(err);
+      }
+      this.#settleReady(err);
     }
-  };
-}
-
-// src/schema/field.ts
-function make(kind, isOptional, isArray) {
-  return { _tag: "FieldDef", kind, isOptional, isArray };
-}
-var field = {
-  string: () => make("string", false, false),
-  number: () => make("number", false, false),
-  boolean: () => make("boolean", false, false),
-  json: () => make("json", false, false),
-  optional: (inner) => make(inner.kind, true, inner.isArray),
-  array: (inner) => make(inner.kind, inner.isOptional, true)
-};
-// src/schema/collection.ts
-var RESERVED_NAMES = new Set(["id", "_deleted", "_createdAt", "_updatedAt"]);
-function collection(name, fields, options) {
-  if (!name || name.trim().length === 0) {
-    throw new Error("Collection name must not be empty");
   }
-  const fieldNames = Object.keys(fields);
-  if (fieldNames.length === 0) {
-    throw new Error(`Collection "${name}" must have at least one field`);
+  get publicKey() {
+    return this.#handle?.publicKey ?? "";
   }
-  for (const fieldName of fieldNames) {
-    if (RESERVED_NAMES.has(fieldName)) {
-      throw new Error(`Field name "${fieldName}" is reserved`);
-    }
+  get members() {
+    return this.#members;
   }
-  const indices = [];
-  if (options?.indices) {
-    for (const idx of options.indices) {
-      const fieldDef = fields[idx];
-      if (!fieldDef) {
-        throw new Error(`Index field "${idx}" does not exist in collection "${name}"`);
-      }
-      if (fieldDef.kind === "json" || fieldDef.isArray) {
-        throw new Error(`Field "${idx}" cannot be indexed (type: ${fieldDef.kind}${fieldDef.isArray ? "[]" : ""})`);
+  collection(name) {
+    if (this.#closed) {
+      throw new ClosedError({ message: "Tablinum is closed" });
+    }
+    let col = this.#collections.get(name);
+    if (!col) {
+      col = new Collection;
+      this.#collections.set(name, col);
+      if (this.#handle) {
+        col._bind(this.#handle.collection(name));
       }
-      indices.push(idx);
     }
+    return col;
   }
-  return { _tag: "CollectionDef", name, fields, indices };
-}
-
-// src/svelte/index.svelte.ts
-async function createTablinum2(config) {
-  const scope = Effect19.runSync(Scope4.make());
-  try {
-    const handle = await Effect19.runPromise(createTablinum(config).pipe(Effect19.provideService(Scope4.Scope, scope)));
-    return new Database(handle, scope);
-  } catch (e) {
-    await Effect19.runPromise(Scope4.close(scope, Exit2.fail(e)));
-    throw e;
+  #requireReady() {
+    if (!this.#handle) {
+      throw this.error ?? new ClosedError({ message: "Tablinum is not ready" });
+    }
+    return this.#handle;
   }
+  exportKey() {
+    return this.#requireReady().exportKey();
+  }
+  exportInvite() {
+    return this.#requireReady().exportInvite();
+  }
+  close = async () => {
+    if (this.#closed)
+      return;
+    this.#closed = true;
+    const closeError = new ClosedError({
+      message: this.#readyState.settled() ? "Tablinum is closed" : "Tablinum was closed before initialization completed"
+    });
+    if (this.#unsubscribeSyncStatus) {
+      this.#unsubscribeSyncStatus();
+      this.#unsubscribeSyncStatus = null;
+    }
+    if (this.#unsubscribePendingCount) {
+      this.#unsubscribePendingCount();
+      this.#unsubscribePendingCount = null;
+    }
+    if (this.#unsubscribeRelayStatus) {
+      this.#unsubscribeRelayStatus();
+      this.#unsubscribeRelayStatus = null;
+    }
+    this.#members._destroy(closeError);
+    for (const col of this.#collections.values())
+      col._destroy(closeError);
+    this.#collections.clear();
+    const handle = this.#handle;
+    const scope = this.#scope;
+    this.#handle = null;
+    this.#scope = null;
+    if (handle && scope) {
+      await Effect25.runPromise(handle.close());
+      await Effect25.runPromise(Scope6.close(scope, Exit2.void));
+    }
+    if (!this.#readyState.settled()) {
+      this.error = closeError;
+      this.#settleReady(closeError);
+    }
+    this.status = "closed";
+  };
+  sync = async () => this.#runHandleEffect((handle) => handle.sync());
+  rebuild = async () => this.#runHandleEffect((handle) => handle.rebuild());
+  addMember = async (pubkey) => this.#runHandleEffect((handle) => handle.addMember(pubkey));
+  removeMember = async (pubkey) => this.#runHandleEffect((handle) => handle.removeMember(pubkey));
+  getMembers = async () => this.#runHandleEffect((handle) => handle.getMembers());
+  setProfile = async (profile) => this.#runHandleEffect((handle) => handle.setProfile(profile));
 }
 export {
   field,
-  createTablinum2 as createTablinum,
+  encodeInvite,
+  decodeInvite,
   collection,
   ValidationError,
+  Tablinum2 as Tablinum,
   SyncError,
   StorageError,
   RelayError,
   NotFoundError,
-  LiveQuery,
-  Database,
   CryptoError,
   Collection,
   ClosedError