@toclocoinc/lattice-grid 1.67.0 → 1.68.1

package/modules/data-router.d.ts

@@ -1,5 +1,5 @@
 /*!
- * Lattice Grid 1.67.0, data-router module type declarations
+ * Lattice Grid 1.68.1, data-router module type declarations
  * Copyright (c) 2026 TOCLOCO Inc. All rights reserved.
  * https://latticegrid.dev
  */
@@ -53,7 +53,16 @@ type RouteWhere = Record<string, unknown>;
  * shorthand (`sum`, `avg`, `min`, `max`, `count`).
  */
 interface RouteRollup {
+  /**
+   * What identifies a group: a property name, a `fn(row)`, or a list of either for a
+   * composite. Named properties are carried onto the summary row.
+   */
   groupBy: RouterKey | RouterKey[];
+  /**
+   * The summary fields, each a reducer over the group's rows: a function handed the rows,
+   * or `{ op, field }` for `count`, `sum`, `avg`, `min` or `max` over the numeric values
+   * of `field`. `avg` over no numeric values is 0; `min` and `max` are undefined.
+   */
   aggregate?: Record<string, ((rows: RouterRecord[]) => unknown) | { op: string; field?: string }>;
 }
 
@@ -81,16 +90,68 @@ type RouterWrite = Record<string, unknown>;
  * refresh under load (v13).
  */
 interface RouteOptions {
+  /**
+   * What identifies a row on this route — a field name or a `fn(row)` — overriding the
+   * router's own `rowKey`.
+   */
   rowKey?: RouterKey;
+  /**
+   * Reshapes each row before the viewer sees it. The row's identity is still taken from
+   * the original, so the keyed diff is unaffected; a transform route is derived and its
+   * edits are always reverted.
+   */
   transform?: (row: RouterRecord) => RouterRecord;
+  /**
+   * Admits a subset of the route's partition to the viewer. It runs on the original row,
+   * before any transform and before a rollup groups them.
+   */
   filter?: (row: RouterRecord) => boolean;
+  /**
+   * Orders the rows the viewer receives — a comparator, or `{ key, dir }`. A viewer with
+   * a sort model of its own still governs the final display; for a rollup route this
+   * sorts the summary rows.
+   */
   sort?: RouteSort;
+  /**
+   * Feeds the viewer one summary row per group instead of the raw rows. A rollup route is
+   * derived and its edits are always reverted.
+   */
   rollup?: RouteRollup;
+  /**
+   * A filter-wire condition for this route's slice, read only by `query()`: the pushable
+   * part goes to the engine and the rest is finished in the browser. It has no effect on
+   * rows arriving through `load`, `apply` or `push`.
+   */
   where?: RouteWhere;
+  /**
+   * Captures the viewer's committed edits and routes them to `onWrite` instead of leaving
+   * them local. Defaults to false; on a derived (rollup or transform) route the edit is
+   * reverted with a warning whatever this says.
+   */
   writable?: boolean;
+  /**
+   * Receives each captured edit as `{ key, colId, value, before, row }`. Return `false`
+   * or `{ ok: false }` (or reject, or throw) to revert the cell, `{ conflict, row }` to
+   * fire `onConflict` and take the winning row, anything else to accept; a promise is
+   * awaited with the optimistic value standing. Overrides the router-wide handler. The
+   * context's `route` is the viewer; `source` is always null.
+   */
   onWrite?: (change: RouterWrite, ctx: { route: unknown; source: unknown }) => unknown;
+  /**
+   * Called when `onWrite` returns a `conflict`, with the server's row, so the host can
+   * tell the user. The router itself is last-write-wins: the returned row (or the
+   * optimistic one) re-enters regardless. Overrides the router-wide handler.
+   */
   onConflict?: (change: RouterWrite, ctx: { serverRow: RouterRecord }) => void;
+  /**
+   * Names this route in `metrics()` and the devtools panel. Defaults to null — the
+   * default route reports `default`.
+   */
   label?: string;
+  /**
+   * Throttles how often this route's viewer is refreshed under load. Omitted, every
+   * change repaints the viewer at once.
+   */
   backpressure?: RouteBackpressure;
 }
 
