tablinum 0.0.1

package/src/crud/query-builder.ts

@@ -0,0 +1,414 @@
+import { Effect, Ref, Stream } from "effect";
+import type { IDBStorageHandle } from "../storage/idb.ts";
+import type { StorageError, ValidationError } from "../errors.ts";
+import { ValidationError as VE } from "../errors.ts";
+import type { CollectionDef, CollectionFields } from "../schema/collection.ts";
+import type { WatchContext } from "./watch.ts";
+
+// ---------------------------------------------------------------------------
+// Query plan (internal)
+// ---------------------------------------------------------------------------
+
+interface QueryPlan {
+  readonly fieldName?: string | undefined;
+  readonly filters: Array<(record: Record<string, unknown>) => boolean>;
+  readonly orderBy?: { field: string; direction: "asc" | "desc" } | undefined;
+  readonly offset?: number | undefined;
+  readonly limit?: number | undefined;
+  readonly indexQuery?:
+    | { field: string; range: IDBKeyRange | IDBValidKey; type: "value" | "range" }
+    | undefined;
+}
+
+function emptyPlan(): QueryPlan {
+  return { filters: [] };
+}
+
+// ---------------------------------------------------------------------------
+// Query context (shared deps for execution)
+// ---------------------------------------------------------------------------
+
+interface QueryContext {
+  readonly storage: IDBStorageHandle;
+  readonly watchCtx: WatchContext;
+  readonly collectionName: string;
+  readonly def: CollectionDef<CollectionFields>;
+  readonly mapRecord: (record: Record<string, unknown>) => unknown;
+}
+
+// ---------------------------------------------------------------------------
+// Execution
+// ---------------------------------------------------------------------------
+
+function executeQuery<T>(
+  ctx: QueryContext,
+  plan: QueryPlan,
+): Effect.Effect<ReadonlyArray<T>, StorageError | ValidationError> {
+  return Effect.gen(function* () {
+    // Validate field references
+    if (plan.fieldName) {
+      const fieldDef = ctx.def.fields[plan.fieldName];
+      if (!fieldDef) {
+        return yield* new VE({
+          message: `Unknown field "${plan.fieldName}" in collection "${ctx.collectionName}"`,
+          field: plan.fieldName,
+        });
+      }
+      if (fieldDef.kind === "json" || fieldDef.isArray) {
+        return yield* new VE({
+          message: `Field "${plan.fieldName}" does not support filtering (type: ${fieldDef.kind}${fieldDef.isArray ? "[]" : ""})`,
+          field: plan.fieldName,
+        });
+      }
+    }
+
+    // Fetch records — use index if available
+    let results: Record<string, unknown>[];
+    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 as IDBValidKey,
+          )),
+        ];
+      } else {
+        results = [
+          ...(yield* ctx.storage.getByIndexRange(
+            ctx.collectionName,
+            plan.indexQuery.field,
+            plan.indexQuery.range as IDBKeyRange,
+          )),
+        ];
+      }
+    } else if (
+      plan.orderBy &&
+      ctx.def.indices.includes(plan.orderBy.field) &&
+      plan.filters.length === 0
+    ) {
+      // Use index for sorting when no filters need to be applied
+      results = [
+        ...(yield* ctx.storage.getAllSorted(
+          ctx.collectionName,
+          plan.orderBy.field,
+          plan.orderBy.direction === "desc" ? "prev" : "next",
+        )),
+      ];
+    } else {
+      results = [...(yield* ctx.storage.getAllRecords(ctx.collectionName))];
+    }
+
+    // Filter deleted records
+    results = results.filter((r) => !r._deleted);
+
+    // Apply filter predicates
+    for (const f of plan.filters) {
+      results = results.filter(f);
+    }
+
+    // Sort (if not already sorted by IDB)
+    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] as string | number | boolean;
+          const vb = b[field] as string | number | boolean;
+          const cmp = va < vb ? -1 : va > vb ? 1 : 0;
+          return direction === "desc" ? -cmp : cmp;
+        });
+      }
+    }
+
+    // Offset
+    if (plan.offset) {
+      results = results.slice(plan.offset);
+    }
+
+    // Limit
+    if (plan.limit !== null && plan.limit !== undefined) {
+      results = results.slice(0, plan.limit);
+    }
+
+    // Map to user-facing type
+    return results.map(ctx.mapRecord) as ReadonlyArray<T>;
+  });
+}
+
+function watchQuery<T>(
+  ctx: QueryContext,
+  plan: QueryPlan,
+): Stream.Stream<ReadonlyArray<T>, StorageError | ValidationError> {
+  const query = () => executeQuery<T>(ctx, plan);
+
+  const changes = Stream.fromPubSub(ctx.watchCtx.pubsub).pipe(
+    Stream.filter((event) => event.collection === ctx.collectionName),
+    Stream.mapEffect(() =>
+      Effect.gen(function* () {
+        const replaying = yield* Ref.get(ctx.watchCtx.replayingRef);
+        if (replaying) return undefined;
+        return yield* query();
+      }),
+    ),
+    Stream.filter((result): result is ReadonlyArray<T> => result !== undefined),
+  );
+
+  return Stream.unwrap(
+    Effect.gen(function* () {
+      const initial = yield* query();
+      return Stream.concat(Stream.make(initial), changes);
+    }),
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Public interfaces
+// ---------------------------------------------------------------------------
+
+export interface WhereClause<T> {
+  readonly equals: (value: string | number | boolean) => QueryBuilder<T>;
+  readonly above: (value: number) => QueryBuilder<T>;
+  readonly aboveOrEqual: (value: number) => QueryBuilder<T>;
+  readonly below: (value: number) => QueryBuilder<T>;
+  readonly belowOrEqual: (value: number) => QueryBuilder<T>;
+  readonly between: (
+    lower: number,
+    upper: number,
+    options?: { includeLower?: boolean; includeUpper?: boolean },
+  ) => QueryBuilder<T>;
+  readonly startsWith: (prefix: string) => QueryBuilder<T>;
+  readonly anyOf: (values: ReadonlyArray<string | number | boolean>) => QueryBuilder<T>;
+  readonly noneOf: (values: ReadonlyArray<string | number | boolean>) => QueryBuilder<T>;
+}
+
+export interface QueryBuilder<T> {
+  readonly and: (fn: (item: T) => boolean) => QueryBuilder<T>;
+  readonly sortBy: (field: string) => QueryBuilder<T>;
+  readonly reverse: () => QueryBuilder<T>;
+  readonly offset: (n: number) => QueryBuilder<T>;
+  readonly limit: (n: number) => QueryBuilder<T>;
+  readonly get: () => Effect.Effect<ReadonlyArray<T>, StorageError | ValidationError>;
+  readonly first: () => Effect.Effect<T | null, StorageError | ValidationError>;
+  readonly count: () => Effect.Effect<number, StorageError | ValidationError>;
+  readonly watch: () => Stream.Stream<ReadonlyArray<T>, StorageError | ValidationError>;
+}
+
+export interface OrderByBuilder<T> {
+  readonly reverse: () => OrderByBuilder<T>;
+  readonly offset: (n: number) => OrderByBuilder<T>;
+  readonly limit: (n: number) => OrderByBuilder<T>;
+  readonly get: () => Effect.Effect<ReadonlyArray<T>, StorageError | ValidationError>;
+  readonly first: () => Effect.Effect<T | null, StorageError | ValidationError>;
+  readonly count: () => Effect.Effect<number, StorageError | ValidationError>;
+  readonly watch: () => Stream.Stream<ReadonlyArray<T>, StorageError | ValidationError>;
+}
+
+// Keep for backwards compat
+export type QueryExecutor<T> = QueryBuilder<T>;
+
+// ---------------------------------------------------------------------------
+// Builders
+// ---------------------------------------------------------------------------
+
+function makeQueryBuilder<T>(ctx: QueryContext, plan: QueryPlan): QueryBuilder<T> {
+  return {
+    and: (fn) =>
+      makeQueryBuilder(ctx, {
+        ...plan,
+        filters: [...plan.filters, (r) => fn(ctx.mapRecord(r) as T)],
+      }),
+    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<T>(ctx, plan),
+    first: () =>
+      Effect.gen(function* () {
+        const limitedPlan = { ...plan, limit: 1 };
+        const results = yield* executeQuery<T>(ctx, limitedPlan);
+        return results[0] ?? null;
+      }),
+    count: () =>
+      Effect.gen(function* () {
+        const results = yield* executeQuery<T>(ctx, plan);
+        return results.length;
+      }),
+    watch: () => watchQuery<T>(ctx, plan),
+  };
+}
+
+function makeOrderByBuilder<T>(ctx: QueryContext, plan: QueryPlan): OrderByBuilder<T> {
+  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<T>(ctx, plan),
+    first: () =>
+      Effect.gen(function* () {
+        const limitedPlan = { ...plan, limit: 1 };
+        const results = yield* executeQuery<T>(ctx, limitedPlan);
+        return results[0] ?? null;
+      }),
+    count: () =>
+      Effect.gen(function* () {
+        const results = yield* executeQuery<T>(ctx, plan);
+        return results.length;
+      }),
+    watch: () => watchQuery<T>(ctx, plan),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Factory functions (called by CollectionHandle)
+// ---------------------------------------------------------------------------
+
+export function createWhereClause<T>(
+  storage: IDBStorageHandle,
+  watchCtx: WatchContext,
+  collectionName: string,
+  def: CollectionDef<CollectionFields>,
+  fieldName: string,
+  mapRecord: (record: Record<string, unknown>) => T,
+): WhereClause<T> {
+  const ctx: QueryContext = { storage, watchCtx, collectionName, def, mapRecord };
+  const fieldDef = def.fields[fieldName];
+  // IDB only supports string/number/Date/Array keys — not booleans
+  const isIndexed =
+    def.indices.includes(fieldName) &&
+    fieldDef !== null &&
+    fieldDef !== undefined &&
+    fieldDef.kind !== "boolean";
+
+  const withFilter = (
+    filterFn: (record: Record<string, unknown>) => boolean,
+    indexQuery?: QueryPlan["indexQuery"],
+  ): QueryBuilder<T> => {
+    const plan: QueryPlan = {
+      ...emptyPlan(),
+      fieldName,
+      filters: [filterFn],
+      indexQuery,
+    };
+    return makeQueryBuilder(ctx, plan);
+  };
+
+  return {
+    equals: (value) =>
+      withFilter(
+        (r) => r[fieldName] === value,
+        isIndexed ? { field: fieldName, range: value as IDBValidKey, type: "value" } : undefined,
+      ),
+
+    above: (value) =>
+      withFilter(
+        (r) => (r[fieldName] as number) > value,
+        isIndexed
+          ? { field: fieldName, range: IDBKeyRange.lowerBound(value, true), type: "range" }
+          : undefined,
+      ),
+
+    aboveOrEqual: (value) =>
+      withFilter(
+        (r) => (r[fieldName] as number) >= value,
+        isIndexed
+          ? { field: fieldName, range: IDBKeyRange.lowerBound(value, false), type: "range" }
+          : undefined,
+      ),
+
+    below: (value) =>
+      withFilter(
+        (r) => (r[fieldName] as number) < value,
+        isIndexed
+          ? { field: fieldName, range: IDBKeyRange.upperBound(value, true), type: "range" }
+          : undefined,
+      ),
+
+    belowOrEqual: (value) =>
+      withFilter(
+        (r) => (r[fieldName] as number) <= 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] as number;
+          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] as string).startsWith(prefix),
+        isIndexed
+          ? {
+              field: fieldName,
+              range: IDBKeyRange.bound(prefix, prefix + "\uffff", false, false),
+              type: "range",
+            }
+          : undefined,
+      ),
+
+    anyOf: (values) => {
+      const set = new Set(values);
+      return withFilter((r) => set.has(r[fieldName] as string | number | boolean));
+    },
+
+    noneOf: (values) => {
+      const set = new Set(values);
+      return withFilter((r) => !set.has(r[fieldName] as string | number | boolean));
+    },
+  };
+}
+
+export function createOrderByBuilder<T>(
+  storage: IDBStorageHandle,
+  watchCtx: WatchContext,
+  collectionName: string,
+  def: CollectionDef<CollectionFields>,
+  fieldName: string,
+  mapRecord: (record: Record<string, unknown>) => T,
+): OrderByBuilder<T> {
+  const ctx: QueryContext = { storage, watchCtx, collectionName, def, mapRecord };
+  const plan: QueryPlan = {
+    ...emptyPlan(),
+    orderBy: { field: fieldName, direction: "asc" },
+  };
+  return makeOrderByBuilder(ctx, plan);
+}

