@ultimat3/realtime 20.2.1 → 21.0.0

package/src/hooks.ts

@@ -1,277 +0,0 @@
-// The four calls a component makes: one live query, one connection view, one mutator call, one
-// queue view. Nothing here is a reactive runtime — realtime never imports solid-js, so every
-// accessor is a closure over the `SignalFactory` the registered `LiveClient` was built with, and
-// every hook resolves that client through one ambient seam rather than a context per surface.
-
-import type { LiveClientLike, LiveHandle, LiveQueryRef, MutatorRef } from './client';
-import { LiveClientMissingError } from './errors';
-import type { JsonValue, Row } from './json';
-import type { LocalTx } from './local-store';
-import type { ConflictStrategy } from './rebase';
-import { serverRenderLiveClient } from './server-render-client';
-
-/** What `setLiveClient` holds. The version signal is the queue's only reactive handle — see below. */
-interface Registered {
-  readonly client: LiveClientLike;
-  /** Read to subscribe, bumped to invalidate: `OfflineQueue` stores plain arrays, not signals. */
-  readonly version: () => number;
-  readonly bump: () => void;
-  /** Drops this registration's queue listener. The client outlives the registration. */
-  readonly release: () => void;
-}
-
-let registered: Registered | null = null;
-
-/** Register once, in the app entry, before the first render. One app, one socket, one client. */
-export function setLiveClient(client: LiveClientLike): void {
-  // The previous registration's listener goes with it. The client outlives `setLiveClient` — a hot
-  // reload, a test's next case, an app that re-registers after signing in — so a discarded
-  // unsubscribe is a listener nothing can reach, bumping a signal nothing renders, once per
-  // registration this process ever made.
-  registered?.release();
-  const [version, setVersion] = client.signal<number>(0);
-  const bump = (): void => {
-    setVersion(version() + 1);
-  };
-  // Closes the gap a direct call can't: a reconnect drains automatically inside `connect()`, and
-  // an ack/fail frame arrives asynchronously inside `#onFrame` — neither is awaited by any hook, so
-  // this is the only path that reaches them. The direct `bump()` calls below stay too: they fire at
-  // the earliest possible moment for the call that made them, and a redundant bump is harmless.
-  const release = client.onQueueChange(bump);
-  registered = { client, version, bump, release };
-}
-
-/** For tests: drop the registration so cases stay independent. */
-export function clearLiveClient(): void {
-  registered?.release();
-  registered = null;
-}
-
-export function hasLiveClient(): boolean {
-  return registered !== null;
-}
-
-/**
- * A DOM is the whole of the question — the same probe and the same rule `@ultimat3/ui`'s `solid()`
- * follows, and deliberately the same words. With a DOM, a hook reaching for a client nobody
- * registered is a real bug: the app entry forgot `setLiveClient`, and every live query on the page
- * is dead. Without one there is no socket a client could have been registered FOR — that is a
- * server render, and `serverRenderLiveClient()` is an honest account of it rather than a
- * degradation of a working path. Never widen this to "no client, never throw": that is the silent
- * feed-that-never-loads the split exists to prevent.
- */
-function hasDom(): boolean {
-  return typeof document !== 'undefined' && typeof window !== 'undefined';
-}
-
-/**
- * The server render's registration, built once. Deliberately NOT written to `registered`:
- * `hasLiveClient()` must keep answering `false` on the server, because that is the guard a
- * component with a static fallback already uses to decide it is being server-rendered
- * (`examples/dummy`'s `update-banner.tsx`).
- */
-let serverSide: Registered | null = null;
-
-function serverRegistration(): Registered {
-  if (serverSide !== null) return serverSide;
-  const client = serverRenderLiveClient();
-  // The version signal never moves, and nothing on the server can move it: one pass, no queue,
-  // no ack — so `bump` and `release` are the no-ops that fact makes them.
-  const [version] = client.signal<number>(0);
-  serverSide = { client, version, bump: () => undefined, release: () => undefined };
-  return serverSide;
-}
-
-function live(hook: string): Registered {
-  if (registered !== null) return registered;
-  if (hasDom()) throw new LiveClientMissingError({ hook });
-  return serverRegistration();
-}
-
-// ---- useLive ------------------------------------------------------------------------------------
-
-/** The query's input, or a thunk returning it. The thunk is read once — see `useLive`. */
-export type LiveInput = JsonValue | (() => JsonValue);
-
-/**
- * A callable result set: `feed()` are the rows, `feed.state()` / `feed.cursor()` /
- * `feed.unsubscribe()` are the rest of the `LiveHandle` hanging off it. It is also `Disposable`
- * (inherited from `LiveHandle`), so `using feed = useLive(...)` unsubscribes on scope exit.
- *
- * `R` is only constrained to `object`: on the wire every row is a `Row`, but a hook bound to a
- * declared query (`query-hook.ts`) answers in that query's own row type, which is whatever its
- * `sql` returns. The three members hanging off the accessor are the same for every `R`.
- */
-export type LiveRows<R extends object = Row> = (() => readonly R[]) & Omit<LiveHandle, 'rows'>;
-
-/**
- * Subscribe to a live query. `query` is anything carrying a `name`, which a `@ultimat3/query`
- * `Query` satisfies structurally — realtime is tier 3, so it names the shape rather than importing
- * the package sideways.
- *
- * A thunk `input` is read **once**, at subscribe time: tier 3 has no reactive runtime of its own,
- * so nothing re-runs it when its dependencies change. Changing input means a new subscription.
- * The caller owns `unsubscribe` — nothing here disposes on unmount, because nothing here knows
- * what a mount is. `using` works too, when the caller does have a scope to hang it on.
- */
-export function useLive<R extends Row = Row>(query: LiveQueryRef, input: LiveInput): LiveRows<R> {
-  const handle = live('useLive').client.useLive<R>(
-    query,
-    typeof input === 'function' ? input() : input,
-  );
-  return Object.assign((): readonly R[] => handle.rows(), {
-    state: handle.state,
-    cursor: handle.cursor,
-    unsubscribe: handle.unsubscribe,
-    [Symbol.dispose]: handle[Symbol.dispose],
-  });
-}
-
-// ---- useConnection ------------------------------------------------------------------------------
-
-export interface Connection {
-  readonly offline: boolean;
-  readonly online: boolean;
-  /** Epoch ms of the next reconnect attempt; `null` while the socket is up. */
-  readonly reconnectAt: number | null;
-  /** The buildId the server announced, or `null` while this build is current. */
-  readonly updateAvailable: string | null;
-}
-
-/**
- * The socket, as four booleans and two values. Every member is a **getter**, so a read inside a
- * tracking scope reaches the underlying signal; a snapshot object would freeze the answer at the
- * moment the component rendered and never say "offline" again.
- */
-export function useConnection(): Connection {
-  const client = live('useConnection').client;
-  return {
-    get offline() {
-      return !client.connected;
-    },
-    get online() {
-      return client.connected;
-    },
-    get reconnectAt() {
-      return client.reconnectAt();
-    },
-    get updateAvailable() {
-      return client.appUpdateAvailable();
-    },
-  };
-}
-
-// ---- useMutation --------------------------------------------------------------------------------
-
-/**
- * Both spellings of a conflict strategy: realtime's `custom()` (`{ kind: 'custom' }`, merging rows)
- * and `@ultimat3/action`'s (`{ strategy: 'custom' }`, merging parsed outputs).
- */
-export type ConflictLike = ConflictStrategy | { readonly strategy: 'custom' };
-
-/**
- * What a hook needs from a mutator: the name it queues under, and the optimistic twin. A
- * `@ultimat3/action` `Mutator` satisfies it structurally.
- *
- * `local` is declared with **method syntax** on purpose. TypeScript relates method parameters
- * bivariantly, so a `Mutator` whose `local` takes its own parsed input and its own `tx` assigns
- * here with no cast at the call site; written as a function-typed property, `strictFunctionTypes`
- * would reject exactly that mutator. The parameters are `unknown` because this layer never reads
- * them — it binds them and hands the closure to the client.
- */
-export interface MutatorLike {
-  readonly name: string;
-  local?(tx: unknown, input: unknown): void;
-  readonly entity?: string;
-  readonly conflict?: ConflictLike;
-}
-
-/** A callable mutator with its own queue depth attached. */
-export type Mutate = ((input: JsonValue) => Promise<void>) & {
-  /** Queued mutations of this mutator. Always `0` at tier 2, where nothing is queued. */
-  readonly pending: number;
-};
-
-/**
- * Call a mutator: optimistic twin, rebase entry, durable queue, drain — all of it inside
- * `LiveClient.mutate`. `pending` is a getter, so it stays reactive for as long as the component
- * reads it; it refreshes on every call routed through this hook and on `useMutationQueue().drain`.
- */
-export function useMutation(mutator: MutatorLike): Mutate {
-  const state = live('useMutation');
-  const ref = mutatorRef(mutator);
-  const call = async (input: JsonValue): Promise<void> => {
-    await state.client.mutate(ref, input);
-    state.bump();
-  };
-  Object.defineProperty(call, 'pending', {
-    get: (): number => {
-      state.version();
-      const queue = state.client.queue;
-      return queue === undefined
-        ? 0
-        : queue.pending().filter((mutation) => mutation.name === mutator.name).length;
-    },
-  });
-  // `defineProperty` cannot widen a function type, so the assembled shape is asserted once, here.
-  return call as Mutate;
-}
-
-// ---- useMutationQueue ---------------------------------------------------------------------------
-
-export interface MutationQueue {
-  /** Queued and not yet acknowledged, across every mutator. */
-  readonly pending: number;
-  /** Terminally failed — a policy denial or a validation error, kept for the UI, never retried. */
-  readonly failed: number;
-  drain(): Promise<void>;
-}
-
-/** The whole durable queue, as two counts and the one command that empties it. */
-export function useMutationQueue(): MutationQueue {
-  const state = live('useMutationQueue');
-  return {
-    get pending() {
-      state.version();
-      return state.client.queue?.pending().length ?? 0;
-    },
-    get failed() {
-      state.version();
-      const all = state.client.queue?.all() ?? [];
-      return all.filter((mutation) => mutation.status === 'failed').length;
-    },
-    drain: async () => {
-      await state.client.drain();
-      state.bump();
-    },
-  };
-}
-
-/** The hook's mutator, as the client's. Only the twin needs binding; the rest is carried through. */
-function mutatorRef(mutator: MutatorLike): MutatorRef {
-  const conflict = replayable(mutator.conflict);
-  return {
-    name: mutator.name,
-    // Called back through the mutator rather than through a hoisted reference: `local` may be
-    // written as a method, and an unbound method loses the receiver its body could read.
-    ...(mutator.local === undefined
-      ? {}
-      : {
-          local: (tx: LocalTx, input: JsonValue) => {
-            mutator.local?.(tx, input);
-          },
-        }),
-    ...(mutator.entity === undefined ? {} : { entity: mutator.entity }),
-    ...(conflict === undefined ? {} : { conflict }),
-  };
-}
-
-/**
- * `@ultimat3/action`'s `custom(merge)` merges parsed *outputs*; realtime's merges *rows*. Only the
- * second is a `CustomMerge` `reconcile` can replay, so the other spelling is dropped rather than
- * handed to a rebase that would call it with the wrong argument — the log then takes its default.
- */
-function replayable(conflict: ConflictLike | undefined): ConflictStrategy | undefined {
-  if (conflict === undefined || typeof conflict === 'string') return conflict;
-  return 'kind' in conflict ? conflict : undefined;
-}

