@rindle/optimistic 0.1.0-rc.5

package/dist/backend.d.ts

@@ -0,0 +1,243 @@
+import type { Ast, Backend, ChangeEvent, ColsMap, Mutation, OptimisticSource, QueryId, RemoteQuery, ResultType, Schema, WireValue } from "@rindle/client";
+/** A keyed row: column name → cell. The ergonomic shape — column names are validated
+ *  against the schema at runtime, so a typo throws immediately with the valid names. */
+export type KeyedRow = Record<string, WireValue>;
+/** The write handle a client mutator runs against (the client `MutationTx`, §4.2):
+ *  reads see the current base + this transaction's own staged writes (§4.1).
+ *
+ *  Prefer the KEYED methods (`insert`/`update`/`upsert`/`delete`/`row`) — named columns,
+ *  schema-checked. The positional methods (`get`/`add`/`remove`/`edit`) are the raw wire
+ *  shape: bare cells in schema column order, `pk` cells in `primaryKey` order. */
+export interface MutationTx {
+    /** Read one row by primary key (e.g. `tx.row("issue", { id: 1 })`). */
+    row(table: string, pk: KeyedRow): KeyedRow | undefined;
+    /** Insert a FULL row (every column named; missing or unknown columns throw). */
+    insert(table: string, row: KeyedRow): void;
+    /** Update the row identified by the pk columns; only the named non-pk columns change.
+     *  A missing row is a NO-OP (rebase-friendly: the row may have vanished upstream). */
+    update(table: string, row: KeyedRow): void;
+    /** Insert, or fully replace when the pk already exists (a FULL row, like `insert`). */
+    upsert(table: string, row: KeyedRow): void;
+    /** Delete the row identified by the pk columns. A missing row is a NO-OP. */
+    delete(table: string, pk: KeyedRow): void;
+    get(table: string, pk: WireValue[]): WireValue[] | undefined;
+    add(table: string, row: WireValue[]): void;
+    remove(table: string, row: WireValue[]): void;
+    edit(table: string, oldRow: WireValue[], newRow: WireValue[]): void;
+}
+/** A client mutator: optimistic, deterministic, replayable — a pure function of
+ *  `(base, args)` (§5: no clock, no randomness; it is RE-INVOKED on every rebase). */
+export type ClientMutator = (tx: MutationTx, args: never) => void;
+/** The client registry (§4.2) — one of the two registries; the server's authoritative
+ *  twin shares names (and possibly code), never the wire. */
+export type ClientRegistry = Record<string, ClientMutator>;
+export type { ResultType };
+/** A virtual-clock seam for the fold debounce/maxWait timers (FOLDED-MUTATIONS-DESIGN §9): the
+ *  oracle injects a deterministic scheduler; production defaults to real timers + `Date.now`. */
+export interface FoldClock {
+    setTimeout(cb: () => void, ms: number): unknown;
+    clearTimeout(handle: unknown): void;
+    now(): number;
+}
+/** Options for a folded call site (FOLDED-MUTATIONS-DESIGN §3). `key` is the identity half of the
+ *  fold key (combined with the mutator name); the rest tune the debounce policy. */
+export interface FoldOptions {
+    /** The identity half of the fold key (typically the targeted primary key). Required. */
+    key: unknown;
+    /** Trailing debounce: the flush fires this long after the LAST invoke for `key`. Default 120ms. */
+    debounceMs?: number;
+    /** Hard cap so a never-idle drag still persists periodically (trailing throttle). Unbounded if
+     *  omitted — an idle gap of `debounceMs` is then the only thing that flushes. */
+    maxWaitMs?: number;
+    /** Keep deferring across overlapping non-fold writes for maximum economy, accepting the §4.2
+     *  read-dependent reorder snap. Default `false` (flush-on-enqueue — correct-and-boring). */
+    deferAcrossWrites?: boolean;
+}
+/** The handle a folded call site gets back (FOLDED-MUTATIONS-DESIGN §3): no `mid` is assigned yet
+ *  (§4.1), so this exposes `flush()` to force the window now and a `mid` promise that resolves with
+ *  the wire id once the window flushes — a caller that needs the server ack can await it. */
+export interface FoldHandle {
+    flush(): void;
+    readonly mid: Promise<number>;
+}
+export interface OptimisticBackendOptions {
+    /** Stable per-client identity for the upstream envelopes (§8.1). */
+    clientID: string;
+    /** Buffered-frame ceiling before the §8.5 escape (drop + re-hydrate). */
+    bufferCap?: number;
+    /** Virtual-clock seam for the fold debounce timers (FOLDED-MUTATIONS-DESIGN §9). Defaults to
+     *  real `setTimeout`/`clearTimeout`/`Date.now`; the fold oracle injects a deterministic clock. */
+    clock?: FoldClock;
+}
+export declare class OptimisticBackend<S extends ColsMap> implements Backend {
+    private readonly local;
+    private readonly sync;
+    private readonly source;
+    private readonly registry;
+    private readonly clientID;
+    private readonly bufferCap;
+    /** Column order + pk indices per table, for the keyed `MutationTx` methods. */
+    private readonly specs;
+    /** Each table's full column count (union-row width) + column-name → base ColId — to learn a
+     *  projected query's per-table projection off its `hello` and register it with the sync layer,
+     *  so it scatters that query's narrower rows into the shared union (PROJECTION-SUPPORT-DESIGN
+     *  §5.2). Without this a projected query's short rows reach the wasm `Db` un-scattered and fail
+     *  its width check. */
+    private readonly colCounts;
+    private readonly colIndex;
+    /** The client's OWN typed per-table schemas + the reserved lmid table — the fixed base
+     *  of the expected-schema set (CRIT#4 validation). Synthetic agg tables are appended as
+     *  queries arrive (`ensureSyntheticTables`). */
+    private readonly clientTablesBase;
+    /** Synthetic aggregate tables (`__agg_*`) registered so far, by name (AGGREGATE-SYNC-DESIGN
+     *  §3.3). Per aggregate DEFINITION (not per query), so two queries over the same count
+     *  share one table. */
+    private readonly synthetic;
+    /** Synthetic table name → how many registered LOCAL queries reference it. A table is
+     *  materialized on the `0→1` transition and reclaimed (engine source + baseline + refcount
+     *  layer + overlay def) on `1→0` — so aggregate state is not permanent (§4). */
+    private readonly syntheticRefs;
+    /** Local qid → the synthetic tables it referenced at registration, to decrement on teardown. */
+    private readonly queryAggTables;
+    /** The optimistic aggregate overlay (§4–§6): the per-aggregate definitions + the per-group
+     *  pending delta `displayed = server_base ⊕ local_pending_delta` is applied from. */
+    private readonly overlay;
+    private handler;
+    private pendingMutations;
+    private nextMid;
+    /** The live fold entries, by fold key `${name}\0${identityJSON}` — at most one per key
+     *  (FOLDED-MUTATIONS-DESIGN §8). Insertion order is creation order (the drain/flush tiebreak). */
+    private readonly folds;
+    /** The fold debounce clock (real timers by default; the oracle injects a virtual one). */
+    private readonly clock;
+    /** The high-water confirmed mutation id, folded from the lmid system query's
+     *  RELEASED ops (lmid-as-data) — never from a frame. */
+    private confirmedLmid;
+    private buffer;
+    private nextSeq;
+    private appliedCv;
+    private readonly asts;
+    /** Per query: the base tables its result can draw from (from the AST tree). */
+    private readonly queryTables;
+    private readonly remoteSubs;
+    private readonly sourceToRemote;
+    private readonly localToRemote;
+    private readonly remoteRetainToLocal;
+    private readonly resultTypes;
+    /** Local view qids that are server-authoritative: a query with no remote sub (purely local) is
+     *  hydrated on registration; a remote query is hydrated when its sub's first snapshot releases.
+     *  An un-hydrated query reports `unknown` (still loading) — the basis of `resultType`. */
+    private readonly hydrated;
+    private resultTypeHandler;
+    /** The pending AXIS (§7.2), split off `ResultType`: per query, whether any pending mutation
+     *  touches its tables. Cached so `onPending` fires only on transitions (invoke ↔ confirm). */
+    private readonly pendingState;
+    private pendingHandler;
+    constructor(schema: Schema<S>, source: OptimisticSource, registry: ClientRegistry, opts: OptimisticBackendOptions);
+    registerQuery(qid: QueryId, ast: Ast, remote?: RemoteQuery): void;
+    /** Register every synthetic aggregate table `ast` needs that we haven't seen yet: on the
+     *  local engine (which auto-tracks it for the optimistic rebase loop), on `NormalizedSync`
+     *  (so its rows refcount/GC by group key), and into the source's expected-schema set (so
+     *  the server's `hello` — which advertises the same table — passes CRIT#4 validation).
+     *  Idempotent across queries that share an aggregate definition. */
+    private ensureSyntheticTables;
+    /** Decrement the refcount of every synthetic table query `qid` referenced; for each one that
+     *  reaches 0 (no live reader left), remove it from the engine, the refcount layer, and the
+     *  overlay — so aggregate state is reclaimed, not permanent (§4). Must run AFTER
+     *  `local.unregisterQuery(qid)` so the engine source has no live connection when
+     *  `unregisterTable` frees it (the engine refuses otherwise). */
+    private releaseSyntheticTables;
+    unregisterQuery(qid: QueryId): void;
+    retainRemoteQuery(qid: QueryId, remote: RemoteQuery, localQueryId?: QueryId): void;
+    releaseRemoteQuery(qid: QueryId): void;
+    /** Raw CRUD has no optimistic story (§9 replaces it with named mutators). Register a
+     *  mutator — even a trivial one — and `invoke` it. */
+    mutate(_mutations: Mutation[]): Promise<void>;
+    onEvent(handler: (qid: QueryId, ev: ChangeEvent) => void): void;
+    /** Run the named client mutator optimistically: the prediction applies to the live
+     *  engine now (affected views update synchronously), `(mid, name, args)` joins the
+     *  pending stack, and the envelope ships upstream. Returns the assigned `mid`. */
+    invoke(name: string, args: unknown): number;
+    /** Run a FOLDED invoke (FOLDED-MUTATIONS-DESIGN §8): apply the prediction to the live engine now
+     *  (like `invoke`), but collapse a run of same-key invokes into ONE pending entry whose `args`
+     *  are overwritten in place, debounce the server write, and ship only the last value. The `mid`
+     *  is assigned at flush, not here (§4.1) — so the return is a {@link FoldHandle}, not a mid. */
+    invokeFolded(name: string, opts: FoldOptions, args: unknown): FoldHandle;
+    /** Flush-on-enqueue (§4.2): for each outstanding fold whose touched tables overlap `tables`,
+     *  assign its mid NOW and ship it — in creation (insertion) order, so the wire stays gapless. A
+     *  `deferAcrossWrites` fold opts out (it keeps deferring, accepting the read-dependent snap). The
+     *  incoming write's own fold key (if any) is skipped — it is being folded into, not flushed. */
+    private drainOverlapping;
+    /** Flush one fold (§8): deal its `mid` from `nextMid` (SEND order — never reserved, so gapless
+     *  by construction), stamp the entry, ship the envelope with the LATEST args, resolve the handle.
+     *  The entry stays on `pendingMutations` (now with a real mid) until the lmid release confirms it. */
+    private flushFold;
+    /** Drain every outstanding fold immediately (FOLDED-MUTATIONS-DESIGN §3): the explicit
+     *  `app.flushFolds()` and the `beforeunload`/`close` hook. Creation (insertion) order. */
+    flushFolds(): void;
+    /** A `trackingTx` op collector that records only the ops over a tracked aggregate's child
+     *  table (the others can't move any count). Applied to the overlay by the caller AFTER the
+     *  mutator succeeds, so a throwing mutator (whose staged write is discarded) leaves no delta. */
+    private opCollector;
+    /** Push the optimistic per-group delta onto the `__agg` head rows (§4):
+     *  `target = server_base ⊕ delta`. A head-only write to the (tracked) synthetic table, so it
+     *  joins the optimistic layer and is rewound/rebuilt by the reconcile cycle like any
+     *  prediction. `server_base` is read from `NormalizedSync` (the authoritative base) — NOT
+     *  from head, which already carries the optimistic layer (a torn read). Works standalone (an
+     *  ordinary delivery) and inside an open cycle (the write buffers into it). */
+    private reconcileAggHead;
+    /** The SERVER CHANNEL's state for a query (§7): `unknown` while not hydrated, else `complete`.
+     *  A pending local mutation no longer moves it — see {@link pending}. */
+    resultType(qid: QueryId): ResultType;
+    onResultType(handler: (qid: QueryId, rt: ResultType) => void): void;
+    /** Whether any pending mutation (folded or not) touches this query's tables — "is a prediction
+     *  pending here?" (FOLDED-MUTATIONS-DESIGN §7.2). Orthogonal to {@link resultType}; this is the
+     *  same `queryTables ∩ pending.touched` computation that used to be smuggled into `unknown`. */
+    pending(qid: QueryId): boolean;
+    /** Reactive pending axis (§7.2): fires when a query's pending-ness flips (invoke ↔ confirm), so a
+     *  "saving…" affordance clears on its own when `lmid` catches up. */
+    onPending(handler: (qid: QueryId, pending: boolean) => void): void;
+    /** The coarse, table-level pending indicator set (§7.2): every table some pending mutation touched. */
+    pendingTables(): Set<string>;
+    /** Recompute the pending axis for every query and fire `onPending` on transitions only. Called
+     *  from the two points that move the pending set: invoke/invokeFolded (add) and the confirm-drop
+     *  (remove) — exactly where `:359`/`:468` used to flip ResultType (§7.3). */
+    private refreshPending;
+    private onNormalized;
+    private onProgress;
+    /** Fold the lmid system query's released ops (lmid-as-data): the one row's
+     *  `last_mutation_id` cell is this client's confirmed high-water mid. */
+    private foldLmidOps;
+    /** One §1.3 reconcile cycle: rewind the optimistic layer and fold the coherent SERVER
+     *  delta into BOTH head AND the `sync` baseline (`serverBatchBegin`), re-invoke every
+     *  still-pending mutator to re-stage the optimistic layer (the rewind un-applied it), then
+     *  deliver the coalesced result (`serverBatchEnd`). This is the engine's only sync-moving
+     *  boundary — `onProgress` releases and `unregisterQuery`'s GC both go through here so head
+     *  and sync never diverge (the §1.2 invariant; CRIT#2). */
+    private runReconcileCycle;
+    /** The daemon restarted (a new boot id): it lost all materialization + `cv` state and its `cv`
+     *  sequence reset, so previously-released `cv`s no longer bound the new stream. The source has
+     *  already re-subscribed every query (reconnect → resync); drop the buffer and the `cv`
+     *  watermark so the fresh, low-`cv` snapshots are RELEASED instead of dropped as stale
+     *  (`onNormalized`/`onProgress` gate on `appliedCv`). Pending optimistic mutations stay put —
+     *  they re-apply on the next reconcile, and the lmid system query's fresh snapshot restores the
+     *  confirmation watermark. */
+    private resetForRestart;
+    /** The §8.5 escape: the buffer outgrew its cap (a pinned `cvMin` under churn). Drop
+     *  everything buffered and re-register every query on the source — the fresh
+     *  snapshots arrive as ordinary frames and the next release re-hydrates via the
+     *  footprint diff (the §5.3 path); still-pending optimism re-applies in that cycle. */
+    private overflow;
+    private setResultType;
+    /** Recompute a query's server-channel state from hydration alone (§7): a pending mutation no
+     *  longer affects it. Used when a remote sub attaches to or hydrates a local view. */
+    private recomputeResultType;
+    /** A remote sub's first snapshot landed: mark it (and every local view it feeds) hydrated, then
+     *  lift those views out of `unknown` (loading). Idempotent — a re-hydrate snapshot re-marks
+     *  harmlessly; a source qid with no sub (the lmid system query) is a no-op. */
+    private markSubHydrated;
+    private retainRemote;
+    private releaseRemote;
+    private addServerDependencyTables;
+}
+//# sourceMappingURL=backend.d.ts.map

package/dist/backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend.d.ts","sourceRoot":"","sources":["../src/backend.ts"],"names":[],"mappings":"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"}