package/src/crud/watch.ts

@@ -0,0 +1,78 @@
+import { Effect, PubSub, Ref, Stream } from "effect";
+import type { IDBStorageHandle } from "../storage/idb.ts";
+import type { StorageError } from "../errors.ts";
+
+export interface ChangeEvent {
+  readonly collection: string;
+  readonly recordId: string;
+  readonly kind: "create" | "update" | "delete";
+}
+
+export interface WatchContext {
+  readonly pubsub: PubSub.PubSub<ChangeEvent>;
+  readonly replayingRef: Ref.Ref<boolean>;
+}
+
+/**
+ * Create a reactive Stream that emits the current result set whenever it changes.
+ */
+export function watchCollection<T>(
+  ctx: WatchContext,
+  storage: IDBStorageHandle,
+  collectionName: string,
+  filter?: (record: Record<string, unknown>) => boolean,
+  mapRecord?: (record: Record<string, unknown>) => T,
+): Stream.Stream<ReadonlyArray<T>, StorageError> {
+  const query = (): Effect.Effect<ReadonlyArray<T>, StorageError> =>
+    Effect.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 as unknown as ReadonlyArray<T>);
+    });
+
+  const changes = Stream.fromPubSub(ctx.pubsub).pipe(
+    Stream.filter((event) => event.collection === collectionName),
+    Stream.mapEffect(() =>
+      Effect.gen(function* () {
+        const replaying = yield* Ref.get(ctx.replayingRef);
+        if (replaying) return undefined;
+        return yield* query();
+      }),
+    ),
+    Stream.filter((result): result is ReadonlyArray<T> => result !== undefined),
+  );
+
+  return Stream.unwrap(
+    Effect.gen(function* () {
+      const initial = yield* query();
+      return Stream.concat(Stream.make(initial), changes);
+    }),
+  );
+}
+
+/**
+ * Notify subscribers of a change.
+ */
+export function notifyChange(ctx: WatchContext, event: ChangeEvent): Effect.Effect<void> {
+  return PubSub.publish(ctx.pubsub, event).pipe(Effect.asVoid);
+}
+
+/**
+ * Emit a replay-complete notification for all collections that changed.
+ * Call after sync replay to trigger batched watch updates.
+ */
+export function notifyReplayComplete(
+  ctx: WatchContext,
+  collections: ReadonlyArray<string>,
+): Effect.Effect<void> {
+  return Effect.gen(function* () {
+    yield* Ref.set(ctx.replayingRef, false);
+    for (const collection of collections) {
+      yield* notifyChange(ctx, {
+        collection,
+        recordId: "",
+        kind: "update",
+      });
+    }
+  });
+}

