tablinum 0.1.0 → 0.1.3

package/dist/svelte/index.svelte.js

@@ -0,0 +1,2050 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  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/db/create-tablinum.ts
+import { Effect as Effect14, PubSub as PubSub2, Ref as Ref5 } from "effect";
+
+// src/schema/validate.ts
+import { Effect, Schema } from "effect";
+
+// src/errors.ts
+import { Data } from "effect";
+
+class ValidationError extends Data.TaggedError("ValidationError") {
+}
+
+class StorageError extends Data.TaggedError("StorageError") {
+}
+
+class CryptoError extends Data.TaggedError("CryptoError") {
+}
+
+class RelayError extends Data.TaggedError("RelayError") {
+}
+
+class SyncError extends Data.TaggedError("SyncError") {
+}
+
+class NotFoundError extends Data.TaggedError("NotFoundError") {
+}
+
+class ClosedError extends Data.TaggedError("ClosedError") {
+}
+
+// src/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/storage/idb.ts
+import { Effect as Effect2 } from "effect";
+import { openDB } from "idb";
+var DB_NAME = "tablinum";
+function storeName(collection) {
+  return `col_${collection}`;
+}
+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;
+}
+function wrap(label, fn) {
+  return Effect2.tryPromise({
+    try: fn,
+    catch: (e) => new StorageError({
+      message: `IndexedDB ${label} failed: ${e instanceof Error ? e.message : String(e)}`,
+      cause: e
+    })
+  });
+}
+function openIDBStorage(dbName, schema) {
+  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;
+  });
+}
+
+// src/storage/records-store.ts
+import { Effect as Effect3 } from "effect";
+
+// src/storage/lww.ts
+function resolveWinner(existing, incoming) {
+  if (existing === null)
+    return incoming;
+  if (incoming.createdAt > existing.createdAt)
+    return incoming;
+  if (incoming.createdAt < existing.createdAt)
+    return existing;
+  return incoming.id < existing.id ? incoming : existing;
+}
+
+// src/storage/records-store.ts
+function buildRecord(event) {
+  return {
+    id: event.recordId,
+    _deleted: event.kind === "delete",
+    _updatedAt: event.createdAt,
+    ...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));
+    }
+    return incomingWon;
+  });
+}
+function rebuild(storage, collections) {
+  return Effect3.gen(function* () {
+    for (const col of collections) {
+      yield* storage.clearRecords(col);
+    }
+    const allEvents = yield* storage.getAllEvents();
+    const sorted = [...allEvents].sort((a, b) => a.createdAt - b.createdAt);
+    const winners = new Map;
+    for (const event of sorted) {
+      const key = `${event.collection}:${event.recordId}`;
+      const current = winners.get(key) ?? null;
+      winners.set(key, resolveWinner(current, event));
+    }
+    for (const event of winners.values()) {
+      yield* storage.putRecord(event.collection, buildRecord(event));
+    }
+  });
+}
+
+// src/crud/collection-handle.ts
+import { Effect as Effect6 } from "effect";
+
+// src/utils/uuid.ts
+function uuidv7() {
+  const now = Date.now();
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  bytes[0] = now / 2 ** 40 & 255;
+  bytes[1] = now / 2 ** 32 & 255;
+  bytes[2] = now / 2 ** 24 & 255;
+  bytes[3] = now / 2 ** 16 & 255;
+  bytes[4] = now / 2 ** 8 & 255;
+  bytes[5] = now & 255;
+  bytes[6] = bytes[6] & 15 | 112;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+// 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";
+function emptyPlan() {
+  return { filters: [] };
+}
+function executeQuery(ctx, plan) {
+  return Effect5.gen(function* () {
+    if (plan.fieldName) {
+      const fieldDef = ctx.def.fields[plan.fieldName];
+      if (!fieldDef) {
+        return yield* new ValidationError({
+          message: `Unknown field "${plan.fieldName}" in collection "${ctx.collectionName}"`,
+          field: plan.fieldName
+        });
+      }
+      if (fieldDef.kind === "json" || fieldDef.isArray) {
+        return yield* new ValidationError({
+          message: `Field "${plan.fieldName}" does not support filtering (type: ${fieldDef.kind}${fieldDef.isArray ? "[]" : ""})`,
+          field: plan.fieldName
+        });
+      }
+    }
+    let results;
+    if (plan.indexQuery && ctx.def.indices.includes(plan.indexQuery.field)) {
+      if (plan.indexQuery.type === "value") {
+        results = [
+          ...yield* ctx.storage.getByIndex(ctx.collectionName, plan.indexQuery.field, plan.indexQuery.range)
+        ];
+      } else {
+        results = [
+          ...yield* ctx.storage.getByIndexRange(ctx.collectionName, plan.indexQuery.field, plan.indexQuery.range)
+        ];
+      }
+    } else if (plan.orderBy && ctx.def.indices.includes(plan.orderBy.field) && plan.filters.length === 0) {
+      results = [
+        ...yield* ctx.storage.getAllSorted(ctx.collectionName, plan.orderBy.field, plan.orderBy.direction === "desc" ? "prev" : "next")
+      ];
+    } else {
+      results = [...yield* ctx.storage.getAllRecords(ctx.collectionName)];
+    }
+    results = results.filter((r) => !r._deleted);
+    for (const f of plan.filters) {
+      results = results.filter(f);
+    }
+    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;
+        results = results.sort((a, b) => {
+          const va = a[field];
+          const vb = b[field];
+          const cmp = va < vb ? -1 : va > vb ? 1 : 0;
+          return direction === "desc" ? -cmp : cmp;
+        });
+      }
+    }
+    if (plan.offset) {
+      results = results.slice(plan.offset);
+    }
+    if (plan.limit !== null && plan.limit !== undefined) {
+      results = results.slice(0, plan.limit);
+    }
+    return results.map(ctx.mapRecord);
+  });
+}
+function watchQuery(ctx, plan) {
+  const query = () => executeQuery(ctx, plan);
+  const changes = Stream2.fromPubSub(ctx.watchCtx.pubsub).pipe(Stream2.filter((event) => event.collection === ctx.collectionName), Stream2.mapEffect(() => Effect5.gen(function* () {
+    const replaying = yield* Ref2.get(ctx.watchCtx.replayingRef);
+    if (replaying)
+      return;
+    return yield* query();
+  })), Stream2.filter((result) => result !== undefined));
+  return Stream2.unwrap(Effect5.gen(function* () {
+    const initial = yield* query();
+    return Stream2.concat(Stream2.make(initial), changes);
+  }));
+}
+function makeQueryBuilder(ctx, plan) {
+  return {
+    and: (fn) => makeQueryBuilder(ctx, {
+      ...plan,
+      filters: [...plan.filters, (r) => fn(ctx.mapRecord(r))]
+    }),
+    sortBy: (field) => makeQueryBuilder(ctx, {
+      ...plan,
+      orderBy: { field, direction: plan.orderBy?.direction ?? "asc" }
+    }),
+    reverse: () => makeQueryBuilder(ctx, {
+      ...plan,
+      orderBy: {
+        field: plan.orderBy?.field ?? "id",
+        direction: plan.orderBy?.direction === "desc" ? "asc" : "desc"
+      }
+    }),
+    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;
+    }),
+    watch: () => watchQuery(ctx, plan)
+  };
+}
+function createWhereClause(storage, watchCtx, collectionName, def, fieldName, mapRecord) {
+  const ctx = { storage, watchCtx, collectionName, def, mapRecord };
+  const fieldDef = def.fields[fieldName];
+  const isIndexed = def.indices.includes(fieldName) && fieldDef !== null && fieldDef !== undefined && fieldDef.kind !== "boolean";
+  const withFilter = (filterFn, indexQuery) => {
+    const plan = {
+      ...emptyPlan(),
+      fieldName,
+      filters: [filterFn],
+      indexQuery
+    };
+    return makeQueryBuilder(ctx, plan);
+  };
+  return {
+    equals: (value) => withFilter((r) => r[fieldName] === value, isIndexed ? { field: fieldName, range: value, type: "value" } : undefined),
+    above: (value) => withFilter((r) => r[fieldName] > value, isIndexed ? { field: fieldName, range: IDBKeyRange.lowerBound(value, true), type: "range" } : undefined),
+    aboveOrEqual: (value) => withFilter((r) => r[fieldName] >= value, isIndexed ? { field: fieldName, range: IDBKeyRange.lowerBound(value, false), type: "range" } : undefined),
+    below: (value) => withFilter((r) => r[fieldName] < value, isIndexed ? { field: fieldName, range: IDBKeyRange.upperBound(value, true), type: "range" } : undefined),
+    belowOrEqual: (value) => withFilter((r) => r[fieldName] <= value, isIndexed ? { field: fieldName, range: IDBKeyRange.upperBound(value, false), type: "range" } : undefined),
+    between: (lower, upper, options) => {
+      const includeLower = options?.includeLower ?? true;
+      const includeUpper = options?.includeUpper ?? true;
+      return withFilter((r) => {
+        const v = r[fieldName];
+        const aboveLower = includeLower ? v >= lower : v > lower;
+        const belowUpper = includeUpper ? v <= upper : v < upper;
+        return aboveLower && belowUpper;
+      }, isIndexed ? {
+        field: fieldName,
+        range: IDBKeyRange.bound(lower, upper, !includeLower, !includeUpper),
+        type: "range"
+      } : undefined);
+    },
+    startsWith: (prefix) => withFilter((r) => typeof r[fieldName] === "string" && r[fieldName].startsWith(prefix), isIndexed ? {
+      field: fieldName,
+      range: IDBKeyRange.bound(prefix, prefix + "￿", false, false),
+      type: "range"
+    } : undefined),
+    anyOf: (values) => {
+      const set = new Set(values);
+      return withFilter((r) => set.has(r[fieldName]));
+    },
+    noneOf: (values) => {
+      const set = new Set(values);
+      return withFilter((r) => !set.has(r[fieldName]));
+    }
+  };
+}
+function createOrderByBuilder(storage, watchCtx, collectionName, def, fieldName, mapRecord) {
+  const ctx = { storage, watchCtx, collectionName, def, mapRecord };
+  const plan = {
+    ...emptyPlan(),
+    orderBy: { field: fieldName, direction: "asc" }
+  };
+  return makeOrderByBuilder(ctx, plan);
+}
+
+// src/crud/collection-handle.ts
+function mapRecord(record) {
+  const { _deleted, _updatedAt, ...fields } = record;
+  return fields;
+}
+function createCollectionHandle(def, storage, watchCtx, validator, partialValidator, makeEventId, onWrite) {
+  const collectionName = def.name;
+  const handle = {
+    add: (data) => Effect6.gen(function* () {
+      const id = uuidv7();
+      const fullRecord = { id, ...data };
+      yield* validator(fullRecord);
+      const event = {
+        id: makeEventId(),
+        collection: collectionName,
+        recordId: id,
+        kind: "create",
+        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"
+      });
+      return id;
+    }),
+    update: (id, data) => Effect6.gen(function* () {
+      const existing = yield* storage.getRecord(collectionName, id);
+      if (!existing || existing._deleted) {
+        return yield* new NotFoundError({
+          collection: collectionName,
+          id
+        });
+      }
+      yield* partialValidator(data);
+      const { _deleted, _updatedAt, ...existingFields } = existing;
+      const merged = { ...existingFields, ...data, id };
+      yield* validator(merged);
+      const event = {
+        id: makeEventId(),
+        collection: collectionName,
+        recordId: id,
+        kind: "update",
+        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"
+      });
+    }),
+    delete: (id) => Effect6.gen(function* () {
+      const existing = yield* storage.getRecord(collectionName, id);
+      if (!existing || existing._deleted) {
+        return yield* new NotFoundError({
+          collection: collectionName,
+          id
+        });
+      }
+      const event = {
+        id: makeEventId(),
+        collection: collectionName,
+        recordId: id,
+        kind: "delete",
+        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"
+      });
+    }),
+    get: (id) => Effect6.gen(function* () {
+      const record = yield* storage.getRecord(collectionName, id);
+      if (!record || record._deleted) {
+        return yield* new NotFoundError({
+          collection: collectionName,
+          id
+        });
+      }
+      return mapRecord(record);
+    }),
+    first: () => Effect6.gen(function* () {
+      const all = yield* storage.getAllRecords(collectionName);
+      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;
+    }),
+    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)
+  };
+  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";
+
+// src/sync/negentropy.ts
+import { Effect as Effect12 } from "effect";
+
+// src/vendor/negentropy.js
+var PROTOCOL_VERSION = 97;
+var ID_SIZE = 32;
+var FINGERPRINT_SIZE = 16;
+var Mode = {
+  Skip: 0,
+  Fingerprint: 1,
+  IdList: 2
+};
+
+class WrappedBuffer {
+  constructor(buffer) {
+    this._raw = new Uint8Array(buffer || 512);
+    this.length = buffer ? buffer.length : 0;
+  }
+  unwrap() {
+    return this._raw.subarray(0, this.length);
+  }
+  get capacity() {
+    return this._raw.byteLength;
+  }
+  extend(buf) {
+    if (buf._raw)
+      buf = buf.unwrap();
+    if (typeof buf.length !== "number")
+      throw Error("bad length");
+    const targetSize = buf.length + this.length;
+    if (this.capacity < targetSize) {
+      const oldRaw = this._raw;
+      const newCapacity = Math.max(this.capacity * 2, targetSize);
+      this._raw = new Uint8Array(newCapacity);
+      this._raw.set(oldRaw);
+    }
+    this._raw.set(buf, this.length);
+    this.length += buf.length;
+  }
+  shift() {
+    const first = this._raw[0];
+    this._raw = this._raw.subarray(1);
+    this.length--;
+    return first;
+  }
+  shiftN(n = 1) {
+    const firstSubarray = this._raw.subarray(0, n);
+    this._raw = this._raw.subarray(n);
+    this.length -= n;
+    return firstSubarray;
+  }
+}
+function decodeVarInt(buf) {
+  let res = 0;
+  while (true) {
+    if (buf.length === 0)
+      throw Error("parse ends prematurely");
+    let byte = buf.shift();
+    res = res << 7 | byte & 127;
+    if ((byte & 128) === 0)
+      break;
+  }
+  return res;
+}
+function encodeVarInt(n) {
+  if (n === 0)
+    return new WrappedBuffer([0]);
+  let o = [];
+  while (n !== 0) {
+    o.push(n & 127);
+    n >>>= 7;
+  }
+  o.reverse();
+  for (let i = 0;i < o.length - 1; i++)
+    o[i] |= 128;
+  return new WrappedBuffer(o);
+}
+function getByte(buf) {
+  return getBytes(buf, 1)[0];
+}
+function getBytes(buf, n) {
+  if (buf.length < n)
+    throw Error("parse ends prematurely");
+  return buf.shiftN(n);
+}
+
+class Accumulator {
+  constructor() {
+    this.setToZero();
+    if (typeof window === "undefined") {
+      const crypto2 = __require("crypto");
+      this.sha256 = async (slice) => new Uint8Array(crypto2.createHash("sha256").update(slice).digest());
+    } else {
+      this.sha256 = async (slice) => new Uint8Array(await crypto.subtle.digest("SHA-256", slice));
+    }
+  }
+  setToZero() {
+    this.buf = new Uint8Array(ID_SIZE);
+  }
+  add(otherBuf) {
+    let currCarry = 0, nextCarry = 0;
+    let p = new DataView(this.buf.buffer);
+    let po = new DataView(otherBuf.buffer);
+    for (let i = 0;i < 8; i++) {
+      let offset = i * 4;
+      let orig = p.getUint32(offset, true);
+      let otherV = po.getUint32(offset, true);
+      let next = orig;
+      next += currCarry;
+      next += otherV;
+      if (next > 4294967295)
+        nextCarry = 1;
+      p.setUint32(offset, next & 4294967295, true);
+      currCarry = nextCarry;
+      nextCarry = 0;
+    }
+  }
+  negate() {
+    let p = new DataView(this.buf.buffer);
+    for (let i = 0;i < 8; i++) {
+      let offset = i * 4;
+      p.setUint32(offset, ~p.getUint32(offset, true));
+    }
+    let one = new Uint8Array(ID_SIZE);
+    one[0] = 1;
+    this.add(one);
+  }
+  async getFingerprint(n) {
+    let input = new WrappedBuffer;
+    input.extend(this.buf);
+    input.extend(encodeVarInt(n));
+    let hash = await this.sha256(input.unwrap());
+    return hash.subarray(0, FINGERPRINT_SIZE);
+  }
+}
+
+class NegentropyStorageVector {
+  constructor() {
+    this.items = [];
+    this.sealed = false;
+  }
+  insert(timestamp, id) {
+    if (this.sealed)
+      throw Error("already sealed");
+    id = loadInputBuffer(id);
+    if (id.byteLength !== ID_SIZE)
+      throw Error("bad id size for added item");
+    this.items.push({ timestamp, id });
+  }
+  seal() {
+    if (this.sealed)
+      throw Error("already sealed");
+    this.sealed = true;
+    this.items.sort(itemCompare);
+    for (let i = 1;i < this.items.length; i++) {
+      if (itemCompare(this.items[i - 1], this.items[i]) === 0)
+        throw Error("duplicate item inserted");
+    }
+  }
+  unseal() {
+    this.sealed = false;
+  }
+  size() {
+    this._checkSealed();
+    return this.items.length;
+  }
+  getItem(i) {
+    this._checkSealed();
+    if (i >= this.items.length)
+      throw Error("out of range");
+    return this.items[i];
+  }
+  iterate(begin, end, cb) {
+    this._checkSealed();
+    this._checkBounds(begin, end);
+    for (let i = begin;i < end; ++i) {
+      if (!cb(this.items[i], i))
+        break;
+    }
+  }
+  findLowerBound(begin, end, bound) {
+    this._checkSealed();
+    this._checkBounds(begin, end);
+    return this._binarySearch(this.items, begin, end, (a) => itemCompare(a, bound) < 0);
+  }
+  async fingerprint(begin, end) {
+    let out = new Accumulator;
+    out.setToZero();
+    this.iterate(begin, end, (item, i) => {
+      out.add(item.id);
+      return true;
+    });
+    return await out.getFingerprint(end - begin);
+  }
+  _checkSealed() {
+    if (!this.sealed)
+      throw Error("not sealed");
+  }
+  _checkBounds(begin, end) {
+    if (begin > end || end > this.items.length)
+      throw Error("bad range");
+  }
+  _binarySearch(arr, first, last, cmp) {
+    let count = last - first;
+    while (count > 0) {
+      let it = first;
+      let step = Math.floor(count / 2);
+      it += step;
+      if (cmp(arr[it])) {
+        first = ++it;
+        count -= step + 1;
+      } else {
+        count = step;
+      }
+    }
+    return first;
+  }
+}
+
+class Negentropy {
+  constructor(storage, frameSizeLimit = 0) {
+    if (frameSizeLimit !== 0 && frameSizeLimit < 4096)
+      throw Error("frameSizeLimit too small");
+    this.storage = storage;
+    this.frameSizeLimit = frameSizeLimit;
+    this.lastTimestampIn = 0;
+    this.lastTimestampOut = 0;
+  }
+  _bound(timestamp, id) {
+    return { timestamp, id: id ? id : new Uint8Array(0) };
+  }
+  async initiate() {
+    if (this.isInitiator)
+      throw Error("already initiated");
+    this.isInitiator = true;
+    let output = new WrappedBuffer;
+    output.extend([PROTOCOL_VERSION]);
+    await this.splitRange(0, this.storage.size(), this._bound(Number.MAX_VALUE), output);
+    return this._renderOutput(output);
+  }
+  setInitiator() {
+    this.isInitiator = true;
+  }
+  async reconcile(query) {
+    let haveIds = [], needIds = [];
+    query = new WrappedBuffer(loadInputBuffer(query));
+    this.lastTimestampIn = this.lastTimestampOut = 0;
+    let fullOutput = new WrappedBuffer;
+    fullOutput.extend([PROTOCOL_VERSION]);
+    let protocolVersion = getByte(query);
+    if (protocolVersion < 96 || protocolVersion > 111)
+      throw Error("invalid negentropy protocol version byte");
+    if (protocolVersion !== PROTOCOL_VERSION) {
+      if (this.isInitiator)
+        throw Error("unsupported negentropy protocol version requested: " + (protocolVersion - 96));
+      else
+        return [this._renderOutput(fullOutput), haveIds, needIds];
+    }
+    let storageSize = this.storage.size();
+    let prevBound = this._bound(0);
+    let prevIndex = 0;
+    let skip = false;
+    while (query.length !== 0) {
+      let o = new WrappedBuffer;
+      let doSkip = () => {
+        if (skip) {
+          skip = false;
+          o.extend(this.encodeBound(prevBound));
+          o.extend(encodeVarInt(Mode.Skip));
+        }
+      };
+      let currBound = this.decodeBound(query);
+      let mode = decodeVarInt(query);
+      let lower = prevIndex;
+      let upper = this.storage.findLowerBound(prevIndex, storageSize, currBound);
+      if (mode === Mode.Skip) {
+        skip = true;
+      } else if (mode === Mode.Fingerprint) {
+        let theirFingerprint = getBytes(query, FINGERPRINT_SIZE);
+        let ourFingerprint = await this.storage.fingerprint(lower, upper);
+        if (compareUint8Array(theirFingerprint, ourFingerprint) !== 0) {
+          doSkip();
+          await this.splitRange(lower, upper, currBound, o);
+        } else {
+          skip = true;
+        }
+      } else if (mode === Mode.IdList) {
+        let numIds = decodeVarInt(query);
+        let theirElems = {};
+        for (let i = 0;i < numIds; i++) {
+          let e = getBytes(query, ID_SIZE);
+          if (this.isInitiator)
+            theirElems[e] = e;
+        }
+        if (this.isInitiator) {
+          skip = true;
+          this.storage.iterate(lower, upper, (item) => {
+            let k = item.id;
+            if (!theirElems[k]) {
+              if (this.isInitiator)
+                haveIds.push(this.wantUint8ArrayOutput ? k : uint8ArrayToHex(k));
+            } else {
+              delete theirElems[k];
+            }
+            return true;
+          });
+          for (let v of Object.values(theirElems)) {
+            needIds.push(this.wantUint8ArrayOutput ? v : uint8ArrayToHex(v));
+          }
+        } else {
+          doSkip();
+          let responseIds = new WrappedBuffer;
+          let numResponseIds = 0;
+          let endBound = currBound;
+          this.storage.iterate(lower, upper, (item, index) => {
+            if (this.exceededFrameSizeLimit(fullOutput.length + responseIds.length)) {
+              endBound = item;
+              upper = index;
+              return false;
+            }
+            responseIds.extend(item.id);
+            numResponseIds++;
+            return true;
+          });
+          o.extend(this.encodeBound(endBound));
+          o.extend(encodeVarInt(Mode.IdList));
+          o.extend(encodeVarInt(numResponseIds));
+          o.extend(responseIds);
+          fullOutput.extend(o);
+          o = new WrappedBuffer;
+        }
+      } else {
+        throw Error("unexpected mode");
+      }
+      if (this.exceededFrameSizeLimit(fullOutput.length + o.length)) {
+        let remainingFingerprint = await this.storage.fingerprint(upper, storageSize);
+        fullOutput.extend(this.encodeBound(this._bound(Number.MAX_VALUE)));
+        fullOutput.extend(encodeVarInt(Mode.Fingerprint));
+        fullOutput.extend(remainingFingerprint);
+        break;
+      } else {
+        fullOutput.extend(o);
+      }
+      prevIndex = upper;
+      prevBound = currBound;
+    }
+    return [
+      fullOutput.length === 1 && this.isInitiator ? null : this._renderOutput(fullOutput),
+      haveIds,
+      needIds
+    ];
+  }
+  async splitRange(lower, upper, upperBound, o) {
+    let numElems = upper - lower;
+    let buckets = 16;
+    if (numElems < buckets * 2) {
+      o.extend(this.encodeBound(upperBound));
+      o.extend(encodeVarInt(Mode.IdList));
+      o.extend(encodeVarInt(numElems));
+      this.storage.iterate(lower, upper, (item) => {
+        o.extend(item.id);
+        return true;
+      });
+    } else {
+      let itemsPerBucket = Math.floor(numElems / buckets);
+      let bucketsWithExtra = numElems % buckets;
+      let curr = lower;
+      for (let i = 0;i < buckets; i++) {
+        let bucketSize = itemsPerBucket + (i < bucketsWithExtra ? 1 : 0);
+        let ourFingerprint = await this.storage.fingerprint(curr, curr + bucketSize);
+        curr += bucketSize;
+        let nextBound;
+        if (curr === upper) {
+          nextBound = upperBound;
+        } else {
+          let prevItem, currItem;
+          this.storage.iterate(curr - 1, curr + 1, (item, index) => {
+            if (index === curr - 1)
+              prevItem = item;
+            else
+              currItem = item;
+            return true;
+          });
+          nextBound = this.getMinimalBound(prevItem, currItem);
+        }
+        o.extend(this.encodeBound(nextBound));
+        o.extend(encodeVarInt(Mode.Fingerprint));
+        o.extend(ourFingerprint);
+      }
+    }
+  }
+  _renderOutput(o) {
+    o = o.unwrap();
+    if (!this.wantUint8ArrayOutput)
+      o = uint8ArrayToHex(o);
+    return o;
+  }
+  exceededFrameSizeLimit(n) {
+    return this.frameSizeLimit && n > this.frameSizeLimit - 200;
+  }
+  decodeTimestampIn(encoded) {
+    let timestamp = decodeVarInt(encoded);
+    timestamp = timestamp === 0 ? Number.MAX_VALUE : timestamp - 1;
+    if (this.lastTimestampIn === Number.MAX_VALUE || timestamp === Number.MAX_VALUE) {
+      this.lastTimestampIn = Number.MAX_VALUE;
+      return Number.MAX_VALUE;
+    }
+    timestamp += this.lastTimestampIn;
+    this.lastTimestampIn = timestamp;
+    return timestamp;
+  }
+  decodeBound(encoded) {
+    let timestamp = this.decodeTimestampIn(encoded);
+    let len = decodeVarInt(encoded);
+    if (len > ID_SIZE)
+      throw Error("bound key too long");
+    let id = getBytes(encoded, len);
+    return { timestamp, id };
+  }
+  encodeTimestampOut(timestamp) {
+    if (timestamp === Number.MAX_VALUE) {
+      this.lastTimestampOut = Number.MAX_VALUE;
+      return encodeVarInt(0);
+    }
+    let temp = timestamp;
+    timestamp -= this.lastTimestampOut;
+    this.lastTimestampOut = temp;
+    return encodeVarInt(timestamp + 1);
+  }
+  encodeBound(key) {
+    let output = new WrappedBuffer;
+    output.extend(this.encodeTimestampOut(key.timestamp));
+    output.extend(encodeVarInt(key.id.length));
+    output.extend(key.id);
+    return output;
+  }
+  getMinimalBound(prev, curr) {
+    if (curr.timestamp !== prev.timestamp) {
+      return this._bound(curr.timestamp);
+    } else {
+      let sharedPrefixBytes = 0;
+      let currKey = curr.id;
+      let prevKey = prev.id;
+      for (let i = 0;i < ID_SIZE; i++) {
+        if (currKey[i] !== prevKey[i])
+          break;
+        sharedPrefixBytes++;
+      }
+      return this._bound(curr.timestamp, curr.id.subarray(0, sharedPrefixBytes + 1));
+    }
+  }
+}
+function loadInputBuffer(inp) {
+  if (typeof inp === "string")
+    inp = hexToUint8Array(inp);
+  else if (__proto__ !== Uint8Array.prototype)
+    inp = new Uint8Array(inp);
+  return inp;
+}
+function hexToUint8Array(h) {
+  if (h.startsWith("0x"))
+    h = h.substr(2);
+  if (h.length % 2 === 1)
+    throw Error("odd length of hex string");
+  let arr = new Uint8Array(h.length / 2);
+  for (let i = 0;i < arr.length; i++)
+    arr[i] = parseInt(h.substr(i * 2, 2), 16);
+  return arr;
+}
+var uint8ArrayToHexLookupTable = new Array(256);
+{
+  const hexAlphabet = [
+    "0",
+    "1",
+    "2",
+    "3",
+    "4",
+    "5",
+    "6",
+    "7",
+    "8",
+    "9",
+    "a",
+    "b",
+    "c",
+    "d",
+    "e",
+    "f"
+  ];
+  for (let i = 0;i < 256; i++) {
+    uint8ArrayToHexLookupTable[i] = hexAlphabet[i >>> 4 & 15] + hexAlphabet[i & 15];
+  }
+}
+function uint8ArrayToHex(arr) {
+  let out = "";
+  for (let i = 0, edx = arr.length;i < edx; i++) {
+    out += uint8ArrayToHexLookupTable[arr[i]];
+  }
+  return out;
+}
+function compareUint8Array(a, b) {
+  for (let i = 0;i < a.byteLength; i++) {
+    if (a[i] < b[i])
+      return -1;
+    if (a[i] > b[i])
+      return 1;
+  }
+  if (a.byteLength > b.byteLength)
+    return 1;
+  if (a.byteLength < b.byteLength)
+    return -1;
+  return 0;
+}
+function itemCompare(a, b) {
+  if (a.timestamp === b.timestamp) {
+    return compareUint8Array(a.id, b.id);
+  }
+  return a.timestamp - b.timestamp;
+}
+
+// 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* () {
+    const allGiftWraps = yield* storage.getAllGiftWraps();
+    const storageVector = new NegentropyStorageVector;
+    for (const gw of allGiftWraps) {
+      storageVector.insert(gw.createdAt, hexToBytes(gw.id));
+    }
+    storageVector.seal();
+    const neg = new Negentropy(storageVector, 0);
+    const filter = {
+      kinds: [1059],
+      "#p": [publicKey]
+    };
+    const allHaveIds = [];
+    const allNeedIds = [];
+    const subId = `neg-${Date.now()}`;
+    const initialMsg = yield* Effect12.tryPromise({
+      try: () => neg.initiate(),
+      catch: (e) => new SyncError({
+        message: `Negentropy initiate failed: ${e instanceof Error ? e.message : String(e)}`,
+        phase: "negotiate",
+        cause: e
+      })
+    });
+    let currentMsg = initialMsg;
+    while (currentMsg !== null) {
+      const response = yield* relay.sendNegMsg(relayUrl, subId, filter, currentMsg);
+      if (response.msgHex === null)
+        break;
+      const reconcileResult = yield* Effect12.tryPromise({
+        try: () => neg.reconcile(response.msgHex),
+        catch: (e) => new SyncError({
+          message: `Negentropy reconcile failed: ${e instanceof Error ? e.message : String(e)}`,
+          phase: "negotiate",
+          cause: e
+        })
+      });
+      const [nextMsg, haveIds, needIds] = reconcileResult;
+      for (const id of haveIds)
+        allHaveIds.push(id);
+      for (const id of needIds)
+        allNeedIds.push(id);
+      currentMsg = nextMsg;
+    }
+    return { haveIds: allHaveIds, needIds: allNeedIds };
+  });
+}
+
+// src/sync/sync-service.ts
+function createSyncHandle(storage, giftWrapHandle, relay, publishQueue, syncStatus, watchCtx, relayUrls, publicKey, onSyncError) {
+  const processGiftWrap = (remoteGw) => Effect13.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")
+      return null;
+    const rumor = unwrapResult.success;
+    const dTag = rumor.tags.find((t) => t[0] === "d")?.[1];
+    if (!dTag)
+      return null;
+    const colonIdx = dTag.indexOf(":");
+    if (colonIdx === -1)
+      return null;
+    const collectionName = dTag.substring(0, colonIdx);
+    const recordId = dTag.substring(colonIdx + 1);
+    let data = null;
+    let kind = "update";
+    try {
+      const parsed = JSON.parse(rumor.content);
+      if (parsed === null || parsed._deleted) {
+        kind = "delete";
+      } else {
+        data = parsed;
+      }
+    } catch {
+      return null;
+    }
+    const event = {
+      id: rumor.id,
+      collection: collectionName,
+      recordId,
+      kind,
+      data,
+      createdAt: rumor.created_at * 1000
+    };
+    yield* storage.putEvent(event);
+    yield* applyEvent(storage, event);
+    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);
+      }
+    }),
+    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);
+        }
+      }
+    })
+  };
+}
+
+// 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"
+      });
+    }
+    const schemaEntries = Object.entries(config.schema);
+    if (schemaEntries.length === 0) {
+      return yield* new ValidationError({
+        message: "Schema must contain at least one collection"
+      });
+    }
+    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 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");
+          }
+        });
+        yield* Effect14.forkDetach(publishEffect);
+      } else {
+        const err = wrapResult.failure;
+        console.error("[tablinum:onWrite] wrap failed:", err);
+        if (config.onSyncError)
+          config.onSyncError(err);
+      }
+    });
+    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 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" });
+        }
+        yield* rebuild(storage, schemaEntries.map(([, def]) => def.name));
+      }),
+      sync: () => Effect14.gen(function* () {
+        const closed = yield* Ref5.get(closedRef);
+        if (closed) {
+          return yield* new SyncError({ message: "Database is closed", phase: "init" });
+        }
+        yield* syncHandle.sync();
+      }),
+      getSyncStatus: () => syncStatus.get()
+    };
+    return dbHandle;
+  });
+}
+
+// src/svelte/database.svelte.ts
+import { Effect as Effect18, Scope as Scope3, Exit } from "effect";
+
+// src/svelte/collection.svelte.ts
+import { Effect as Effect17, Fiber as Fiber2, Stream as Stream5 } from "effect";
+
+// src/svelte/query.svelte.ts
+import { Effect as Effect16 } from "effect";
+
+// src/svelte/live-query.svelte.ts
+import { Effect as Effect15, Fiber, Stream as Stream4 } from "effect";
+
+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/svelte/query.svelte.ts
+function wrapQueryBuilder(builder, onLive) {
+  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;
+    }
+  };
+}
+function wrapWhereClause(clause, onLive) {
+  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)
+  };
+}
+function wrapOrderByBuilder(builder, onLive) {
+  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;
+    }
+  };
+}
+
+// src/svelte/collection.svelte.ts
+class Collection {
+  items = $state([]);
+  error = $state(null);
+  #handle;
+  #watchFiber = null;
+  #liveQueries = new Set;
+  constructor(handle) {
+    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);
+  }
+  #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;
+    }
+  };
+  #onLive = (lq) => {
+    this.#liveQueries.add(lq);
+  };
+  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);
+  };
+  orderBy = (field) => {
+    return wrapOrderByBuilder(this.#handle.orderBy(field), this.#onLive);
+  };
+  _destroy() {
+    if (this.#watchFiber) {
+      Effect17.runFork(Fiber2.interrupt(this.#watchFiber));
+      this.#watchFiber = null;
+    }
+    for (const lq of this.#liveQueries) {
+      lq.destroy();
+    }
+    this.#liveQueries.clear();
+  }
+}
+
+// src/svelte/database.svelte.ts
+class Database {
+  status = $state("idle");
+  error = $state(null);
+  #handle;
+  #scope;
+  #collections = new Map;
+  #statusInterval = 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);
+  }
+  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);
+    }
+    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();
+    }
+    this.#collections.clear();
+    await Effect18.runPromise(this.#handle.close());
+    await Effect18.runPromise(Scope3.close(this.#scope, Exit.void));
+  };
+  sync = async () => {
+    try {
+      this.error = null;
+      await Effect18.runPromise(this.#handle.sync());
+    } catch (e) {
+      this.error = e instanceof Error ? e : new Error(String(e));
+      throw this.error;
+    }
+  };
+  rebuild = async () => {
+    try {
+      this.error = null;
+      await Effect18.runPromise(this.#handle.rebuild());
+    } catch (e) {
+      this.error = e instanceof Error ? e : new Error(String(e));
+      throw this.error;
+    }
+  };
+}
+
+// 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/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;
+  }
+}
+export {
+  field,
+  createTablinum2 as createTablinum,
+  collection,
+  ValidationError,
+  SyncError,
+  StorageError,
+  RelayError,
+  NotFoundError,
+  LiveQuery,
+  Database,
+  CryptoError,
+  Collection,
+  ClosedError
+};