@toclocoinc/lattice-grid 1.63.1 → 1.63.3

package/docs/API.html

@@ -360,7 +360,7 @@
 <div class="shell">
   <aside class="rail">
     <p class="rail__brand">Lattice Grid</p>
-    <p class="rail__sub">API reference · v1.63.1</p>
+    <p class="rail__sub">API reference · v1.63.3</p>
     <nav>
       <div class="rail__group">
         <span class="rail__label">Start</span>
@@ -421,6 +421,7 @@
         <a href="#units">Units of your own</a>
         <a href="#chartsmodule">The charts module</a>
         <a href="#layout">The dashboard layout</a>
+        <a href="#datarouter">The data router</a>
         <a href="#mocksocket">The mock socket</a>
         <a href="#charts">In-cell charts</a>
         <a href="#formulas">Formulas</a>
@@ -443,7 +444,7 @@
     </header>
 
     <p class="chips">
-      <span class="chip">Version 1.63.1</span>
+      <span class="chip">Version 1.63.3</span>
       <span class="chip">Zero dependencies</span>
       <span class="chip"><a href="api-detail.html">Developer guide &rarr;</a></span>
     </p>
@@ -1392,7 +1393,7 @@ grid.destroy();
       <table>
         <thead><tr><th>Member</th><th>Returns</th><th>Description</th></tr></thead>
         <tbody>
-          <tr><td class="sig">getVersion()</td><td class="type">string</td><td class="desc">The version this grid came from, e.g. <code>'1.63.1'</code>. Also on the module as <code>getVersion()</code>, for when you have no grid to hand.</td></tr>
+          <tr><td class="sig">getVersion()</td><td class="type">string</td><td class="desc">The version this grid came from, e.g. <code>'1.63.3'</code>. Also on the module as <code>getVersion()</code>, for when you have no grid to hand.</td></tr>
           <tr><td class="sig">get(key)</td><td class="type">unknown</td><td class="desc">Read any configuration key.</td></tr>
           <tr><td class="sig">set(key, value)</td><td class="type">void</td><td class="desc">Write one key. Every key is live; nothing needs a rebuild.</td></tr>
           <tr><td class="sig">setAll(values)</td><td class="type">void</td><td class="desc">Write several in one pass. Emits one <code>config:changed</code> for the batch, not one per key.</td></tr>
@@ -5630,12 +5631,12 @@ router.load(snapshot);                        <span class="cmt">// every viewer
       <table>
         <thead><tr><th>Member</th><th>Description</th></tr></thead>
         <tbody>
-          <tr><td class="sig">createDataRouter({ key, rowKey?, overlap?, onUnrouted?, seq?, dedupe?, batch?, coalesce?, time?, now?, onWrite?, onConflict?, config? })</td><td class="desc">Create a router. <code>key</code> is the partition (property or <code>fn(row)</code>); <code>rowKey</code> the default identity within a grid; <code>overlap</code> fans a record to all matching routes; <code>onUnrouted</code> is a sink for unmatched records. <strong>v3:</strong> <code>seq</code> (a version field or <code>fn(row)</code>) turns on ordered de-duplication, <code>dedupe: false</code> opts out; <code>batch</code> (interval ms or <code>{ intervalMs }</code>) / <code>coalesce: true</code> buffer a high-frequency <code>push</code>. <strong>v4:</strong> <code>time</code> (a timestamp field or <code>fn(row)</code>) and an injectable <code>now</code> clock drive time-domain scrubbing. <strong>v8:</strong> <code>onWrite</code>/<code>onConflict</code> are the router-global write-back callbacks. <strong>v5:</strong> <code>config</code> is a declarative routing spec, desugared through <code>configure</code>.</td></tr>
+          <tr><td class="sig">createDataRouter({ key?, rowKey?, overlap?, onUnrouted?, selectionDebounce?, metricsInterval?, seq?, dedupe?, batch?, coalesce?, time?, now?, onWrite?, onConflict?, config? })</td><td class="desc">Create a router. <code>key</code> is the partition (property or <code>fn(row)</code>) &mdash; optional, since a router whose routes all use <code>fn(row)</code> predicates never reads it; <code>rowKey</code> the default identity within a grid; <code>overlap</code> fans a record to all matching routes; <code>onUnrouted</code> is a sink for unmatched records (it receives the row on <code>load</code> and <code>query</code>, and the whole delta on <code>apply</code>). <code>selectionDebounce</code> is the debounce in ms for cross-grid selection refilters (default 16; <code>0</code> refilters synchronously). <strong>v10:</strong> <code>metricsInterval</code> is the ms between periodic <code>on('metrics')</code> emits (default 1000; <code>0</code> disables the timer). <strong>v3:</strong> <code>seq</code> (a version field or <code>fn(row)</code>) turns on ordered de-duplication, <code>dedupe: false</code> opts out; <code>batch</code> (interval ms or <code>{ intervalMs }</code>) / <code>coalesce: true</code> buffer a high-frequency <code>push</code>. <strong>v4:</strong> <code>time</code> (a timestamp field or <code>fn(row)</code>) and an injectable <code>now</code> clock drive time-domain scrubbing. <strong>v8:</strong> <code>onWrite</code>/<code>onConflict</code> are the router-global write-back callbacks. <strong>v5:</strong> <code>config</code> is a declarative routing spec, desugared through <code>configure</code>.</td></tr>
           <tr><td class="sig">attach(grid, predicate, { rowKey? })</td><td class="desc">Route to <code>grid</code> when <code>predicate</code> matches: a value compared to <code>key</code>, or a <code>fn(row) =&gt; boolean</code>. <code>rowKey</code> overrides the router default for this grid.</td></tr>
           <tr><td class="sig">attachDefault(grid, { rowKey? })</td><td class="desc">The "rest" sink: the grid that receives every record no explicit route matched.</td></tr>
           <tr><td class="sig">load(snapshot)</td><td class="desc">Apply a full snapshot as a keyed diff per grid. Returns per-route <code>{ added, updated, removed }</code> counts in attach order.</td></tr>
           <tr><td class="sig">apply(deltas)</td><td class="desc">Apply <code>{ op: 'upsert' | 'delete', row }</code> deltas in place by <code>rowKey</code>.</td></tr>