package/src/identity-map.ts

@@ -1,141 +0,0 @@
-// One row VALUE per `(scope, id)` for the whole client — the identity map the thesis takes from
-// Ember Data. Two components holding two copies of one row is the bug it makes unrepresentable:
-// a live query's window and the tier-3 local store are both projections over this one map, so a
-// write through either is the same row for both. Membership and order live in the projections.
-
-import type { JsonObject, JsonValue, Row } from './json';
-
-/**
- * The entity's table — the same name `ChangeEvent.entity`, `tx.<table>` and a mutator's `entity`
- * already use, which is what makes the live path and the local store address one row identically.
- * A subscription whose entity the server did not name gets a private `?query:<name>` scope: no
- * sharing is worse than sharing two different entities that happen to spell one id the same way.
- */
-export type RowScope = string;
-
-/** `scope`+NUL+`id`. NUL cannot occur in an entity name, so the join is unambiguous. */
-export type RowKey = string;
-
-export function rowKey(scope: RowScope, id: string): RowKey {
-  return `${scope}\u0000${id}`;
-}
-
-/** The scope a subscription uses until the server names its entity. `?` starts no entity name. */
-export function privateScope(queryName: string): RowScope {
-  return `?query:${queryName}`;
-}
-
-export type IdentityListener = (changed: ReadonlySet<RowKey>) => void;
-
-/**
- * The map. Values are immutable: every write produces a NEW row object, because a projection over
- * this map hands its rows to a signal and a mutated-in-place row is a render that never happens.
- * "One row per id" therefore means one *current value* per id, referenced by every holder at once.
- */
-export class IdentityMap {
-  readonly #values = new Map<RowKey, Row>();
-  /** How many projections hold each key. A row nobody holds is dropped — a window is not a leak. */
-  readonly #holds = new Map<RowKey, number>();
-  readonly #listeners = new Set<IdentityListener>();
-  /** Non-null while a batch is open; every write inside one notifies exactly once, at the end. */
-  #changed: Set<RowKey> | null = null;
-
-  peek(scope: RowScope, id: string): Row | undefined {
-    return this.#values.get(rowKey(scope, id));
-  }
-
-  /** Whole-row write: the value becomes exactly this row. `insert` and a rollback's undo use it. */
-  set(scope: RowScope, row: Row): Row {
-    const key = rowKey(scope, row.id);
-    const current = this.#values.get(key);
-    if (current === row) return row;
-    this.#values.set(key, row);
-    this.#touch(key);
-    return row;
-  }
-
-  /**
-   * Merge changed columns onto the current value. This is the write every server patch, every
-   * snapshot row and every `upsert` takes: a projection that selected fewer columns must not blank
-   * the columns another projection is rendering, so a write never removes a key. `undefined` in a
-   * patch means "leave it alone", exactly as the local store's contract already says.
-   */
-  merge(
-    scope: RowScope,
-    id: string,
-    columns: Readonly<Record<string, JsonValue | undefined>>,
-  ): Row {
-    const key = rowKey(scope, id);
-    const current = this.#values.get(key);
-    const next: JsonObject = { ...current };
-    let changed = current === undefined;
-    for (const [column, value] of Object.entries(columns)) {
-      if (value === undefined || column === 'id') continue;
-      if (current === undefined || current[column] !== value) changed = true;
-      next[column] = value;
-    }
-    const row: Row = { ...next, id };
-    // A patch that changed nothing must not re-emit: a no-op write re-rendering every holder is
-    // how a live query becomes the most expensive thing on the page.
-    if (!changed && current !== undefined) return current;
-    this.#values.set(key, row);
-    this.#touch(key);
-    return row;
-  }
-
-  retain(scope: RowScope, id: string): void {
-    const key = rowKey(scope, id);
-    this.#holds.set(key, (this.#holds.get(key) ?? 0) + 1);
-  }
-
-  /** The last holder leaving drops the value: an infinite scroll must not retain every row it saw. */
-  release(scope: RowScope, id: string): void {
-    const key = rowKey(scope, id);
-    const holds = this.#holds.get(key);
-    if (holds === undefined) return;
-    if (holds > 1) {
-      this.#holds.set(key, holds - 1);
-      return;
-    }
-    this.#holds.delete(key);
-    if (this.#values.delete(key)) this.#touch(key);
-  }
-
-  /** Every write inside `fn` collapses into one notification — one patch frame, one render. */
-  batch<T>(fn: () => T): T {
-    if (this.#changed !== null) return fn();
-    const collected = new Set<RowKey>();
-    this.#changed = collected;
-    try {
-      return fn();
-    } finally {
-      this.#changed = null;
-      if (collected.size > 0) this.#notify(collected);
-    }
-  }
-
-  subscribe(listener: IdentityListener): () => void {
-    this.#listeners.add(listener);
-    return () => {
-      this.#listeners.delete(listener);
-    };
-  }
-
-  /** Held keys. Tests assert on it; nothing in the client branches on a count. */
-  get size(): number {
-    return this.#values.size;
-  }
-
-  #touch(key: RowKey): void {
-    const batch = this.#changed;
-    if (batch !== null) {
-      batch.add(key);
-      return;
-    }
-    this.#notify(new Set([key]));
-  }
-
-  #notify(changed: ReadonlySet<RowKey>): void {
-    for (const listener of this.#listeners) listener(changed);
-  }
-}

package/src/local-store.ts

@@ -1,241 +0,0 @@
-// Tier 3: the durable local store a `mutator`'s `local(tx, input)` half writes to.
-//
-// `local` must be replayable — no I/O, no Date.now(), no Math.random() — because rebase replays it.
-// That is why every write goes through a journal keyed by the mutation's idempotency key: rollback
-// is "undo this key's journal in reverse", not "re-fetch and hope".
-//
-// A table owns MEMBERSHIP (which ids it holds); the shared `IdentityMap` owns the VALUES, so an
-// optimistic write and the live query rendering that row are one row, not two copies.
-
-import { NotImplementedError } from './errors';
-import { IdentityMap } from './identity-map';
-import type { Row } from './json';
-
-export interface LocalTable<R extends Row = Row> {
-  get(id: string): R | undefined;
-  all(): readonly R[];
-  insert(row: R): void;
-  upsert(row: R): void;
-  /** `patch` returns changed fields only, mirroring the canonical mutator example. */
-  update(id: string, patch: (row: R) => Partial<R>): void;
-  delete(id: string): void;
-}
-
-export type TableMap = Record<string, Row>;
-
-/**
- * The transaction handle passed to `local`. In a generated app the table map comes from the app's
- * entities, so `tx.posts` is a real property with a real row type — never an index signature.
- */
-export type LocalTx<T extends TableMap = TableMap> = { readonly [K in keyof T]: LocalTable<T[K]> };
-
-interface JournalEntry {
-  readonly table: string;
-  readonly id: string;
-  /** Row state before the write; `undefined` means "did not exist" (so undo = drop membership). */
-  readonly before: Row | undefined;
-}
-
-export interface LocalStore<T extends TableMap = TableMap> {
-  /**
-   * The one map every row value lives in, shared with the live-query windows on the same client.
-   * A `LiveClient` reads it off the store rather than building its own — two identity maps in one
-   * client is the bug an identity map exists to prevent, one level up.
-   */
-  readonly identity: IdentityMap;
-  readonly tx: LocalTx<T>;
-  table(name: string): LocalTable;
-  /** Runs `fn` while journalling every write under `key`, so it can be rolled back verbatim. */
-  apply(key: string, fn: (tx: LocalTx<T>) => void): void;
-  /** Undo one key's writes, newest first. Used by rebase before reapplying pending mutations. */
-  rollback(key: string): void;
-  /** Server confirmed: drop the journal. After this the write is no longer optimistic. */
-  commit(key: string): void;
-  pendingKeys(): readonly string[];
-  snapshot(name: string): readonly Row[];
-  reset(tables: Readonly<Record<string, readonly Row[]>>): void;
-}
-
-/**
- * The reference implementation. Every rule in the tier-3 contract (journalling, ordered undo, key
- * scoping) is implemented here; OPFS SQLite swaps the storage, not the semantics.
- */
-export class MemoryLocalStore<T extends TableMap = TableMap> implements LocalStore<T> {
-  /** Membership and nothing else: `#members.get('posts')` is which ids this table holds. */
-  readonly #members = new Map<string, Set<string>>();
-  readonly #journals = new Map<string, JournalEntry[]>();
-  #recordingKey: string | null = null;
-
-  readonly identity: IdentityMap;
-  readonly tx: LocalTx<T>;
-
-  constructor(tables: Readonly<Record<string, readonly Row[]>> = {}, identity = new IdentityMap()) {
-    this.identity = identity;
-    this.reset(tables);
-    const handler: ProxyHandler<Record<string, LocalTable>> = {
-      // Symbols (`Symbol.iterator`, `then`) must not resolve to a table, or awaiting a tx would
-      // silently create one.
-      get: (_target, property) => (typeof property === 'symbol' ? undefined : this.table(property)),
-    };
-    this.tx = new Proxy({} as Record<string, LocalTable>, handler) as LocalTx<T>;
-  }
-
-  table(name: string): LocalTable {
-    const ids = this.#ids(name);
-    const read = (id: string): Row | undefined =>
-      ids.has(id) ? this.identity.peek(name, id) : undefined;
-    return {
-      get: read,
-      all: () => {
-        const rows: Row[] = [];
-        for (const id of ids) {
-          const row = this.identity.peek(name, id);
-          if (row !== undefined) rows.push(row);
-        }
-        return rows;
-      },
-      insert: (row) => {
-        this.#journal(name, row.id, read(row.id));
-        this.#join(name, row.id, ids);
-        this.identity.set(name, row);
-      },
-      upsert: (row) => {
-        this.#journal(name, row.id, read(row.id));
-        this.#join(name, row.id, ids);
-        this.identity.merge(name, row.id, row);
-      },
-      update: (id, patch) => {
-        const current = read(id);
-        if (!current) return;
-        this.#journal(name, id, current);
-        this.identity.merge(name, id, patch(current));
-      },
-      delete: (id) => {
-        const current = read(id);
-        if (!current) return;
-        this.#journal(name, id, current);
-        this.#leave(name, id, ids);
-      },
-    };
-  }
-
-  apply(key: string, fn: (tx: LocalTx<T>) => void): void {
-    const previous = this.#recordingKey;
-    this.#recordingKey = key;
-    if (!this.#journals.has(key)) this.#journals.set(key, []);
-    try {
-      // One notification for the whole twin: a mutator touching twenty rows is one render.
-      this.identity.batch(() => fn(this.tx));
-    } finally {
-      this.#recordingKey = previous;
-    }
-  }
-
-  rollback(key: string): void {
-    const journal = this.#journals.get(key);
-    if (!journal) return;
-    this.identity.batch(() => {
-      for (let i = journal.length - 1; i >= 0; i -= 1) {
-        const entry = journal[i];
-        if (!entry) continue;
-        const ids = this.#ids(entry.table);
-        if (entry.before === undefined) {
-          this.#leave(entry.table, entry.id, ids);
-          continue;
-        }
-        this.#join(entry.table, entry.id, ids);
-        this.identity.set(entry.table, entry.before);
-      }
-    });
-    this.#journals.delete(key);
-  }
-
-  commit(key: string): void {
-    this.#journals.delete(key);
-  }
-
-  pendingKeys(): readonly string[] {
-    return [...this.#journals.keys()];
-  }
-
-  snapshot(name: string): readonly Row[] {
-    return this.table(name).all();
-  }
-
-  reset(tables: Readonly<Record<string, readonly Row[]>>): void {
-    this.identity.batch(() => {
-      for (const [name, ids] of this.#members) {
-        for (const id of ids) this.identity.release(name, id);
-      }
-      this.#members.clear();
-      this.#journals.clear();
-      for (const [name, rows] of Object.entries(tables)) {
-        const ids = this.#ids(name);
-        for (const row of rows) {
-          this.#join(name, row.id, ids);
-          this.identity.set(name, row);
-        }
-      }
-    });
-  }
-
-  #ids(name: string): Set<string> {
-    const existing = this.#members.get(name);
-    if (existing) return existing;
-    const created = new Set<string>();
-    this.#members.set(name, created);
-    return created;
-  }
-
-  /** Membership is what holds a value in the map, so joining and retaining are one step. */
-  #join(name: string, id: string, ids: Set<string>): void {
-    if (ids.has(id)) return;
-    ids.add(id);
-    this.identity.retain(name, id);
-  }
-
-  /** Leaving releases: the value survives only while a live window still holds the same row. */
-  #leave(name: string, id: string, ids: Set<string>): void {
-    if (!ids.delete(id)) return;
-    this.identity.release(name, id);
-  }
-
-  /** Only the *first* write to a row within one key is journalled — undo must reach the base state. */
-  #journal(table: string, id: string, before: Row | undefined): void {
-    const key = this.#recordingKey;
-    if (key === null) return;
-    const journal = this.#journals.get(key);
-    if (!journal) return;
-    if (journal.some((entry) => entry.table === table && entry.id === id)) return;
-    journal.push(before === undefined ? { table, id, before: undefined } : { table, id, before });
-  }
-}
-
-export interface OpfsLocalStoreOptions {
-  /** OPFS file name, versioned so a client-side migration can run before first read. */
-  readonly file: string;
-  readonly schemaVersion: number;
-}
-
-/**
- * The production tier-3 store: SQLite over the Origin Private File System, opened in a worker so a
- * long write never blocks the main thread. Browser-only, so it must not be reachable from a server
- * bundle — which is why it is a factory that throws rather than a class you can accidentally new
- * on the server.
- *
- * The refusal below is the whole of what tier 3's durable half ships today, so its two lines have
- * to be true of THIS build. Both were false until 2026-08-23: the fix told the caller to import
- * this factory from a `/browser` subpath, which `package.json`'s `exports` has never declared —
- * two entries ship, `.` and `./server` — so pasting it ended in a module-resolution failure. Its
- * alternative was `persist: false` on the query, which `query()` has never accepted either (a
- * `TS2353` excess property). An instruction that cannot run is axiom 4 failing in the package that
- * documents it, so the fix now names an export that exists on an entry that exists:
- * `MemoryLocalStore`, on `.`, declared beside this factory. `fix-specifier.test.ts` is the
- * mechanical half.
- */
-export function createOpfsLocalStore(options: OpfsLocalStoreOptions): LocalStore {
-  throw new NotImplementedError({
-    what: `the OPFS SQLite local store for ${options.file} (schema v${options.schemaVersion}), which is realtime tier 3's durable half,`,
-    fix: "replace createOpfsLocalStore(...) with new MemoryLocalStore(), imported from '@ultimat3/realtime' beside it: the same LocalStore contract — journalled writes, ordered rollback, one row value per (entity, id) — held for the tab's lifetime rather than across a reload",
-  });
-}