tablinum 0.0.1 → 0.1.1

package/src/storage/idb.ts

@@ -1,244 +0,0 @@
-import { Effect, Scope } from "effect";
-import { openDB, type IDBPDatabase } from "idb";
-import { StorageError } from "../errors.ts";
-import type { SchemaConfig } from "../schema/types.ts";
-
-export interface StoredEvent {
-  readonly id: string;
-  readonly collection: string;
-  readonly recordId: string;
-  readonly kind: "create" | "update" | "delete";
-  readonly data: Record<string, unknown> | null;
-  readonly createdAt: number;
-}
-
-export interface StoredGiftWrap {
-  readonly id: string;
-  readonly event: Record<string, unknown>;
-  readonly createdAt: number;
-}
-
-export interface IDBStorageHandle {
-  // Records — per-collection stores with flat shape
-  readonly putRecord: (
-    collection: string,
-    record: Record<string, unknown>,
-  ) => Effect.Effect<void, StorageError>;
-  readonly getRecord: (
-    collection: string,
-    id: string,
-  ) => Effect.Effect<Record<string, unknown> | undefined, StorageError>;
-  readonly getAllRecords: (
-    collection: string,
-  ) => Effect.Effect<ReadonlyArray<Record<string, unknown>>, StorageError>;
-  readonly countRecords: (collection: string) => Effect.Effect<number, StorageError>;
-  readonly clearRecords: (collection: string) => Effect.Effect<void, StorageError>;
-
-  // Index-based queries
-  readonly getByIndex: (
-    collection: string,
-    indexName: string,
-    value: IDBValidKey,
-  ) => Effect.Effect<ReadonlyArray<Record<string, unknown>>, StorageError>;
-  readonly getByIndexRange: (
-    collection: string,
-    indexName: string,
-    range: IDBKeyRange,
-  ) => Effect.Effect<ReadonlyArray<Record<string, unknown>>, StorageError>;
-  readonly getAllSorted: (
-    collection: string,
-    indexName: string,
-    direction?: "next" | "prev",
-  ) => Effect.Effect<ReadonlyArray<Record<string, unknown>>, StorageError>;
-
-  // Events
-  readonly putEvent: (event: StoredEvent) => Effect.Effect<void, StorageError>;
-  readonly getEvent: (id: string) => Effect.Effect<StoredEvent | undefined, StorageError>;
-  readonly getAllEvents: () => Effect.Effect<ReadonlyArray<StoredEvent>, StorageError>;
-  readonly getEventsByRecord: (
-    collection: string,
-    recordId: string,
-  ) => Effect.Effect<ReadonlyArray<StoredEvent>, StorageError>;
-
-  // Gift wraps
-  readonly putGiftWrap: (gw: StoredGiftWrap) => Effect.Effect<void, StorageError>;
-  readonly getGiftWrap: (id: string) => Effect.Effect<StoredGiftWrap | undefined, StorageError>;
-  readonly getAllGiftWraps: () => Effect.Effect<ReadonlyArray<StoredGiftWrap>, StorageError>;
-
-  readonly close: () => Effect.Effect<void>;
-}
-
-const DB_NAME = "localstr";
-
-function storeName(collection: string): string {
-  return `col_${collection}`;
-}
-
-function schemaVersion(schema: SchemaConfig): number {
-  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<T>(label: string, fn: () => Promise<T>): Effect.Effect<T, StorageError> {
-  return Effect.tryPromise({
-    try: fn,
-    catch: (e) =>
-      new StorageError({
-        message: `IndexedDB ${label} failed: ${e instanceof Error ? e.message : String(e)}`,
-        cause: e,
-      }),
-  });
-}
-
-export function openIDBStorage(
-  dbName: string | undefined,
-  schema: SchemaConfig,
-): Effect.Effect<IDBStorageHandle, StorageError, Scope.Scope> {
-  return Effect.gen(function* () {
-    const name = dbName ?? DB_NAME;
-    const version = schemaVersion(schema);
-
-    const db: IDBPDatabase = yield* Effect.tryPromise({
-      try: () =>
-        openDB(name, version, {
-          upgrade(database) {
-            // Create events store if missing
-            if (!database.objectStoreNames.contains("events")) {
-              const events = database.createObjectStore("events", {
-                keyPath: "id",
-              });
-              events.createIndex("by-record", ["collection", "recordId"]);
-            }
-
-            // Create giftwraps store if missing
-            if (!database.objectStoreNames.contains("giftwraps")) {
-              database.createObjectStore("giftwraps", {
-                keyPath: "id",
-              });
-            }
-
-            // Remove old shared records store if it exists
-            if (database.objectStoreNames.contains("records")) {
-              database.deleteObjectStore("records");
-            }
-
-            // Determine which collection stores should exist
-            const expectedStores = new Set<string>();
-            for (const [, def] of Object.entries(schema)) {
-              const sn = storeName(def.name);
-              expectedStores.add(sn);
-
-              if (!database.objectStoreNames.contains(sn)) {
-                // Create new collection store
-                const store = database.createObjectStore(sn, { keyPath: "id" });
-                for (const idx of def.indices ?? []) {
-                  store.createIndex(idx, idx);
-                }
-              } else {
-                // Update indices on existing store
-                const tx = (database as any).transaction;
-                // During upgrade, we can access stores via transaction
-                // The idb library handles this through the upgrade callback
-                const store = (tx as IDBTransaction).objectStore(sn);
-                const existingIndices = new Set(Array.from(store.indexNames));
-                const wantedIndices = new Set(def.indices ?? []);
-
-                // Remove stale indices
-                for (const idx of existingIndices) {
-                  if (!wantedIndices.has(idx)) {
-                    store.deleteIndex(idx);
-                  }
-                }
-                // Add new indices
-                for (const idx of wantedIndices) {
-                  if (!existingIndices.has(idx as string)) {
-                    store.createIndex(idx as string, idx as string);
-                  }
-                }
-              }
-            }
-
-            // Remove collection stores no longer in schema
-            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* Effect.addFinalizer(() => Effect.sync(() => db.close()));
-
-    const handle: IDBStorageHandle = {
-      putRecord: (collection, record) =>
-        wrap("putRecord", () => db.put(storeName(collection), record).then(() => undefined)),
-
-      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: Record<string, unknown>[] = [];
-          let cursor = await index.openCursor(null, direction ?? "next");
-          while (cursor) {
-            results.push(cursor.value as Record<string, unknown>);
-            cursor = await cursor.continue();
-          }
-          return results;
-        }),
-
-      putEvent: (event) => wrap("putEvent", () => db.put("events", event).then(() => undefined)),
-
-      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(() => undefined)),
-
-      getGiftWrap: (id) => wrap("getGiftWrap", () => db.get("giftwraps", id)),
-
-      getAllGiftWraps: () => wrap("getAllGiftWraps", () => db.getAll("giftwraps")),
-
-      close: () => Effect.sync(() => db.close()),
-    };
-
-    return handle;
-  });
-}

package/src/storage/lww.ts

@@ -1,17 +0,0 @@
-export interface EventMeta {
-  readonly id: string;
-  readonly createdAt: number;
-}
-
-/**
- * Last-write-wins resolution.
- * Higher `createdAt` wins. Ties broken by lowest event ID (lexicographic).
- * Returns the winner.
- */
-export function resolveWinner<T extends EventMeta>(existing: T | null, incoming: T): T {
-  if (existing === null) return incoming;
-  if (incoming.createdAt > existing.createdAt) return incoming;
-  if (incoming.createdAt < existing.createdAt) return existing;
-  // Tie: lowest event ID wins
-  return incoming.id < existing.id ? incoming : existing;
-}

package/src/storage/records-store.ts

@@ -1,76 +0,0 @@
-import { Effect } from "effect";
-import type { IDBStorageHandle, StoredEvent } from "./idb.ts";
-import { resolveWinner } from "./lww.ts";
-import type { StorageError } from "../errors.ts";
-
-/**
- * Build a flat record from an event for storage in per-collection IDB stores.
- */
-function buildRecord(event: StoredEvent): Record<string, unknown> {
-  return {
-    id: event.recordId,
-    _deleted: event.kind === "delete",
-    _updatedAt: event.createdAt,
-    ...(event.data ?? {}),
-  };
-}
-
-/**
- * Apply an event to the records store using LWW resolution.
- * Returns true if the incoming event won and the record was updated.
- */
-export function applyEvent(
-  storage: IDBStorageHandle,
-  event: StoredEvent,
-): Effect.Effect<boolean, StorageError> {
-  return Effect.gen(function* () {
-    const existingEvents = yield* storage.getEventsByRecord(event.collection, event.recordId);
-
-    // Find the current winning event for this record
-    let currentWinner: StoredEvent | null = null;
-    for (const e of existingEvents) {
-      if (e.id === event.id) continue; // Skip the event we're applying
-      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;
-  });
-}
-
-/**
- * Rebuild the records store by clearing it and replaying all events.
- */
-export function rebuild(
-  storage: IDBStorageHandle,
-  collections: ReadonlyArray<string>,
-): Effect.Effect<void, StorageError> {
-  return Effect.gen(function* () {
-    for (const col of collections) {
-      yield* storage.clearRecords(col);
-    }
-    const allEvents = yield* storage.getAllEvents();
-
-    // Sort by createdAt for deterministic replay
-    const sorted = [...allEvents].sort((a, b) => a.createdAt - b.createdAt);
-
-    // Group events by record and resolve each
-    const winners = new Map<string, StoredEvent>();
-    for (const event of sorted) {
-      const key = `${event.collection}:${event.recordId}`;
-      const current = winners.get(key) ?? null;
-      winners.set(key, resolveWinner(current, event));
-    }
-
-    // Write winning records
-    for (const event of winners.values()) {
-      yield* storage.putRecord(event.collection, buildRecord(event));
-    }
-  });
-}

package/src/svelte/collection.svelte.ts

@@ -1,87 +0,0 @@
-import { Effect, Fiber, Stream } from "effect";
-import type { CollectionDef, CollectionFields } from "../schema/collection.ts";
-import type { InferRecord } from "../schema/types.ts";
-import type { CollectionHandle } from "../crud/collection-handle.ts";
-import { LiveQuery } from "./live-query.svelte.ts";
-import {
-  wrapWhereClause,
-  wrapOrderByBuilder,
-  type SvelteWhereClause,
-  type SvelteOrderByBuilder,
-} from "./query.svelte.ts";
-
-export class Collection<C extends CollectionDef<CollectionFields>> {
-  items = $state<ReadonlyArray<InferRecord<C>>>([]);
-  error = $state<Error | null>(null);
-
-  #handle: CollectionHandle<C>;
-  #watchFiber: Fiber.Fiber<void, unknown> | null = null;
-  #liveQueries: Set<LiveQuery<unknown>> = new Set();
-
-  constructor(handle: CollectionHandle<C>) {
-    this.#handle = handle;
-
-    // Auto-watch: subscribe to all records, surface errors to this.error
-    const watchEffect = Stream.runForEach(handle.watch(), (records) =>
-      Effect.sync(() => {
-        this.items = records;
-      }),
-    ).pipe(
-      Effect.catch((e) =>
-        Effect.sync(() => {
-          this.error = e instanceof Error ? e : new Error(String(e));
-        }),
-      ),
-    );
-    this.#watchFiber = Effect.runFork(watchEffect);
-  }
-
-  #run = async <R>(effect: Effect.Effect<R, unknown>): Promise<R> => {
-    try {
-      this.error = null;
-      return await Effect.runPromise(effect);
-    } catch (e) {
-      this.error = e instanceof Error ? e : new Error(String(e));
-      throw this.error;
-    }
-  };
-
-  #onLive = (lq: LiveQuery<unknown>): void => {
-    this.#liveQueries.add(lq);
-  };
-
-  add = (data: Omit<InferRecord<C>, "id">): Promise<string> => this.#run(this.#handle.add(data));
-
-  update = (id: string, data: Partial<Omit<InferRecord<C>, "id">>): Promise<void> =>
-    this.#run(this.#handle.update(id, data));
-
-  delete = (id: string): Promise<void> => this.#run(this.#handle.delete(id));
-
-  get = (id: string): Promise<InferRecord<C>> => this.#run(this.#handle.get(id));
-
-  first = (): Promise<InferRecord<C> | null> => this.#run(this.#handle.first());
-
-  count = (): Promise<number> => this.#run(this.#handle.count());
-
-  where = (field: string & keyof Omit<InferRecord<C>, "id">): SvelteWhereClause<InferRecord<C>> => {
-    return wrapWhereClause(this.#handle.where(field), this.#onLive);
-  };
-
-  orderBy = (
-    field: string & keyof Omit<InferRecord<C>, "id">,
-  ): SvelteOrderByBuilder<InferRecord<C>> => {
-    return wrapOrderByBuilder(this.#handle.orderBy(field), this.#onLive);
-  };
-
-  /** @internal Called by Database.close() */
-  _destroy(): void {
-    if (this.#watchFiber) {
-      Effect.runFork(Fiber.interrupt(this.#watchFiber));
-      this.#watchFiber = null;
-    }
-    for (const lq of this.#liveQueries) {
-      lq.destroy();
-    }
-    this.#liveQueries.clear();
-  }
-}

package/src/svelte/database.svelte.ts

@@ -1,83 +0,0 @@
-import { Effect, Scope, Exit } from "effect";
-import type { SchemaConfig } from "../schema/types.ts";
-import type { CollectionDef, CollectionFields } from "../schema/collection.ts";
-import type { DatabaseHandle, SyncStatus } from "../db/database-handle.ts";
-import { Collection } from "./collection.svelte.ts";
-
-export class Database<S extends SchemaConfig> {
-  status = $state<SyncStatus>("idle");
-  error = $state<Error | null>(null);
-
-  #handle: DatabaseHandle<S>;
-  #scope: Scope.Closeable;
-  #collections = new Map<string, Collection<CollectionDef<CollectionFields>>>();
-  #statusInterval: ReturnType<typeof setInterval> | null = null;
-  #closed = false;
-
-  constructor(handle: DatabaseHandle<S>, scope: Scope.Closeable) {
-    this.#handle = handle;
-    this.#scope = scope;
-
-    // Poll sync status
-    this.#statusInterval = setInterval(() => {
-      if (this.#closed) return;
-      Effect.runPromise(this.#handle.getSyncStatus())
-        .then((s) => {
-          this.status = s;
-        })
-        .catch(() => {
-          /* database may be closed, ignore */
-        });
-    }, 1000);
-  }
-
-  collection<K extends string & keyof S>(name: K): Collection<S[K]> {
-    let col = this.#collections.get(name);
-    if (!col) {
-      const handle = this.#handle.collection(name);
-      col = new Collection(handle) as Collection<CollectionDef<CollectionFields>>;
-      this.#collections.set(name, col);
-    }
-    return col as unknown as Collection<S[K]>;
-  }
-
-  exportKey(): string {
-    return this.#handle.exportKey();
-  }
-
-  close = async (): Promise<void> => {
-    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 Effect.runPromise(this.#handle.close());
-    await Effect.runPromise(Scope.close(this.#scope, Exit.void));
-  };
-
-  sync = async (): Promise<void> => {
-    try {
-      this.error = null;
-      await Effect.runPromise(this.#handle.sync());
-    } catch (e) {
-      this.error = e instanceof Error ? e : new Error(String(e));
-      throw this.error;
-    }
-  };
-
-  rebuild = async (): Promise<void> => {
-    try {
-      this.error = null;
-      await Effect.runPromise(this.#handle.rebuild());
-    } catch (e) {
-      this.error = e instanceof Error ? e : new Error(String(e));
-      throw this.error;
-    }
-  };
-}

package/src/svelte/index.svelte.ts

@@ -1,52 +0,0 @@
-import { Effect, Exit, Scope } from "effect";
-import type { SchemaConfig } from "../schema/types.ts";
-import {
-  createLocalstr as coreCreateLocalstr,
-  type LocalstrConfig,
-} from "../db/create-localstr.ts";
-import { Database } from "./database.svelte.ts";
-
-// Re-export schema utilities (unchanged)
-export { field } from "../schema/field.ts";
-export { collection } from "../schema/collection.ts";
-export type { CollectionDef, CollectionFields } from "../schema/collection.ts";
-export type { FieldDef, FieldKind } from "../schema/field.ts";
-export type { InferRecord, SchemaConfig } from "../schema/types.ts";
-export type { LocalstrConfig } from "../db/create-localstr.ts";
-export type { SyncStatus } from "../db/database-handle.ts";
-
-// Re-export errors
-export {
-  ValidationError,
-  StorageError,
-  CryptoError,
-  RelayError,
-  SyncError,
-  NotFoundError,
-  ClosedError,
-} from "../errors.ts";
-
-// Re-export Svelte classes
-export { Database } from "./database.svelte.ts";
-export { Collection } from "./collection.svelte.ts";
-export { LiveQuery } from "./live-query.svelte.ts";
-export type {
-  SvelteQueryBuilder,
-  SvelteWhereClause,
-  SvelteOrderByBuilder,
-} from "./query.svelte.ts";
-
-export async function createLocalstr<S extends SchemaConfig>(
-  config: LocalstrConfig<S>,
-): Promise<Database<S>> {
-  const scope = Effect.runSync(Scope.make());
-  try {
-    const handle = await Effect.runPromise(
-      coreCreateLocalstr(config).pipe(Effect.provideService(Scope.Scope, scope)),
-    );
-    return new Database(handle, scope) as Database<S>;
-  } catch (e) {
-    await Effect.runPromise(Scope.close(scope, Exit.fail(e)));
-    throw e;
-  }
-}

package/src/svelte/live-query.svelte.ts

@@ -1,29 +0,0 @@
-import { Effect, Fiber, Stream } from "effect";
-
-export class LiveQuery<T> {
-  items = $state<ReadonlyArray<T>>([]);
-  error = $state<Error | null>(null);
-  #fiber: Fiber.Fiber<void, unknown> | null = null;
-
-  constructor(stream: Stream.Stream<ReadonlyArray<T>, unknown>) {
-    const effect = Stream.runForEach(stream, (records) =>
-      Effect.sync(() => {
-        this.items = records;
-      }),
-    ).pipe(
-      Effect.catch((e) =>
-        Effect.sync(() => {
-          this.error = e instanceof Error ? e : new Error(String(e));
-        }),
-      ),
-    );
-    this.#fiber = Effect.runFork(effect);
-  }
-
-  destroy(): void {
-    if (this.#fiber) {
-      Effect.runFork(Fiber.interrupt(this.#fiber));
-      this.#fiber = null;
-    }
-  }
-}

package/src/svelte/query.svelte.ts

@@ -1,101 +0,0 @@
-import { Effect } from "effect";
-import type { WhereClause, QueryBuilder, OrderByBuilder } from "../crud/query-builder.ts";
-import { LiveQuery } from "./live-query.svelte.ts";
-
-export type OnLiveCallback = (lq: LiveQuery<unknown>) => void;
-
-export interface SvelteQueryBuilder<T> {
-  readonly and: (fn: (item: T) => boolean) => SvelteQueryBuilder<T>;
-  readonly sortBy: (field: string) => SvelteQueryBuilder<T>;
-  readonly reverse: () => SvelteQueryBuilder<T>;
-  readonly offset: (n: number) => SvelteQueryBuilder<T>;
-  readonly limit: (n: number) => SvelteQueryBuilder<T>;
-  readonly get: () => Promise<ReadonlyArray<T>>;
-  readonly first: () => Promise<T | null>;
-  readonly count: () => Promise<number>;
-  readonly live: () => LiveQuery<T>;
-}
-
-export interface SvelteWhereClause<T> {
-  readonly equals: (value: string | number | boolean) => SvelteQueryBuilder<T>;
-  readonly above: (value: number) => SvelteQueryBuilder<T>;
-  readonly aboveOrEqual: (value: number) => SvelteQueryBuilder<T>;
-  readonly below: (value: number) => SvelteQueryBuilder<T>;
-  readonly belowOrEqual: (value: number) => SvelteQueryBuilder<T>;
-  readonly between: (
-    lower: number,
-    upper: number,
-    options?: { includeLower?: boolean; includeUpper?: boolean },
-  ) => SvelteQueryBuilder<T>;
-  readonly startsWith: (prefix: string) => SvelteQueryBuilder<T>;
-  readonly anyOf: (values: ReadonlyArray<string | number | boolean>) => SvelteQueryBuilder<T>;
-  readonly noneOf: (values: ReadonlyArray<string | number | boolean>) => SvelteQueryBuilder<T>;
-}
-
-export interface SvelteOrderByBuilder<T> {
-  readonly reverse: () => SvelteOrderByBuilder<T>;
-  readonly offset: (n: number) => SvelteOrderByBuilder<T>;
-  readonly limit: (n: number) => SvelteOrderByBuilder<T>;
-  readonly get: () => Promise<ReadonlyArray<T>>;
-  readonly first: () => Promise<T | null>;
-  readonly count: () => Promise<number>;
-  readonly live: () => LiveQuery<T>;
-}
-
-function wrapQueryBuilder<T>(
-  builder: QueryBuilder<T>,
-  onLive?: OnLiveCallback,
-): SvelteQueryBuilder<T> {
-  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: () => Effect.runPromise(builder.get()),
-    first: () => Effect.runPromise(builder.first()),
-    count: () => Effect.runPromise(builder.count()),
-    live: () => {
-      const lq = new LiveQuery(builder.watch());
-      onLive?.(lq as LiveQuery<unknown>);
-      return lq;
-    },
-  };
-}
-
-export function wrapWhereClause<T>(
-  clause: WhereClause<T>,
-  onLive?: OnLiveCallback,
-): SvelteWhereClause<T> {
-  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),
-  };
-}
-
-export function wrapOrderByBuilder<T>(
-  builder: OrderByBuilder<T>,
-  onLive?: OnLiveCallback,
-): SvelteOrderByBuilder<T> {
-  return {
-    reverse: () => wrapOrderByBuilder(builder.reverse(), onLive),
-    offset: (n) => wrapOrderByBuilder(builder.offset(n), onLive),
-    limit: (n) => wrapOrderByBuilder(builder.limit(n), onLive),
-    get: () => Effect.runPromise(builder.get()),
-    first: () => Effect.runPromise(builder.first()),
-    count: () => Effect.runPromise(builder.count()),
-    live: () => {
-      const lq = new LiveQuery(builder.watch());
-      onLive?.(lq as LiveQuery<unknown>);
-      return lq;
-    },
-  };
-}