-          <tr><td class="sig">unrouted</td><td class="desc">How many records matched no route (reset by <code>load</code>, running for deltas).</td></tr>
+          <tr><td class="sig">unrouted</td><td class="desc">How many records matched no route. Reset to zero by <code>load</code> and by <code>query</code>, then running for deltas &mdash; so read it straight after the call you care about, not at the end of a session.</td></tr>
           <tr><td class="sig">link(source, target, relation)</td><td class="desc"><strong>v2:</strong> make a selection in <code>source</code> filter what <code>target</code> receives. <code>relation</code> is a key map <code>{ from, to }</code> (target rows whose <code>to</code> value is among the selected source rows' <code>from</code> values &mdash; multi-select is an IN set, ANY match) or a function <code>fn(selectedSourceRows) =&gt; (row) =&gt; boolean</code>. No selection shows the full partition; changes are debounced.</td></tr>
           <tr><td class="sig">flush()</td><td class="desc"><strong>v2:</strong> apply any debounced selection refilter now, for a deterministic point (and for tests).</td></tr>
           <tr><td class="sig">attach(grid, predicate, { rollup })</td><td class="desc"><strong>v3:</strong> feed the grid a grouped/summarised view &mdash; <code>rollup: { groupBy, aggregate }</code> gives one summary row per group (<code>op</code> of <code>sum</code>/<code>avg</code>/<code>min</code>/<code>max</code>/<code>count</code> over a <code>field</code>, or a <code>fn(rows)</code>). Applied by keyed diff, so only a moved group repaints.</td></tr>
@@ -5650,8 +5651,9 @@ router.load(snapshot);                        <span class="cmt">// every viewer
           <tr><td class="sig">attach(grid, predicate, { writable, onWrite?, onConflict? })</td><td class="desc"><strong>v8 (BACKLOG-0000912):</strong> make a route <strong>writable</strong> &mdash; the router captures the grid's committed edits off its public edit surface (<code>grid.on('cell:changed')</code> &rarr; <code>grid.edit.setCells</code>) and routes them to <code>onWrite(change, { route, source })</code> (per-route here, or the router-global <code>onWrite</code>), reverting the cell on reject and re-entering an accepted write as a normal delta. <code>onConflict(change, { serverRow })</code> surfaces a last-write-wins conflict. A derived (<code>rollup</code>/<code>transform</code>) route cannot be writable &mdash; its edits are reverted and warned.</td></tr>
           <tr><td class="sig">attach(grid, predicate, { where })</td><td class="desc"><strong>v7 (BACKLOG-0000914):</strong> a route-level <code>where</code> &mdash; a filter-wire condition <code>{ col, op, value }</code> or an <code>and</code>/<code>or</code>/<code>not</code> group &mdash; used only by query-slice routing (<code>query()</code>): the router pushes it <em>down</em> to the engine where the adapter allows and finishes the residual client-side. Distinct from <code>filter</code> (a <code>fn(row)</code> that only ever runs in the browser).</td></tr>
           <tr><td class="sig">attach(grid, predicate, { label, backpressure })</td><td class="desc"><strong>v10/v13:</strong> a human <code>label</code> for the route (shown in <code>metrics()</code> and the devtools panel), and a per-route <strong>backpressure</strong> policy that throttles / coalesces / samples how that route's viewer is refreshed under load &mdash; <em>without</em> touching the keyed store or any other route. <code>backpressure: { maxHz, minInterval?, sample?, maxLag? }</code>: <code>maxLag</code> (a backlog depth) sets when it engages (below it, changes pass straight through); <code>maxHz</code>/<code>minInterval</code> cap the refresh rate; <code>sample</code> (an integer &gt; 1) thins intermediate refreshes. A trailing flush always lands the latest state (deletes included), so the viewer converges and is never left stale.</td></tr>
+          <tr><td class="sig">flushBackpressure()</td><td class="desc"><strong>v13 (BACKLOG-0000962):</strong> refresh every backpressured route to the latest state now. A route with a <code>backpressure</code> policy holds its viewer refresh until its rate limit or sample count allows one, so a test &mdash; or a teardown &mdash; can observe a route that has not caught up yet; this forces the deferred flush for every route at once and gives you a deterministic point. A no-op for routes without a policy or with nothing pending, and it never touches the keyed store: the rows were always current, only the refresh was held.</td></tr>
           <tr><td class="sig">query(adapter, request?)</td><td class="desc"><strong>v7 (BACKLOG-0000914):</strong> source the router from a DFQL/DuckDB (or any pushdown) adapter. Runs <code>adapter.execute</code>, partitions the result across the routes and drives the grids by the same keyed diff <code>load()</code> uses; a route's <code>where</code> is planned against the adapter's capabilities (pushed down where allowed, residual finished client-side). Composes with per-route <code>transform</code>/<code>filter</code>/<code>sort</code>/<code>rollup</code> and links/graph. Async &mdash; resolves once every slice is fetched and applied.</td></tr>
-          <tr><td class="sig">lastQueryPlan()</td><td class="desc"><strong>v7:</strong> the pushed/residual split of the last <code>query()</code>, per fetch &mdash; whether a filter reached the engine and what work was left client-side. <code>null</code> before any query. Provenance, so a slow slice is diagnosed rather than guessed.</td></tr>
+          <tr><td class="sig">lastQueryPlan()</td><td class="desc"><strong>v7:</strong> the pushed/residual split of the last <code>query()</code>, per fetch &mdash; whether a filter reached the engine and what work was left client-side. <code>null</code> before any query. Each entry is <code>{ route, pushedFilter, residual }</code> for a <code>where</code> route &mdash; <code>route</code> the grid, <code>pushedFilter</code> whether its filter reached the engine, <code>residual</code> the work finished client-side &mdash; or <code>{ base: true, pushedFilter, residual }</code> for the single base fetch that fed every route without a <code>where</code>. Provenance, so a slow slice is diagnosed rather than guessed.</td></tr>
           <tr><td class="sig">buffer({ window?, max? })</td><td class="desc"><strong>v4 (BACKLOG-0000911):</strong> turn on time-travel buffering &mdash; record the ordered, de-duplicated stream into a <strong>bounded</strong> ring (a time <code>window</code> in ms and/or a <code>max</code> delta count; eviction folds the oldest into a moving base, so memory never grows unbounded; a default cap applies if you name neither). Seeded from the current world, so it can be turned on at any time. Opt-in and off by default.</td></tr>
           <tr><td class="sig">scrubTo(target, { by? })</td><td class="desc"><strong>v4:</strong> scrub the grids to a past point &mdash; the base snapshot plus the buffered deltas up to <code>target</code> (a seq when the router has one, else a timestamp; <code>{ by: 'seq' | 'time' }</code> chooses). Pushed by keyed diff, so each view keeps scroll and selection and only changed rows repaint. Live deltas keep arriving into the buffer but do not disturb the view.</td></tr>
           <tr><td class="sig">replay(from, to, { speed?, by? })</td><td class="desc"><strong>v4:</strong> walk an incident &mdash; scrub to <code>from</code>, then apply each buffered delta in <code>(from, to]</code> in order, one per <code>speed</code> ms (default <code>0</code>). Returns a promise resolving when the range finishes (or is superseded); the router stays parked at <code>to</code> until <code>live()</code>.</td></tr>
@@ -5664,7 +5666,7 @@ router.load(snapshot);                        <span class="cmt">// every viewer
           <tr><td class="sig">removeSource(ref) / sources()</td><td class="desc"><strong>v9:</strong> drop exactly the rows a feed contributed (by source id or handle) from every route and unregister it; and list the registered source ids.</td></tr>
           <tr><td class="sig">metrics()</td><td class="desc"><strong>v10 (BACKLOG-0000932):</strong> a cheap point-in-time observability snapshot &mdash; per-route row counts and throughput (rows/sec since the previous read), per-source rates and totals (fan-in), and the global <code>unrouted</code> / <code>dropped</code> / <code>buffered</code> / <code>lag</code> figures. Throughput is sampled over the interval since the last <code>metrics()</code> call or emit. Each entry in <code>routes[]</code> also carries its <code>label</code> and, when the route declares a backpressure policy, a <code>backpressure: { pending, coalesced }</code> object &mdash; <code>pending</code> is the held backlog since the last flush (the route's lag) and <code>coalesced</code> the cumulative change-events it has absorbed into deferred refreshes (<code>null</code> when the route has no policy).</td></tr>
           <tr><td class="sig">on('metrics', handler)</td><td class="desc"><strong>v10:</strong> subscribe to the periodic <code>metrics</code> emit (the <code>metricsInterval</code> ms, default 1000; <code>0</code> disables it). The timer runs only while at least one listener is registered and stops when the last is removed. Returns an unsubscribe function.</td></tr>
-          <tr><td class="sig">mountDevtools(el, { interval? })</td><td class="desc"><strong>v10:</strong> mount an opt-in, DOM-touching live panel (in the module's own <code>devtools.js</code>, so the core stays DOM-free) that renders <code>metrics()</code> into <code>el</code> and refreshes on each emit. Returns a controller with <code>destroy()</code>. Off unless called.</td></tr>
+          <tr><td class="sig">mountDevtools(el)</td><td class="desc"><strong>v10:</strong> mount an opt-in, DOM-touching live panel (in the module's own <code>devtools.js</code>, so the core stays DOM-free) that renders <code>metrics()</code> into <code>el</code> and re-renders on each <code>on('metrics')</code> emit &mdash; so the panel's cadence is the router's <code>metricsInterval</code>, not a setting of its own. Returns a controller with <code>refresh()</code>, which forces an immediate re-render, and <code>destroy()</code>, which unsubscribes and removes the panel from the DOM. The same panel is available without a router: <code>mountRouterDevtools(router, el)</code> is a named export of <code>modules/data-router/devtools.js</code>, and <code>mountDevtools</code> is a one-line wrapper over it. Off unless called.</td></tr>
           <tr><td class="sig">persist({ key?, debounce?, storage?, indexedDB?, dbName?, storeName? })</td><td class="desc"><strong>v12 (BACKLOG-0000961):</strong> turn on durable persistence &mdash; snapshot the keyed store and the time-travel ring to a durable async key/value store so an offline reload or a browser refresh resumes exactly where it left off. The default backend is <strong>IndexedDB</strong> (native, no dependency), opened lazily and guarded so private-mode or blocked storage degrades to in-memory with a one-time warning rather than throwing. Writes a coalesced snapshot after each <code>load</code>/<code>apply</code> (debounced by <code>debounce</code> ms, default 250; <code>0</code> is eager). Pass <code>storage</code> &mdash; any object with async <code>get(key)</code>/<code>set(key, value)</code> &mdash; to use another backend (a server, a test double). Opt-in and off by default.</td></tr>
           <tr><td class="sig">restore()</td><td class="desc"><strong>v12:</strong> resume from the durable snapshot. Read the last persisted state and apply it &mdash; <code>load</code> the live head through the ordinary keyed diff (so grids attached before this call repaint only what differs), restore the resume checkpoint and, when the snapshot carried a time-travel ring, restore buffering and the ring so <code>scrubTo</code>/<code>replay</code>/<code>live</code> work straight after a reload. Call it once, after attaching the grids. <code>async</code>; resolves <code>true</code> when a snapshot was found and applied, <code>false</code> when persistence is off/degraded or nothing was stored.</td></tr>
           <tr><td class="sig">flushPersist() / persisting</td><td class="desc"><strong>v12:</strong> flush any pending durable write now (<code>async</code>; cancels the debounce and resolves once the write settles &mdash; for a <code>beforeunload</code> handler, a deterministic checkpoint, or a test), and whether durable persistence is on and not degraded to in-memory.</td></tr>
@@ -5673,13 +5675,14 @@ router.load(snapshot);                        <span class="cmt">// every viewer
         </tbody>
       </table>
     </div>
+    <p class="section-note"><strong>Four things worth knowing before you build on this.</strong> <code>attachDefault</code> keeps <em>one</em> sink: calling it twice replaces the first, silently, along with whatever slice it held &mdash; attach the sink once, at setup. An <code>alert</code> has no removal: <code>detach</code> drops routes, links and graph edges but leaves alerts running against their own partition, so an alert added at setup keeps firing until <code>destroy()</code>, even after every grid is gone. <code>detach</code> does take a <code>subscribe</code> handler as well as a grid &mdash; pass the same function you handed <code>subscribe</code> and the subscription goes with it. And a <code>join</code> accepts three spellings the examples below do not use: <code>on</code> for <code>localKey</code>, <code>fromKey</code> for <code>foreignKey</code>, and <code>select</code> for <code>fields</code>; they are equivalent, and a spec the router cannot honour degrades to plain fan-in with a one-time warning rather than throwing.</p>
     <p>The router keeps a small <code>Map&lt;rowKey, row&gt;</code> per route to compute the snapshot diff. That is deliberate for v1; a future optimisation could diff against the grid's own key index rather than a shadow copy. Ordering and dedupe across a live feed are the host's to guarantee &mdash; a caller that must drop stale out-of-order deltas can carry its own version or sequence field and filter before <code>apply</code>; v1 imposes no version scheme.</p>
     <p><strong>Cross-grid selection filtering (v2, BACKLOG-0000880).</strong> <code>link</code> keeps each target's <em>full partition</em> separate from what it currently shows: when the source's selection changes, the router recomputes the shown subset from the relation and re-pushes it through the same keyed-diff path, so the target grid stays dumb &mdash; it only ever receives rows, never a query or a reference to the source. Selection <em>in</em> the target survives an unrelated refilter, because the keyed path preserves it. No selection (or one the router cannot resolve to routed rows) shows the full partition, and deselecting restores it. The source grid must have selection enabled; still no grid-core change. Debounce is controlled by <code>selectionDebounce</code> (default 16&nbsp;ms; <code>0</code> is synchronous), and <code>flush()</code> forces it.</p>
     <h3 id="datarouter-v2-example">Cross-grid selection filtering, executed</h3>
     <p class="section-note">A customers grid and an orders grid off one feed; selecting customers filters the orders
     grid to their regions through the keyed-diff path, and deselecting restores the full set. Run headless
     on every build.</p>
-    <pre data-run="js" data-expect="3 | 2 | 3 | 3" data-covers="export:createDataRouter"><code><span class="kw">const</span> { createHeadlessGrid } = <span class="kw">await</span> import('../packages/core/src/index.js');
+    <pre data-run="js" data-expect="3 | 2 | 3 | 3" data-covers="export:createDataRouter config:key config:selectionDebounce"><code><span class="kw">const</span> { createHeadlessGrid } = <span class="kw">await</span> import('../packages/core/src/index.js');
 <span class="kw">const</span> { createDataRouter } = <span class="kw">await</span> import('../packages/modules/data-router/index.js');
 
 <span class="kw">const</span> cols = [{ id: 'id', field: 'id' }, { id: 'type', field: 'type' }, { id: 'region', field: 'region', type: 'text' }];
@@ -5744,7 +5747,7 @@ g.destroy(); router.destroy();
 <span class="kw">return</span> out.join(' | ');</code></pre>
 
     <p><strong>Aggregate/rollup routes (v3, BACKLOG-0000887).</strong> A route can be fed a <em>grouped, summarised</em> view of its partition instead of the raw rows &mdash; a per-category total for a chart route, say. <code>attach(grid, predicate, { rollup: { groupBy, aggregate } })</code> gives the grid one summary row per group: <code>groupBy</code> is a property, a <code>fn(row)</code> or an array of either, and each <code>aggregate</code> entry is a <code>{ op, field }</code> (<code>sum</code>, <code>avg</code>, <code>min</code>, <code>max</code>, <code>count</code>) or a <code>fn(rows) =&gt; value</code>. A route <code>filter</code> runs on the raw rows before grouping; <code>sort</code> and <code>transform</code> run on the summaries. The summary is applied by the same keyed diff, so only a group that actually moved repaints &mdash; the router owns the roll-up, the grid stays dumb.</p>
-    <pre data-run="js" data-expect="2 | amer | 115" data-covers="export:createDataRouter"><code><span class="kw">const</span> { createHeadlessGrid } = <span class="kw">await</span> import('../packages/core/src/index.js');
+    <pre data-run="js" data-expect="2 | amer | 115" data-covers="export:createDataRouter config:rollup"><code><span class="kw">const</span> { createHeadlessGrid } = <span class="kw">await</span> import('../packages/core/src/index.js');
 <span class="kw">const</span> { createDataRouter } = <span class="kw">await</span> import('../packages/modules/data-router/index.js');
 
 <span class="kw">const</span> cols = [{ id: 'region', field: 'region' }, { id: 'total', field: 'total', type: 'number' }];
@@ -5772,7 +5775,7 @@ chart.destroy(); router.destroy();
 <span class="kw">return</span> [groups, top, emeaTotal].join(' | ');</code></pre>
 
     <p><strong>The relationship graph (v3, BACKLOG-0000887).</strong> <code>relate([...])</code> is the scalable form of v2's pairwise <code>link()</code>. Each edge is <code>{ from, to, on }</code>, where <code>on</code> is a key map <code>{ from, to }</code> or a function <code>fn(sourceRows) =&gt; (row) =&gt; boolean</code>. The router resolves the whole graph on any selection change, so it handles <strong>multi-hop</strong> chains (A&rarr;B&rarr;C: a selection in A narrows B and, through B's resulting rows, C &mdash; with no selection in B), <strong>several sources into one target</strong> (their filters AND together), and <strong>mutual</strong> edges (<code>mutual: true</code> &mdash; selecting in either linked view narrows the other; requires a key-map <code>on</code>). A node's effective set is its own selection when it has one, otherwise the rows its incoming edges leave &mdash; that is what carries a selection transitively down a chain. Additive to <code>link()</code>; the two compose.</p>
-    <pre data-run="js" data-expect="o1,o3 | l1,l3,l4" data-covers="export:createDataRouter"><code><span class="kw">const</span> { createHeadlessGrid } = <span class="kw">await</span> import('../packages/core/src/index.js');
+    <pre data-run="js" data-expect="o1,o3 | l1,l3,l4" data-covers="export:createDataRouter config:relate"><code><span class="kw">const</span> { createHeadlessGrid } = <span class="kw">await</span> import('../packages/core/src/index.js');
 <span class="kw">const</span> { createDataRouter } = <span class="kw">await</span> import('../packages/modules/data-router/index.js');
 
 <span class="kw">const</span> cols = [{ id: 'id', field: 'id' }, { id: 'type', field: 'type' }, { id: 'region', field: 'region', type: 'text' }, { id: 'orderId', field: 'orderId', type: 'text' }];
@@ -5797,11 +5800,11 @@ customers.destroy(); orders.destroy(); lines.destroy(); router.destroy();
 <span class="kw">return</span> out.join(' | ');</code></pre>
 
     <p><strong>Stream hygiene (v3, BACKLOG-0000887).</strong> A production feed arrives out of order, gets replayed, and comes faster than a grid should repaint. Configure a <code>seq</code> (a version field or <code>fn(row)</code>) and the router orders each batch by it and <strong>drops</strong> any delta not newer than the one it already applied for that record (counted in <code>router.dropped</code>) &mdash; an out-of-order or replayed feed converges to the newest state. <code>push(delta)</code> with a <code>batch</code> interval or <code>coalesce: true</code> buffers a high-frequency feed and coalesces rapid updates to one key into a single apply (flush a deterministic point with <code>flushStream()</code>). When the host's own connection drops and it reconnects, resume precisely: <code>load</code> a fresh snapshot (a keyed diff that preserves grid state) and replay from <code>lastSeq()</code>/<code>checkpoint()</code> &mdash; the deltas the router already saw are dropped by the same gate. The router does not detect or recover from the drop itself; see <a href="#datarouter-websocket-example">a live WebSocket feed</a> for the worked reconnect example. <code>seenThrough(mark)</code> primes the checkpoint from a persisted one.</p>
-    <pre data-run="js" data-expect="30 | 1 | 4" data-covers="export:createDataRouter"><code><span class="kw">const</span> { createHeadlessGrid } = <span class="kw">await</span> import('../packages/core/src/index.js');
+    <pre data-run="js" data-expect="30 | 1 | 4" data-covers="export:createDataRouter config:seq config:dedupe"><code><span class="kw">const</span> { createHeadlessGrid } = <span class="kw">await</span> import('../packages/core/src/index.js');
 <span class="kw">const</span> { createDataRouter } = <span class="kw">await</span> import('../packages/modules/data-router/index.js');
 
 <span class="kw">const</span> g = createHeadlessGrid({ rowKey: 'id', columns: [{ id: 'id', field: 'id' }, { id: 'n', field: 'n', type: 'number' }] });
-<span class="kw">const</span> router = createDataRouter({ rowKey: 'id', seq: 'v' });
+<span class="kw">const</span> router = createDataRouter({ rowKey: 'id', seq: 'v', dedupe: true });
 router.attach(g, () =&gt; true);
 router.load([]);
 
@@ -5823,12 +5826,12 @@ g.destroy(); router.destroy();
     dropped by the <code>seq</code> checkpoint while a genuinely new one lands. Swapping in a real
     <code>WebSocket</code> is a one-line constructor change — see <a href="#mocksocket">the mock socket</a>.
     Run headless on every build.</p>
-    <pre data-run="js" data-expect="A@3 | 3 | A@4 | 2" data-covers="export:createDataRouter export:MockWebSocket"><code><span class="kw">const</span> { createHeadlessGrid } = <span class="kw">await</span> import('../packages/core/src/index.js');
+    <pre data-run="js" data-expect="A@3 | 3 | A@4 | 2" data-covers="export:createDataRouter config:seq config:dedupe export:MockWebSocket"><code><span class="kw">const</span> { createHeadlessGrid } = <span class="kw">await</span> import('../packages/core/src/index.js');
 <span class="kw">const</span> { createDataRouter } = <span class="kw">await</span> import('../packages/modules/data-router/index.js');
 <span class="kw">const</span> { MockWebSocket } = <span class="kw">await</span> import('../packages/modules/mock-socket/index.js');
 
 <span class="kw">const</span> g = createHeadlessGrid({ rowKey: 'id', columns: [{ id: 'id', field: 'id' }, { id: 'label', field: 'label' }] });
-<span class="kw">const</span> router = createDataRouter({ rowKey: 'id', seq: 'v' });
+<span class="kw">const</span> router = createDataRouter({ rowKey: 'id', seq: 'v', dedupe: true });
 router.attach(g, () =&gt; <span class="kw">true</span>);
 
 <span class="cmt">// THE INTEGRATION: a snapshot message loads, a delta message applies. This is</span>
@@ -5850,7 +5853,7 @@ router.attach(g, () =&gt; <span class="kw">true</span>);
 }
 <span class="kw">const</span> socketA = <span class="kw">new</span> MockWebSocket({ feed: feedA(), rate: 5, jitter: 0, snapshotDelay: 5 });
 wireRouter(router, socketA);
-<span class="kw">await</span> wait(30);
+<span class="kw">await</span> wait(80);
 <span class="kw">const</span> beforeDrop = g.rows.value('a', 'label');  <span class="cmt">// A@3</span>
 <span class="kw">const</span> resumeFrom = router.lastSeq();             <span class="cmt">// 3 — the resume cursor</span>
 socketA.close();
@@ -5913,7 +5916,7 @@ orders.destroy(); invoices.destroy(); rest.destroy(); router.destroy();
     <h3 id="datarouter-v4-example">Scrub and return to live, executed</h3>
     <p class="section-note">A versioned feed buffered into a bounded ring; the view scrubs to a past seq, reads the
     reconstructed value, then returns to the live head. Run headless on every build.</p>
-    <pre data-run="js" data-expect="30 | 10 | true | 30" data-covers="export:createDataRouter"><code><span class="kw">const</span> { createHeadlessGrid } = <span class="kw">await</span> import('../packages/core/src/index.js');
+    <pre data-run="js" data-expect="30 | 10 | true | 30" data-covers="export:createDataRouter config:buffer config:seq"><code><span class="kw">const</span> { createHeadlessGrid } = <span class="kw">await</span> import('../packages/core/src/index.js');
 <span class="kw">const</span> { createDataRouter } = <span class="kw">await</span> import('../packages/modules/data-router/index.js');
 
 <span class="kw">const</span> g = createHeadlessGrid({ rowKey: 'id', columns: [{ id: 'id', field: 'id' }, { id: 'n', field: 'n', type: 'number' }] });
@@ -5974,7 +5977,7 @@ big.destroy(); small.destroy(); router.destroy();
     <h3 id="datarouter-v9-example">Fan-in from two feeds, executed</h3>
     <p class="section-note">Two feeds with a colliding raw id, namespaced per source so they merge without clobbering;
     removing one feed drops exactly its rows. Run headless on every build.</p>
-    <pre data-run="js" data-expect="3 | crm,erp | 2" data-covers="export:createDataRouter"><code><span class="kw">const</span> { createHeadlessGrid } = <span class="kw">await</span> import('../packages/core/src/index.js');
+    <pre data-run="js" data-expect="3 | crm,erp | 2 | 2" data-covers="export:createDataRouter config:id config:key config:load config:size config:remove"><code><span class="kw">const</span> { createHeadlessGrid } = <span class="kw">await</span> import('../packages/core/src/index.js');
 <span class="kw">const</span> { createDataRouter } = <span class="kw">await</span> import('../packages/modules/data-router/index.js');
 
 <span class="kw">const</span> cols = [{ id: 'id', field: 'id' }, { id: 'type', field: 'type' }, { id: 'n', field: 'n', type: 'number' }];
@@ -5989,12 +5992,13 @@ crm.load([{ id: '1', type: 'order', n: 10 }, { id: '2', type: 'order', n: 20 }])
 erp.load([{ id: '1', type: 'order', n: 99 }]);  <span class="cmt">// same raw id '1' — merged, not clobbered</span>
 <span class="kw">const</span> merged = g.rows.count();               <span class="cmt">// 3</span>
 <span class="kw">const</span> ids = router.sources().join(',');       <span class="cmt">// crm,erp</span>
+<span class="kw">const</span> held = crm.size;                        <span class="cmt">// 2 — what this one feed holds live</span>
 
-router.removeSource('erp');                    <span class="cmt">// drops exactly erp's row</span>
+erp.remove();                                  <span class="cmt">// drops exactly erp's row; the handle knows its own feed</span>
 <span class="kw">const</span> afterRemove = g.rows.count();          <span class="cmt">// 2</span>
 
 g.destroy(); router.destroy();
-<span class="kw">return</span> [merged, ids, afterRemove].join(' | ');</code></pre>
+<span class="kw">return</span> [merged, ids, held, afterRemove].join(' | ');</code></pre>
 
     <p><strong>Fan-in JOIN / enrichment (v11, BACKLOG-0000957).</strong> Fan-in above <em>merges</em> feeds side by side; a <code>join</code> spec goes further and <em>enriches</em> one feed's rows with fields looked up from <em>another</em> registered source &mdash; e.g. an <code>orders</code> feed enriched with <code>name</code>/<code>tier</code> from a <code>customers</code> source keyed by <code>customerId</code>. Declared per source: <code>addSource('orders', { join: { from: 'customers', localKey: 'customerId', fields: ['name', 'tier'], missing: 'hold' } })</code>. <code>localKey</code> is the field on the enriched (left) row holding the foreign key (a field name or <code>fn(row)</code>); <code>foreignKey</code> is the field matched on the lookup row (defaults to <code>localKey</code>'s name); <code>fields</code> is what to pull &mdash; an array, a <code>{ src: dest }</code> rename map, or <code>select(lookupRow, leftRow) =&gt; object</code>. No second store is built: the lookup source <em>is</em> an ordinary fan-in source, and the join probes its existing keyed store by an index of join-key&nbsp;&rarr;&nbsp;store-id. <code>missing</code> chooses what happens when the lookup is absent or late: <code>hold</code> withholds the row from viewers until its lookup arrives, <code>passthrough</code> (the default) lets it flow unenriched, and <code>null</code> flows it with the pulled fields set to <code>null</code>. Enriched rows reach viewers through the ordinary keyed-diff path. <strong>Late lookups re-enrich:</strong> when a lookup row arrives, changes, or is deleted, every already-seated left row that references it is re-enriched and re-emitted &mdash; a held row is released, a <code>null</code>/<code>passthrough</code> row gains its fields, and a row whose lookup vanished is nulled/stripped (or, under <code>hold</code>, withheld again). Enrichment always recomputes from the untouched base row, so it is idempotent.</p>
     <p><strong>Durable resume and backpressure (v12/v13, BACKLOG-0000961 / BACKLOG-0000962).</strong> <code>persist({ key })</code> turns on durability: the router snapshots its keyed store and time-travel ring to a durable async store (IndexedDB by default, or any <code>{ get, set }</code> you pass as <code>storage</code>) after each <code>load</code>/<code>apply</code>, and <code>await router.restore()</code> &mdash; called once after the grids are attached &mdash; rehydrates them through the ordinary keyed diff, so an offline reload or a browser refresh resumes exactly where it left off (blocked/private storage degrades to in-memory with a one-time warning, never a throw). Independently, a route can declare <strong>backpressure</strong> &mdash; <code>attach(grid, type, { label, backpressure: { maxHz } })</code> &mdash; to cap how often its viewer repaints under load without slowing the store or any sibling route: <code>maxHz</code>/<code>minInterval</code> rate-limit the refresh, <code>sample</code> thins intermediate ones, and <code>maxLag</code> sets the backlog depth at which throttling engages; a trailing flush always lands the latest state so the viewer converges. What it cost is observable: <code>router.metrics().routes[].backpressure</code> is <code>{ pending, coalesced }</code> &mdash; the held backlog and the cumulative change-events folded into deferred refreshes (<code>null</code> for a route with no policy).</p>
@@ -6028,15 +6032,15 @@ g.destroy(); router.destroy();
     <h3 id="datarouter-v10-example">A metrics snapshot, executed</h3>
     <p class="section-note">A snapshot fanned to a route and a sink; the metrics read reports the route's row count and the
     unrouted total, and <code>on('metrics')</code> returns an unsubscribe. Run headless on every build.</p>
-    <pre data-run="js" data-expect="2 | 1 | function" data-covers="export:createDataRouter"><code><span class="kw">const</span> { createHeadlessGrid } = <span class="kw">await</span> import('../packages/core/src/index.js');
+    <pre data-run="js" data-expect="2 | 1 | function" data-covers="export:createDataRouter config:metricsInterval"><code><span class="kw">const</span> { createHeadlessGrid } = <span class="kw">await</span> import('../packages/core/src/index.js');
 <span class="kw">const</span> { createDataRouter } = <span class="kw">await</span> import('../packages/modules/data-router/index.js');
 
 <span class="kw">const</span> cols = [{ id: 'id', field: 'id' }, { id: 'type', field: 'type' }];
 <span class="kw">const</span> g = createHeadlessGrid({ rowKey: 'id', columns: cols });
-<span class="kw">const</span> router = createDataRouter({ key: 'type', rowKey: 'id' });
+<span class="kw">const</span> router = createDataRouter({ key: 'type', rowKey: 'id', metricsInterval: 0 });  <span class="cmt">// 0: no periodic emit; read on demand</span>
 router.attach(g, 'order');
 
-<span class="kw">const</span> off = router.on('metrics', () =&gt; {});   <span class="cmt">// register; starts the timer, returns unsubscribe</span>
+<span class="kw">const</span> off = router.on('metrics', () =&gt; {});   <span class="cmt">// register; returns unsubscribe (no timer at interval 0)</span>
 router.load([
   { id: 'o1', type: 'order' },
   { id: 'o2', type: 'order' },
@@ -6045,11 +6049,192 @@ router.load([
 <span class="kw">const</span> m = router.metrics();
 <span class="kw">const</span> rows = m.routes[0].rows;               <span class="cmt">// 2</span>
 <span class="kw">const</span> unrouted = m.unrouted;                 <span class="cmt">// 1</span>
-off();                                        <span class="cmt">// stops the timer (last listener gone)</span>
+off();                                        <span class="cmt">// last listener gone</span>
 
 g.destroy(); router.destroy();
 <span class="kw">return</span> [rows, unrouted, typeof off].join(' | ');</code></pre>
 
+
+    <h3 id="datarouter-options-examples">The remaining options, each executed</h3>
+    <p class="section-note">One short example per option family the eight above do not reach: overlap and the unrouted sink, coalesced pushes, write-back, the declarative graph, durable resume, backpressure, and time-domain scrubbing. Each is run headless on every build.</p>
+    <h3 id="datarouter-overlap-example">Fan one value to two viewers, and log the strays, executed</h3>
+    <p class="section-note">With <code>overlap</code> a record goes to <em>every</em> route it matches, so a grid and a second viewer can share one partition; <code>onUnrouted</code> receives what matched none, which is the right sink when a stray record is a bug to log rather than a row to show. Run headless on every build.</p>
+    <pre data-run="js" data-expect="1 | 1 | x1 | 1" data-covers="export:createDataRouter config:overlap config:onUnrouted"><code><span class="kw">const</span> { createHeadlessGrid } = <span class="kw">await</span> import('../packages/core/src/index.js');
+<span class="kw">const</span> { createDataRouter } = <span class="kw">await</span> import('../packages/modules/data-router/index.js');
+
+<span class="kw">const</span> cols = [{ id: 'id', field: 'id' }, { id: 'type', field: 'type' }];
+<span class="kw">const</span> g1 = createHeadlessGrid({ rowKey: 'id', columns: cols });
+<span class="kw">const</span> g2 = createHeadlessGrid({ rowKey: 'id', columns: cols });
+<span class="kw">const</span> strays = [];
+<span class="kw">const</span> router = createDataRouter({ key: 'type', rowKey: 'id', overlap: true, onUnrouted: (row) =&gt; strays.push(row.id) });
+router.attach(g1, 'order');
+router.attach(g2, 'order');            // a second viewer on the same value: allowed because overlap is on
+router.load([{ id: 'o1', type: 'order' }, { id: 'x1', type: 'ticket' }]);
+<span class="kw">const</span> out = [g1.rows.count(), g2.rows.count(), strays.join(','), router.unrouted];
+g1.destroy(); g2.destroy(); router.destroy();
+<span class="kw">return</span> out.join(' | ');</code></pre>
+    <h3 id="datarouter-coalesce-example">Coalesce a burst into one repaint, executed</h3>
+    <p class="section-note">A high-frequency feed goes through <code>push</code>; with <code>coalesce</code> (or a <code>batch</code> interval) rapid updates to one key fold into a single <code>apply</code>, and <code>flushStream</code> gives a deterministic point. Run headless on every build.</p>
+    <pre data-run="js" data-expect="0 | 1 | 3" data-covers="export:createDataRouter config:push config:coalesce config:batch"><code><span class="kw">const</span> { createHeadlessGrid } = <span class="kw">await</span> import('../packages/core/src/index.js');
+<span class="kw">const</span> { createDataRouter } = <span class="kw">await</span> import('../packages/modules/data-router/index.js');
+
+<span class="cmt">// A hand-rolled viewer, grid-shaped: the router accepts anything with rows.apply.</span>
+<span class="kw">const</span> rows = <span class="kw">new</span> Map(); <span class="kw">let</span> applies = 0;
+<span class="kw">const</span> g = { rows: { apply(change) {
+  applies += 1;
+  <span class="kw">for</span> (<span class="kw">const</span> row <span class="kw">of</span> [...(change.add || []), ...(change.update || [])]) rows.set(row.id, row);
+} } };
+<span class="kw">const</span> router = createDataRouter({ rowKey: 'id', coalesce: true, batch: { intervalMs: 50 } });
+router.attach(g, () =&gt; true);
+router.push({ op: 'upsert', row: { id: 'a', n: 1 } });
+router.push({ op: 'upsert', row: { id: 'a', n: 2 } });
+router.push({ op: 'upsert', row: { id: 'a', n: 3 } });
+<span class="kw">const</span> before = applies;                    // 0: nothing applied inside the batch window
+router.flushStream();                      // one apply, carrying the latest value
+<span class="kw">const</span> after = applies;
+<span class="kw">const</span> n = rows.get('a').n;
+router.destroy();
+<span class="kw">return</span> [before, after, n].join(' | ');</code></pre>
+    <h3 id="datarouter-writeback-example">A writable route, a conflict, executed</h3>
+    <p class="section-note">A route attached <code>writable</code> captures the grid&rsquo;s committed edits and routes them to <code>onWrite</code>; when the server answers with a conflict, <code>onConflict</code> fires with the server row and the optimistic value stands (last-write-wins, no merge engine). Run headless on every build.</p>
+    <pre data-run="js" data-expect="1 | 7 | 99" data-covers="export:createDataRouter config:writable config:onWrite config:onConflict"><code><span class="kw">const</span> { createHeadlessGrid } = <span class="kw">await</span> import('../packages/core/src/index.js');
+<span class="kw">const</span> { createDataRouter } = <span class="kw">await</span> import('../packages/modules/data-router/index.js');
+
+<span class="kw">const</span> cols = [{ id: 'id', field: 'id' }, { id: 'type', field: 'type' }, { id: 'amt', field: 'amt', type: 'number', edit: true }];
+<span class="kw">const</span> g = createHeadlessGrid({ rowKey: 'id', columns: cols });
+<span class="kw">const</span> conflicts = [];
+<span class="kw">const</span> router = createDataRouter({ key: 'type', rowKey: 'id', onConflict: (change, ctx) =&gt; conflicts.push(ctx.serverRow.amt) });
+router.attach(g, 'a', { writable: true, onWrite: () =&gt; ({ conflict: { id: 'r1', type: 'a', amt: 7 } }) });
+router.load([{ id: 'r1', type: 'a', amt: 10 }]);
+g.edit.setCells([{ key: 'r1', colId: 'amt', value: 99 }]);   // the user's edit, routed to onWrite
+<span class="kw">const</span> out = [conflicts.length, conflicts[0], g.rows.byKey('r1').data.amt];
+g.destroy(); router.destroy();
+<span class="kw">return</span> out.join(' | ');</code></pre>
+    <h3 id="datarouter-configure-example">The routing graph as one declarative spec, executed</h3>
+    <p class="section-note">The same routes and links the imperative calls would make, as data: <code>routes</code> attach a grid <code>when</code> a value matches, <code>links</code> filter one grid by another&rsquo;s selection. Run headless on every build.</p>
+    <pre data-run="js" data-expect="2 | 1" data-covers="export:createDataRouter config:routes config:links"><code><span class="kw">const</span> { createHeadlessGrid } = <span class="kw">await</span> import('../packages/core/src/index.js');
+<span class="kw">const</span> { createDataRouter } = <span class="kw">await</span> import('../packages/modules/data-router/index.js');
+
+<span class="kw">const</span> cols = [{ id: 'id', field: 'id' }, { id: 'type', field: 'type' }, { id: 'region', field: 'region' }];
+<span class="kw">const</span> customers = createHeadlessGrid({ rowKey: 'id', columns: cols, selection: 'multiple' });
+<span class="kw">const</span> orders = createHeadlessGrid({ rowKey: 'id', columns: cols });
+<span class="kw">const</span> router = createDataRouter({ key: 'type', rowKey: 'id', selectionDebounce: 0 });
+router.configure({
+  routes: [{ grid: customers, when: 'customer' }, { grid: orders, when: 'order' }],
+  links: [{ from: customers, to: orders, on: { from: 'region', to: 'region' } }],
+});
+router.load([
+  { id: 'c1', type: 'customer', region: 'emea' },
+  { id: 'o1', type: 'order', region: 'emea' },
+  { id: 'o2', type: 'order', region: 'amer' },
+]);
+<span class="kw">const</span> all = orders.rows.count();           // 2: no selection shows the whole partition
+customers.selection.set(['c1']);
+router.flush();
+<span class="kw">const</span> linked = orders.rows.count();        // 1: only emea orders
+customers.destroy(); orders.destroy(); router.destroy();
+<span class="kw">return</span> [all, linked].join(' | ');</code></pre>
+    <h3 id="datarouter-persist-example">Durable resume through a store of your own, executed</h3>
+    <p class="section-note">The router snapshots to IndexedDB by default &mdash; <code>dbName</code> and <code>storeName</code> say where, and <code>indexedDB</code> lets you hand it a factory (here a tiny fake, so the example is deterministic) &mdash; or to any <code>storage</code> with async <code>get</code>/<code>set</code>. A second router over the same store <code>restore</code>s what the first one wrote. Run headless on every build.</p>
+    <pre data-run="js" data-expect="demo | router | true | 2 | true | 1" data-covers="export:createDataRouter config:storage config:indexedDB config:dbName config:storeName"><code><span class="kw">const</span> { createHeadlessGrid } = <span class="kw">await</span> import('../packages/core/src/index.js');
+<span class="kw">const</span> { createDataRouter } = <span class="kw">await</span> import('../packages/modules/data-router/index.js');
+
+<span class="cmt">// A fake IDBFactory: one database, one object store, put/get in a transaction.</span>
+<span class="kw">const</span> dbs = <span class="kw">new</span> Map(); <span class="kw">const</span> opened = [];
+<span class="kw">const</span> req = () =&gt; ({ onsuccess: null, onerror: null, onupgradeneeded: null, result: undefined, error: null });
+<span class="kw">const</span> fakeIndexedDB = { open(name) {
+  <span class="kw">const</span> r = req(); opened.push(name);
+  queueMicrotask(() =&gt; {
+    <span class="kw">const</span> fresh = !dbs.has(name); <span class="kw">if</span> (fresh) dbs.set(name, <span class="kw">new</span> Map());
+    <span class="kw">const</span> stores = dbs.get(name);
+    r.result = {
+      objectStoreNames: { contains: (n) =&gt; stores.has(n) },
+      ['createObjectStore'](n) { stores.set(n, <span class="kw">new</span> Map()); <span class="kw">return</span> {}; },
+      transaction(n) {
+        <span class="kw">const</span> store = stores.get(Array.isArray(n) ? n[0] : n); <span class="kw">const</span> tx = { oncomplete: null, onerror: null, onabort: null }; <span class="kw">const</span> ops = [];
+        tx.objectStore = () =&gt; ({
+          put(v, k) { <span class="kw">const</span> q = req(); ops.push(() =&gt; { store.set(k, v); <span class="kw">if</span> (q.onsuccess) q.onsuccess({ target: q }); }); <span class="kw">return</span> q; },
+          get(k) { <span class="kw">const</span> q = req(); ops.push(() =&gt; { q.result = store.get(k); <span class="kw">if</span> (q.onsuccess) q.onsuccess({ target: q }); }); <span class="kw">return</span> q; },
+        });
+        queueMicrotask(() =&gt; { <span class="kw">for</span> (<span class="kw">const</span> op <span class="kw">of</span> ops) op(); <span class="kw">if</span> (tx.oncomplete) tx.oncomplete(); });
+        <span class="kw">return</span> tx;
+      },
+      close() {},
+    };
+    <span class="kw">if</span> (fresh &amp;&amp; r.onupgradeneeded) r.onupgradeneeded({ target: r });
+    <span class="kw">if</span> (r.onsuccess) r.onsuccess({ target: r });
+  });
+  <span class="kw">return</span> r;
+} };
+
+<span class="kw">const</span> cols = [{ id: 'id', field: 'id' }, { id: 'type', field: 'type' }];
+<span class="kw">const</span> a = createDataRouter({ key: 'type', rowKey: 'id' });
+<span class="kw">const</span> ga = createHeadlessGrid({ rowKey: 'id', columns: cols });
+a.attach(ga, 'order');
+a.persist({ indexedDB: fakeIndexedDB, dbName: 'demo', storeName: 'router', debounce: 0 });
+a.load([{ id: 'o1', type: 'order' }, { id: 'o2', type: 'order' }]);
+<span class="kw">await</span> a.flushPersist();
+
+<span class="kw">const</span> b = createDataRouter({ key: 'type', rowKey: 'id' });      // "after the reload"
+<span class="kw">const</span> gb = createHeadlessGrid({ rowKey: 'id', columns: cols });
+b.attach(gb, 'order');
+b.persist({ indexedDB: fakeIndexedDB, dbName: 'demo', storeName: 'router' });
+<span class="kw">const</span> found = <span class="kw">await</span> b.restore();
+<span class="kw">const</span> store = [...dbs.get('demo').keys()][0];
+
+<span class="cmt">// Or skip IndexedDB entirely: any async get/set pair is a store.</span>
+<span class="kw">const</span> mem = <span class="kw">new</span> Map();
+<span class="kw">const</span> c = createDataRouter({ key: 'type', rowKey: 'id' });
+c.attach(createHeadlessGrid({ rowKey: 'id', columns: cols }), 'order');
+c.persist({ storage: { get: <span class="kw">async</span> (k) =&gt; mem.get(k), set: <span class="kw">async</span> (k, v) =&gt; { mem.set(k, v); } }, debounce: 0 });
+c.load([{ id: 'o9', type: 'order' }]);
+<span class="kw">await</span> c.flushPersist();
+<span class="kw">const</span> out = [opened[0], store, found, gb.rows.count(), b.persisting, mem.size];
+ga.destroy(); gb.destroy(); a.destroy(); b.destroy(); c.destroy();
+<span class="kw">return</span> out.join(' | ');</code></pre>
+    <h3 id="datarouter-backpressure-example">Throttle one viewer under load, executed</h3>
+    <p class="section-note">A <code>backpressure</code> policy on one route caps how often <em>that</em> viewer is refreshed without slowing the store or any sibling; a burst inside the window is held to one leading refresh, and <code>flushBackpressure</code> lands the coalesced latest state. Run headless on every build.</p>
+    <pre data-run="js" data-expect="1 | 2 | 9 | 3" data-covers="export:createDataRouter config:backpressure"><code><span class="kw">const</span> { createHeadlessGrid } = <span class="kw">await</span> import('../packages/core/src/index.js');
+<span class="kw">const</span> { createDataRouter } = <span class="kw">await</span> import('../packages/modules/data-router/index.js');
+
+<span class="kw">let</span> clock = 0;
+<span class="kw">const</span> router = createDataRouter({ key: 'type', rowKey: 'id', now: () =&gt; clock });
+<span class="kw">const</span> view = { refreshes: 0, rows: <span class="kw">new</span> Map() };
+router.subscribe('x', (change) =&gt; {
+  view.refreshes += 1;
+  <span class="kw">for</span> (<span class="kw">const</span> row <span class="kw">of</span> [...change.add, ...change.update]) view.rows.set(row.id, row);
+  <span class="kw">for</span> (<span class="kw">const</span> key <span class="kw">of</span> change.remove) view.rows.delete(key);
+}, { backpressure: { maxHz: 100 } });      // at most one refresh per 10 ms
+<span class="kw">const</span> up = (id, n) =&gt; ({ op: 'upsert', row: { id, type: 'x', n } });
+router.apply([up('a', 1)]);                // leading edge: refreshes at once
+router.apply([up('b', 2)]);                // inside the window: held
+router.apply([up('c', 3)]);
+router.apply([up('a', 9)]);                // still held; a's latest value wins
+<span class="kw">const</span> held = view.refreshes;               // 1
+clock = 10;
+router.flushBackpressure();                // window open: one trailing refresh
+<span class="kw">const</span> out = [held, view.refreshes, view.rows.get('a').n, view.rows.size];
+router.destroy();
+<span class="kw">return</span> out.join(' | ');</code></pre>
+    <h3 id="datarouter-time-example">Scrub by wall-clock time, executed</h3>
+    <p class="section-note">When rows carry a timestamp, <code>time</code> names it and the buffer works in the time domain: <code>scrubTo</code> takes a moment rather than a seq, and <code>live</code> returns to the head. Run headless on every build.</p>
+    <pre data-run="js" data-expect="1 | 3" data-covers="export:createDataRouter config:time config:buffer"><code><span class="kw">const</span> { createHeadlessGrid } = <span class="kw">await</span> import('../packages/core/src/index.js');
+<span class="kw">const</span> { createDataRouter } = <span class="kw">await</span> import('../packages/modules/data-router/index.js');
+
+<span class="kw">const</span> cols = [{ id: 'id', field: 'id' }, { id: 'ts', field: 'ts', type: 'number' }];
+<span class="kw">const</span> g = createHeadlessGrid({ rowKey: 'id', columns: cols });
+<span class="kw">const</span> router = createDataRouter({ rowKey: 'id', time: 'ts' });
+router.attach(g, () =&gt; true);
+router.buffer({ window: 10000 });
+router.apply([{ op: 'upsert', row: { id: 'a', ts: 100 } }]);
+router.apply([{ op: 'upsert', row: { id: 'b', ts: 200 } }]);
+router.apply([{ op: 'upsert', row: { id: 'c', ts: 300 } }]);
+router.scrubTo(150, { by: 'time' });       // what the grid showed at t=150
+<span class="kw">const</span> then = g.rows.count();               // 1
+router.live();
+<span class="kw">const</span> now = g.rows.count();                // 3
+g.destroy(); router.destroy();
+<span class="kw">return</span> [then, now].join(' | ');</code></pre>
     <h2 id="ganttmodule">The Gantt module</h2>
     <p><code>modules/gantt</code> is a separate, opt-in project-planning module &mdash; its own bundle, imported only when you want it, changing nothing in the grid core. It turns a task list into a real schedule: a <strong>CPM (Critical Path Method) engine</strong> computes each task's early/late start and finish, its slack (total float), and the zero-float <strong>critical path</strong>, recomputing on every edit. <code>computeSchedule(tasks, deps)</code> is the pure engine; <code>createGantt(opts)</code> is a controller that holds the model, recomputes on <code>setTasks</code>/<code>setDependencies</code>/<code>applyEdit</code>, and emits <code>schedule</code> (or <code>error</code>). Dependencies are the four standard link types &mdash; <code>LINK_TYPES</code> is <code>['FS','SS','FF','SF']</code> &mdash; each with optional lag/lead. A <strong>milestone</strong> is a zero-duration task scheduled as a point; a <strong>summary</strong> task (any task named as another's <code>parent</code>) is derived from its children (start = earliest child, end = latest child, duration-weighted progress) and is not scheduled itself. Bad input never throws or loops: a dependency cycle is refused and reported with a code from <code>SCHEDULE_ERROR</code>, and <code>findViolations</code> flags any task placed earlier than its predecessors allow. <code>toISODate</code> converts an engine day-number back to a calendar date for display.</p>
     <p><strong>Feed it the rows you already have.</strong> <code>fields</code> names your own task properties for the scheduler &mdash; <code>{ id: 'taskId', start: 'startDate', name: 'jobName', duration: 'dur' }</code>, each a field name or a reader <code>(row) =&gt; value</code> &mdash; so a task list arrives as it is rather than being renamed first. The vocabulary is <code>id</code>, <code>name</code>, <code>start</code>, <code>end</code>, <code>duration</code>, <code>milestone</code>, <code>percentComplete</code>, <code>parent</code>, <code>baselineStart</code>, <code>baselineEnd</code>, <code>constraint</code> and <code>constraintDate</code>; anything you leave unmapped reads its canonical name, so an existing plan is unaffected. <code>rowKey</code> reaches the scheduler too, so a row carrying <code>taskId</code> and no <code>id</code> is identified by it &mdash; a task's own <code>id</code> still wins where it has one. It is a <strong>read</strong> mapping: <code>applyEdit</code> and <code>level()</code> write the canonical property, so each says so plainly rather than writing to a field the schedule is not read from, and <code>assignee</code>/<code>cost</code>/<code>actualCost</code> belong to the resource and earned-value layers rather than to this list.</p>
@@ -9476,18 +9661,75 @@ return `next ${p.mean.toFixed(1)}; r2 ${f.r2.toFixed(1)}; band ${p.upper - p.low
       <table>
         <thead><tr><th>Member</th><th>Type</th><th>Description</th></tr></thead>
         <tbody>
-          <tr><td class="name">attach</td><td class="type">(grid: unknown, predicate: RoutePredicate, opts?: RouteOptions): DataRouter</td><td class="desc">Attach a grid behind a predicate; `opts` may reshape/filter/sort the route (v3).</td></tr>
-          <tr><td class="name">attachDefault</td><td class="type">(grid: unknown, opts?: RouteOptions): DataRouter</td><td class="desc">Attach the "rest" sink for records no explicit route matched.</td></tr>
-          <tr><td class="name">detach</td><td class="type">(grid: unknown): DataRouter</td><td class="desc">Detach a grid; the host still owns and destroys it.</td></tr>
-          <tr><td class="name">load</td><td class="type">(snapshot: RouterRecord[]): RouteDiff[]</td><td class="desc">Apply a full snapshot as a keyed diff per grid; returns per-route counts.</td></tr>
-          <tr><td class="name">apply</td><td class="type">(deltas: { op: 'upsert' | 'delete'; row: RouterRecord }[]): void</td><td class="desc">Apply incremental deltas, routed and applied in place by `rowKey`.</td></tr>
+          <tr><td class="name">attach</td><td class="type">(grid: unknown, predicate: RoutePredicate, opts?: RouteOptions): DataRouter</td><td class="desc">Attach a grid behind a predicate; `opts` may reshape, filter, sort, summarise or throttle the route.</td></tr>
+          <tr><td class="name">attachDefault</td><td class="type">(grid: unknown, opts?: RouteOptions): DataRouter</td><td class="desc">Attach the "rest" sink for records no explicit route matched. A second call replaces the first.</td></tr>
+          <tr><td class="name">subscribe</td><td class="type">(predicate: RoutePredicate, handler: (change: RouterChange) =&gt; void, opts?: RouteOptions): DataRouter</td><td class="desc">Route a partition slice to any non-grid view (v5): the handler receives the same keyed diff a grid would.</td></tr>
+          <tr><td class="name">alert</td><td class="type">(predicate: RoutePredicate, condition: (rows: RouterRecord[]) =&gt; unknown, handler: (signal: unknown, rows: RouterRecord[]) =&gt; void, opts?: AlertOptions): DataRouter</td><td class="desc">Watch a slice and emit on a rising edge of `condition` rather than render (v5). Removed only by `destroy`.</td></tr>
+          <tr><td class="name">configure</td><td class="type">(spec?: RouterConfig): DataRouter</td><td class="desc">Take the whole routing graph as one declarative spec (v5); desugars to the calls above and composes with them.</td></tr>
           <tr><td class="name">link</td><td class="type">(source: unknown, target: unknown, relation: SelectionRelation): DataRouter</td><td class="desc">Link a source grid's selection to what a target grid receives (v2, BACKLOG-0000880): the target shows the subset of its partition the `relation` admits, re-pushed through the keyed-diff path. No selection shows the full partition; changes are debounced.</td></tr>
+          <tr><td class="name">relate</td><td class="type">(edges: RouterEdge[]): DataRouter</td><td class="desc">Declare a relationship graph (v3): multi-hop, several-into-one and mutual edges — the scalable form of `link`.</td></tr>
           <tr><td class="name">flush</td><td class="type">(): DataRouter</td><td class="desc">Apply any debounced selection refilter synchronously (for tests/determinism).</td></tr>
-          <tr><td class="name">unrouted</td><td class="type">number</td><td class="desc">How many records matched no route. <small>(read-only)</small></td></tr>
+          <tr><td class="name">detach</td><td class="type">(grid: unknown): DataRouter</td><td class="desc">Detach a grid — or a `subscribe` handler — and drop any link it is part of; the host still owns and destroys it.</td></tr>
+          <tr><td class="name">load</td><td class="type">(snapshot: RouterRecord[]): RouteDiff[]</td><td class="desc">Apply a full snapshot as a keyed diff per grid; returns per-route counts. Resets `unrouted`.</td></tr>
+          <tr><td class="name">apply</td><td class="type">(deltas: RouterDelta[]): void</td><td class="desc">Apply incremental deltas, routed and applied in place by `rowKey`; ordered and de-duplicated when `seq` is on.</td></tr>
+          <tr><td class="name">push</td><td class="type">(delta: RouterDelta | RouterDelta[]): DataRouter</td><td class="desc">Enqueue deltas for batched or coalesced application (v3); applies at once when no batching mode is on.</td></tr>
+          <tr><td class="name">flushStream</td><td class="type">(): DataRouter</td><td class="desc">Apply the buffered deltas now as a single `apply` (v3) — a deterministic point, and for tests.</td></tr>
+          <tr><td class="name">flushBackpressure</td><td class="type">(): DataRouter</td><td class="desc">Refresh every backpressured route to the latest state now (v13); a no-op with nothing pending.</td></tr>
+          <tr><td class="name">addSource</td><td class="type">(feed: string | RouterSourceOptions, opts?: RouterSourceOptions): RouterSourceHandle</td><td class="desc">Register a source feed for fan-in (v9): its rows are normalised and namespaced into the one keyed store.</td></tr>
+          <tr><td class="name">removeSource</td><td class="type">(ref: string | RouterSourceHandle): DataRouter</td><td class="desc">Remove a source feed by id or handle (v9): delete exactly its rows from every route, then unregister it.</td></tr>
+          <tr><td class="name">sources</td><td class="type">(): string[]</td><td class="desc">The registered source ids (v9).</td></tr>
+          <tr><td class="name">metrics</td><td class="type">(): RouterMetrics</td><td class="desc">A cheap point-in-time snapshot of the router's runtime (v10); throughput is measured since the previous read.</td></tr>
+          <tr><td class="name">on</td><td class="type">(event: 'metrics', handler: (snapshot: RouterMetrics) =&gt; void): () =&gt; void</td><td class="desc">Subscribe to the periodic `metrics` emit (v10) — the only event; the timer runs only while a listener is registered. Returns the unsubscribe.</td></tr>
+          <tr><td class="name">mountDevtools</td><td class="type">(el: unknown): RouterDevtoolsPanel</td><td class="desc">Mount the live devtools panel into `el` (v10); it re-renders on each `metrics` emit.</td></tr>
+          <tr><td class="name">unrouted</td><td class="type">number</td><td class="desc">How many records matched no route since the last `load` or `query`, running for deltas. <small>(read-only)</small></td></tr>
+          <tr><td class="name">dropped</td><td class="type">number</td><td class="desc">How many stale or duplicate deltas the dedupe gate dropped since creation (v3). <small>(read-only)</small></td></tr>
+          <tr><td class="name">lastSeq</td><td class="type">(): number | undefined</td><td class="desc">The highest seq applied — the resume point to request the feed from after a dropped socket (v3).</td></tr>
+          <tr><td class="name">checkpoint</td><td class="type">(): Map&lt;string, number&gt;</td><td class="desc">A copy of the per-record resume checkpoint: record identity → last applied seq (v3).</td></tr>
+          <tr><td class="name">seenThrough</td><td class="type">(mark: Map&lt;string, number&gt; | Record&lt;string, number&gt;): DataRouter</td><td class="desc">Prime the resume checkpoint from a persisted one, so replayed deltas at or below those seqs are dropped (v3).</td></tr>
+          <tr><td class="name">persist</td><td class="type">(opts?: RouterPersistOptions): DataRouter</td><td class="desc">Turn on durable persistence of the router's state (v12).</td></tr>
+          <tr><td class="name">restore</td><td class="type">(): Promise&lt;boolean&gt;</td><td class="desc">Resume from the durable snapshot (v12); resolves true when one was found and applied.</td></tr>
+          <tr><td class="name">flushPersist</td><td class="type">(): Promise&lt;DataRouter&gt;</td><td class="desc">Flush any pending durable write now (v12); resolves once it has settled.</td></tr>
+          <tr><td class="name">persisting</td><td class="type">boolean</td><td class="desc">Whether durable persistence is on and not degraded to in-memory (v12). <small>(read-only)</small></td></tr>
+          <tr><td class="name">buffer</td><td class="type">(opts?: { window?: number; max?: number }): DataRouter</td><td class="desc">Record the stream into a bounded ring for time travel (v4): a time `window` in ms and/or a `max` delta count.</td></tr>
+          <tr><td class="name">scrubTo</td><td class="type">(target: number, opts?: { by?: 'seq' | 'time' }): DataRouter</td><td class="desc">Scrub the attached grids to a past seq or timestamp (v4).</td></tr>
+          <tr><td class="name">replay</td><td class="type">(from: number, to: number, opts?: { speed?: number; by?: 'seq' | 'time' }): Promise&lt;void&gt;</td><td class="desc">Replay a buffered range step by step (v4); resolves when it completes or is superseded.</td></tr>
+          <tr><td class="name">pause</td><td class="type">(): DataRouter</td><td class="desc">Pause an in-flight replay at the current step (v4); a no-op when nothing is replaying.</td></tr>
+          <tr><td class="name">resume</td><td class="type">(): DataRouter</td><td class="desc">Resume a paused replay from where it stopped (v4); a no-op when not paused.</td></tr>
+          <tr><td class="name">live</td><td class="type">(): DataRouter</td><td class="desc">Return to live (v4): rebuild the head from the base plus every buffered delta.</td></tr>
+          <tr><td class="name">traveling</td><td class="type">boolean</td><td class="desc">Whether the grids are currently showing a reconstructed past (v4). <small>(read-only)</small></td></tr>
+          <tr><td class="name">buffered</td><td class="type">number</td><td class="desc">How many deltas the bounded buffer currently holds (v4). <small>(read-only)</small></td></tr>
+          <tr><td class="name">broadcast</td><td class="type">(opts: { channel: string }): DataRouter</td><td class="desc">Mirror the ordered, de-duplicated deltas to other tabs over a BroadcastChannel (v6), with no echo loop.</td></tr>
+          <tr><td class="name">broadcasting</td><td class="type">boolean</td><td class="desc">Whether the router is mirroring to a BroadcastChannel (v6). <small>(read-only)</small></td></tr>
+          <tr><td class="name">query</td><td class="type">(adapter: RouterQueryAdapter, request?: Record&lt;string, unknown&gt;): Promise&lt;DataRouter&gt;</td><td class="desc">Source the router from a pushdown adapter (v7): each `where` route is planned against the adapter's capabilities.</td></tr>
+          <tr><td class="name">lastQueryPlan</td><td class="type">(): RouterQueryPlanEntry[] | null</td><td class="desc">The pushed/residual split of the last `query()` (v7), per fetch, or null before any.</td></tr>
           <tr><td class="name">destroy</td><td class="type">(): void</td><td class="desc">Detach every grid and drop every link (the host destroys the grids themselves).</td></tr>
         </tbody>
       </table>
     </div>
+    <h3 id="type-DataRouterOptions">DataRouterOptions</h3>
+    <p class="section-note">Options for `createDataRouter`. `key` is the partition property or `fn(row)`; optional, since a router whose routes all use `fn(row)` predicates never reads it. `rowKey` is the identity within a grid; `overlap` fans a record to every matching route (default: first match wins); `onUnrouted` receives what matched no route — the row on `load` and `query`, the whole delta on `apply`; `selectionDebounce` is the ms debounce for cross-grid selection refilters (default 16; `0` is synchronous). `seq` names the per-record version that orders and de-duplicates a feed (v3), `dedupe` (default on with `seq`) drops stale and duplicate deltas; `batch` (ms, or `{ intervalMs }`) and `coalesce` buffer a high-frequency feed for `push`; `time` reads a row's timestamp for time-domain scrubbing and `now` overrides the clock (v4); `config` is a declarative routing graph applied at construction (v5); `onWrite` and `onConflict` are the defaults for every writable route (v8); `metricsInterval` is the ms between `metrics` emits (default 1000; `0` disables the timer) (v10).</p>
+    <div class="table-wrap">
+      <table>
+        <thead><tr><th>Member</th><th>Type</th><th>Description</th></tr></thead>
+        <tbody>
+          <tr><td class="name">key</td><td class="type">RouterKey</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">rowKey</td><td class="type">RouterKey</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">overlap</td><td class="type">boolean</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">onUnrouted</td><td class="type">(item: RouterRecord | RouterDelta) =&gt; void</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">selectionDebounce</td><td class="type">number</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">seq</td><td class="type">RouterKey</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">dedupe</td><td class="type">boolean</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">batch</td><td class="type">number | { intervalMs: number }</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">coalesce</td><td class="type">boolean</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">time</td><td class="type">RouterKey</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">now</td><td class="type">() =&gt; number</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">config</td><td class="type">RouterConfig</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">onWrite</td><td class="type">(change: RouterWrite, ctx: { route: unknown; source: unknown }) =&gt; unknown</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">onConflict</td><td class="type">(change: RouterWrite, ctx: { serverRow: RouterRecord }) =&gt; void</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">metricsInterval</td><td class="type">number</td><td class="desc"><small>(optional)</small></td></tr>
+        </tbody>
+      </table>
+    </div>
     <h3 id="type-DatasetColumnDifference">DatasetColumnDifference</h3>
     <div class="table-wrap">
       <table>
@@ -12589,15 +12831,133 @@ return `next ${p.mean.toFixed(1)}; r2 ${f.r2.toFixed(1)}; band ${p.upper - p.low
       </table>
     </div>
     <h3 id="type-RouteOptions">RouteOptions</h3>
-    <p class="section-note">Per-route reshaping options (v3, BACKLOG-0000887): `transform` maps/renames/ derives each row before the grid sees it; `filter` gives the grid only the rows it admits; `sort` (a comparator or `{ key, dir }`) orders what the grid receives. `rowKey` overrides the router default. All optional.</p>
+    <p class="section-note">Per-route options, shared by `attach`, `attachDefault` and `subscribe`. `rowKey` overrides the router default for this route. `transform` reshapes each row before the viewer sees it; `filter` admits a subset; `sort` orders what the viewer receives; `rollup` summarises the slice (v3). A `transform` or `rollup` route is derived and cannot be `writable`. `where` is read only by `query()` (v7). `writable` routes the grid's committed edits to `onWrite`, reverting on reject, with `onConflict` for a last- write-wins conflict (v8); both default to the router's own. `label` names the route in metrics and the devtools panel; `backpressure` throttles its refresh under load (v13).</p>
     <div class="table-wrap">
       <table>
         <thead><tr><th>Member</th><th>Type</th><th>Description</th></tr></thead>
         <tbody>
-          <tr><td class="name">rowKey</td><td class="type">(string | ((row: RouterRecord) =&gt; unknown))</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">rowKey</td><td class="type">RouterKey</td><td class="desc"><small>(optional)</small></td></tr>
           <tr><td class="name">transform</td><td class="type">(row: RouterRecord) =&gt; RouterRecord</td><td class="desc"><small>(optional)</small></td></tr>
           <tr><td class="name">filter</td><td class="type">(row: RouterRecord) =&gt; boolean</td><td class="desc"><small>(optional)</small></td></tr>
-          <tr><td class="name">sort</td><td class="type">(((a: RouterRecord, b: RouterRecord) =&gt; number) | { key: string; dir?: 'asc' | 'desc' })</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">sort</td><td class="type">RouteSort</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">rollup</td><td class="type">RouteRollup</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">where</td><td class="type">RouteWhere</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">writable</td><td class="type">boolean</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">onWrite</td><td class="type">(change: RouterWrite, ctx: { route: unknown; source: unknown }) =&gt; unknown</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">onConflict</td><td class="type">(change: RouterWrite, ctx: { serverRow: RouterRecord }) =&gt; void</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">label</td><td class="type">string</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">backpressure</td><td class="type">RouteBackpressure</td><td class="desc"><small>(optional)</small></td></tr>
+        </tbody>
+      </table>
+    </div>
+    <h3 id="type-RouterConfig">RouterConfig</h3>
+    <p class="section-note">A declarative routing graph (v5, BACKLOG-0000910): the same routes, links, relationship edges and buffer the imperative calls would make, as one data spec. Desugars to those calls and composes with them.</p>
+    <div class="table-wrap">
+      <table>
+        <thead><tr><th>Member</th><th>Type</th><th>Description</th></tr></thead>
+        <tbody>
+          <tr><td class="name">routes</td><td class="type">Record&lt;string, unknown&gt;[]</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">links</td><td class="type">{ from: unknown; to: unknown; on?: SelectionRelation; relation?: SelectionRelation }[]</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">relate</td><td class="type">RouterEdge[]</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">buffer</td><td class="type">{ window?: number; max?: number }</td><td class="desc"><small>(optional)</small></td></tr>
+        </tbody>
+      </table>
+    </div>
+    <h3 id="type-RouterJoin">RouterJoin</h3>
+    <p class="section-note">A fan-in source's lookup join (v11): `from` is the lookup source's id; `localKey` (alias `on`) reads the joining value off this source's row; `foreignKey` (alias `fromKey`) reads it off the lookup row, defaulting to a string `localKey`; `fields` (alias `select`) picks the lookup fields to carry — a list, a rename map, or a function of both rows; `missing` says what to do while the lookup row has not arrived: `hold` the row back, `passthrough` it unjoined, or fill the fields with `null`.</p>
+    <div class="table-wrap">
+      <table>
+        <thead><tr><th>Member</th><th>Type</th><th>Description</th></tr></thead>
+        <tbody>
+          <tr><td class="name">from</td><td class="type">string</td><td class="desc"></td></tr>
+          <tr><td class="name">localKey</td><td class="type">RouterKey</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">on</td><td class="type">RouterKey</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">foreignKey</td><td class="type">RouterKey</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">fromKey</td><td class="type">RouterKey</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">fields</td><td class="type">string[] | Record&lt;string, string&gt; | ((lookupRow: RouterRecord | null, leftRow: RouterRecord) =&gt; RouterRecord)</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">select</td><td class="type">string[] | Record&lt;string, string&gt; | ((lookupRow: RouterRecord | null, leftRow: RouterRecord) =&gt; RouterRecord)</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">missing</td><td class="type">'hold' | 'passthrough' | 'null'</td><td class="desc"><small>(optional)</small></td></tr>
+        </tbody>
+      </table>
+    </div>
+    <h3 id="type-RouterMetrics">RouterMetrics</h3>
+    <p class="section-note">A `metrics()` snapshot (v10): per-route and per-source counts and throughput (rows/sec since the previous read), and the global unrouted, dropped (duplicate), buffered and lag figures.</p>
+    <div class="table-wrap">
+      <table>
+        <thead><tr><th>Member</th><th>Type</th><th>Description</th></tr></thead>
+        <tbody>
+          <tr><td class="name">routes</td><td class="type">RouterRouteMetrics[]</td><td class="desc"></td></tr>
+          <tr><td class="name">sources</td><td class="type">RouterSourceMetrics[]</td><td class="desc"></td></tr>
+          <tr><td class="name">unrouted</td><td class="type">number</td><td class="desc"></td></tr>
+          <tr><td class="name">dropped</td><td class="type">number</td><td class="desc"></td></tr>
+          <tr><td class="name">buffered</td><td class="type">number</td><td class="desc"></td></tr>
+          <tr><td class="name">lag</td><td class="type">number</td><td class="desc"></td></tr>
+          <tr><td class="name">throughput</td><td class="type">number</td><td class="desc"></td></tr>
+        </tbody>
+      </table>
+    </div>
+    <h3 id="type-RouteRollup">RouteRollup</h3>
+    <p class="section-note">A rollup route's summary spec (v3): one summary row per `groupBy` group, each `aggregate` a named reducer over the group's rows or a `{ op, field }` shorthand (`sum`, `avg`, `min`, `max`, `count`).</p>
+    <div class="table-wrap">
+      <table>
+        <thead><tr><th>Member</th><th>Type</th><th>Description</th></tr></thead>
+        <tbody>
+          <tr><td class="name">groupBy</td><td class="type">RouterKey | RouterKey[]</td><td class="desc"></td></tr>
+          <tr><td class="name">aggregate</td><td class="type">Record&lt;string, ((rows: RouterRecord[]) =&gt; unknown) | { op: string; field?: string }&gt;</td><td class="desc"><small>(optional)</small></td></tr>
+        </tbody>
+      </table>
+    </div>
+    <h3 id="type-RouterPersistOptions">RouterPersistOptions</h3>
+    <p class="section-note">Durable persistence options (v12): `key` names the snapshot, `debounce` (ms) coalesces writes, `storage` is a `{ get, set }` pair of your own, or `indexedDB` / `dbName` / `storeName` select the browser store.</p>
+    <div class="table-wrap">
+      <table>
+        <thead><tr><th>Member</th><th>Type</th><th>Description</th></tr></thead>
+        <tbody>
+          <tr><td class="name">key</td><td class="type">string</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">debounce</td><td class="type">number</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">storage</td><td class="type">{ get: (key: string) =&gt; Promise&lt;unknown&gt;; set: (key: string, value: unknown) =&gt; Promise&lt;void&gt; }</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">indexedDB</td><td class="type">unknown</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">dbName</td><td class="type">string</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">storeName</td><td class="type">string</td><td class="desc"><small>(optional)</small></td></tr>
+        </tbody>
+      </table>
+    </div>
+    <h3 id="type-RouterQueryAdapter">RouterQueryAdapter</h3>
+    <p class="section-note">A pushdown adapter `query()` can source the router from (v7): anything with an `execute(query, request)` returning rows, and optional `capabilities` the planner consults to decide what it may push down.</p>
+    <div class="table-wrap">
+      <table>
+        <thead><tr><th>Member</th><th>Type</th><th>Description</th></tr></thead>
+        <tbody>
+          <tr><td class="name">capabilities</td><td class="type">Record&lt;string, unknown&gt;</td><td class="desc"><small>(optional)</small></td></tr>
+          <tr><td class="name">execute</td><td class="type">(query: Record&lt;string, unknown&gt;, request?: Record&lt;string, unknown&gt;) =&gt; Promise&lt;{ rows: RouterRecord[]; total?: number }&gt;</td><td class="desc"></td></tr>
+        </tbody>
+      </table>
+    </div>
+    <h3 id="type-RouterRouteMetrics">RouterRouteMetrics</h3>
+    <p class="section-note">One route's figures in a `metrics()` snapshot (v10).</p>
+    <div class="table-wrap">
+      <table>
+        <thead><tr><th>Member</th><th>Type</th><th>Description</th></tr></thead>
+        <tbody>
+          <tr><td class="name">label</td><td class="type">string | null</td><td class="desc"></td></tr>
+          <tr><td class="name">rows</td><td class="type">number</td><td class="desc"></td></tr>
+          <tr><td class="name">shown</td><td class="type">number</td><td class="desc"></td></tr>
+          <tr><td class="name">throughput</td><td class="type">number</td><td class="desc"></td></tr>
+        </tbody>
+      </table>
+    </div>
+    <h3 id="type-RouterSourceHandle">RouterSourceHandle</h3>
+    <p class="section-note">The handle `addSource` returns for one feed (v9). Its `load` is a per-source snapshot — a keyed diff over this feed's rows only, other feeds untouched; `apply` and `push` take this feed's deltas through the router's ordinary and batched paths; `remove` deletes exactly the rows it holds and unregisters it, returning the router.</p>
+    <div class="table-wrap">
+      <table>
+        <thead><tr><th>Member</th><th>Type</th><th>Description</th></tr></thead>
+        <tbody>
+          <tr><td class="name">id</td><td class="type">string</td><td class="desc">The source id. <small>(read-only)</small></td></tr>
+          <tr><td class="name">size</td><td class="type">number</td><td class="desc">How many rows this source currently holds live. <small>(read-only)</small></td></tr>
+          <tr><td class="name">load</td><td class="type">(rows: RouterRecord[]): RouterSourceHandle</td><td class="desc">Apply a per-source snapshot: upsert its current rows, delete the ones it no longer has.</td></tr>
+          <tr><td class="name">apply</td><td class="type">(deltas: RouterDelta[]): RouterSourceHandle</td><td class="desc">Apply per-source deltas through the router's ordinary apply path.</td></tr>
+          <tr><td class="name">push</td><td class="type">(delta: RouterDelta | RouterDelta[]): RouterSourceHandle</td><td class="desc">Enqueue per-source deltas through the router's stream path (batching honoured).</td></tr>
+          <tr><td class="name">remove</td><td class="type">(): DataRouter</td><td class="desc">Remove this source: delete exactly the rows it holds from every route, then unregister it.</td></tr>
         </tbody>
       </table>
     </div>
@@ -13444,7 +13804,7 @@ return `next ${p.mean.toFixed(1)}; r2 ${f.r2.toFixed(1)}; band ${p.upper - p.low
 <!-- END GENERATED TYPE REFERENCE -->
 
     <footer>
-      Lattice Grid 1.63.1 · Copyright © 2026 TOCLOCO Inc. All rights reserved.
+      Lattice Grid 1.63.3 · Copyright © 2026 TOCLOCO Inc. All rights reserved.
       This document describes the behaviour of the shipped library. Where this guide and the code
       disagree, the code wins: please <a href="https://www.latticegrid.dev">tell us</a>.
     </footer>