package/src/db/create-localstr.ts

@@ -0,0 +1,217 @@
+import { Effect, PubSub, Ref, Scope } from "effect";
+import type { CollectionFields } from "../schema/collection.ts";
+import type { CollectionDef } from "../schema/collection.ts";
+import type { SchemaConfig } from "../schema/types.ts";
+import { buildValidator, buildPartialValidator } from "../schema/validate.ts";
+import { openIDBStorage } from "../storage/idb.ts";
+import { rebuild as rebuildRecords } from "../storage/records-store.ts";
+import {
+  createCollectionHandle,
+  type CollectionHandle,
+  type OnWriteCallback,
+} from "../crud/collection-handle.ts";
+import type { ChangeEvent } from "../crud/watch.ts";
+import { createIdentity } from "./identity.ts";
+import type { DatabaseHandle } from "./database-handle.ts";
+import { createGiftWrapHandle } from "../sync/gift-wrap.ts";
+import { createRelayHandle } from "../sync/relay.ts";
+import { createPublishQueue } from "../sync/publish-queue.ts";
+import { createSyncStatusHandle } from "../sync/sync-status.ts";
+import { createSyncHandle } from "../sync/sync-service.ts";
+import { CryptoError, StorageError, SyncError, ValidationError } from "../errors.ts";
+import { uuidv7 } from "../utils/uuid.ts";
+
+export interface LocalstrConfig<S extends SchemaConfig> {
+  readonly schema: S;
+  readonly relays: readonly string[];
+  readonly privateKey?: Uint8Array | undefined;
+  readonly dbName?: string | undefined;
+  readonly onSyncError?: ((error: Error) => void) | undefined;
+}
+
+export function createLocalstr<S extends SchemaConfig>(
+  config: LocalstrConfig<S>,
+): Effect.Effect<DatabaseHandle<S>, ValidationError | StorageError | CryptoError, Scope.Scope> {
+  return Effect.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",
+      });
+    }
+
+    // Resolve private key: supplied > persisted > generate new
+    let resolvedKey = config.privateKey;
+    const storageKeyName = `localstr-key-${config.dbName ?? "localstr"}`;
+    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);
+
+    // Persist the key for next session
+    if (typeof globalThis.localStorage !== "undefined") {
+      globalThis.localStorage.setItem(storageKeyName, identity.exportKey());
+    }
+
+    const storage = yield* openIDBStorage(config.dbName, config.schema);
+
+    // Watch infrastructure
+    const pubsub = yield* PubSub.unbounded<ChangeEvent>();
+    const replayingRef = yield* Ref.make(false);
+    const watchCtx = { pubsub, replayingRef };
+    const closedRef = yield* Ref.make(false);
+
+    // Sync infrastructure
+    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,
+    );
+
+    // On local write: create gift wrap and publish asynchronously
+    const onWrite: OnWriteCallback = (event) =>
+      Effect.gen(function* () {
+        console.log("[localstr: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* Effect.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(
+            "[localstr:onWrite] gift wrap created:",
+            gw.id,
+            "kind:",
+            gw.kind,
+            "tags:",
+            JSON.stringify(gw.tags),
+          );
+          yield* storage.putGiftWrap({
+            id: gw.id,
+            event: gw as unknown as Record<string, unknown>,
+            createdAt: gw.created_at,
+          });
+          console.log("[localstr:onWrite] gift wrap stored, publishing...");
+          const publishEffect = Effect.gen(function* () {
+            const pubResult = yield* Effect.result(
+              syncHandle.publishLocal({
+                id: gw.id,
+                event: gw as unknown as Record<string, unknown>,
+                createdAt: gw.created_at,
+              }),
+            );
+            if (pubResult._tag === "Failure") {
+              const err = pubResult.failure;
+              console.error("[localstr:publish] failed:", err);
+              if (config.onSyncError) config.onSyncError(err);
+            } else {
+              console.log("[localstr:publish] success");
+            }
+          });
+          yield* Effect.forkDetach(publishEffect);
+        } else {
+          const err = wrapResult.failure;
+          console.error("[localstr:onWrite] wrap failed:", err);
+          if (config.onSyncError) config.onSyncError(err);
+        }
+      });
+
+    // Build collection handles
+    const handles = new Map<string, CollectionHandle<CollectionDef<CollectionFields>>>();
+
+    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 as CollectionHandle<CollectionDef<CollectionFields>>);
+    }
+
+    // Start real-time subscription to incoming gift wraps
+    yield* syncHandle.startSubscription();
+
+    const dbHandle: DatabaseHandle<S> = {
+      collection: <K extends string & keyof S>(name: K) => {
+        const handle = handles.get(name);
+        if (!handle) {
+          throw new Error(`Collection "${name}" not found in schema`);
+        }
+        return handle as unknown as CollectionHandle<S[K]>;
+      },
+
+      exportKey: () => identity.exportKey(),
+
+      close: () =>
+        Effect.gen(function* () {
+          yield* Ref.set(closedRef, true);
+          yield* relayHandle.closeAll();
+          yield* storage.close();
+        }),
+
+      rebuild: () =>
+        Effect.gen(function* () {
+          const closed = yield* Ref.get(closedRef);
+          if (closed) {
+            return yield* new StorageError({ message: "Database is closed" });
+          }
+          yield* rebuildRecords(
+            storage,
+            schemaEntries.map(([, def]) => def.name),
+          );
+        }),
+
+      sync: () =>
+        Effect.gen(function* () {
+          const closed = yield* Ref.get(closedRef);
+          if (closed) {
+            return yield* new SyncError({ message: "Database is closed", phase: "init" });
+          }
+          yield* syncHandle.sync();
+        }),
+
+      getSyncStatus: () => syncStatus.get(),
+    };
+
+    return dbHandle;
+  });
+}