@@ -120,9 +181,26 @@ interface RouterEdge { from: unknown; to: unknown; on?: SelectionRelation; relat
  * spec. Desugars to those calls and composes with them.
  */
 interface RouterConfig {
+  /**
+   * The routes to open, each `{ grid, when, ...routeOptions }`, or `{ default: grid }`,
+   * or `{ subscribe: handler, when }`, or `{ alert: handler, when, condition }`. `when`
+   * is the partition value or predicate `attach` takes.
+   */
   routes?: Record<string, unknown>[];
+  /**
+   * Selection links to make, each naming the `from` and `to` grids and the relation as
+   * `on` (or `relation`) — the arguments of `link()`.
+   */
   links?: { from: unknown; to: unknown; on?: SelectionRelation; relation?: SelectionRelation }[];
+  /**
+   * Relationship-graph edges to register, as `relate()` takes them; an edge may be
+   * `mutual` to work in both directions.
+   */
   relate?: RouterEdge[];
+  /**
+   * Turns on the time-travel buffer, bounded by `window` (ms of feed time) and/or `max`
+   * deltas. An empty object applies a default cap of 10,000 deltas and warns.
+   */
   buffer?: { window?: number; max?: number };
 }
 
@@ -136,13 +214,37 @@ interface RouterConfig {
  * `passthrough` it unjoined, or fill the fields with `null`.
  */
 interface RouterJoin {
+  /** The id of the registered source holding the lookup rows. */
   from: string;
+  /**
+   * Reads the joining value off this source's row — a field name or a `fn(row)`.
+   * Required: without it (or `on`) the join is ignored with a warning.
+   */
   localKey?: RouterKey;
+  /** An alias for `localKey`, read when `localKey` is absent. */
   on?: RouterKey;
+  /**
+   * Reads the joining value off the lookup row — a field name or a `fn(row)`. Defaults to
+   * a string `localKey`; with a function `localKey` and no `foreignKey`, the join is
+   * ignored with a warning.
+   */
   foreignKey?: RouterKey;
+  /** An alias for `foreignKey`, read when `foreignKey` is absent. */
   fromKey?: RouterKey;
+  /**
+   * Which lookup fields to carry onto the row: a list of names, a `{ from: to }` rename
+   * map, or a `fn(lookupRow, leftRow)` returning the fields to merge. With none, rows
+   * pass through unenriched and the router warns.
+   */
   fields?: string[] | Record<string, string> | ((lookupRow: RouterRecord | null, leftRow: RouterRecord) => RouterRecord);
+  /** An alias for `fields`, read when `fields` is absent. */
   select?: string[] | Record<string, string> | ((lookupRow: RouterRecord | null, leftRow: RouterRecord) => RouterRecord);
+  /**
+   * What happens while the lookup row has not arrived: `hold` keeps the row from viewers
+   * until it does, `passthrough` sends it unenriched, `null` fills the declared fields
+   * with null. Defaults to `passthrough`, which an unrecognised value also falls back to,
+   * with a warning.
+   */
   missing?: 'hold' | 'passthrough' | 'null';
 }
 
@@ -178,9 +280,19 @@ interface RouterSourceHandle {
 
 /** One route's figures in a `metrics()` snapshot (v10). */
 interface RouterRouteMetrics {
+  /** The route's `label`, or `default` for the default route, or null when it has neither. */
   label: string | null;
+  /** How many rows the route's partition holds, before its filter, links and rollup. */
   rows: number;
+  /**
+   * How many rows the viewer currently holds — the partition after the route's filter,
+   * any cross-grid links, and a rollup's grouping.
+   */
   shown: number;
+  /**
+   * Rows routed to this route per second since the previous metrics read. The first read
+   * of a route reports 0, having no interval to measure.
+   */
   throughput: number;
   [key: string]: unknown;
 }
@@ -194,12 +306,31 @@ interface RouterSourceMetrics { id: string; rows: number; throughput: number; [k
  * dropped (duplicate), buffered and lag figures.
  */
 interface RouterMetrics {
+  /** One entry per route, in attach order, the default route last. */
   routes: RouterRouteMetrics[];
+  /** One entry per registered fan-in source. */
   sources: RouterSourceMetrics[];
+  /**
+   * How many arriving records matched no route (and went to the default sink, if there is
+   * one). Counted since the last `load()` or `query()`, each of which resets it.
+   */
   unrouted: number;
+  /**
+   * How many deltas the dedupe gate discarded as stale or already seen, cumulative for
+   * the router's life.
+   */
   dropped: number;
+  /** How many deltas the time-travel ring currently holds. Zero when not buffering. */
   buffered: number;
+  /**
+   * How many buffered deltas the viewers are behind the live head, in deltas. Nonzero
+   * only while scrubbed into the past.
+   */
   lag: number;
+  /**
+   * Rows routed across every route per second since the previous metrics read; 0 on the
+   * first read.
+   */
   throughput: number;
 }
 
@@ -220,7 +351,17 @@ interface RouterDevtoolsPanel { refresh(): void; destroy(): void }
  * `capabilities` the planner consults to decide what it may push down.
  */
 interface RouterQueryAdapter {
+  /**
+   * What the engine can evaluate, as the pushdown capability model reads it; the planner
+   * consults it to decide how much of a filter to push down. Omitted, the conservative
+   * defaults apply.
+   */
   capabilities?: Record<string, unknown>;
+  /**
+   * Runs one planned query and resolves to its rows (`total` optional and unused by the
+   * router). Called once per `where` route, plus once for the base query shared by the
+   * routes without one.
+   */
   execute: (query: Record<string, unknown>, request?: Record<string, unknown>) => Promise<{ rows: RouterRecord[]; total?: number }>;
 }
 
@@ -230,11 +371,24 @@ interface RouterQueryAdapter {
  * `indexedDB` / `dbName` / `storeName` select the browser store.
  */
 interface RouterPersistOptions {
+  /** The record the snapshot is written under. Defaults to `lattice-router`. */
   key?: string;
+  /**
+   * How long to wait after a change before writing, in ms, so a burst costs one write.
+   * Defaults to 250; zero or less writes on every change.
+   */
   debounce?: number;
+  /** An async key/value backend of your own. Given one, IndexedDB is never opened. */
   storage?: { get: (key: string) => Promise<unknown>; set: (key: string, value: unknown) => Promise<void> };
+  /**
+   * The `IDBFactory` to open the database with. Defaults to the global `indexedDB`; where
+   * none is reachable the router warns once and keeps running in memory with no durable
+   * resume.
+   */
   indexedDB?: unknown;
+  /** The IndexedDB database to open. Defaults to `lattice-router`. */
   dbName?: string;
+  /** The object store inside the database. Defaults to `snapshots`. */
   storeName?: string;
 }
 
@@ -356,20 +510,92 @@ interface DataRouter {
  * disables the timer) (v10).
  */
 interface DataRouterOptions {
+  /**
+   * How a record says which partition it belongs to: a property name, or a
+   * function of the record. This is the one thing the router needs to route.
+   */
   key?: RouterKey;
+  /**
+   * A record's identity within a route — a property name or a function. It
+   * is what makes an update an update rather than a second row, and what
+   * lets a record whose partition changed *move* between routes instead of
+   * being duplicated. Defaults to the record's `rowKey` property.
+   */
   rowKey?: RouterKey;
+  /**
+   * Send a record to every route whose predicate it matches, rather than to
+   * the first one only. Off by default.
+   */
   overlap?: boolean;
+  /**
+   * Called with each record that matched no route. They are never silently
+   * dropped: they are counted as well, and go to the default route when one
+   * is attached.
+   */
   onUnrouted?: (item: RouterRecord | RouterDelta) => void;
+  /**
+   * How long, in milliseconds, to wait before re-filtering linked grids
+   * after a selection changes. 16 by default; `0` re-filters synchronously.
+   */
   selectionDebounce?: number;
+  /**
+   * Where a record carries its version or sequence number — a property name
+   * or a function. Supplying it lets the router apply a feed in order and,
+   * unless `dedupe` says otherwise, drop a delta it has already seen.
+   */
   seq?: RouterKey;
+  /**
+   * Whether to drop a record whose sequence number is not newer than the
+   * last one applied for that identity. On whenever `seq` is given;
+   * meaningless without it.
+   */
   dedupe?: boolean;
+  /**
+   * Buffer incoming records and apply them on an interval rather than one at
+   * a time: a number of milliseconds, or `{ intervalMs }`. Batching also
+   * turns coalescing on.
+   */
   batch?: number | { intervalMs: number };
+  /**
+   * Settle repeated updates to the same identity inside one batch into a
+   * single apply, so a fast feed costs one update per row rather than one
+   * per message.
+   */
   coalesce?: boolean;
+  /**
+   * Where a record carries its timestamp — a property name or a function. It
+   * is the axis `scrubTo` and `replay` move along when time-travel is
+   * buffering.
+   */
   time?: RouterKey;
+  /**
+   * The clock the router stamps and expires by. `Date.now` unless you supply
+   * one, which is how a test drives time without faking the global.
+   */
   now?: () => number;
+  /**
+   * A whole router described as data — routes, links, buffering — applied
+   * through `configure()` as soon as the router is built.
+   */
   config?: RouterConfig;
+  /**
+   * Persist an edit committed in any route attached `{ writable: true }`
+   * that names no handler of its own. Return, or resolve, falsely to revert
+   * the edit; a route with neither this nor its own handler leaves the edit
+   * in place unpersisted and warns.
+   */
   onWrite?: (change: RouterWrite, ctx: { route: unknown; source: unknown }) => unknown;
+  /**
+   * Called when a write comes back reporting a conflict, with the server's
+   * version of the row. The router itself is last-write-wins; this is where
+   * a host resolves it differently.
+   */
   onConflict?: (change: RouterWrite, ctx: { serverRow: RouterRecord }) => void;
+  /**
+   * How often, in milliseconds, to emit the `metrics` event. 1000 by
+   * default; `0` stops the timer and leaves `metrics()` to be read on
+   * demand.
+   */
   metricsInterval?: number;
 }
 

package/modules/data-router.esm.min.js

@@ -1,5 +1,5 @@
 /*!
- * Lattice Grid 1.67.0, data-router module
+ * Lattice Grid 1.68.1, data-router module
  * Copyright (c) 2026 TOCLOCO Inc. All rights reserved.
  * https://latticegrid.dev
  */
@@ -52,12 +52,12 @@ Object.defineProperty(__exports,"frameBatched",{enumerable:true,get:function(){r
 Object.defineProperty(__exports,"settleDebounce",{enumerable:true,get:function(){return settleDebounce;}});
 Object.defineProperty(__exports,"whenIdle",{enumerable:true,get:function(){return whenIdle;}});
 Object.defineProperty(__exports,"uid",{enumerable:true,get:function(){return uid;}});
-const STAMPED_VERSION="1.67.0";
+const STAMPED_VERSION="1.68.1";
 async function resolveVersion(){
 if(STAMPED_VERSION!=='0.0.0-source')return STAMPED_VERSION;
 return STAMPED_VERSION;
 }
-const VERSION="1.67.0";
+const VERSION="1.68.1";
 const warned=new Set();
 const WARNED_LIMIT=2000;
 function rememberWarned(key){
@@ -1544,6 +1544,180 @@ grandTotals:()=>lastGrand,
 };
 }
 });
+__def("packages/core/src/model/rowkey.js",function(__exports,__req){
+'use strict';
+Object.defineProperty(__exports,"KEY_DEPENDENT_FEATURES",{enumerable:true,get:function(){return KEY_DEPENDENT_FEATURES;}});
+Object.defineProperty(__exports,"compositeKey",{enumerable:true,get:function(){return compositeKey;}});
+Object.defineProperty(__exports,"createRowKey",{enumerable:true,get:function(){return createRowKey;}});
+Object.defineProperty(__exports,"warnMissingKeys",{enumerable:true,get:function(){return warnMissingKeys;}});
+Object.defineProperty(__exports,"groupPathKey",{enumerable:true,get:function(){return groupPathKey;}});
+Object.defineProperty(__exports,"splitPathKey",{enumerable:true,get:function(){return splitPathKey;}});
+const __m0=__req("packages/core/src/internal/util.js");
+const warnOnce=__m0["warnOnce"];
+const pathGetter=__m0["pathGetter"];
+const isFunction=__m0["isFunction"];
+const isBlank=__m0["isBlank"];
+const KEY_DEPENDENT_FEATURES=[
+'changes (rows.apply / rows.queue)',
+'streaming dedupe',
+'selection persistence',
+'remote reload',
+'cell comments',
+];
+const SEP='\u001f';
+function part(value){
+if(value===null)return'\u0000n';
+if(value===undefined)return'\u0000u';
+const t=typeof value;
+if(t==='string')return value;
+if(t==='number'||t==='bigint'||t==='boolean')return String(value);
+if(value instanceof Date)return`\u0000d${value.getTime()}`;
+try{
+return`\u0000o${JSON.stringify(value)}`;
+}catch{
+return'\u0000o?';
+}
+}
+function compositeKey(parts){
+if(parts.length===1)return part(parts[0]);
+let out='';
+for(let i=0;i<parts.length;i++){
+if(i)out+=SEP;
+out+=part(parts[i]);
+}
+return out;
+}
+function createRowKey(spec,opts={}){
+const warn=opts.warn!==false;
+if(isFunction(spec)){
+const fn=(spec);
+return{
+stable:true,
+fields:[],
+disabled:[],
+key(data,index){
+try{
+const value=fn(data);
+return Array.isArray(value)?compositeKey(value):part(value);
+}catch(err){
+warnOnce('rowKey.throw','rowKey function threw; falling back to index identity for the affected rows.',err);
+return`#${index??-1}`;
+}
+},
+keyEmpty(data){
+try{
+const value=fn(data);
+return Array.isArray(value)?value.length===0||value.some(isBlank):isBlank(value);
+}catch{
+return false;
+}
+},
+missingFields(){return[];},
+};
+}
+if(Array.isArray(spec)&&spec.length>0){
+const fields=spec.filter((f)=>typeof f==='string');
+const getters=fields.map((f)=>pathGetter(f));
+const n=getters.length;
+return{
+stable:true,
+fields,
+disabled:[],
+key(data){
+const parts=new Array(n);
+for(let i=0;i<n;i++)parts[i]=getters[i](data);
+return compositeKey(parts);
+},
+keyEmpty(data){
+for(let i=0;i<n;i++)if(isBlank(getters[i](data)))return true;
+return false;
+},
+missingFields(data){
+const out=[];
+for(let i=0;i<n;i++)if(isBlank(getters[i](data)))out.push(fields[i]);
+return out;
+},
+};
+}
+if(typeof spec==='string'&&spec.length>0){
+const get=pathGetter(spec);
+return{
+stable:true,
+fields:[spec],
+disabled:[],
+key(data){
+return part(get(data));
+},
+keyEmpty(data){
+return isBlank(get(data));
+},
+missingFields(data){
+return isBlank(get(data))?[spec]:[];
+},
+};
+}
+if(warn){
+warnOnce(
+'rowKey.missing',
+`no rowKey configured, so rows are identified by object identity. This disables: ${KEY_DEPENDENT_FEATURES.join(', ')}. Set rowKey to a field name, an array of field names, or a function.`,
+);
+}
+return{
+stable:false,
+fields:[],
+disabled:KEY_DEPENDENT_FEATURES.slice(),
+key(data,index){
+if(data===null||typeof data!=='object'){
+return`#${index??0}:${String(data)}`;
+}
+let assigned=autoKeys.get(data);
+if(assigned===undefined){
+assigned=`#${autoKeySeq++}`;
+autoKeys.set(data,assigned);
+}
+return assigned;
+},
+};
+}
+const autoKeys=new WeakMap();
+let autoKeySeq=0;
+function warnMissingKeys(resolver,rows){
+if(!resolver||resolver.stable===false||!isFunction(resolver.keyEmpty))return;
+if(!Array.isArray(rows)||rows.length===0)return;
+let missing=0;
+let sampleFields=null;
+let sampleData;
+for(let i=0;i<rows.length;i++){
+const data=rows[i];
+if(!resolver.keyEmpty(data))continue;
+missing++;
+if(sampleFields===null){
+sampleFields=isFunction(resolver.missingFields)?resolver.missingFields(data):[];
+sampleData=data;
+}
+}
+if(missing===0)return;
+const dedupFields=resolver.fields.length?resolver.fields.join(','):'(function)';
+const named=sampleFields&&sampleFields.length
+?sampleFields.join(', ')
+:(resolver.fields.length?resolver.fields.join(', '):'the rowKey function');
+const present=sampleData!==null&&typeof sampleData==='object'
+?(Object.keys((sampleData)).join(', ')||'(no fields)')
+:String(sampleData);
+warnOnce(
+`rowKey.emptyValue:${dedupFields}`,
+`rowKey ${named} is missing on ${missing} of ${rows.length} rows; the first such row has: ${present}. `
++'Rows without a key value collapse onto one key, so selection, edits and rows.apply updates land on '
++'whichever row now shares it. Set rowKey to a field present on every row, or fix the source data.',
+);
+}
+function groupPathKey(path){
+return compositeKey(path);
+}
+function splitPathKey(key){
+return key.split(SEP);
+}
+});
 __def("packages/modules/data-router/devtools.js",function(__exports,__req){
 'use strict';
 Object.defineProperty(__exports,"mountRouterDevtools",{enumerable:true,get:function(){return mountRouterDevtools;}});
@@ -1629,8 +1803,10 @@ const warnOnce=__m0["warnOnce"];
 const __m1=__req("packages/core/src/source/pushdown.js");
 const planQuery=__m1["planQuery"];
 const capabilitiesOf=__m1["capabilitiesOf"];
-const __m2=__req("packages/modules/data-router/devtools.js");
-const mountRouterDevtools=__m2["mountRouterDevtools"];
+const __m2=__req("packages/core/src/model/rowkey.js");
+const compositeKey=__m2["compositeKey"];
+const __m3=__req("packages/modules/data-router/devtools.js");
+const mountRouterDevtools=__m3["mountRouterDevtools"];
 function resolver(spec,fallback){
 if(typeof spec==='function')return spec;
 if(typeof spec==='string')return(row)=>row[spec];
@@ -1683,6 +1859,8 @@ const maxLag=(Number.isFinite(spec.maxLag)&&spec.maxLag>=0)?Math.floor(Number(sp
 if(minInterval===0&&sample===1&&maxLag===null)return null;
 return{minInterval,sample,maxLag};
 }
+let routeSeq=0;
+function nextRouteId(){routeSeq+=1;return`r${routeSeq}`;}
 function grouper(groupBy){
 const specs=Array.isArray(groupBy)?groupBy:[groupBy];
 const parts=specs.map((s)=>({name:typeof s==='string'?s:null,get:resolver(s,()=>undefined)}));
@@ -1694,7 +1872,7 @@ const v=part.get(row);
 vals.push(v);
 if(part.name)fields[part.name]=v;
 }
-return{key:vals.map((v)=>String(v)).join('\u0001'),fields};
+return{key:compositeKey(vals),fields};
 };
 }
 function aggregateOne(spec,rows){
@@ -1863,10 +2041,25 @@ return fallbackRoute?[fallbackRoute]:[];
 };
 const applyChange=(route,change)=>{
 if(change.add.length||change.update.length||change.remove.length){
-route.sink(change);
+const result=route.sink(change);
+warnRejectedRemovals(route,result);
 }
 return{added:change.add.length,updated:change.update.length,removed:change.remove.length};
 };
+const warnRejectedRemovals=(route,result)=>{
+const rejected=(result)?.rejected;
+if(!Array.isArray(rejected)||!rejected.length)return;
+const removals=rejected.filter((r)=>r&&r.operation==='remove');
+if(!removals.length)return;
+const name=route.label||`route ${route.routeId}`;
+warnOnce(
+`data-router:remove-rejected:${route.routeId}`,
+`route "${name}" asked its target to remove ${removals.length} row(s) the target does not have`
++` (for example ${JSON.stringify(String(removals[0].id))}). The rows are still on screen.`
++' This is a key mismatch: the key the route derives for a row is not the key the grid derives'
++' for it. Check that the route\'s `rowKey` names the same value as the grid\'s.',
+);
+};
 const passes=(route,row)=>{
 for(const link of links){
 if(link.to!==route.grid)continue;
@@ -1904,7 +2097,9 @@ shown=new Map(summaries.map((s)=>[s.gkey,s.row]));
 let rows=kept;
 if(route.sort)rows=rows.slice().sort(route.sort);
 shown=new Map();
-for(const row of rows)shown.set(String(route.keyOf(row)),route.transform?route.transform(row):row);
+for(const row of rows){
+shown.set(compositeKey([route.keyOf(row)]),route.transform?route.transform(row):row);
+}
 }
 const add=[];
 const update=[];
@@ -2053,6 +2248,7 @@ return()=>{};
 };
 const makeRoute=(grid,match,o)=>({
 grid,
+routeId:nextRouteId(),
 sink:targetSink(grid),
 match,
 keyOf:resolver(assertRowKeySpec(o.rowKey,'routes'),defaultKeyOf),