@toclocoinc/lattice-grid 1.54.0 → 1.56.0

package/lattice-grid.esm.min.js

@@ -1,5 +1,5 @@
 /*!
- * Lattice Grid 1.54.0, core + DOM renderer
+ * Lattice Grid 1.56.0, core + DOM renderer
  * Copyright (c) 2026 TOCLOCO Inc. All rights reserved.
  * https://latticegrid.dev
  */
@@ -52,7 +52,7 @@ 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.54.0";
+const STAMPED_VERSION="1.56.0";
 async function resolveVersion(){
 if(STAMPED_VERSION!=='0.0.0-source')return STAMPED_VERSION;
 try{
@@ -69,7 +69,7 @@ return JSON.parse(text).version||STAMPED_VERSION;
 return STAMPED_VERSION;
 }
 }
-const VERSION="1.54.0";
+const VERSION="1.56.0";
 const warned=new Set();
 const WARNED_LIMIT=2000;
 function rememberWarned(key){
@@ -3233,10 +3233,7 @@ return dateTimeFormatter(o)(ms);
 function matchesDateTime(value){
 if(value instanceof Date)return!Number.isNaN(value.getTime());
 if(typeof value!=='string')return false;
-const head=DATE_HEAD.exec(value.trim());
-if(!head)return false;
-const rest=(head[4]||'').trim();
-if(rest==='')return false;
+if(!DATE_HEAD.test(value.trim()))return false;
 return parseDateTime(value)!==null;
 }
 const DURATION_UNITS=Object.freeze([
@@ -4240,6 +4237,21 @@ other:'Apply {count} held updates',
 'comments.write':'Write a comment',
 'comments.post':'Comment',
 'comments.delete':'Delete',
+'comments.valueMoved':'Written when the value was {was}: it is now {now}.',
+'presence.hidden':{one:'{count} not in view',other:'{count} not in view'},
+'presence.someoneElse':'someone else',
+'a11y.presence.refused':'This cell is being edited by {name}',
+'facets.filter':'{column} distribution filter',
+'header.totalOf':'{total} of {column}',
+'diff.before':'Was: {value}',
+'diff.empty':'(empty)',
+'kanban.columnCards':{one:'{title}, {count} card',other:'{title}, {count} cards'},
+'kanban.laneCards':{
+one:'{lane}, {title}, {count} card',
+other:'{lane}, {title}, {count} cards',
+},
+'gantt.lag':'+{days}d',
+'gantt.lead':'{days}d',
 'timeline.scrub':'Scrub through recent changes',
 'timeline.goLive':'Go live',
 'timeline.returnToPresent':'Return to the present',
@@ -6629,7 +6641,7 @@ const EXTENDED_TYPES=__m3["EXTENDED_TYPES"];
 const __m4=__req("packages/core/src/formula/index.js");
 const evaluateFormula=__m4["evaluateFormula"];
 const looksLikeFormula=__m4["looksLikeFormula"];
-const ISO_DATE=/^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?)?$/;
+const ISO_DATE_ONLY=/^\d{4}-\d{2}-\d{2}$/;
 function isLocalMidnight(d){
 return d.getHours()===0&&d.getMinutes()===0
 &&d.getSeconds()===0&&d.getMilliseconds()===0;
@@ -6743,7 +6755,7 @@ fromClipboard:(s,p)=>parseNumberText(s,p&&p.locale),
 date:{
 base:'dateString',
 storage:'dictionary',
-matches:(v)=>(typeof v==='string'&&ISO_DATE.test(v)&&!Number.isNaN(Date.parse(v)))
+matches:(v)=>(typeof v==='string'&&ISO_DATE_ONLY.test(v)&&!Number.isNaN(Date.parse(v)))
 ||(v instanceof Date&&!Number.isNaN(v.getTime())&&isLocalMidnight(v)),
 parse:(p)=>toIsoDate(p.text),
 compare:compareIso,
@@ -6757,7 +6769,7 @@ fromClipboard:(s)=>toIsoDate(s),
 dateString:{
 base:'dateString',
 storage:'dictionary',
-matches:(v)=>typeof v==='string'&&ISO_DATE.test(v)&&!Number.isNaN(Date.parse(v)),
+matches:(v)=>typeof v==='string'&&ISO_DATE_ONLY.test(v)&&!Number.isNaN(Date.parse(v)),
 parse:(p)=>toIsoDate(p.text),
 compare:compareIso,
 format:formatDateValue,
@@ -7414,6 +7426,32 @@ get graph(){return this.#graph;}
 setGraph(graph){this.#graph=graph;this.#memo.clear();}
 beginPass(){this.#memo.clear();}
 endPass(){this.#memo.clear();}
+invalidate(opts){
+if(this.#memo.size===0)return;
+const rows=opts&&opts.rows?new Set([...opts.rows].map(String)):null;
+const columns=opts&&opts.columns?[...opts.columns]:null;
+if(!rows&&!columns){this.#memo.clear();return;}
+const colIds=columns?this.#downstream(columns):null;
+for(const key of[...this.#memo.keys()]){
+const parts=String(key).split(MEMO_SEP);
+if(parts.length!==3)continue;
+if(rows&&!rows.has(parts[0]))continue;
+if(colIds&&!colIds.has(parts[2]))continue;
+this.#memo.delete(key);
+}
+}
+#downstream(colIds){
+const out=new Set();
+const graph=this.#graph;
+const work=[...colIds];
+while(work.length){
+const id=work.pop();
+if(out.has(id))continue;
+out.add(id);
+for(const dependent of(graph?graph.dependents.get(id)||[]:[]))work.push(dependent);
+}
+return out;
+}
 value(column,data,row){
 const col=typeof column==='string'?this.#columns.get(column):column;
 if(!col)return undefined;
@@ -7423,12 +7461,16 @@ if(col.value.pure!==false&&this.#stored&&row&&row.physical!=null
 return this.#stored.get(col.id,row.physical);
 }
 if(col.volatile)return this.compute(col,data,row);
-const key=`${this.#rowKey(data,row)}${MEMO_SEP}${col.id}`;
+if(col.value.pure===false)return this.compute(col,data,row);
+const key=`${this.#memoKey(data,row)}${MEMO_SEP}${col.id}`;
 if(this.#memo.has(key))return this.#memo.get(key);
 const out=this.compute(col,data,row);
 this.#memo.set(key,out);
 return out;
 }
+#memoKey(data,row){
+return`${this.#rowKey(data,row)}${MEMO_SEP}${identityOf(data)}`;
+}
 #stored_(col,data,row){
 if(this.#stored&&row&&row.physical!=null&&this.#stored.has(col.id)){
 return this.#stored.get(col.id,row.physical);
@@ -7546,7 +7588,7 @@ return{ok:true,value,oldValue,changed};
 }
 #invalidate(col,data,row){
 if(this.#memo.size===0)return;
-const key=this.#rowKey(data,row);
+const key=this.#memoKey(data,row);
 this.#memo.delete(`${key}${MEMO_SEP}${col.id}`);
 for(const id of(this.#graph?this.#graph.dependents.get(col.id)||[]:[])){
 this.#memo.delete(`${key}${MEMO_SEP}${id}`);
@@ -7555,6 +7597,9 @@ this.#memo.delete(`${key}${MEMO_SEP}${id}`);
 }
 function defaultRowKey(data,row){
 if(row&&row.key!=null)return String(row.key);
+return identityOf(data);
+}
+function identityOf(data){
 if(data&&typeof data==='object'){
 let id=identities.get(data);
 if(id===undefined){id=`#${identitySeq++}`;identities.set(data,id);}
@@ -8078,12 +8123,13 @@ allowPivot:true,
 allowTotal:true,
 nullable:true,
 };
-const ALIGN_ALIASES={left:'start',right:'end',centre:'center'};
+const ALIGN_ALIASES={centre:'center'};
+const ALIGN_VALUES=new Set(['start','center','end','left','right']);
 function normaliseAlign(value){
 if(typeof value!=='string')return undefined;
 const key=value.toLowerCase();
 if(ALIGN_ALIASES[key])return ALIGN_ALIASES[key];
-return key==='start'||key==='center'||key==='end'?key:undefined;
+return ALIGN_VALUES.has(key)?key:undefined;
 }
 function normaliseVAlign(value){
 if(typeof value!=='string')return undefined;
@@ -8112,6 +8158,28 @@ set('header','render');
 set('facet','strategy');
 return out;
 }
+const KNOWN_COLUMN_KEYS=new Set([
+'allowGroup','allowPivot','allowTotal','cell','contextMenu','edit',
+'export','field','filter','format','grandTotal','group','groupTotal',
+'header','headerControls','id','layout','lookup','nullable','pivot',
+'preset','running','shadow','sort','spec','tags','title','total',
+'type','validation','value','verticalAlign',
+]);
+const KNOWN_COLUMN_GROUP_KEYS=new Set([
+'collapsible','columns','facet','header','id','marryChildren',
+'openByDefault','showWhen','title',
+]);
+function warnUnknownKeys(def,known,kind,name){
+const label=kind==='columnGroup'?'column group':'column';
+for(const key of Object.keys(def)){
+if(known.has(key))continue;
+warnOnce(
+`${kind}.unknown:${key}`,
+`'${key}' is not a configuration key this grid recognises, so it had no `
++`effect on ${label} "${name}". Check the spelling against the reference.`,
+);
+}
+}
 function typeDefaultsLayer(type){
 const d=type.defaults||{};
 const layer={};
@@ -8180,6 +8248,7 @@ return total;
 #context;
 #graph;
 #pipeline;
+#rowKey;
 #inferred=false;
 #sampleSize;
 #onChange;
@@ -8194,6 +8263,7 @@ this.#grid=opts.grid||null;
 this.#context=opts.context;
 this.#sampleSize=opts.sampleSize??DEFAULT_SAMPLE;
 this.#onChange=opts.onChange||null;
+this.#rowKey=isFunction(opts.rowKey)?opts.rowKey:undefined;
 this.#types=createTypeRegistry(opts.dataTypes,this.#registry);
 const{leaves,groups}=flattenTree(opts.columns||[]);
 this.#groups=groups;
@@ -8216,6 +8286,7 @@ this.#order.push(column.id);
 this.#compile(opts.stored||null);
 }
 #resolve(def,inferredType){
+warnUnknownKeys(def,KNOWN_COLUMN_KEYS,'column',def.id||def.field||'(unnamed)');
 const own=expandColumn(def);
 const presetNames=toArray(def.preset);
 const presets=presetNames.map((name)=>{
@@ -8303,7 +8374,7 @@ spec:def.spec||null,
 validation:def.validation||null,
 volatile:!!(def.shadow||def.running),
 title:m.title??humanise(field||id),
-type:typeName,
+type:type.name,
 dataType:type,
 nullable:m.nullable!==false,
 align:normaliseAlign(
@@ -8409,6 +8480,7 @@ graph:this.#graph,
 grid:this.#grid,
 context:this.#context,
 stored:stored||null,
+rowKey:this.#rowKey,
 });
 }
 const pipeline=this.#pipeline;
@@ -8930,6 +9002,9 @@ const out=[];
 for(const node of nodes){
 if(!isObject(node)){fail('a column definition must be an object');continue;}
 if(Array.isArray(node.columns)){
+warnUnknownKeys(
+node,KNOWN_COLUMN_GROUP_KEYS,'columnGroup',node.title||node.id||'(unnamed)',
+);
 const group={
 id:node.id||uid('grp'),
 title:node.title||'',
@@ -17121,7 +17196,11 @@ const __default=RunningTotal;
 __def("packages/core/src/source/filterwire.js",function(__exports,__req){
 'use strict';
 Object.defineProperty(__exports,"HOST_FILTER_WARN_ID",{enumerable:true,get:function(){return HOST_FILTER_WARN_ID;}});
+Object.defineProperty(__exports,"WHERE_PAGE_RELATIVE_WARN_ID",{enumerable:true,get:function(){return WHERE_PAGE_RELATIVE_WARN_ID;}});
+Object.defineProperty(__exports,"warnWherePageRelative",{enumerable:true,get:function(){return warnWherePageRelative;}});
 Object.defineProperty(__exports,"warnHostFilterNotApplied",{enumerable:true,get:function(){return warnHostFilterNotApplied;}});
+Object.defineProperty(__exports,"WHERE_NOT_APPLIED_WARN_ID",{enumerable:true,get:function(){return WHERE_NOT_APPLIED_WARN_ID;}});
+Object.defineProperty(__exports,"warnWhereNotApplied",{enumerable:true,get:function(){return warnWhereNotApplied;}});
 Object.defineProperty(__exports,"RELATIVE_TOKENS",{enumerable:true,get:function(){return RELATIVE_TOKENS;}});
 Object.defineProperty(__exports,"parseRelativeToken",{enumerable:true,get:function(){return parseRelativeToken;}});
 Object.defineProperty(__exports,"resolveRelativeRange",{enumerable:true,get:function(){return resolveRelativeRange;}});
@@ -17137,6 +17216,16 @@ Object.defineProperty(__exports,"querySignature",{enumerable:true,get:function()
 const __m0=__req("packages/core/src/internal/util.js");
 const warnOnce=__m0["warnOnce"];
 const HOST_FILTER_WARN_ID='source.remote.hostFilter';
+const WHERE_PAGE_RELATIVE_WARN_ID='source.where.pageRelative';
+function warnWherePageRelative(names,mode){
+if(!Array.isArray(names)||!names.length)return;
+warnOnce(
+WHERE_PAGE_RELATIVE_WARN_ID,
+`filters.where (${names.join(', ')}) runs over the rows the ${mode} source fetched,`,
+'not the whole dataset: match counts and totals are page-relative.',
+'Give the predicate a { condition } twin so the engine can narrow the fetch itself.',
+);
+}
 function warnHostFilterNotApplied(ctx){
 const host=(ctx||{}).config;
 if(!host||!host.hostFilter)return;
@@ -17147,6 +17236,17 @@ HOST_FILTER_WARN_ID,
 'Express the filter as a FilterSet condition, or send it through config.context.',
 );
 }
+const WHERE_NOT_APPLIED_WARN_ID='source.where.notApplied';
+function warnWhereNotApplied(name,mode){
+warnOnce(
+`${WHERE_NOT_APPLIED_WARN_ID}:${name}`,
+`filters.where("${name}") is registered but the ${mode} source holds only its fetched window`,
+'and cannot run the predicate over it: the predicate is not applied there, and rows it would',
+'exclude stay on screen.',
+'Give it a { condition } twin so the engine can narrow the fetch itself — that is the',
+'supported route for a paged or remote source.',
+);
+}
 const zoneFormatters=new Map();
 function zoneFormatter(tz){
 let f=zoneFormatters.get(tz);
@@ -18346,7 +18446,9 @@ return entry.result;
 #filterKey(){
 const host=(this.#ctx.config||{}).hostFilter;
 const hostActive=host&&isFunction(host.active)&&host.active()?1:0;
-return`${this.#queryVersion}|${querySignature({filters:this.#state('filters',null),quick:this.#state('quick',''),quickMode:this.#state('quickMode','contains')})}|${hostActive}`;
+const where=(this.#state('where',null));
+const whereVersion=where?where.version:0;
+return`${this.#queryVersion}|${querySignature({filters:this.#state('filters',null),quick:this.#state('quick',''),quickMode:this.#state('quickMode','contains')})}|${hostActive}|${whereVersion}`;
 }
 #sortKey(){return`${this.#idOf('filter')}|${JSON.stringify(this.#state('sort',[]))}`;}
 #groupKey(){return`${this.#idOf('sort')}|${JSON.stringify(this.#state('groupBy',[]))}`;}
@@ -18402,6 +18504,9 @@ this.#rowCache.clear();
 this.#quickText.clear();
 this.#view=null;
 }
+invalidateHandles(){
+this.#handles.invalidate();
+}
 rows(){return this.#rows;}
 unfilteredIndices(){
 return this.#baseIndices();
@@ -18434,7 +18539,10 @@ const quick=String(this.#state('quick','')||'').trim().toLowerCase();
 const matches=quick?quickMatcher(quick,String(this.#state('quickMode','contains')||'contains')):null;
 const host=(this.#ctx.config||{}).hostFilter;
 const hostActive=!!(host&&isFunction(host.active)&&host.active());
-if(!filters&&!quick&&!hostActive)return base;
+const where=(
+this.#state('where',null));
+const whereActive=!!(where&&where.active);
+if(!filters&&!quick&&!hostActive&&!whereActive)return base;
 let mask=null;
 if(filters){
 const evaluate=this.#kernel('evaluateFilters');
@@ -18451,7 +18559,11 @@ for(let i=0;i<base.length;i++){
 const physical=base[i];
 if(mask&&!mask[physical])continue;
 if(matches&&!this.#quickPasses(physical,matches))continue;
-if(hostActive&&!host.passes(this.#leafRow(physical)))continue;
+if(hostActive||whereActive){
+const row=this.#leafRow(physical);
+if(hostActive&&!host.passes(row))continue;
+if(whereActive&&!where.passes(row.data,row.key))continue;
+}
 out[n++]=physical;
 }
 if(mask){
@@ -19839,6 +19951,9 @@ this.#emit('model:changed',{reason:'collapse',key});
 }
 expandedKeys(){return[...this.#expanded];}
 pivotFields(){return this.#pivotFields;}
+invalidateHandles(){
+if(this.#fullMemory&&isFunction(this.#fullMemory.invalidateHandles))this.#fullMemory.invalidateHandles();
+}
 #fullFrame(){
 const fn=(this.#config).fullFrame;
 return isFunction(fn)?fn():null;
@@ -20950,6 +21065,11 @@ evicted:this.#evicted,
 }
 promoted(){return this.#memory!==null;}
 memorySource(){return this.#memory;}
+invalidateHandles(){
+if(!this.#memory)return;
+if(isFunction(this.#memory.invalidateHandles))this.#memory.invalidateHandles();
+if(isFunction(this.#memory.invalidate))this.#memory.invalidate('sort');
+}
 renderCount(){return this.#renderCount;}
 ingestStats(){
 return{worker:this.#workerChunks,inline:this.#inlineChunks,storeBacked:this.#storeBacked};
@@ -21174,6 +21294,12 @@ const quick=String(this.#state('quick','')||'').toLowerCase();
 if(quick&&!this.#quickText(data).includes(quick))return false;
 const host=(this.#ctx.config||{}).hostFilter;
 if(host&&isFunction(host.active)&&host.active()&&!host.passes(this.#leafRow(physical)))return false;
+const where=(
+this.#state('where',null));
+if(where&&where.active){
+const row=this.#leafRow(physical);
+if(!where.passes(row.data,row.key))return false;
+}
 return true;
 }
 #passesNode(node,data){
@@ -22420,6 +22546,11 @@ const removed=Array.isArray(change.removed)?change.removed:null;
 if(!updated&&!added&&!removed)return null;
 const cols=this.#filterCols;
 if(cols&&cols.size&&String(spec.follow||'filtered')!=='all'){
+if(change.edit===true&&Array.isArray(change.columns)){
+for(const col of change.columns){
+if(cols.has(String(col)))return null;
+}
+}
 for(const row of updated||[]){
 const key=row&&row.key;
 const before=key===undefined?undefined:this.#index.rowData.get(String(key));
@@ -23045,6 +23176,7 @@ const isFunction=__m0["isFunction"];
 const warnOnce=__m0["warnOnce"];
 const __m1=__req("packages/core/src/source/filterwire.js");
 const isGroup=__m1["isGroup"];
+const warnWherePageRelative=__m1["warnWherePageRelative"];
 const __m2=__req("packages/core/src/source/aggregates.js");
 const resolveAggregatePlan=__m2["resolveAggregatePlan"];
 const groupKeysPushable=__m2["groupKeysPushable"];
@@ -23154,10 +23286,13 @@ if(!sortPushable&&wanted.length)unpushed.push('sort');
 const quick=request.quick?String(request.quick):'';
 const quickPushable=!quick||!!caps.quick;
 if(!quickPushable)unpushed.push('quick');
+const where=request.where&&request.where.active?request.where:null;
+if(where)unpushed.push('where');
 const residual={
 filters:filters.residual,
 sort:sortPushable?null:wanted,
 quick:quickPushable?'':quick,
+where,
 };
 const full=!!fullDataset;
 const needsAll=full||!!(residual.filters||residual.sort||residual.quick)||!caps.range;
@@ -23183,6 +23318,10 @@ const kept=[];
 for(let i=0;i<out.length;i++)if(mask[i])kept.push(out[i]);
 out=kept;
 }
+if(residual.where&&residual.where.active){
+warnWherePageRelative(residual.where.names,'pushdown');
+out=out.filter((row)=>residual.where.passes(row));
+}
 if(residual.quick){
 const needle=residual.quick.toLowerCase();
 out=out.filter((row)=>{
@@ -24818,12 +24957,14 @@ __def("packages/core/src/model/rowkey.js",function(__exports,__req){
 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',
@@ -24871,6 +25012,15 @@ warnOnce('rowKey.throw','rowKey function threw; falling back to index identity f
 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){
@@ -24886,6 +25036,15 @@ 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){
@@ -24897,6 +25056,12 @@ disabled:[],
 key(data){
 return part(get(data));
 },
+keyEmpty(data){
+return isBlank(get(data));
+},
+missingFields(data){
+return isBlank(get(data))?[spec]:[];
+},
 };
 }
 if(warn){
@@ -24924,6 +25089,36 @@ 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);
 }
@@ -25482,6 +25677,7 @@ return createRowKey((spec));
 });
 __def("packages/core/src/model/selection.js",function(__exports,__req){
 'use strict';
+Object.defineProperty(__exports,"resolveSelectionConfig",{enumerable:true,get:function(){return resolveSelectionConfig;}});
 Object.defineProperty(__exports,"SelectionModel",{enumerable:true,get:function(){return SelectionModel;}});
 Object.defineProperty(__exports,"normaliseRange",{enumerable:true,get:function(){return normaliseRange;}});
 Object.defineProperty(__exports,"rangeContains",{enumerable:true,get:function(){return rangeContains;}});
@@ -25493,8 +25689,23 @@ Object.defineProperty(__exports,"summarise",{enumerable:true,get:function(){retu
 const __m0=__req("packages/core/src/internal/util.js");
 const warnOnce=__m0["warnOnce"];
 const isFunction=__m0["isFunction"];
+const isObject=__m0["isObject"];
 const __m1=__req("packages/core/src/model/rowmodel.js");
 const childrenOf=__m1["childrenOf"];
+function resolveSelectionConfig(raw){
+const cfg=typeof raw==='string'?{mode:raw}:(isObject(raw)?raw:{});
+const isNone=cfg.mode==='none';
+const ranges=cfg.ranges!==undefined
+?cfg.ranges!==false
+:(cfg.fillHandle===true||!isNone);
+const fillHandle=cfg.fillHandle!==undefined
+?cfg.fillHandle!==false
+:(ranges&&!isNone);
+const checkboxOnly=cfg.checkboxOnly===true;
+return{
+...cfg,ranges,fillHandle,checkboxOnly,
+};
+}
 class SelectionModel{
 #mode='multiple';
 #groupSelectsChildren=false;
@@ -26902,6 +27113,375 @@ out[scope]=rules[scope];
 return out;
 }
 });
+__def("packages/core/src/ai/schema.js",function(__exports,__req){
+'use strict';
+Object.defineProperty(__exports,"SCHEMA_VERSION",{enumerable:true,get:function(){return SCHEMA_VERSION;}});
+Object.defineProperty(__exports,"OPERATORS",{enumerable:true,get:function(){return OPERATORS;}});
+Object.defineProperty(__exports,"OPERATOR_ARITY",{enumerable:true,get:function(){return OPERATOR_ARITY;}});
+Object.defineProperty(__exports,"OPERATORS_BY_FAMILY",{enumerable:true,get:function(){return OPERATORS_BY_FAMILY;}});
+Object.defineProperty(__exports,"INTENT_ACTIONS",{enumerable:true,get:function(){return INTENT_ACTIONS;}});
+Object.defineProperty(__exports,"CLEAR_TARGETS",{enumerable:true,get:function(){return CLEAR_TARGETS;}});
+Object.defineProperty(__exports,"DEFAULT_LIMITS",{enumerable:true,get:function(){return DEFAULT_LIMITS;}});
+Object.defineProperty(__exports,"familyOf",{enumerable:true,get:function(){return familyOf;}});
+Object.defineProperty(__exports,"describeGrid",{enumerable:true,get:function(){return describeGrid;}});
+Object.defineProperty(__exports,"columnIndex",{enumerable:true,get:function(){return columnIndex;}});
+Object.defineProperty(__exports,"operatorsFor",{enumerable:true,get:function(){return operatorsFor;}});
+Object.defineProperty(__exports,"promptText",{enumerable:true,get:function(){return promptText;}});
+Object.defineProperty(__exports,"toolDefinition",{enumerable:true,get:function(){return toolDefinition;}});
+const __m0=__req("packages/core/src/internal/util.js");
+const isFunction=__m0["isFunction"];
+const isObject=__m0["isObject"];
+const SCHEMA_VERSION=1;
+const OPERATORS=Object.freeze(([
+'eq','ne',
+'lt','lte','gt','gte',
+'between','notBetween',
+'in','notIn',
+'contains','notContains','startsWith','endsWith','matches',
+'blank','notBlank',
+'containsAny','containsAll','containsNone',
+]));
+const OPERATOR_ARITY=Object.freeze({
+eq:'one',ne:'one',
+lt:'one',lte:'one',gt:'one',gte:'one',
+between:'range',notBetween:'range',
+in:'set',notIn:'set',
+contains:'one',notContains:'one',startsWith:'one',endsWith:'one',matches:'one',
+blank:'none',notBlank:'none',
+containsAny:'set',containsAll:'set',containsNone:'set',
+});
+const OPERATORS_BY_FAMILY=Object.freeze(({
+text:Object.freeze([
+'eq','ne','contains','notContains','startsWith','endsWith','matches',
+'in','notIn','blank','notBlank',
+]),
+number:Object.freeze([
+'eq','ne','lt','lte','gt','gte','between','notBetween','in','notIn',
+'blank','notBlank',
+]),
+boolean:Object.freeze(['eq','ne','blank','notBlank']),
+date:Object.freeze([
+'eq','ne','lt','lte','gt','gte','between','notBetween','blank','notBlank',
+]),
+lookup:Object.freeze(['eq','ne','in','notIn','blank','notBlank']),
+lookupMulti:Object.freeze([
+'containsAny','containsAll','containsNone','in','notIn','blank','notBlank',
+]),
+object:Object.freeze(['eq','ne','blank','notBlank']),
+}));
+const INTENT_ACTIONS=Object.freeze([
+Object.freeze({
+name:'setFilters',
+summary:'Replace the whole filter tree. Omit to leave filters alone; use clear to remove them.',
+params:Object.freeze({
+filters:'a condition {col, op, value} or a group {op: "and"|"or"|"not", conditions: [...]}',
+}),
+}),
+Object.freeze({
+name:'setSort',
+summary:'Replace the sort model. First entry is the primary sort.',
+params:Object.freeze({sort:'array of {col, dir: "asc"|"desc"}'}),
+}),
+Object.freeze({
+name:'groupBy',
+summary:'Group rows by one or more columns, outermost first.',
+params:Object.freeze({columns:'array of column ids'}),
+}),
+Object.freeze({
+name:'showColumns',
+summary:'Make columns visible.',
+params:Object.freeze({columns:'array of column ids'}),
+}),
+Object.freeze({
+name:'hideColumns',
+summary:'Hide columns.',
+params:Object.freeze({columns:'array of column ids'}),
+}),
+Object.freeze({
+name:'setQuick',
+summary:'Set the quick-filter text, which matches across every column.',
+params:Object.freeze({text:'the search text'}),
+}),
+Object.freeze({
+name:'clear',
+summary:'Remove something already applied.',
+params:Object.freeze({what:'"filters" | "sort" | "group" | "quick" | "all"'}),
+}),
+]);
+const CLEAR_TARGETS=Object.freeze(['filters','sort','group','quick','all']);
+const DEFAULT_LIMITS=Object.freeze({
+maxColumns:150,
+maxOptions:20,
+maxTotalOptions:400,
+maxLabelLength:60,
+maxFilterChars:600,
+});
+function resolveLimits(opts){
+const out={...DEFAULT_LIMITS};
+if(!isObject(opts))return out;
+for(const key of Object.keys(DEFAULT_LIMITS)){
+const value=(opts)[key];
+if(typeof value==='number'&&Number.isFinite(value)&&value>=0){
+(out)[key]=Math.floor(value);
+}
+}
+return out;
+}
+function shorten(value,max){
+const text=value===null||value===undefined?'':String(value);
+if(text.length<=max)return text;
+return`${text.slice(0,Math.max(0,max-1))}…`;
+}
+function readColumns(grid){
+if(Array.isArray(grid))return grid;
+if(!grid)return[];
+const api=grid.columns;
+try{
+if(Array.isArray(api))return api;
+if(api&&isFunction(api.all))return api.all()||[];
+if(isFunction(api))return api()||[];
+}catch{
+return[];
+}
+return[];
+}
+function familyOf(column){
+const lookup=column&&column.lookup;
+if(lookup)return lookup.multiple?'lookupMulti':'lookup';
+const base=(column&&column.dataType&&column.dataType.base)||column?.type||'text';
+if(base==='number'||base==='boolean'||base==='object')return base;
+if(base==='date'||base==='dateString')return'date';
+return'text';
+}
+function readOptions(column,perColumn,remaining){
+const lookup=column&&column.lookup;
+if(!lookup||!isFunction(lookup.options))return null;
+let all=[];
+try{
+all=lookup.options()||[];
+}catch{
+return null;
+}
+const cap=Math.max(0,Math.min(perColumn,remaining));
+const kept=[];
+for(const option of all.slice(0,cap)){
+if(!isObject(option))continue;
+kept.push({value:option.id,label:String(option.label??option.id??'')});
+}
+return{options:kept,total:all.length,open:lookup.allowCustom===true};
+}
+function describeColumn(column,limits,budget,truncated){
+const id=String(column.id);
+const family=familyOf(column);
+const out={
+id,
+title:shorten(column.title??id,limits.maxLabelLength),
+type:String(column.type||family),
+family,
+filterable:!(column.filter&&column.filter.enabled===false),
+sortable:!(column.sort&&column.sort.enabled===false),
+groupable:column.allowGroup!==false,
+hidden:!!(column.layout&&column.layout.hidden),
+};
+if(column.layout&&column.layout.lockVisible)out.lockVisible=true;
+const report=readOptions(column,limits.maxOptions,budget.remaining);
+if(report){
+out.options=report.options.map((o)=>(
+o.label===String(o.value)?{value:o.value}:{value:o.value,label:shorten(o.label,limits.maxLabelLength)}
+));
+budget.remaining-=report.options.length;
+if(report.options.length<report.total){
+out.optionsTotal=report.total;
+truncated.push(`column "${id}": ${report.options.length} of ${report.total} options listed`);
+}
+if(report.open)out.optionsOpen=true;
+}
+return out;
+}
+function readState(grid,limits,truncated){
+const state={sort:[],group:[],quick:'',filters:null};
+if(!grid)return state;
+try{
+if(grid.sort&&isFunction(grid.sort.get)){
+state.sort=(grid.sort.get()||[]).map((e)=>({col:e.col,dir:e.dir}));
+}
+if(grid.columns&&isFunction(grid.columns.state)){
+const group=(grid.columns.state()||[])
+.filter((c)=>typeof c.groupIndex==='number'&&c.groupIndex>=0)
+.sort((a,b)=>a.groupIndex-b.groupIndex);
+state.group=group.map((c)=>c.id);
+}
+if(grid.filters&&isFunction(grid.filters.get)){
+const filters=grid.filters.get()||null;
+const text=filters?JSON.stringify(filters):'';
+if(text.length>limits.maxFilterChars){
+truncated.push('the current filter tree was too large to include; it is summarised as "complex"');
+state.filters='complex';
+}else{
+state.filters=filters;
+}
+}
+}catch{
+}
+return state;
+}
+function describeGrid(grid,opts={}){
+const limits=resolveLimits(opts);
+const truncated=[];
+const budget={remaining:limits.maxTotalOptions};
+let columns=readColumns(grid).filter((c)=>c&&typeof c.id==='string');
+if(opts.includeHidden===false){
+columns=columns.filter((c)=>!(c.layout&&c.layout.hidden));
+}
+const total=columns.length;
+if(total>limits.maxColumns){
+truncated.push(`${total-limits.maxColumns} of ${total} columns omitted; ask the user to narrow the question`);
+columns=columns.slice(0,limits.maxColumns);
+}
+const described=columns.map((c)=>describeColumn(c,limits,budget,truncated));
+if(budget.remaining<=0&&described.some((c)=>c.options)){
+truncated.push(`the total option budget of ${limits.maxTotalOptions} was reached`);
+}
+const schema={
+schemaVersion:SCHEMA_VERSION,
+grid:{columns:total,described:described.length},
+columns:described,
+operators:{
+all:[...OPERATORS],
+byFamily:OPERATORS_BY_FAMILY,
+arity:OPERATOR_ARITY,
+},
+actions:INTENT_ACTIONS.map((a)=>({name:a.name,summary:a.summary,params:a.params})),
+truncated,
+};
+if(opts.includeState!==false)schema.state=readState(grid,limits,truncated);
+return schema;
+}
+function columnIndex(schema){
+const index=new Map();
+const columns=schema&&Array.isArray(schema.columns)?schema.columns:[];
+for(const column of columns){
+if(column&&typeof column.id==='string')index.set(column.id,column);
+}
+return index;
+}
+function operatorsFor(column){
+const family=column&&column.family;
+return(OPERATORS_BY_FAMILY)[family]||OPERATORS_BY_FAMILY.text;
+}
+function columnLine(column){
+const flags=[
+column.filterable?'filter':'',
+column.sortable?'sort':'',
+column.groupable?'group':'',
+column.hidden?'hidden':'',
+].filter(Boolean).join(',');
+let line=`  ${column.id} | ${column.title} | ${column.family} | ${flags}`;
+if(column.options){
+const values=column.options.map((o)=>(
+o.label===undefined?String(o.value):`${String(o.value)}=${o.label}`
+));
+const more=column.optionsTotal?` (+${column.optionsTotal-column.options.length} more)`:'';
+line+=` | options: ${values.join(', ')}${more}`;
+if(column.optionsOpen)line+=' (values outside this list are allowed)';
+}
+return line;
+}
+function promptText(schema){
+if(!isObject(schema))return'';
+const lines=[];
+lines.push(`LATTICE GRID SCHEMA v${schema.schemaVersion||SCHEMA_VERSION}`);
+lines.push('');
+lines.push('COLUMNS  id | title | family | capabilities | options');
+for(const column of schema.columns||[])lines.push(columnLine(column));
+lines.push('');
+lines.push('OPERATORS by family');
+for(const[family,ops]of Object.entries(schema.operators?.byFamily||OPERATORS_BY_FAMILY)){
+lines.push(`  ${family}: ${ops.join(', ')}`);
+}
+lines.push('');
+lines.push('OPERATOR VALUE SHAPES');
+lines.push('  no value: blank, notBlank');
+lines.push('  [lo, hi]: between, notBetween');
+lines.push('  array:    in, notIn, containsAny, containsAll, containsNone');
+lines.push('  scalar:   everything else');
+lines.push('');
+lines.push('ACTIONS (an intent is {"actions": [...]}; nothing outside this list is permitted)');
+for(const action of schema.actions||INTENT_ACTIONS){
+lines.push(`  ${action.name}: ${action.summary}`);
+for(const[key,shape]of Object.entries(action.params||{}))lines.push(`      ${key}: ${shape}`);
+}
+if(schema.state){
+lines.push('');
+lines.push('CURRENT VIEW');
+lines.push(`  sort: ${schema.state.sort?.length?schema.state.sort.map((s)=>`${s.col} ${s.dir}`).join(', '):'none'}`);
+lines.push(`  group: ${schema.state.group?.length?schema.state.group.join(', '):'none'}`);
+lines.push(`  quick filter: ${schema.state.quick?JSON.stringify(schema.state.quick):'none'}`);
+lines.push(`  filters: ${schema.state.filters?JSON.stringify(schema.state.filters):'none'}`);
+}
+if(schema.truncated&&schema.truncated.length){
+lines.push('');
+lines.push('INCOMPLETE: this schema was shortened to fit:');
+for(const note of schema.truncated)lines.push(`  ${note}`);
+}
+lines.push('');
+lines.push('Reply with JSON only. Use exactly the column ids above; never invent one.');
+return lines.join('\n');
+}
+function toolDefinition(schema,opts={}){
+const ids=(schema&&Array.isArray(schema.columns)?schema.columns:[]).map((c)=>c.id);
+const maxEnum=typeof opts.maxEnum==='number'?opts.maxEnum:200;
+const columnId=ids.length&&ids.length<=maxEnum
+?{type:'string',description:'A column id from the grid schema.',enum:ids}
+:{type:'string',description:'A column id from the grid schema.'};
+const condition={
+type:'object',
+description:'A single condition, or a group combining conditions.',
+properties:{
+col:columnId,
+op:{type:'string',enum:[...OPERATORS,'and','or','not']},
+value:{description:'Scalar, [lo, hi] for between, or an array for the set operators.'},
+conditions:{type:'array',description:'Child nodes, when op is and/or/not.',items:{type:'object'}},
+},
+};
+return{
+name:'lattice_grid_intent',
+description:
+'Reshape the data grid: filter, sort, group, show or hide columns. Returns a plan the '
++'user reviews before it is applied. Use only column ids from the supplied schema.',
+input_schema:{
+type:'object',
+properties:{
+actions:{
+type:'array',
+description:'The steps to take, in order.',
+items:{
+type:'object',
+properties:{
+type:{type:'string',enum:INTENT_ACTIONS.map((a)=>a.name)},
+filters:condition,
+sort:{
+type:'array',
+items:{
+type:'object',
+properties:{col:columnId,dir:{type:'string',enum:['asc','desc']}},
+required:['col','dir'],
+},
+},
+columns:{type:'array',items:columnId},
+text:{type:'string'},
+what:{type:'string',enum:[...CLEAR_TARGETS]},
+},
+required:['type'],
+},
+},
+explain:{type:'string',description:'One short sentence describing the change, for the user.'},
+},
+required:['actions'],
+},
+};
+}
+});
 __def("packages/core/src/model/state.js",function(__exports,__req){
 'use strict';
 Object.defineProperty(__exports,"STATE_VERSION",{enumerable:true,get:function(){return STATE_VERSION;}});
@@ -26909,17 +27489,23 @@ Object.defineProperty(__exports,"STATE_KEYS",{enumerable:true,get:function(){ret
 Object.defineProperty(__exports,"migrateState",{enumerable:true,get:function(){return migrateState;}});
 Object.defineProperty(__exports,"StateModel",{enumerable:true,get:function(){return StateModel;}});
 Object.defineProperty(__exports,"pruneFilters",{enumerable:true,get:function(){return pruneFilters;}});
+Object.defineProperty(__exports,"sanitizeFilterOperators",{enumerable:true,get:function(){return sanitizeFilterOperators;}});
 Object.defineProperty(__exports,"serialiseState",{enumerable:true,get:function(){return serialiseState;}});
 Object.defineProperty(__exports,"restoreState",{enumerable:true,get:function(){return restoreState;}});
 const __m0=__req("packages/core/src/internal/util.js");
 const isObject=__m0["isObject"];
 const isFunction=__m0["isFunction"];
+const warnOnce=__m0["warnOnce"];
 const __m1=__req("packages/core/src/formatting/model.js");
 const GRID_SCOPE=__m1["GRID_SCOPE"];
 const isFormattingState=__m1["isFormattingState"];
+const __m2=__req("packages/core/src/ai/schema.js");
+const OPERATORS=__m2["OPERATORS"];
+const OPERATORS_BY_FAMILY=__m2["OPERATORS_BY_FAMILY"];
+const familyOf=__m2["familyOf"];
 const STATE_VERSION=2;
 const STATE_KEYS=([
-'columns','columnOrder','columnGroups','sort','filters','quick','quickMode','group','pivot',
+'columns','columnOrder','columnGroups','sort','filters','where','quick','quickMode','group','pivot',
 'pivotView',
 'formatting','redaction','annotations','facets','expanded','selection','pagination','scroll',
 ]);
@@ -26958,6 +27544,10 @@ if(Array.isArray(bands)&&bands.length)state.columnGroups=clone(bands);
 }
 if(t.sort&&isFunction(t.sort.get))state.sort=clone(t.sort.get())||[];
 if(t.filters&&isFunction(t.filters.get))state.filters=clone(t.filters.get())??null;
+if(t.filters&&isFunction(t.filters.where)){
+const where=t.filters.where();
+if(Array.isArray(where)&&where.length)state.where=[...where];
+}
 if(t.filters&&isFunction(t.filters.quick)){
 const quick=t.filters.quick();
 if(quick)state.quick=quick;
@@ -27010,7 +27600,12 @@ const value=(incoming)[key];
 if(value===undefined)continue;
 this.#applyKey(key,value,known,c,t);
 }
-this.#emit('state:changed',{state:incoming,report:c.report},opts.origin||'api');
+this.#emit('state:changed',{
+state:incoming,
+report:c.report,
+cause:opts.cause||'apply',
+sections:c.report.applied.slice(),
+},opts.origin||'api');
 return c.report;
 }
 #applyKey(key,value,known,c,t){
@@ -27020,6 +27615,7 @@ case'columnOrder':return this.#applyOrder(value,known,c,t);
 case'columnGroups':return this.#applyColumnGroups(value,c,t);
 case'sort':return this.#applySort(value,known,c,t);
 case'filters':return this.#applyFilters(value,known,c,t);
+case'where':return this.#applyWhere(value,c,t);
 case'quick':return this.#applySimple('quick',value,c,t.filters,'setQuick');
 case'quickMode':return this.#applySimple('quickMode',value,c,t.filters,'setQuickMode');
 case'group':return this.#applyIdList('group',value,known,c,t.group);
@@ -27081,7 +27677,11 @@ return c.applied('columnGroups');
 if(!Array.isArray(value))return c.skipped('sort','not an array');
 if(!t.sort||!isFunction(t.sort.set))return c.skipped('sort','no sort target');
 const usable=value.filter((e)=>{
-if(!isObject(e)||typeof e.col!=='string')return false;
+if(!isObject(e)||typeof e.col!=='string'){
+const label=isObject(e)?(Object.keys(e).sort().join(',')||'empty'):String(e);
+c.skipped(`sort.${label}`,'not a valid sort entry (expected { col, dir })');
+return false;
+}
 if(known&&!known.has(e.col)){
 c.skipped(`sort.${e.col}`,'unknown column');
 return false;
@@ -27098,12 +27698,39 @@ t.filters.set(null);
 return c.applied('filters');
 }
 if(!isObject(value))return c.skipped('filters','not a filter set');
-const pruned=pruneFilters((value),known,(col)=>{
+const byColumn=pruneFilters((value),known,(col)=>{
 c.skipped(`filters.${col}`,'unknown column');
 });
-t.filters.set(pruned);
+const resolveColumn=t.columns&&isFunction(t.columns.get)?(id)=>t.columns.get(id):undefined;
+const sanitized=sanitizeFilterOperators(byColumn,resolveColumn,(col,op,allowed)=>{
+c.skipped(`filters.${col}`,`unknown operator "${op}"; valid operators: ${allowed.join(', ')}`);
+});
+t.filters.set(sanitized);
 return c.applied('filters');
 }
+#applyWhere(value,c,t){
+if(!t.filters||!isFunction(t.filters.where))return c.skipped('where','no filter target');
+if(!Array.isArray(value))return c.skipped('where','not a list of predicate names');
+const registered=new Set(t.filters.where());
+let matched=0;
+for(const name of value){
+if(typeof name!=='string'||!name){
+c.skipped('where','a predicate name must be a non-empty string');
+continue;
+}
+if(registered.has(name)){
+matched++;
+continue;
+}
+c.skipped(
+`where.${name}`,
+'no predicate is registered under this name; call '
++`filters.where(${JSON.stringify(name)}, fn) before applying this state`,
+);
+}
+if(matched)c.applied('where');
+return undefined;
+}
 #applyIdList(key,value,known,c,target){
 if(!Array.isArray(value))return c.skipped(key,'not an array');
 if(!target||!isFunction(target.set))return c.skipped(key,`no ${key} target`);
@@ -27181,6 +27808,32 @@ return null;
 }
 return node;
 }
+function sanitizeFilterOperators(node,resolveColumn,onDrop){
+if(!node)return null;
+if(Array.isArray(node.conditions)){
+let changed=false;
+const kept=[];
+for(const child of node.conditions){
+const sanitized=sanitizeFilterOperators(child,resolveColumn,onDrop);
+if(sanitized!==child)changed=true;
+if(sanitized!==null)kept.push(sanitized);
+}
+if(!changed)return node;
+if(kept.length===0)return null;
+if(kept.length===1&&node.op!=='not')return kept[0];
+return{...node,conditions:kept};
+}
+const op=node.op;
+if(typeof op==='string'&&(op==='relative'||OPERATORS.includes((op))))return node;
+const column=typeof node.col==='string'&&typeof resolveColumn==='function'
+?resolveColumn(node.col):undefined;
+const allowed=column?(OPERATORS_BY_FAMILY[familyOf(column)]||OPERATORS):OPERATORS;
+warnOnce(`filter:op:${String(node.col)}:${String(op)}`,
+`filter operator "${String(op)}" is unknown for column "${String(node.col)}"; the condition is refused `
++`rather than matching every row. Valid operators here: ${allowed.join(', ')}.`);
+if(onDrop)onDrop(node.col,op,allowed);
+return null;
+}
 function clone(value){
 if(value===null||typeof value!=='object')return value;
 try{
@@ -31332,375 +31985,6 @@ return isFunction(value)?value.bind(target):value;
 }
 }
 });
-__def("packages/core/src/ai/schema.js",function(__exports,__req){
-'use strict';
-Object.defineProperty(__exports,"SCHEMA_VERSION",{enumerable:true,get:function(){return SCHEMA_VERSION;}});
-Object.defineProperty(__exports,"OPERATORS",{enumerable:true,get:function(){return OPERATORS;}});
-Object.defineProperty(__exports,"OPERATOR_ARITY",{enumerable:true,get:function(){return OPERATOR_ARITY;}});
-Object.defineProperty(__exports,"OPERATORS_BY_FAMILY",{enumerable:true,get:function(){return OPERATORS_BY_FAMILY;}});
-Object.defineProperty(__exports,"INTENT_ACTIONS",{enumerable:true,get:function(){return INTENT_ACTIONS;}});
-Object.defineProperty(__exports,"CLEAR_TARGETS",{enumerable:true,get:function(){return CLEAR_TARGETS;}});
-Object.defineProperty(__exports,"DEFAULT_LIMITS",{enumerable:true,get:function(){return DEFAULT_LIMITS;}});
-Object.defineProperty(__exports,"familyOf",{enumerable:true,get:function(){return familyOf;}});
-Object.defineProperty(__exports,"describeGrid",{enumerable:true,get:function(){return describeGrid;}});
-Object.defineProperty(__exports,"columnIndex",{enumerable:true,get:function(){return columnIndex;}});
-Object.defineProperty(__exports,"operatorsFor",{enumerable:true,get:function(){return operatorsFor;}});
-Object.defineProperty(__exports,"promptText",{enumerable:true,get:function(){return promptText;}});
-Object.defineProperty(__exports,"toolDefinition",{enumerable:true,get:function(){return toolDefinition;}});
-const __m0=__req("packages/core/src/internal/util.js");
-const isFunction=__m0["isFunction"];
-const isObject=__m0["isObject"];
-const SCHEMA_VERSION=1;
-const OPERATORS=Object.freeze(([
-'eq','ne',
-'lt','lte','gt','gte',
-'between','notBetween',
-'in','notIn',
-'contains','notContains','startsWith','endsWith','matches',
-'blank','notBlank',
-'containsAny','containsAll','containsNone',
-]));
-const OPERATOR_ARITY=Object.freeze({
-eq:'one',ne:'one',
-lt:'one',lte:'one',gt:'one',gte:'one',
-between:'range',notBetween:'range',
-in:'set',notIn:'set',
-contains:'one',notContains:'one',startsWith:'one',endsWith:'one',matches:'one',
-blank:'none',notBlank:'none',
-containsAny:'set',containsAll:'set',containsNone:'set',
-});
-const OPERATORS_BY_FAMILY=Object.freeze(({
-text:Object.freeze([
-'eq','ne','contains','notContains','startsWith','endsWith','matches',
-'in','notIn','blank','notBlank',
-]),
-number:Object.freeze([
-'eq','ne','lt','lte','gt','gte','between','notBetween','in','notIn',
-'blank','notBlank',
-]),
-boolean:Object.freeze(['eq','ne','blank','notBlank']),
-date:Object.freeze([
-'eq','ne','lt','lte','gt','gte','between','notBetween','blank','notBlank',
-]),
-lookup:Object.freeze(['eq','ne','in','notIn','blank','notBlank']),
-lookupMulti:Object.freeze([
-'containsAny','containsAll','containsNone','in','notIn','blank','notBlank',
-]),
-object:Object.freeze(['eq','ne','blank','notBlank']),
-}));
-const INTENT_ACTIONS=Object.freeze([
-Object.freeze({
-name:'setFilters',
-summary:'Replace the whole filter tree. Omit to leave filters alone; use clear to remove them.',
-params:Object.freeze({
-filters:'a condition {col, op, value} or a group {op: "and"|"or"|"not", conditions: [...]}',
-}),
-}),
-Object.freeze({
-name:'setSort',
-summary:'Replace the sort model. First entry is the primary sort.',
-params:Object.freeze({sort:'array of {col, dir: "asc"|"desc"}'}),
-}),
-Object.freeze({
-name:'groupBy',
-summary:'Group rows by one or more columns, outermost first.',
-params:Object.freeze({columns:'array of column ids'}),
-}),
-Object.freeze({
-name:'showColumns',
-summary:'Make columns visible.',
-params:Object.freeze({columns:'array of column ids'}),
-}),
-Object.freeze({
-name:'hideColumns',
-summary:'Hide columns.',
-params:Object.freeze({columns:'array of column ids'}),
-}),
-Object.freeze({
-name:'setQuick',
-summary:'Set the quick-filter text, which matches across every column.',
-params:Object.freeze({text:'the search text'}),
-}),
-Object.freeze({
-name:'clear',
-summary:'Remove something already applied.',
-params:Object.freeze({what:'"filters" | "sort" | "group" | "quick" | "all"'}),
-}),
-]);
-const CLEAR_TARGETS=Object.freeze(['filters','sort','group','quick','all']);
-const DEFAULT_LIMITS=Object.freeze({
-maxColumns:150,
-maxOptions:20,
-maxTotalOptions:400,
-maxLabelLength:60,
-maxFilterChars:600,
-});
-function resolveLimits(opts){
-const out={...DEFAULT_LIMITS};
-if(!isObject(opts))return out;
-for(const key of Object.keys(DEFAULT_LIMITS)){
-const value=(opts)[key];
-if(typeof value==='number'&&Number.isFinite(value)&&value>=0){
-(out)[key]=Math.floor(value);
-}
-}
-return out;
-}
-function shorten(value,max){
-const text=value===null||value===undefined?'':String(value);
-if(text.length<=max)return text;
-return`${text.slice(0,Math.max(0,max-1))}…`;
-}
-function readColumns(grid){
-if(Array.isArray(grid))return grid;
-if(!grid)return[];
-const api=grid.columns;
-try{
-if(Array.isArray(api))return api;
-if(api&&isFunction(api.all))return api.all()||[];
-if(isFunction(api))return api()||[];
-}catch{
-return[];
-}
-return[];
-}
-function familyOf(column){
-const lookup=column&&column.lookup;
-if(lookup)return lookup.multiple?'lookupMulti':'lookup';
-const base=(column&&column.dataType&&column.dataType.base)||column?.type||'text';
-if(base==='number'||base==='boolean'||base==='object')return base;
-if(base==='date'||base==='dateString')return'date';
-return'text';
-}
-function readOptions(column,perColumn,remaining){
-const lookup=column&&column.lookup;
-if(!lookup||!isFunction(lookup.options))return null;
-let all=[];
-try{
-all=lookup.options()||[];
-}catch{
-return null;
-}
-const cap=Math.max(0,Math.min(perColumn,remaining));
-const kept=[];
-for(const option of all.slice(0,cap)){
-if(!isObject(option))continue;
-kept.push({value:option.id,label:String(option.label??option.id??'')});
-}
-return{options:kept,total:all.length,open:lookup.allowCustom===true};
-}
-function describeColumn(column,limits,budget,truncated){
-const id=String(column.id);
-const family=familyOf(column);
-const out={
-id,
-title:shorten(column.title??id,limits.maxLabelLength),
-type:String(column.type||family),
-family,
-filterable:!(column.filter&&column.filter.enabled===false),
-sortable:!(column.sort&&column.sort.enabled===false),
-groupable:column.allowGroup!==false,
-hidden:!!(column.layout&&column.layout.hidden),
-};
-if(column.layout&&column.layout.lockVisible)out.lockVisible=true;
-const report=readOptions(column,limits.maxOptions,budget.remaining);
-if(report){
-out.options=report.options.map((o)=>(
-o.label===String(o.value)?{value:o.value}:{value:o.value,label:shorten(o.label,limits.maxLabelLength)}
-));
-budget.remaining-=report.options.length;
-if(report.options.length<report.total){
-out.optionsTotal=report.total;
-truncated.push(`column "${id}": ${report.options.length} of ${report.total} options listed`);
-}
-if(report.open)out.optionsOpen=true;
-}
-return out;
-}
-function readState(grid,limits,truncated){
-const state={sort:[],group:[],quick:'',filters:null};
-if(!grid)return state;
-try{
-if(grid.sort&&isFunction(grid.sort.get)){
-state.sort=(grid.sort.get()||[]).map((e)=>({col:e.col,dir:e.dir}));
-}
-if(grid.columns&&isFunction(grid.columns.state)){
-const group=(grid.columns.state()||[])
-.filter((c)=>typeof c.groupIndex==='number'&&c.groupIndex>=0)
-.sort((a,b)=>a.groupIndex-b.groupIndex);
-state.group=group.map((c)=>c.id);
-}
-if(grid.filters&&isFunction(grid.filters.get)){
-const filters=grid.filters.get()||null;
-const text=filters?JSON.stringify(filters):'';
-if(text.length>limits.maxFilterChars){
-truncated.push('the current filter tree was too large to include; it is summarised as "complex"');
-state.filters='complex';
-}else{
-state.filters=filters;
-}
-}
-}catch{
-}
-return state;
-}
-function describeGrid(grid,opts={}){
-const limits=resolveLimits(opts);
-const truncated=[];
-const budget={remaining:limits.maxTotalOptions};
-let columns=readColumns(grid).filter((c)=>c&&typeof c.id==='string');
-if(opts.includeHidden===false){
-columns=columns.filter((c)=>!(c.layout&&c.layout.hidden));
-}
-const total=columns.length;
-if(total>limits.maxColumns){
-truncated.push(`${total-limits.maxColumns} of ${total} columns omitted; ask the user to narrow the question`);
-columns=columns.slice(0,limits.maxColumns);
-}
-const described=columns.map((c)=>describeColumn(c,limits,budget,truncated));
-if(budget.remaining<=0&&described.some((c)=>c.options)){
-truncated.push(`the total option budget of ${limits.maxTotalOptions} was reached`);
-}
-const schema={
-schemaVersion:SCHEMA_VERSION,
-grid:{columns:total,described:described.length},
-columns:described,
-operators:{
-all:[...OPERATORS],
-byFamily:OPERATORS_BY_FAMILY,
-arity:OPERATOR_ARITY,
-},
-actions:INTENT_ACTIONS.map((a)=>({name:a.name,summary:a.summary,params:a.params})),
-truncated,
-};
-if(opts.includeState!==false)schema.state=readState(grid,limits,truncated);
-return schema;
-}
-function columnIndex(schema){
-const index=new Map();
-const columns=schema&&Array.isArray(schema.columns)?schema.columns:[];
-for(const column of columns){
-if(column&&typeof column.id==='string')index.set(column.id,column);
-}
-return index;
-}
-function operatorsFor(column){
-const family=column&&column.family;
-return(OPERATORS_BY_FAMILY)[family]||OPERATORS_BY_FAMILY.text;
-}
-function columnLine(column){
-const flags=[
-column.filterable?'filter':'',
-column.sortable?'sort':'',
-column.groupable?'group':'',
-column.hidden?'hidden':'',
-].filter(Boolean).join(',');
-let line=`  ${column.id} | ${column.title} | ${column.family} | ${flags}`;
-if(column.options){
-const values=column.options.map((o)=>(
-o.label===undefined?String(o.value):`${String(o.value)}=${o.label}`
-));
-const more=column.optionsTotal?` (+${column.optionsTotal-column.options.length} more)`:'';
-line+=` | options: ${values.join(', ')}${more}`;
-if(column.optionsOpen)line+=' (values outside this list are allowed)';
-}
-return line;
-}
-function promptText(schema){
-if(!isObject(schema))return'';
-const lines=[];
-lines.push(`LATTICE GRID SCHEMA v${schema.schemaVersion||SCHEMA_VERSION}`);
-lines.push('');
-lines.push('COLUMNS  id | title | family | capabilities | options');
-for(const column of schema.columns||[])lines.push(columnLine(column));
-lines.push('');
-lines.push('OPERATORS by family');
-for(const[family,ops]of Object.entries(schema.operators?.byFamily||OPERATORS_BY_FAMILY)){
-lines.push(`  ${family}: ${ops.join(', ')}`);
-}
-lines.push('');
-lines.push('OPERATOR VALUE SHAPES');
-lines.push('  no value: blank, notBlank');
-lines.push('  [lo, hi]: between, notBetween');
-lines.push('  array:    in, notIn, containsAny, containsAll, containsNone');
-lines.push('  scalar:   everything else');
-lines.push('');
-lines.push('ACTIONS (an intent is {"actions": [...]}; nothing outside this list is permitted)');
-for(const action of schema.actions||INTENT_ACTIONS){
-lines.push(`  ${action.name}: ${action.summary}`);
-for(const[key,shape]of Object.entries(action.params||{}))lines.push(`      ${key}: ${shape}`);
-}
-if(schema.state){
-lines.push('');
-lines.push('CURRENT VIEW');
-lines.push(`  sort: ${schema.state.sort?.length?schema.state.sort.map((s)=>`${s.col} ${s.dir}`).join(', '):'none'}`);
-lines.push(`  group: ${schema.state.group?.length?schema.state.group.join(', '):'none'}`);
-lines.push(`  quick filter: ${schema.state.quick?JSON.stringify(schema.state.quick):'none'}`);
-lines.push(`  filters: ${schema.state.filters?JSON.stringify(schema.state.filters):'none'}`);
-}
-if(schema.truncated&&schema.truncated.length){
-lines.push('');
-lines.push('INCOMPLETE: this schema was shortened to fit:');
-for(const note of schema.truncated)lines.push(`  ${note}`);
-}
-lines.push('');
-lines.push('Reply with JSON only. Use exactly the column ids above; never invent one.');
-return lines.join('\n');
-}
-function toolDefinition(schema,opts={}){
-const ids=(schema&&Array.isArray(schema.columns)?schema.columns:[]).map((c)=>c.id);
-const maxEnum=typeof opts.maxEnum==='number'?opts.maxEnum:200;
-const columnId=ids.length&&ids.length<=maxEnum
-?{type:'string',description:'A column id from the grid schema.',enum:ids}
-:{type:'string',description:'A column id from the grid schema.'};
-const condition={
-type:'object',
-description:'A single condition, or a group combining conditions.',
-properties:{
-col:columnId,
-op:{type:'string',enum:[...OPERATORS,'and','or','not']},
-value:{description:'Scalar, [lo, hi] for between, or an array for the set operators.'},
-conditions:{type:'array',description:'Child nodes, when op is and/or/not.',items:{type:'object'}},
-},
-};
-return{
-name:'lattice_grid_intent',
-description:
-'Reshape the data grid: filter, sort, group, show or hide columns. Returns a plan the '
-+'user reviews before it is applied. Use only column ids from the supplied schema.',
-input_schema:{
-type:'object',
-properties:{
-actions:{
-type:'array',
-description:'The steps to take, in order.',
-items:{
-type:'object',
-properties:{
-type:{type:'string',enum:INTENT_ACTIONS.map((a)=>a.name)},
-filters:condition,
-sort:{
-type:'array',
-items:{
-type:'object',
-properties:{col:columnId,dir:{type:'string',enum:['asc','desc']}},
-required:['col','dir'],
-},
-},
-columns:{type:'array',items:columnId},
-text:{type:'string'},
-what:{type:'string',enum:[...CLEAR_TARGETS]},
-},
-required:['type'],
-},
-},
-explain:{type:'string',description:'One short sentence describing the change, for the user.'},
-},
-required:['actions'],
-},
-};
-}
-});
 __def("packages/core/src/ai/intent.js",function(__exports,__req){
 'use strict';
 Object.defineProperty(__exports,"ACTION_NAMES",{enumerable:true,get:function(){return ACTION_NAMES;}});
@@ -32548,6 +32832,7 @@ this.#emit('cell:changed',{
 row:session.row,key:w.key,colId:w.colId,value:w.after,oldValue:w.before,
 },origin);
 }
+if(!this.#batching)this.#announce(session.mode==='row'?'row':'cell',writes,origin);
 }
 this.#emit(session.mode==='row'?'row:edit:end':'cell:edit:end',{
 row:session.row,key:session.key,colId:session.colId,valid:true,writes,
@@ -32696,13 +32981,31 @@ this.#replaying=false;
 this.#emit('cell:changed',{
 row,key,colId,value,oldValue,revert:true,reason:opts.reason??null,
 },opts.origin||'api');
+this.#announce('rollback',[{key,colId,before:oldValue,after:value}],opts.origin||'api');
 return true;
 }
+#announce(reason,writes,origin){
+if(!writes.length)return;
+const updated=[];
+const seen=new Set();
+const columns=new Set();
+for(const w of writes){
+columns.add(w.colId);
+if(seen.has(w.key))continue;
+seen.add(w.key);
+const row=this.#rows.byKey(w.key);
+if(row)updated.push(row);
+}
+this.#emit('rows:changed',{
+identified:true,edit:true,reason,columns:[...columns],
+added:[],updated,removed:[],
+},origin);
+}
 record(type,writes){
 if(!writes||writes.length===0)return;
 this.#record({type,writes:writes.slice(),at:Date.now()});
 }
-batch(type,fn){
+batch(type,fn,opts={}){
 if(this.#batching){fn();return[];}
 this.#batching=[];
 try{
@@ -32712,6 +33015,7 @@ const writes=this.#batching;
 this.#batching=null;
 if(writes.length)this.#record({type,writes,at:Date.now()});
 this.#batched=writes;
+this.#announce(type,writes,opts.origin||'api');
 }
 return this.#batched;
 }
@@ -32747,6 +33051,7 @@ return entry;
 #replay(entry,which,origin){
 this.#replaying=true;
 const writes=which==='before'?[...entry.writes].reverse():entry.writes;
+const landed=[];
 try{
 for(const w of writes){
 const row=this.#rows.byKey(w.key);
@@ -32758,11 +33063,13 @@ if(this.#write(row,column,to,from)){
 this.#emit('cell:changed',{
 row,key:w.key,colId:w.colId,value:to,oldValue:from,undo:which==='before',
 },origin);
+landed.push({key:w.key,colId:w.colId,before:from,after:to});
 }
 }
 }finally{
 this.#replaying=false;
 }
+this.#announce(which==='before'?'undo':'redo',landed,origin);
 }
 clearHistory(){
 this.#undoStack.length=0;
@@ -33292,6 +33599,191 @@ for(const w of waiters)w.resolve({added:[],updated:[],removed:[]});
 }
 }
 });
+__def("packages/core/src/model/where.js",function(__exports,__req){
+'use strict';
+Object.defineProperty(__exports,"WhereModel",{enumerable:true,get:function(){return WhereModel;}});
+const __m0=__req("packages/core/src/internal/util.js");
+const warnOnce=__m0["warnOnce"];
+const isFunction=__m0["isFunction"];
+const isObject=__m0["isObject"];
+class WhereModel{
+#entries=new Map();
+#cache=new Map();
+#version=0;
+register(name,fn,opts={}){
+if(typeof name!=='string'||!name.trim()){
+warnOnce(
+'filters.where.name',
+'filters.where(name, fn) needs a non-empty string name; the predicate was not registered.',
+);
+return false;
+}
+if(!isFunction(fn)){
+warnOnce(
+`filters.where.fn:${name}`,
+`filters.where("${name}", fn) needs a function; the predicate was not registered.`,
+'Pass null to remove a registered predicate.',
+);
+return false;
+}
+const options=isObject(opts)?opts:{};
+let deps=null;
+if(options.deps!==undefined){
+if(Array.isArray(options.deps)&&options.deps.every((d)=>typeof d==='string'&&d)){
+deps=[...options.deps];
+}else{
+warnOnce(
+`filters.where.deps:${name}`,
+`filters.where("${name}", fn, { deps }) needs an array of column ids;`,
+'the predicate is registered but re-runs on every pass instead.',
+);
+}
+}
+let condition=null;
+if(options.condition!==undefined){
+if(isObject(options.condition))condition=options.condition;
+else{
+warnOnce(
+`filters.where.condition:${name}`,
+`filters.where("${name}", fn, { condition }) needs a FilterSet;`,
+'the predicate is registered but nothing is pushed to the source.',
+);
+}
+}
+this.#entries.set(name,{
+name,
+fn,
+deps,
+pinned:options.pinned===true,
+condition,
+});
+this.#cache.delete(name);
+this.#version++;
+return true;
+}
+remove(name){
+if(!this.#entries.delete(name))return false;
+this.#cache.delete(name);
+this.#version++;
+return true;
+}
+clear(){
+let changed=false;
+for(const[name,entry]of this.#entries){
+if(entry.pinned)continue;
+this.#entries.delete(name);
+this.#cache.delete(name);
+changed=true;
+}
+if(changed)this.#version++;
+return changed;
+}
+reapply(name){
+if(name===undefined){
+this.#cache.clear();
+this.#version++;
+return this.#entries.size>0;
+}
+if(!this.#entries.has(name))return false;
+this.#cache.delete(name);
+this.#version++;
+return true;
+}
+names(){
+return[...this.#entries.keys()];
+}
+has(name){
+return this.#entries.has(name);
+}
+conditionFor(name){
+const entry=this.#entries.get(name);
+return entry?entry.condition:null;
+}
+get active(){
+return this.#entries.size>0;
+}
+get version(){
+return this.#version;
+}
+mentions(colId){
+for(const entry of this.#entries.values()){
+if(!entry.deps)return true;
+if(entry.deps.includes(colId))return true;
+}
+return false;
+}
+invalidateCell(key,colId){
+let changed=false;
+for(const entry of this.#entries.values()){
+if(!entry.deps||!entry.deps.includes(colId))continue;
+const byKey=this.#cache.get(entry.name);
+if(byKey&&byKey.delete(key))changed=true;
+}
+if(changed)this.#version++;
+return changed;
+}
+invalidateRow(key){
+let changed=false;
+for(const byKey of this.#cache.values()){
+if(byKey.delete(key))changed=true;
+}
+if(changed)this.#version++;
+return changed;
+}
+invalidateAll(){
+if(!this.#cache.size)return;
+this.#cache.clear();
+this.#version++;
+}
+passes(data,key){
+for(const entry of this.#entries.values()){
+if(!this.#verdict(entry,data,key))return false;
+}
+return true;
+}
+#verdict(entry,data,key){
+if(!entry.deps||key===undefined||key===null)return this.#call(entry,data);
+let byKey=this.#cache.get(entry.name);
+if(!byKey){
+byKey=new Map();
+this.#cache.set(entry.name,byKey);
+}
+const cached=byKey.get(key);
+if(cached!==undefined)return cached;
+const value=this.#call(entry,data);
+byKey.set(key,value);
+return value;
+}
+#call(entry,data){
+try{
+return!!entry.fn(data);
+}catch(error){
+warnOnce(
+`filters.where.threw:${entry.name}`,
+`the where predicate "${entry.name}" threw; its rows are treated as not matching:`,
+error,
+);
+return false;
+}
+}
+conditions(){
+const out=[];
+for(const entry of this.#entries.values()){
+if(entry.condition)out.push(entry.condition);
+}
+if(!out.length)return null;
+return out.length===1?out[0]:{op:'and',conditions:out};
+}
+runtime(){
+return{
+active:this.active,
+names:this.names(),
+version:this.#version,
+passes:(data,key)=>this.passes(data,key),
+};
+}
+}
+});
 __def("packages/core/src/model/validation.js",function(__exports,__req){
 'use strict';
 Object.defineProperty(__exports,"compileValidation",{enumerable:true,get:function(){return compileValidation;}});
@@ -36312,6 +36804,7 @@ const INTEGER_RE=/^[+-]?\d+$/;
 const NUMBER_RE=/^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)$|^[+-]?(?:\d+\.?\d*|\.\d+)$/;
 const BOOLEAN_WORDS=new Set(['true','false','yes','no','y','n']);
 const ISO_DATE_RE=/^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/;
+const ISO_DATE_ONLY_RE=/^\d{4}-\d{2}-\d{2}$/;
 function detectDelimiter(text){
 const firstLine=String(text??'').split(/\r\n|\r|\n/).find((line)=>line.trim()!=='')||'';
 let best=',';
@@ -36373,7 +36866,9 @@ if(!present.length)return'string';
 if(present.every((v)=>INTEGER_RE.test(v.replace(/,/g,''))))return'integer';
 if(present.every((v)=>NUMBER_RE.test(v.replace(/,/g,''))))return'number';
 if(present.every((v)=>BOOLEAN_WORDS.has(v.toLowerCase())))return'boolean';
-if(present.every((v)=>ISO_DATE_RE.test(v)))return'date';
+if(present.every((v)=>ISO_DATE_RE.test(v))){
+return present.every((v)=>ISO_DATE_ONLY_RE.test(v))?'date':'datetime';
+}
 return'string';
 }
 function coerce(raw,type){
@@ -36596,115 +37091,122 @@ const compute=__m25;
 const __m26=__req("packages/core/src/source/index.js");
 const createSource=__m26["createSource"];
 const DERIVED_ROW_KEY=__m26["DERIVED_ROW_KEY"];
-const __m27=__req("packages/core/src/source/rows.js");
-const pinnedRow=__m27["pinnedRow"];
-const DEFAULT_ROW_HEIGHT=__m27["DEFAULT_ROW_HEIGHT"];
-const __m28=__req("packages/core/src/model/rowkey.js");
-const createRowKey=__m28["createRowKey"];
-const __m29=__req("packages/core/src/model/rowmodel.js");
-const RowModel=__m29["RowModel"];
-const createRow=__m29["createRow"];
-const __m30=__req("packages/core/src/model/selection.js");
-const SelectionModel=__m30["SelectionModel"];
-const RangeModel=__m30["RangeModel"];
-const summarise=__m30["summarise"];
-const detectSeries=__m30["detectSeries"];
-const extendSeries=__m30["extendSeries"];
-const __m31=__req("packages/core/src/model/history.js");
-const HistoryModel=__m31["HistoryModel"];
-const __m32=__req("packages/core/src/model/diff.js");
-const DiffModel=__m32["DiffModel"];
-const readValue=__m32["readValue"];
-const __m33=__req("packages/core/src/model/views.js");
-const ViewStore=__m33["ViewStore"];
-const __m34=__req("packages/core/src/model/highlight.js");
-const HighlightModel=__m34["HighlightModel"];
-const __m35=__req("packages/core/src/model/find.js");
-const FindModel=__m35["FindModel"];
-const __m36=__req("packages/core/src/model/redaction.js");
-const RedactionModel=__m36["RedactionModel"];
-const __m37=__req("packages/core/src/model/presentation.js");
-const PresentationModel=__m37["PresentationModel"];
-const __m38=__req("packages/core/src/model/timeline.js");
-const Timeline=__m38["Timeline"];
-const __m39=__req("packages/core/src/model/facets.js");
-const FacetModel=__m39["FacetModel"];
-const DEFAULT_DEBOUNCE=__m39["DEFAULT_DEBOUNCE"];
-const DEFAULT_ROW_CEILING=__m39["DEFAULT_ROW_CEILING"];
-const DEFAULT_FACET_HEIGHT=__m39["DEFAULT_FACET_HEIGHT"];
-const __m40=__req("packages/core/src/model/comments.js");
-const CommentModel=__m40["CommentModel"];
-const parseCommentKey=__m40["parseCellKey"];
-const DEFAULT_INDEX_DEBOUNCE=__m40["DEFAULT_INDEX_DEBOUNCE"];
-const DEFAULT_INDEX_LIMIT=__m40["DEFAULT_INDEX_LIMIT"];
-const __m41=__req("packages/core/src/model/diagnostics.js");
-const Diagnostics=__m41["Diagnostics"];
-const WARNING_IDS=__m41["WARNING_IDS"];
-const instrument=__m41["instrument"];
-const instrumentProvider=__m41["instrumentProvider"];
-const __m42=__req("packages/core/src/model/presence.js");
-const PresenceModel=__m42["PresenceModel"];
-const DEFAULT_THROTTLE_MS=__m42["DEFAULT_THROTTLE_MS"];
-const DEFAULT_IDLE_MS=__m42["DEFAULT_IDLE_MS"];
-const DEFAULT_REMOVE_MS=__m42["DEFAULT_REMOVE_MS"];
-const DEFAULT_LOCK_MS=__m42["DEFAULT_LOCK_MS"];
-const __m43=__req("packages/core/src/compute/facet.js");
-const facetKind=__m43["facetKind"];
-const DEFAULT_BUCKETS=__m43["DEFAULT_BUCKETS"];
-const DEFAULT_CARDINALITY_LIMIT=__m43["DEFAULT_CARDINALITY_LIMIT"];
-const __m44=__req("packages/worker/src/host.js");
-const createWorkerHost=__m44["createWorkerHost"];
-const __m45=__req("packages/core/src/i18n/index.js");
-const Messages=__m45["Messages"];
-const MESSAGE_KEYS=__m45["MESSAGE_KEYS"];
-const __m46=__req("packages/core/src/model/pending.js");
-const PendingWrites=__m46["PendingWrites"];
-const __m47=__req("packages/core/src/model/pending-rows.js");
-const PendingRows=__m47["PendingRows"];
-const isTempKey=__m47["isTempKey"];
-const __m48=__req("packages/core/src/registry/licence.js");
-const setSharedLicence=__m48["setLicence"];
-const licenceInfo=__m48["licenceInfo"];
-const licenceWatermark=__m48["watermark"];
-const licenceState=__m48["licenceState"];
-const sharedLicence=__m48["sharedLicence"];
-const __m49=__req("packages/core/src/columns/permissions.js");
-const PermissionModel=__m49["PermissionModel"];
-const __m50=__req("packages/core/src/ai/schema.js");
-const describeGrid=__m50["describeGrid"];
-const promptText=__m50["promptText"];
-const toolDefinition=__m50["toolDefinition"];
-const __m51=__req("packages/core/src/ai/intent.js");
-const planIntent=__m51["planIntent"];
-const applyPlan=__m51["applyPlan"];
-const buildPrompt=__m51["buildPrompt"];
-const __m52=__req("packages/core/src/model/edit.js");
-const EditModel=__m52["EditModel"];
-const __m53=__req("packages/core/src/model/changes.js");
-const ChangeModel=__m53["ChangeModel"];
-const __m54=__req("packages/core/src/model/state.js");
-const StateModel=__m54["StateModel"];
-const __m55=__req("packages/core/src/formatting/model.js");
-const FormattingModel=__m55["FormattingModel"];
-const GRID_SCOPE=__m55["GRID_SCOPE"];
-const __m56=__req("packages/core/src/model/validation.js");
-const ValidationModel=__m56["ValidationModel"];
-const __m57=__req("packages/core/src/formatting/rules.js");
-const summariseColumn=__m57["summariseColumn"];
-const __m58=__req("packages/core/src/export/index.js");
-const exportCsv=__m58["exportCsv"];
-const exportExcel=__m58["exportExcel"];
-const copyToClipboard=__m58["copyToClipboard"];
-const writeClipboardText=__m58["writeClipboardText"];
-const printGrid=__m58["printGrid"];
-const buildClipboardText=__m58["buildClipboardText"];
-const pasteIntoRange=__m58["pasteIntoRange"];
-const writeHookFor=__m58["writeHookFor"];
-const parseClipboardText=__m58["parseClipboardText"];
-const __m59=__req("packages/core/src/import/index.js");
-const previewImport=__m59["previewImport"];
-const previewXlsx=__m59["previewXlsx"];
-const resolveRecords=__m59["resolveRecords"];
+const __m27=__req("packages/core/src/source/filterwire.js");
+const warnWhereNotApplied=__m27["warnWhereNotApplied"];
+const __m28=__req("packages/core/src/source/rows.js");
+const pinnedRow=__m28["pinnedRow"];
+const DEFAULT_ROW_HEIGHT=__m28["DEFAULT_ROW_HEIGHT"];
+const __m29=__req("packages/core/src/model/rowkey.js");
+const createRowKey=__m29["createRowKey"];
+const warnMissingKeys=__m29["warnMissingKeys"];
+const __m30=__req("packages/core/src/model/rowmodel.js");
+const RowModel=__m30["RowModel"];
+const createRow=__m30["createRow"];
+const __m31=__req("packages/core/src/model/selection.js");
+const SelectionModel=__m31["SelectionModel"];
+const RangeModel=__m31["RangeModel"];
+const resolveSelectionConfig=__m31["resolveSelectionConfig"];
+const summarise=__m31["summarise"];
+const detectSeries=__m31["detectSeries"];
+const extendSeries=__m31["extendSeries"];
+const __m32=__req("packages/core/src/model/history.js");
+const HistoryModel=__m32["HistoryModel"];
+const __m33=__req("packages/core/src/model/diff.js");
+const DiffModel=__m33["DiffModel"];
+const readValue=__m33["readValue"];
+const __m34=__req("packages/core/src/model/views.js");
+const ViewStore=__m34["ViewStore"];
+const __m35=__req("packages/core/src/model/highlight.js");
+const HighlightModel=__m35["HighlightModel"];
+const __m36=__req("packages/core/src/model/find.js");
+const FindModel=__m36["FindModel"];
+const __m37=__req("packages/core/src/model/redaction.js");
+const RedactionModel=__m37["RedactionModel"];
+const __m38=__req("packages/core/src/model/presentation.js");
+const PresentationModel=__m38["PresentationModel"];
+const __m39=__req("packages/core/src/model/timeline.js");
+const Timeline=__m39["Timeline"];
+const __m40=__req("packages/core/src/model/facets.js");
+const FacetModel=__m40["FacetModel"];
+const DEFAULT_DEBOUNCE=__m40["DEFAULT_DEBOUNCE"];
+const DEFAULT_ROW_CEILING=__m40["DEFAULT_ROW_CEILING"];
+const DEFAULT_FACET_HEIGHT=__m40["DEFAULT_FACET_HEIGHT"];
+const __m41=__req("packages/core/src/model/comments.js");
+const CommentModel=__m41["CommentModel"];
+const parseCommentKey=__m41["parseCellKey"];
+const DEFAULT_INDEX_DEBOUNCE=__m41["DEFAULT_INDEX_DEBOUNCE"];
+const DEFAULT_INDEX_LIMIT=__m41["DEFAULT_INDEX_LIMIT"];
+const __m42=__req("packages/core/src/model/diagnostics.js");
+const Diagnostics=__m42["Diagnostics"];
+const WARNING_IDS=__m42["WARNING_IDS"];
+const instrument=__m42["instrument"];
+const instrumentProvider=__m42["instrumentProvider"];
+const __m43=__req("packages/core/src/model/presence.js");
+const PresenceModel=__m43["PresenceModel"];
+const DEFAULT_THROTTLE_MS=__m43["DEFAULT_THROTTLE_MS"];
+const DEFAULT_IDLE_MS=__m43["DEFAULT_IDLE_MS"];
+const DEFAULT_REMOVE_MS=__m43["DEFAULT_REMOVE_MS"];
+const DEFAULT_LOCK_MS=__m43["DEFAULT_LOCK_MS"];
+const __m44=__req("packages/core/src/compute/facet.js");
+const facetKind=__m44["facetKind"];
+const DEFAULT_BUCKETS=__m44["DEFAULT_BUCKETS"];
+const DEFAULT_CARDINALITY_LIMIT=__m44["DEFAULT_CARDINALITY_LIMIT"];
+const __m45=__req("packages/worker/src/host.js");
+const createWorkerHost=__m45["createWorkerHost"];
+const __m46=__req("packages/core/src/i18n/index.js");
+const Messages=__m46["Messages"];
+const MESSAGE_KEYS=__m46["MESSAGE_KEYS"];
+const __m47=__req("packages/core/src/model/pending.js");
+const PendingWrites=__m47["PendingWrites"];
+const __m48=__req("packages/core/src/model/pending-rows.js");
+const PendingRows=__m48["PendingRows"];
+const isTempKey=__m48["isTempKey"];
+const __m49=__req("packages/core/src/registry/licence.js");
+const setSharedLicence=__m49["setLicence"];
+const licenceInfo=__m49["licenceInfo"];
+const licenceWatermark=__m49["watermark"];
+const licenceState=__m49["licenceState"];
+const sharedLicence=__m49["sharedLicence"];
+const __m50=__req("packages/core/src/columns/permissions.js");
+const PermissionModel=__m50["PermissionModel"];
+const __m51=__req("packages/core/src/ai/schema.js");
+const describeGrid=__m51["describeGrid"];
+const promptText=__m51["promptText"];
+const toolDefinition=__m51["toolDefinition"];
+const __m52=__req("packages/core/src/ai/intent.js");
+const planIntent=__m52["planIntent"];
+const applyPlan=__m52["applyPlan"];
+const buildPrompt=__m52["buildPrompt"];
+const __m53=__req("packages/core/src/model/edit.js");
+const EditModel=__m53["EditModel"];
+const __m54=__req("packages/core/src/model/changes.js");
+const ChangeModel=__m54["ChangeModel"];
+const __m55=__req("packages/core/src/model/state.js");
+const StateModel=__m55["StateModel"];
+const sanitizeFilterOperators=__m55["sanitizeFilterOperators"];
+const __m56=__req("packages/core/src/model/where.js");
+const WhereModel=__m56["WhereModel"];
+const __m57=__req("packages/core/src/formatting/model.js");
+const FormattingModel=__m57["FormattingModel"];
+const GRID_SCOPE=__m57["GRID_SCOPE"];
+const __m58=__req("packages/core/src/model/validation.js");
+const ValidationModel=__m58["ValidationModel"];
+const __m59=__req("packages/core/src/formatting/rules.js");
+const summariseColumn=__m59["summariseColumn"];
+const __m60=__req("packages/core/src/export/index.js");
+const exportCsv=__m60["exportCsv"];
+const exportExcel=__m60["exportExcel"];
+const copyToClipboard=__m60["copyToClipboard"];
+const writeClipboardText=__m60["writeClipboardText"];
+const printGrid=__m60["printGrid"];
+const buildClipboardText=__m60["buildClipboardText"];
+const pasteIntoRange=__m60["pasteIntoRange"];
+const writeHookFor=__m60["writeHookFor"];
+const parseClipboardText=__m60["parseClipboardText"];
+const __m61=__req("packages/core/src/import/index.js");
+const previewImport=__m61["previewImport"];
+const previewXlsx=__m61["previewXlsx"];
+const resolveRecords=__m61["resolveRecords"];
 const QUICK_MODES=['contains','words','fuzzy','regex'];
 function canonicalise(column,value){
 const lookup=column&&column.lookup;
@@ -36739,6 +37241,75 @@ const EMPTY_ROWS=Object.freeze([]);
 const AUTOSIZE_PADDING=24;
 const DEFAULT_WIDTH=150;
 const MIN_WIDTH=40;
+const STATE_SECTIONS_BY_ACTION=Object.freeze({
+sort:['sort'],
+group:['group'],
+pivot:['pivot'],
+page:['pagination'],
+formatting:['formatting'],
+view:['redaction'],
+'column:visible':['columns'],
+'column:move':['columns','columnOrder'],
+'column:pin':['columns'],
+'column:resize':['columns'],
+'column:decorate':['columns'],
+'column:groupColumns':['columnGroups'],
+'column:ungroupColumn':['columnGroups'],
+'column:renameGroup':['columnGroups'],
+'column:dissolveGroup':['columnGroups'],
+'column:moveGroup':['columnGroups'],
+});
+const STATE_SECTIONS_BY_COLUMN_CHANGE=Object.freeze({
+move:['columns','columnOrder'],
+visible:['columns'],
+pin:['columns'],
+resize:['columns'],
+decorate:['columns'],
+columngroup:['columnGroups'],
+});
+function roundToTotal(values,maxes){
+const target=Math.round(values.reduce((sum,v)=>sum+v,0));
+const out=values.map((v)=>Math.floor(v));
+let short=target-out.reduce((sum,v)=>sum+v,0);
+const order=values
+.map((_,i)=>i)
+.sort((a,b)=>(values[b]-out[b])-(values[a]-out[a])||a-b);
+for(const i of order){
+if(short<=0)break;
+if(out[i]+1>maxes[i])continue;
+out[i]+=1;
+short-=1;
+}
+return out;
+}
+function shareWithin(weights,mins,maxes,target){
+const n=weights.length;
+const out=new Array(n).fill(0);
+const frozen=new Array(n).fill(false);
+for(let pass=0;pass<n;pass++){
+let remaining=target;
+let weight=0;
+for(let i=0;i<n;i++){
+if(frozen[i])remaining-=out[i];
+else weight+=weights[i];
+}
+if(weight<=0)break;
+let violation=0;
+const moved=new Array(n).fill(0);
+for(let i=0;i<n;i++){
+if(frozen[i])continue;
+const raw=(Math.max(0,remaining)*weights[i])/weight;
+out[i]=Math.min(maxes[i],Math.max(mins[i],raw));
+moved[i]=out[i]-raw;
+violation+=moved[i];
+}
+if(Math.abs(violation)<1e-9)break;
+for(let i=0;i<n;i++){
+if(!frozen[i]&&(violation>0?moved[i]>0:moved[i]<0))frozen[i]=true;
+}
+}
+return out;
+}
 const DATA_KEYS=new Set(['rows','source','rowKey','tree']);
 const COLUMN_KEYS=new Set([
 'columns','columnGroups','columnDefaults','columnPresets','dataTypes',
@@ -36777,6 +37348,7 @@ const CONFIG_SHAPES=Object.freeze({
 aggregateChooser:'boolean',
 allowUnsafeTemplates:'boolean',
 columnVirtualisationAbove:'number',
+direction:['ltr','rtl','auto'],
 groupFooter:'boolean',
 headerControls:['hover','always','hidden'],
 headerHeight:'number',
@@ -36812,7 +37384,13 @@ rows:(v)=>!Array.isArray(v),
 pinnedTopRows:(v)=>!Array.isArray(v),
 pinnedBottomRows:(v)=>!Array.isArray(v),
 alignedGrids:(v)=>!Array.isArray(v),
-rowKey:(v)=>typeof v!=='string'&&typeof v!=='function',
+rowKey:(v)=>{
+if(typeof v==='string'||typeof v==='function')return false;
+if(Array.isArray(v)){
+return v.length===0||v.some((f)=>typeof f!=='string');
+}
+return true;
+},
 rowHeight:(v)=>typeof v!=='number'&&typeof v!=='function',
 source:(v)=>!isPlainObject(v),
 columnDefaults:(v)=>!isPlainObject(v),
@@ -36883,7 +37461,7 @@ const KNOWN_CONFIG_KEYS=new Set([
 'columnGroups','columnMenu','columnPresets','columnTagFilter',
 'columnVirtualisationAbove','columns','comments','components','context',
 'contextMenu','cornerRadius','dataTypes','density','detail','diff','edit',
-'environment','facets','find','formatting','formulaFunctions','fullWidth','gallery',
+'direction','environment','facets','find','formatting','formulaFunctions','fullWidth','gallery',
 'grandTotalRow','gridLines','groupFooter','groupPanel','headerHeight','highlightOnChange',
 'headerControls','historyBar','hostFilter','import','ingest','kpis','licence','locale','maximise','overscan','pagination',
 'permissions','pinnedBottomRows','pinnedTopRows','pipes','pivot','pivotView','presence',
@@ -36940,6 +37518,10 @@ static#nextSourceId=1;
 #validation;
 #validationWired=false;
 #baseline=null;
+#stateDepth=0;
+#stateCause=null;
+#stateSections=new Set();
+#stateApplied=null;
 #highlights;
 #find;
 #flashOnChange=null;
@@ -36973,6 +37555,7 @@ static#nextSourceId=1;
 #structuralKinds={append:false,delete:false};
 #rowKey;
 #rowKeyResolver;
+#where=new WhereModel();
 #query={
 sort:([]),
 filters:(null),
@@ -37195,7 +37778,10 @@ computeColumn:(colId,bounds)=>this.#computeFacet(colId,bounds),
 this.#buildColumns();
 this.#buildModels();
 this.#buildSource();
-this.#bus.on('rows:changed',(e)=>{if(e&&e.derived===true)this.#refresh('rows');});
+this.#bus.on('rows:changed',(e)=>{
+if(!e||e.derived!==true)return;
+this.#refresh('rows');
+});
 this.#bus.on('timeline:seeking',()=>this.#clearTimelineMarks());
 this.#bus.on('timeline:detached',()=>this.#clearTimelineMarks());
 this.#timeline=new Timeline({
@@ -37298,9 +37884,13 @@ if(rowMutate&&typeof rowMutate==='object'&&isFunction(rowMutate.mutate)
 this.#buildStructuralWrites(rowMutate);
 }
 this.#applyInitialColumnState();
-if(this.#config.state)this.state.apply(this.#config.state);
-if(!this.#config.state)this.#applyDefaultView();
+if(this.#config.state){
+this.#baseline=this.#stateModel.get();
+this.state.apply(this.#config.state);
+}else{
+this.#applyDefaultView();
 this.#baseline=this.#stateModel.get();
+}
 this.#history?.clear();
 const readyHandle=nextFrame(()=>{
 if(this.#destroyed)return;
@@ -37409,6 +37999,7 @@ stored:{
 has:(id)=>!!(this.#store&&this.#store.column(id)),
 get:(id,physical)=>this.#store.get(id,physical),
 },
+rowKey:this.#rowKeyResolver&&this.#rowKeyResolver.stable?this.#rowKey:undefined,
 });
 this.#permissions=new PermissionModel({
 permissions:config.permissions,
@@ -37486,6 +38077,7 @@ emitBefore,
 this.#ranges=new RangeModel({
 columnIds:()=>this.#columns.visible().map((c)=>c.id),
 rowCount:()=>this.rows.count(),
+enabled:resolveSelectionConfig(config.selection).ranges,
 emit,
 });
 this.#editModel=new EditModel({
@@ -37520,6 +38112,7 @@ host:{
 add:(objects,at,sink)=>{
 const applied=this.#source.apply({add:objects,at});
 if(sink&&applied.rejected)sink.push(...applied.rejected);
+this.#invalidateComputed({rows:keysOf(applied.added)});
 return applied.added;
 },
 update:(objects,sink)=>{
@@ -37527,11 +38120,13 @@ const applied=this.#source.apply({update:objects});
 if(sink&&applied.rejected)sink.push(...applied.rejected);
 const updated=applied.updated;
 this.#syncRowsToStore(updated);
+this.#invalidateComputed({rows:keysOf(updated)});
 return updated;
 },
 remove:(keys,sink)=>{
 const applied=this.#source.apply({remove:keys});
 if(sink&&applied.rejected)sink.push(...applied.rejected);
+this.#invalidateComputed({rows:keysOf(applied.removed)});
 return applied.removed;
 },
 },
@@ -37580,6 +38175,7 @@ quick:()=>this.#query.quick,
 quickMode:()=>this.#query.quickMode||'contains',
 setQuick:(t)=>this.filters.quick(t),
 setQuickMode:(mode)=>this.filters.quick(this.#query.quick||'',{mode}),
+where:()=>this.filters.where(),
 },
 group:{
 get:()=>[...this.#query.groupBy],
@@ -37617,7 +38213,10 @@ scroll:{
 position:()=>(this.#renderer?this.#renderer.scrollPosition():{top:0,left:0}),
 scrollTo:(pos)=>this.#renderer&&this.#renderer.scrollTo?.(pos),
 },
-emit,
+emit:(type,payload,origin)=>{
+if(type==='state:changed'){this.#stateFromModel(payload);return undefined;}
+return emit(type,payload,origin);
+},
 });
 this.#history=new HistoryModel({
 depth:config.edit&&config.edit.undoDepth,
@@ -37628,8 +38227,10 @@ delete snapshot.selection;
 return snapshot;
 },
 apply:(patch)=>{
+this.#stateChange('apply',undefined,()=>{
 this.#stateModel.apply(patch,{origin:'undo'});
 this.#refresh('rows');
+});
 },
 edit:this.#editModel,
 });
@@ -37669,6 +38270,8 @@ retainSource:this.#storeRetainSource(),
 }
 this.#facets?.invalidate();
 this.#facetCache?.clear();
+this.#invalidateComputed();
+const previous=this.#source||null;
 this.#source=createSource(sourceConfig,{
 columns:this.#columns,
 columnHidden:(colId)=>!this.#permissions.isReadable(colId),
@@ -37685,7 +38288,8 @@ storeSchema:()=>this.#columns.storeSchema(),
 config,
 state:{
 sort:()=>this.#query.sort,
-filters:()=>this.#query.filters,
+filters:()=>this.#queryFilters(),
+where:()=>this.#where.runtime(),
 quick:()=>this.#query.quick,
 quickMode:()=>this.#query.quickMode||'contains',
 groupBy:()=>this.#query.groupBy,
@@ -37705,6 +38309,7 @@ idle:(fn)=>whenIdle(fn),
 cancel:(handle)=>cancelFrame(handle),
 },
 });
+if(previous&&previous!==this.#source)previous.destroy?.();
 if(this.#store){
 this.#ingest(config.rows||[]);
 this.#interceptApply();
@@ -37721,6 +38326,7 @@ this.#bus.emit('columns:changed',{reason:'inferred',types:inferred},'api');
 if(!this.#rowKeyResolver||this.#rowKeyResolver.stable===false){
 return{kept:additions,rejected:[]};
 }
+warnMissingKeys(this.#rowKeyResolver,additions);
 const kept=[];
 const rejected=[];
 const seen=new Set();
@@ -37737,6 +38343,7 @@ return{kept,rejected};
 }
 #ingest(rows){
 if(!this.#store||!rows.length)return;
+warnMissingKeys(this.#rowKeyResolver,rows);
 this.#store.append(rows);
 this.#observeShadows();
 }
@@ -37969,6 +38576,40 @@ value=column.field?getPath(data,column.field):column.getValue(data,row);
 store.set(column.id,physical,value);
 }
 }
+#invalidateComputed(opts){
+this.#values?.invalidate?.(opts);
+const model=this.#columns&&isFunction(this.#columns.pipeline)
+?this.#columns.pipeline():null;
+if(model&&model!==this.#values)model.invalidate?.(opts);
+}
+#rematerialise(keys,colIds){
+const store=this.#store;
+if(!store||!this.#columns)return;
+let targets=this.#columns.all().filter((c)=>c.computed&&store.column(c.id));
+if(colIds){
+const named=[...colIds];
+const wanted=new Set([...named,...this.#columns.affectedBy(named)]);
+targets=targets.filter((c)=>wanted.has(c.id));
+}
+if(!targets.length)return;
+const order=this.#values.graph&&this.#values.graph.order;
+if(order)targets.sort((a,b)=>order.indexOf(a.id)-order.indexOf(b.id));
+const source=this.#source;
+let rows;
+if(keys){
+rows=[...keys].map((key)=>(isFunction(source.byKey)?source.byKey(String(key)):undefined));
+}else if(isFunction(source.unfilteredRows)){
+rows=source.unfilteredRows();
+}else{
+rows=this.#displayRows();
+}
+for(const row of rows){
+if(!row||row.group||row.physical==null||row.data==null)continue;
+for(const column of targets){
+store.set(column.id,row.physical,this.#values.compute(column,row.data,row));
+}
+}
+}
 #stampSelection(row){
 if(row&&!row.group&&row.key!==undefined){
 row.selected=this.#selection.has(row.key);
@@ -37997,6 +38638,8 @@ for(const stage of['sort','group','total','pivot'])this.#source.invalidate?.(sta
 }
 this.#bus.emit(map[kind]||'model:changed',payload||{},'api');
 this.#renderer?.invalidate('columns');
+const moved=(STATE_SECTIONS_BY_COLUMN_CHANGE)[kind];
+if(moved)this.#noteStateSections(moved,'user');
 }
 #runStages(plan){
 const stages=(plan&&plan.stages)||[];
@@ -38861,12 +39504,17 @@ for(const dependent of this.#columns.affectedBy([colId])){
 if(dependent===colId)continue;
 const target=this.#columns.get(dependent);
 if(!target||!this.#store||!this.#store.column(dependent))continue;
-this.#store.set(dependent,row.physical,rawOf(target));
+const value=target.computed
+?this.#values.compute(target,row.data,row)
+:rawOf(target);
+this.#store.set(dependent,row.physical,value);
 }
+this.#where.invalidateCell(row.key,colId);
 const queried=this.#query.sort.some((s)=>s.col===colId)
 ||this.#query.groupBy.includes(colId)
 ||this.#query.pivotBy.includes(colId)
-||filterMentions(this.#query.filters,colId);
+||filterMentions(this.#query.filters,colId)
+||this.#where.mentions(colId);
 this.#source.invalidate?.(queried?'filter':'total');
 }
 #storeStats(){
@@ -39521,7 +40169,14 @@ out[column.id]=grid.#values.value(column,row&&row.data,row);
 }
 return out;
 },
-refresh(opts){grid.#renderer?.refresh(opts||{});},
+refresh(opts){
+const what=opts||{};
+grid.#values.invalidate(what);
+if(what.rows||what.columns||!grid.#store)grid.#columns.pipeline().invalidate(what);
+if(what.force)grid.#rematerialise(what.rows,what.columns);
+grid.#source?.invalidateHandles?.();
+grid.#renderer?.refresh(what);
+},
 expand(key,deep){grid.#setExpanded(key,true);if(deep)grid.rows.expandAll();},
 collapse(key){grid.#setExpanded(key,false);},
 expandAll(){
@@ -39584,7 +40239,8 @@ if(query.quick)return true;
 const filters=query.filters;
 if(filters&&Object.keys(filters).length)return true;
 const host=this.#config.hostFilter;
-return!!(host&&isFunction(host.active)&&host.active());
+if(host&&isFunction(host.active)&&host.active())return true;
+return this.#where.active;
 }
 get form(){
 return{
@@ -39673,18 +40329,40 @@ grid.#renderer.invalidate('columns');
 fit(){
 const renderer=grid.#renderer;
 if(!renderer)return;
-const available=renderer.viewportWidth;
-const visible=model.visible().filter((c)=>c.layout&&c.layout.resizable!==false);
-if(!available||!visible.length)return;
-const total=visible.reduce((sum,c)=>sum+(c.layout.width||DEFAULT_WIDTH),0);
-if(total<=0)return;
-const scale=available/total;
-for(const column of visible){
-const current=column.layout.width||DEFAULT_WIDTH;
-const min=column.layout.min??MIN_WIDTH;
-const max=column.layout.max??Infinity;
-model.resize(column.id,Math.max(min,Math.min(max,Math.round(current*scale))));
-}
+const available=typeof renderer.measureViewportWidth==='function'
+?renderer.measureViewportWidth()
+:renderer.viewportWidth;
+if(!available)return;
+const drawn=typeof renderer.drawnColumns==='function'
+?renderer.drawnColumns()
+:model.visible().map((c)=>({id:c.id,width:c.layout&&c.layout.width}));
+const sized=[];
+let unsized=0;
+for(const entry of drawn){
+const column=model.get(entry.id);
+const width=Number(entry.width)>0?Number(entry.width):0;
+if(column&&column.layout&&column.layout.resizable!==false){
+sized.push({column,weight:width||DEFAULT_WIDTH});
+}else{
+unsized+=width;
+}
+}
+if(!sized.length)return;
+const target=available-unsized;
+const mins=sized.map(({column})=>(column.layout.min>0?column.layout.min:MIN_WIDTH));
+const maxes=sized.map(({column})=>(column.layout.max>0?column.layout.max:Infinity));
+const floor=mins.reduce((sum,v)=>sum+v,0);
+if(target<floor){
+warnOnce('columns.fit-overflow',
+`columns.fit(): the columns it does not size (resizable: false, and the grid's own checkbox, `
++`expander, group and tree columns) take ${Math.round(unsized)}px of a ${Math.round(available)}px `
++`viewport, leaving ${Math.max(0,Math.round(target))}px for ${sized.length} column(s) that need `
++`at least ${Math.round(floor)}px. They are set to their minimum widths and the grid scrolls `
++'horizontally. Narrow the fixed columns, lower the minimums, or widen the grid.');
+}
+const ideal=shareWithin(sized.map((s)=>s.weight),mins,maxes,Math.max(0,target));
+const widths=roundToTotal(ideal,maxes);
+sized.forEach(({column},i)=>model.resize(column.id,widths[i]));
 renderer.invalidate('columns');
 },
 group(ids){
@@ -39843,15 +40521,49 @@ set(filters){
 return grid.#gateBefore('beforeFilter','filter:cancelled',
 {filters,kind:'structured',origin:'user'},
 ()=>grid.#tracked('filter','filter',()=>{
-grid.#query.filters=grid.#permissions.pruneFilters(filters||null);
+const permitted=grid.#permissions.pruneFilters(filters||null);
+grid.#query.filters=sanitizeFilterOperators(
+permitted,(id)=>grid.#columns.get(id),
+);
 grid.#source.invalidate?.('filter');
-grid.#bus.emit('filter:changed',{filters},'api');
+grid.#bus.emit('filter:changed',{filters:grid.#query.filters},'api');
 grid.#facets.refresh();
 grid.#renderer?.refreshHeader?.();
 grid.#refresh('rows');
 }));
 },
-clear(){this.set(null);grid.#query.quick='';},
+clear(){
+grid.#where.clear();
+this.set(null);
+grid.#query.quick='';
+},
+where(name,predicate,opts){
+if(name===undefined)return grid.#where.names();
+if(predicate===null){
+if(grid.#where.remove(name))grid.#whereChanged();
+return undefined;
+}
+if(grid.#where.register(name,predicate,opts)){
+grid.#warnWhereWindowed(name);
+grid.#whereChanged();
+}
+return undefined;
+},
+reapply(name){
+const moved=grid.#where.reapply(name);
+if(moved){
+grid.#whereChanged();
+return true;
+}
+if(name!==undefined){
+warnOnce(
+`filters.reapply:${name}`,
+`filters.reapply(${JSON.stringify(name)}) names no registered where predicate;`,
+'nothing was re-run.',
+);
+}
+return false;
+},
 quick(text,opts){
 return grid.#gateBefore('beforeFilter','filter:cancelled',
 {quick:text,kind:'quick',origin:'user'},
@@ -39874,6 +40586,32 @@ quickMode:this.#query.quickMode||'contains',
 this.#renderer?.refreshHeader?.();
 this.#refresh('rows');
 }
+#warnWhereWindowed(name){
+const mode=this.#source&&this.#source.mode;
+if(mode!=='paged'&&mode!=='remote')return;
+const sourceConfig=(this.#config.source);
+if(sourceConfig&&sourceConfig.adapter)return;
+if(this.#where.conditionFor(name))return;
+warnWhereNotApplied(name,mode);
+}
+#whereChanged(){
+this.#source.invalidate?.('filter');
+this.#bus.emit('filter:changed',{
+filters:this.#query.filters,
+where:this.#where.names(),
+cause:'where',
+},'api');
+this.#facets.refresh();
+this.#renderer?.refreshHeader?.();
+this.#refresh('rows');
+}
+#queryFilters(){
+const twin=this.#where.conditions();
+if(!twin)return this.#query.filters;
+const own=this.#query.filters;
+if(!own||!Object.keys(own).length)return twin;
+return{op:'and',conditions:[own,twin]};
+}
 get pagination(){
 const grid=this;
 return{
@@ -39923,9 +40661,62 @@ const column=this.#columns.get(id);
 return(column&&(column.title||column.id))||id;
 }
 #tracked(type,label,fn,opts={}){
+const sections=type==='filter'
+?(opts.target==='quick'?['quick']:['filters'])
+:(STATE_SECTIONS_BY_ACTION)[type];
+return this.#stateChange('user',sections,()=>{
 if(!this.#history){fn();return;}
 this.#history.transaction(label,fn,{type,...opts});
 this.#historyChanged();
+});
+}
+#stateChange(cause,sections,fn){
+if(this.#stateDepth===0){
+this.#stateCause=cause;
+this.#stateSections.clear();
+this.#stateApplied=null;
+}
+if(sections)for(const section of sections)this.#stateSections.add(section);
+this.#stateDepth++;
+try{
+return fn();
+}finally{
+this.#stateDepth--;
+if(this.#stateDepth===0)this.#announceStateChange();
+}
+}
+#noteStateSections(sections,cause){
+if(this.#stateDepth>0){
+for(const section of sections)this.#stateSections.add(section);
+return;
+}
+this.#stateChange(cause,sections,()=>{});
+}
+#stateFromModel(payload){
+const report=((payload&&payload.report)||null);
+const sections=report&&Array.isArray(report.applied)?report.applied:[];
+const applied={state:((payload&&payload.state)||null),report};
+if(this.#stateDepth>0){
+for(const section of sections)this.#stateSections.add(section);
+this.#stateApplied=applied;
+return;
+}
+this.#stateChange('apply',sections,()=>{this.#stateApplied=applied;});
+}
+#announceStateChange(){
+const cause=this.#stateCause;
+const applied=this.#stateApplied;
+const sections=[...this.#stateSections].sort();
+this.#stateCause=null;
+this.#stateApplied=null;
+this.#stateSections.clear();
+if(!cause)return;
+this.#bus.emit('state:changed',{
+cause,
+sections,
+state:applied?applied.state:null,
+report:applied?applied.report:null,
+},cause==='user'?'user':'api');
 }
 #gateBefore(beforeName,cancelledName,payload,apply,revalidate){
 const origin=(payload.origin)||'user';
@@ -39967,7 +40758,7 @@ if(named)this.#bus.emit(named,{view,views,reason},'api');
 #applyDefaultView(){
 const view=this.#views.defaultView();
 if(!view||!view.state)return;
-this.#stateModel.apply(view.state);
+this.#stateChange('apply',undefined,()=>this.#stateModel.apply(view.state));
 this.#activeView=view.id;
 }
 #permissionsChanged(){
@@ -40254,7 +41045,21 @@ return{
 get(){return[...grid.#query.sort];},
 set(entries){
 entries=(Array.isArray(entries)?entries:[])
-.filter((e)=>e&&grid.#permissions.isReadable(e.col));
+.filter((e)=>{
+if(!isObject(e))return false;
+if(typeof e.col!=='string'||!e.col){
+const keys=Object.keys(e).sort().join(', ')||'(none)';
+warnOnce(`grid.sort.shape.${keys}`,
+`sort ignores an entry with keys { ${keys} }; expected { col, dir } `
++'(AG Grid\'s sort model uses "colId"/"direction" — this grid uses "col"/"dir").');
+return false;
+}
+if(!grid.#columns.get(e.col)){
+warnOnce(`grid.sort.unknown.${e.col}`,`sort ignores unknown column "${e.col}".`);
+return false;
+}
+return grid.#permissions.isReadable(e.col);
+});
 const first=Array.isArray(entries)&&entries[0];
 const label=first?`sort by ${grid.#columnTitle(first.col)}`:'clear sort';
 return grid.#gateBefore('beforeSort','sort:cancelled',
@@ -40383,7 +41188,7 @@ deferred.push((result));
 applied++;
 }
 }
-});
+},{origin});
 if(deferred.length){
 return Promise.all(deferred).then((results)=>{
 for(const r of results)if(r&&r.ok!==false)applied++;
@@ -40679,9 +41484,11 @@ const{state}=grid.#permissions.sanitiseState(grid.#stateModel.get());
 return state;
 },
 apply(state,opts){
+return grid.#stateChange('apply',undefined,()=>{
 const report=grid.#stateModel.apply(state,opts);
 grid.#refresh('rows');
 return report;
+});
 },
 baseline(){
 if(!grid.#baseline)return null;
@@ -40691,11 +41498,13 @@ return state;
 reset(){
 if(!grid.#baseline)return null;
 let report=null;
+grid.#stateChange('reset',undefined,()=>{
 grid.#tracked('state','restore the default view',()=>{
 report=grid.#stateModel.apply(grid.#baseline);
 grid.#setQuick(grid.#baseline.quick||'');
 grid.#refresh('rows');
 });
+});
 grid.#bus.emit('state:reset',{state:grid.#baseline},'api');
 return report;
 },
@@ -41715,6 +42524,15 @@ return VERSION;
 function version(){
 return VERSION;
 }
+function keysOf(list){
+const out=[];
+for(const entry of list||[]){
+if(entry==null)continue;
+const key=typeof entry==='object'?(entry).key:entry;
+if(key!=null)out.push(String(key));
+}
+return out;
+}
 function optimisticConfig(config,sourceEdit,warnIfNoCommit){
 if(config===true){
 const fromSource=sourceEdit&&typeof sourceEdit==='object'
@@ -52683,10 +53501,13 @@ const __m5=__req("packages/core/src/model/state.js");
 Object.defineProperty(__exports,"StateModel",{enumerable:true,get:function(){return __m5["StateModel"];}});
 Object.defineProperty(__exports,"migrateState",{enumerable:true,get:function(){return __m5["migrateState"];}});
 Object.defineProperty(__exports,"pruneFilters",{enumerable:true,get:function(){return __m5["pruneFilters"];}});
+Object.defineProperty(__exports,"sanitizeFilterOperators",{enumerable:true,get:function(){return __m5["sanitizeFilterOperators"];}});
 Object.defineProperty(__exports,"STATE_VERSION",{enumerable:true,get:function(){return __m5["STATE_VERSION"];}});
 Object.defineProperty(__exports,"STATE_KEYS",{enumerable:true,get:function(){return __m5["STATE_KEYS"];}});
 Object.defineProperty(__exports,"serialiseState",{enumerable:true,get:function(){return __m5["serialiseState"];}});
 Object.defineProperty(__exports,"restoreState",{enumerable:true,get:function(){return __m5["restoreState"];}});
+const __m6=__req("packages/core/src/model/where.js");
+Object.defineProperty(__exports,"WhereModel",{enumerable:true,get:function(){return __m6["WhereModel"];}});
 });
 __def("packages/core/src/index.js",function(__exports,__req){
 'use strict';
@@ -53177,6 +53998,7 @@ class Viewport{
 #headerCentreWidth=NaN;
 #rowFill='\u0000';
 #clipWidth='\u0000';
+#placed=new WeakMap();
 constructor(element,opts={}){
 const document=opts.document||element.ownerDocument||globalThis.document;
 if(!document||typeof document.createElement!=='function'){
@@ -53338,6 +54160,10 @@ record.el.style.height=`${height}px`;
 placeCell(cell,left,width){
 cell.style.transform=`translate3d(${signedX(left,this.#rtl)}px, 0, 0)`;
 cell.style.width=`${width}px`;
+this.#placed.set(cell,{left,width});
+}
+placed(cell){
+return this.#placed.get(cell);
 }
 }
 });
@@ -54047,7 +54873,7 @@ const root=doc.createElement('div');
 root.className=ROOT;
 root.setAttribute('data-col',this.#colId);
 root.setAttribute('role','group');
-root.setAttribute('aria-label',`${title} distribution filter`);
+root.setAttribute('aria-label',this.#t('facets.filter',{column:title}));
 const bars=doc.createElement('div');
 bars.className=`${ROOT}__bars`;
 root.appendChild(bars);
@@ -54284,6 +55110,7 @@ class Accessibility{
 #focus={rowKey:null,rowIndex:-1,colId:null};
 #inside=false;
 #tabStop=null;
+#reclaim=false;
 #headerRows=1;
 #live=null;
 #lastAnnounced='';
@@ -54407,21 +55234,38 @@ return true;
 }
 place(el){
 const root=this.#viewport.root;
+const dropped=this.#reclaim&&this.#focusDropped();
+this.#reclaim=false;
 if(!el){
 if(this.#tabStop&&this.#tabStop!==root)this.#tabStop.setAttribute('tabindex','-1');
 root.setAttribute('tabindex','0');
 this.#tabStop=root;
+if(dropped&&isFunction(root.focus))root.focus();
 return;
 }
 if(this.#tabStop===el){
-if(this.#shouldFocus(el))el.focus();
+if(dropped||this.#shouldFocus(el))el.focus();
 return;
 }
 if(this.#tabStop&&this.#tabStop!==root)this.#tabStop.setAttribute('tabindex','-1');
 root.setAttribute('tabindex','-1');
 el.setAttribute('tabindex','0');
 this.#tabStop=el;
-if(this.#shouldFocus(el))el.focus();
+if(dropped||this.#shouldFocus(el))el.focus();
+}
+keepFocus(){
+const doc=this.#viewport.document;
+const root=this.#viewport.root;
+const active=doc.activeElement;
+const held=!!active&&active!==doc.body
+&&isFunction(root.contains)&&root.contains(active);
+if(held)this.#reclaim=true;
+return held;
+}
+#focusDropped(){
+const doc=this.#viewport.document;
+const active=doc.activeElement;
+return!active||active===doc.body;
 }
 #shouldFocus(el){
 if(!this.#inside)return false;
@@ -54703,7 +55547,11 @@ const spec=column.header;
 if(!spec)return false;
 if(spec.class){
 const classes=Array.isArray(spec.class)?spec.class:[spec.class];
-for(const name of classes)if(name)label.parentNode?.classList?.add(String(name));
+const cell=label.parentNode;
+for(const entry of classes){
+if(!entry)continue;
+for(const name of String(entry).split(/\s+/))if(name)cell?.classList?.add(name);
+}
 }
 if(!spec.render)return false;
 const impl=this.#resolveHeaderRenderer(spec.render,column);
@@ -54859,7 +55707,9 @@ el.setAttribute('title',this.#t('header.dragHint',{column:column.title??column.i
 el.setAttribute('aria-roledescription',this.#t('header.dragRole'));
 }
 el.addEventListener('keydown',(e)=>{
-if(this.#onHeaderKey(e,slot)&&isFunction(e.preventDefault))e.preventDefault();
+if(!this.#onHeaderKey(e,slot))return;
+if(isFunction(e.preventDefault))e.preventDefault();
+if(isFunction(e.stopPropagation))e.stopPropagation();
 });
 this.#attachBand(el,slot.id);
 this.#cells.set(slot.id,el);
@@ -54955,7 +55805,7 @@ const name=label.ownerDocument.createElement('span');
 name.className=PART.totalName;
 name.textContent=title;
 label.appendChild(name);
-if(prefix)label.setAttribute('title',`${prefix} of ${title}`);
+if(prefix)label.setAttribute('title',this.#t('header.totalOf',{total:prefix,column:title}));
 else label.removeAttribute('title');
 if(prefix)el.setAttribute('data-total',String(column.total));
 else el.removeAttribute('data-total');
@@ -57886,6 +58736,10 @@ const isTextEntry=__m0["isTextEntry"];
 const isFindBarControl=__m0["isFindBarControl"];
 const __m1=__req("packages/dom/src/detailhost.js");
 const insideDetail=__m1["insideDetail"];
+const __m2=__req("packages/core/src/model/selection.js");
+const resolveSelectionConfig=__m2["resolveSelectionConfig"];
+const __m3=__req("packages/core/src/columns/selectcolumn.js");
+const SELECT_COLUMN_ID=__m3["SELECT_COLUMN_ID"];
 const SHORTCUTS=Object.freeze({
 'ArrowUp/Down/Left/Right':'Move the focused cell',
 'Home / End':'First / last cell of the row',
@@ -58028,6 +58882,10 @@ case'Enter':
 return this.#run('edit',{rowIndex:rowAt,colId:columns[colAt]});
 case' ':
 case'Spacebar':
+if(resolveSelectionConfig(this.#host.grid?.get?.('selection')).checkboxOnly
+&&current.colId!==SELECT_COLUMN_ID){
+return true;
+}
 this.#run('select',{rowIndex:rowAt,extend:event.shiftKey,toggle:ctrl||!event.shiftKey});
 return true;
 case'Escape':
@@ -58090,6 +58948,7 @@ Object.defineProperty(__exports,"resolveStripedRows",{enumerable:true,get:functi
 Object.defineProperty(__exports,"resolveScrollbars",{enumerable:true,get:function(){return resolveScrollbars;}});
 Object.defineProperty(__exports,"DEFAULT_OVERSCAN",{enumerable:true,get:function(){return DEFAULT_OVERSCAN;}});
 Object.defineProperty(__exports,"textCellLayer",{enumerable:true,get:function(){return textCellLayer;}});
+Object.defineProperty(__exports,"clientExtent",{enumerable:true,get:function(){return clientExtent;}});
 Object.defineProperty(__exports,"DomRenderer",{enumerable:true,get:function(){return DomRenderer;}});
 Object.defineProperty(__exports,"displayIndexOf",{enumerable:true,get:function(){return displayIndexOf;}});
 const __m0=__req("packages/core/src/internal/util.js");
@@ -58140,13 +58999,15 @@ const __m18=__req("packages/core/src/columns/selectcolumn.js");
 const SELECT_COLUMN_ID=__m18["SELECT_COLUMN_ID"];
 const __m19=__req("packages/core/src/columns/detailcolumn.js");
 const DETAIL_COLUMN_ID=__m19["DETAIL_COLUMN_ID"];
-const __m20=__req("packages/dom/src/renderer/scaled.js");
-const scaleFor=__m20["scaleFor"];
-const anchor=__m20["anchor"];
-const anchorAt=__m20["anchorAt"];
-const rowAtContent=__m20["rowAtContent"];
-const __m21=__req("packages/dom/src/detailhost.js");
-const insideDetail=__m21["insideDetail"];
+const __m20=__req("packages/core/src/model/selection.js");
+const resolveSelectionConfig=__m20["resolveSelectionConfig"];
+const __m21=__req("packages/dom/src/renderer/scaled.js");
+const scaleFor=__m21["scaleFor"];
+const anchor=__m21["anchor"];
+const anchorAt=__m21["anchorAt"];
+const rowAtContent=__m21["rowAtContent"];
+const __m22=__req("packages/dom/src/detailhost.js");
+const insideDetail=__m22["insideDetail"];
 function resolveGroupHeadingDepth(config){
 if(config===false||config===undefined||config===null)return 0;
 if(config===true)return 2;
@@ -58194,6 +59055,14 @@ releaseCell(el,_column){el.textContent='';},
 function now(){
 return typeof performance==='object'&&performance?performance.now():Date.now();
 }
+function clientExtent(client,offset,rect){
+const c=Number(client)||0;
+if(!(c>0))return 0;
+const o=Number(offset)||0;
+const r=Number(rect)||0;
+if(!(o>0)||!(r>0)||Math.abs(r-o)>=1)return c;
+return Math.max(0,Math.floor(r-(o-c)));
+}
 class DomRenderer{
 #element;
 #host;
@@ -58710,6 +59579,20 @@ this.#header.paintBands();
 get cellLayer(){return this.#cellLayer;}
 get headerLevels(){return this.#header?this.#header.levels:1;}
 get viewportWidth(){return this.#size.width;}
+measureViewportWidth(){
+if(this.#destroyed)return this.#size.width;
+this.#scroll.flush();
+const body=this.#viewport.bodyViewport;
+if(!body)return this.#size.width;
+const rect=typeof body.getBoundingClientRect==='function'?body.getBoundingClientRect():null;
+const width=clientExtent(body.clientWidth,body.offsetWidth,rect?rect.width:0);
+return width>0?width:this.#size.width;
+}
+drawnColumns(){
+if(this.#destroyed)return[];
+return[...this.#layout.start,...this.#layout.centre,...this.#layout.end]
+.map((slot)=>({id:slot.id,width:slot.width}));
+}
 get stats(){
 return{
 ...this.#stats,
@@ -58768,11 +59651,12 @@ if(this.#needsSize){
 const body=this.#viewport.bodyViewport;
 const rect=body.getBoundingClientRect();
 const root=this.#viewport.root.getBoundingClientRect();
+const offsetHeight=Number(body.offsetHeight)||0;
 this.#size={
-width:body.clientWidth||rect.width||root.width||0,
-height:body.clientHeight||rect.height||Math.max(0,(root.height||0)-this.#header.height),
+width:clientExtent(body.clientWidth,body.offsetWidth,rect.width)||rect.width||root.width||0,
+height:clientExtent(body.clientHeight,offsetHeight,rect.height)||rect.height
+||Math.max(0,(root.height||0)-this.#header.height),
 };
-const offsetHeight=Number(body.offsetHeight)||0;
 this.#hscroll=offsetHeight&&body.clientHeight?Math.max(0,offsetHeight-body.clientHeight):0;
 const bodyTop=Number(body.offsetTop);
 const rootEl=this.#viewport.root;
@@ -59082,7 +59966,12 @@ if(applied.length)record.hostStyles=applied;
 }
 #sameColumns(record,slots){
 if(record.cells.size!==slots.length)return false;
-for(const slot of slots)if(!record.cells.has(slot.id))return false;
+for(const slot of slots){
+const cell=record.cells.get(slot.id);
+if(!cell)return false;
+const placed=this.#viewport.placed(cell.el);
+if(!placed||placed.left!==slot.left||placed.width!==slot.width)return false;
+}
 return true;
 }
 #syncDetail(record,row){
@@ -59224,6 +60113,7 @@ return columns&&isFunction(columns.get)?columns.get(id):undefined;
 this.#layout.setHiddenByGroups(this.#header?this.#header.hiddenColumns():[]);
 this.#layout.update(this.#size.width);
 this.#spans.refreshColumns(this.#allSlots());
+this.#a11y.keepFocus();
 if(this.#header)this.#header.build();
 for(const region of REGIONS){
 for(const[,record]of this.#mounted[region]){
@@ -59329,6 +60219,7 @@ if(suffix==='clicked')this.#selectFromClick(event,index,colId);
 }
 #selectFromClick(event,index,colId){
 if(event.defaultPrevented)return;
+if(resolveSelectionConfig(this.#host.grid?.get?.('selection')).checkboxOnly)return;
 if(colId===SELECT_COLUMN_ID||colId===DETAIL_COLUMN_ID)return;
 const target=event.target;
 if(isFunction(target.closest)
@@ -59355,15 +60246,15 @@ event,
 },'user');
 return;
 }
-const cellEl=target.closest(`.${CLASS.cell}`);
 const rowEl=target.closest(`.${CLASS.row}`);
-if(!cellEl||!rowEl)return;
+if(!rowEl)return;
 const index=displayIndexOf(rowEl);
 if(index<0)return;
 const row=this.#host.rowAt(index);
 if(!row)return;
-const colId=cellEl.getAttribute('data-col');
-const column=this.#host.columns.get(colId);
+const cellEl=target.closest(`.${CLASS.cell}`);
+const colId=cellEl?cellEl.getAttribute('data-col'):null;
+const column=colId!=null?this.#host.columns.get(colId):undefined;
 if(column&&column.control===true)return;
 if(isFunction(event.preventDefault))event.preventDefault();
 this.#host.emit('cell:contextmenu',{
@@ -59372,7 +60263,7 @@ key:row.key,
 index,
 colId,
 column,
-value:this.#host.cellValue?this.#host.cellValue(row,column):undefined,
+value:column&&this.#host.cellValue?this.#host.cellValue(row,column):undefined,
 x:event.clientX,
 y:event.clientY,
 event,
@@ -60342,6 +61233,11 @@ viewBox:'0 0 16 16',
 paths:['M5.5 2.5h8v8M2.5 5.5h8v8h-8Z'],
 paint:'stroke',
 },
+present:{
+viewBox:'0 0 16 16',
+paths:['M2 2.5h12v8H2Z','M8 10.5v3','M6 13.5h4'],
+paint:'stroke',
+},
 blank:{viewBox:'0 0 16 16',paths:['']},
 };
 const registry=new Map(Object.entries(BUILT_IN));
@@ -60368,7 +61264,11 @@ function iconNames(){
 return[...registry.keys()];
 }
 function createIcon(doc,name,opts){
-const def=registry.get(name)||registry.get('blank');
+let def=registry.get(name);
+if(!def){
+warnOnce(`icon:${name}`,`Unknown icon '${name}'; drew a blank glyph in its place. Register it with grid.icons or config.icons.`);
+def=registry.get('blank');
+}
 const svg=doc.createElementNS(SVG_NS,'svg');
 svg.setAttribute('class',(opts&&opts.className)||'lat-icon');
 svg.setAttribute('viewBox',def.viewBox);
@@ -63245,7 +64145,7 @@ colId,stylesheet:ctx.stylesheet,root:ctx.root,column,
 })
 :null;
 const staticClasses=[];
-if(column.align==='end'||column.align==='center')staticClasses.push(`lat-cell--${column.align}`);
+if(column.align&&column.align!=='start')staticClasses.push(`lat-cell--${column.align}`);
 if(column.verticalAlign)staticClasses.push(`lat-cell--valign-${column.verticalAlign}`);
 if(cellSpec.wrap===true)staticClasses.push('lat-cell--wrap');
 let dynamicClass=null;
@@ -75089,6 +75989,7 @@ name:t('menu.copyWithHeaders'),
 disabled:!scope(),
 action:()=>grid.export.clipboard({headers:true,rows:selected?'selected':'range'}),
 },
+...(colId==null?[]:[
 {
 name:t('menu.paste'),
 shortcut:`${mod}+V`,
@@ -75108,6 +76009,7 @@ shortcut:`${mod}+D`,
 disabled:!ranges||!writable||ranged<2,
 action:()=>ranges&&ranges.fillDown(),
 },
+]),
 ...(chartRange&&rangeChart.handler
 ?[{
 name:'Chart selection',
@@ -75157,18 +76059,18 @@ disabled:!selected&&!row,
 action:()=>grid.edit.deleteRows(selected?undefined:(row?row.key:undefined)),
 }]
 :[]),
-{
+...(colId==null?[]:[{
 name:'Edit cell',
 disabled:!row||!colId||!cellWritable,
 action:()=>row&&colId&&grid.edit.start(row.key,colId),
-},
+}]),
 ];
 }
 function applyMenuLayer(layer,items,params,where){
 if(layer===undefined||layer===null)return{items,spoke:false,suppress:false};
 if(layer===false)return{items,spoke:true,suppress:true};
 if(layer===true)return{items,spoke:true,suppress:false};
-if(Array.isArray(layer))return{items:layer,spoke:true,suppress:false};
+if(Array.isArray(layer))return{items:[...items,...layer],spoke:true,suppress:false};
 if(isFunction(layer)){
 const built=layer(params,items);
 return{items:Array.isArray(built)?built:items,spoke:true,suppress:false};
@@ -76961,6 +77863,7 @@ class ToolPanelDock{
 #dock=null;
 #off=[];
 #side='right';
+#presenting=null;
 constructor(opts){
 this.#grid=opts.grid;
 this.#doc=opts.document;
@@ -77031,11 +77934,50 @@ addAction(action){
 if(!action||!action.name)return;
 if(this.#panel.actions.some((a)=>a.name===action.name))return;
 this.#panel.registerAction(action);
+if(this.#presenting&&!action.annotation){
+const entry=this.#panel.actions.find((a)=>a.name===action.name);
+if(entry)this.#hideWhilePresenting(entry.button);
+}
 this.#applyWidth();
 }
 removeAction(name){
 if(this.#panel.removeAction(name))this.#applyWidth();
 }
+presentOnly(){
+if(this.#presenting)return true;
+const panel=this.#panel;
+if(!panel.actions.some((a)=>a.annotation&&a.button))return false;
+this.#presenting={hidden:[],reopen:panel.openPanel||null};
+if(this.#presenting.reopen)panel.hide();
+this.#hideWhilePresenting(panel.body);
+for(const child of[...(panel.tabs?.children||[])]){
+if(child!==panel.actionGroup)this.#hideWhilePresenting(child);
+}
+for(const child of[...(panel.actionGroup?.children||[])]){
+const action=panel.actions.find((a)=>a.button===child);
+if(!action||!action.annotation)this.#hideWhilePresenting(child);
+}
+this.#applyWidth();
+return true;
+}
+presentRestore(){
+const record=this.#presenting;
+if(!record)return false;
+this.#presenting=null;
+for(const entry of record.hidden){
+if(entry.el&&entry.el.style)entry.el.style.display=entry.display;
+}
+if(record.reopen)this.#panel.show(record.reopen);
+this.#applyWidth();
+return true;
+}
+#hideWhilePresenting(element){
+if(!element||!element.style||!this.#presenting)return;
+const display=element.style.display||'';
+if(display==='none')return;
+element.style.display='none';
+this.#presenting.hidden.push({el:element,display});
+}
 #applyWidth(){
 if(!this.#dock)return;
 const open=!!this.#panel.openPanel;
@@ -77057,6 +77999,7 @@ return measured>0?Math.ceil(measured):RAIL_WIDTH;
 destroy(){
 for(const off of this.#off)off();
 this.#off=[];
+this.#presenting=null;
 this.#host.destroyFilters();
 this.#panel.destroy();
 if(this.#dock&&this.#dock.remove)this.#dock.remove();
@@ -77270,6 +78213,7 @@ return null;
 }
 close(){
 if(this.#cell)markInvalid(this.#cell,null);
+const held=this.#held();
 if(this.#editor&&isFunction(this.#editor.destroy))this.#editor.destroy();
 if(this.#host){
 this.#host.classList.remove(EDITING_CLASS);
@@ -77278,6 +78222,7 @@ const column=this.#target?this.#grid.columns.get(this.#target.colId):null;
 this.#cellLayer.releaseCell(this.#host,column);
 }
 if(this.#host.replaceChildren)this.#host.replaceChildren();
+if(held)this.#returnFocus(this.#host);
 this.#renderer.refresh({force:true});
 }
 this.#editor=null;
@@ -77287,6 +78232,18 @@ this.#target=null;
 this.#rowIndex=-1;
 this.#committed=false;
 }
+#held(){
+const active=this.#doc.activeElement;
+if(!active||active===this.#doc.body)return false;
+const element=this.#editor&&isFunction(this.#editor.element)?this.#editor.element():null;
+const within=(node)=>!!node&&isFunction(node.contains)&&node.contains(active);
+return within(element)||within(this.#host);
+}
+#returnFocus(cell){
+const focusable=isFunction(cell.hasAttribute)&&cell.hasAttribute('tabindex');
+const target=focusable?cell:this.#renderer.viewport.root;
+if(target&&isFunction(target.focus))target.focus();
+}
 destroy(){
 this.close();
 for(const off of this.#off)off();
@@ -77737,6 +78694,7 @@ const __m1=__req("packages/core/src/i18n/index.js");
 const defaultMessages=__m1["defaultMessages"];
 const __m2=__req("packages/core/src/model/selection.js");
 const extendSeries=__m2["extendSeries"];
+const resolveSelectionConfig=__m2["resolveSelectionConfig"];
 const __m3=__req("packages/dom/src/renderer/textentry.js");
 const isTextEntry=__m3["isTextEntry"];
 const isFindBarControl=__m3["isFindBarControl"];
@@ -78119,9 +79077,7 @@ this.#handle.style.left=`${Math.round(inlineEnd-b.left)-4}px`;
 this.#handle.style.top=`${Math.round(a.bottom-b.top)-4}px`;
 }
 #fillEnabled(){
-const config=this.#grid.get('selection');
-if(!config||typeof config!=='object')return true;
-return config.fillHandle!==false;
+return resolveSelectionConfig(this.#grid.get('selection')).fillHandle;
 }
 #isEditing(){
 const root=this.#renderer.viewport.root;
@@ -78573,6 +79529,8 @@ Object.defineProperty(__exports,"diffConfigured",{enumerable:true,get:function()
 Object.defineProperty(__exports,"default",{enumerable:true,get:function(){return __default;}});
 const __m0=__req("packages/core/src/internal/util.js");
 const isFunction=__m0["isFunction"];
+const __m1=__req("packages/core/src/i18n/index.js");
+const defaultMessages=__m1["defaultMessages"];
 const ROW_CLASS={
 changed:'lat-row--changed',
 added:'lat-row--added',
@@ -78615,15 +79573,19 @@ const cellStatus=diff.cellStatus(key,colId);
 if(cellStatus==='changed'){
 cell.classList.add(CELL_CHANGED);
 const before=diff.before(key,colId);
-const text=before===null||before===undefined?'(empty)':String(before);
+const text=before===null||before===undefined?this.#t('diff.empty'):String(before);
 cell.setAttribute('data-before',text);
-cell.setAttribute('title',`Was: ${text}`);
+cell.setAttribute('title',this.#t('diff.before',{value:text}));
 }else if(cellStatus==='added-column'){
 cell.classList.add(CELL_ADDED_COLUMN);
 }
 }
 }
 }
+#t(key,params){
+const grid=this.#grid;
+return(grid&&grid.messages?grid.messages:defaultMessages).t(key,params);
+}
 destroy(){
 for(const off of this.#off)off();
 this.#off=[];
@@ -79375,6 +80337,7 @@ const keep=new Set(this.#grid.presentation?.options?.chrome||[]);
 const hidden=[];
 for(const name of CHROME){
 if(keep.has(name))continue;
+if(name==='toolPanel'&&this.#railPresentsAnnotations())continue;
 const el=this.#chromeElement(name);
 if(el&&el.style&&el.style.display!=='none'){
 el.style.display='none';
@@ -79402,6 +80365,8 @@ if(this.#progress){this.#progress.remove?.();this.#progress=null;}
 root?.classList?.remove(TRANSITION_CLASS);
 this.#paintSpotlight();
 if(restore){
+const dock=this.#grid.toolPanel;
+if(dock&&isFunction(dock.presentRestore))dock.presentRestore();
 for(const el of restore.hidden)el.style.display='';
 if(this.#maximiser&&!restore.maximised&&this.#maximiser.active())this.#maximiser.exit();
 }
@@ -79459,6 +80424,10 @@ if(!child.style||child.style.display!=='none')return false;
 }
 return true;
 }
+#railPresentsAnnotations(){
+const dock=this.#grid.toolPanel;
+return!!(dock&&isFunction(dock.presentOnly)&&dock.presentOnly());
+}
 #chromeElement(name){
 const host=this.#grid.element;
 if(!host||!isFunction(host.querySelector))return null;
@@ -80197,10 +81166,12 @@ Object.defineProperty(__exports,"PresencePainter",{enumerable:true,get:function(
 Object.defineProperty(__exports,"default",{enumerable:true,get:function(){return __default;}});
 const __m0=__req("packages/core/src/internal/util.js");
 const isFunction=__m0["isFunction"];
-const __m1=__req("packages/dom/src/editors/common.js");
-const cssEscape=__m1["cssEscape"];
-const __m2=__req("packages/core/src/model/presence.js");
-const CURSOR_LABEL_MS=__m2["CURSOR_LABEL_MS"];
+const __m1=__req("packages/core/src/i18n/index.js");
+const defaultMessages=__m1["defaultMessages"];
+const __m2=__req("packages/dom/src/editors/common.js");
+const cssEscape=__m2["cssEscape"];
+const __m3=__req("packages/core/src/model/presence.js");
+const CURSOR_LABEL_MS=__m3["CURSOR_LABEL_MS"];
 const ROSTER='lat-presence';
 class PresencePainter{
 #grid;
@@ -80345,13 +81316,18 @@ const hidden=peers.filter((p)=>p.hidden).length;
 if(hidden){
 const note=doc.createElement('span');
 note.className=`${ROSTER}__hidden`;
-note.textContent=`${hidden} not in view`;
+note.textContent=this.#t('presence.hidden',{count:hidden});
 this.#roster.appendChild(note);
 }
 }
 announceRefusal(peer){
 if(!this.#live)return;
-this.#live.textContent=`This cell is being edited by ${peer&&peer.name?peer.name:'someone else'}`;
+const name=peer&&peer.name?peer.name:this.#t('presence.someoneElse');
+this.#live.textContent=this.#t('a11y.presence.refused',{name});
+}
+#t(key,params){
+const grid=this.#grid;
+return(grid&&grid.messages?grid.messages:defaultMessages).t(key,params);
 }
 destroy(){
 for(const off of this.#off)off();
@@ -80450,7 +81426,6 @@ mount(){
 this.#off.push(this.#grid.on('comment:threadOpened',(e)=>this.#show(e)));
 this.#off.push(this.#grid.on('comment:threadClosed',()=>this.#hide()));
 this.#off.push(this.#grid.on('render:done',()=>{this.#paint();this.#place();}));
-this.#off.push(this.#grid.on('scroll:changed',()=>this.#place()));
 this.#off.push(this.#grid.on('stream:evicted',()=>this.#closeIfEvicted()));
 }
 #show(e){
@@ -80632,7 +81607,10 @@ el.appendChild(body);
 if(comment.value!==undefined&&!Object.is(comment.value,current)){
 const moved=doc.createElement('p');
 moved.className=`${ROOT}__moved`;
-moved.textContent=`Written when the value was ${String(comment.value)}: it is now ${String(current)}.`;
+moved.textContent=this.#t('comments.valueMoved',{
+was:String(comment.value),
+now:String(current),
+});
 el.appendChild(moved);
 }
 const can=comment.can||{};
@@ -80856,7 +81834,7 @@ if(w)this.#placeholder.style.width=`${w}px`;
 if(h)this.#placeholder.style.height=`${h}px`;
 const scroll=this.#captureScroll?this.#captureScroll():null;
 parent.insertBefore(this.#placeholder,this.#element);
-this.#doc.body.appendChild(this.#element);
+this.#moveKeepingFocus(()=>this.#doc.body.appendChild(this.#element));
 this.#saved={};
 for(const[prop,value]of Object.entries(FILL)){
 this.#saved[prop]=this.#element.style[prop]||'';
@@ -80876,7 +81854,9 @@ if(!this.active())return false;
 const scroll=this.#captureScroll?this.#captureScroll():null;
 const placeholder=(this.#placeholder);
 const parent=placeholder.parentNode;
-if(parent&&isFunction(parent.insertBefore))parent.insertBefore(this.#element,placeholder);
+if(parent&&isFunction(parent.insertBefore)){
+this.#moveKeepingFocus(()=>parent.insertBefore(this.#element,placeholder));
+}
 if(isFunction(placeholder.remove))placeholder.remove();
 this.#placeholder=null;
 if(this.#saved){
@@ -80896,6 +81876,14 @@ this.#changed();
 return true;
 }
 toggle(){return this.active()?!this.exit():this.enter();}
+#moveKeepingFocus(move){
+const active=this.#doc.activeElement;
+const held=active&&active!==this.#doc.body
+&&isFunction(this.#element.contains)&&this.#element.contains(active)
+?active:null;
+move();
+if(held&&isFunction(held.focus))held.focus();
+}
 #escape(e){
 if(!e||e.key!=='Escape'||e.defaultPrevented)return;
 this.exit();
@@ -81565,46 +82553,48 @@ const __m19=__req("packages/dom/src/editbar.js");
 const EditBar=__m19["EditBar"];
 const __m20=__req("packages/dom/src/rangeselect.js");
 const RangeController=__m20["RangeController"];
-const __m21=__req("packages/dom/src/importer.js");
-const ImportController=__m21["ImportController"];
-const __m22=__req("packages/dom/src/historybar.js");
-const HistoryBar=__m22["HistoryBar"];
-const __m23=__req("packages/dom/src/diffpaint.js");
-const DiffPainter=__m23["DiffPainter"];
-const __m24=__req("packages/dom/src/detailhost.js");
-const DetailHost=__m24["DetailHost"];
-const __m25=__req("packages/dom/src/highlightpaint.js");
-const HighlightPainter=__m25["HighlightPainter"];
-const __m26=__req("packages/dom/src/findpaint.js");
-const FindPainter=__m26["FindPainter"];
-const __m27=__req("packages/dom/src/findbar.js");
-const FindBar=__m27["FindBar"];
-const __m28=__req("packages/dom/src/redactpaint.js");
-const RedactionPainter=__m28["RedactionPainter"];
-const __m29=__req("packages/dom/src/validationpaint.js");
-const ValidationPainter=__m29["ValidationPainter"];
-const __m30=__req("packages/dom/src/presentation.js");
-const PresentationController=__m30["PresentationController"];
-const __m31=__req("packages/dom/src/capture.js");
-const captureElement=__m31["captureElement"];
-const __m32=__req("packages/dom/src/annotate.js");
-const AnnotationLayer=__m32["AnnotationLayer"];
-const __m33=__req("packages/dom/src/timelinebar.js");
-const TimelineBar=__m33["TimelineBar"];
-const __m34=__req("packages/dom/src/commentpaint.js");
-const CommentPainter=__m34["CommentPainter"];
-const __m35=__req("packages/dom/src/presencepaint.js");
-const PresencePainter=__m35["PresencePainter"];
-const __m36=__req("packages/dom/src/commentpanel.js");
-const CommentPanel=__m36["CommentPanel"];
-const __m37=__req("packages/dom/src/watermark.js");
-const Watermark=__m37["Watermark"];
-const __m38=__req("packages/dom/src/maximise.js");
-const Maximiser=__m38["Maximiser"];
-const __m39=__req("packages/dom/src/promptbar.js");
-const PromptBar=__m39["PromptBar"];
-const __m40=__req("packages/dom/src/kpistrip.js");
-const KpiStrip=__m40["KpiStrip"];
+const __m21=__req("packages/core/src/model/selection.js");
+const resolveSelectionConfig=__m21["resolveSelectionConfig"];
+const __m22=__req("packages/dom/src/importer.js");
+const ImportController=__m22["ImportController"];
+const __m23=__req("packages/dom/src/historybar.js");
+const HistoryBar=__m23["HistoryBar"];
+const __m24=__req("packages/dom/src/diffpaint.js");
+const DiffPainter=__m24["DiffPainter"];
+const __m25=__req("packages/dom/src/detailhost.js");
+const DetailHost=__m25["DetailHost"];
+const __m26=__req("packages/dom/src/highlightpaint.js");
+const HighlightPainter=__m26["HighlightPainter"];
+const __m27=__req("packages/dom/src/findpaint.js");
+const FindPainter=__m27["FindPainter"];
+const __m28=__req("packages/dom/src/findbar.js");
+const FindBar=__m28["FindBar"];
+const __m29=__req("packages/dom/src/redactpaint.js");
+const RedactionPainter=__m29["RedactionPainter"];
+const __m30=__req("packages/dom/src/validationpaint.js");
+const ValidationPainter=__m30["ValidationPainter"];
+const __m31=__req("packages/dom/src/presentation.js");
+const PresentationController=__m31["PresentationController"];
+const __m32=__req("packages/dom/src/capture.js");
+const captureElement=__m32["captureElement"];
+const __m33=__req("packages/dom/src/annotate.js");
+const AnnotationLayer=__m33["AnnotationLayer"];
+const __m34=__req("packages/dom/src/timelinebar.js");
+const TimelineBar=__m34["TimelineBar"];
+const __m35=__req("packages/dom/src/commentpaint.js");
+const CommentPainter=__m35["CommentPainter"];
+const __m36=__req("packages/dom/src/presencepaint.js");
+const PresencePainter=__m36["PresencePainter"];
+const __m37=__req("packages/dom/src/commentpanel.js");
+const CommentPanel=__m37["CommentPanel"];
+const __m38=__req("packages/dom/src/watermark.js");
+const Watermark=__m38["Watermark"];
+const __m39=__req("packages/dom/src/maximise.js");
+const Maximiser=__m39["Maximiser"];
+const __m40=__req("packages/dom/src/promptbar.js");
+const PromptBar=__m40["PromptBar"];
+const __m41=__req("packages/dom/src/kpistrip.js");
+const KpiStrip=__m41["KpiStrip"];
 function label(t,action,entry){
 const bare=action==='redo'?'toolbar.redo':'toolbar.undo';
 if(!entry||!entry.label)return t(bare);
@@ -81707,6 +82697,7 @@ title:()=>t(`toolbar.annotate.${tool}`),
 icon:icons[tool],
 run:()=>grid.annotate?.use(tool),
 active:()=>grid.annotate?.tool===tool,
+annotation:true,
 }));
 }
 const ANNOTATE_TOOLS=['pen','arrow','rect','highlight'];
@@ -81783,7 +82774,7 @@ const h=viewport.statusBar.offsetHeight||viewport.statusBar.getBoundingClientRec
 viewport.root.style.setProperty('--lattice-status-height',`${Math.ceil(h)}px`);
 };
 const refresh=()=>{bar.refresh();measureBar();};
-const offs=['rows:changed','model:changed','selection:changed','range:changed','source:progress',
+const offs=['rows:changed','model:changed','selection:changed','range:changed',
 'rows:queued','rows:paused','rows:resumed',
 'comment:added','comment:edited','comment:deleted','comment:indexLoaded']
 .map((event)=>grid.on(event,refresh));
@@ -81795,10 +82786,8 @@ viewport.root.style.removeProperty('--lattice-status-height');
 bar.destroy?.();
 });
 }
-const selectionConfig=config.selection;
-const rangesOn=selectionConfig===undefined
-||selectionConfig==='single'||selectionConfig==='multiple'
-||(typeof selectionConfig==='object'&&selectionConfig.ranges!==false);
+const selectionConfig=resolveSelectionConfig(config.selection);
+const rangesOn=selectionConfig.ranges;
 if(rangesOn){
 const rangeController=new RangeController({grid,renderer,document:doc});
 rangeController.mount();
@@ -82051,8 +83040,7 @@ for(const[event,cause]of[
 ['rows:changed','data'],
 ['column:resized','resize'],
 ['column:moved','columns'],
-['column:visibility','columns'],
-['theme:changed','theme'],
+['column:visible','columns'],
 ]){
 teardown.push(grid.on(event,()=>{pendingCause=cause;}));
 }
@@ -82680,7 +83668,7 @@ createLocalViewStorage,
 const __default=LatticeGrid;
 });
 try{
-__req("packages/worker/src/inline.js").setWorkerSource("(function(root){\n'use strict';\nvar __mods=Object.create(null);\nvar __cache=Object.create(null);\nfunction __def(id,fn){__mods[id]=fn;}\nfunction __req(id){\nvar hit=__cache[id];\nif(hit)return hit;\nvar exports=Object.create(null);\n__cache[id]=exports;\nvar fn=__mods[id];\nif(!fn)throw new Error('[lattice] missing module: '+id);\nfn(exports,__req);\nreturn exports;\n}\n__def(\"packages/core/src/internal/util.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"VERSION\",{enumerable:true,get:function(){return VERSION;}});\nObject.defineProperty(__exports,\"reportedWarnings\",{enumerable:true,get:function(){return reportedWarnings;}});\nObject.defineProperty(__exports,\"warnOnce\",{enumerable:true,get:function(){return warnOnce;}});\nObject.defineProperty(__exports,\"infoOnce\",{enumerable:true,get:function(){return infoOnce;}});\nObject.defineProperty(__exports,\"resetWarnings\",{enumerable:true,get:function(){return resetWarnings;}});\nObject.defineProperty(__exports,\"fail\",{enumerable:true,get:function(){return fail;}});\nObject.defineProperty(__exports,\"invariant\",{enumerable:true,get:function(){return invariant;}});\nObject.defineProperty(__exports,\"DEV\",{enumerable:true,get:function(){return DEV;}});\nObject.defineProperty(__exports,\"isObject\",{enumerable:true,get:function(){return isObject;}});\nObject.defineProperty(__exports,\"isFunction\",{enumerable:true,get:function(){return isFunction;}});\nObject.defineProperty(__exports,\"isNil\",{enumerable:true,get:function(){return isNil;}});\nObject.defineProperty(__exports,\"isBlank\",{enumerable:true,get:function(){return isBlank;}});\nObject.defineProperty(__exports,\"isCtor\",{enumerable:true,get:function(){return isCtor;}});\nObject.defineProperty(__exports,\"pathGetter\",{enumerable:true,get:function(){return pathGetter;}});\nObject.defineProperty(__exports,\"pathSetter\",{enumerable:true,get:function(){return pathSetter;}});\nObject.defineProperty(__exports,\"getPath\",{enumerable:true,get:function(){return getPath;}});\nObject.defineProperty(__exports,\"setPath\",{enumerable:true,get:function(){return setPath;}});\nObject.defineProperty(__exports,\"humanise\",{enumerable:true,get:function(){return humanise;}});\nObject.defineProperty(__exports,\"escapeHtml\",{enumerable:true,get:function(){return escapeHtml;}});\nObject.defineProperty(__exports,\"titleCase\",{enumerable:true,get:function(){return titleCase;}});\nObject.defineProperty(__exports,\"expand\",{enumerable:true,get:function(){return expand;}});\nObject.defineProperty(__exports,\"toArray\",{enumerable:true,get:function(){return toArray;}});\nObject.defineProperty(__exports,\"merge\",{enumerable:true,get:function(){return merge;}});\nObject.defineProperty(__exports,\"mergeRow\",{enumerable:true,get:function(){return mergeRow;}});\nObject.defineProperty(__exports,\"Lru\",{enumerable:true,get:function(){return Lru;}});\nObject.defineProperty(__exports,\"collator\",{enumerable:true,get:function(){return collator;}});\nObject.defineProperty(__exports,\"defaultCompare\",{enumerable:true,get:function(){return defaultCompare;}});\nObject.defineProperty(__exports,\"now\",{enumerable:true,get:function(){return now;}});\nObject.defineProperty(__exports,\"nextFrame\",{enumerable:true,get:function(){return nextFrame;}});\nObject.defineProperty(__exports,\"cancelFrame\",{enumerable:true,get:function(){return cancelFrame;}});\nObject.defineProperty(__exports,\"frameBatched\",{enumerable:true,get:function(){return frameBatched;}});\nObject.defineProperty(__exports,\"settleDebounce\",{enumerable:true,get:function(){return settleDebounce;}});\nObject.defineProperty(__exports,\"whenIdle\",{enumerable:true,get:function(){return whenIdle;}});\nObject.defineProperty(__exports,\"uid\",{enumerable:true,get:function(){return uid;}});\nconst STAMPED_VERSION=\"1.54.0\";\nasync function resolveVersion(){\nif(STAMPED_VERSION!=='0.0.0-source')return STAMPED_VERSION;\ntry{\nif(typeof process==='undefined'||!process.versions||!process.versions.node){\nreturn STAMPED_VERSION;\n}\nconst mod=await import('node:'+'module');\nconst req=mod.createRequire((typeof document!=='undefined'&&document.currentScript?document.currentScript.src:''));\nconst fs=req('node:'+'fs');\nconst url=new URL('../../../../package.json',(typeof document!=='undefined'&&document.currentScript?document.currentScript.src:''));\nconst text=fs.readFileSync(url,'utf8');\nreturn JSON.parse(text).version||STAMPED_VERSION;\n}catch{\nreturn STAMPED_VERSION;\n}\n}\nconst VERSION=\"1.54.0\";\nconst warned=new Set();\nconst WARNED_LIMIT=2000;\nfunction rememberWarned(key){\nwarned.add(key);\nif(warned.size>WARNED_LIMIT){\nconst oldest=warned.values().next().value;\nif(oldest!==undefined)warned.delete(oldest);\n}\n}\nconst reported=[];\nconst REPORT_LIMIT=500;\nfunction record(key,level,message){\nreported.push({\nkey,\nlevel,\nmessage:message.map((m)=>(typeof m==='string'?m:safeString(m))).join(' '),\nat:Date.now(),\n});\nif(reported.length>REPORT_LIMIT)reported.shift();\n}\nfunction safeString(value){\nif(value instanceof Error)return value.message;\ntry{return JSON.stringify(value);}catch{return String(value);}\n}\nfunction reportedWarnings(){return reported.map((r)=>({...r}));}\nfunction warnOnce(key,...message){\nif(warned.has(key))return;\nrememberWarned(key);\nrecord(key,'warn',message);\nconsole.warn('[lattice]',...message);\n}\nfunction infoOnce(key,...message){\nif(warned.has(key))return;\nrememberWarned(key);\nrecord(key,'info',message);\nconsole.info('[lattice]',...message);\n}\nfunction resetWarnings(){\nwarned.clear();\nreported.length=0;\n}\nfunction fail(message,extra){\nconst err=new Error(`[lattice] ${message}`);\nif(extra!==undefined)err.cause=extra;\nthrow err;\n}\nfunction invariant(condition,message){\nif(!condition)fail(message);\n}\nconst DEV=(()=>{\ntry{\nreturn!(typeof process!=='undefined'&&process.env\n&&process.env.NODE_ENV==='production');\n}catch{\nreturn true;\n}\n})();\nfunction isObject(v){\nreturn v!==null&&typeof v==='object'&&!Array.isArray(v);\n}\nfunction isFunction(v){\nreturn typeof v==='function';\n}\nfunction isNil(v){\nreturn v===null||v===undefined;\n}\nfunction isBlank(v){\nreturn v===null||v===undefined||v==='';\n}\nfunction isCtor(v){\nif(typeof v!=='function')return false;\nif(/^class[\\s{]/.test(Function.prototype.toString.call(v)))return true;\nreturn!!(v.prototype&&Object.getOwnPropertyNames(v.prototype).length>1);\n}\nconst pathCache=new Map();\nfunction pathGetter(path){\nlet fn=pathCache.get(path);\nif(fn)return fn;\nif(!path.includes('.')){\nfn=(o)=>(o==null?undefined:o[path]);\n}else{\nconst parts=path.split('.');\nconst n=parts.length;\nfn=(o)=>{\nlet cur=o;\nfor(let i=0;i<n;i++){\nif(cur==null)return undefined;\ncur=cur[parts[i]];\n}\nreturn cur;\n};\n}\npathCache.set(path,fn);\nreturn fn;\n}\nconst setterCache=new Map();\nfunction pathSetter(path){\nlet fn=setterCache.get(path);\nif(fn)return fn;\nif(!path.includes('.')){\nfn=(o,v)=>{if(o!=null)o[path]=v;};\n}else{\nconst parts=path.split('.');\nconst last=parts.length-1;\nfn=(o,v)=>{\nlet cur=o;\nfor(let i=0;i<last;i++){\nif(cur==null)return;\nconst k=parts[i];\nif(cur[k]==null)cur[k]={};\ncur=cur[k];\n}\nif(cur!=null)cur[parts[last]]=v;\n};\n}\nsetterCache.set(path,fn);\nreturn fn;\n}\nfunction getPath(obj,path){\nreturn pathGetter(path)(obj);\n}\nfunction setPath(obj,path,value){\npathSetter(path)(obj,value);\n}\nfunction humanise(field){\nif(!field)return'';\nconst leaf=field.includes('.')?field.slice(field.lastIndexOf('.')+1):field;\nreturn leaf\n.replace(/[_-]+/g,' ')\n.replace(/([a-z0-9])([A-Z])/g,'$1 $2')\n.replace(/([A-Z]+)([A-Z][a-z])/g,'$1 $2')\n.replace(/\\s+/g,' ')\n.trim()\n.replace(/^./,(c)=>c.toUpperCase());\n}\nconst ESCAPES={'&':'&amp;','<':'&lt;','>':'&gt;','\"':'&quot;',\"'\":'&#39;'};\nfunction escapeHtml(s){\nconst str=s==null?'':String(s);\nreturn/[&<>\"']/.test(str)?str.replace(/[&<>\"']/g,(c)=>ESCAPES[c]):str;\n}\nfunction titleCase(s){\nreturn String(s).replace(/\\w\\S*/g,(t)=>t[0].toUpperCase()+t.slice(1).toLowerCase());\n}\nfunction expand(value,key,whenTrue){\nif(value===undefined)return undefined;\nif(value===true)return{enabled:true,...whenTrue};\nif(value===false)return{enabled:false};\nif(isObject(value))return value;\nreturn{[key]:value,enabled:true};\n}\nfunction toArray(v){\nif(v===undefined||v===null)return[];\nreturn Array.isArray(v)?v:[v];\n}\nconst MERGE_FORBIDDEN_KEYS=Object.freeze(new Set(['__proto__','constructor','prototype']));\nfunction merge(a,b){\nif(!isObject(a))return isObject(b)?{...b}:b;\nif(!isObject(b))return b===undefined?a:b;\nconst out={...a};\nfor(const k of Object.keys(b)){\nif(MERGE_FORBIDDEN_KEYS.has(k))continue;\nconst bv=b[k];\nif(bv===undefined)continue;\nout[k]=isObject(bv)&&isObject(out[k])?merge(out[k],bv):bv;\n}\nreturn out;\n}\nfunction mergeRow(previous,patch){\nif(!isObject(previous)||!isObject(patch)||previous===patch)return patch;\nconst out=Object.create(Object.getPrototypeOf(previous));\nObject.assign(out,previous,patch);\nreturn out;\n}\nclass Lru{\n#max;\n#map=new Map();\n#onEvict;\nconstructor(max=256,onEvict=null){\nthis.#max=max;\nthis.#onEvict=onEvict;\n}\nget size(){\nreturn this.#map.size;\n}\nget max(){\nreturn this.#max;\n}\nset max(v){\nthis.#max=v;\nthis.#trim();\n}\nhas(k){\nreturn this.#map.has(k);\n}\nget(k){\nconst m=this.#map;\nif(!m.has(k))return undefined;\nconst v=m.get(k);\nm.delete(k);\nm.set(k,v);\nreturn v;\n}\npeek(k){\nreturn this.#map.get(k);\n}\nset(k,v){\nconst m=this.#map;\nif(m.has(k))m.delete(k);\nm.set(k,v);\nthis.#trim();\nreturn v;\n}\ndelete(k){\nconst v=this.#map.get(k);\nif(this.#map.delete(k)&&this.#onEvict)this.#onEvict(v,k);\nreturn v;\n}\nclear(){\nif(this.#onEvict)for(const[k,v]of this.#map)this.#onEvict(v,k);\nthis.#map.clear();\n}\nkeys(){\nreturn this.#map.keys();\n}\nvalues(){\nreturn this.#map.values();\n}\n#trim(){\nconst m=this.#map;\nwhile(m.size>this.#max){\nconst oldest=m.keys().next().value;\nconst v=m.get(oldest);\nm.delete(oldest);\nif(this.#onEvict)this.#onEvict(v,oldest);\n}\n}\n}\nconst collators=new Map();\nfunction collator(locale,opts){\nconst key=`${locale||''}|${opts?JSON.stringify(opts):''}`;\nlet c=collators.get(key);\nif(!c){\nc=new Intl.Collator(locale||undefined,{\nnumeric:true,sensitivity:'variant',...opts,\n});\ncollators.set(key,c);\n}\nreturn c;\n}\nfunction defaultCompare(a,b){\nif(a===b)return 0;\nif(a===null||a===undefined)return 1;\nif(b===null||b===undefined)return-1;\nif(typeof a==='number'&&typeof b==='number'){\nif(Number.isNaN(a))return Number.isNaN(b)?0:1;\nif(Number.isNaN(b))return-1;\nreturn a<b?-1:a>b?1:0;\n}\nconst sa=String(a);\nconst sb=String(b);\nreturn sa<sb?-1:sa>sb?1:0;\n}\nfunction now(){\nreturn typeof performance!=='undefined'&&performance.now\n?performance.now()\n:Date.now();\n}\nconst hasRaf=typeof requestAnimationFrame==='function';\nfunction nextFrame(fn){\nif(hasRaf)return requestAnimationFrame(fn);\nreturn setTimeout(()=>fn(now()),16);\n}\nfunction cancelFrame(handle){\nif(handle==null)return;\nif(hasRaf)cancelAnimationFrame(handle);\nelse clearTimeout(handle);\n}\nfunction frameBatched(fn){\nlet handle=null;\nlet lastArgs=null;\nconst run=()=>{\nhandle=null;\nconst a=lastArgs;\nlastArgs=null;\nfn(...(a||[]));\n};\nconst wrapped=(...args)=>{\nlastArgs=args;\nif(handle===null)handle=nextFrame(run);\n};\nwrapped.cancel=()=>{\ncancelFrame(handle);\nhandle=null;\nlastArgs=null;\n};\nwrapped.flush=()=>{\nif(handle!==null){\ncancelFrame(handle);\nrun();\n}\n};\nreturn wrapped;\n}\nfunction settleDebounce(fn,waitMs){\nlet timer=null;\nlet held=null;\nconst trailing=()=>{\ntimer=null;\nif(held===null)return;\nconst args=held;\nheld=null;\nfn(...args);\narm();\n};\nconst arm=()=>{\ntimer=setTimeout(trailing,waitMs);\nif(typeof timer?.unref==='function')timer.unref();\n};\nconst wrapped=(...args)=>{\nif(timer===null){\nfn(...args);\narm();\n}else{\nheld=args;\nclearTimeout(timer);\narm();\n}\n};\nwrapped.flush=()=>{\nif(timer!==null)clearTimeout(timer);\ntimer=null;\nif(held===null)return;\nconst args=held;\nheld=null;\nfn(...args);\n};\nwrapped.cancel=()=>{\nif(timer!==null)clearTimeout(timer);\ntimer=null;\nheld=null;\n};\nwrapped.pending=()=>timer!==null||held!==null;\nreturn wrapped;\n}\nfunction whenIdle(fn,timeout=50){\nif(typeof requestIdleCallback==='function'){\nreturn requestIdleCallback(fn,{timeout});\n}\nreturn setTimeout(()=>fn({timeRemaining:()=>0,didTimeout:true}),1);\n}\nlet idSeq=0;\nfunction uid(prefix='l'){\nreturn`${prefix}${(++idSeq).toString(36)}`;\n}\n});\n__def(\"packages/worker/src/transport.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"PROTOCOL\",{enumerable:true,get:function(){return PROTOCOL;}});\nObject.defineProperty(__exports,\"OPS\",{enumerable:true,get:function(){return OPS;}});\nObject.defineProperty(__exports,\"CONTROL\",{enumerable:true,get:function(){return CONTROL;}});\nObject.defineProperty(__exports,\"ERRORS\",{enumerable:true,get:function(){return ERRORS;}});\nObject.defineProperty(__exports,\"packHandle\",{enumerable:true,get:function(){return packHandle;}});\nObject.defineProperty(__exports,\"packHandles\",{enumerable:true,get:function(){return packHandles;}});\nObject.defineProperty(__exports,\"TransportedDictionary\",{enumerable:true,get:function(){return TransportedDictionary;}});\nObject.defineProperty(__exports,\"unpackHandle\",{enumerable:true,get:function(){return unpackHandle;}});\nObject.defineProperty(__exports,\"unpackHandles\",{enumerable:true,get:function(){return unpackHandles;}});\nObject.defineProperty(__exports,\"createMaskPool\",{enumerable:true,get:function(){return createMaskPool;}});\nObject.defineProperty(__exports,\"isTransferable\",{enumerable:true,get:function(){return isTransferable;}});\nObject.defineProperty(__exports,\"collectTransfers\",{enumerable:true,get:function(){return collectTransfers;}});\nObject.defineProperty(__exports,\"isPortable\",{enumerable:true,get:function(){return isPortable;}});\nObject.defineProperty(__exports,\"filterColumnIds\",{enumerable:true,get:function(){return filterColumnIds;}});\nconst __m0=__req(\"packages/core/src/internal/util.js\");\nconst collator=__m0[\"collator\"];\nconst isFunction=__m0[\"isFunction\"];\nconst PROTOCOL=1;\nconst OPS=Object.freeze({\nSORT_COLUMN:'sortColumn',\nSORT_MULTI:'sortMulti',\nEVALUATE_FILTERS:'evaluateFilters',\nCOMPACT:'compact',\nGROUP_BY_COLUMNS:'groupByColumns',\nTOTAL:'total',\nPIVOT:'pivot',\nFACET:'facet',\nCOLUMNIZE:'columnize',\nCOLLATE_STRING_RANKS:'collateStringRanks',\n});\nconst CONTROL=Object.freeze({\nREADY:'ready',\nCANCEL:'cancel',\nPING:'ping',\n});\nconst ERRORS=Object.freeze({\nNO_COMPUTE:'E_NO_COMPUTE',\nNO_KERNEL:'E_NO_KERNEL',\nABORTED:'E_ABORTED',\nKERNEL:'E_KERNEL',\nPROTOCOL:'E_PROTOCOL',\n});\nfunction packHandle(handle){\nif(handle==null)return null;\nconst presence=handle.presence;\nreturn{\nid:handle.id,\nkind:handle.kind,\nnullable:!!handle.nullable,\nvalues:handle.values??null,\npresence:presence?(presence.words??presence):null,\npresenceBits:presence?(presence.size??(presence.words??presence).length*8):0,\ndict:handle.dict?sliceDictionary(handle.dict):null,\noffsets:handle.offsets??null,\nversion:handle.version??0,\n};\n}\nfunction sliceDictionary(dict){\nif(Array.isArray(dict))return dict;\nif(isFunction(dict.values))return dict.values();\nreturn[];\n}\nfunction packHandles(handles){\nconst out=new Array(handles.length);\nfor(let i=0;i<handles.length;i++)out[i]=packHandle(handles[i]);\nreturn out;\n}\nclass TransportedBitset{\n#words;\n#bits;\nconstructor(words,bits){\nthis.#words=words;\nthis.#bits=bits;\n}\nget words(){return this.#words;}\nget size(){return this.#bits;}\nget(i){return(this.#words[i>>>3]&(1<<(i&7)))!==0;}\ncount(){\nconst w=this.#words;\nlet n=0;\nfor(let i=0;i<w.length;i++){\nlet v=w[i];\nwhile(v){v&=v-1;n++;}\n}\nreturn n;\n}\n}\nclass TransportedDictionary{\n#values;\n#index=null;\n#version=0;\n#ranks=new Map();\nconstructor(values){\nthis.#values=values||[];\n}\nget size(){return this.#values.length;}\nget version(){return this.#version;}\ncodeOf(value){\nif(this.#index===null){\nthis.#index=new Map();\nfor(let i=0;i<this.#values.length;i++)this.#index.set(this.#values[i],i);\n}\nconst found=this.#index.get(value);\nif(found!==undefined)return found;\nconst code=this.#values.length;\nthis.#values.push(value);\nthis.#index.set(value,code);\nthis.#version++;\nreturn code;\n}\nvalueOf(code){return this.#values[code];}\nvalues(){return this.#values;}\nranks(locale){\nconst key=locale||'';\nconst cached=this.#ranks.get(key);\nif(cached&&cached.version===this.#version)return cached.ranks;\nconst n=this.#values.length;\nconst order=new Uint32Array(n);\nfor(let i=0;i<n;i++)order[i]=i;\nconst cmp=collator(locale).compare;\nconst vals=this.#values;\nconst sorted=Array.from(order).sort((a,b)=>{\nconst av=vals[a];\nconst bv=vals[b];\nif(av===bv)return 0;\nif(av===null||av===undefined)return 1;\nif(bv===null||bv===undefined)return-1;\nreturn cmp(String(av),String(bv));\n});\nconst ranks=new Uint32Array(n);\nfor(let r=0;r<sorted.length;r++)ranks[sorted[r]]=r;\nthis.#ranks.set(key,{version:this.#version,ranks});\nreturn ranks;\n}\n}\nfunction unpackHandle(packed){\nif(packed==null)return null;\nconst presence=packed.presence\n?new TransportedBitset(packed.presence,packed.presenceBits||packed.presence.length*8)\n:null;\nconst dict=packed.dict?new TransportedDictionary(packed.dict):null;\nconst values=packed.values;\nconst offsets=packed.offsets??null;\nconst kind=packed.kind;\nconst get=(physical)=>{\nif(presence&&!presence.get(physical))return null;\nswitch(kind){\ncase'dictionary':\nreturn dict?dict.valueOf(values[physical]):values[physical];\ncase'bitset':\nreturn(values[physical>>>3]&(1<<(physical&7)))!==0;\ncase'multi':{\nif(!offsets)return null;\nconst from=offsets[physical];\nconst to=offsets[physical+1];\nconst out=new Array(to-from);\nfor(let i=from;i<to;i++)out[i-from]=dict?dict.valueOf(values[i]):values[i];\nreturn out;\n}\ndefault:\nreturn values[physical];\n}\n};\nreturn{\nid:packed.id,\nkind,\nnullable:packed.nullable,\nvalues,\npresence,\ndict,\noffsets,\nget,\nversion:packed.version,\n};\n}\nfunction unpackHandles(packed){\nconst out=new Array(packed.length);\nfor(let i=0;i<packed.length;i++)out[i]=unpackHandle(packed[i]);\nreturn out;\n}\nfunction createMaskPool(){\nconst masks=[];\nconst indices=[];\nreturn{\nmask(n){\nfor(let i=0;i<masks.length;i++){\nif(masks[i].length>=n){\nconst buf=masks.splice(i,1)[0].subarray(0,n);\nbuf.fill(0);\nreturn buf;\n}\n}\nreturn new Uint8Array(n);\n},\nindices(n){\nfor(let i=0;i<indices.length;i++){\nif(indices[i].length>=n)return indices.splice(i,1)[0].subarray(0,n);\n}\nreturn new Uint32Array(n);\n},\nrelease(buf){\nif(!buf)return;\nif(buf instanceof Uint8Array)masks.push(buf);\nelse if(buf instanceof Uint32Array)indices.push(buf);\n},\nclear(){masks.length=0;indices.length=0;},\n};\n}\nfunction isTransferable(v){\nif(!ArrayBuffer.isView(v))return false;\nconst buf=(v).buffer;\nif(!buf)return false;\nreturn typeof SharedArrayBuffer==='undefined'||!(buf instanceof SharedArrayBuffer);\n}\nfunction collectTransfers(value,out=[]){\nconst add=(v)=>{\nif(!isTransferable(v))return;\nconst buf=(v).buffer;\nif(!out.includes(buf))out.push(buf);\n};\nif(value==null)return out;\nif(ArrayBuffer.isView(value)){add(value);return out;}\nif(Array.isArray(value)){\nfor(const item of value)add(item);\nreturn out;\n}\nif(typeof value==='object'){\nfor(const key of Object.keys(value)){\nconst item=(value)[key];\nif(Array.isArray(item))for(const sub of item)add(sub);\nelse add(item);\n}\n}\nreturn out;\n}\nfunction isPortable(value,depth=0){\nif(value==null)return true;\nconst t=typeof value;\nif(t==='function'||t==='symbol')return false;\nif(t!=='object')return true;\nif(depth>4)return true;\nif(ArrayBuffer.isView(value)||value instanceof ArrayBuffer||value instanceof Date)return true;\nif(Array.isArray(value)){\nfor(const item of value)if(!isPortable(item,depth+1))return false;\nreturn true;\n}\nfor(const key of Object.keys(value)){\nif(!isPortable((value)[key],depth+1))return false;\n}\nreturn true;\n}\nfunction filterColumnIds(filters,out=new Set()){\nif(!filters||typeof filters!=='object')return out;\nconst node=(filters);\nif(typeof node.col==='string')out.add(node.col);\nconst conditions=node.conditions;\nif(Array.isArray(conditions))for(const child of conditions)filterColumnIds(child,out);\nreturn out;\n}\n});\n__def(\"packages/core/src/store/bitset.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"Bitset\",{enumerable:true,get:function(){return Bitset;}});\nconst WORD_BITS=8;\nclass Bitset{\nstatic#POP=new Uint8Array(256);\nstatic{\nfor(let i=1;i<256;i++)Bitset.#POP[i]=Bitset.#POP[i>>1]+(i&1);\n}\n#words;\n#bits;\nconstructor(bits=0){\nconst n=Math.max(0,bits|0);\nthis.#bits=n;\nthis.#words=new Uint8Array(Math.ceil(n/WORD_BITS));\n}\nget size(){return this.#bits;}\nget words(){return this.#words;}\nget bytes(){return this.#words?this.#words.byteLength:0;}\nget(i){\nif(i<0||i>=this.#bits)return 0;\nreturn(this.#words[i>>3]>>(i&7))&1;\n}\nset(i){\nif(i>=0&&i<this.#bits)this.#words[i>>3]|=1<<(i&7);\nreturn this;\n}\nclear(i){\nif(i>=0&&i<this.#bits)this.#words[i>>3]&=~(1<<(i&7));\nreturn this;\n}\nassign(i,bit){return bit?this.set(i):this.clear(i);}\nfill(bit=false){\nthis.#words.fill(bit?0xff:0);\nif(bit)this.#maskTail();\nreturn this;\n}\ngrow(bits){\nconst n=Math.max(0,bits|0);\nif(n<=this.#bits)return this;\nconst need=Math.ceil(n/WORD_BITS);\nif(need>this.#words.length){\nconst next=new Uint8Array(need);\nnext.set(this.#words);\nthis.#words=next;\n}\nthis.#bits=n;\nreturn this;\n}\ncount(){\nconst w=this.#words;\nconst pop=Bitset.#POP;\nlet total=0;\nfor(let i=0;i<w.length;i++)total+=pop[w[i]];\nreturn total;\n}\nand(other){\nconst b=other instanceof Bitset?other.words:other;\nconst w=this.#words;\nconst shared=Math.min(w.length,b.length);\nfor(let i=0;i<shared;i++)w[i]&=b[i];\nfor(let i=shared;i<w.length;i++)w[i]=0;\nreturn this;\n}\nor(other){\nconst b=other instanceof Bitset?other.words:other;\nconst w=this.#words;\nconst shared=Math.min(w.length,b.length);\nfor(let i=0;i<shared;i++)w[i]|=b[i];\nreturn this;\n}\nnot(){\nconst w=this.#words;\nfor(let i=0;i<w.length;i++)w[i]=~w[i]&0xff;\nthis.#maskTail();\nreturn this;\n}\nclone(){\nconst out=new Bitset(this.#bits);\nout.words.set(this.#words.subarray(0,out.words.length));\nreturn out;\n}\nrelease(){\nthis.#words=new Uint8Array(0);\nthis.#bits=0;\n}\n#maskTail(){\nconst used=this.#bits&7;\nif(used===0)return;\nconst last=(this.#bits>>3);\nif(last<this.#words.length)this.#words[last]&=(1<<used)-1;\n}\nstatic from(bools){\nconst arr=Array.isArray(bools)?bools:Array.from(bools);\nconst out=new Bitset(arr.length);\nfor(let i=0;i<arr.length;i++)if(arr[i])out.set(i);\nreturn out;\n}\n}\n});\n__def(\"packages/core/src/store/dictionary.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"Dictionary\",{enumerable:true,get:function(){return Dictionary;}});\nconst __m0=__req(\"packages/core/src/internal/util.js\");\nconst collator=__m0[\"collator\"];\nconst defaultCompare=__m0[\"defaultCompare\"];\nclass Dictionary{\n#values;\n#codes=new Map();\n#version=0;\n#ranks=null;\n#ranksVersion=-1;\n#ranksLocale='\\u0000';\nconstructor(values=[]){\nthis.#values=[];\nfor(let i=0;i<values.length;i++){\nconst v=values[i];\nif(this.#codes.has(v))continue;\nthis.#codes.set(v,this.#values.length);\nthis.#values.push(v);\n}\n}\nget size(){return this.#values.length;}\nget version(){return this.#version;}\nget bytes(){\nlet total=this.#values.length*8;\nfor(let i=0;i<this.#values.length;i++){\nconst v=this.#values[i];\nif(typeof v==='string')total+=v.length*2;\ntotal+=16;\n}\nreturn total;\n}\ncodeOf(value){\nconst existing=this.#codes.get(value);\nif(existing!==undefined)return existing;\nconst code=this.#values.length;\nthis.#values.push(value);\nthis.#codes.set(value,code);\nthis.#version++;\nreturn code;\n}\nlookup(value){\nconst code=this.#codes.get(value);\nreturn code===undefined?-1:code;\n}\nhas(value){return this.#codes.has(value);}\nvalueOf(code){return this.#values[code];}\nvalues(){return this.#values;}\nranks(locale){\nconst key=locale||'';\nif(this.#ranks&&this.#ranksVersion===this.#version&&this.#ranksLocale===key){\nreturn this.#ranks;\n}\nconst n=this.#values.length;\nconst order=new Array(n);\nfor(let i=0;i<n;i++)order[i]=i;\nconst cmp=collator(locale).compare;\nconst values=this.#values;\norder.sort((a,b)=>this.#compare(values[a],values[b],cmp));\nconst ranks=new Uint32Array(n);\nfor(let rank=0;rank<n;rank++)ranks[order[rank]]=rank;\nthis.#ranks=ranks;\nthis.#ranksVersion=this.#version;\nthis.#ranksLocale=key;\nreturn ranks;\n}\n#compare(a,b,compare){\nif(typeof a==='string'&&typeof b==='string')return compare(a,b);\nreturn defaultCompare(a,b);\n}\n}\n});\n__def(\"packages/core/src/store/multivalue.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"MultiValue\",{enumerable:true,get:function(){return MultiValue;}});\nclass MultiValue{\n#values;\n#offsets;\n#rows=0;\n#fill=0;\nconstructor(capacity={}){\nconst rows=Math.max(1,capacity.rows??16);\nconst values=Math.max(1,capacity.values??rows);\nthis.#values=new Int32Array(values);\nthis.#offsets=new Uint32Array(rows+1);\n}\nget values(){return this.#values;}\nget offsets(){return this.#offsets;}\nget rows(){return this.#rows;}\nget length(){return this.#fill;}\nget bytes(){return this.#values.byteLength+this.#offsets.byteLength;}\ncount(r){\nif(r<0||r>=this.#rows)return 0;\nreturn this.#offsets[r+1]-this.#offsets[r];\n}\nat(r){\nif(r<0||r>=this.#rows)return this.#values.subarray(0,0);\nreturn this.#values.subarray(this.#offsets[r],this.#offsets[r+1]);\n}\nhas(r,code){\nif(r<0||r>=this.#rows)return false;\nconst v=this.#values;\nconst end=this.#offsets[r+1];\nfor(let i=this.#offsets[r];i<end;i++)if(v[i]===code)return true;\nreturn false;\n}\nhasAny(r,codes){\nfor(let i=0;i<codes.length;i++)if(this.has(r,codes[i]))return true;\nreturn false;\n}\nhasAll(r,codes){\nfor(let i=0;i<codes.length;i++)if(!this.has(r,codes[i]))return false;\nreturn true;\n}\nhasNone(r,codes){return!this.hasAny(r,codes);}\npush(codes){\nconst r=this.#rows;\nconst n=codes.length;\nthis.#ensureRows(r+1);\nthis.#ensureValues(this.#fill+n);\nconst start=this.#fill;\nfor(let i=0;i<n;i++)this.#values[start+i]=codes[i]|0;\nthis.#fill+=n;\nthis.#rows=r+1;\nthis.#offsets[r]=start;\nthis.#offsets[r+1]=this.#fill;\nreturn r;\n}\nwrite(r,codes){\nif(r===this.#rows){this.push(codes);return;}\nif(r<0||r>this.#rows)return;\nconst start=this.#offsets[r];\nconst end=this.#offsets[r+1];\nconst n=codes.length;\nif(end-start===n){\nfor(let i=0;i<n;i++)this.#values[start+i]=codes[i]|0;\nreturn;\n}\nthis.#rebuild(r,codes);\n}\ncompact(remap,liveCount,dead){\nconst oldValues=this.#values;\nconst oldOffsets=this.#offsets;\nconst oldRows=this.#rows;\nconst values=new Int32Array(Math.max(1,this.#fill));\nconst offsets=new Uint32Array(liveCount+1);\nlet w=0;\nfor(let p=0;p<oldRows;p++){\nif(remap[p]===dead)continue;\nconst start=oldOffsets[p];\nconst end=oldOffsets[p+1];\noffsets[remap[p]]=w;\nfor(let i=start;i<end;i++)values[w++]=oldValues[i];\noffsets[remap[p]+1]=w;\n}\nthis.#values=values;\nthis.#offsets=offsets;\nthis.#rows=liveCount;\nthis.#fill=w;\n}\nrelease(){\nthis.#values=new Int32Array(0);\nthis.#offsets=new Uint32Array(1);\nthis.#rows=0;\nthis.#fill=0;\n}\n#ensureRows(rows){\nif(rows+1<=this.#offsets.length)return;\nlet cap=this.#offsets.length-1;\nwhile(cap<rows)cap=cap*2||16;\nconst next=new Uint32Array(cap+1);\nnext.set(this.#offsets);\nthis.#offsets=next;\n}\n#ensureValues(n){\nif(n<=this.#values.length)return;\nlet cap=this.#values.length;\nwhile(cap<n)cap=cap*2||16;\nconst next=new Int32Array(cap);\nnext.set(this.#values);\nthis.#values=next;\n}\n#rebuild(r,codes){\nconst oldValues=this.#values;\nconst oldOffsets=this.#offsets;\nconst rows=this.#rows;\nconst delta=codes.length-(oldOffsets[r+1]-oldOffsets[r]);\nconst values=new Int32Array(Math.max(1,this.#fill+delta));\nconst offsets=new Uint32Array(oldOffsets.length);\nlet w=0;\nfor(let p=0;p<rows;p++){\noffsets[p]=w;\nif(p===r){\nfor(let i=0;i<codes.length;i++)values[w++]=codes[i]|0;\n}else{\nfor(let i=oldOffsets[p];i<oldOffsets[p+1];i++)values[w++]=oldValues[i];\n}\noffsets[p+1]=w;\n}\nthis.#values=values;\nthis.#offsets=offsets;\nthis.#fill=w;\n}\n}\n});\n__def(\"packages/core/src/compute/handle.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"identity\",{enumerable:true,get:function(){return identity;}});\nObject.defineProperty(__exports,\"rowCount\",{enumerable:true,get:function(){return rowCount;}});\nObject.defineProperty(__exports,\"bitReader\",{enumerable:true,get:function(){return bitReader;}});\nObject.defineProperty(__exports,\"presenceReader\",{enumerable:true,get:function(){return presenceReader;}});\nObject.defineProperty(__exports,\"dictSize\",{enumerable:true,get:function(){return dictSize;}});\nObject.defineProperty(__exports,\"dictValue\",{enumerable:true,get:function(){return dictValue;}});\nObject.defineProperty(__exports,\"multiValue\",{enumerable:true,get:function(){return multiValue;}});\nObject.defineProperty(__exports,\"valueReader\",{enumerable:true,get:function(){return valueReader;}});\nObject.defineProperty(__exports,\"numericTotalOrder\",{enumerable:true,get:function(){return numericTotalOrder;}});\nObject.defineProperty(__exports,\"valueComparator\",{enumerable:true,get:function(){return valueComparator;}});\nObject.defineProperty(__exports,\"dictRanks\",{enumerable:true,get:function(){return dictRanks;}});\nObject.defineProperty(__exports,\"isMissing\",{enumerable:true,get:function(){return isMissing;}});\nconst __m0=__req(\"packages/core/src/internal/util.js\");\nconst collator=__m0[\"collator\"];\nconst defaultCompare=__m0[\"defaultCompare\"];\nconst warnOnce=__m0[\"warnOnce\"];\nfunction identity(n){\nconst out=new Uint32Array(n);\nfor(let i=0;i<n;i++)out[i]=i;\nreturn out;\n}\nfunction rowCount(handle,opts){\nif(opts&&typeof opts.count==='number')return opts.count;\nif(!handle)return 0;\nif(typeof handle.count==='number')return handle.count;\nif(typeof handle.length==='number')return handle.length;\nconst values=handle.values;\nif(handle.kind==='multi'&&handle.offsets)return Math.max(0,handle.offsets.length-1);\nif(!values)return handle.presence&&typeof handle.presence.size==='number'?handle.presence.size:0;\nif(handle.kind==='bitset'){\nif(typeof values.size==='number')return values.size;\nif(handle.presence&&typeof handle.presence.size==='number')return handle.presence.size;\nwarnOnce(`count:${handle.id}`,`column \"${handle.id}\" is bitset-backed with no declared row count; assuming ${values.length*8}`);\nreturn values.length*8;\n}\nreturn values.length;\n}\nconst bitOrders=new WeakMap();\nfunction bitOrderOf(bitset){\nconst ctor=bitset.constructor;\nif(!ctor)return'unknown';\nconst cached=bitOrders.get(ctor);\nif(cached)return cached;\nlet order='unknown';\ntry{\nlet probe=null;\nif(typeof ctor.from==='function')probe=ctor.from([false,true]);\nelse{\nprobe=new ctor(8);\nprobe.set(1);\n}\nconst words=probe&&probe.words;\nif(words&&words.length){\nif(words[0]===0x02)order='lsb';\nelse if(words[0]===0x40)order='msb';\n}\n}catch{\norder='unknown';\n}\nbitOrders.set(ctor,order);\nreturn order;\n}\nfunction bitReader(bits){\nif(!bits)return()=>0;\nconst raw=bits instanceof Uint8Array?bits:bits.words;\nif(raw instanceof Uint8Array){\nconst order=bits instanceof Uint8Array?'lsb':bitOrderOf(bits);\nif(order==='lsb')return(i)=>(raw[i>>>3]>>>(i&7))&1;\nif(order==='msb')return(i)=>(raw[i>>>3]>>>(7-(i&7)))&1;\n}\nif(typeof bits.get==='function')return(i)=>(bits.get(i)?1:0);\nreturn()=>0;\n}\nfunction presenceReader(handle){\nif(!handle||!handle.presence)return null;\nreturn bitReader(handle.presence);\n}\nfunction dictSize(dict){\nif(!dict)return 0;\nif(typeof dict.size==='number')return dict.size;\nif(typeof dict.values==='function')return dict.values().length;\nreturn 0;\n}\nfunction dictValue(dict,code){\nif(!dict)return null;\nif(typeof dict.valueOf==='function')return dict.valueOf(code);\nif(typeof dict.values==='function')return dict.values()[code];\nreturn null;\n}\nfunction multiValue(handle,i){\nconst offsets=handle.offsets;\nconst values=handle.values;\nif(!offsets||!values)return[];\nconst from=offsets[i];\nconst to=offsets[i+1];\nif(!(to>from))return[];\nconst dict=handle.dict;\nconst out=new Array(to-from);\nfor(let k=from;k<to;k++)out[k-from]=dict?dictValue(dict,values[k]):values[k];\nreturn out;\n}\nfunction valueReader(handle){\nif(!handle)return()=>undefined;\nconst values=handle.values;\nconst present=presenceReader(handle);\nconst kind=handle.kind;\nif(kind==='dictionary'){\nconst dict=handle.dict;\nif(present)return(i)=>(present(i)?dictValue(dict,values[i]):null);\nreturn(i)=>dictValue(dict,values[i]);\n}\nif(kind==='bitset'){\nconst bit=bitReader(values);\nif(present)return(i)=>(present(i)?bit(i)===1:null);\nreturn(i)=>bit(i)===1;\n}\nif(kind==='multi'){\nif(present)return(i)=>(present(i)?multiValue(handle,i):null);\nreturn(i)=>multiValue(handle,i);\n}\nif(!values&&typeof handle.get==='function'){\nconst get=handle.get.bind(handle);\nreturn(i)=>{\nconst v=get(i);\nreturn v===undefined?null:v;\n};\n}\nif(present){\nreturn(i)=>{\nif(!present(i))return null;\nconst v=values[i];\nreturn v===undefined?null:v;\n};\n}\nreturn(i)=>{\nconst v=values[i];\nreturn v===undefined?null:v;\n};\n}\nfunction numericTotalOrder(a,b){\nif(a<b)return-1;\nif(a>b)return 1;\nif(a===b){\nconst na=Object.is(a,-0);\nconst nb=Object.is(b,-0);\nif(na===nb)return 0;\nreturn na?-1:1;\n}\nconst an=Number.isNaN(a);\nconst bn=Number.isNaN(b);\nif(an&&bn)return 0;\nreturn an?1:-1;\n}\nfunction valueComparator(locale){\nconst coll=collator(locale);\nreturn(a,b)=>{\nif(a===b)return 0;\nconst ta=typeof a;\nconst tb=typeof b;\nif(ta==='string'&&tb==='string')return coll.compare(a,b);\nif(ta==='number'&&tb==='number')return numericTotalOrder(a,b);\nif(ta==='boolean'&&tb==='boolean')return a===b?0:a?1:-1;\nif(a instanceof Date||b instanceof Date){\nconst na=a instanceof Date?a.getTime():Number(a);\nconst nb=b instanceof Date?b.getTime():Number(b);\nreturn numericTotalOrder(na,nb);\n}\nreturn defaultCompare(a,b);\n};\n}\nfunction dictRanks(dict,locale){\nif(dict&&typeof dict.ranks==='function')return dict.ranks(locale);\nconst table=dict&&typeof dict.values==='function'?dict.values():[];\nconst n=table.length;\nconst cmp=valueComparator(locale);\nconst order=new Array(n);\nfor(let i=0;i<n;i++)order[i]=i;\norder.sort((a,b)=>cmp(table[a],table[b])||a-b);\nconst ranks=new Uint32Array(n);\nfor(let r=0;r<n;r++)ranks[order[r]]=r;\nreturn ranks;\n}\nfunction isMissing(v){\nreturn v===null||v===undefined||(typeof v==='number'&&Number.isNaN(v));\n}\n});\n__def(\"packages/core/src/compute/sort.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"radixSortFloat64\",{enumerable:true,get:function(){return radixSortFloat64;}});\nObject.defineProperty(__exports,\"radixSortInt32\",{enumerable:true,get:function(){return radixSortInt32;}});\nObject.defineProperty(__exports,\"rankSortDictionary\",{enumerable:true,get:function(){return rankSortDictionary;}});\nObject.defineProperty(__exports,\"mergeSortComparator\",{enumerable:true,get:function(){return mergeSortComparator;}});\nObject.defineProperty(__exports,\"rankSortStrings\",{enumerable:true,get:function(){return rankSortStrings;}});\nObject.defineProperty(__exports,\"collateStringRanks\",{enumerable:true,get:function(){return collateStringRanks;}});\nObject.defineProperty(__exports,\"sortColumn\",{enumerable:true,get:function(){return sortColumn;}});\nObject.defineProperty(__exports,\"sortMulti\",{enumerable:true,get:function(){return sortMulti;}});\nconst __m0=__req(\"packages/core/src/compute/handle.js\");\nconst bitReader=__m0[\"bitReader\"];\nconst dictRanks=__m0[\"dictRanks\"];\nconst dictSize=__m0[\"dictSize\"];\nconst identity=__m0[\"identity\"];\nconst isMissing=__m0[\"isMissing\"];\nconst presenceReader=__m0[\"presenceReader\"];\nconst rowCount=__m0[\"rowCount\"];\nconst valueComparator=__m0[\"valueComparator\"];\nconst valueReader=__m0[\"valueReader\"];\nconst EMPTY_INDICES=new Uint32Array(0);\nconst SCRATCH=new ArrayBuffer(8);\nconst SCRATCH_F64=new Float64Array(SCRATCH);\nconst SCRATCH_U32=new Uint32Array(SCRATCH);\nconst HI=(()=>{\nSCRATCH_F64[0]=-1;\nreturn(SCRATCH_U32[1]&0x80000000)!==0?1:0;\n})();\nconst LO=HI===1?0:1;\nfunction transformDouble(value,out){\nSCRATCH_F64[0]=value;\nlet hi=SCRATCH_U32[HI];\nlet lo=SCRATCH_U32[LO];\nif((hi&0x80000000)!==0){\nhi=~hi>>>0;\nlo=~lo>>>0;\n}else{\nhi=(hi^0x80000000)>>>0;\n}\nout[0]=lo;\nout[1]=hi;\n}\nfunction radixLsd64(idx,lo,hi,n){\nif(n<2)return idx;\nconst hist=new Uint32Array(256*8);\nfor(let i=0;i<n;i++){\nconst l=lo[i];\nconst h=hi[i];\nhist[l&0xff]++;\nhist[256+((l>>>8)&0xff)]++;\nhist[512+((l>>>16)&0xff)]++;\nhist[768+((l>>>24)&0xff)]++;\nhist[1024+(h&0xff)]++;\nhist[1280+((h>>>8)&0xff)]++;\nhist[1536+((h>>>16)&0xff)]++;\nhist[1792+((h>>>24)&0xff)]++;\n}\nlet srcIdx=idx;\nlet srcLo=lo;\nlet srcHi=hi;\nlet dstIdx=new Uint32Array(n);\nlet dstLo=new Uint32Array(n);\nlet dstHi=new Uint32Array(n);\nconst offset=new Uint32Array(256);\nfor(let pass=0;pass<8;pass++){\nconst base=pass<<8;\nconst shift=(pass&3)<<3;\nconst useHi=pass>=4;\nlet skip=false;\nfor(let b=0;b<256;b++){\nif(hist[base+b]===n){skip=true;break;}\n}\nif(skip)continue;\nlet sum=0;\nfor(let b=0;b<256;b++){\noffset[b]=sum;\nsum+=hist[base+b];\n}\nfor(let i=0;i<n;i++){\nconst l=srcLo[i];\nconst h=srcHi[i];\nconst digit=((useHi?h:l)>>>shift)&0xff;\nconst p=offset[digit]++;\ndstIdx[p]=srcIdx[i];\ndstLo[p]=l;\ndstHi[p]=h;\n}\nlet t=srcIdx;srcIdx=dstIdx;dstIdx=t;\nt=srcLo;srcLo=dstLo;dstLo=t;\nt=srcHi;srcHi=dstHi;dstHi=t;\n}\nreturn srcIdx;\n}\nfunction radixLsd32(idx,keys,n){\nif(n<2)return idx;\nconst hist=new Uint32Array(256*4);\nfor(let i=0;i<n;i++){\nconst k=keys[i];\nhist[k&0xff]++;\nhist[256+((k>>>8)&0xff)]++;\nhist[512+((k>>>16)&0xff)]++;\nhist[768+((k>>>24)&0xff)]++;\n}\nlet srcIdx=idx;\nlet srcKeys=keys;\nlet dstIdx=new Uint32Array(n);\nlet dstKeys=new Uint32Array(n);\nconst offset=new Uint32Array(256);\nfor(let pass=0;pass<4;pass++){\nconst base=pass<<8;\nconst shift=pass<<3;\nlet skip=false;\nfor(let b=0;b<256;b++){\nif(hist[base+b]===n){skip=true;break;}\n}\nif(skip)continue;\nlet sum=0;\nfor(let b=0;b<256;b++){\noffset[b]=sum;\nsum+=hist[base+b];\n}\nfor(let i=0;i<n;i++){\nconst k=srcKeys[i];\nconst p=offset[(k>>>shift)&0xff]++;\ndstIdx[p]=srcIdx[i];\ndstKeys[p]=k;\n}\nlet t=srcIdx;srcIdx=dstIdx;dstIdx=t;\nt=srcKeys;srcKeys=dstKeys;dstKeys=t;\n}\nreturn srcIdx;\n}\nfunction countingSort(idx,keys,n,radix){\nconst counts=new Uint32Array(radix+1);\nfor(let i=0;i<n;i++)counts[keys[i]]++;\nlet sum=0;\nfor(let k=0;k<=radix;k++){\nconst c=counts[k];\ncounts[k]=sum;\nsum+=c;\n}\nconst out=new Uint32Array(n);\nfor(let i=0;i<n;i++)out[counts[keys[i]]++]=idx[i];\nreturn out;\n}\nfunction sortUint32Keys(idx,keys,n,radix){\nif(n<2)return idx;\nif(radix<=65536||radix<=n*2)return countingSort(idx,keys,n,radix);\nreturn radixLsd32(idx,keys,n);\n}\nfunction exact(buffer,n){\nif(buffer.length===n&&buffer.byteOffset===0)return buffer;\nreturn Uint32Array.prototype.slice.call(buffer,0,n);\n}\nfunction radixSortFloat64(values,order,descending=false){\nconst src=order||identity(values.length);\nconst n=src.length;\nif(n<2)return Uint32Array.from(src);\nconst idx=new Uint32Array(n);\nconst lo=new Uint32Array(n);\nconst hi=new Uint32Array(n);\nconst nans=new Uint32Array(n);\nconst pair=new Uint32Array(2);\nlet m=0;\nlet nanCount=0;\nfor(let i=0;i<n;i++){\nconst row=src[i];\nconst v=values[row];\nif(Number.isNaN(v)){nans[nanCount++]=row;continue;}\ntransformDouble(v,pair);\nif(descending){\nlo[m]=~pair[0]>>>0;\nhi[m]=~pair[1]>>>0;\n}else{\nlo[m]=pair[0];\nhi[m]=pair[1];\n}\nidx[m++]=row;\n}\nconst sorted=radixLsd64(idx.subarray(0,m),lo.subarray(0,m),hi.subarray(0,m),m);\nif(nanCount===0)return exact(sorted,m);\nconst out=new Uint32Array(n);\nout.set(sorted.subarray(0,m),0);\nout.set(nans.subarray(0,nanCount),m);\nreturn out;\n}\nfunction radixSortInt32(values,order,descending=false){\nconst src=order||identity(values.length);\nconst n=src.length;\nif(n<2)return Uint32Array.from(src);\nconst idx=Uint32Array.from(src);\nconst keys=new Uint32Array(n);\nfor(let i=0;i<n;i++){\nconst k=(values[idx[i]]^0x80000000)>>>0;\nkeys[i]=descending?(~k>>>0):k;\n}\nreturn exact(radixLsd32(idx,keys,n),n);\n}\nfunction rankSortDictionary(handle,order,opts={}){\nconst src=order||identity(rowCount(handle,opts));\nconst n=src.length;\nif(n<2)return Uint32Array.from(src);\nconst ranks=dictRanks(handle.dict,opts.locale);\nconst codes=handle.values;\nconst present=presenceReader(handle);\nconst size=Math.max(dictSize(handle.dict),ranks.length);\nconst absentRank=size;\nconst idx=Uint32Array.from(src);\nconst keys=new Uint32Array(n);\nconst descending=!!opts.descending;\nfor(let i=0;i<n;i++){\nconst row=idx[i];\nlet rank=present&&present(row)===0?absentRank:ranks[codes[row]];\nif(rank===undefined)rank=absentRank;\nkeys[i]=descending?absentRank-rank:rank;\n}\nreturn exact(sortUint32Keys(idx,keys,n,size+1),n);\n}\nfunction mergeSortComparator(values,order,compare){\nconst n=order.length;\nlet src=Uint32Array.from(order);\nif(n<2)return src;\nlet dst=new Uint32Array(n);\nfor(let width=1;width<n;width<<=1){\nfor(let start=0;start<n;start+=width<<1){\nconst mid=Math.min(start+width,n);\nconst end=Math.min(start+(width<<1),n);\nlet i=start;\nlet j=mid;\nlet k=start;\nwhile(i<mid&&j<end){\ndst[k++]=compare(values[src[i]],values[src[j]])<=0?src[i++]:src[j++];\n}\nwhile(i<mid)dst[k++]=src[i++];\nwhile(j<end)dst[k++]=src[j++];\n}\nconst t=src;src=dst;dst=t;\n}\nreturn src;\n}\nfunction sortBitsetColumn(handle,idx,descending){\nconst bit=bitReader(handle.values);\nconst n=idx.length;\nconst out=new Uint32Array(n);\nconst first=descending?1:0;\nlet k=0;\nfor(let i=0;i<n;i++)if(bit(idx[i])===first)out[k++]=idx[i];\nfor(let i=0;i<n;i++)if(bit(idx[i])!==first)out[k++]=idx[i];\nreturn out;\n}\nfunction indexableValues(handle,idx){\nconst values=handle.values;\nconst kind=handle.kind;\nconst direct=(kind==='object'||kind===undefined)&&(Array.isArray(values)||ArrayBuffer.isView(values));\nif(direct&&!handle.presence)return values;\nconst reader=valueReader(handle);\nconst materialised=new Array(rowCount(handle)||0);\nfor(let i=0;i<idx.length;i++){\nconst row=idx[i];\nmaterialised[row]=reader(row);\n}\nreturn materialised;\n}\nfunction allStrings(values,idx){\nfor(let i=0;i<idx.length;i++){\nif(typeof values[idx[i]]!=='string')return false;\n}\nreturn true;\n}\nfunction rankSortStrings(idx,codes,ranks,d,descending){\nconst n=idx.length;\nconst idxOut=Uint32Array.from(idx);\nif(n<2||d<1)return idxOut;\nconst keys=new Uint32Array(n);\nconst top=d-1;\nfor(let i=0;i<n;i++){\nconst rank=ranks[codes[i]];\nkeys[i]=descending?top-rank:rank;\n}\nreturn exact(sortUint32Keys(idxOut,keys,n,d),n);\n}\nfunction collateStringRanks(table,d,locale){\nconst compare=valueComparator(locale);\nconst order=new Array(d);\nfor(let i=0;i<d;i++)order[i]=i;\norder.sort((a,b)=>compare(table[a],table[b])||a-b);\nconst ranks=new Uint32Array(d);\nfor(let r=0;r<d;r++)ranks[order[r]]=r;\nreturn ranks;\n}\nfunction keyedSortStrings(values,idx,opts){\nconst n=idx.length;\nconst codeOf=new Map();\nconst table=[];\nconst codes=new Uint32Array(n);\nfor(let i=0;i<n;i++){\nconst v=values[idx[i]];\nlet c=codeOf.get(v);\nif(c===undefined){c=table.length;codeOf.set(v,c);table.push(v);}\ncodes[i]=c;\n}\nconst d=table.length;\nconst ranks=collateStringRanks(table,d,opts.locale);\nreturn rankSortStrings(idx,codes,ranks,d,!!opts.descending);\n}\nfunction sortByComparator(handle,idx,opts){\nconst values=indexableValues(handle,idx);\nif(idx.length>=2&&allStrings(values,idx)){\nconst index=handle.stringRank;\nif(index&&index.version===handle.version&&index.usable(idx,values,opts.locale)){\nreturn index.sort(idx,opts);\n}\nreturn keyedSortStrings(values,idx,opts);\n}\nconst base=valueComparator(opts.locale);\nconst compare=opts.descending?(a,b)=>base(b,a):base;\nreturn mergeSortComparator(values,idx,compare);\n}\nfunction sortByCompare(handle,idx,opts){\nconst values=indexableValues(handle,idx);\nconst user=opts.compare;\nconst descending=!!opts.descending;\nconst compare=descending\n?(a,b)=>-user(a,b,undefined,undefined,true)\n:(a,b)=>user(a,b,undefined,undefined,false);\nreturn mergeSortComparator(values,idx,compare);\n}\nfunction partitionPresent(handle,idx){\nconst n=idx.length;\nconst present=presenceReader(handle);\nconst values=handle.values;\nconst checkNaN=handle.kind==='float64'&&!!values;\nconst looseKind=handle.kind==='object'||handle.kind==='multi'||handle.kind===undefined;\nif(!present&&!checkNaN&&!looseKind)return{present:idx,absent:EMPTY_INDICES};\nconst keep=new Uint32Array(n);\nconst drop=new Uint32Array(n);\nlet p=0;\nlet a=0;\nif(present&&checkNaN){\nfor(let i=0;i<n;i++){\nconst row=idx[i];\nif(present(row)===1&&!Number.isNaN(values[row]))keep[p++]=row;else drop[a++]=row;\n}\n}else if(checkNaN&&!present){\nfor(let i=0;i<n;i++){\nconst row=idx[i];\nif(!Number.isNaN(values[row]))keep[p++]=row;else drop[a++]=row;\n}\n}else if(present&&!looseKind){\nfor(let i=0;i<n;i++){\nconst row=idx[i];\nif(present(row)===1)keep[p++]=row;else drop[a++]=row;\n}\n}else{\nconst reader=valueReader(handle);\nfor(let i=0;i<n;i++){\nconst row=idx[i];\nif(!isMissing(reader(row)))keep[p++]=row;else drop[a++]=row;\n}\n}\nif(a===0)return{present:idx,absent:EMPTY_INDICES};\nreturn{present:keep.subarray(0,p),absent:drop.subarray(0,a)};\n}\nfunction joinRuns(sorted,absent,nullsFirst){\nif(absent.length===0)return sorted;\nconst out=new Uint32Array(sorted.length+absent.length);\nif(nullsFirst){\nout.set(absent,0);\nout.set(sorted,absent.length);\n}else{\nout.set(sorted,0);\nout.set(absent,sorted.length);\n}\nreturn out;\n}\nfunction sortColumn(handle,order,opts={}){\nconst src=order||identity(rowCount(handle,opts));\nif(!handle||src.length<2)return Uint32Array.from(src);\nconst{present,absent}=partitionPresent(handle,src);\nif(present.length===0)return Uint32Array.from(src);\nconst descending=!!opts.descending;\nlet sorted;\nif(typeof opts.compare==='function'){\nsorted=sortByCompare(handle,present,opts);\n}else{\nswitch(handle.kind){\ncase'float64':\nsorted=radixSortFloat64(handle.values,present,descending);\nbreak;\ncase'int32':\nsorted=radixSortInt32(handle.values,present,descending);\nbreak;\ncase'dictionary':\nsorted=rankSortDictionary(handle,present,opts);\nbreak;\ncase'bitset':\nsorted=sortBitsetColumn(handle,present,descending);\nbreak;\ndefault:\nsorted=sortByComparator(handle,present,opts);\nbreak;\n}\n}\nreturn joinRuns(sorted,absent,!!opts.nullsFirst);\n}\nfunction sortMulti(handles,entries,order,opts={}){\nconst list=entries||[];\nconst first=(list.length&&(list[0].handle||byId(handles,list[0].col)))||(handles&&handles[0]);\nlet current=order||identity(rowCount(first,opts));\nfor(let i=list.length-1;i>=0;i--){\nconst entry=list[i];\nconst handle=entry.handle||byId(handles,entry.col)||(handles&&handles[i]);\nif(!handle)continue;\ncurrent=sortColumn(handle,current,{\ndescending:entry.descending!==undefined?!!entry.descending:entry.dir==='desc',\nnullsFirst:!!entry.nullsFirst,\nlocale:entry.locale!==undefined?entry.locale:opts.locale,\ncompare:entry.compare,\n});\n}\nreturn current instanceof Uint32Array?current:Uint32Array.from(current);\n}\nfunction byId(handles,id){\nif(!handles||id===undefined)return undefined;\nfor(let i=0;i<handles.length;i++)if(handles[i]&&handles[i].id===id)return handles[i];\nreturn undefined;\n}\n});\n__def(\"packages/core/src/store/stringrank.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"DEFAULT_MAX_DISTINCT\",{enumerable:true,get:function(){return DEFAULT_MAX_DISTINCT;}});\nObject.defineProperty(__exports,\"StringRankIndex\",{enumerable:true,get:function(){return StringRankIndex;}});\nconst __m0=__req(\"packages/core/src/compute/sort.js\");\nconst collateStringRanks=__m0[\"collateStringRanks\"];\nconst rankSortStrings=__m0[\"rankSortStrings\"];\nconst DEFAULT_MAX_DISTINCT=100000;\nclass StringRankIndex{\n#table=[];\n#codeOf=new Map();\n#codeByRow;\n#length=0;\n#generation=0;\n#stamp=-1;\n#maxDistinct;\n#capped=false;\n#ranks=null;\n#ranksGeneration=-1;\n#ranksLocale='\\u0000';\nconstructor(maxDistinct=DEFAULT_MAX_DISTINCT){\nthis.#maxDistinct=maxDistinct>0?maxDistinct:DEFAULT_MAX_DISTINCT;\nthis.#codeByRow=new Uint32Array(0);\n}\nget version(){return this.#stamp;}\nset version(version){this.#stamp=version;}\nget generation(){return this.#generation;}\nget size(){return this.#table.length;}\nget capped(){return this.#capped;}\nget length(){return this.#length;}\nget bytes(){\nlet total=this.#codeByRow.byteLength;\nconst table=this.#table;\nfor(let i=0;i<table.length;i++)total+=table[i].length*2+24;\nreturn total;\n}\n#intern(value,capOnGrowth){\nconst existing=this.#codeOf.get(value);\nif(existing!==undefined)return existing;\nif(this.#capped)return-1;\nif(capOnGrowth&&this.#table.length>=this.#maxDistinct){\nthis.#capped=true;\nreturn-1;\n}\nconst code=this.#table.length;\nthis.#table.push(value);\nthis.#codeOf.set(value,code);\nthis.#generation++;\nreturn code;\n}\nbuild(values,count){\nconst n=count|0;\nthis.#table=[];\nthis.#codeOf=new Map();\nthis.#generation=0;\nthis.#capped=false;\nthis.#ranks=null;\nthis.#ranksGeneration=-1;\nthis.#codeByRow=new Uint32Array(n);\nfor(let row=0;row<n;row++){\nconst v=values[row];\nconst code=typeof v==='string'?this.#intern(v,false):-1;\nthis.#codeByRow[row]=code<0?0:code;\n}\nthis.#length=n;\n}\nappend(values,from,count){\nconst to=(from|0)+(count|0);\nif(to>this.#codeByRow.length){\nconst next=new Uint32Array(to);\nnext.set(this.#codeByRow.subarray(0,this.#length));\nthis.#codeByRow=next;\n}\nfor(let row=from|0;row<to;row++){\nconst v=values[row];\nconst code=typeof v==='string'?this.#intern(v,true):-1;\nthis.#codeByRow[row]=code<0?0:code;\n}\nthis.#length=Math.max(this.#length,to);\n}\nranks(locale){\nconst key=locale||'';\nif(this.#ranks&&this.#ranksGeneration===this.#generation&&this.#ranksLocale===key){\nreturn this.#ranks;\n}\nconst ranks=collateStringRanks(this.#table,this.#table.length,locale);\nthis.#ranks=ranks;\nthis.#ranksGeneration=this.#generation;\nthis.#ranksLocale=key;\nreturn ranks;\n}\nusable(idx,values,locale){\nif(this.#capped||this.#table.length===0)return false;\nconst codeByRow=this.#codeByRow;\nconst table=this.#table;\nconst covered=this.#length;\nfor(let i=0;i<idx.length;i++){\nconst row=idx[i];\nif(row>=covered)return false;\nif(table[codeByRow[row]]!==values[row])return false;\n}\nreturn true;\n}\nsort(idx,opts){\nconst ranks=this.ranks(opts.locale);\nconst d=this.#table.length;\nconst n=idx.length;\nconst codes=new Uint32Array(n);\nconst codeByRow=this.#codeByRow;\nfor(let i=0;i<n;i++)codes[i]=codeByRow[idx[i]];\nreturn rankSortStrings(idx,codes,ranks,d,!!opts.descending);\n}\n}\n});\n__def(\"packages/core/src/store/columnstore.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"REMOVED\",{enumerable:true,get:function(){return REMOVED;}});\nObject.defineProperty(__exports,\"toFloat\",{enumerable:true,get:function(){return toFloat;}});\nObject.defineProperty(__exports,\"ColumnHandle\",{enumerable:true,get:function(){return ColumnHandle;}});\nObject.defineProperty(__exports,\"ColumnStore\",{enumerable:true,get:function(){return ColumnStore;}});\nconst __m0=__req(\"packages/core/src/internal/util.js\");\nconst warnOnce=__m0[\"warnOnce\"];\nconst isFunction=__m0[\"isFunction\"];\nconst pathGetter=__m0[\"pathGetter\"];\nconst __m1=__req(\"packages/core/src/store/bitset.js\");\nconst Bitset=__m1[\"Bitset\"];\nconst __m2=__req(\"packages/core/src/store/dictionary.js\");\nconst Dictionary=__m2[\"Dictionary\"];\nconst __m3=__req(\"packages/core/src/store/multivalue.js\");\nconst MultiValue=__m3[\"MultiValue\"];\nconst __m4=__req(\"packages/core/src/store/stringrank.js\");\nconst StringRankIndex=__m4[\"StringRankIndex\"];\nconst REMOVED=0xFFFFFFFF;\nconst DEFAULT_CAPACITY=1024;\nconst DEFAULT_COLUMNAR_BELOW=5000;\nconst DEFAULT_COMPACT_RATIO=0.2;\nconst KINDS=new Set(['float64','int32','bitset','dictionary','object','multi']);\nfunction absent(v){return v===null||v===undefined;}\nfunction toFloat(v){\nif(typeof v==='number')return v;\nif(v instanceof Date)return v.getTime();\nif(typeof v==='boolean')return v?1:0;\nconst n=Number(v);\nreturn Number.isNaN(n)&&typeof v==='string'?Date.parse(v):n;\n}\nfunction toInt(v){\nconst n=toFloat(v);\nreturn Number.isFinite(n)?n|0:0;\n}\nfunction toMembers(v){\nif(absent(v))return[];\nreturn Array.isArray(v)?v:[v];\n}\nfunction decodeFrom(old,p){\nswitch(old.kind){\ncase'float64':\ncase'int32':return old.buf[p];\ncase'bitset':return old.bits.get(p)===1;\ncase'dictionary':return old.dict.valueOf(old.buf[p]);\ncase'multi':{\nconst codes=old.mv.at(p);\nconst out=new Array(codes.length);\nfor(let i=0;i<codes.length;i++)out[i]=old.dict.valueOf(codes[i]);\nreturn out;\n}\ndefault:return old.buf[p];\n}\n}\nfunction decodePacked(frag,i){\nswitch(frag.kind){\ncase'float64':\ncase'int32':return frag.values[i];\ncase'bitset':return(frag.values[i>>3]&(1<<(i&7)))!==0;\ncase'dictionary':return(frag.table||[])[frag.values[i]];\ncase'multi':{\nconst start=frag.offsets[i];\nconst end=frag.offsets[i+1];\nconst table=frag.table||[];\nconst out=new Array(end-start);\nfor(let k=start;k<end;k++)out[k-start]=table[frag.values[k]];\nreturn out;\n}\ndefault:return frag.values[i];\n}\n}\nclass ColumnHandle{\n#id;\n#kind;\n#target;\n#nullable;\n#read;\n#host;\n#seed;\n#columnar=false;\n#buf=null;\n#bits=null;\n#mv=null;\n#dict=null;\n#stringRank=null;\n#stringRankOn;\n#stringRankMax;\n#stringRankVersion=-1;\n#presence=null;\n#capacity=0;\n#version=0;\n#overlay=null;\n#cache=null;\n#released=false;\nconstructor(schema,host){\nthis.#id=schema.id;\nconst kind=KINDS.has(schema.kind)?schema.kind:'object';\nif(schema.kind&&!KINDS.has(schema.kind)){\nwarnOnce(`store.kind.${schema.id}`,\n`column \"${schema.id}\" declares unknown storage kind \"${schema.kind}\"; falling back to object`);\n}\nthis.#target=kind;\nthis.#kind=kind;\nthis.#nullable=schema.nullable!==false;\nthis.#seed=schema.dictionary??null;\nthis.#host=host;\nthis.#read=isFunction(schema.read)\n?schema.read\n:pathGetter(schema.field||schema.id);\nthis.#stringRankOn=schema.stringRankIndex!=='off';\nthis.#stringRankMax=typeof schema.stringRankMaxDistinct==='number'\n?schema.stringRankMaxDistinct\n:0;\nthis.#overlay=new Map();\n}\nget id(){return this.#id;}\nget kind(){return this.#columnar?this.#kind:'object';}\nget target(){return this.#target;}\nget nullable(){return this.#nullable;}\nget values(){\nif(this.#released)return null;\nif(!this.#columnar)return this.#lazy().values;\nif(this.#kind==='bitset')return this.#bits.words;\nif(this.#kind==='multi')return this.#mv.values;\nreturn this.#buf;\n}\nget presence(){\nif(this.#released||!this.#nullable)return null;\nreturn this.#columnar?this.#presence:this.#lazy().presence;\n}\nget dict(){\nif(this.#released||!this.#columnar)return null;\nreturn this.#kind==='dictionary'||this.#kind==='multi'?this.#dict:null;\n}\nget stringRank(){\nif(this.#released||!this.#stringRankOn)return null;\nif(this.kind!=='object')return null;\nconst values=this.values;\nconst n=this.#host.physical();\nif(!values||n===0)return null;\nif(this.#stringRank===null){\nif(typeof values[0]!=='string')return null;\nconst index=new StringRankIndex(this.#resolveStringRankMax());\nindex.build(values,n);\nindex.version=this.#version;\nthis.#stringRank=index;\nthis.#stringRankVersion=this.#version;\nreturn index.capped?null:index;\n}\nif(this.#stringRank.length<n){\nthis.#stringRank.append(values,this.#stringRank.length,n-this.#stringRank.length);\n}\nthis.#stringRank.version=this.#version;\nthis.#stringRankVersion=this.#version;\nreturn this.#stringRank.capped?null:this.#stringRank;\n}\n#resolveStringRankMax(){return this.#stringRankMax;}\n#dropStringRank(){\nthis.#stringRank=null;\nthis.#stringRankVersion=-1;\n}\nget offsets(){\nif(this.#released||!this.#columnar||this.#kind!=='multi')return null;\nreturn this.#mv.offsets;\n}\nget version(){return this.#version;}\nget bytes(){\nlet total=0;\nif(this.#buf)total+=this.#buf.byteLength??this.#buf.length*8;\nif(this.#bits)total+=this.#bits.bytes;\nif(this.#mv)total+=this.#mv.bytes;\nif(this.#presence)total+=this.#presence.bytes;\nif(this.#dict)total+=this.#dict.bytes;\nif(this.#overlay)total+=this.#overlay.size*24;\nreturn total;\n}\nget(physical){\nif(this.#released)return undefined;\nif(physical<0||physical>=this.#host.physical())return undefined;\nif(!this.#columnar)return this.#rowValue(physical);\nif(this.#nullable&&this.#presence.get(physical)===0)return null;\nswitch(this.#kind){\ncase'float64':\ncase'int32':return this.#buf[physical];\ncase'bitset':return this.#bits.get(physical)===1;\ncase'dictionary':return this.#dict.valueOf(this.#buf[physical]);\ncase'multi':{\nconst codes=this.#mv.at(physical);\nconst out=new Array(codes.length);\nfor(let i=0;i<codes.length;i++)out[i]=this.#dict.valueOf(codes[i]);\nreturn out;\n}\ndefault:return this.#buf[physical];\n}\n}\nset(physical,value){\nif(this.#released)return;\nif(this.#columnar)this.#writeValue(physical,value);\nelse this.#overlay.set(physical,value===undefined?null:value);\nif(this.#stringRank)this.#dropStringRank();\nthis.#version++;\n}\nread(row){return this.#read(row);}\nappendColumn(objects,from,n){\nif(this.#released||n<=0)return;\nif(!this.#columnar){this.#version++;return;}\nconst read=this.#read;\nconst nullable=this.#nullable;\nconst presence=this.#presence;\nlet sawAbsent=false;\nswitch(this.#kind){\ncase'float64':{\nconst buf=this.#buf;\nfor(let i=0;i<n;i++){\nconst v=read(objects[i]);\nif(typeof v==='number'){\nif(nullable)presence.set(from+i);\nbuf[from+i]=v;\ncontinue;\n}\nconst gone=v===null||v===undefined;\nif(nullable)presence.assign(from+i,!gone);\nelse if(gone)sawAbsent=true;\nbuf[from+i]=gone?NaN:toFloat(v);\n}\nbreak;\n}\ncase'int32':{\nconst buf=this.#buf;\nfor(let i=0;i<n;i++){\nconst v=read(objects[i]);\nconst gone=v===null||v===undefined;\nif(nullable)presence.assign(from+i,!gone);\nelse if(gone)sawAbsent=true;\nbuf[from+i]=gone?0:toInt(v);\n}\nbreak;\n}\ncase'bitset':{\nconst bits=this.#bits;\nfor(let i=0;i<n;i++){\nconst v=read(objects[i]);\nconst gone=v===null||v===undefined;\nif(nullable)presence.assign(from+i,!gone);\nelse if(gone)sawAbsent=true;\nbits.assign(from+i,!gone&&!!v);\n}\nbreak;\n}\ncase'dictionary':{\nconst buf=this.#buf;\nconst dict=this.#dict;\nfor(let i=0;i<n;i++){\nconst v=read(objects[i]);\nconst gone=v===null||v===undefined;\nif(nullable)presence.assign(from+i,!gone);\nelse if(gone)sawAbsent=true;\nbuf[from+i]=gone?0:dict.codeOf(v);\n}\nbreak;\n}\ncase'multi':{\nconst mv=this.#mv;\nconst dict=this.#dict;\nfor(let i=0;i<n;i++){\nconst v=read(objects[i]);\nconst gone=v===null||v===undefined;\nif(nullable)presence.assign(from+i,!gone);\nelse if(gone)sawAbsent=true;\nconst members=toMembers(v);\nconst codes=new Array(members.length);\nfor(let k=0;k<members.length;k++)codes[k]=dict.codeOf(members[k]);\nmv.write(from+i,codes);\n}\nbreak;\n}\ndefault:{\nconst buf=this.#buf;\nfor(let i=0;i<n;i++){\nconst v=read(objects[i]);\nconst gone=v===null||v===undefined;\nif(nullable)presence.assign(from+i,!gone);\nelse if(gone)sawAbsent=true;\nbuf[from+i]=gone?null:v;\n}\nbreak;\n}\n}\nif(sawAbsent){\nwarnOnce(`store.null.${this.#id}`,\n`column \"${this.#id}\" is declared non-nullable but received null; storing a filler value`);\n}\nif(this.#stringRank&&this.#kind==='object'){\nthis.#stringRank.append(this.#buf,from,n);\nthis.#stringRank.version=this.#version+1;\nthis.#stringRankVersion=this.#version+1;\n}\nthis.#version++;\n}\nappendPacked(frag,from,n){\nif(this.#released||n<=0||!frag)return;\nif(!this.#columnar){this.#version++;return;}\nconst presence=this.#presence;\nconst fragPresence=frag.presence;\nif(presence){\nif(fragPresence){\nfor(let i=0;i<n;i++)presence.assign(from+i,(fragPresence[i>>3]&(1<<(i&7)))!==0);\n}else{\nfor(let i=0;i<n;i++)presence.set(from+i);\n}\n}\nconst kindsAgree=frag.kind===this.#kind;\nif(kindsAgree&&(this.#kind==='float64'||this.#kind==='int32')){\nthis.#buf.set(frag.values,from);\nthis.#version++;\nreturn;\n}\nif(kindsAgree&&this.#kind==='bitset'){\nconst words=frag.values;\nfor(let i=0;i<n;i++)this.#bits.assign(from+i,(words[i>>3]&(1<<(i&7)))!==0);\nthis.#version++;\nreturn;\n}\nif(kindsAgree&&this.#kind==='dictionary'){\nconst table=frag.table||[];\nconst remap=new Uint32Array(table.length);\nfor(let t=0;t<table.length;t++)remap[t]=this.#dict.codeOf(table[t]);\nconst codes=frag.values;\nconst buf=this.#buf;\nconst pres=presence;\nfor(let i=0;i<n;i++){\nif(pres&&(fragPresence?(fragPresence[i>>3]&(1<<(i&7)))===0:false)){buf[from+i]=0;continue;}\nbuf[from+i]=remap[codes[i]]??0;\n}\nthis.#version++;\nreturn;\n}\nif(kindsAgree&&this.#kind==='multi'){\nconst table=frag.table||[];\nconst remap=new Uint32Array(table.length);\nfor(let t=0;t<table.length;t++)remap[t]=this.#dict.codeOf(table[t]);\nconst flat=frag.values;\nconst offsets=frag.offsets;\nfor(let i=0;i<n;i++){\nconst start=offsets[i];\nconst end=offsets[i+1];\nconst codes=new Array(end-start);\nfor(let k=start;k<end;k++)codes[k-start]=remap[flat[k]]??0;\nthis.#mv.write(from+i,codes);\n}\nthis.#version++;\nreturn;\n}\nfor(let i=0;i<n;i++){\nconst gone=fragPresence\n?(fragPresence[i>>3]&(1<<(i&7)))===0\n:(frag.kind==='object'?frag.values[i]===null:false);\nthis.#writeValue(from+i,gone?null:decodePacked(frag,i));\n}\nthis.#version++;\n}\ntouch(){this.#version++;}\ncolumnarise(capacity,fill){\nif(this.#columnar||this.#released)return;\nconst values=new Array(fill);\nfor(let p=0;p<fill;p++)values[p]=this.#rowValue(p);\nthis.#kind=this.#target;\nthis.#columnar=true;\nthis.#alloc(capacity);\nfor(let p=0;p<fill;p++)this.#writeValue(p,values[p]);\nthis.#overlay.clear();\nthis.#cache=null;\nthis.#dropStringRank();\nthis.#version++;\n}\ngrow(capacity){\nif(!this.#columnar||this.#released||capacity<=this.#capacity)return;\nswitch(this.#kind){\ncase'float64':case'int32':case'dictionary':{\nconst next=new this.#buf.constructor(capacity);\nnext.set(this.#buf);\nthis.#buf=next;\nbreak;\n}\ncase'bitset':this.#bits.grow(capacity);break;\ncase'multi':break;\ndefault:this.#buf.length=capacity;break;\n}\nif(this.#presence)this.#presence.grow(capacity);\nthis.#capacity=capacity;\nthis.#version++;\n}\nconvert(kind){\nif(this.#released||!KINDS.has(kind))return false;\nthis.#target=kind;\nif(!this.#columnar||kind===this.#kind)return false;\nconst old={kind:this.#kind,buf:this.#buf,bits:this.#bits,mv:this.#mv,dict:this.#dict};\nconst n=this.#host.physical();\nconst presence=this.#presence;\nthis.#kind=kind;\nthis.#alloc(this.#capacity);\nfor(let p=0;p<n;p++){\nconst gone=presence!==null&&presence.get(p)===0;\nif(gone&&kind!=='multi')continue;\nthis.#writeValue(p,gone?null:decodeFrom(old,p));\n}\nthis.#dropStringRank();\nthis.#version++;\nreturn true;\n}\ncompact(remap,oldFill,liveCount){\nif(this.#released)return;\nthis.#dropStringRank();\nif(!this.#columnar){\nconst overlay=this.#overlay;\nif(overlay.size){\nconst next=new Map();\nfor(const[p,v]of overlay)if(remap[p]!==REMOVED)next.set(remap[p],v);\nthis.#overlay=next;\n}\nthis.#cache=null;\nthis.#version++;\nreturn;\n}\nswitch(this.#kind){\ncase'float64':case'int32':case'dictionary':case'object':{\nconst buf=this.#buf;\nfor(let p=0;p<oldFill;p++)if(remap[p]!==REMOVED)buf[remap[p]]=buf[p];\nif(this.#kind==='object')for(let p=liveCount;p<oldFill;p++)buf[p]=undefined;\nbreak;\n}\ncase'bitset':{\nconst bits=this.#bits;\nfor(let p=0;p<oldFill;p++)if(remap[p]!==REMOVED)bits.assign(remap[p],bits.get(p)===1);\nfor(let p=liveCount;p<oldFill;p++)bits.clear(p);\nbreak;\n}\ncase'multi':this.#mv.compact(remap,liveCount,REMOVED);break;\ndefault:break;\n}\nif(this.#presence){\nconst pres=this.#presence;\nfor(let p=0;p<oldFill;p++)if(remap[p]!==REMOVED)pres.assign(remap[p],pres.get(p)===1);\nfor(let p=liveCount;p<oldFill;p++)pres.clear(p);\n}\nthis.#version++;\n}\nrelease(){\nif(this.#released)return;\nthis.#released=true;\nthis.#buf=null;\nif(this.#bits)this.#bits.release();\nthis.#bits=null;\nif(this.#mv)this.#mv.release();\nthis.#mv=null;\nif(this.#presence)this.#presence.release();\nthis.#presence=null;\nthis.#dict=null;\nthis.#stringRank=null;\nthis.#overlay=new Map();\nthis.#cache=null;\nthis.#capacity=0;\nthis.#version++;\n}\n#alloc(capacity){\nconst cap=Math.max(1,capacity);\nthis.#buf=null;\nthis.#bits=null;\nthis.#mv=null;\nswitch(this.#kind){\ncase'float64':this.#buf=new Float64Array(cap);break;\ncase'int32':this.#buf=new Int32Array(cap);break;\ncase'bitset':this.#bits=new Bitset(cap);break;\ncase'dictionary':\nthis.#buf=new Uint32Array(cap);\nthis.#dict=this.#dict??new Dictionary(this.#seed??[]);\nbreak;\ncase'multi':\nthis.#mv=new MultiValue({rows:cap,values:cap});\nthis.#dict=this.#dict??new Dictionary(this.#seed??[]);\nbreak;\ndefault:this.#buf=new Array(cap);break;\n}\nif(this.#kind!=='dictionary'&&this.#kind!=='multi')this.#dict=null;\nif(this.#nullable){\nif(this.#presence)this.#presence.grow(cap);\nelse this.#presence=new Bitset(cap);\n}\nthis.#capacity=cap;\n}\n#writeValue(p,value){\nconst gone=absent(value);\nif(this.#nullable)this.#presence.assign(p,!gone);\nelse if(gone){\nwarnOnce(`store.null.${this.#id}`,\n`column \"${this.#id}\" is declared non-nullable but received null; storing a filler value`);\n}\nswitch(this.#kind){\ncase'float64':this.#buf[p]=gone?NaN:toFloat(value);break;\ncase'int32':this.#buf[p]=gone?0:toInt(value);break;\ncase'bitset':this.#bits.assign(p,!gone&&!!value);break;\ncase'dictionary':this.#buf[p]=gone?0:this.#dict.codeOf(value);break;\ncase'multi':{\nconst members=toMembers(value);\nconst codes=new Array(members.length);\nfor(let i=0;i<members.length;i++)codes[i]=this.#dict.codeOf(members[i]);\nthis.#mv.write(p,codes);\nbreak;\n}\ndefault:this.#buf[p]=gone?null:value;break;\n}\n}\n#rowValue(p){\nif(this.#overlay.has(p))return this.#overlay.get(p);\nconst v=this.#read(this.#host.rowAt(p));\nreturn v===undefined?null:v;\n}\n#lazy(){\nif(this.#cache&&this.#cache.version===this.#version)return this.#cache;\nconst n=this.#host.physical();\nconst values=new Array(n);\nconst presence=this.#nullable?new Bitset(n):null;\nfor(let p=0;p<n;p++){\nconst v=this.#rowValue(p);\nvalues[p]=v;\nif(presence&&!absent(v))presence.set(p);\n}\nthis.#cache={version:this.#version,values,presence};\nreturn this.#cache;\n}\n}\nclass ColumnStore{\n#schema;\n#handles=new Map();\n#list=[];\n#rows=[];\n#fill=0;\n#capacity=0;\n#live=0;\n#dead=0;\n#tombs=new Bitset(0);\n#columnar=false;\n#retainSource=true;\n#columnarBelow;\n#initial;\n#ratio;\n#destroyed=false;\nconstructor(schema,opts={}){\nthis.#schema=Array.isArray(schema)?schema:[];\nthis.#initial=Math.max(1,opts.initialCapacity??DEFAULT_CAPACITY);\nthis.#retainSource=opts.retainSource!==false;\nthis.#columnarBelow=this.#retainSource?(opts.columnarBelow??DEFAULT_COLUMNAR_BELOW):0;\nthis.#ratio=opts.compactRatio??DEFAULT_COMPACT_RATIO;\nconst host={\nrowAt:(p)=>this.#rows[p],\nphysical:()=>this.#fill,\n};\nfor(const entry of this.#schema){\nif(!entry||!entry.id)continue;\nif(this.#handles.has(entry.id)){\nwarnOnce(`store.dup.${entry.id}`,`duplicate column id \"${entry.id}\" in the store schema; ignoring the second`);\ncontinue;\n}\nconst handle=new ColumnHandle(entry,host);\nthis.#handles.set(entry.id,handle);\nthis.#list.push(handle);\n}\nif(this.#columnarBelow<=0)this.#columnarise();\n}\nget count(){return this.#live;}\nget physical(){return this.#fill;}\nget capacity(){return this.#columnar?this.#capacity:this.#rows.length;}\nget tombstones(){return this.#dead;}\nget columnar(){return this.#columnar;}\nget destroyed(){return this.#destroyed;}\nget bytes(){\nlet total=this.#tombs.bytes+this.#rows.length*8;\nfor(const h of this.#list)total+=h.bytes;\nreturn total;\n}\nappend(objects){\nconst from=this.#fill;\nif(this.#destroyed||!objects)return{from,to:from};\nconst n=objects.length|0;\nif(n===0)return{from,to:from};\nif(this.#retainSource)for(let i=0;i<n;i++)this.#rows[from+i]=objects[i];\nthis.#fill=from+n;\nthis.#live+=n;\nthis.#tombs.grow(this.#fill);\nif(!this.#columnar){\nif(this.#fill>=this.#columnarBelow)this.#columnarise();\nelse for(const h of this.#list)h.touch();\nreturn{from,to:this.#fill};\n}\nthis.#ensure(this.#fill);\nconst cols=this.#list;\nfor(let c=0;c<cols.length;c++)cols[c].appendColumn(objects,from,n);\nreturn{from,to:this.#fill};\n}\nappendPacked(chunk,objects){\nconst from=this.#fill;\nif(this.#destroyed||!chunk)return{from,to:from};\nconst n=chunk.count|0;\nif(n===0)return{from,to:from};\nif(this.#retainSource&&objects){\nfor(let i=0;i<n;i++)this.#rows[from+i]=objects[i];\n}\nthis.#fill=from+n;\nthis.#live+=n;\nthis.#tombs.grow(this.#fill);\nif(!this.#columnar)this.#columnarise();\nthis.#ensure(this.#fill);\nconst byId=new Map();\nfor(const col of chunk.columns)byId.set(col.id,col);\nfor(const h of this.#list){\nconst frag=byId.get(h.id);\nif(frag)h.appendPacked(frag,from,n);\nelse{\nh.grow(this.#capacity);\n}\n}\nreturn{from,to:this.#fill};\n}\nsource(physical){\nif(this.#retainSource)return this.#rows[physical];\nif(physical<0||physical>=this.#fill)return undefined;\nreturn this.#reconstruct(physical);\n}\nsetSource(physical,object){\nif(this.#destroyed)return;\nif(physical<0||physical>=this.#fill)return;\nif(!this.#retainSource)return;\nthis.#rows[physical]=object;\n}\nget(colId,physical){\nconst h=this.#handles.get(colId);\nreturn h?h.get(physical):undefined;\n}\nset(colId,physical,value){\nif(this.#destroyed)return;\nif(physical<0||physical>=this.#fill)return;\nconst h=this.#handles.get(colId);\nif(!h){\nwarnOnce(`store.set.${colId}`,`set() on unknown column \"${colId}\"`);\nreturn;\n}\nh.set(physical,value);\n}\nremove(physical){\nif(this.#destroyed||physical<0||physical>=this.#fill)return false;\nif(this.#tombs.get(physical)===1)return false;\nthis.#tombs.set(physical);\nthis.#dead++;\nthis.#live--;\nreturn true;\n}\nlive(physical){\nif(physical<0||physical>=this.#fill)return false;\nreturn this.#tombs.get(physical)===0;\n}\ncompact(opts={}){\nif(this.#destroyed||this.#dead===0)return null;\nif(!opts.force&&this.#dead/this.#fill<this.#ratio)return null;\nconst oldFill=this.#fill;\nconst remap=new Uint32Array(oldFill);\nlet w=0;\nfor(let p=0;p<oldFill;p++)remap[p]=this.#tombs.get(p)===1?REMOVED:w++;\nfor(const h of this.#list)h.compact(remap,oldFill,w);\nif(this.#retainSource){\nconst rows=this.#rows;\nfor(let p=0;p<oldFill;p++)if(remap[p]!==REMOVED)rows[remap[p]]=rows[p];\nrows.length=w;\n}\nthis.#fill=w;\nthis.#live=w;\nthis.#dead=0;\nthis.#tombs=new Bitset(Math.max(this.#capacity,w));\nreturn remap;\n}\ncolumn(colId){return this.#handles.get(colId);}\ncolumns(){return this.#list.slice();}\nliveIndices(){\nconst out=new Uint32Array(this.#live);\nif(this.#dead===0){\nfor(let p=0;p<this.#fill;p++)out[p]=p;\nreturn out;\n}\nlet k=0;\nfor(let p=0;p<this.#fill;p++)if(this.#tombs.get(p)===0)out[k++]=p;\nreturn out;\n}\nconvert(colId,kind){\nconst h=this.#handles.get(colId);\nreturn h?h.convert(kind):false;\n}\ndestroy(){\nif(this.#destroyed)return;\nthis.#destroyed=true;\nfor(const h of this.#list)h.release();\nthis.#handles.clear();\nthis.#list.length=0;\nthis.#rows.length=0;\nthis.#tombs.release();\nthis.#fill=0;\nthis.#live=0;\nthis.#dead=0;\nthis.#capacity=0;\n}\n#ensure(n){\nif(n<=this.#capacity)return;\nlet cap=this.#capacity||this.#initial;\nwhile(cap<n)cap*=2;\nfor(const h of this.#list)h.grow(cap);\nthis.#tombs.grow(cap);\nthis.#capacity=cap;\n}\n#reconstruct(physical){\nconst out={};\nfor(const h of this.#list)out[h.id]=h.get(physical);\nreturn out;\n}\n#columnarise(){\nif(this.#columnar)return;\nlet cap=this.#initial;\nwhile(cap<this.#fill)cap*=2;\nthis.#columnar=true;\nthis.#capacity=cap;\nthis.#tombs.grow(cap);\nfor(const h of this.#list)h.columnarise(cap,this.#fill);\n}\n}\n});\n__def(\"packages/core/src/store/ingest.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"INGEST_DEFAULTS\",{enumerable:true,get:function(){return INGEST_DEFAULTS;}});\nObject.defineProperty(__exports,\"inferKind\",{enumerable:true,get:function(){return inferKind;}});\nObject.defineProperty(__exports,\"decideText\",{enumerable:true,get:function(){return decideText;}});\nObject.defineProperty(__exports,\"createReaders\",{enumerable:true,get:function(){return createReaders;}});\nObject.defineProperty(__exports,\"Ingest\",{enumerable:true,get:function(){return Ingest;}});\nObject.defineProperty(__exports,\"ingest\",{enumerable:true,get:function(){return ingest;}});\nObject.defineProperty(__exports,\"ingestSync\",{enumerable:true,get:function(){return ingestSync;}});\nconst __m0=__req(\"packages/core/src/internal/util.js\");\nconst now=__m0[\"now\"];\nconst nextFrame=__m0[\"nextFrame\"];\nconst infoOnce=__m0[\"infoOnce\"];\nconst warnOnce=__m0[\"warnOnce\"];\nconst isFunction=__m0[\"isFunction\"];\nconst pathGetter=__m0[\"pathGetter\"];\nconst __m1=__req(\"packages/core/src/store/columnstore.js\");\nconst ColumnStore=__m1[\"ColumnStore\"];\nconst INGEST_DEFAULTS=Object.freeze({\nchunkMs:8,\nchunkRows:512,\nsampleSize:100,\ndictionaryRatio:0.1,\ncolumnarBelow:5000,\ninitialCapacity:1024,\n});\nfunction inferKind(samples,hints={}){\nif(hints.multi)return'multi';\nif(samples.length===0)return'object';\nlet numbers=0;let booleans=0;let strings=0;let dates=0;let arrays=0;\nfor(let i=0;i<samples.length;i++){\nconst v=samples[i];\nif(typeof v==='number')numbers++;\nelse if(typeof v==='boolean')booleans++;\nelse if(typeof v==='string')strings++;\nelse if(v instanceof Date)dates++;\nelse if(Array.isArray(v))arrays++;\n}\nconst n=samples.length;\nif(numbers===n)return'float64';\nif(booleans===n)return'bitset';\nif(dates===n)return'float64';\nif(strings===n)return'text';\nif(arrays===n)return'multi';\nreturn'object';\n}\nfunction decideText(distinct,rows,ratio){\nif(rows<=0)return'dictionary';\nreturn distinct<ratio*rows?'dictionary':'object';\n}\nfunction createReaders(columns,computed,context){\nconst readers=new Map();\nconst base=new Map();\nfor(const col of columns){\nif(col.computed)continue;\nconst read=isFunction(col.read)?col.read:pathGetter(col.field||col.id);\nbase.set(col.id,read);\nreaders.set(col.id,read);\n}\nconst order=computed?.order??[];\nconst fns=computed?.fns??{};\nconst deps=computed?.deps??{};\nconst wrapDeps=computed?.wrapDeps??null;\nconst active=order.filter((id)=>isFunction(fns[id]));\nconst wildcard=active.some((id)=>deps[id]==='*');\nlet memo=new WeakMap();\nconst resolve=(data)=>{\nconst values={};\nif(wildcard)for(const[id,read]of base)values[id]=read(data);\nfor(const id of active){\nconst declared=deps[id];\nlet bag;\nif(declared==='*'){\nbag=values;\n}else{\nbag={};\nconst list=declared||[];\nfor(let i=0;i<list.length;i++){\nconst d=list[i];\nbag[d]=d in values?values[d]:base.get(d)?.(data);\n}\n}\nvalues[id]=fns[id](wrapDeps?wrapDeps(bag,id):bag,{\ndata,row:null,column:null,grid:null,context,\n});\n}\nreturn values;\n};\nconst valuesFor=(data)=>{\nif(data===null||(typeof data!=='object'&&typeof data!=='function'))return resolve(data);\nlet v=memo.get(data);\nif(v===undefined){v=resolve(data);memo.set(data,v);}\nreturn v;\n};\nfor(const id of active){\nreaders.set(id,\n(data)=>valuesFor(data)[id]);\n}\nreturn{\nreaders,\nreset(){memo=new WeakMap();},\n};\n}\nclass ColumnPlan{\nspec;\nread;\nkind;\ninferred;\nnullable;\ncandidate=false;\ndistinct=null;\nchange=null;\nreason='';\nconstructor(spec,read){\nthis.spec=spec;\nthis.read=read;\nthis.kind='object';\nthis.inferred=false;\nthis.nullable=spec.nullable!==false;\n}\n}\nclass Ingest{\n#rows;\n#plans=[];\n#store=null;\n#readers;\n#cursor=0;\n#opts;\n#done=false;\n#cancelled=false;\n#elapsed=0;\n#columnar;\nconstructor(rows,plan={},opts={}){\nthis.#rows=Array.isArray(rows)?rows:Array.from(rows||[]);\nthis.#opts={...INGEST_DEFAULTS,...opts};\nconst columns=plan.columns??[];\nthis.#readers=createReaders(columns,plan.computed??null,plan.context);\nthis.#columnar=this.#rows.length>=this.#opts.columnarBelow;\nthis.#planColumns(columns,plan.computed??null);\nthis.#store=new ColumnStore(this.#plans.map((p)=>({\nid:p.spec.id,\nkind:p.kind,\nnullable:p.nullable,\nread:p.read,\ndictionary:p.spec.dictionary,\n})),{\ninitialCapacity:this.#opts.initialCapacity,\ncolumnarBelow:this.#opts.columnarBelow,\n});\n}\nget store(){return this.#store;}\nget done(){return this.#done||this.#cancelled;}\nget progress(){return this.#cursor;}\nslice(){\nif(this.done)return false;\nif(this.#opts.signal?.aborted){this.#cancelled=true;return false;}\nconst started=now();\nconst{chunkMs,chunkRows}=this.#opts;\nconst total=this.#rows.length;\ndo{\nconst end=Math.min(this.#cursor+chunkRows,total);\nthis.#store.append(this.#rows.slice(this.#cursor,end));\nthis.#measure(this.#cursor,end);\nthis.#cursor=end;\nthis.#readers.reset();\nthis.#reviewCardinality(false);\n}while(this.#cursor<total&&now()-started<chunkMs);\nthis.#elapsed+=now()-started;\nthis.#opts.onProgress?.({loaded:this.#cursor,total});\nif(this.#cursor>=total){\nthis.#reviewCardinality(true);\nthis.#done=true;\nreturn false;\n}\nreturn true;\n}\ncancel(){this.#cancelled=true;}\nresult(){\nreturn{\nstore:this.#store,\nschema:this.#plans.map((p)=>({\nid:p.spec.id,kind:p.kind,nullable:p.nullable,read:p.read,\ndictionary:p.spec.dictionary,\n})),\ndecisions:this.#plans.map((p)=>({\nid:p.spec.id,\nkind:p.kind,\nnullable:p.nullable,\ninferred:p.inferred,\ndistinct:p.candidate||p.change?this.#distinctOf(p):null,\nchange:p.change,\nreason:p.reason,\n})),\ncount:this.#store.count,\nelapsed:this.#elapsed,\ncancelled:this.#cancelled,\n};\n}\n#planColumns(columns,computed){\nconst rows=this.#rows;\nconst sampleN=Math.min(this.#opts.sampleSize,rows.length);\nconst ratio=this.#opts.dictionaryRatio;\nconst pure=computed?.pure instanceof Set\n?computed.pure\n:new Set(computed?.pure??computed?.order??[]);\nfor(const spec of columns){\nif(!spec||!spec.id)continue;\nif(spec.computed&&(spec.pure===false||(computed&&!pure.has(spec.id)))){\nwarnOnce(`ingest.impure.${spec.id}`,\n`column \"${spec.id}\" is an impure computed column and is not materialised into the store`);\ncontinue;\n}\nconst read=this.#readers.readers.get(spec.id)\n??(isFunction(spec.read)?spec.read:pathGetter(spec.field||spec.id));\nconst plan=new ColumnPlan(spec,read);\nif(spec.kind){\nplan.kind=spec.kind;\nplan.reason='declared by the caller';\n}else if(spec.dictionary){\nplan.kind=spec.multi?'multi':'dictionary';\nplan.reason='value table supplied (lookup column)';\n}else{\nconst samples=[];\nfor(let i=0;i<sampleN&&samples.length<this.#opts.sampleSize;i++){\nconst v=read(rows[i]);\nif(v!==null&&v!==undefined)samples.push(v);\n}\nplan.inferred=true;\nconst kind=inferKind(samples,{multi:spec.multi});\nif(kind==='text'){\nconst distinct=new Set(samples).size;\nplan.kind=decideText(distinct,samples.length,ratio);\nplan.candidate=this.#columnar;\nplan.reason=`sampled ${distinct} distinct in ${samples.length}`;\n}else{\nplan.kind=kind;\nplan.reason=`inferred from ${samples.length} sampled values`;\nif(kind==='object'&&samples.length){\ninfoOnce(`ingest.mixed.${spec.id}`,\n`column \"${spec.id}\" holds mixed or unrecognised value types; storing as an object array. Declare a type to avoid this.`);\n}\n}\nif(plan.kind==='object'&&plan.candidate)plan.distinct=new Set(samples);\n}\nthis.#plans.push(plan);\n}\n}\n#measure(from,to){\nconst rows=this.#rows;\nfor(const plan of this.#plans){\nif(!plan.candidate||!plan.distinct)continue;\nconst set=plan.distinct;\nfor(let i=from;i<to;i++){\nconst v=plan.read(rows[i]);\nif(v!==null&&v!==undefined)set.add(v);\n}\n}\n}\n#distinctOf(plan){\nif(plan.distinct)return plan.distinct.size;\nconst handle=this.#store.column(plan.spec.id);\nreturn handle?.dict?handle.dict.size:0;\n}\n#reviewCardinality(final){\nconst ratio=this.#opts.dictionaryRatio;\nconst total=this.#rows.length;\nfor(const plan of this.#plans){\nif(!plan.candidate)continue;\nconst distinct=this.#distinctOf(plan);\nif(plan.kind==='dictionary'&&distinct>=ratio*total){\nconst handle=this.#store.column(plan.spec.id);\nplan.distinct=new Set(handle?.dict?handle.dict.values():[]);\nthis.#store.convert(plan.spec.id,'object');\nplan.kind='object';\nplan.change='demoted';\nplan.reason=`${distinct} distinct values is at or above ${ratio*100}% of ${total} rows`;\ncontinue;\n}\nif(plan.kind==='object'&&distinct>=ratio*total){\nplan.candidate=false;\nplan.distinct=null;\nplan.reason=`${distinct} distinct values is at or above ${ratio*100}% of ${total} rows`;\ncontinue;\n}\nif(final&&plan.kind==='object'&&distinct<ratio*total){\nthis.#store.convert(plan.spec.id,'dictionary');\nplan.kind='dictionary';\nplan.change=plan.change==='demoted'?null:'promoted';\nplan.reason=`${distinct} distinct values is below ${ratio*100}% of ${total} rows`;\nplan.distinct=null;\n}\nif(final)plan.candidate=false;\n}\n}\n}\nasync function ingest(rows,plan={},opts={}){\nconst run=new Ingest(rows,plan,opts);\nconst frame=opts.scheduler?.frame??nextFrame;\nwhile(run.slice()){\nawait new Promise((resolve)=>{frame(resolve);});\n}\nreturn run.result();\n}\nfunction ingestSync(rows,plan={},opts={}){\nconst run=new Ingest(rows,plan,{...opts,chunkMs:Infinity});\nwhile(run.slice());\nreturn run.result();\n}\n});\n__def(\"packages/core/src/store/columnpack.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"isPortableSchema\",{enumerable:true,get:function(){return isPortableSchema;}});\nObject.defineProperty(__exports,\"packChunk\",{enumerable:true,get:function(){return packChunk;}});\nObject.defineProperty(__exports,\"packedTransfers\",{enumerable:true,get:function(){return packedTransfers;}});\nconst __m0=__req(\"packages/core/src/internal/util.js\");\nconst pathGetter=__m0[\"pathGetter\"];\nconst __m1=__req(\"packages/core/src/store/ingest.js\");\nconst inferKind=__m1[\"inferKind\"];\nconst decideText=__m1[\"decideText\"];\nconst INGEST_DEFAULTS=__m1[\"INGEST_DEFAULTS\"];\nconst __m2=__req(\"packages/core/src/store/columnstore.js\");\nconst toFloat=__m2[\"toFloat\"];\nconst PORTABLE_KINDS=new Set(['float64','int32','bitset','dictionary','object','multi']);\nfunction isPortableSchema(schema){\nif(!Array.isArray(schema)||schema.length===0)return false;\nfor(const col of schema){\nif(!col||typeof col.id!=='string')return false;\nif(typeof col.field!=='string'||col.field==='')return false;\nif(col.kind&&!PORTABLE_KINDS.has(col.kind))return false;\n}\nreturn true;\n}\nfunction toInt(v){\nconst n=toFloat(v);\nreturn Number.isFinite(n)?n|0:0;\n}\nfunction toMembers(v){\nif(v===null||v===undefined)return[];\nreturn Array.isArray(v)?v:[v];\n}\nfunction resolveKind(col,values,rows,ratio){\nif(col.kind)return col.kind;\nconst samples=[];\nfor(let i=0;i<values.length&&samples.length<INGEST_DEFAULTS.sampleSize;i++){\nconst v=values[i];\nif(v!==null&&v!==undefined)samples.push(v);\n}\nconst kind=inferKind(samples,{multi:col.multi});\nif(kind!=='text')return kind;\nconst distinct=new Set(samples).size;\nreturn decideText(distinct,samples.length,ratio);\n}\nfunction packChunk(schema,rows,opts={}){\nconst n=rows.length|0;\nconst ratio=opts.dictionaryRatio??INGEST_DEFAULTS.dictionaryRatio;\nconst columns=[];\nfor(const col of schema){\nconst read=pathGetter(col.field||col.id);\nconst nullable=col.nullable!==false;\nconst raw=new Array(n);\nfor(let i=0;i<n;i++){\nconst v=read(rows[i]);\nraw[i]=v===undefined?null:v;\n}\nconst kind=resolveKind(col,raw,n,ratio);\nconst presence=nullable?new Uint8Array((n+7)>>3):null;\nconst present=(i)=>{if(presence)presence[i>>3]|=1<<(i&7);};\nlet packed;\nswitch(kind){\ncase'float64':{\nconst values=new Float64Array(n);\nfor(let i=0;i<n;i++){\nconst v=raw[i];\nconst gone=v===null;\nif(!gone)present(i);\nvalues[i]=gone?NaN:toFloat(v);\n}\npacked={id:col.id,kind,nullable,values,presence,offsets:null,table:null};\nbreak;\n}\ncase'int32':{\nconst values=new Int32Array(n);\nfor(let i=0;i<n;i++){\nconst v=raw[i];\nconst gone=v===null;\nif(!gone)present(i);\nvalues[i]=gone?0:toInt(v);\n}\npacked={id:col.id,kind,nullable,values,presence,offsets:null,table:null};\nbreak;\n}\ncase'bitset':{\nconst words=new Uint8Array((n+7)>>3);\nfor(let i=0;i<n;i++){\nconst v=raw[i];\nconst gone=v===null;\nif(!gone)present(i);\nif(!gone&&!!v)words[i>>3]|=1<<(i&7);\n}\npacked={id:col.id,kind,nullable,values:words,presence,offsets:null,table:null};\nbreak;\n}\ncase'dictionary':{\nconst codes=new Uint32Array(n);\nconst table=[];\nconst index=new Map();\nfor(let i=0;i<n;i++){\nconst v=raw[i];\nif(v===null){codes[i]=0;continue;}\npresent(i);\nlet code=index.get(v);\nif(code===undefined){code=table.length;table.push(v);index.set(v,code);}\ncodes[i]=code;\n}\npacked={id:col.id,kind,nullable,values:codes,presence,offsets:null,table};\nbreak;\n}\ncase'multi':{\nconst table=[];\nconst index=new Map();\nconst offsets=new Uint32Array(n+1);\nconst flat=[];\nfor(let i=0;i<n;i++){\nconst v=raw[i];\noffsets[i]=flat.length;\nconst gone=v===null;\nif(!gone)present(i);\nconst members=toMembers(v);\nfor(let k=0;k<members.length;k++){\nconst m=members[k];\nlet code=index.get(m);\nif(code===undefined){code=table.length;table.push(m);index.set(m,code);}\nflat.push(code);\n}\n}\noffsets[n]=flat.length;\npacked={id:col.id,kind,nullable,values:Int32Array.from(flat),presence,offsets,table};\nbreak;\n}\ndefault:{\nconst values=new Array(n);\nfor(let i=0;i<n;i++){\nconst v=raw[i];\nif(v!==null)present(i);\nvalues[i]=v;\n}\npacked={id:col.id,kind:'object',nullable,values,presence,offsets:null,table:null};\nbreak;\n}\n}\ncolumns.push(packed);\n}\nreturn{count:n,columns};\n}\nfunction packedTransfers(chunk){\nconst out=[];\nif(!chunk||!Array.isArray(chunk.columns))return out;\nconst add=(v)=>{\nif(ArrayBuffer.isView(v)&&v.buffer&&!out.includes(v.buffer))out.push(v.buffer);\n};\nfor(const col of chunk.columns){\nadd(col.values);\nadd(col.presence);\nadd(col.offsets);\n}\nreturn out;\n}\n});\n__def(\"packages/core/src/compute/sortspec.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"collationDescriptor\",{enumerable:true,get:function(){return collationDescriptor;}});\nObject.defineProperty(__exports,\"isPortableSort\",{enumerable:true,get:function(){return isPortableSort;}});\nObject.defineProperty(__exports,\"isPortableSortSet\",{enumerable:true,get:function(){return isPortableSortSet;}});\nObject.defineProperty(__exports,\"describeSortEntry\",{enumerable:true,get:function(){return describeSortEntry;}});\nObject.defineProperty(__exports,\"describeSort\",{enumerable:true,get:function(){return describeSort;}});\nfunction collationDescriptor(locale){\nreturn{locale:locale===undefined?undefined:String(locale),numeric:true,sensitivity:'variant'};\n}\nfunction isPortableSort(entry){\nreturn!!entry&&typeof entry.compare!=='function';\n}\nfunction isPortableSortSet(entries){\nif(!entries)return true;\nfor(let i=0;i<entries.length;i++)if(!isPortableSort(entries[i]))return false;\nreturn true;\n}\nfunction describeSortEntry(entry,locale){\nconst col=entry.col!==undefined?entry.col:(entry.handle&&entry.handle.id);\nconst chosen=entry.locale!==undefined?entry.locale:locale;\nreturn{\ncol,\ndescending:entry.descending!==undefined?!!entry.descending:entry.dir==='desc',\nnullsFirst:!!entry.nullsFirst,\ncollation:collationDescriptor(chosen),\n};\n}\nfunction describeSort(entries,locale){\nconst list=entries||[];\nconst out=new Array(list.length);\nfor(let i=0;i<list.length;i++)out[i]=describeSortEntry(list[i],locale);\nreturn out;\n}\n});\n__def(\"packages/core/src/format/date.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"scanPattern\",{enumerable:true,get:function(){return scanPattern;}});\nObject.defineProperty(__exports,\"toDate\",{enumerable:true,get:function(){return toDate;}});\nObject.defineProperty(__exports,\"compilePattern\",{enumerable:true,get:function(){return compilePattern;}});\nObject.defineProperty(__exports,\"compileDate\",{enumerable:true,get:function(){return compileDate;}});\nObject.defineProperty(__exports,\"toIsoDate\",{enumerable:true,get:function(){return toIsoDate;}});\nObject.defineProperty(__exports,\"toIsoDateTime\",{enumerable:true,get:function(){return toIsoDateTime;}});\nObject.defineProperty(__exports,\"compareIso\",{enumerable:true,get:function(){return compareIso;}});\nconst __m0=__req(\"packages/core/src/internal/util.js\");\nconst isNil=__m0[\"isNil\"];\nconst warnOnce=__m0[\"warnOnce\"];\nconst TOKENS=[\n'yyyy','yy','MMMM','MMM','MM','M','dd','d',\n'EEEE','EEE','HH','H','hh','h','mm','m','ss','s','SSS','a',\n];\nfunction scanPattern(pattern){\nconst out=[];\nlet i=0;\nlet literal='';\nconst flush=()=>{if(literal){out.push({token:null,text:literal});literal='';}};\nwhile(i<pattern.length){\nconst ch=pattern[i];\nif(ch===\"'\"){\nif(pattern[i+1]===\"'\"){literal+=\"'\";i+=2;continue;}\nconst end=pattern.indexOf(\"'\",i+1);\nif(end===-1){literal+=pattern.slice(i+1);i=pattern.length;continue;}\nliteral+=pattern.slice(i+1,end);\ni=end+1;\ncontinue;\n}\nconst token=TOKENS.find((t)=>pattern.startsWith(t,i));\nif(token){flush();out.push({token,text:token});i+=token.length;continue;}\nif(/[A-Za-z]/.test(ch)){\nwarnOnce(\n`date.pattern.token:${ch}`,\n`the date pattern \"${pattern}\" contains '${ch}', which is not a supported token, `\n+'so it is rendered as text. Quote it as a literal to silence this. '\n+`Supported: ${TOKENS.join(' ')}.`,\n);\n}\nliteral+=ch;\ni+=1;\n}\nflush();\nreturn out;\n}\nconst WALL_CLOCK=/^(\\d{4})-(\\d{2})-(\\d{2})(?:[T ](\\d{2}):(\\d{2})(?::(\\d{2}))?(?:\\.\\d+)?)?$/;\nfunction toDate(value){\nif(isNil(value)||value==='')return null;\nif(value instanceof Date)return Number.isNaN(value.getTime())?null:value;\nif(typeof value==='number')return Number.isNaN(value)?null:new Date(value);\nif(typeof value==='string'){\nconst wall=WALL_CLOCK.exec(value.trim());\nif(wall){\nconst[,y,mo,d,h='0',mi='0',sec='0']=wall;\nreturn new Date(+y,+mo-1,+d,+h,+mi,+sec);\n}\nconst d=new Date(value);\nreturn Number.isNaN(d.getTime())?null:d;\n}\nreturn null;\n}\nfunction pad(n,w){return String(n).padStart(w,'0');}\nfunction fieldReader(timeZone){\nif(!timeZone){\nreturn(d)=>({\nyear:d.getFullYear(),month:d.getMonth()+1,day:d.getDate(),\nhour:d.getHours(),minute:d.getMinutes(),second:d.getSeconds(),\nms:d.getMilliseconds(),weekday:d.getDay(),\n});\n}\nconst zoned=new Intl.DateTimeFormat('en-US',{\ntimeZone,year:'numeric',month:'2-digit',day:'2-digit',\nhour:'2-digit',minute:'2-digit',second:'2-digit',hour12:false,weekday:'short',\n});\nconst days={Sun:0,Mon:1,Tue:2,Wed:3,Thu:4,Fri:5,Sat:6};\nreturn(d)=>{\nconst f={year:0,month:1,day:1,hour:0,minute:0,second:0,ms:d.getMilliseconds(),weekday:0};\nfor(const part of zoned.formatToParts(d)){\nswitch(part.type){\ncase'year':f.year=Number(part.value);break;\ncase'month':f.month=Number(part.value);break;\ncase'day':f.day=Number(part.value);break;\ncase'hour':f.hour=Number(part.value)%24;break;\ncase'minute':f.minute=Number(part.value);break;\ncase'second':f.second=Number(part.value);break;\ncase'weekday':f.weekday=days[part.value]??0;break;\ndefault:break;\n}\n}\nreturn f;\n};\n}\nfunction compilePattern(pattern,locale,timeZone){\nconst segments=scanPattern(pattern);\nconst read=fieldReader(timeZone);\nconst used=new Set(segments.filter((s)=>s.token).map((s)=>s.token));\nconst monthShort=used.has('MMM')?new Intl.DateTimeFormat(locale,{month:'short',timeZone}):null;\nconst monthLong=used.has('MMMM')?new Intl.DateTimeFormat(locale,{month:'long',timeZone}):null;\nconst dayShort=used.has('EEE')?new Intl.DateTimeFormat(locale,{weekday:'short',timeZone}):null;\nconst dayLong=used.has('EEEE')?new Intl.DateTimeFormat(locale,{weekday:'long',timeZone}):null;\nreturn(d)=>{\nconst f=read(d);\nlet out='';\nfor(const seg of segments){\nif(!seg.token){out+=seg.text;continue;}\nswitch(seg.token){\ncase'yyyy':out+=pad(f.year,4);break;\ncase'yy':out+=pad(f.year%100,2);break;\ncase'MMMM':out+=monthLong.format(d);break;\ncase'MMM':out+=monthShort.format(d);break;\ncase'MM':out+=pad(f.month,2);break;\ncase'M':out+=String(f.month);break;\ncase'dd':out+=pad(f.day,2);break;\ncase'd':out+=String(f.day);break;\ncase'EEEE':out+=dayLong.format(d);break;\ncase'EEE':out+=dayShort.format(d);break;\ncase'HH':out+=pad(f.hour,2);break;\ncase'H':out+=String(f.hour);break;\ncase'hh':out+=pad(f.hour%12===0?12:f.hour%12,2);break;\ncase'h':out+=String(f.hour%12===0?12:f.hour%12);break;\ncase'mm':out+=pad(f.minute,2);break;\ncase'm':out+=String(f.minute);break;\ncase'ss':out+=pad(f.second,2);break;\ncase's':out+=String(f.second);break;\ncase'SSS':out+=pad(f.ms,3);break;\ncase'a':out+=f.hour<12?'AM':'PM';break;\ndefault:out+=seg.text;break;\n}\n}\nreturn out;\n};\n}\nconst UNITS=[\n['year',365*24*3600e3],\n['month',30*24*3600e3],\n['week',7*24*3600e3],\n['day',24*3600e3],\n['hour',3600e3],\n['minute',60e3],\n['second',1e3],\n];\nfunction compileDate(spec,locale){\nconst s=spec||{};\nconst loc=s.locale||locale||undefined;\nconst nullDisplay=s.nullDisplay??'';\nconst timeZone=s.timeZone;\nlet absolute;\nif(s.pattern){\nabsolute=compilePattern(s.pattern,loc,timeZone);\n}else if(s.dateStyle||s.timeStyle){\nconst opts={timeZone};\nif(s.dateStyle)opts.dateStyle=s.dateStyle;\nif(s.timeStyle)opts.timeStyle=s.timeStyle;\nconst dtf=new Intl.DateTimeFormat(loc,opts);\nabsolute=(d)=>dtf.format(d);\n}else{\nconst dtf=new Intl.DateTimeFormat(loc,{dateStyle:'medium',timeZone});\nabsolute=(d)=>dtf.format(d);\n}\nconst relative=s.relative?new Intl.RelativeTimeFormat(loc,{numeric:'auto'}):null;\nconst thresholdDays=typeof s.relative==='object'&&s.relative\n?(s.relative.threshold??7)\n:7;\nconst thresholdMs=thresholdDays*24*3600e3;\nconst format=(value,params)=>{\nconst d=toDate(value);\nif(!d)return nullDisplay;\nif(relative){\nconst now=params&&typeof params.now==='number'?params.now:Date.now();\nconst delta=d.getTime()-now;\nif(Math.abs(delta)<thresholdMs){\nfor(const[unit,ms]of UNITS){\nif(Math.abs(delta)>=ms||unit==='second'){\nreturn relative.format(Math.round(delta/ms),unit);\n}\n}\n}\n}\nreturn absolute(d);\n};\nformat.spec=s;\nreturn format;\n}\nfunction toIsoDate(value){\nif(isNil(value)||value==='')return null;\nif(typeof value==='string'){\nconst match=/^(\\d{4}-\\d{2}-\\d{2})/.exec(value.trim());\nif(match)return match[1];\nconst parsed=toDate(value);\nreturn parsed?toIsoDate(parsed):null;\n}\nconst date=toDate(value);\nif(!date)return null;\nconst pad=(n)=>String(n).padStart(2,'0');\nreturn`${date.getFullYear()}-${pad(date.getMonth()+1)}-${pad(date.getDate())}`;\n}\nfunction toIsoDateTime(value,timeZone){\nif(isNil(value)||value==='')return null;\nif(typeof value==='string'){\nconst text=value.trim();\nif(ZONE_SUFFIX.test(text)){\nconst instant=toDate(text);\nreturn instant?wallClockIn(instant,timeZone):null;\n}\nconst match=/^(\\d{4}-\\d{2}-\\d{2})[T ](\\d{2}):(\\d{2})(?::(\\d{2}))?/.exec(text);\nif(match){\nconst[,day,hour,minute,second]=match;\nreturn`${day}T${hour}:${minute}${second&&second!=='00'?`:${second}`:''}`;\n}\nif(/^\\d{4}-\\d{2}-\\d{2}$/.test(text))return`${text}T00:00`;\nconst parsed=toDate(text);\nreturn parsed?toIsoDateTime(parsed):null;\n}\nconst date=toDate(value);\nif(!date)return null;\nreturn wallClockIn(date,timeZone);\n}\nconst ZONE_SUFFIX=/(?:Z|[+-]\\d{2}:?\\d{2})$/i;\nfunction wallClockIn(date,timeZone){\nconst pad=(n)=>String(n).padStart(2,'0');\nif(timeZone){\ntry{\nconst parts=new Intl.DateTimeFormat('en-CA',{\ntimeZone,\nyear:'numeric',month:'2-digit',day:'2-digit',\nhour:'2-digit',minute:'2-digit',second:'2-digit',\nhour12:false,\n}).formatToParts(date).reduce((out,part)=>{\nif(part.type!=='literal')out[part.type]=part.value;\nreturn out;\n},{});\nconst hour=parts.hour==='24'?'00':parts.hour;\nconst seconds=Number(parts.second);\nreturn`${parts.year}-${parts.month}-${parts.day}T${hour}:${parts.minute}`\n+(seconds?`:${parts.second}`:'');\n}catch{\n}\n}\nconst day=`${date.getFullYear()}-${pad(date.getMonth()+1)}-${pad(date.getDate())}`;\nconst seconds=date.getSeconds();\nconst clock=`${pad(date.getHours())}:${pad(date.getMinutes())}${seconds?`:${pad(seconds)}`:''}`;\nreturn`${day}T${clock}`;\n}\nfunction compareIso(a,b){\nconst left=isNil(a)||a===''?null:String(a);\nconst right=isNil(b)||b===''?null:String(b);\nif(left===null)return right===null?0:1;\nif(right===null)return-1;\nreturn left<right?-1:left>right?1:0;\n}\n});\n__def(\"packages/core/src/compute/filter.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"releaseMask\",{enumerable:true,get:function(){return releaseMask;}});\nObject.defineProperty(__exports,\"compilePredicate\",{enumerable:true,get:function(){return compilePredicate;}});\nObject.defineProperty(__exports,\"testValue\",{enumerable:true,get:function(){return testValue;}});\nObject.defineProperty(__exports,\"evaluateCondition\",{enumerable:true,get:function(){return evaluateCondition;}});\nObject.defineProperty(__exports,\"evaluateFilters\",{enumerable:true,get:function(){return evaluateFilters;}});\nObject.defineProperty(__exports,\"pruneColumn\",{enumerable:true,get:function(){return pruneColumn;}});\nObject.defineProperty(__exports,\"mentionsColumn\",{enumerable:true,get:function(){return mentionsColumn;}});\nObject.defineProperty(__exports,\"compact\",{enumerable:true,get:function(){return compact;}});\nconst __m0=__req(\"packages/core/src/internal/util.js\");\nconst isBlank=__m0[\"isBlank\"];\nconst toArray=__m0[\"toArray\"];\nconst warnOnce=__m0[\"warnOnce\"];\nconst __m1=__req(\"packages/core/src/format/date.js\");\nconst toIsoDate=__m1[\"toIsoDate\"];\nconst __m2=__req(\"packages/core/src/compute/handle.js\");\nconst bitReader=__m2[\"bitReader\"];\nconst dictSize=__m2[\"dictSize\"];\nconst dictValue=__m2[\"dictValue\"];\nconst presenceReader=__m2[\"presenceReader\"];\nconst valueComparator=__m2[\"valueComparator\"];\nconst valueReader=__m2[\"valueReader\"];\nconst ISO_DAY=/^\\d{4}-\\d{2}-\\d{2}$/;\nconst NULL_KEY='\\u0000null\\u0000';\nfunction acquireMask(ctx,n){\nconst pool=ctx&&ctx.pool;\nif(pool){\nconst take=pool.mask||pool.acquireMask||pool.acquire||pool.take;\nif(typeof take==='function'){\nconst mask=take.call(pool,n);\nif(mask&&mask.length>=n)return mask;\n}\n}\nreturn new Uint8Array(n);\n}\nfunction releaseMask(ctx,mask){\nconst pool=ctx&&ctx.pool;\nif(!pool||!mask)return;\nconst give=pool.release||pool.releaseMask||pool.free||pool.recycle;\nif(typeof give==='function')give.call(pool,mask);\n}\nfunction fillMask(mask,n,value){\nmask.fill(value,0,n);\nreturn mask;\n}\nfunction unorderable(v){\nreturn v===null||v===undefined||(typeof v==='number'&&Number.isNaN(v));\n}\nfunction coerceTarget(value,type){\nif(value===null||value===undefined)return value;\nif(type==='number')return typeof value==='number'?value:Number(value);\nif(type==='date'||type==='dateString'){\nconst iso=toIsoDate(value);\nreturn iso===null?toMillis(value):iso;\n}\nif(type==='boolean'){\nif(typeof value==='boolean')return value;\nif(value==='true'||value===1)return true;\nif(value==='false'||value===0)return false;\nreturn!!value;\n}\nreturn value;\n}\nfunction toMillis(value){\nif(value instanceof Date)return value.getTime();\nif(typeof value==='number')return value;\nreturn Date.parse(String(value));\n}\nfunction toNumber(value){\nif(typeof value==='number')return value;\nif(value instanceof Date)return value.getTime();\nif(value===null||value===undefined||value==='')return NaN;\nreturn Number(value);\n}\nfunction textOf(v,caseSensitive){\nconst s=typeof v==='string'?v:String(v);\nreturn caseSensitive?s:s.toLowerCase();\n}\nfunction setKey(v,caseSensitive){\nif(v===null||v===undefined)return NULL_KEY;\nif(typeof v==='string')return caseSensitive?v:v.toLowerCase();\nif(v instanceof Date)return v.getTime();\nreturn v;\n}\nfunction buildSet(value,caseSensitive,type){\nconst set=new Set();\nfor(const raw of toArray(value)){\nconst entry=coerceTarget(raw,type);\nset.add(setKey(entry,caseSensitive));\nif(typeof entry==='string'&&entry!==''&&Number.isFinite(Number(entry)))set.add(Number(entry));\nelse if(typeof entry==='number'&&Number.isFinite(entry))set.add(setKey(String(entry),caseSensitive));\n}\nreturn set;\n}\nfunction valueEquals(a,b,caseSensitive){\nif(a===null||a===undefined||b===null||b===undefined){\nreturn(a===null||a===undefined)&&(b===null||b===undefined);\n}\nconst ta=typeof a;\nconst tb=typeof b;\nif(ta==='string'&&tb==='string')return caseSensitive?a===b:a.toLowerCase()===b.toLowerCase();\nif(a instanceof Date||b instanceof Date)return toMillis(a)===toMillis(b);\nif(ta==='number'&&tb==='number')return a===b||(Number.isNaN(a)&&Number.isNaN(b));\nif(ta==='number'&&tb==='string')return a===Number(b);\nif(ta==='string'&&tb==='number')return Number(a)===b;\nif(ta==='boolean'||tb==='boolean')return a===b;\nif(Array.isArray(a)&&Array.isArray(b)){\nreturn a.length===b.length&&a.every((x,i)=>valueEquals(x,b[i],caseSensitive));\n}\nreturn a===b;\n}\nfunction compileRegExp(value,caseSensitive){\ntry{\nif(value instanceof RegExp){\nconst flags=value.flags.replace(/[gy]/g,'');\nreturn new RegExp(value.source,caseSensitive?flags:flags.includes('i')?flags:`${flags}i`);\n}\nreturn new RegExp(String(value),caseSensitive?'':'i');\n}catch(err){\nwarnOnce(`regex:${String(value)}`,`filter operator \"matches\" received an invalid pattern: ${String(value)}`,err);\nreturn null;\n}\n}\nfunction compilePredicate(condition,locale){\nconst predicate=compileValuePredicate(condition,locale);\nconst type=condition&&condition.type;\nif(type!=='date'&&type!=='dateString')return predicate;\nreturn(v)=>predicate(typeof v==='string'&&ISO_DAY.test(v)?v:(toIsoDate(v)??v));\n}\nfunction compileValuePredicate(condition,locale){\nconst op=condition&&condition.op;\nconst caseSensitive=!!(condition&&condition.caseSensitive);\nconst type=condition&&condition.type;\nconst cmp=valueComparator(locale);\nconst not=(p)=>(v)=>!p(v);\nswitch(op){\ncase'eq':{\nconst target=coerceTarget(condition.value,type);\nreturn(v)=>valueEquals(v,target,caseSensitive);\n}\ncase'ne':{\nconst target=coerceTarget(condition.value,type);\nreturn(v)=>!valueEquals(v,target,caseSensitive);\n}\ncase'lt':case'lte':case'gt':case'gte':{\nconst target=coerceTarget(condition.value,type);\nif(unorderable(target))return()=>false;\nconst want=op==='lt'?-1:op==='lte'?0:op==='gt'?1:2;\nreturn(v)=>{\nif(unorderable(v))return false;\nconst c=cmp(v,target);\nreturn want===-1?c<0:want===0?c<=0:want===1?c>0:c>=0;\n};\n}\ncase'between':case'notBetween':{\nconst pair=toArray(condition.value);\nconst lo=coerceTarget(pair[0],type);\nconst hi=coerceTarget(pair[1],type);\nconst bounds=condition.bounds||'[]';\nconst loInclusive=bounds.charAt(0)!=='(';\nconst hiInclusive=bounds.charAt(1)!==')';\nif(unorderable(lo)||unorderable(hi))return op==='between'?()=>false:()=>true;\nconst inRange=(v)=>{\nif(unorderable(v))return false;\nconst a=cmp(v,lo);\nconst b=cmp(v,hi);\nreturn(loInclusive?a>=0:a>0)&&(hiInclusive?b<=0:b<0);\n};\nreturn op==='between'?inRange:not(inRange);\n}\ncase'in':case'notIn':{\nconst set=buildSet(condition.value,caseSensitive,type);\nconst member=(v)=>set.has(setKey(v,caseSensitive));\nreturn op==='in'?member:not(member);\n}\ncase'contains':case'notContains':{\nconst needle=textOf(coerceTarget(condition.value,type),caseSensitive);\nconst has=(v)=>(v===null||v===undefined?false:textOf(v,caseSensitive).includes(needle));\nreturn op==='contains'?has:not(has);\n}\ncase'startsWith':{\nconst needle=textOf(coerceTarget(condition.value,type),caseSensitive);\nreturn(v)=>(v===null||v===undefined?false:textOf(v,caseSensitive).startsWith(needle));\n}\ncase'endsWith':{\nconst needle=textOf(coerceTarget(condition.value,type),caseSensitive);\nreturn(v)=>(v===null||v===undefined?false:textOf(v,caseSensitive).endsWith(needle));\n}\ncase'matches':{\nconst re=compileRegExp(condition.value,caseSensitive);\nif(!re)return()=>false;\nreturn(v)=>(v===null||v===undefined?false:re.test(String(v)));\n}\ncase'blank':\nreturn(v)=>isBlank(v)||(Array.isArray(v)&&v.length===0);\ncase'notBlank':\nreturn(v)=>!(isBlank(v)||(Array.isArray(v)&&v.length===0));\ncase'containsAny':case'containsNone':{\nconst set=buildSet(condition.value,caseSensitive,type);\nconst any=(v)=>{\nconst list=v===null||v===undefined?[]:toArray(v);\nfor(let i=0;i<list.length;i++)if(set.has(setKey(list[i],caseSensitive)))return true;\nreturn false;\n};\nreturn op==='containsAny'?any:not(any);\n}\ncase'containsAll':{\nconst wanted=toArray(condition.value).map((x)=>setKey(coerceTarget(x,type),caseSensitive));\nreturn(v)=>{\nconst list=v===null||v===undefined?[]:toArray(v);\nif(wanted.length===0)return true;\nconst have=new Set(list.map((x)=>setKey(x,caseSensitive)));\nfor(let i=0;i<wanted.length;i++)if(!have.has(wanted[i]))return false;\nreturn true;\n};\n}\ndefault:\nwarnOnce(`op:${String(op)}`,`unknown filter operator \"${String(op)}\"; the condition passes every row`);\nreturn()=>true;\n}\n}\nfunction testValue(value,condition,locale){\nreturn compilePredicate(condition,locale)(value);\n}\nfunction presenceCondition(handle,wantPresent,mask,count){\nconst present=presenceReader(handle);\nif(present){\nconst target=wantPresent?1:0;\nfor(let i=0;i<count;i++)mask[i]=present(i)===target?1:0;\nreturn mask;\n}\nconst kind=handle.kind;\nif(kind==='float64'||kind==='int32'||kind==='bitset'){\nreturn fillMask(mask,count,wantPresent?1:0);\n}\nconst read=valueReader(handle);\nfor(let i=0;i<count;i++){\nconst v=read(i);\nconst blank=isBlank(v)||(Array.isArray(v)&&v.length===0);\nmask[i]=blank===wantPresent?0:1;\n}\nreturn mask;\n}\nfunction dictionaryCondition(handle,pred,mask,count){\nconst dict=handle.dict;\nconst size=dictSize(dict);\nconst allowed=new Uint8Array(size);\nfor(let code=0;code<size;code++)allowed[code]=pred(dictValue(dict,code))?1:0;\nconst codes=handle.values;\nconst present=presenceReader(handle);\nif(!present){\nfor(let i=0;i<count;i++)mask[i]=allowed[codes[i]];\nreturn mask;\n}\nconst absentAnswer=pred(null)?1:0;\nfor(let i=0;i<count;i++)mask[i]=present(i)===1?allowed[codes[i]]:absentAnswer;\nreturn mask;\n}\nfunction booleanCondition(handle,pred,mask,count){\nconst bit=bitReader(handle.values);\nconst whenTrue=pred(true)?1:0;\nconst whenFalse=pred(false)?1:0;\nconst present=presenceReader(handle);\nif(!present){\nfor(let i=0;i<count;i++)mask[i]=bit(i)===1?whenTrue:whenFalse;\nreturn mask;\n}\nconst absentAnswer=pred(null)?1:0;\nfor(let i=0;i<count;i++){\nmask[i]=present(i)===0?absentAnswer:(bit(i)===1?whenTrue:whenFalse);\n}\nreturn mask;\n}\nfunction numericCondition(handle,condition,pred,mask,count){\nconst values=handle.values;\nconst type=condition.type;\nconst op=condition.op;\nlet handled=true;\nswitch(op){\ncase'eq':case'ne':{\nconst target=toNumber(coerceTarget(condition.value,type));\nconst wantNaN=typeof condition.value==='number'&&Number.isNaN(condition.value);\nconst invert=op==='ne'?1:0;\nif(wantNaN){\nfor(let i=0;i<count;i++)mask[i]=(Number.isNaN(values[i])?1:0)^invert;\n}else{\nfor(let i=0;i<count;i++)mask[i]=((values[i]===target)?1:0)^invert;\n}\nbreak;\n}\ncase'lt':{\nconst t=toNumber(coerceTarget(condition.value,type));\nfor(let i=0;i<count;i++)mask[i]=values[i]<t?1:0;\nbreak;\n}\ncase'lte':{\nconst t=toNumber(coerceTarget(condition.value,type));\nfor(let i=0;i<count;i++)mask[i]=values[i]<=t?1:0;\nbreak;\n}\ncase'gt':{\nconst t=toNumber(coerceTarget(condition.value,type));\nfor(let i=0;i<count;i++)mask[i]=values[i]>t?1:0;\nbreak;\n}\ncase'gte':{\nconst t=toNumber(coerceTarget(condition.value,type));\nfor(let i=0;i<count;i++)mask[i]=values[i]>=t?1:0;\nbreak;\n}\ncase'between':case'notBetween':{\nconst pair=toArray(condition.value);\nconst lo=toNumber(coerceTarget(pair[0],type));\nconst hi=toNumber(coerceTarget(pair[1],type));\nconst bounds=condition.bounds||'[]';\nconst loInclusive=bounds.charAt(0)!=='(';\nconst hiInclusive=bounds.charAt(1)!==')';\nconst invert=op==='notBetween'?1:0;\nif(loInclusive&&hiInclusive){\nfor(let i=0;i<count;i++)mask[i]=(((values[i]>=lo)&(values[i]<=hi))?1:0)^invert;\n}else if(loInclusive){\nfor(let i=0;i<count;i++)mask[i]=(((values[i]>=lo)&(values[i]<hi))?1:0)^invert;\n}else if(hiInclusive){\nfor(let i=0;i<count;i++)mask[i]=(((values[i]>lo)&(values[i]<=hi))?1:0)^invert;\n}else{\nfor(let i=0;i<count;i++)mask[i]=(((values[i]>lo)&(values[i]<hi))?1:0)^invert;\n}\nbreak;\n}\ncase'in':case'notIn':{\nconst set=new Set();\nfor(const raw of toArray(condition.value)){\nconst n=toNumber(coerceTarget(raw,type));\nif(!Number.isNaN(n))set.add(n);\n}\nconst invert=op==='notIn'?1:0;\nfor(let i=0;i<count;i++)mask[i]=(set.has(values[i])?1:0)^invert;\nbreak;\n}\ndefault:\nhandled=false;\nbreak;\n}\nif(!handled)return false;\nconst present=presenceReader(handle);\nif(present){\nconst absentAnswer=pred(null)?1:0;\nfor(let i=0;i<count;i++)if(present(i)===0)mask[i]=absentAnswer;\n}\nreturn true;\n}\nfunction genericCondition(handle,pred,mask,count){\nconst read=valueReader(handle);\nfor(let i=0;i<count;i++)mask[i]=pred(read(i))?1:0;\nreturn mask;\n}\nfunction evaluateCondition(condition,ctx,out){\nconst count=ctx.count|0;\nconst mask=out||acquireMask(ctx,count);\nif(!condition)return fillMask(mask,count,1);\nconst handle=typeof ctx.handle==='function'?ctx.handle(condition.col):undefined;\nconst custom=typeof ctx.custom==='function'?ctx.custom:null;\nif(!handle){\nif(custom){\nfor(let i=0;i<count;i++)mask[i]=custom(condition,i)?1:0;\nreturn mask;\n}\nwarnOnce(`filter:col:${String(condition.col)}`,\n`filter references unknown column \"${String(condition.col)}\"; the condition passes every row`);\nreturn fillMask(mask,count,1);\n}\nconst op=condition.op;\nif(op==='blank'||op==='notBlank')return presenceCondition(handle,op==='notBlank',mask,count);\nconst pred=compilePredicate(condition,ctx.locale);\nswitch(handle.kind){\ncase'dictionary':\nreturn dictionaryCondition(handle,pred,mask,count);\ncase'bitset':\nreturn booleanCondition(handle,pred,mask,count);\ncase'float64':case'int32':\nif(numericCondition(handle,condition,pred,mask,count))return mask;\nreturn genericCondition(handle,pred,mask,count);\ndefault:\nreturn genericCondition(handle,pred,mask,count);\n}\n}\nfunction evaluateNode(node,ctx,count){\nif(!node)return fillMask(acquireMask(ctx,count),count,1);\nif(Array.isArray(node.conditions)){\nconst children=node.conditions.filter((c)=>c!=null);\nconst op=node.op==='or'?'or':node.op==='not'?'not':'and';\nif(children.length===0)return fillMask(acquireMask(ctx,count),count,1);\nconst acc=evaluateNode(children[0],ctx,count);\nfor(let k=1;k<children.length;k++){\nconst rhs=evaluateNode(children[k],ctx,count);\nif(op==='or')for(let i=0;i<count;i++)acc[i]|=rhs[i];\nelse for(let i=0;i<count;i++)acc[i]&=rhs[i];\nreleaseMask(ctx,rhs);\n}\nif(op==='not')for(let i=0;i<count;i++)acc[i]^=1;\nreturn acc;\n}\nreturn evaluateCondition(node,ctx,acquireMask(ctx,count));\n}\nfunction evaluateFilters(filters,ctx){\nreturn evaluateNode(filters,ctx,ctx.count|0);\n}\nfunction pruneColumn(filters,colId){\nif(!filters||!colId)return filters||null;\nconst node=(filters);\nif(Array.isArray(node.conditions)){\nconst op=node.op==='or'?'or':node.op==='not'?'not':'and';\nif(op!=='and'){\nreturn mentionsColumn(node,colId)?null:filters;\n}\nconst kept=[];\nfor(const child of node.conditions){\nconst pruned=pruneColumn(child,colId);\nif(pruned)kept.push(pruned);\n}\nif(!kept.length)return null;\nreturn{...node,op:'and',conditions:kept};\n}\nreturn node.col===colId?null:filters;\n}\nfunction mentionsColumn(filters,colId){\nif(!filters||typeof filters!=='object')return false;\nconst node=(filters);\nif(node.col===colId)return true;\nif(Array.isArray(node.conditions)){\nfor(const child of node.conditions)if(mentionsColumn(child,colId))return true;\n}\nreturn false;\n}\nfunction compact(mask,count,out){\nif(out&&out.length>=count){\nlet k=0;\nfor(let i=0;i<count;i++)if(mask[i])out[k++]=i;\nreturn out.subarray(0,k);\n}\nlet survivors=0;\nfor(let i=0;i<count;i++)survivors+=mask[i]?1:0;\nconst result=new Uint32Array(survivors);\nlet k=0;\nfor(let i=0;i<count;i++)if(mask[i])result[k++]=i;\nreturn result;\n}\n});\n__def(\"packages/core/src/compute/group.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"packKeys\",{enumerable:true,get:function(){return packKeys;}});\nObject.defineProperty(__exports,\"groupByColumns\",{enumerable:true,get:function(){return groupByColumns;}});\nconst __m0=__req(\"packages/core/src/compute/handle.js\");\nconst dictSize=__m0[\"dictSize\"];\nconst identity=__m0[\"identity\"];\nconst presenceReader=__m0[\"presenceReader\"];\nconst rowCount=__m0[\"rowCount\"];\nconst valueReader=__m0[\"valueReader\"];\nconst KEY_SEPARATOR='\\u001F';\nconst NULL_MARKER='\\u0000';\nconst MAX_DIRECT_COUNTS=1<<20;\nfunction packKeys(handles,idx,n,project){\nconst k=handles.length;\nconst base=handles.map((h)=>valueReader(h));\nconst projected=Array.isArray(project)&&project.some(Boolean);\nconst readers=projected\n?base.map((r,j)=>(project[j]?(i)=>project[j](r(i)):r))\n:base;\nconst allDictionary=!projected&&k>0&&handles.every((h)=>h&&h.kind==='dictionary'&&h.dict);\nif(allDictionary){\nconst cards=handles.map((h)=>dictSize(h.dict)+1);\nlet product=1;\nfor(let j=0;j<k;j++)product*=cards[j];\nif(product<=Number.MAX_SAFE_INTEGER){\nconst codes=handles.map((h)=>h.values);\nconst presence=handles.map((h)=>presenceReader(h));\nconst keyOf=(row)=>{\nlet key=0;\nfor(let j=0;j<k;j++){\nconst present=presence[j];\nconst code=present&&present(row)===0?cards[j]-1:codes[j][row];\nkey=key*cards[j]+code;\n}\nreturn key;\n};\nconst packed=new Float64Array(n);\nfor(let i=0;i<n;i++)packed[i]=keyOf(idx[i]);\nreturn{packed,strings:null,product,readers,keyOf};\n}\n}\nconst keyOf=(row)=>{\nlet key='';\nfor(let j=0;j<k;j++){\nconst v=readers[j](row);\nkey+=(j===0?'':KEY_SEPARATOR)+(v===null||v===undefined?NULL_MARKER:String(v));\n}\nreturn key;\n};\nconst strings=new Array(n);\nfor(let i=0;i<n;i++)strings[i]=keyOf(idx[i]);\nreturn{packed:null,strings,product:Infinity,readers,keyOf};\n}\nfunction scatterBuckets(idx,ids,n,groups){\nconst offsets=new Uint32Array(groups+1);\nfor(let i=0;i<n;i++)offsets[ids[i]+1]++;\nfor(let g=0;g<groups;g++)offsets[g+1]+=offsets[g];\nconst scattered=new Uint32Array(n);\nconst cursor=offsets.slice(0,groups);\nfor(let i=0;i<n;i++)scattered[cursor[ids[i]]++]=idx[i];\nconst buckets=new Array(groups);\nfor(let g=0;g<groups;g++)buckets[g]=scattered.subarray(offsets[g],offsets[g+1]);\nreturn buckets;\n}\nfunction groupByColumns(handles,order,opts={}){\nconst list=handles||[];\nconst idx=order||identity(rowCount(list[0],opts));\nconst n=idx.length;\nif(list.length===0||n===0)return{keys:[],buckets:[]};\nconst{packed,strings,product,readers}=packKeys(list,idx,n,opts.project);\nconst ids=new Uint32Array(n);\nlet groups=0;\nlet packedKeys=null;\nif(packed&&product<=Math.max(1024,Math.min(MAX_DIRECT_COUNTS,n*4))){\nconst size=product;\nconst seen=new Int32Array(size).fill(-1);\nfor(let i=0;i<n;i++)seen[packed[i]]=0;\nfor(let key=0;key<size;key++)if(seen[key]===0)seen[key]=groups++;\nfor(let i=0;i<n;i++)ids[i]=seen[packed[i]];\npackedKeys=new Float64Array(groups);\nfor(let key=0;key<size;key++)if(seen[key]>=0)packedKeys[seen[key]]=key;\n}else if(packed){\nconst seen=new Map();\nfor(let i=0;i<n;i++){\nconst key=packed[i];\nlet id=seen.get(key);\nif(id===undefined){id=groups++;seen.set(key,id);}\nids[i]=id;\n}\npackedKeys=new Float64Array(groups);\nfor(const[key,id]of seen)packedKeys[id]=key;\n}else{\nconst seen=new Map();\nfor(let i=0;i<n;i++){\nconst key=strings[i];\nlet id=seen.get(key);\nif(id===undefined){id=groups++;seen.set(key,id);}\nids[i]=id;\n}\n}\nconst buckets=scatterBuckets(idx,ids,n,groups);\nconst keys=new Array(groups);\nfor(let g=0;g<groups;g++){\nconst row=buckets[g][0];\nconst tuple=new Array(readers.length);\nfor(let j=0;j<readers.length;j++)tuple[j]=readers[j](row);\nkeys[g]=tuple;\n}\nconst result={keys,buckets};\nif(packedKeys)result.packed=packedKeys;\nreturn result;\n}\n});\n__def(\"packages/core/src/compute/facet.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"STRATEGIES\",{enumerable:true,get:function(){return STRATEGIES;}});\nObject.defineProperty(__exports,\"GRANULARITIES\",{enumerable:true,get:function(){return GRANULARITIES;}});\nObject.defineProperty(__exports,\"DEFAULT_BUCKETS\",{enumerable:true,get:function(){return DEFAULT_BUCKETS;}});\nObject.defineProperty(__exports,\"DEFAULT_CARDINALITY_LIMIT\",{enumerable:true,get:function(){return DEFAULT_CARDINALITY_LIMIT;}});\nObject.defineProperty(__exports,\"QUANTILE_SAMPLE\",{enumerable:true,get:function(){return QUANTILE_SAMPLE;}});\nObject.defineProperty(__exports,\"facetKind\",{enumerable:true,get:function(){return facetKind;}});\nObject.defineProperty(__exports,\"orderedReader\",{enumerable:true,get:function(){return orderedReader;}});\nObject.defineProperty(__exports,\"toNumeric\",{enumerable:true,get:function(){return toNumeric;}});\nObject.defineProperty(__exports,\"cardinalityOf\",{enumerable:true,get:function(){return cardinalityOf;}});\nObject.defineProperty(__exports,\"pickGranularity\",{enumerable:true,get:function(){return pickGranularity;}});\nObject.defineProperty(__exports,\"floorTo\",{enumerable:true,get:function(){return floorTo;}});\nObject.defineProperty(__exports,\"advance\",{enumerable:true,get:function(){return advance;}});\nObject.defineProperty(__exports,\"computeBounds\",{enumerable:true,get:function(){return computeBounds;}});\nObject.defineProperty(__exports,\"countInto\",{enumerable:true,get:function(){return countInto;}});\nObject.defineProperty(__exports,\"bucketOf\",{enumerable:true,get:function(){return bucketOf;}});\nObject.defineProperty(__exports,\"facet\",{enumerable:true,get:function(){return facet;}});\nObject.defineProperty(__exports,\"default\",{enumerable:true,get:function(){return __default;}});\nconst __m0=__req(\"packages/core/src/compute/handle.js\");\nconst presenceReader=__m0[\"presenceReader\"];\nconst valueReader=__m0[\"valueReader\"];\nconst dictSize=__m0[\"dictSize\"];\nconst dictValue=__m0[\"dictValue\"];\nconst STRATEGIES=Object.freeze(['equal','quantile','log']);\nconst GRANULARITIES=Object.freeze(['hour','day','week','month','quarter','year']);\nconst DEFAULT_BUCKETS=20;\nconst DEFAULT_CARDINALITY_LIMIT=50;\nconst QUANTILE_SAMPLE=10_000;\nfunction facetKind(handle,type){\nif(!handle)return'none';\nconst base=type&&type.base;\nif(base==='date'||base==='datetime'||base==='time'||base==='dateString')return'date';\nswitch(handle.kind){\ncase'bitset':return'boolean';\ncase'float64':case'int32':return'numeric';\ncase'dictionary':return'category';\ncase'multi':return'category';\ndefault:\nif(base==='number')return'numeric';\nif(base==='boolean')return'boolean';\nif(base==='text')return'category';\nreturn'none';\n}\n}\nfunction orderedReader(handle){\nconst values=handle.values;\nconst kind=handle.kind;\nif((kind==='float64'||kind==='int32')&&values)return(i)=>values[i];\nconst read=valueReader(handle);\nreturn(i)=>toNumeric(read(i));\n}\nfunction toNumeric(v){\nif(typeof v==='number')return v;\nif(v instanceof Date)return v.getTime();\nif(v===null||v===undefined||v==='')return NaN;\nif(typeof v==='boolean')return v?1:0;\nif(typeof v==='string'){\nconst n=Number(v);\nif(Number.isFinite(n))return n;\nconst t=Date.parse(v);\nreturn Number.isFinite(t)?t:NaN;\n}\nreturn NaN;\n}\nfunction cardinalityOf(handle,indices,count,limit=DEFAULT_CARDINALITY_LIMIT){\nif(!handle)return{cardinality:0,exact:true};\nif(handle.dict)return{cardinality:dictSize(handle.dict),exact:true};\nif(handle.kind==='bitset')return{cardinality:2,exact:true};\nconst read=valueReader(handle);\nconst n=indices?indices.length:count;\nconst seen=new Set();\nfor(let k=0;k<n;k++){\nconst v=read(indices?indices[k]:k);\nif(v===null||v===undefined)continue;\nseen.add(v);\nif(seen.size>limit)return{cardinality:seen.size,exact:false};\n}\nreturn{cardinality:seen.size,exact:true};\n}\nconst HOUR_MS=3600_000;\nconst DAY_MS=86_400_000;\nfunction pickGranularity(span,target=DEFAULT_BUCKETS){\nconst ms=Number.isFinite(span)&&span>0?span:0;\nconst wide=Math.max(1,target)*2;\nif(ms/HOUR_MS<=wide)return'hour';\nif(ms/DAY_MS<=wide)return'day';\nif(ms/(7*DAY_MS)<=wide)return'week';\nif(ms/(30*DAY_MS)<=wide)return'month';\nif(ms/(91*DAY_MS)<=wide)return'quarter';\nreturn'year';\n}\nfunction floorTo(ms,granularity){\nif(!Number.isFinite(ms))return NaN;\nconst d=new Date(ms);\nswitch(granularity){\ncase'hour':d.setMinutes(0,0,0);return d.getTime();\ncase'day':d.setHours(0,0,0,0);return d.getTime();\ncase'week':{\nd.setHours(0,0,0,0);\nconst back=(d.getDay()+6)%7;\nd.setDate(d.getDate()-back);\nreturn d.getTime();\n}\ncase'month':d.setDate(1);d.setHours(0,0,0,0);return d.getTime();\ncase'quarter':\nd.setMonth(Math.floor(d.getMonth()/3)*3,1);\nd.setHours(0,0,0,0);\nreturn d.getTime();\ndefault:d.setMonth(0,1);d.setHours(0,0,0,0);return d.getTime();\n}\n}\nfunction advance(ms,granularity){\nconst d=new Date(ms);\nswitch(granularity){\ncase'hour':d.setHours(d.getHours()+1);break;\ncase'day':d.setDate(d.getDate()+1);break;\ncase'week':d.setDate(d.getDate()+7);break;\ncase'month':d.setMonth(d.getMonth()+1);break;\ncase'quarter':d.setMonth(d.getMonth()+3);break;\ndefault:d.setFullYear(d.getFullYear()+1);break;\n}\nreturn d.getTime();\n}\nfunction numericExtent(handle,indices,count){\nconst read=orderedReader(handle);\nconst present=presenceReader(handle);\nconst n=indices?indices.length:count;\nlet min=Infinity;\nlet max=-Infinity;\nlet nulls=0;\nlet finite=0;\nfor(let k=0;k<n;k++){\nconst i=indices?indices[k]:k;\nif(present&&!present(i)){nulls++;continue;}\nconst v=read(i);\nif(!Number.isFinite(v)){nulls++;continue;}\nif(v<min)min=v;\nif(v>max)max=v;\nfinite++;\n}\nreturn{min,max,nulls,finite};\n}\nfunction sortedSample(handle,indices,count,cap){\nconst read=orderedReader(handle);\nconst present=presenceReader(handle);\nconst n=indices?indices.length:count;\nconst step=n>cap?n/cap:1;\nconst out=[];\nfor(let s=0;s<n;s+=step){\nconst i=indices?indices[Math.floor(s)]:Math.floor(s);\nif(present&&!present(i))continue;\nconst v=read(i);\nif(Number.isFinite(v))out.push(v);\n}\nconst arr=Float64Array.from(out);\narr.sort();\nreturn arr;\n}\nfunction computeBounds(handle,indices,count,opts={}){\nconst kind=opts.kind||facetKind(handle,opts.type);\nif(kind==='none'||!handle)return{kind:'none',buckets:[],suppressed:'type'};\nif(kind==='boolean')return boundsForBoolean(handle,indices,count);\nif(kind==='category')return boundsForCategory(handle,indices,count,opts);\nreturn boundsForOrdered(handle,indices,count,kind,opts);\n}\nfunction boundsForBoolean(handle,indices,count){\nconst present=presenceReader(handle);\nlet nulls=0;\nif(present){\nconst n=indices?indices.length:count;\nfor(let k=0;k<n;k++)if(!present(indices?indices[k]:k))nulls++;\n}\nconst buckets=[{value:false,label:'false'},{value:true,label:'true'}];\nif(nulls>0)buckets.push({null:true,label:'Empty'});\nreturn{kind:'boolean',buckets};\n}\nfunction boundsForCategory(handle,indices,count,opts){\nconst limit=opts.cardinalityLimit??DEFAULT_CARDINALITY_LIMIT;\nconst{cardinality}=cardinalityOf(handle,indices,count,limit);\nif(cardinality>limit&&(opts.aboveLimit||'suppress')==='suppress'){\nreturn{kind:'category',buckets:[],suppressed:'cardinality',cardinality};\n}\nconst read=valueReader(handle);\nconst n=indices?indices.length:count;\nconst tally=new Map();\nlet nulls=0;\nfor(let k=0;k<n;k++){\nconst v=read(indices?indices[k]:k);\nif(v===null||v===undefined||v===''){nulls++;continue;}\nif(Array.isArray(v)){\nif(!v.length){nulls++;continue;}\nfor(const m of v)tally.set(m,(tally.get(m)||0)+1);\ncontinue;\n}\ntally.set(v,(tally.get(v)||0)+1);\n}\nlet entries=[...tally.entries()];\nif(opts.order==='alpha'){\nentries.sort((a,b)=>String(a[0]).localeCompare(String(b[0])));\n}else{\nentries.sort((a,b)=>b[1]-a[1]);\n}\nlet remainder=0;\nlet dropped=0;\nif(entries.length>limit){\ndropped=entries.length-limit;\nfor(let i=limit;i<entries.length;i++)remainder+=entries[i][1];\nentries=entries.slice(0,limit);\n}\nconst buckets=entries.map(([value])=>({value,label:String(value)}));\nif(remainder>0)buckets.push({remainder:true,label:`Other (${dropped} values)`});\nif(nulls>0)buckets.push({null:true,label:'Empty'});\nreturn{kind:'category',buckets,cardinality};\n}\nfunction boundsForOrdered(handle,indices,count,kind,opts){\nconst{min,max,nulls,finite}=numericExtent(handle,indices,count);\nif(!finite){\nreturn{kind,buckets:nulls?[{null:true,label:'Empty'}]:[],empty:true};\n}\nconst wanted=Math.max(1,Math.floor(opts.buckets||DEFAULT_BUCKETS));\nlet buckets=[];\nif(kind==='date'){\nconst granularity=GRANULARITIES.includes(opts.granularity)\n?opts.granularity:pickGranularity(max-min,wanted);\nlet edge=floorTo(min,granularity);\nwhile(edge<=max&&buckets.length<4096){\nconst next=advance(edge,granularity);\nif(!(next>edge))break;\nbuckets.push({from:edge,to:next});\nedge=next;\n}\nreturn{kind,buckets:withNull(buckets,nulls),granularity};\n}\nconst strategy=STRATEGIES.includes(opts.strategy)?opts.strategy:'equal';\nif(strategy==='quantile'){\nconst sample=sortedSample(handle,indices,count,QUANTILE_SAMPLE);\nif(sample.length){\nconst edges=[sample[0]];\nfor(let b=1;b<wanted;b++){\nconst v=sample[Math.min(sample.length-1,Math.floor((b/wanted)*sample.length))];\nif(v>edges[edges.length-1])edges.push(v);\n}\nedges.push(max);\nfor(let b=0;b<edges.length-1;b++)buckets.push({from:edges[b],to:edges[b+1]});\n}\n}else if(strategy==='log'&&min>0){\nconst lo=Math.log10(min);\nconst hi=Math.log10(max);\nconst step=(hi-lo)/wanted||1;\nfor(let b=0;b<wanted;b++){\nbuckets.push({from:10**(lo+b*step),to:10**(lo+(b+1)*step)});\n}\n}\nif(!buckets.length){\nconst width=(max-min)/wanted||1;\nfor(let b=0;b<wanted;b++)buckets.push({from:min+b*width,to:min+(b+1)*width});\n}\nbuckets[buckets.length-1].to=max;\nreturn{kind,buckets:withNull(buckets,nulls),strategy,min,max};\n}\nfunction withNull(buckets,nulls){\nreturn nulls>0?[...buckets,{null:true,label:'Empty'}]:buckets;\n}\nfunction countInto(handle,indices,count,bounds,out){\nconst buckets=(bounds&&bounds.buckets)||[];\nconst counts=out&&out.length>=buckets.length?out.subarray(0,buckets.length)\n:new Uint32Array(buckets.length);\ncounts.fill(0);\nif(!handle||!buckets.length)return counts;\nconst nullBucket=buckets.length-1;\nconst hasNull=!!buckets[nullBucket]&&buckets[nullBucket].null===true;\nconst n=indices?indices.length:count;\nif(bounds.kind==='boolean'){\nconst read=valueReader(handle);\nfor(let k=0;k<n;k++){\nconst v=read(indices?indices[k]:k);\nif(v===null||v===undefined){if(hasNull)counts[nullBucket]++;continue;}\ncounts[v?1:0]++;\n}\nreturn counts;\n}\nif(bounds.kind==='category'){\nconst slot=new Map();\nfor(let b=0;b<buckets.length;b++){\nif(!buckets[b].null&&!buckets[b].remainder)slot.set(buckets[b].value,b);\n}\nconst remainderAt=buckets.findIndex((b)=>b.remainder);\nconst read=valueReader(handle);\nfor(let k=0;k<n;k++){\nconst v=read(indices?indices[k]:k);\nif(v===null||v===undefined||v===''){if(hasNull)counts[nullBucket]++;continue;}\nif(Array.isArray(v)){\nif(!v.length){if(hasNull)counts[nullBucket]++;continue;}\nfor(const m of v){\nconst at=slot.get(m);\nif(at!==undefined)counts[at]++;\nelse if(remainderAt>=0)counts[remainderAt]++;\n}\ncontinue;\n}\nconst at=slot.get(v);\nif(at!==undefined)counts[at]++;\nelse if(remainderAt>=0)counts[remainderAt]++;\n}\nreturn counts;\n}\nconst ordered=hasNull?buckets.length-1:buckets.length;\nconst edges=new Float64Array(ordered+1);\nfor(let b=0;b<ordered;b++)edges[b]=buckets[b].from;\nedges[ordered]=ordered?buckets[ordered-1].to:0;\nconst read=orderedReader(handle);\nconst present=presenceReader(handle);\nfor(let k=0;k<n;k++){\nconst i=indices?indices[k]:k;\nif(present&&!present(i)){if(hasNull)counts[nullBucket]++;continue;}\nconst v=read(i);\nif(!Number.isFinite(v)){if(hasNull)counts[nullBucket]++;continue;}\nconst at=bucketOf(edges,ordered,v);\nif(at>=0)counts[at]++;\n}\nreturn counts;\n}\nfunction bucketOf(edges,ordered,v){\nif(!ordered)return-1;\nif(v<edges[0])return-1;\nif(v>=edges[ordered])return v===edges[ordered]?ordered-1:-1;\nlet lo=0;\nlet hi=ordered-1;\nwhile(lo<hi){\nconst mid=(lo+hi+1)>>>1;\nif(v>=edges[mid])lo=mid;else hi=mid-1;\n}\nreturn lo;\n}\nfunction facet(handle,indices,count,opts={}){\nconst bounds=opts.bounds||computeBounds(handle,opts.boundsIndices??indices,count,opts);\nreturn{bounds,counts:countInto(handle,indices,count,bounds)};\n}\nconst __default=facet;\n});\n__def(\"packages/core/src/compute/special.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"logGamma\",{enumerable:true,get:function(){return logGamma;}});\nObject.defineProperty(__exports,\"incompleteBeta\",{enumerable:true,get:function(){return incompleteBeta;}});\nObject.defineProperty(__exports,\"normalQuantile\",{enumerable:true,get:function(){return normalQuantile;}});\nObject.defineProperty(__exports,\"normalCdf\",{enumerable:true,get:function(){return normalCdf;}});\nObject.defineProperty(__exports,\"studentT\",{enumerable:true,get:function(){return studentT;}});\nObject.defineProperty(__exports,\"studentTQuantile\",{enumerable:true,get:function(){return studentTQuantile;}});\nObject.defineProperty(__exports,\"regularizedGammaP\",{enumerable:true,get:function(){return regularizedGammaP;}});\nObject.defineProperty(__exports,\"chiSquareCdf\",{enumerable:true,get:function(){return chiSquareCdf;}});\nObject.defineProperty(__exports,\"chiSquareUpperTail\",{enumerable:true,get:function(){return chiSquareUpperTail;}});\nconst LANCZOS=Object.freeze([\n676.5203681218851,-1259.1392167224028,771.32342877765313,\n-176.61502916214059,12.507343278686905,-0.13857109526572012,\n9.9843695780195716e-6,1.5056327351493116e-7,\n]);\nconst EPS=3e-12;\nconst TINY=1e-300;\nfunction logGamma(x){\nif(x<0.5)return Math.log(Math.PI/Math.sin(Math.PI*x))-logGamma(1-x);\nconst z=x-1;\nlet a=0.99999999999980993;\nconst t=z+7.5;\nfor(let i=0;i<LANCZOS.length;i++)a+=LANCZOS[i]/(z+i+1);\nreturn 0.5*Math.log(2*Math.PI)+(z+0.5)*Math.log(t)-t+Math.log(a);\n}\nfunction betaContinuedFraction(a,b,x){\nconst qab=a+b;\nconst qap=a+1;\nconst qam=a-1;\nlet c=1;\nlet d=1-(qab*x)/qap;\nif(Math.abs(d)<TINY)d=TINY;\nd=1/d;\nlet h=d;\nfor(let m=1;m<=300;m++){\nconst m2=2*m;\nlet aa=(m*(b-m)*x)/((qam+m2)*(a+m2));\nd=1+aa*d;\nif(Math.abs(d)<TINY)d=TINY;\nc=1+aa/c;\nif(Math.abs(c)<TINY)c=TINY;\nd=1/d;\nh*=d*c;\naa=(-(a+m)*(qab+m)*x)/((a+m2)*(qap+m2));\nd=1+aa*d;\nif(Math.abs(d)<TINY)d=TINY;\nc=1+aa/c;\nif(Math.abs(c)<TINY)c=TINY;\nd=1/d;\nconst step=d*c;\nh*=step;\nif(Math.abs(step-1)<EPS)break;\n}\nreturn h;\n}\nfunction incompleteBeta(a,b,x){\nif(!(a>0)||!(b>0)||!Number.isFinite(x))return Number.NaN;\nif(x<=0)return 0;\nif(x>=1)return 1;\nconst front=Math.exp(\nlogGamma(a+b)-logGamma(a)-logGamma(b)+a*Math.log(x)+b*Math.log(1-x),\n);\nreturn x<(a+1)/(a+b+2)\n?(front*betaContinuedFraction(a,b,x))/a\n:1-(front*betaContinuedFraction(b,a,1-x))/b;\n}\nfunction normalQuantile(p){\nif(!(p>0)||!(p<1))return p===0?-Infinity:(p===1?Infinity:Number.NaN);\nconst a=[-3.969683028665376e+1,2.209460984245205e+2,-2.759285104469687e+2,\n1.383577518672690e+2,-3.066479806614716e+1,2.506628277459239];\nconst b=[-5.447609879822406e+1,1.615858368580409e+2,-1.556989798598866e+2,\n6.680131188771972e+1,-1.328068155288572e+1];\nconst c=[-7.784894002430293e-3,-3.223964580411365e-1,-2.400758277161838,\n-2.549732539343734,4.374664141464968,2.938163982698783];\nconst d=[7.784695709041462e-3,3.224671290700398e-1,2.445134137142996,\n3.754408661907416];\nconst low=0.02425;\nlet q;\nlet r;\nlet x;\nif(p<low){\nq=Math.sqrt(-2*Math.log(p));\nx=(((((c[0]*q+c[1])*q+c[2])*q+c[3])*q+c[4])*q+c[5])\n/ ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1);\n}else if(p<=1-low){\nq=p-0.5;\nr=q*q;\nx=((((((a[0]*r+a[1])*r+a[2])*r+a[3])*r+a[4])*r+a[5])*q)\n/ (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1);\n}else{\nq=Math.sqrt(-2*Math.log(1-p));\nx=-(((((c[0]*q+c[1])*q+c[2])*q+c[3])*q+c[4])*q+c[5])\n/ ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1);\n}\nconst e=0.5*erfc(-x/Math.SQRT2)-p;\nconst u=e*Math.sqrt(2*Math.PI)*Math.exp((x*x)/2);\nreturn x-u/(1+(x*u)/2);\n}\nfunction erfc(x){\nconst z=Math.abs(x);\nconst t=2/(2+z);\nconst ty=4*t-2;\nconst cof=[-1.3026537197817094,6.4196979235649026e-1,1.9476473204185836e-2,\n-9.561514786808631e-3,-9.46595344482036e-4,3.66839497852761e-4,\n4.2523324806907e-5,-2.0278578112534e-5,-1.624290004647e-6,\n1.303655835580e-6,1.5626441722e-8,-8.5238095915e-8,6.529054439e-9,\n5.059343495e-9,-9.91364156e-10,-2.27365122e-10,9.6467911e-11,\n2.394038e-12,-6.886027e-12,8.94487e-13,3.13092e-13,-1.12708e-13,\n3.81e-16,7.106e-15];\nlet dd=0;\nlet dv=0;\nlet tmp;\nfor(let j=cof.length-1;j>0;j--){\ntmp=dv;\ndv=ty*dv-dd+cof[j];\ndd=tmp;\n}\nconst ans=t*Math.exp(-z*z+0.5*(cof[0]+ty*dv)-dd);\nreturn x>=0?ans:2-ans;\n}\nfunction normalCdf(x){\nreturn 0.5*erfc(-x/Math.SQRT2);\n}\nfunction studentT(t,df){\nif(!(df>0)||!Number.isFinite(t))return Number.NaN;\nconst tail=0.5*incompleteBeta(df/2,0.5,df/(df+t*t));\nreturn t>0?1-tail:tail;\n}\nfunction studentTQuantile(p,df){\nif(!(p>0)||!(p<1)||!(df>0))return Number.NaN;\nif(df>1e7)return normalQuantile(p);\nlet lo=-1e4;\nlet hi=1e4;\nlet x=normalQuantile(p);\nconst logBeta=logGamma(df/2)+logGamma(0.5)-logGamma((df+1)/2);\nfor(let i=0;i<60;i++){\nconst cdf=studentT(x,df);\nif(cdf<p)lo=x;else hi=x;\nconst pdf=Math.exp(-((df+1)/2)*Math.log(1+(x*x)/df)-logBeta)\n/ Math.sqrt(df);\nconst step=pdf>0?(cdf-p)/pdf:0;\nif(Math.abs(step)<1e-12)break;\nconst next=x-step;\nx=next>lo&&next<hi&&Number.isFinite(next)?next:(lo+hi)/2;\nif(hi-lo<1e-12)break;\n}\nreturn x;\n}\nfunction gammaSeries(a,x){\nlet ap=a;\nlet sum=1/a;\nlet del=sum;\nfor(let n=0;n<300;n++){\nap+=1;\ndel*=x/ap;\nsum+=del;\nif(Math.abs(del)<Math.abs(sum)*EPS)break;\n}\nreturn sum*Math.exp(-x+a*Math.log(x)-logGamma(a));\n}\nfunction gammaContinuedFraction(a,x){\nlet b=x+1-a;\nlet c=1/TINY;\nlet d=1/b;\nlet h=d;\nfor(let i=1;i<=300;i++){\nconst an=-i*(i-a);\nb+=2;\nd=an*d+b;\nif(Math.abs(d)<TINY)d=TINY;\nc=b+an/c;\nif(Math.abs(c)<TINY)c=TINY;\nd=1/d;\nconst del=d*c;\nh*=del;\nif(Math.abs(del-1)<EPS)break;\n}\nreturn Math.exp(-x+a*Math.log(x)-logGamma(a))*h;\n}\nfunction regularizedGammaP(a,x){\nif(!(a>0)||!(x>=0)||!Number.isFinite(x))return Number.NaN;\nif(x===0)return 0;\nreturn x<a+1?gammaSeries(a,x):1-gammaContinuedFraction(a,x);\n}\nfunction chiSquareCdf(x,df){\nif(!(df>0))return Number.NaN;\nreturn regularizedGammaP(df/2,x/2);\n}\nfunction chiSquareUpperTail(x,df){\nconst cdf=chiSquareCdf(x,df);\nreturn Number.isNaN(cdf)?Number.NaN:Math.min(1,Math.max(0,1-cdf));\n}\n});\n__def(\"packages/core/src/compute/linalg.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"cholesky\",{enumerable:true,get:function(){return cholesky;}});\nObject.defineProperty(__exports,\"choleskySolve\",{enumerable:true,get:function(){return choleskySolve;}});\nObject.defineProperty(__exports,\"choleskyInverse\",{enumerable:true,get:function(){return choleskyInverse;}});\nObject.defineProperty(__exports,\"normalEquations\",{enumerable:true,get:function(){return normalEquations;}});\nObject.defineProperty(__exports,\"matVec\",{enumerable:true,get:function(){return matVec;}});\nObject.defineProperty(__exports,\"quadForm\",{enumerable:true,get:function(){return quadForm;}});\nfunction cholesky(a){\nconst n=a.length;\nconst l=Array.from({length:n},()=>new Array(n).fill(0));\nfor(let i=0;i<n;i++){\nfor(let j=0;j<=i;j++){\nlet sum=a[i][j];\nfor(let k=0;k<j;k++)sum-=l[i][k]*l[j][k];\nif(i===j){\nif(!(sum>0))return null;\nl[i][j]=Math.sqrt(sum);\n}else{\nl[i][j]=sum/l[j][j];\n}\n}\n}\nreturn l;\n}\nfunction choleskySolve(l,b){\nconst n=l.length;\nconst y=new Array(n).fill(0);\nfor(let i=0;i<n;i++){\nlet sum=b[i];\nfor(let k=0;k<i;k++)sum-=l[i][k]*y[k];\ny[i]=sum/l[i][i];\n}\nconst x=new Array(n).fill(0);\nfor(let i=n-1;i>=0;i--){\nlet sum=y[i];\nfor(let k=i+1;k<n;k++)sum-=l[k][i]*x[k];\nx[i]=sum/l[i][i];\n}\nreturn x;\n}\nfunction choleskyInverse(l){\nconst n=l.length;\nconst inv=Array.from({length:n},()=>new Array(n).fill(0));\nfor(let c=0;c<n;c++){\nconst e=new Array(n).fill(0);\ne[c]=1;\nconst col=choleskySolve(l,e);\nfor(let r=0;r<n;r++)inv[r][c]=col[r];\n}\nreturn inv;\n}\nfunction normalEquations(x,y,w){\nconst n=x.length;\nconst p=n?x[0].length:0;\nconst xtwx=Array.from({length:p},()=>new Array(p).fill(0));\nconst xtwy=new Array(p).fill(0);\nfor(let i=0;i<n;i++){\nconst wi=w?w[i]:1;\nconst row=x[i];\nfor(let a=0;a<p;a++){\nconst wxa=wi*row[a];\nxtwy[a]+=wxa*y[i];\nfor(let b=a;b<p;b++)xtwx[a][b]+=wxa*row[b];\n}\n}\nfor(let a=0;a<p;a++)for(let b=0;b<a;b++)xtwx[a][b]=xtwx[b][a];\nreturn{xtwx,xtwy};\n}\nfunction matVec(m,v){\nreturn m.map((row)=>row.reduce((sum,cell,j)=>sum+cell*v[j],0));\n}\nfunction quadForm(x,m){\nlet sum=0;\nfor(let a=0;a<x.length;a++){\nlet inner=0;\nfor(let b=0;b<x.length;b++)inner+=m[a][b]*x[b];\nsum+=x[a]*inner;\n}\nreturn sum;\n}\n});\n__def(\"packages/core/src/compute/sketch.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"Welford\",{enumerable:true,get:function(){return Welford;}});\nObject.defineProperty(__exports,\"Reservoir\",{enumerable:true,get:function(){return Reservoir;}});\nObject.defineProperty(__exports,\"hash32\",{enumerable:true,get:function(){return hash32;}});\nObject.defineProperty(__exports,\"HyperLogLog\",{enumerable:true,get:function(){return HyperLogLog;}});\nObject.defineProperty(__exports,\"SpaceSaving\",{enumerable:true,get:function(){return SpaceSaving;}});\nObject.defineProperty(__exports,\"KLL\",{enumerable:true,get:function(){return KLL;}});\nObject.defineProperty(__exports,\"SKETCH_BOUNDS\",{enumerable:true,get:function(){return SKETCH_BOUNDS;}});\nObject.defineProperty(__exports,\"default\",{enumerable:true,get:function(){return __default;}});\nclass Welford{\n#n=0;\n#mean=0;\n#m2=0;\nstatic get errorBound(){\nreturn Object.freeze({\nkind:'exact',metric:'none',value:0,\nstatement:'mean and variance match a full recompute to float rounding',\n});\n}\nget count(){return this.#n;}\nadd(x){\nif(!Number.isFinite(x))return;\nthis.#n++;\nconst delta=x-this.#mean;\nthis.#mean+=delta/this.#n;\nthis.#m2+=delta*(x-this.#mean);\n}\nmerge(other){\nif(other.#n===0)return;\nif(this.#n===0){this.#n=other.#n;this.#mean=other.#mean;this.#m2=other.#m2;return;}\nconst n=this.#n+other.#n;\nconst delta=other.#mean-this.#mean;\nthis.#mean+=delta*(other.#n/n);\nthis.#m2+=other.#m2+delta*delta*(this.#n*other.#n/n);\nthis.#n=n;\n}\nmean(){return this.#n?this.#mean:null;}\nvariance(){return this.#n>1?this.#m2/(this.#n-1):null;}\nvarianceP(){return this.#n?this.#m2/this.#n:null;}\nstddev(){const v=this.variance();return v===null?null:Math.sqrt(v);}\nstddevP(){const v=this.varianceP();return v===null?null:Math.sqrt(v);}\n}\nclass Reservoir{\n#items=[];\n#seen=0;\n#capacity;\n#rng;\nconstructor(capacity,rng=Math.random){\nif(!(capacity>0))throw new RangeError('reservoir capacity must be positive');\nthis.#capacity=Math.floor(capacity);\nthis.#rng=rng;\n}\nstatic get errorBound(){\nreturn Object.freeze({\nkind:'probabilistic',metric:'none',value:0,\nstatement:'uniform sample: each element included with probability capacity/n; sample statistics are unbiased estimators',\n});\n}\nget seen(){return this.#seen;}\nget size(){return this.#items.length;}\nadd(x){\nif(!Number.isFinite(x))return;\nthis.#seen++;\nif(this.#items.length<this.#capacity){\nthis.#items.push(x);\nreturn;\n}\nconst j=Math.floor(this.#rng()*this.#seen);\nif(j<this.#capacity)this.#items[j]=x;\n}\nsample(){return this.#items.slice();}\nmean(){\nif(!this.#items.length)return null;\nlet s=0;\nfor(const v of this.#items)s+=v;\nreturn s/this.#items.length;\n}\nquantile(p){\nconst n=this.#items.length;\nif(!n)return null;\nconst sorted=this.#items.slice().sort((a,b)=>a-b);\nif(n===1)return sorted[0];\nconst h=(n-1)*Math.min(1,Math.max(0,p));\nconst lo=Math.floor(h);\nconst hi=Math.ceil(h);\nreturn lo===hi?sorted[lo]:sorted[lo]+(h-lo)*(sorted[hi]-sorted[lo]);\n}\n}\nfunction fmix32(h){\nh^=h>>>16;\nh=Math.imul(h,0x85ebca6b);\nh^=h>>>13;\nh=Math.imul(h,0xc2b2ae35);\nh^=h>>>15;\nreturn h>>>0;\n}\nfunction hash32(v){\nif(typeof v==='number'){\nconst buf=new DataView(new ArrayBuffer(8));\nbuf.setFloat64(0,v===0?0:v);\nreturn fmix32(buf.getUint32(0)^buf.getUint32(4));\n}\nconst s=typeof v==='string'?v:String(v);\nlet h=0x811c9dc5;\nfor(let i=0;i<s.length;i++){\nh^=s.charCodeAt(i);\nh=Math.imul(h,0x01000193);\n}\nreturn fmix32(h);\n}\nclass HyperLogLog{\n#p;\n#m;\n#registers;\nconstructor(precision=14){\nconst p=Math.floor(precision);\nif(p<4||p>16)throw new RangeError('HLL precision must be 4..16');\nthis.#p=p;\nthis.#m=1<<p;\nthis.#registers=new Uint8Array(this.#m);\n}\nstatic errorBoundFor(precision=14){\nconst m=1<<Math.floor(precision);\nconst rse=1.04/Math.sqrt(m);\nreturn Object.freeze({\nkind:'probabilistic',metric:'relative',value:rse,\nstatement:`distinct count within ~${(rse*100).toFixed(2)}% relative standard error (m=${m} buckets)`,\n});\n}\nerrorBound(){return HyperLogLog.errorBoundFor(this.#p);}\nadd(v){\nconst h=hash32(v);\nconst idx=h&(this.#m-1);\nconst rest=(h>>>this.#p)|(1<<(32-this.#p));\nlet rank=1;\nlet x=rest;\nwhile((x&1)===0){rank++;x>>>=1;}\nif(rank>this.#registers[idx])this.#registers[idx]=rank;\n}\ncount(){\nconst m=this.#m;\nconst q=32-this.#p;\nconst hist=new Float64Array(q+2);\nfor(let i=0;i<m;i++)hist[this.#registers[i]]++;\nlet z=m*tau(1-hist[q+1]/m);\nfor(let k=q;k>=1;k--)z=0.5*(z+hist[k]);\nz+=m*sigma(hist[0]/m);\nconst estimate=(ERTL_ALPHA_INF*m*m)/z;\nreturn Math.round(estimate);\n}\n}\nconst ERTL_ALPHA_INF=0.5/Math.log(2);\nfunction sigma(x){\nif(x===1)return Infinity;\nlet y=1;\nlet z=x;\nlet prev;\ndo{\nx*=x;\nprev=z;\nz+=x*y;\ny+=y;\n}while(z!==prev);\nreturn z;\n}\nfunction tau(x){\nif(x===0||x===1)return 0;\nlet y=1;\nlet z=1-x;\nlet prev;\ndo{\nx=Math.sqrt(x);\nprev=z;\ny*=0.5;\nz-=(1-x)**2*y;\n}while(z!==prev);\nreturn z/3;\n}\nclass SpaceSaving{\n#counters=new Map();\n#capacity;\n#n=0;\nconstructor(capacity){\nif(!(capacity>0))throw new RangeError('Space-Saving capacity must be positive');\nthis.#capacity=Math.floor(capacity);\n}\nerrorBoundFor(n){\nconst value=n/this.#capacity;\nreturn Object.freeze({\nkind:'deterministic',metric:'absolute',value,\nstatement:`each count overestimates the truth by at most N/m = ${value.toFixed(2)} (N=${n}, m=${this.#capacity})`,\n});\n}\nget seen(){return this.#n;}\nadd(item){\nthis.#n++;\nconst existing=this.#counters.get(item);\nif(existing){existing.count++;return;}\nif(this.#counters.size<this.#capacity){\nthis.#counters.set(item,{count:1,error:0});\nreturn;\n}\nlet minItem;\nlet minCount=Infinity;\nfor(const[k,v]of this.#counters){\nif(v.count<minCount){minCount=v.count;minItem=k;}\n}\nthis.#counters.delete(minItem);\nthis.#counters.set(item,{count:minCount+1,error:minCount});\n}\ntop(k=this.#capacity){\nconst all=[...this.#counters.entries()]\n.map(([item,v])=>({item,count:v.count,error:v.error}))\n.sort((a,b)=>b.count-a.count);\nreturn all.slice(0,Math.max(0,Math.floor(k)));\n}\n}\nclass KLL{\n#k;\n#levels=[[]];\n#n=0;\n#rng;\n#capacityFactor;\nconstructor(k=200,rng=Math.random){\nthis.#k=Math.max(8,Math.floor(k));\nthis.#rng=rng;\nthis.#capacityFactor=2/3;\n}\nstatic errorBoundFor(k=200){\nconst eps=1/Math.max(8,Math.floor(k));\nreturn Object.freeze({\nkind:'probabilistic',metric:'rank',value:eps,\nstatement:`queried quantile's true rank within ~${(eps*100).toFixed(2)}% of N of the requested rank (k=${k})`,\n});\n}\nerrorBound(){return KLL.errorBoundFor(this.#k);}\nget count(){return this.#n;}\n#levelCapacity(height){\nconst top=this.#levels.length-1;\nconst depthFromTop=top-height;\nconst cap=Math.ceil(this.#k*this.#capacityFactor**depthFromTop);\nreturn Math.max(2,cap);\n}\nadd(x){\nif(!Number.isFinite(x))return;\nthis.#n++;\nthis.#levels[0].push(x);\nif(this.#levels[0].length>=this.#levelCapacity(0))this.#compact(0);\n}\n#compact(height){\nconst level=this.#levels[height];\nlevel.sort((a,b)=>a-b);\nif(height+1>=this.#levels.length)this.#levels.push([]);\nconst up=this.#levels[height+1];\nconst offset=this.#rng()<0.5?0:1;\nfor(let i=offset;i<level.length;i+=2)up.push(level[i]);\nthis.#levels[height]=[];\nfor(let h=0;h<this.#levels.length;h++){\nif(this.#levels[h].length>=this.#levelCapacity(h)){this.#compact(h);return;}\n}\n}\n#weighted(){\nconst out=[];\nfor(let h=0;h<this.#levels.length;h++){\nconst w=1<<h;\nfor(const v of this.#levels[h])out.push({v,w});\n}\nreturn out;\n}\nquantile(p){\nconst items=this.#weighted();\nif(!items.length)return null;\nitems.sort((a,b)=>a.v-b.v);\nlet totalW=0;\nfor(const it of items)totalW+=it.w;\nconst target=Math.min(1,Math.max(0,p))*totalW;\nlet cum=0;\nfor(const it of items){\ncum+=it.w;\nif(cum>=target)return it.v;\n}\nreturn items[items.length-1].v;\n}\nrank(x){\nlet cum=0;\nfor(let h=0;h<this.#levels.length;h++){\nconst w=1<<h;\nfor(const v of this.#levels[h])if(v<=x)cum+=w;\n}\nreturn cum;\n}\n}\nconst SKETCH_BOUNDS=Object.freeze({\ndistinct:HyperLogLog.errorBoundFor(14),\nmedian:KLL.errorBoundFor(200),\np25:KLL.errorBoundFor(200),\np75:KLL.errorBoundFor(200),\np90:KLL.errorBoundFor(200),\np95:KLL.errorBoundFor(200),\np99:KLL.errorBoundFor(200),\niqr:KLL.errorBoundFor(200),\ntopK:Object.freeze({\nkind:'deterministic',metric:'absolute',value:0,\nstatement:'each count overestimates the truth by at most N/m; top-K exact when the K-th item exceeds N/m',\n}),\n});\nconst __default={\nWelford,Reservoir,HyperLogLog,SpaceSaving,KLL,hash32,SKETCH_BOUNDS,\n};\n});\n__def(\"packages/core/src/compute/statistics.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"KENDALL_LIMIT\",{enumerable:true,get:function(){return KENDALL_LIMIT;}});\nObject.defineProperty(__exports,\"MAINTENANCE\",{enumerable:true,get:function(){return MAINTENANCE;}});\nObject.defineProperty(__exports,\"APPROXIMATE\",{enumerable:true,get:function(){return APPROXIMATE;}});\nObject.defineProperty(__exports,\"maintenanceOf\",{enumerable:true,get:function(){return maintenanceOf;}});\nObject.defineProperty(__exports,\"numbers\",{enumerable:true,get:function(){return numbers;}});\nObject.defineProperty(__exports,\"frequencies\",{enumerable:true,get:function(){return frequencies;}});\nObject.defineProperty(__exports,\"herfindahl\",{enumerable:true,get:function(){return herfindahl;}});\nObject.defineProperty(__exports,\"entropy\",{enumerable:true,get:function(){return entropy;}});\nObject.defineProperty(__exports,\"evenness\",{enumerable:true,get:function(){return evenness;}});\nObject.defineProperty(__exports,\"topShare\",{enumerable:true,get:function(){return topShare;}});\nObject.defineProperty(__exports,\"gini\",{enumerable:true,get:function(){return gini;}});\nObject.defineProperty(__exports,\"moments\",{enumerable:true,get:function(){return moments;}});\nObject.defineProperty(__exports,\"quantileSorted\",{enumerable:true,get:function(){return quantileSorted;}});\nObject.defineProperty(__exports,\"quantile\",{enumerable:true,get:function(){return quantile;}});\nObject.defineProperty(__exports,\"STAT_FNS\",{enumerable:true,get:function(){return STAT_FNS;}});\nObject.defineProperty(__exports,\"STAT_LABELS\",{enumerable:true,get:function(){return STAT_LABELS;}});\nObject.defineProperty(__exports,\"weightedAverage\",{enumerable:true,get:function(){return weightedAverage;}});\nObject.defineProperty(__exports,\"extremeRow\",{enumerable:true,get:function(){return extremeRow;}});\nObject.defineProperty(__exports,\"correlation\",{enumerable:true,get:function(){return correlation;}});\nObject.defineProperty(__exports,\"trimmedMean\",{enumerable:true,get:function(){return trimmedMean;}});\nObject.defineProperty(__exports,\"winsorizedMean\",{enumerable:true,get:function(){return winsorizedMean;}});\nObject.defineProperty(__exports,\"modifiedZOutliers\",{enumerable:true,get:function(){return modifiedZOutliers;}});\nObject.defineProperty(__exports,\"jarqueBera\",{enumerable:true,get:function(){return jarqueBera;}});\nObject.defineProperty(__exports,\"weightedQuantile\",{enumerable:true,get:function(){return weightedQuantile;}});\nObject.defineProperty(__exports,\"pairs\",{enumerable:true,get:function(){return pairs;}});\nObject.defineProperty(__exports,\"covariance\",{enumerable:true,get:function(){return covariance;}});\nObject.defineProperty(__exports,\"regression\",{enumerable:true,get:function(){return regression;}});\nObject.defineProperty(__exports,\"fitLinearModel\",{enumerable:true,get:function(){return fitLinearModel;}});\nObject.defineProperty(__exports,\"ADF_CT_CRITICAL\",{enumerable:true,get:function(){return ADF_CT_CRITICAL;}});\nObject.defineProperty(__exports,\"augmentedDickeyFuller\",{enumerable:true,get:function(){return augmentedDickeyFuller;}});\nObject.defineProperty(__exports,\"autocorrelations\",{enumerable:true,get:function(){return autocorrelations;}});\nObject.defineProperty(__exports,\"spearman\",{enumerable:true,get:function(){return spearman;}});\nObject.defineProperty(__exports,\"kendall\",{enumerable:true,get:function(){return kendall;}});\nObject.defineProperty(__exports,\"seriesStats\",{enumerable:true,get:function(){return seriesStats;}});\nObject.defineProperty(__exports,\"D2_N2\",{enumerable:true,get:function(){return D2_N2;}});\nObject.defineProperty(__exports,\"D4_N2\",{enumerable:true,get:function(){return D4_N2;}});\nObject.defineProperty(__exports,\"movingRanges\",{enumerable:true,get:function(){return movingRanges;}});\nObject.defineProperty(__exports,\"withinSigma\",{enumerable:true,get:function(){return withinSigma;}});\nObject.defineProperty(__exports,\"capability\",{enumerable:true,get:function(){return capability;}});\nObject.defineProperty(__exports,\"controlLimits\",{enumerable:true,get:function(){return controlLimits;}});\nObject.defineProperty(__exports,\"westernElectricViolations\",{enumerable:true,get:function(){return westernElectricViolations;}});\nObject.defineProperty(__exports,\"nelsonViolations\",{enumerable:true,get:function(){return nelsonViolations;}});\nObject.defineProperty(__exports,\"CONTROL_RULE_SETS\",{enumerable:true,get:function(){return CONTROL_RULE_SETS;}});\nObject.defineProperty(__exports,\"controlViolations\",{enumerable:true,get:function(){return controlViolations;}});\nObject.defineProperty(__exports,\"countOutside\",{enumerable:true,get:function(){return countOutside;}});\nObject.defineProperty(__exports,\"histogram\",{enumerable:true,get:function(){return histogram;}});\nObject.defineProperty(__exports,\"DEFAULT_CONFIDENCE\",{enumerable:true,get:function(){return DEFAULT_CONFIDENCE;}});\nObject.defineProperty(__exports,\"meanInterval\",{enumerable:true,get:function(){return meanInterval;}});\nObject.defineProperty(__exports,\"proportionInterval\",{enumerable:true,get:function(){return proportionInterval;}});\nObject.defineProperty(__exports,\"slopeInterval\",{enumerable:true,get:function(){return slopeInterval;}});\nObject.defineProperty(__exports,\"capabilityInterval\",{enumerable:true,get:function(){return capabilityInterval;}});\nObject.defineProperty(__exports,\"standardizedMeanDifference\",{enumerable:true,get:function(){return standardizedMeanDifference;}});\nObject.defineProperty(__exports,\"normalTotalVariation\",{enumerable:true,get:function(){return normalTotalVariation;}});\nObject.defineProperty(__exports,\"frequencyMap\",{enumerable:true,get:function(){return frequencyMap;}});\nObject.defineProperty(__exports,\"categoricalDistance\",{enumerable:true,get:function(){return categoricalDistance;}});\nObject.defineProperty(__exports,\"SUBSET_RELIABILITY_FLOOR\",{enumerable:true,get:function(){return SUBSET_RELIABILITY_FLOOR;}});\nObject.defineProperty(__exports,\"compareColumn\",{enumerable:true,get:function(){return compareColumn;}});\nObject.defineProperty(__exports,\"isNumericColumn\",{enumerable:true,get:function(){return isNumericColumn;}});\nObject.defineProperty(__exports,\"populationRead\",{enumerable:true,get:function(){return populationRead;}});\nconst __m0=__req(\"packages/core/src/compute/handle.js\");\nconst presenceReader=__m0[\"presenceReader\"];\nconst valueReader=__m0[\"valueReader\"];\nconst __m1=__req(\"packages/core/src/compute/special.js\");\nconst studentTQuantile=__m1[\"studentTQuantile\"];\nconst studentT=__m1[\"studentT\"];\nconst normalQuantile=__m1[\"normalQuantile\"];\nconst normalCdf=__m1[\"normalCdf\"];\nconst chiSquareUpperTail=__m1[\"chiSquareUpperTail\"];\nconst __m2=__req(\"packages/core/src/compute/linalg.js\");\nconst cholesky=__m2[\"cholesky\"];\nconst choleskySolve=__m2[\"choleskySolve\"];\nconst choleskyInverse=__m2[\"choleskyInverse\"];\nconst normalEquations=__m2[\"normalEquations\"];\nconst quadForm=__m2[\"quadForm\"];\nconst __m3=__req(\"packages/core/src/compute/sketch.js\");\nconst SKETCH_BOUNDS=__m3[\"SKETCH_BOUNDS\"];\nconst KENDALL_LIMIT=5000;\nconst MAINTENANCE=Object.freeze({\nvariance:'rescan',\nvarianceP:'rescan',\nstddev:'rescan',\nstddevP:'rescan',\nsumSquares:'rescan',\nweightedAvg:'rescan',\nmedian:'rescan',\np25:'rescan',\np75:'rescan',\np90:'rescan',\np95:'rescan',\np99:'rescan',\niqr:'rescan',\nmode:'rescan',\ndistinct:'rescan',\nrange:'rescan',\nskewness:'rescan',\nkurtosis:'rescan',\ngeomean:'rescan',\nharmean:'rescan',\nmad:'rescan',\nargmin:'rescan',\nargmax:'rescan',\nhhi:'rescan',\nentropy:'rescan',\nevenness:'rescan',\ntop3Share:'rescan',\ntop10Share:'rescan',\ngini:'rescan',\ntrimmedMean:'rescan',\nwinsorizedMean:'rescan',\nrobustOutliers:'rescan',\njarqueBera:'rescan',\npassRate:'rescan',\nfailureCount:'rescan',\n});\nconst APPROXIMATE=Object.freeze({\ndistinct:Object.freeze({sketch:'HyperLogLog',bound:SKETCH_BOUNDS.distinct}),\nmedian:Object.freeze({sketch:'KLL',bound:SKETCH_BOUNDS.median}),\np25:Object.freeze({sketch:'KLL',bound:SKETCH_BOUNDS.p25}),\np75:Object.freeze({sketch:'KLL',bound:SKETCH_BOUNDS.p75}),\np90:Object.freeze({sketch:'KLL',bound:SKETCH_BOUNDS.p90}),\np95:Object.freeze({sketch:'KLL',bound:SKETCH_BOUNDS.p95}),\np99:Object.freeze({sketch:'KLL',bound:SKETCH_BOUNDS.p99}),\niqr:Object.freeze({sketch:'KLL',bound:SKETCH_BOUNDS.iqr}),\ntop3Share:Object.freeze({sketch:'SpaceSaving',bound:SKETCH_BOUNDS.topK}),\ntop10Share:Object.freeze({sketch:'SpaceSaving',bound:SKETCH_BOUNDS.topK}),\n});\nfunction maintenanceOf(fn){\nconst exact=fn==='sum'||fn==='avg'||fn==='countValues'||fn==='min'||fn==='max'\n?'maintained'\n:(Object.prototype.hasOwnProperty.call(MAINTENANCE,fn)?MAINTENANCE[fn]:null);\nconst approximate=Object.prototype.hasOwnProperty.call(APPROXIMATE,fn)?APPROXIMATE[fn]:null;\nreturn{stat:fn,exact,approximate};\n}\nfunction numbers(handle,indices){\nconst n=indices.length;\nconst out=new Float64Array(n);\nlet count=0;\nconst numeric=handle&&(handle.kind==='float64'||handle.kind==='int32');\nif(numeric){\nconst values=handle.values;\nconst present=presenceReader(handle);\nfor(let i=0;i<n;i++){\nconst row=indices[i];\nif(present&&present(row)!==1)continue;\nconst v=values[row];\nif(Number.isNaN(v))continue;\nout[count++]=v;\n}\nreturn out.subarray(0,count);\n}\nconst read=valueReader(handle);\nfor(let i=0;i<n;i++){\nconst raw=read(indices[i]);\nif(raw===null||raw===undefined||raw==='')continue;\nconst v=typeof raw==='number'?raw:Number(raw);\nif(!Number.isFinite(v))continue;\nout[count++]=v;\n}\nreturn out.subarray(0,count);\n}\nfunction frequencies(handle,indices){\nconst seen=new Map();\nconst read=valueReader(handle);\nlet total=0;\nfor(let i=0;i<indices.length;i++){\nconst raw=read(indices[i]);\nif(raw===null||raw===undefined||raw==='')continue;\nif(typeof raw==='number'&&Number.isNaN(raw))continue;\nconst key=typeof raw==='object'?String(raw):raw;\nseen.set(key,(seen.get(key)||0)+1);\ntotal++;\n}\nconst counts=[...seen.values()].sort((a,b)=>b-a);\nreturn{counts,total,distinct:counts.length};\n}\nfunction sharesOf(freq){\nreturn freq.total>0?freq.counts.map((c)=>c/freq.total):[];\n}\nfunction herfindahl(handle,indices){\nconst freq=frequencies(handle,indices);\nif(!freq.total)return null;\nlet sum=0;\nfor(const share of sharesOf(freq))sum+=share*share;\nreturn sum;\n}\nfunction entropy(handle,indices){\nconst freq=frequencies(handle,indices);\nif(!freq.total)return null;\nlet sum=0;\nfor(const share of sharesOf(freq))if(share>0)sum-=share*Math.log2(share);\nreturn sum;\n}\nfunction evenness(handle,indices){\nconst freq=frequencies(handle,indices);\nif(!freq.total||freq.distinct<2)return freq.total?1:null;\nlet sum=0;\nfor(const share of sharesOf(freq))if(share>0)sum-=share*Math.log2(share);\nreturn sum/Math.log2(freq.distinct);\n}\nfunction topShare(handle,indices,n=3){\nconst freq=frequencies(handle,indices);\nif(!freq.total)return null;\nconst take=Math.max(1,Math.floor(n));\nlet held=0;\nfor(let i=0;i<Math.min(take,freq.counts.length);i++)held+=freq.counts[i];\nreturn held/freq.total;\n}\nfunction gini(handle,indices){\nconst values=numbers(handle,indices);\nconst n=values.length;\nif(!n)return null;\nconst sorted=values.slice().sort();\nif(sorted[0]<0)return null;\nlet total=0;\nlet weighted=0;\nfor(let i=0;i<n;i++){\ntotal+=sorted[i];\nweighted+=(i+1)*sorted[i];\n}\nif(total===0)return 0;\nreturn(2*weighted)/(n*total)-(n+1)/n;\n}\nfunction moments(values){\nlet n=0;\nlet mean=0;\nlet m2=0;\nfor(let i=0;i<values.length;i++){\nconst x=values[i];\nn++;\nconst delta=x-mean;\nmean+=delta/n;\nm2+=delta*(x-mean);\n}\nreturn{n,mean,m2};\n}\nfunction quantileSorted(sorted,p){\nconst n=sorted.length;\nif(!n)return NaN;\nif(n===1)return sorted[0];\nconst h=(n-1)*Math.min(1,Math.max(0,p));\nconst lo=Math.floor(h);\nconst hi=Math.ceil(h);\nif(lo===hi)return sorted[lo];\nreturn sorted[lo]+(h-lo)*(sorted[hi]-sorted[lo]);\n}\nfunction quantile(values,p){\nif(!values.length)return NaN;\nconst sorted=values.slice().sort();\nreturn quantileSorted(sorted,p);\n}\nfunction specTally(handle,indices){\nconst read=valueReader(handle);\nlet pass=0;\nlet fail=0;\nlet warn=0;\nfor(let k=0;k<indices.length;k++){\nconst raw=read(indices[k]);\nif(raw===null||raw===undefined||raw==='')continue;\nconst token=String(raw).toUpperCase();\nif(token==='PASS')pass++;\nelse if(token==='FAIL')fail++;\nelse if(token==='WARN')warn++;\n}\nreturn{pass:pass+warn,fail,warn,judged:pass+warn+fail};\n}\nconst STAT_FNS=Object.freeze({\nhhi:(h,i)=>herfindahl(h,i),\nentropy:(h,i)=>entropy(h,i),\nevenness:(h,i)=>evenness(h,i),\ntop3Share:(h,i)=>topShare(h,i,3),\ntop10Share:(h,i)=>topShare(h,i,10),\ngini:(h,i)=>gini(h,i),\ntrimmedMean:(h,i)=>trimmedMean(numbers(h,i),0.1),\nwinsorizedMean:(h,i)=>winsorizedMean(numbers(h,i),0.1),\nrobustOutliers:(h,i)=>modifiedZOutliers(numbers(h,i),3.5),\njarqueBera:(h,i)=>jarqueBera(numbers(h,i)),\nvariance:(h,i)=>{\nconst{n,m2}=moments(numbers(h,i));\nreturn n>1?m2/(n-1):null;\n},\nvarianceP:(h,i)=>{\nconst{n,m2}=moments(numbers(h,i));\nreturn n>0?m2/n:null;\n},\nstddev:(h,i)=>{\nconst{n,m2}=moments(numbers(h,i));\nreturn n>1?Math.sqrt(m2/(n-1)):null;\n},\nstddevP:(h,i)=>{\nconst{n,m2}=moments(numbers(h,i));\nreturn n>0?Math.sqrt(m2/n):null;\n},\nmedian:(h,i)=>{\nconst values=numbers(h,i);\nreturn values.length?quantile(values,0.5):null;\n},\np25:(h,i)=>{\nconst values=numbers(h,i);\nreturn values.length?quantile(values,0.25):null;\n},\np75:(h,i)=>{\nconst values=numbers(h,i);\nreturn values.length?quantile(values,0.75):null;\n},\np90:(h,i)=>{\nconst values=numbers(h,i);\nreturn values.length?quantile(values,0.9):null;\n},\np95:(h,i)=>{\nconst values=numbers(h,i);\nreturn values.length?quantile(values,0.95):null;\n},\np99:(h,i)=>{\nconst values=numbers(h,i);\nreturn values.length?quantile(values,0.99):null;\n},\niqr:(h,i)=>{\nconst values=numbers(h,i);\nif(!values.length)return null;\nconst sorted=values.slice().sort();\nreturn quantileSorted(sorted,0.75)-quantileSorted(sorted,0.25);\n},\nmad:(h,i)=>{\nconst values=numbers(h,i);\nif(!values.length)return null;\nconst middle=quantile(values,0.5);\nconst deviations=new Float64Array(values.length);\nfor(let k=0;k<values.length;k++)deviations[k]=Math.abs(values[k]-middle);\nreturn quantile(deviations,0.5);\n},\nrange:(h,i)=>{\nconst values=numbers(h,i);\nif(!values.length)return null;\nlet lo=Infinity;\nlet hi=-Infinity;\nfor(let k=0;k<values.length;k++){\nif(values[k]<lo)lo=values[k];\nif(values[k]>hi)hi=values[k];\n}\nreturn hi-lo;\n},\ndistinct:(h,i)=>{\nconst read=valueReader(h);\nconst seen=new Set();\nfor(let k=0;k<i.length;k++){\nconst v=read(i[k]);\nif(v===null||v===undefined||v==='')continue;\nseen.add(v instanceof Date?v.getTime():v);\n}\nreturn seen.size;\n},\nmode:(h,i)=>{\nconst read=valueReader(h);\nconst counts=new Map();\nfor(let k=0;k<i.length;k++){\nconst v=read(i[k]);\nif(v===null||v===undefined||v==='')continue;\nconst id=v instanceof Date?v.getTime():v;\ncounts.set(id,(counts.get(id)||0)+1);\n}\nlet best=null;\nlet most=1;\nfor(const[value,times]of counts){\nif(times>most){\nmost=times;\nbest=value;\n}\n}\nreturn best;\n},\nskewness:(h,i)=>{\nconst values=numbers(h,i);\nconst{n,mean,m2}=moments(values);\nif(n<3||m2<=0)return null;\nconst sd=Math.sqrt(m2/(n-1));\nlet sum=0;\nfor(let k=0;k<values.length;k++)sum+=((values[k]-mean)/sd)**3;\nreturn(n/((n-1)*(n-2)))*sum;\n},\nkurtosis:(h,i)=>{\nconst values=numbers(h,i);\nconst{n,mean,m2}=moments(values);\nif(n<4||m2<=0)return null;\nconst sd=Math.sqrt(m2/(n-1));\nlet sum=0;\nfor(let k=0;k<values.length;k++)sum+=((values[k]-mean)/sd)**4;\nconst a=(n*(n+1))/((n-1)*(n-2)*(n-3));\nconst b=(3*(n-1)**2)/((n-2)*(n-3));\nreturn a*sum-b;\n},\ngeomean:(h,i)=>{\nconst values=numbers(h,i);\nif(!values.length)return null;\nlet sum=0;\nfor(let k=0;k<values.length;k++){\nif(values[k]<=0)return null;\nsum+=Math.log(values[k]);\n}\nreturn Math.exp(sum/values.length);\n},\nharmean:(h,i)=>{\nconst values=numbers(h,i);\nif(!values.length)return null;\nlet sum=0;\nfor(let k=0;k<values.length;k++){\nif(values[k]===0)return null;\nsum+=1/values[k];\n}\nreturn values.length/sum;\n},\nsumSquares:(h,i)=>{\nconst values=numbers(h,i);\nlet sum=0;\nfor(let k=0;k<values.length;k++)sum+=values[k]*values[k];\nreturn sum;\n},\npassRate:(h,i)=>{\nconst{pass,judged}=specTally(h,i);\nreturn judged?pass/judged:null;\n},\nfailureCount:(h,i)=>specTally(h,i).fail,\n});\nconst STAT_LABELS=Object.freeze({\nhhi:'Concentration (HHI)',\nentropy:'Entropy',\nevenness:'Evenness',\ntop3Share:'Top 3 share',\ntop10Share:'Top 10 share',\ngini:'Gini coefficient',\ntrimmedMean:'Trimmed mean',\nwinsorizedMean:'Winsorized mean',\nrobustOutliers:'Outliers (robust)',\njarqueBera:'Jarque–Bera',\nmedian:'Median',\np25:'25th percentile',\np75:'75th percentile',\np90:'90th percentile',\np95:'95th percentile',\np99:'99th percentile',\niqr:'Interquartile range',\nmad:'Median absolute deviation',\nvariance:'Variance',\nvarianceP:'Variance (population)',\nstddev:'Standard deviation',\nstddevP:'Standard deviation (population)',\nrange:'Range',\ndistinct:'Distinct',\nmode:'Mode',\nskewness:'Skewness',\nkurtosis:'Kurtosis',\ngeomean:'Geometric mean',\nharmean:'Harmonic mean',\nsumSquares:'Sum of squares',\nweightedAvg:'Weighted average',\nargmin:'Lowest by',\nargmax:'Highest by',\npassRate:'Pass rate',\nfailureCount:'Failures',\n});\nfunction weightedAverage(handle,weights,indices){\nconst readValue=valueReader(handle);\nconst readWeight=valueReader(weights);\nlet top=0;\nlet bottom=0;\nfor(let i=0;i<indices.length;i++){\nconst row=indices[i];\nconst value=Number(readValue(row));\nconst weight=Number(readWeight(row));\nif(!Number.isFinite(value)||!Number.isFinite(weight))continue;\ntop+=value*weight;\nbottom+=weight;\n}\nreturn bottom===0?null:top/bottom;\n}\nfunction extremeRow(handle,indices,largest){\nconst read=valueReader(handle);\nlet best=null;\nlet bestValue=largest?-Infinity:Infinity;\nfor(let i=0;i<indices.length;i++){\nconst row=indices[i];\nconst value=Number(read(row));\nif(!Number.isFinite(value))continue;\nif(largest?value>bestValue:value<bestValue){\nbestValue=value;\nbest=row;\n}\n}\nreturn best;\n}\nfunction correlation(a,b,indices){\nconst readA=valueReader(a);\nconst readB=valueReader(b);\nlet n=0;\nlet sx=0;\nlet sy=0;\nlet sxx=0;\nlet syy=0;\nlet sxy=0;\nfor(let i=0;i<indices.length;i++){\nconst row=indices[i];\nconst x=Number(readA(row));\nconst y=Number(readB(row));\nif(!Number.isFinite(x)||!Number.isFinite(y))continue;\nn++;\nsx+=x;\nsy+=y;\nsxx+=x*x;\nsyy+=y*y;\nsxy+=x*y;\n}\nif(n<2)return null;\nconst top=n*sxy-sx*sy;\nconst bottom=Math.sqrt((n*sxx-sx*sx)*(n*syy-sy*sy));\nif(bottom===0)return null;\nconst r=top/bottom;\nreturn Math.max(-1,Math.min(1,r));\n}\nfunction trimmedMean(values,share=0.1){\nconst n=values.length;\nif(!n)return null;\nconst sorted=Array.from(values).sort((a,b)=>a-b);\nconst cut=Math.floor(n*Math.min(0.49,Math.max(0,share)));\nconst kept=sorted.slice(cut,n-cut);\nif(!kept.length)return quantileSorted(sorted,0.5);\nlet sum=0;\nfor(const v of kept)sum+=v;\nreturn sum/kept.length;\n}\nfunction winsorizedMean(values,share=0.1){\nconst n=values.length;\nif(!n)return null;\nconst sorted=Array.from(values).sort((a,b)=>a-b);\nconst cut=Math.floor(n*Math.min(0.49,Math.max(0,share)));\nconst low=sorted[cut];\nconst high=sorted[n-1-cut];\nlet sum=0;\nfor(const v of sorted)sum+=Math.min(high,Math.max(low,v));\nreturn sum/n;\n}\nfunction modifiedZOutliers(values,threshold=3.5){\nconst n=values.length;\nif(!n)return null;\nconst sorted=Array.from(values).sort((a,b)=>a-b);\nconst middle=quantileSorted(sorted,0.5);\nconst deviations=sorted.map((v)=>Math.abs(v-middle)).sort((a,b)=>a-b);\nconst mad=quantileSorted(deviations,0.5);\nif(mad===0)return null;\nlet count=0;\nfor(const v of sorted)if(Math.abs((0.6745*(v-middle))/mad)>threshold)count++;\nreturn count;\n}\nfunction jarqueBera(values){\nconst n=values.length;\nif(n<8)return null;\nlet mean=0;\nfor(const v of values)mean+=v;\nmean/=n;\nlet m2=0;\nlet m3=0;\nlet m4=0;\nfor(const v of values){\nconst d=v-mean;\nm2+=d*d;\nm3+=d*d*d;\nm4+=d*d*d*d;\n}\nm2/=n;\nm3/=n;\nm4/=n;\nif(m2===0)return null;\nconst skew=m3/m2**1.5;\nconst excess=m4/(m2*m2)-3;\nreturn(n/6)*(skew*skew+(excess*excess)/4);\n}\nfunction weightedQuantile(values,weights,p){\nconst paired=[];\nlet total=0;\nfor(let i=0;i<values.length;i++){\nconst v=Number(values[i]);\nconst w=Number(weights[i]);\nif(!Number.isFinite(v)||!Number.isFinite(w)||w<=0)continue;\npaired.push([v,w]);\ntotal+=w;\n}\nif(!paired.length||total<=0)return null;\npaired.sort((a,b)=>a[0]-b[0]);\nif(paired.length===1)return paired[0][0];\nconst at=[];\nlet seen=0;\nfor(const[,w]of paired){\nat.push((seen+w/2)/total);\nseen+=w;\n}\nconst target=Math.max(0,Math.min(1,p));\nif(target<=at[0])return paired[0][0];\nif(target>=at[at.length-1])return paired[paired.length-1][0];\nfor(let i=1;i<at.length;i++){\nif(target>at[i])continue;\nconst span=at[i]-at[i-1];\nconst within=span>0?(target-at[i-1])/span:0;\nreturn paired[i-1][0]+(paired[i][0]-paired[i-1][0])*within;\n}\nreturn paired[paired.length-1][0];\n}\nfunction pairs(a,b,indices){\nconst readA=valueReader(a);\nconst readB=valueReader(b);\nconst xs=new Float64Array(indices.length);\nconst ys=new Float64Array(indices.length);\nlet n=0;\nfor(let i=0;i<indices.length;i++){\nconst row=indices[i];\nconst x=Number(readA(row));\nconst y=Number(readB(row));\nif(!Number.isFinite(x)||!Number.isFinite(y))continue;\nxs[n]=x;\nys[n]=y;\nn++;\n}\nreturn{xs:xs.subarray(0,n),ys:ys.subarray(0,n),n};\n}\nfunction covariance(a,b,indices,population=false){\nconst{xs,ys,n}=pairs(a,b,indices);\nif(n<2)return null;\nlet mx=0;\nlet my=0;\nfor(let i=0;i<n;i++){mx+=xs[i];my+=ys[i];}\nmx/=n;\nmy/=n;\nlet sum=0;\nfor(let i=0;i<n;i++)sum+=(xs[i]-mx)*(ys[i]-my);\nreturn sum/(population?n:n-1);\n}\nfunction regression(a,b,indices){\nconst{xs,ys,n}=pairs(a,b,indices);\nif(n<2)return null;\nlet mx=0;\nlet my=0;\nfor(let i=0;i<n;i++){mx+=xs[i];my+=ys[i];}\nmx/=n;\nmy/=n;\nlet sxx=0;\nlet sxy=0;\nlet syy=0;\nfor(let i=0;i<n;i++){\nconst dx=xs[i]-mx;\nconst dy=ys[i]-my;\nsxx+=dx*dx;\nsxy+=dx*dy;\nsyy+=dy*dy;\n}\nif(sxx===0)return null;\nconst slope=sxy/sxx;\nconst intercept=my-slope*mx;\nconst r2=syy===0?1:Math.max(0,Math.min(1,(sxy*sxy)/(sxx*syy)));\nconst residual=Math.max(0,syy-slope*sxy);\nconst stdError=n>2?Math.sqrt(residual/(n-2)/sxx):0;\nreturn{slope,intercept,r2,stdError,n};\n}\nconst SUPPORTED_METHODS=new Set(['ols','wls','robust']);\nconst DEFERRED_METHODS=new Set(['quantile']);\nconst OUT_OF_SCOPE_METHODS=new Set(['ridge','lasso','elasticnet','mixed','gls']);\nconst HUBER_C=1.345;\nfunction solveWls(design,y,w){\nconst{xtwx,xtwy}=normalEquations(design,y,w);\nconst l=cholesky(xtwx);\nif(!l)return null;\nconst beta=choleskySolve(l,xtwy);\nconst cov=choleskyInverse(l);\nconst fitted=matVecRows(design,beta);\nconst residuals=y.map((yi,i)=>yi-fitted[i]);\nreturn{beta,cov,fitted,residuals};\n}\nfunction matVecRows(rows,v){\nreturn rows.map((row)=>row.reduce((sum,cell,j)=>sum+cell*v[j],0));\n}\nfunction auxiliaryR2(predictors,j){\nconst n=predictors.length;\nconst y=predictors.map((row)=>row[j]);\nconst design=predictors.map((row)=>[1,...row.filter((unused,c)=>c!==j)]);\nconst fit=solveWls(design,y,null);\nif(!fit)return 1;\nconst ybar=y.reduce((s,v)=>s+v,0)/n;\nlet rss=0;\nlet tss=0;\nfor(let i=0;i<n;i++){rss+=fit.residuals[i]**2;tss+=(y[i]-ybar)**2;}\nif(tss===0)return 1;\nreturn Math.max(0,Math.min(1,1-rss/tss));\n}\nfunction madScale(values){\nconst sorted=[...values].sort((a,b)=>a-b);\nconst med=medianOfSorted(sorted);\nconst dev=values.map((v)=>Math.abs(v-med)).sort((a,b)=>a-b);\nreturn medianOfSorted(dev)/0.6745;\n}\nfunction medianOfSorted(sorted){\nconst n=sorted.length;\nif(!n)return 0;\nconst mid=Math.floor(n/2);\nreturn n%2?sorted[mid]:(sorted[mid-1]+sorted[mid])/2;\n}\nfunction fitLinearModel(matrix,y,opts={}){\nconst method=opts.method||'ols';\nif(OUT_OF_SCOPE_METHODS.has(method)){\nthrow new Error(`[lattice] regression method \"${method}\" is out of scope; use ols, wls or robust.`);\n}\nif(DEFERRED_METHODS.has(method)){\nthrow new Error(`[lattice] quantile regression is coming next and not yet available; use ols, wls or robust.`);\n}\nif(!SUPPORTED_METHODS.has(method)){\nthrow new Error(`[lattice] unknown regression method \"${method}\"; use ols, wls or robust.`);\n}\nconst n=Array.isArray(y)?y.length:0;\nconst k=n&&Array.isArray(matrix[0])?matrix[0].length:0;\nconst p=k+1;\nif(!(n>p))return null;\nfor(let i=0;i<n;i++){\nif(!Number.isFinite(y[i]))return null;\nif(!Array.isArray(matrix[i])||matrix[i].length!==k)return null;\nfor(let j=0;j<k;j++)if(!Number.isFinite(matrix[i][j]))return null;\n}\nlet weights=null;\nif(method==='wls'){\nweights=opts.weights;\nif(!Array.isArray(weights)||weights.length!==n)return null;\nfor(let i=0;i<n;i++)if(!(weights[i]>0)||!Number.isFinite(weights[i]))return null;\n}\nconst design=matrix.map((row)=>[1,...row]);\nlet fit;\nlet robustWeights=null;\nif(method==='robust'){\nfit=solveWls(design,y,null);\nif(!fit)return null;\nfor(let iter=0;iter<50;iter++){\nconst scale=madScale(fit.residuals);\nif(!(scale>0))break;\nconst w=fit.residuals.map((r)=>{\nconst u=Math.abs(r/scale);\nreturn u<=HUBER_C?1:HUBER_C/u;\n});\nconst next=solveWls(design,y,w);\nif(!next)return null;\nconst moved=next.beta.reduce((m,b,j)=>Math.max(m,Math.abs(b-fit.beta[j])),0);\nfit=next;\nrobustWeights=w;\nif(moved<1e-10)break;\n}\n}else{\nfit=solveWls(design,y,weights);\nif(!fit)return null;\n}\nconst w=method==='robust'?robustWeights:weights;\nconst{beta,cov,fitted,residuals}=fit;\nlet rss=0;\nlet sw=0;\nlet swy=0;\nfor(let i=0;i<n;i++){\nconst wi=w?w[i]:1;\nrss+=wi*residuals[i]**2;\nsw+=wi;\nswy+=wi*y[i];\n}\nconst ybar=swy/sw;\nlet tss=0;\nfor(let i=0;i<n;i++){const wi=w?w[i]:1;tss+=wi*(y[i]-ybar)**2;}\nconst df=n-p;\nconst sigma2=rss/df;\nconst r2=tss===0?1:Math.max(0,Math.min(1,1-rss/tss));\nconst adjR2=1-(1-r2)*(n-1)/df;\nconst names=Array.isArray(opts.names)&&opts.names.length===k\n?opts.names:matrix[0].map((unused,j)=>`x${j+1}`);\nconst conf=level(opts.confidence);\nconst tCrit=df>0?studentTQuantile(1-(1-conf)/2,df):Infinity;\nconst coefficients=beta.map((estimate,j)=>{\nconst stdError=Math.sqrt(Math.max(0,sigma2*cov[j][j]));\nconst t=stdError>0?estimate/stdError:(estimate===0?0:Infinity);\nconst pv=Number.isFinite(t)?2*(1-studentT(Math.abs(t),df)):0;\nconst half=Number.isFinite(tCrit)?tCrit*stdError:null;\nreturn{\nname:j===0?'(intercept)':names[j-1],\nestimate,\nstdError,\nt,\np:Math.max(0,Math.min(1,pv)),\nlower:half===null?null:estimate-half,\nupper:half===null?null:estimate+half,\n};\n});\nconst leverage=new Array(n);\nconst cooksD=new Array(n);\nfor(let i=0;i<n;i++){\nconst wi=w?w[i]:1;\nconst h=Math.max(0,Math.min(1,wi*quadForm(design[i],cov)));\nleverage[i]=h;\nconst denom=(1-h)**2;\ncooksD[i]=(denom>0&&sigma2>0)\n?(residuals[i]**2/(p*sigma2))*(h/denom)\n:null;\n}\nconst vif=matrix[0].map((unused,j)=>{\nif(k<2)return 1;\nconst rj=auxiliaryR2(matrix,j);\nreturn rj>=1?Infinity:1/(1-rj);\n});\nlet hetero=null;\n{\nconst e2=residuals.map((r)=>r*r);\nconst aux=solveWls(design,e2,null);\nif(aux){\nconst e2bar=e2.reduce((s,v)=>s+v,0)/n;\nlet arss=0;\nlet atss=0;\nfor(let i=0;i<n;i++){arss+=aux.residuals[i]**2;atss+=(e2[i]-e2bar)**2;}\nconst auxR2=atss===0?0:Math.max(0,Math.min(1,1-arss/atss));\nconst statistic=n*auxR2;\nconst pv=chiSquareUpperTail(statistic,k);\nhetero={statistic,df:k,p:pv,heteroscedastic:pv<0.05};\n}\n}\nlet band=null;\nif(k===1){\nconst order=matrix.map((row,i)=>i).sort((i,j)=>matrix[i][0]-matrix[j][0]);\nband={\nconfidence:conf,\npoints:order.map((i)=>{\nconst xo=design[i];\nconst se=Math.sqrt(Math.max(0,sigma2*quadForm(xo,cov)));\nreturn{x:matrix[i][0],yhat:fitted[i],lower:fitted[i]-tCrit*se,upper:fitted[i]+tCrit*se};\n}),\n};\n}\nreturn{\nmethod,\ncoefficients,\nr2,\nadjR2,\nn,\ndf,\nsigma2,\nfitted,\nresiduals,\nleverage,\ncooksD,\nvif,\nheteroscedasticity:hetero,\nband,\nweights:w?[...w]:null,\n};\n}\nfunction ranksOf(values){\nconst n=values.length;\nconst order=Array.from({length:n},(unused,i)=>i)\n.sort((i,j)=>values[i]-values[j]);\nconst ranks=new Float64Array(n);\nlet i=0;\nwhile(i<n){\nlet j=i;\nwhile(j+1<n&&values[order[j+1]]===values[order[i]])j++;\nconst shared=(i+j)/2+1;\nfor(let k=i;k<=j;k++)ranks[order[k]]=shared;\ni=j+1;\n}\nreturn ranks;\n}\nconst ADF_CT_CRITICAL=Object.freeze({'1%':-3.9638,'5%':-3.4126,'10%':-3.1279});\nfunction adfInterpolatedP(stat){\nconst levels=[0.01,0.05,0.10];\nconst crit=[ADF_CT_CRITICAL['1%'],ADF_CT_CRITICAL['5%'],ADF_CT_CRITICAL['10%']];\nif(stat<=crit[0]){\nconst slope=(Math.log(levels[1])-Math.log(levels[0]))/(crit[1]-crit[0]);\nreturn Math.max(1e-4,Math.min(0.01,Math.exp(Math.log(levels[0])+slope*(stat-crit[0]))));\n}\nif(stat>=crit[2]){\nconst slope=(Math.log(levels[2])-Math.log(levels[1]))/(crit[2]-crit[1]);\nreturn Math.max(0.10,Math.min(0.999,Math.exp(Math.log(levels[2])+slope*(stat-crit[2]))));\n}\nconst i=stat<crit[1]?0:1;\nconst t=(stat-crit[i])/(crit[i+1]-crit[i]);\nreturn Math.exp(Math.log(levels[i])+t*(Math.log(levels[i+1])-Math.log(levels[i])));\n}\nfunction augmentedDickeyFuller(x,opts={}){\nconst series=[];\nfor(let i=0;i<x.length;i++){\nconst v=Number(x[i]);\nif(Number.isFinite(v))series.push(v);\n}\nconst n=series.length;\nconst m=n-1;\nif(n<8||m<6)return null;\nconst xdiff=new Array(m);\nfor(let i=0;i<m;i++)xdiff[i]=series[i+1]-series[i];\nlet maxlag=Number.isFinite(opts.maxlag)\n?Math.floor(opts.maxlag)\n:Math.ceil(12*(n/100)**0.25);\nmaxlag=Math.max(0,Math.min(maxlag,Math.floor((m-5)/2)));\nconst fit=(p,start)=>{\nconst rows=[];\nconst y=[];\nfor(let j=start;j<m;j++){\nconst row=[(j-start)+1,series[j]];\nfor(let d=1;d<=p;d++)row.push(xdiff[j-d]);\nrows.push(row);\ny.push(xdiff[j]);\n}\nreturn fitLinearModel(rows,y,{method:'ols'});\n};\nconst nFixed=m-maxlag;\nlet bestLag=0;\nlet bestAic=Infinity;\nfor(let p=0;p<=maxlag;p++){\nconst model=fit(p,maxlag);\nif(!model)continue;\nconst params=p+3;\nconst rss=model.sigma2*(nFixed-params);\nif(!(rss>0))continue;\nconst aic=nFixed*Math.log(rss/nFixed)+2*params;\nif(aic<bestAic){bestAic=aic;bestLag=p;}\n}\nconst finalModel=fit(bestLag,bestLag);\nif(!finalModel||!finalModel.coefficients[2])return null;\nconst statistic=finalModel.coefficients[2].t;\nconst pValue=adfInterpolatedP(statistic);\nconst stationary=statistic<ADF_CT_CRITICAL['5%'];\nreturn{\nstatistic,\nusedLag:bestLag,\nnobs:m-bestLag,\ncriticalValues:{...ADF_CT_CRITICAL},\npValue,\npApproximate:true,\nstationary,\nverdict:stationary?'stationary':'non-stationary',\nregression:'ct',\n};\n}\nfunction autocorrelations(x,opts={}){\nconst y=[];\nfor(let i=0;i<x.length;i++){\nconst v=Number(x[i]);\nif(Number.isFinite(v))y.push(v);\n}\nconst n=y.length;\nif(n<3)return null;\nlet maxlag=Number.isFinite(opts.maxlag)?Math.floor(opts.maxlag):Math.min(10,n-1);\nmaxlag=Math.max(1,Math.min(maxlag,n-1));\nlet mean=0;\nfor(const v of y)mean+=v;\nmean/=n;\nconst dev=y.map((v)=>v-mean);\nlet c0=0;\nfor(const d of dev)c0+=d*d;\nc0/=n;\nconst acf=new Array(maxlag+1).fill(0);\nacf[0]=1;\nfor(let k=1;k<=maxlag;k++){\nlet s=0;\nfor(let t=k;t<n;t++)s+=dev[t]*dev[t-k];\nacf[k]=c0>0?(s/n)/c0:0;\n}\nconst pacf=new Array(maxlag+1).fill(0);\npacf[0]=1;\nlet prev=[];\nfor(let k=1;k<=maxlag;k++){\nlet num=acf[k];\nfor(let j=1;j<k;j++)num-=prev[j-1]*acf[k-j];\nlet den=1;\nfor(let j=1;j<k;j++)den-=prev[j-1]*acf[j];\nconst phikk=den!==0?num/den:0;\nconst cur=new Array(k);\nfor(let j=1;j<k;j++)cur[j-1]=prev[j-1]-phikk*prev[k-1-j];\ncur[k-1]=phikk;\npacf[k]=phikk;\nprev=cur;\n}\nconst bound=1.96/Math.sqrt(n);\nreturn{acf,pacf,bounds:{upper:bound,lower:-bound},n,nlags:maxlag,approximate:true};\n}\nfunction spearman(a,b,indices){\nconst{xs,ys,n}=pairs(a,b,indices);\nif(n<2)return null;\nconst rx=ranksOf(xs);\nconst ry=ranksOf(ys);\nlet mx=0;\nlet my=0;\nfor(let i=0;i<n;i++){mx+=rx[i];my+=ry[i];}\nmx/=n;\nmy/=n;\nlet sxy=0;\nlet sxx=0;\nlet syy=0;\nfor(let i=0;i<n;i++){\nconst dx=rx[i]-mx;\nconst dy=ry[i]-my;\nsxy+=dx*dy;\nsxx+=dx*dx;\nsyy+=dy*dy;\n}\nif(sxx===0||syy===0)return null;\nreturn Math.max(-1,Math.min(1,sxy/Math.sqrt(sxx*syy)));\n}\nfunction kendall(a,b,indices){\nconst{xs,ys,n}=pairs(a,b,indices);\nif(n<2||n>KENDALL_LIMIT)return null;\nlet concordant=0;\nlet discordant=0;\nlet tiedXOnly=0;\nlet tiedYOnly=0;\nfor(let i=0;i<n;i++){\nfor(let j=i+1;j<n;j++){\nconst dx=Math.sign(xs[i]-xs[j]);\nconst dy=Math.sign(ys[i]-ys[j]);\nconst product=dx*dy;\nif(product>0)concordant++;\nelse if(product<0)discordant++;\nelse if(dx===0&&dy===0){}\nelse if(dx===0)tiedXOnly++;\nelse tiedYOnly++;\n}\n}\nconst orderedByX=concordant+discordant+tiedYOnly;\nconst orderedByY=concordant+discordant+tiedXOnly;\nif(orderedByX===0||orderedByY===0)return null;\nreturn(concordant-discordant)/Math.sqrt(orderedByX*orderedByY);\n}\nfunction seriesStats(ordered,opts={}){\nconst n=ordered.length;\nif(n<2)return null;\nconst first=ordered[0];\nconst last=ordered[n-1];\nconst returns=[];\nfor(let i=1;i<n;i++){\nconst previous=ordered[i-1];\nif(previous===0)continue;\nreturns.push((ordered[i]-previous)/Math.abs(previous));\n}\nlet volatility=null;\nif(returns.length>1){\nlet mean=0;\nfor(const r of returns)mean+=r;\nmean/=returns.length;\nlet m2=0;\nfor(const r of returns)m2+=(r-mean)**2;\nvolatility=Math.sqrt(m2/(returns.length-1));\n}\nconst periods=Number(opts.periodsPerYear)>0?Number(opts.periodsPerYear):null;\nlet peak=ordered[0];\nlet peakAt=0;\nlet worst=0;\nlet worstFrom=0;\nlet worstTo=0;\nfor(let i=1;i<n;i++){\nif(ordered[i]>peak){peak=ordered[i];peakAt=i;continue;}\nif(peak<=0)continue;\nconst fall=(peak-ordered[i])/peak;\nif(fall>worst){worst=fall;worstFrom=peakAt;worstTo=i;}\n}\nlet autocorrelation=null;\nif(n>2){\nlet mean=0;\nfor(let i=0;i<n;i++)mean+=ordered[i];\nmean/=n;\nlet top=0;\nlet bottom=0;\nfor(let i=0;i<n;i++){\nconst d=ordered[i]-mean;\nbottom+=d*d;\nif(i>0)top+=d*(ordered[i-1]-mean);\n}\nautocorrelation=bottom>0?top/bottom:null;\n}\nlet up=0;\nlet down=0;\nfor(const r of returns){if(r>0)up++;else if(r<0)down++;}\nlet growth=null;\nif(first>0&&last>0){\nconst perPeriod=(last/first)**(1/(n-1))-1;\ngrowth=periods?(1+perPeriod)**periods-1:perPeriod;\n}\nreturn{\nn,\nfirst,\nlast,\nchange:last-first,\nchangePercent:first===0?null:((last-first)/Math.abs(first))*100,\nvolatility,\nannualisedVolatility:volatility!==null&&periods?volatility*Math.sqrt(periods):null,\ngrowth,\nmaxDrawdown:worst,\nmaxDrawdownFrom:worstFrom,\nmaxDrawdownTo:worstTo,\nautocorrelation,\nupDays:up,\ndownDays:down,\n};\n}\nconst D2_N2=1.128;\nconst D4_N2=3.267;\nfunction movingRanges(ordered){\nconst n=ordered.length;\nif(n<2)return null;\nconst ranges=[];\nfor(let i=1;i<n;i++)ranges.push(Math.abs(ordered[i]-ordered[i-1]));\nconst centre=ranges.reduce((t,r)=>t+r,0)/ranges.length;\nreturn{ranges,centre,upper:D4_N2*centre,lower:0};\n}\nfunction withinSigma(ordered){\nconst n=ordered.length;\nif(n<2)return null;\nlet total=0;\nfor(let i=1;i<n;i++)total+=Math.abs(ordered[i]-ordered[i-1]);\nconst meanRange=total/(n-1);\nreturn{sigma:meanRange/D2_N2,meanRange};\n}\nfunction capability(ordered,spec){\nconst n=ordered.length;\nif(n<2||!spec)return null;\nconst lower=Number.isFinite(Number(spec.lower))?Number(spec.lower):null;\nconst upper=Number.isFinite(Number(spec.upper))?Number(spec.upper):null;\nif(lower===null&&upper===null)return null;\nlet mean=0;\nfor(let i=0;i<n;i++)mean+=ordered[i];\nmean/=n;\nlet m2=0;\nfor(let i=0;i<n;i++)m2+=(ordered[i]-mean)**2;\nconst overall=Math.sqrt(m2/(n-1));\nconst within=withinSigma(ordered);\nconst sigmaWithin=within?within.sigma:null;\nconst indices=(sigma)=>{\nif(!sigma||sigma<=0)return{index:null,k:null};\nconst both=lower!==null&&upper!==null;\nconst index=both?(upper-lower)/(6*sigma):null;\nconst upperSide=upper!==null?(upper-mean)/(3*sigma):Infinity;\nconst lowerSide=lower!==null?(mean-lower)/(3*sigma):Infinity;\nreturn{index,k:Math.min(upperSide,lowerSide)};\n};\nconst short=indices(sigmaWithin);\nconst long=indices(overall);\nlet outOfSpec=0;\nfor(let i=0;i<n;i++){\nif(lower!==null&&ordered[i]<lower){outOfSpec++;continue;}\nif(upper!==null&&ordered[i]>upper)outOfSpec++;\n}\nreturn{\nn,\nmean,\nlower,\nupper,\ntarget:Number.isFinite(Number(spec.target))?Number(spec.target):null,\nsigmaWithin,\nsigmaOverall:overall,\ncp:short.index,\ncpk:short.k,\npp:long.index,\nppk:long.k,\noutOfSpec,\ndefectRate:n?outOfSpec/n:null,\n};\n}\nfunction controlLimits(ordered){\nconst n=ordered.length;\nif(n<2)return null;\nconst within=withinSigma(ordered);\nif(!within||!(within.sigma>0))return null;\nlet centre=0;\nfor(let i=0;i<n;i++)centre+=ordered[i];\ncentre/=n;\nreturn{\ncentre,\nsigma:within.sigma,\nupper:centre+3*within.sigma,\nlower:centre-3*within.sigma,\n};\n}\nfunction westernElectricViolations(ordered,limits){\nif(!limits||!(limits.sigma>0))return[];\nconst n=ordered.length;\nconst{centre,sigma}=limits;\nconst z=(i)=>(ordered[i]-centre)/sigma;\nconst out=[];\nfor(let i=0;i<n;i++){\nif(Math.abs(z(i))>3){\nout.push({index:i,rule:1,description:'beyond three sigma'});\n}\nif(i>=2){\nfor(const side of[1,-1]){\nlet hits=0;\nfor(let k=i-2;k<=i;k++)if(z(k)*side>2)hits++;\nif(hits>=2){\nout.push({index:i,rule:2,description:'two of three past two sigma'});\nbreak;\n}\n}\n}\nif(i>=4){\nfor(const side of[1,-1]){\nlet hits=0;\nfor(let k=i-4;k<=i;k++)if(z(k)*side>1)hits++;\nif(hits>=4){\nout.push({index:i,rule:3,description:'four of five past one sigma'});\nbreak;\n}\n}\n}\nif(i>=7){\nfor(const side of[1,-1]){\nlet all=true;\nfor(let k=i-7;k<=i;k++)if(z(k)*side<=0){all=false;break;}\nif(all){\nout.push({index:i,rule:4,description:'eight in a row on one side'});\nbreak;\n}\n}\n}\n}\nreturn out;\n}\nfunction nelsonViolations(ordered,limits){\nif(!limits||!(limits.sigma>0))return[];\nconst n=ordered.length;\nconst{centre,sigma}=limits;\nconst z=(i)=>(ordered[i]-centre)/sigma;\nconst oneSide=(from,to,past,need)=>{\nfor(const side of[1,-1]){\nlet hits=0;\nfor(let k=from;k<=to;k++)if(z(k)*side>past)hits++;\nif(hits>=need)return true;\n}\nreturn false;\n};\nconst out=[];\nfor(let i=0;i<n;i++){\nif(Math.abs(z(i))>3)out.push({index:i,rule:1,description:'beyond three sigma'});\nif(i>=8){\nfor(const side of[1,-1]){\nlet all=true;\nfor(let k=i-8;k<=i;k++)if(z(k)*side<=0){all=false;break;}\nif(all){out.push({index:i,rule:2,description:'nine in a row on one side'});break;}\n}\n}\nif(i>=5){\nfor(const dir of[1,-1]){\nlet all=true;\nfor(let k=i-4;k<=i;k++){\nif((ordered[k]-ordered[k-1])*dir<=0){all=false;break;}\n}\nif(all){\nout.push({index:i,rule:3,description:dir>0?'six rising':'six falling'});\nbreak;\n}\n}\n}\nif(i>=13){\nlet alternating=true;\nfor(let k=i-12;k<=i;k++){\nconst a=ordered[k]-ordered[k-1];\nconst b=ordered[k+1<=i?k+1:k]-ordered[k];\nif(k+1>i)break;\nif(a===0||b===0||(a>0)===(b>0)){alternating=false;break;}\n}\nif(alternating)out.push({index:i,rule:4,description:'fourteen alternating'});\n}\nif(i>=2&&oneSide(i-2,i,2,2)){\nout.push({index:i,rule:5,description:'two of three past two sigma'});\n}\nif(i>=4&&oneSide(i-4,i,1,4)){\nout.push({index:i,rule:6,description:'four of five past one sigma'});\n}\nif(i>=14){\nlet inside=true;\nfor(let k=i-14;k<=i;k++)if(Math.abs(z(k))>=1){inside=false;break;}\nif(inside)out.push({index:i,rule:7,description:'fifteen within one sigma'});\n}\nif(i>=7){\nlet outside=true;\nfor(let k=i-7;k<=i;k++)if(Math.abs(z(k))<=1){outside=false;break;}\nif(outside)out.push({index:i,rule:8,description:'eight beyond one sigma'});\n}\n}\nreturn out;\n}\nconst CONTROL_RULE_SETS=Object.freeze(['westernElectric','nelson']);\nfunction controlViolations(ordered,limits,ruleSet='westernElectric'){\nreturn String(ruleSet)==='nelson'\n?nelsonViolations(ordered,limits)\n:westernElectricViolations(ordered,limits);\n}\nfunction countOutside(values,low,high){\nlet count=0;\nfor(let i=0;i<values.length;i++){\nif(values[i]<low||values[i]>high)count++;\n}\nreturn count;\n}\nfunction histogram(sorted,q1,q3,cap=20){\nconst n=sorted.length;\nif(!n)return[];\nconst min=sorted[0];\nconst max=sorted[n-1];\nif(max===min)return[{from:min,to:max,count:n}];\nconst iqr=q3-q1;\nconst fence=1.5*iqr;\nlet lo=iqr>0?Math.max(min,q1-fence):min;\nlet hi=iqr>0?Math.min(max,q3+fence):max;\nif(!(hi>lo)){lo=min;hi=max;}\nconst width=iqr>0?(2*iqr)/Math.cbrt(n):(hi-lo)/(Math.ceil(Math.log2(n))+1);\nconst count=width>0\n?Math.min(cap,Math.max(1,Math.ceil((hi-lo)/width)))\n:1;\nconst step=(hi-lo)/count;\nconst bins=[];\nfor(let i=0;i<count;i++){\nbins.push({from:lo+i*step,to:lo+(i+1)*step,count:0});\n}\nfor(let i=0;i<n;i++){\nconst at=Math.min(count-1,Math.max(0,Math.floor((sorted[i]-lo)/step)));\nbins[at].count++;\n}\nbins[0].from=min;\nbins[count-1].to=max;\nreturn bins;\n}\nconst DEFAULT_CONFIDENCE=0.95;\nfunction level(conf){\nconst c=Number(conf);\nreturn Number.isFinite(c)&&c>0&&c<1?c:DEFAULT_CONFIDENCE;\n}\nfunction meanInterval(values,conf=DEFAULT_CONFIDENCE){\nconst n=values.length;\nif(n<2)return null;\nlet sum=0;\nfor(let i=0;i<n;i++)sum+=values[i];\nconst mean=sum/n;\nlet ss=0;\nfor(let i=0;i<n;i++){const d=values[i]-mean;ss+=d*d;}\nconst sd=Math.sqrt(ss/(n-1));\nconst c=level(conf);\nconst t=studentTQuantile(1-(1-c)/2,n-1);\nconst margin=(t*sd)/Math.sqrt(n);\nreturn{mean,lower:mean-margin,upper:mean+margin,margin,n,confidence:c};\n}\nfunction proportionInterval(successes,n,conf=DEFAULT_CONFIDENCE){\nconst k=Number(successes);\nconst total=Number(n);\nif(!(total>0)||!(k>=0)||k>total)return null;\nconst c=level(conf);\nconst z=normalQuantile(1-(1-c)/2);\nconst p=k/total;\nconst z2=z*z;\nconst denominator=1+z2/total;\nconst centre=(p+z2/(2*total))/denominator;\nconst half=(z/denominator)\n*Math.sqrt((p*(1-p))/total+z2/(4*total*total));\nreturn{\nproportion:p,\nlower:Math.max(0,centre-half),\nupper:Math.min(1,centre+half),\nn:total,\nconfidence:c,\n};\n}\nfunction slopeInterval(fit,conf=DEFAULT_CONFIDENCE){\nif(!fit||!(fit.n>2)||!Number.isFinite(fit.stdError))return null;\nconst c=level(conf);\nconst t=studentTQuantile(1-(1-c)/2,fit.n-2);\nconst margin=t*fit.stdError;\nreturn{\nslope:fit.slope,\nlower:fit.slope-margin,\nupper:fit.slope+margin,\nmargin,\nconfidence:c,\n};\n}\nfunction capabilityInterval(index,n,conf=DEFAULT_CONFIDENCE){\nconst k=Number(index);\nconst count=Number(n);\nif(!Number.isFinite(k)||!(count>1))return null;\nconst c=level(conf);\nconst z=normalQuantile(1-(1-c)/2);\nconst margin=z*Math.sqrt(1/(9*count)+(k*k)/(2*(count-1)));\nreturn{index:k,lower:k-margin,upper:k+margin,margin,n:count,confidence:c};\n}\nfunction standardizedMeanDifference(population,subsetMean){\nif(!population||!(population.sd>0))return null;\nif(!Number.isFinite(subsetMean)||!Number.isFinite(population.mean))return null;\nreturn(subsetMean-population.mean)/population.sd;\n}\nfunction normalTotalVariation(d){\nif(!Number.isFinite(d))return 0;\nreturn Math.min(1,Math.max(0,2*normalCdf(Math.abs(d)/2)-1));\n}\nfunction frequencyMap(handle,indices){\nconst map=new Map();\nconst read=valueReader(handle);\nlet total=0;\nfor(let i=0;i<indices.length;i++){\nconst raw=read(indices[i]);\nif(raw===null||raw===undefined||raw==='')continue;\nif(typeof raw==='number'&&Number.isNaN(raw))continue;\nconst key=raw instanceof Date?raw.getTime()\n:(typeof raw==='object'?String(raw):raw);\nmap.set(key,(map.get(key)||0)+1);\ntotal++;\n}\nreturn{map,total};\n}\nfunction categoricalDistance(subset,subsetTotal,population,populationTotal){\nif(!(subsetTotal>0)||!(populationTotal>0))return null;\nlet sum=0;\nconst keys=new Set(subset.keys());\nfor(const k of population.keys())keys.add(k);\nfor(const k of keys){\nconst a=(subset.get(k)||0)/subsetTotal;\nconst b=(population.get(k)||0)/populationTotal;\nsum+=Math.abs(a-b);\n}\nreturn sum/2;\n}\nconst SUBSET_RELIABILITY_FLOOR=10;\nfunction compareColumn(handle,subsetIndices,populationStats){\nconst numeric=populationStats&&populationStats.numeric;\nif(numeric){\nconst values=numbers(handle,subsetIndices);\nconst{n,mean}=moments(values);\nconst d=n>0\n?standardizedMeanDifference(\n{mean:populationStats.mean,sd:populationStats.sd},mean,\n)\n:null;\nreturn{\nmeasure:'standardizedMeanDifference',\nmagnitude:d,\ndistance:d===null?0:normalTotalVariation(d),\ndirection:d===null?0:Math.sign(d),\nsubsetN:n,\npopulationN:populationStats.n||0,\nreliable:n>=SUBSET_RELIABILITY_FLOOR,\n};\n}\nconst{map,total}=frequencyMap(handle,subsetIndices);\nconst tvd=categoricalDistance(map,total,populationStats.map,populationStats.total);\nreturn{\nmeasure:'categoricalTotalVariation',\nmagnitude:tvd,\ndistance:tvd===null?0:tvd,\ndirection:0,\nsubsetN:total,\npopulationN:populationStats.total||0,\nreliable:total>=SUBSET_RELIABILITY_FLOOR,\n};\n}\nfunction isNumericColumn(handle,indices){\nif(handle&&(handle.kind==='float64'||handle.kind==='int32'))return true;\nconst read=valueReader(handle);\nlet seen=0;\nlet numeric=0;\nfor(let i=0;i<indices.length&&seen<200;i++){\nconst raw=read(indices[i]);\nif(raw===null||raw===undefined||raw==='')continue;\nif(raw instanceof Date)return false;\nseen++;\nconst v=typeof raw==='number'?raw:Number(raw);\nif(Number.isFinite(v))numeric++;\n}\nif(seen===0)return false;\nreturn numeric/seen>=0.9;\n}\nfunction populationRead(handle,populationIndices){\nif(isNumericColumn(handle,populationIndices)){\nconst values=numbers(handle,populationIndices);\nconst{n,mean,m2}=moments(values);\nreturn{numeric:true,mean,sd:n>0?Math.sqrt(m2/n):0,n};\n}\nconst{map,total}=frequencyMap(handle,populationIndices);\nreturn{numeric:false,map,total};\n}\n});\n__def(\"packages/core/src/compute/total.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"TOTAL_FNS\",{enumerable:true,get:function(){return TOTAL_FNS;}});\nObject.defineProperty(__exports,\"TOTAL_LABELS\",{enumerable:true,get:function(){return TOTAL_LABELS;}});\nObject.defineProperty(__exports,\"totalLabel\",{enumerable:true,get:function(){return totalLabel;}});\nObject.defineProperty(__exports,\"aggregatesFor\",{enumerable:true,get:function(){return aggregatesFor;}});\nObject.defineProperty(__exports,\"aggregateAllowed\",{enumerable:true,get:function(){return aggregateAllowed;}});\nObject.defineProperty(__exports,\"collectValues\",{enumerable:true,get:function(){return collectValues;}});\nObject.defineProperty(__exports,\"total\",{enumerable:true,get:function(){return total;}});\nconst __m0=__req(\"packages/core/src/internal/util.js\");\nconst isFunction=__m0[\"isFunction\"];\nconst warnOnce=__m0[\"warnOnce\"];\nconst __m1=__req(\"packages/core/src/compute/handle.js\");\nconst presenceReader=__m1[\"presenceReader\"];\nconst valueComparator=__m1[\"valueComparator\"];\nconst valueReader=__m1[\"valueReader\"];\nconst __m2=__req(\"packages/core/src/compute/statistics.js\");\nconst STAT_FNS=__m2[\"STAT_FNS\"];\nconst STAT_LABELS=__m2[\"STAT_LABELS\"];\nfunction isNumericBacking(handle){\nreturn!!handle&&(handle.kind==='float64'||handle.kind==='int32');\n}\nfunction sum(handle,indices){\nconst n=indices.length;\nlet acc=0;\nif(isNumericBacking(handle)){\nconst values=handle.values;\nconst present=presenceReader(handle);\nif(!present){\nfor(let i=0;i<n;i++){\nconst v=values[indices[i]];\nif(!Number.isNaN(v))acc+=v;\n}\nreturn acc;\n}\nfor(let i=0;i<n;i++){\nconst row=indices[i];\nif(present(row)===1){\nconst v=values[row];\nif(!Number.isNaN(v))acc+=v;\n}\n}\nreturn acc;\n}\nconst read=valueReader(handle);\nfor(let i=0;i<n;i++){\nconst v=numberOf(read(indices[i]));\nif(v!==null)acc+=v;\n}\nreturn acc;\n}\nsum.kernel=true;\nfunction countValues(handle,indices){\nconst n=indices.length;\nlet count=0;\nif(isNumericBacking(handle)){\nconst values=handle.values;\nconst present=presenceReader(handle);\nif(!present){\nfor(let i=0;i<n;i++)if(!Number.isNaN(values[indices[i]]))count++;\nreturn count;\n}\nfor(let i=0;i<n;i++){\nconst row=indices[i];\nif(present(row)===1&&!Number.isNaN(values[row]))count++;\n}\nreturn count;\n}\nconst read=valueReader(handle);\nfor(let i=0;i<n;i++){\nconst v=read(indices[i]);\nif(v!==null&&v!==undefined&&!(typeof v==='number'&&Number.isNaN(v)))count++;\n}\nreturn count;\n}\ncountValues.kernel=true;\nfunction count(handle,indices){\nreturn indices.length;\n}\ncount.kernel=true;\nfunction avg(handle,indices){\nconst values=countValues(handle,indices);\nif(values===0)return null;\nreturn sum(handle,indices)/values;\n}\navg.kernel=true;\nfunction extreme(handle,indices,direction,locale){\nconst n=indices.length;\nif(isNumericBacking(handle)){\nconst values=handle.values;\nconst present=presenceReader(handle);\nlet best=null;\nif(!present){\nfor(let i=0;i<n;i++){\nconst v=values[indices[i]];\nif(Number.isNaN(v))continue;\nif(best===null||(direction<0?v<best:v>best))best=v;\n}\nreturn best;\n}\nfor(let i=0;i<n;i++){\nconst row=indices[i];\nif(present(row)===0)continue;\nconst v=values[row];\nif(Number.isNaN(v))continue;\nif(best===null||(direction<0?v<best:v>best))best=v;\n}\nreturn best;\n}\nconst read=valueReader(handle);\nconst cmp=valueComparator(locale);\nlet best=null;\nfor(let i=0;i<n;i++){\nconst v=read(indices[i]);\nif(v===null||v===undefined||(typeof v==='number'&&Number.isNaN(v)))continue;\nif(best===null||(direction<0?cmp(v,best)<0:cmp(v,best)>0))best=v;\n}\nreturn best;\n}\nfunction min(handle,indices,ctx){\nreturn extreme(handle,indices,-1,ctx&&ctx.locale);\n}\nmin.kernel=true;\nfunction max(handle,indices,ctx){\nreturn extreme(handle,indices,1,ctx&&ctx.locale);\n}\nmax.kernel=true;\nfunction first(handle,indices){\nif(indices.length===0)return null;\nreturn valueReader(handle)(indices[0]);\n}\nfirst.kernel=true;\nfunction last(handle,indices){\nif(indices.length===0)return null;\nreturn valueReader(handle)(indices[indices.length-1]);\n}\nlast.kernel=true;\nfunction numberOf(v){\nif(typeof v==='number')return Number.isNaN(v)?null:v;\nif(v===null||v===undefined||v===''||typeof v==='boolean')return null;\nif(v instanceof Date)return v.getTime();\nconst n=Number(v);\nreturn Number.isNaN(n)?null:n;\n}\nconst TOTAL_FNS={\nsum,min,max,avg,count,first,last,countValues,\n...STAT_FNS,\n};\nconst TOTAL_LABELS=Object.freeze({\n...STAT_LABELS,\nsum:'Sum',\navg:'Average',\nmin:'Min',\nmax:'Max',\ncount:'Count',\ncountValues:'Count of values',\nfirst:'First',\nlast:'Last',\n});\nfunction totalLabel(fn){\nif(!fn)return'';\nif(typeof fn==='string')return TOTAL_LABELS[fn]||fn;\nreturn'Total';\n}\nconst CHOOSER_ORDER=Object.freeze([\n'sum','avg','min','max','count','countValues','first','last',\n]);\nfunction aggregatesFor(column){\nconst supported=column&&column.dataType\n&&column.dataType.totals&&column.dataType.totals.supported;\nif(Array.isArray(supported))return supported.slice();\nconst named=CHOOSER_ORDER.filter((name)=>name in TOTAL_FNS);\nfor(const name of Object.keys(TOTAL_FNS))if(!named.includes(name))named.push(name);\nreturn named;\n}\nfunction aggregateAllowed(column,name){\nif(typeof name!=='string')return true;\nreturn aggregatesFor(column).includes(name);\n}\nfunction collectValues(handle,indices){\nconst read=valueReader(handle);\nconst out=[];\nfor(let i=0;i<indices.length;i++){\nconst v=read(indices[i]);\nif(v===null||v===undefined)continue;\nout.push(v);\n}\nreturn out;\n}\nfunction total(handle,indices,fn,ctx){\nconst list=indices||[];\nif(typeof fn==='string'){\nconst kernel=TOTAL_FNS[fn];\nif(!kernel){\nwarnOnce(`total:${fn}`,`unknown total function \"${fn}\"; register it in config.totalFns`);\nreturn null;\n}\nreturn kernel(handle,list,ctx);\n}\nif(isFunction(fn)){\nif(fn.kernel===true)return fn(handle,list,ctx);\nreturn fn(collectValues(handle,list),ctx||{});\n}\nreturn null;\n}\n});\n__def(\"packages/core/src/compute/pivot.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"KEY_DELIMITER\",{enumerable:true,get:function(){return KEY_DELIMITER;}});\nObject.defineProperty(__exports,\"DEFAULT_PATH_SEPARATOR\",{enumerable:true,get:function(){return DEFAULT_PATH_SEPARATOR;}});\nObject.defineProperty(__exports,\"DEFAULT_MAX_COLUMNS\",{enumerable:true,get:function(){return DEFAULT_MAX_COLUMNS;}});\nObject.defineProperty(__exports,\"pivotKey\",{enumerable:true,get:function(){return pivotKey;}});\nObject.defineProperty(__exports,\"joinPath\",{enumerable:true,get:function(){return joinPath;}});\nObject.defineProperty(__exports,\"resolvePivotKeys\",{enumerable:true,get:function(){return resolvePivotKeys;}});\nObject.defineProperty(__exports,\"pivot\",{enumerable:true,get:function(){return pivot;}});\nconst __m0=__req(\"packages/core/src/internal/util.js\");\nconst warnOnce=__m0[\"warnOnce\"];\nconst __m1=__req(\"packages/core/src/compute/handle.js\");\nconst valueComparator=__m1[\"valueComparator\"];\nconst __m2=__req(\"packages/core/src/compute/group.js\");\nconst packKeys=__m2[\"packKeys\"];\nconst __m3=__req(\"packages/core/src/compute/total.js\");\nconst total=__m3[\"total\"];\nconst KEY_DELIMITER='|';\nconst DEFAULT_PATH_SEPARATOR='/';\nconst DEFAULT_MAX_COLUMNS=2000;\nfunction pivotKey(groupPath,pivotPath,colId){\nreturn`${groupPath}${KEY_DELIMITER}${pivotPath}${KEY_DELIMITER}${colId}`;\n}\nfunction joinPath(parts,separator){\nlet out='';\nfor(let i=0;i<parts.length;i++){\nconst v=parts[i];\nout+=(i===0?'':separator)+(v===null||v===undefined?'':String(v));\n}\nreturn out;\n}\nfunction resolvePivotKeys(handles,order,opts={}){\nconst separator=opts.separator||DEFAULT_PATH_SEPARATOR;\nconst n=order.length;\nconst{keyOf,readers}=packKeys(handles,order,0);\nconst seen=new Map();\nconst tuples=[];\nconst rawKeys=[];\nfor(let i=0;i<n;i++){\nconst row=order[i];\nconst key=keyOf(row);\nif(seen.has(key))continue;\nseen.set(key,tuples.length);\nrawKeys.push(key);\nconst tuple=new Array(readers.length);\nfor(let j=0;j<readers.length;j++)tuple[j]=readers[j](row);\ntuples.push(tuple);\n}\nconst cmp=valueComparator(opts.locale);\nconst rank=tuples.map((_,i)=>i);\nrank.sort((a,b)=>{\nconst ta=tuples[a];\nconst tb=tuples[b];\nfor(let j=0;j<ta.length;j++){\nconst c=compareNullable(ta[j],tb[j],cmp);\nif(c!==0)return c;\n}\nreturn a-b;\n});\nconst keys=new Array(rank.length);\nconst paths=new Array(rank.length);\nconst idByKey=new Map();\nfor(let position=0;position<rank.length;position++){\nconst from=rank[position];\nkeys[position]=tuples[from];\npaths[position]=joinPath(tuples[from],separator);\nidByKey.set(rawKeys[from],position);\n}\nconst idOf=(row)=>{\nconst id=idByKey.get(keyOf(row));\nreturn id===undefined?-1:id;\n};\nreturn{keys,paths,idOf};\n}\nfunction compareNullable(a,b,cmp){\nconst na=a===null||a===undefined;\nconst nb=b===null||b===undefined;\nif(na||nb)return na&&nb?0:na?1:-1;\nreturn cmp(a,b);\n}\nfunction resolveValueColumns(opts){\nconst declared=opts.values||opts.totals||[];\nif(declared.length&&typeof declared[0]==='object'&&declared[0]!==null){\nreturn declared.filter((entry)=>entry&&entry.handle);\n}\nconst resolve=typeof opts.handle==='function'?opts.handle:null;\nif(!resolve){\nif(declared.length){\nwarnOnce('pivot:handles',\n'pivot was given total column ids but no handle(colId) resolver, so no cell values were reduced. Pass values: [{ colId, handle, fn }] or opts.handle.');\n}\nreturn[];\n}\nconst totalOf=typeof opts.totalOf==='function'?opts.totalOf:null;\nconst out=[];\nfor(const colId of declared){\nconst handle=resolve(colId);\nif(!handle)continue;\nout.push({colId,handle,fn:totalOf?totalOf(colId):'sum'});\n}\nreturn out;\n}\nfunction normaliseArgs(a,b,c){\nif(Array.isArray(a)){\nconst opts=c||{};\nreturn{...opts,pivotHandles:a,order:b||null,groups:opts.groups||null};\n}\nreturn a||{};\n}\nfunction pivot(input,orderArg,optsArg){\nconst opts=normaliseArgs(input,orderArg,optsArg);\nconst separator=opts.separator||DEFAULT_PATH_SEPARATOR;\nconst valueColumns=resolveValueColumns(opts);\nconst maxColumns=opts.maxColumns===undefined?DEFAULT_MAX_COLUMNS:opts.maxColumns;\nconst groups=opts.groups&&opts.groups.buckets?opts.groups:null;\nconst buckets=groups?groups.buckets:[opts.order||new Uint32Array(0)];\nconst groupPaths=opts.groupPaths\n||(groups?groups.keys.map((tuple)=>joinPath(tuple,separator)):['']);\nconst scope=concatIndices(buckets);\nconst{keys,paths,idOf}=resolvePivotKeys(opts.pivotHandles||[],scope,opts);\nconst columns=paths.length*Math.max(1,valueColumns.length);\nconst fields=derivedFields(paths,valueColumns,separator);\nif(maxColumns&&columns>maxColumns){\nconst empty=new Map();\nreturn{\nkeys,\npaths,\nfields,\ngroupPaths,\ncolumns,\nvalues:empty,\ncells:empty,\nerror:{\ncode:'pivot-max-columns',\nmessage:`[lattice] pivot would generate ${columns} columns, above pivot.maxColumns of ${maxColumns}. Narrow the pivot columns or raise the limit.`,\ncolumns,\nmaxColumns,\n},\n};\n}\nconst cells=new Map();\nconst keyCount=paths.length;\nfor(let g=0;g<buckets.length;g++){\nconst bucket=buckets[g];\nconst groupPath=groupPaths[g]===undefined?'':groupPaths[g];\nconst n=bucket.length;\nif(n===0)continue;\nconst ids=new Int32Array(n);\nconst counts=new Uint32Array(keyCount+1);\nfor(let i=0;i<n;i++){\nconst id=idOf(bucket[i]);\nids[i]=id;\nif(id>=0)counts[id+1]++;\n}\nfor(let k=0;k<keyCount;k++)counts[k+1]+=counts[k];\nconst scattered=new Uint32Array(n);\nconst cursor=counts.slice(0,keyCount);\nfor(let i=0;i<n;i++){\nconst id=ids[i];\nif(id>=0)scattered[cursor[id]++]=bucket[i];\n}\nfor(let k=0;k<keyCount;k++){\nconst from=counts[k];\nconst to=counts[k+1];\nif(to===from)continue;\nconst slice=scattered.subarray(from,to);\nfor(let c=0;c<valueColumns.length;c++){\nconst column=valueColumns[c];\nconst result=total(column.handle,slice,column.fn,opts.totalContext||{locale:opts.locale});\ncells.set(pivotKey(groupPath,paths[k],column.colId),result);\n}\n}\n}\nreturn{keys,paths,fields,groupPaths,columns,values:cells,cells,error:null};\n}\nfunction derivedFields(paths,valueColumns,separator){\nif(valueColumns.length===0)return paths.slice();\nconst out=[];\nfor(const path of paths){\nfor(const column of valueColumns)out.push(`${path}${separator}${column.colId}`);\n}\nreturn out;\n}\nfunction concatIndices(buckets){\nif(buckets.length===1)return buckets[0]||new Uint32Array(0);\nlet n=0;\nfor(const b of buckets)n+=b?b.length:0;\nconst out=new Uint32Array(n);\nlet at=0;\nfor(const b of buckets){\nif(!b||b.length===0)continue;\nout.set(b,at);\nat+=b.length;\n}\nreturn out;\n}\n});\n__def(\"packages/core/src/compute/pivotmatrix.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"GRAND_PATH\",{enumerable:true,get:function(){return GRAND_PATH;}});\nObject.defineProperty(__exports,\"resolveAxis\",{enumerable:true,get:function(){return resolveAxis;}});\nObject.defineProperty(__exports,\"pivotMatrix\",{enumerable:true,get:function(){return pivotMatrix;}});\nObject.defineProperty(__exports,\"cellKey\",{enumerable:true,get:function(){return cellKey;}});\nObject.defineProperty(__exports,\"marginKey\",{enumerable:true,get:function(){return marginKey;}});\nconst __m0=__req(\"packages/core/src/compute/handle.js\");\nconst valueComparator=__m0[\"valueComparator\"];\nconst __m1=__req(\"packages/core/src/compute/total.js\");\nconst total=__m1[\"total\"];\nconst __m2=__req(\"packages/core/src/compute/group.js\");\nconst packKeys=__m2[\"packKeys\"];\nconst __m3=__req(\"packages/core/src/compute/pivot.js\");\nconst joinPath=__m3[\"joinPath\"];\nconst DEFAULT_PATH_SEPARATOR=__m3[\"DEFAULT_PATH_SEPARATOR\"];\nconst DEFAULT_MAX_COLUMNS=__m3[\"DEFAULT_MAX_COLUMNS\"];\nconst GRAND_PATH='';\nfunction resolveAxis(handles,leaves,opts={}){\nconst separator=opts.separator||DEFAULT_PATH_SEPARATOR;\nconst list=handles||[];\nconst order=leaves instanceof Uint32Array?leaves:Uint32Array.from(leaves||[]);\nconst n=order.length;\nif(list.length===0){\nreturn{tuples:[[]],paths:[GRAND_PATH],buckets:[order]};\n}\nconst{keyOf,readers}=packKeys(list,order,0);\nconst seen=new Map();\nconst tuples=[];\nconst rawKeys=[];\nconst rowsByKey=[];\nfor(let i=0;i<n;i++){\nconst row=order[i];\nconst key=keyOf(row);\nlet at=seen.get(key);\nif(at===undefined){\nat=tuples.length;\nseen.set(key,at);\nrawKeys.push(key);\nconst tuple=new Array(readers.length);\nfor(let j=0;j<readers.length;j++)tuple[j]=readers[j](row);\ntuples.push(tuple);\nrowsByKey.push([]);\n}\nrowsByKey[at].push(row);\n}\nconst cmp=valueComparator(opts.locale);\nconst rank=tuples.map((_,i)=>i);\nrank.sort((a,b)=>{\nconst ta=tuples[a];\nconst tb=tuples[b];\nfor(let j=0;j<ta.length;j++){\nconst c=compareNullable(ta[j],tb[j],cmp);\nif(c!==0)return c;\n}\nreturn a-b;\n});\nconst outTuples=new Array(rank.length);\nconst paths=new Array(rank.length);\nconst buckets=new Array(rank.length);\nfor(let position=0;position<rank.length;position++){\nconst from=rank[position];\noutTuples[position]=tuples[from];\npaths[position]=joinPath(tuples[from],separator);\nbuckets[position]=Uint32Array.from(rowsByKey[from]);\n}\nreturn{tuples:outTuples,paths,buckets};\n}\nfunction compareNullable(a,b,cmp){\nconst na=a===null||a===undefined;\nconst nb=b===null||b===undefined;\nif(na||nb)return na&&nb?0:na?1:-1;\nreturn cmp(a,b);\n}\nfunction intersect(a,b,bSet){\nconst out=[];\nfor(let i=0;i<a.length;i++){\nif(bSet.has(a[i]))out.push(a[i]);\n}\nreturn Uint32Array.from(out);\n}\nfunction reduceCell(handle,leaves,fn,ctx){\nconst value=leaves.length?total(handle,leaves,fn,ctx):null;\nreturn{value,leaves,count:leaves.length};\n}\nfunction pivotMatrix(input){\nconst opts=(input&&input.opts)||{};\nconst separator=opts.separator||DEFAULT_PATH_SEPARATOR;\nconst ctx=opts.totalContext||{locale:opts.locale};\nconst measures=(input.measures||[]).filter((m)=>m&&m.handle);\nconst leaves=input.leaves instanceof Uint32Array\n?input.leaves\n:Uint32Array.from(input.leaves||[]);\nconst rowAxis=resolveAxis(input.rowHandles||[],leaves,{...opts,separator});\nconst columnAxis=resolveAxis(input.columnHandles||[],leaves,{...opts,separator});\nconst maxColumns=opts.maxColumns===undefined?DEFAULT_MAX_COLUMNS:opts.maxColumns;\nconst columns=columnAxis.paths.length*Math.max(1,measures.length);\nconst empty=new Map();\nif(maxColumns&&columns>maxColumns){\nreturn{\nrowAxis,\ncolumnAxis,\nmeasures:measures.map((m)=>({colId:m.colId,fn:m.fn})),\nbody:empty,\nrowMargin:empty,\ncolumnMargin:empty,\ngrand:empty,\ncolumns,\nerror:{\ncode:'pivot-max-columns',\nmessage:`[lattice] pivot would generate ${columns} columns, above pivot.maxColumns of `\n+`${maxColumns}. Narrow the pivot columns or raise the limit.`,\ncolumns,\nmaxColumns,\n},\n};\n}\nconst body=new Map();\nconst rowMargin=new Map();\nconst columnMargin=new Map();\nconst grand=new Map();\nconst columnSets=columnAxis.buckets.map((b)=>new Set(b));\nfor(let c=0;c<columnAxis.paths.length;c++){\nconst columnLeaves=columnAxis.buckets[c];\nconst columnPath=columnAxis.paths[c];\nfor(const m of measures){\ncolumnMargin.set(marginKey(columnPath,m.colId),reduceCell(m.handle,columnLeaves,m.fn,ctx));\n}\n}\nfor(let r=0;r<rowAxis.paths.length;r++){\nconst rowLeaves=rowAxis.buckets[r];\nconst rowPath=rowAxis.paths[r];\nfor(const m of measures){\nrowMargin.set(marginKey(rowPath,m.colId),reduceCell(m.handle,rowLeaves,m.fn,ctx));\n}\nfor(let c=0;c<columnAxis.paths.length;c++){\nconst cellLeaves=intersect(rowLeaves,columnAxis.buckets[c],columnSets[c]);\nif(cellLeaves.length===0)continue;\nconst columnPath=columnAxis.paths[c];\nfor(const m of measures){\nbody.set(cellKey(rowPath,columnPath,m.colId),reduceCell(m.handle,cellLeaves,m.fn,ctx));\n}\n}\n}\nfor(const m of measures){\ngrand.set(m.colId,reduceCell(m.handle,leaves,m.fn,ctx));\n}\nreturn{\nrowAxis,\ncolumnAxis,\nmeasures:measures.map((m)=>({colId:m.colId,fn:m.fn})),\nbody,\nrowMargin,\ncolumnMargin,\ngrand,\ncolumns,\nerror:null,\n};\n}\nfunction cellKey(rowPath,columnPath,colId){\nreturn`${rowPath}\\u0000${columnPath}\\u0000${colId}`;\n}\nfunction marginKey(path,colId){\nreturn`${path}\\u0000${colId}`;\n}\n});\n__def(\"packages/core/src/compute/reference.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"referenceValue\",{enumerable:true,get:function(){return referenceValue;}});\nObject.defineProperty(__exports,\"referenceSort\",{enumerable:true,get:function(){return referenceSort;}});\nObject.defineProperty(__exports,\"referenceFilter\",{enumerable:true,get:function(){return referenceFilter;}});\nObject.defineProperty(__exports,\"referencePasses\",{enumerable:true,get:function(){return referencePasses;}});\nObject.defineProperty(__exports,\"referenceGroup\",{enumerable:true,get:function(){return referenceGroup;}});\nObject.defineProperty(__exports,\"referenceTotal\",{enumerable:true,get:function(){return referenceTotal;}});\nconst __m0=__req(\"packages/core/src/internal/util.js\");\nconst getPath=__m0[\"getPath\"];\nconst __m1=__req(\"packages/core/src/compute/handle.js\");\nconst isMissing=__m1[\"isMissing\"];\nconst valueComparator=__m1[\"valueComparator\"];\nconst __m2=__req(\"packages/core/src/compute/filter.js\");\nconst testValue=__m2[\"testValue\"];\nconst KEY_SEPARATOR=String.fromCharCode(0x1f);\nconst NULL_MARKER=String.fromCharCode(0x00);\nfunction referenceValue(row,col){\nconst v=col.includes('.')?getPath(row,col):(row==null?undefined:row[col]);\nreturn v===undefined?null:v;\n}\nfunction referenceSort(rows,entries,opts={}){\nconst list=entries||[];\nlet order=rows.map((_,i)=>i);\nif(list.length===0)return order;\nfor(let e=list.length-1;e>=0;e--){\norder=referenceSortOne(rows,order,list[e],opts);\n}\nreturn order;\n}\nfunction referenceSortOne(rows,order,entry,opts){\nconst locale=entry.locale!==undefined?entry.locale:opts.locale;\nconst base=valueComparator(locale);\nconst descending=entry.descending!==undefined?!!entry.descending:entry.dir==='desc';\nconst present=[];\nconst absent=[];\nfor(const i of order){\nconst v=referenceValue(rows[i],entry.col);\nif(isMissing(v))absent.push(i);else present.push(i);\n}\nconst position=new Map();\nfor(let p=0;p<present.length;p++)position.set(present[p],p);\nconst compare=(a,b)=>{\nconst va=referenceValue(rows[a],entry.col);\nconst vb=referenceValue(rows[b],entry.col);\nlet c;\nif(typeof entry.compare==='function'){\nc=entry.compare(va,vb,rows[a],rows[b],descending);\nif(descending)c=-c;\n}else{\nc=descending?base(vb,va):base(va,vb);\n}\nreturn c!==0?c:position.get(a)-position.get(b);\n};\npresent.sort(compare);\nreturn entry.nullsFirst?absent.concat(present):present.concat(absent);\n}\nfunction referenceFilter(rows,filters,opts={}){\nconst out=[];\nfor(let i=0;i<rows.length;i++){\nif(referencePasses(rows[i],filters,opts,i))out.push(i);\n}\nreturn out;\n}\nfunction referencePasses(row,node,opts,index){\nif(!node)return true;\nif(Array.isArray(node.conditions)){\nconst children=node.conditions.filter((c)=>c!=null);\nif(children.length===0)return true;\nif(node.op==='or')return children.some((c)=>referencePasses(row,c,opts,index));\nconst all=children.every((c)=>referencePasses(row,c,opts,index));\nreturn node.op==='not'?!all:all;\n}\nif(node.col===undefined&&typeof opts.custom==='function')return!!opts.custom(node,row,index);\nreturn testValue(referenceValue(row,node.col),node,opts.locale);\n}\nfunction referenceGroup(rows,cols,order,project){\nconst source=order||rows.map((_,i)=>i);\nconst seen=new Map();\nconst keys=[];\nconst buckets=[];\nfor(const i of source){\nconst tuple=cols.map((col,j)=>{\nconst v=referenceValue(rows[i],col);\nreturn(project&&project[j])?project[j](v):v;\n});\nconst key=tuple\n.map((v)=>(v===null||v===undefined?NULL_MARKER:String(v)))\n.join(KEY_SEPARATOR);\nlet at=seen.get(key);\nif(at===undefined){\nat=keys.length;\nseen.set(key,at);\nkeys.push(tuple);\nbuckets.push([]);\n}\nbuckets[at].push(i);\n}\nreturn{keys,buckets};\n}\nfunction referenceTotal(values,fn,opts={}){\nconst cmp=valueComparator(opts.locale);\nconst live=values.filter((v)=>!isMissing(v));\nconst numbers=live.map(toNumberOrNull).filter((v)=>v!==null);\nswitch(fn){\ncase'count':return values.length;\ncase'countValues':return live.length;\ncase'sum':return numbers.reduce((a,b)=>a+b,0);\ncase'avg':return live.length===0?null:numbers.reduce((a,b)=>a+b,0)/live.length;\ncase'min':return live.length===0?null:live.reduce((a,b)=>(cmp(b,a)<0?b:a));\ncase'max':return live.length===0?null:live.reduce((a,b)=>(cmp(b,a)>0?b:a));\ncase'first':return values.length===0?null:normaliseNull(values[0]);\ncase'last':return values.length===0?null:normaliseNull(values[values.length-1]);\ndefault:return null;\n}\n}\nfunction toNumberOrNull(v){\nif(typeof v==='number')return Number.isNaN(v)?null:v;\nif(v===null||v===undefined||v===''||typeof v==='boolean')return null;\nif(v instanceof Date)return v.getTime();\nconst n=Number(v);\nreturn Number.isNaN(n)?null:n;\n}\nfunction normaliseNull(v){\nreturn v===undefined?null:v;\n}\n});\n__def(\"packages/core/src/compute/windowed.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"Window\",{enumerable:true,get:function(){return Window;}});\nObject.defineProperty(__exports,\"WINDOW_KINDS\",{enumerable:true,get:function(){return WINDOW_KINDS;}});\nObject.defineProperty(__exports,\"openWindow\",{enumerable:true,get:function(){return openWindow;}});\nObject.defineProperty(__exports,\"default\",{enumerable:true,get:function(){return __default;}});\nconst __m0=__req(\"packages/core/src/compute/sketch.js\");\nconst Welford=__m0[\"Welford\"];\nclass Window{\n#kind;\n#span;\n#ticks=[];\n#now;\n#opened;\nconstructor(kind,span=0,now=Date.now){\nif(kind!=='count'&&kind!=='time'&&kind!=='session'){\nthrow new RangeError(`unknown window kind: ${kind}`);\n}\nif((kind==='count'||kind==='time')&&!(span>0)){\nthrow new RangeError(`a ${kind} window needs a positive span`);\n}\nthis.#kind=kind;\nthis.#span=Math.floor(span);\nthis.#now=now;\nthis.#opened=now();\n}\nget size(){return this.#ticks.length;}\npush(v,t=this.#now()){\nif(!Number.isFinite(v))return;\nthis.#ticks.push({t,v});\nthis.#evict(t);\n}\n#evict(nowT){\nif(this.#kind==='count'){\nwhile(this.#ticks.length>this.#span)this.#ticks.shift();\n}else if(this.#kind==='time'){\nconst cutoff=nowT-this.#span;\nwhile(this.#ticks.length&&this.#ticks[0].t<cutoff)this.#ticks.shift();\n}\n}\nspec(){\nconst span=this.#kind==='session'?this.#now()-this.#opened:this.#span;\nreturn{kind:this.#kind,span,size:this.#ticks.length};\n}\nvalues(){return this.#ticks.map((tk)=>tk.v);}\naggregate(){\nconst spec=this.spec();\nif(!this.#ticks.length){\nreturn{over:spec,count:0,sum:null,mean:null,min:null,max:null,variance:null,stddev:null};\n}\nconst w=new Welford();\nlet sum=0;\nlet min=Infinity;\nlet max=-Infinity;\nfor(const{v}of this.#ticks){\nsum+=v;\nif(v<min)min=v;\nif(v>max)max=v;\nw.add(v);\n}\nreturn{\nover:spec,\ncount:this.#ticks.length,\nsum,\nmean:w.mean(),\nmin,\nmax,\nvariance:w.variance(),\nstddev:w.stddev(),\n};\n}\nreduce(fn){\nconst agg=this.aggregate();\nconst map={\nsum:agg.sum,avg:agg.mean,mean:agg.mean,min:agg.min,max:agg.max,\ncount:agg.count,variance:agg.variance,stddev:agg.stddev,\n};\nif(!(fn in map))throw new RangeError(`unknown windowed aggregate: ${fn}`);\nreturn{value:map[fn],over:agg.over};\n}\n}\nconst WINDOW_KINDS=Object.freeze(['count','time','session']);\nfunction openWindow(opts,now=Date.now){\nconst span=opts.kind==='time'&&opts.minutes!=null\n?opts.minutes*60_000\n:opts.span??0;\nreturn new Window(opts.kind,span,now);\n}\nconst __default={Window,WINDOW_KINDS,openWindow};\n});\n__def(\"packages/core/src/compute/anomaly.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"MAD_SCALE\",{enumerable:true,get:function(){return MAD_SCALE;}});\nObject.defineProperty(__exports,\"DEFAULT_MODIFIED_Z_THRESHOLD\",{enumerable:true,get:function(){return DEFAULT_MODIFIED_Z_THRESHOLD;}});\nObject.defineProperty(__exports,\"DEFAULT_IQR_K\",{enumerable:true,get:function(){return DEFAULT_IQR_K;}});\nObject.defineProperty(__exports,\"DEFAULT_CHI_SQUARE_P\",{enumerable:true,get:function(){return DEFAULT_CHI_SQUARE_P;}});\nObject.defineProperty(__exports,\"ANOMALY_METHODS\",{enumerable:true,get:function(){return ANOMALY_METHODS;}});\nObject.defineProperty(__exports,\"robustSpread\",{enumerable:true,get:function(){return robustSpread;}});\nObject.defineProperty(__exports,\"modifiedZScores\",{enumerable:true,get:function(){return modifiedZScores;}});\nObject.defineProperty(__exports,\"iqrFences\",{enumerable:true,get:function(){return iqrFences;}});\nObject.defineProperty(__exports,\"chiSquareCdf\",{enumerable:true,get:function(){return chiSquareCdf;}});\nObject.defineProperty(__exports,\"chiSquareQuantile\",{enumerable:true,get:function(){return chiSquareQuantile;}});\nObject.defineProperty(__exports,\"mahalanobis\",{enumerable:true,get:function(){return mahalanobis;}});\nObject.defineProperty(__exports,\"DEFAULT_ROLLING_WINDOW\",{enumerable:true,get:function(){return DEFAULT_ROLLING_WINDOW;}});\nObject.defineProperty(__exports,\"ROLLING_ANOMALY_METHODS\",{enumerable:true,get:function(){return ROLLING_ANOMALY_METHODS;}});\nObject.defineProperty(__exports,\"rollingAnomalies\",{enumerable:true,get:function(){return rollingAnomalies;}});\nObject.defineProperty(__exports,\"anomalyCondition\",{enumerable:true,get:function(){return anomalyCondition;}});\nconst __m0=__req(\"packages/core/src/compute/statistics.js\");\nconst quantileSorted=__m0[\"quantileSorted\"];\nconst __m1=__req(\"packages/core/src/compute/special.js\");\nconst logGamma=__m1[\"logGamma\"];\nconst MAD_SCALE=0.6745;\nconst DEFAULT_MODIFIED_Z_THRESHOLD=3.5;\nconst DEFAULT_IQR_K=1.5;\nconst DEFAULT_CHI_SQUARE_P=0.975;\nconst ANOMALY_METHODS=Object.freeze(['modifiedZScore','iqr','mahalanobis']);\nfunction robustSpread(values){\nconst n=values.length;\nif(!n)return null;\nconst sorted=Array.from(values,Number).sort((a,b)=>a-b);\nconst median=quantileSorted(sorted,0.5);\nconst deviations=sorted.map((v)=>Math.abs(v-median)).sort((a,b)=>a-b);\nconst mad=quantileSorted(deviations,0.5);\nreturn{median,mad};\n}\nfunction modifiedZScores(values,opts={}){\nconst threshold=Number.isFinite(opts.threshold)?opts.threshold:DEFAULT_MODIFIED_Z_THRESHOLD;\nconst n=values.length;\nconst scores=new Array(n).fill(null);\nconst flags=new Array(n).fill(false);\nconst finite=[];\nfor(let i=0;i<n;i++){\nconst v=Number(values[i]);\nif(Number.isFinite(v))finite.push(v);\n}\nif(!finite.length)return{median:null,mad:null,threshold,scores,flags,flagged:0};\nconst spread=robustSpread(finite);\nif(spread.mad===0)return{median:spread.median,mad:0,threshold,scores,flags,flagged:0};\nlet flagged=0;\nfor(let i=0;i<n;i++){\nconst v=Number(values[i]);\nif(!Number.isFinite(v))continue;\nconst score=(MAD_SCALE*(v-spread.median))/spread.mad;\nscores[i]=score;\nif(Math.abs(score)>threshold){flags[i]=true;flagged++;}\n}\nreturn{median:spread.median,mad:spread.mad,threshold,scores,flags,flagged};\n}\nfunction iqrFences(values,opts={}){\nconst k=Number.isFinite(opts.k)?opts.k:DEFAULT_IQR_K;\nconst finite=[];\nfor(let i=0;i<values.length;i++){\nconst v=Number(values[i]);\nif(Number.isFinite(v))finite.push(v);\n}\nif(!finite.length)return null;\nconst sorted=finite.sort((a,b)=>a-b);\nconst q1=quantileSorted(sorted,0.25);\nconst q3=quantileSorted(sorted,0.75);\nconst iqr=q3-q1;\nreturn{q1,q3,iqr,lower:q1-k*iqr,upper:q3+k*iqr,k};\n}\nfunction regularizedGammaP(a,x){\nif(x<=0)return 0;\nconst gln=logGamma(a);\nif(x<a+1){\nlet ap=a;\nlet sum=1/a;\nlet term=sum;\nfor(let i=0;i<1000;i++){\nap+=1;\nterm*=x/ap;\nsum+=term;\nif(Math.abs(term)<Math.abs(sum)*1e-15)break;\n}\nreturn sum*Math.exp(-x+a*Math.log(x)-gln);\n}\nconst tiny=1e-300;\nlet b=x+1-a;\nlet c=1/tiny;\nlet d=1/b;\nlet h=d;\nfor(let i=1;i<1000;i++){\nconst an=-i*(i-a);\nb+=2;\nd=an*d+b;\nif(Math.abs(d)<tiny)d=tiny;\nc=b+an/c;\nif(Math.abs(c)<tiny)c=tiny;\nd=1/d;\nconst delta=d*c;\nh*=delta;\nif(Math.abs(delta-1)<1e-15)break;\n}\nconst q=Math.exp(-x+a*Math.log(x)-gln)*h;\nreturn 1-q;\n}\nfunction chiSquareCdf(x,df){\nif(x<=0)return 0;\nreturn regularizedGammaP(df/2,x/2);\n}\nfunction chiSquareQuantile(df,p=DEFAULT_CHI_SQUARE_P){\nif(!(p>0)||!(p<1))return NaN;\nlet lo=0;\nlet hi=Math.max(1,df);\nwhile(chiSquareCdf(hi,df)<p)hi*=2;\nfor(let i=0;i<200;i++){\nconst mid=(lo+hi)/2;\nif(chiSquareCdf(mid,df)<p)lo=mid;else hi=mid;\nif(hi-lo<1e-10)break;\n}\nreturn(lo+hi)/2;\n}\nfunction invertMatrix(matrix){\nconst k=matrix.length;\nconst a=matrix.map((row,i)=>{\nconst copy=row.slice();\nfor(let j=0;j<k;j++)copy.push(i===j?1:0);\nreturn copy;\n});\nfor(let col=0;col<k;col++){\nlet pivot=col;\nfor(let r=col+1;r<k;r++){\nif(Math.abs(a[r][col])>Math.abs(a[pivot][col]))pivot=r;\n}\nif(Math.abs(a[pivot][col])<1e-12)return null;\nif(pivot!==col){const t=a[pivot];a[pivot]=a[col];a[col]=t;}\nconst div=a[col][col];\nfor(let j=0;j<2*k;j++)a[col][j]/=div;\nfor(let r=0;r<k;r++){\nif(r===col)continue;\nconst factor=a[r][col];\nif(factor===0)continue;\nfor(let j=0;j<2*k;j++)a[r][j]-=factor*a[col][j];\n}\n}\nreturn a.map((row)=>row.slice(k));\n}\nfunction meanAndCovariance(rows,k){\nconst n=rows.length;\nconst mean=new Array(k).fill(0);\nfor(const row of rows)for(let j=0;j<k;j++)mean[j]+=row[j];\nfor(let j=0;j<k;j++)mean[j]/=n;\nconst cov=Array.from({length:k},()=>new Array(k).fill(0));\nfor(const row of rows){\nfor(let a=0;a<k;a++){\nconst da=row[a]-mean[a];\nfor(let b=a;b<k;b++){\ncov[a][b]+=da*(row[b]-mean[b]);\n}\n}\n}\nconst denom=n>1?n-1:1;\nfor(let a=0;a<k;a++){\nfor(let b=a;b<k;b++){\ncov[a][b]/=denom;\ncov[b][a]=cov[a][b];\n}\n}\nreturn{mean,cov};\n}\nfunction mahalanobis(matrix,opts={}){\nconst p=Number.isFinite(opts.p)?opts.p:DEFAULT_CHI_SQUARE_P;\nconst ridgeFraction=Number.isFinite(opts.ridge)?opts.ridge:1e-6;\nconst n=matrix.length;\nif(!n)return null;\nconst k=matrix[0].length;\nif(!k)return null;\nconst distances=new Array(n).fill(null);\nconst squared=new Array(n).fill(null);\nconst flags=new Array(n).fill(false);\nconst completeIndex=[];\nconst complete=[];\nfor(let i=0;i<n;i++){\nconst row=matrix[i];\nlet ok=row.length===k;\nconst coords=new Array(k);\nfor(let j=0;ok&&j<k;j++){\nconst v=Number(row[j]);\nif(!Number.isFinite(v))ok=false;else coords[j]=v;\n}\nif(ok){completeIndex.push(i);complete.push(coords);}\n}\nconst df=k;\nconst cutoff=chiSquareQuantile(df,p);\nif(complete.length<=k){\nreturn{center:[],df,cutoff,singular:true,used:complete.length,distances,squared,flags,flagged:0};\n}\nconst{mean,cov}=meanAndCovariance(complete,k);\nlet inverse=invertMatrix(cov);\nlet singular=false;\nif(!inverse){\nsingular=true;\nlet trace=0;\nfor(let j=0;j<k;j++)trace+=cov[j][j];\nconst ridge=(trace/k)*ridgeFraction||ridgeFraction;\nconst nudged=cov.map((row,i)=>row.map((v,j)=>(i===j?v+ridge:v)));\ninverse=invertMatrix(nudged);\nif(!inverse){\nreturn{center:mean,df,cutoff,singular:true,used:complete.length,distances,squared,flags,flagged:0};\n}\n}\nlet flagged=0;\nfor(let c=0;c<complete.length;c++){\nconst row=complete[c];\nconst dev=new Array(k);\nfor(let j=0;j<k;j++)dev[j]=row[j]-mean[j];\nlet d2=0;\nfor(let a=0;a<k;a++){\nlet sa=0;\nfor(let b=0;b<k;b++)sa+=inverse[a][b]*dev[b];\nd2+=dev[a]*sa;\n}\nif(d2<0)d2=0;\nconst at=completeIndex[c];\nsquared[at]=d2;\ndistances[at]=Math.sqrt(d2);\nif(d2>cutoff){flags[at]=true;flagged++;}\n}\nreturn{\ncenter:mean,df,cutoff,singular,used:complete.length,distances,squared,flags,flagged,\n};\n}\nconst DEFAULT_ROLLING_WINDOW=20;\nconst ROLLING_ANOMALY_METHODS=Object.freeze(['rollingModifiedZScore','rollingIqr']);\nfunction rollingAnomalies(values,opts={}){\nconst method=opts.method==='rollingIqr'?'rollingIqr':'rollingModifiedZScore';\nconst windowLen=Number.isFinite(opts.windowLen)&&opts.windowLen>=1\n?Math.floor(opts.windowLen):DEFAULT_ROLLING_WINDOW;\nconst threshold=Number.isFinite(opts.threshold)?opts.threshold:DEFAULT_MODIFIED_Z_THRESHOLD;\nconst k=Number.isFinite(opts.k)?opts.k:DEFAULT_IQR_K;\nconst minPeriods=Number.isFinite(opts.minPeriods)&&opts.minPeriods>=1\n?Math.floor(opts.minPeriods):windowLen;\nconst n=values.length;\nconst scores=new Array(n).fill(null);\nconst flags=new Array(n).fill(false);\nlet flagged=0;\nfor(let i=0;i<n;i++){\nconst v=Number(values[i]);\nif(!Number.isFinite(v))continue;\nconst start=Math.max(0,i-windowLen+1);\nconst win=[];\nfor(let j=start;j<=i;j++){\nconst w=Number(values[j]);\nif(Number.isFinite(w))win.push(w);\n}\nif(win.length<minPeriods)continue;\nif(method==='rollingIqr'){\nconst fences=iqrFences(win,{k});\nif(!fences)continue;\nif(v<fences.lower||v>fences.upper){flags[i]=true;flagged++;}\n}else{\nconst spread=robustSpread(win);\nif(!spread||spread.mad===0)continue;\nconst score=(MAD_SCALE*(v-spread.median))/spread.mad;\nscores[i]=score;\nif(Math.abs(score)>threshold){flags[i]=true;flagged++;}\n}\n}\nreturn{method,windowLen,minPeriods,threshold,k,scores,flags,flagged};\n}\nfunction anomalyCondition(opts={}){\nconst spec=opts||{};\nconst field=spec.field;\nif(typeof field!=='string'||!field){\nthrow new TypeError('[lattice] anomalyCondition: a string `field` naming the numeric property to monitor is required');\n}\nconst method=spec.method||'modifiedZScore';\nconst known=ANOMALY_METHODS.includes(method)||ROLLING_ANOMALY_METHODS.includes(method);\nif(!known||method==='mahalanobis'){\nthrow new RangeError(`[lattice] anomalyCondition: unknown or unsupported method '${method}'`);\n}\nconst orderBy=typeof spec.orderBy==='string'?spec.orderBy:null;\nconst latest=spec.latest===true;\nconst isRolling=ROLLING_ANOMALY_METHODS.includes(method);\nconst read=(row)=>Number(row==null?NaN:row[field]);\nreturn(rows)=>{\nconst list=Array.isArray(rows)?rows.slice():[...rows];\nif(orderBy){\nlist.sort((a,b)=>{\nconst av=a==null?undefined:a[orderBy];\nconst bv=b==null?undefined:b[orderBy];\nif(av===bv)return 0;\nif(av===undefined||av===null)return-1;\nif(bv===undefined||bv===null)return 1;\nreturn av<bv?-1:1;\n});\n}\nconst values=list.map(read);\nlet flags;\nlet scores;\nif(isRolling){\nconst r=rollingAnomalies(values,{\nmethod,windowLen:spec.windowLen,threshold:spec.threshold,k:spec.k,minPeriods:spec.minPeriods,\n});\n({flags,scores}=r);\n}else if(method==='iqr'){\nconst fences=iqrFences(values,{k:spec.k});\nflags=values.map((v)=>(fences?Number.isFinite(v)&&(v<fences.lower||v>fences.upper):false));\nscores=values.map(()=>null);\n}else{\nconst z=modifiedZScores(values,{threshold:spec.threshold});\n({flags,scores}=z);\n}\nif(latest){\nconst i=flags.length-1;\nif(i<0||!flags[i])return false;\nreturn{method,field,flagged:[{row:list[i],score:scores[i]}]};\n}\nconst flaggedRows=[];\nfor(let i=0;i<flags.length;i++){\nif(flags[i])flaggedRows.push({row:list[i],score:scores[i]});\n}\nreturn flaggedRows.length?{method,field,flagged:flaggedRows}:false;\n};\n}\n});\n__def(\"packages/core/src/compute/forecast.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"FORECAST_METHODS\",{enumerable:true,get:function(){return FORECAST_METHODS;}});\nObject.defineProperty(__exports,\"forecast\",{enumerable:true,get:function(){return forecast;}});\nObject.defineProperty(__exports,\"default\",{enumerable:true,get:function(){return __default;}});\nconst __m0=__req(\"packages/core/src/compute/special.js\");\nconst normalQuantile=__m0[\"normalQuantile\"];\nconst studentTQuantile=__m0[\"studentTQuantile\"];\nconst __m1=__req(\"packages/core/src/internal/util.js\");\nconst warnOnce=__m1[\"warnOnce\"];\nconst FORECAST_METHODS=Object.freeze([\n'movingAverage','ses','holt','holtWinters','linear',\n]);\nconst SMOOTH_LO=1e-4;\nconst SMOOTH_HI=1-1e-4;\nfunction normalise(seq){\nconst rows=[];\nfor(let i=0;i<seq.length;i++){\nconst el=seq[i];\nif(el!==null&&typeof el==='object'){\nconst at=Number.isFinite(el.at)?el.at:i;\nconst value=Number.isFinite(el.value)?el.value:null;\nrows.push({at,value});\n}else{\nrows.push({at:i,value:Number.isFinite(el)?Number(el):null});\n}\n}\nreturn rows;\n}\nfunction axis(rows){\nconst finite=rows.filter((r)=>r.value!==null);\nconst first=finite[0];\nconst last=finite[finite.length-1];\nconst span=last.at-first.at;\nconst step=finite.length>1&&span>0?span/(finite.length-1):1;\nreturn{lastAt:last.at,step};\n}\nfunction clamp(x){return Math.min(SMOOTH_HI,Math.max(SMOOTH_LO,x));}\nfunction goldenMin(f,lo=SMOOTH_LO,hi=SMOOTH_HI,iters=80){\nconst invphi=(Math.sqrt(5)-1)/2;\nlet a=lo;\nlet b=hi;\nlet c=b-invphi*(b-a);\nlet d=a+invphi*(b-a);\nlet fc=f(c);\nlet fd=f(d);\nfor(let i=0;i<iters;i++){\nif(fc<fd){b=d;d=c;fd=fc;c=b-invphi*(b-a);fc=f(c);}\nelse{a=c;c=d;fc=fd;d=a+invphi*(b-a);fd=f(d);}\n}\nreturn(a+b)/2;\n}\nfunction runSes(y,alpha){\nlet level=null;\nlet sse=0;\nlet m=0;\nfor(let i=0;i<y.length;i++){\nconst v=y[i];\nif(v===null)continue;\nif(level===null){level=v;continue;}\nsse+=(v-level)**2;\nm+=1;\nlevel=alpha*v+(1-alpha)*level;\n}\nreturn{level,sse,m};\n}\nfunction runHolt(y,alpha,beta){\nlet level=null;\nlet trend=null;\nlet sse=0;\nlet m=0;\nfor(let i=0;i<y.length;i++){\nconst v=y[i];\nif(v===null){if(level!==null&&trend!==null)level+=trend;continue;}\nif(level===null){level=v;continue;}\nif(trend===null){trend=v-level;}\nconst forecast=level+trend;\nsse+=(v-forecast)**2;\nm+=1;\nconst prev=level;\nlevel=alpha*v+(1-alpha)*(prev+trend);\ntrend=beta*(level-prev)+(1-beta)*trend;\n}\nreturn{level,trend,sse,m};\n}\nfunction runHoltWinters(y,m,alpha,beta,gamma){\nconst n=y.length;\nif(n<2*m)return null;\nconst seasonMean=(from)=>{\nlet s=0;\nlet c=0;\nfor(let i=from;i<from+m&&i<n;i++)if(y[i]!==null){s+=y[i];c+=1;}\nreturn c?s/c:null;\n};\nconst m0=seasonMean(0);\nconst m1=seasonMean(m);\nif(m0===null||m1===null)return null;\nlet level=m0;\nlet trend=(m1-m0)/m;\nconst season=new Array(m).fill(0);\nfor(let i=0;i<m;i++)season[i]=(y[i]===null?0:y[i]-level);\nconst bias=season.reduce((a,b)=>a+b,0)/m;\nfor(let i=0;i<m;i++)season[i]-=bias;\nlet sse=0;\nlet count=0;\nfor(let t=m;t<n;t++){\nconst phase=t%m;\nconst s=season[phase];\nconst v=y[t];\nif(v===null){level+=trend;continue;}\nconst forecast=level+trend+s;\nsse+=(v-forecast)**2;\ncount+=1;\nconst prevLevel=level;\nlevel=alpha*(v-s)+(1-alpha)*(level+trend);\ntrend=beta*(level-prevLevel)+(1-beta)*trend;\nseason[phase]=gamma*(v-level)+(1-gamma)*s;\n}\nreturn{level,trend,season,phase:(n-1)%m,sse,count};\n}\nfunction esBand(sigma2,c,z){\nlet acc=1;\nfor(const cj of c)acc+=cj*cj;\nconst se=Math.sqrt(sigma2*acc);\nreturn{se,margin:z*se};\n}\nfunction forecast(seq,opts={}){\nif(!seq||typeof seq.length!=='number'||seq.length===0)return null;\nconst method=FORECAST_METHODS.includes(opts.method)?opts.method:'linear';\nconst horizon=Math.max(1,Math.floor(Number(opts.horizon)||1));\nconst conf=Number.isFinite(opts.confidence)&&opts.confidence>0&&opts.confidence<1\n?opts.confidence:0.95;\nconst tail=1-(1-conf)/2;\nconst rows=normalise(seq);\nconst y=rows.map((r)=>r.value);\nconst finite=y.filter((v)=>v!==null);\nconst n=finite.length;\nconst{lastAt,step}=n?axis(rows):{lastAt:0,step:1};\nconst atOf=(h)=>lastAt+h*step;\nif(method==='linear')return forecastLinear(rows,n,horizon,conf,tail,atOf);\nif(method==='movingAverage')return forecastMovingAverage(finite,n,horizon,conf,tail,opts,atOf);\nif(method==='ses')return forecastSes(y,n,horizon,conf,tail,opts,atOf);\nif(method==='holt')return forecastHolt(y,n,horizon,conf,tail,opts,atOf);\nreturn forecastHoltWinters(y,n,horizon,conf,tail,opts,atOf);\n}\nfunction forecastLinear(rows,n,horizon,conf,tail,atOf){\nif(n<2)return null;\nlet mx=0;\nlet my=0;\nfor(const r of rows)if(r.value!==null){mx+=r.at;my+=r.value;}\nmx/=n;\nmy/=n;\nlet sxx=0;\nlet sxy=0;\nlet syy=0;\nfor(const r of rows){\nif(r.value===null)continue;\nconst dx=r.at-mx;\nconst dy=r.value-my;\nsxx+=dx*dx;\nsxy+=dx*dy;\nsyy+=dy*dy;\n}\nif(sxx===0)return null;\nconst slope=sxy/sxx;\nconst intercept=my-slope*mx;\nconst r2=syy===0?1:Math.max(0,Math.min(1,(sxy*sxy)/(sxx*syy)));\nconst sse=Math.max(0,syy-slope*sxy);\nconst s=n>2?Math.sqrt(sse/(n-2)):null;\nconst t=n>2?studentTQuantile(tail,n-2):null;\nconst points=[];\nfor(let h=1;h<=horizon;h++){\nconst x0=atOf(h);\nconst mean=intercept+slope*x0;\nlet lower=null;\nlet upper=null;\nlet lowerMean=null;\nlet upperMean=null;\nlet se=null;\nif(s!==null){\nconst leverage=1/n+((x0-mx)**2)/sxx;\nconst sePred=s*Math.sqrt(1+leverage);\nconst seMean=s*Math.sqrt(leverage);\nse=sePred;\nlower=mean-t*sePred;\nupper=mean+t*sePred;\nlowerMean=mean-t*seMean;\nupperMean=mean+t*seMean;\n}\npoints.push({step:h,at:x0,mean,lower,upper,lowerMean,upperMean,se});\n}\nreturn{\nmethod:'linear',horizon,confidence:conf,n,sigma:s,r2,\nparams:{slope,intercept},points,\n};\n}\nfunction forecastMovingAverage(finite,n,horizon,conf,tail,opts,atOf){\nif(n<1)return null;\nconst k=Math.max(1,Math.min(n,Math.floor(Number(opts.windowLen)||n)));\nconst recent=finite.slice(n-k);\nlet sum=0;\nfor(const v of recent)sum+=v;\nconst mean=sum/k;\nlet se=null;\nlet t=null;\nif(k>1){\nlet ss=0;\nfor(const v of recent)ss+=(v-mean)**2;\nconst s=Math.sqrt(ss/(k-1));\nse=s*Math.sqrt(1+1/k);\nt=studentTQuantile(tail,k-1);\n}\nconst margin=se===null?null:t*se;\nconst points=[];\nfor(let h=1;h<=horizon;h++){\npoints.push({\nstep:h,at:atOf(h),mean,\nlower:margin===null?null:mean-margin,\nupper:margin===null?null:mean+margin,\nse,\n});\n}\nreturn{\nmethod:'movingAverage',horizon,confidence:conf,n,\nsigma:se===null?null:se,params:{windowLen:k},points,\n};\n}\nfunction forecastSes(y,n,horizon,conf,tail,opts,atOf){\nif(n<1)return null;\nlet alpha=Number.isFinite(opts.alpha)?clamp(opts.alpha):null;\nif(alpha===null)alpha=goldenMin((x)=>runSes(y,x).sse);\nconst run=runSes(y,alpha);\nconst z=normalQuantile(tail);\nconst sigma2=run.m>0?run.sse/run.m:null;\nconst points=[];\nfor(let h=1;h<=horizon;h++){\nconst mean=run.level;\nlet lower=null;\nlet upper=null;\nlet se=null;\nif(sigma2!==null){\nconst c=[];\nfor(let j=1;j<h;j++)c.push(alpha);\nconst band=esBand(sigma2,c,z);\nse=band.se;\nlower=mean-band.margin;\nupper=mean+band.margin;\n}\npoints.push({step:h,at:atOf(h),mean,lower,upper,se});\n}\nreturn{\nmethod:'ses',horizon,confidence:conf,n,\nsigma:sigma2===null?null:Math.sqrt(sigma2),params:{alpha},points,\n};\n}\nfunction forecastHolt(y,n,horizon,conf,tail,opts,atOf){\nif(n<2)return null;\nlet alpha=Number.isFinite(opts.alpha)?clamp(opts.alpha):null;\nlet beta=Number.isFinite(opts.beta)?clamp(opts.beta):null;\nif(alpha===null||beta===null){\nlet a=alpha===null?0.5:alpha;\nlet b=beta===null?0.5:beta;\nfor(let round=0;round<6;round++){\nif(alpha===null)a=goldenMin((x)=>runHolt(y,x,b).sse);\nif(beta===null)b=goldenMin((x)=>runHolt(y,a,x).sse);\n}\nalpha=alpha===null?a:alpha;\nbeta=beta===null?b:beta;\n}\nconst run=runHolt(y,alpha,beta);\nconst z=normalQuantile(tail);\nconst sigma2=run.m>0?run.sse/run.m:null;\nconst phi=alpha*beta;\nconst points=[];\nfor(let h=1;h<=horizon;h++){\nconst mean=run.level+h*run.trend;\nlet lower=null;\nlet upper=null;\nlet se=null;\nif(sigma2!==null){\nconst c=[];\nfor(let j=1;j<h;j++)c.push(alpha+j*phi);\nconst band=esBand(sigma2,c,z);\nse=band.se;\nlower=mean-band.margin;\nupper=mean+band.margin;\n}\npoints.push({step:h,at:atOf(h),mean,lower,upper,se});\n}\nreturn{\nmethod:'holt',horizon,confidence:conf,n,\nsigma:sigma2===null?null:Math.sqrt(sigma2),params:{alpha,beta},points,\n};\n}\nfunction forecastHoltWinters(y,n,horizon,conf,tail,opts,atOf){\nconst m=Math.floor(Number(opts.period));\nif(!(m>=2)){\nwarnOnce('forecast.holtWinters.period','forecast: holtWinters needs a period (opts.period >= 2)');\nreturn null;\n}\nif(n<2*m)return null;\nlet alpha=Number.isFinite(opts.alpha)?clamp(opts.alpha):null;\nlet beta=Number.isFinite(opts.beta)?clamp(opts.beta):null;\nlet gamma=Number.isFinite(opts.gamma)?clamp(opts.gamma):null;\nconst sseAt=(a,b,g)=>{\nconst r=runHoltWinters(y,m,a,b,g);\nreturn r?r.sse:Infinity;\n};\nif(alpha===null||beta===null||gamma===null){\nlet a=alpha===null?0.5:alpha;\nlet b=beta===null?0.5:beta;\nlet g=gamma===null?0.5:gamma;\nfor(let round=0;round<8;round++){\nif(alpha===null)a=goldenMin((x)=>sseAt(x,b,g));\nif(beta===null)b=goldenMin((x)=>sseAt(a,x,g));\nif(gamma===null)g=goldenMin((x)=>sseAt(a,b,x));\n}\nalpha=alpha===null?a:alpha;\nbeta=beta===null?b:beta;\ngamma=gamma===null?g:gamma;\n}\nconst run=runHoltWinters(y,m,alpha,beta,gamma);\nif(!run)return null;\nconst z=normalQuantile(tail);\nconst sigma2=run.count>0?run.sse/run.count:null;\nconst phi=alpha*beta;\nconst gs=gamma*(1-alpha);\nconst points=[];\nfor(let h=1;h<=horizon;h++){\nconst s=run.season[(run.phase+h)%m];\nconst mean=run.level+h*run.trend+s;\nlet lower=null;\nlet upper=null;\nlet se=null;\nif(sigma2!==null){\nconst c=[];\nfor(let j=1;j<h;j++)c.push(alpha+j*phi+(j%m===0?gs:0));\nconst band=esBand(sigma2,c,z);\nse=band.se;\nlower=mean-band.margin;\nupper=mean+band.margin;\n}\npoints.push({step:h,at:atOf(h),mean,lower,upper,se});\n}\nreturn{\nmethod:'holtWinters',horizon,confidence:conf,n,\nsigma:sigma2===null?null:Math.sqrt(sigma2),\nparams:{alpha,beta,gamma,period:m},points,\n};\n}\nconst __default={FORECAST_METHODS,forecast};\n});\n__def(\"packages/core/src/compute/index.js\",function(__exports,__req){\n'use strict';\nconst __m0=__req(\"packages/core/src/compute/sort.js\");\nObject.defineProperty(__exports,\"sortColumn\",{enumerable:true,get:function(){return __m0[\"sortColumn\"];}});\nObject.defineProperty(__exports,\"sortMulti\",{enumerable:true,get:function(){return __m0[\"sortMulti\"];}});\nObject.defineProperty(__exports,\"radixSortFloat64\",{enumerable:true,get:function(){return __m0[\"radixSortFloat64\"];}});\nObject.defineProperty(__exports,\"radixSortInt32\",{enumerable:true,get:function(){return __m0[\"radixSortInt32\"];}});\nObject.defineProperty(__exports,\"rankSortDictionary\",{enumerable:true,get:function(){return __m0[\"rankSortDictionary\"];}});\nObject.defineProperty(__exports,\"mergeSortComparator\",{enumerable:true,get:function(){return __m0[\"mergeSortComparator\"];}});\nObject.defineProperty(__exports,\"collateStringRanks\",{enumerable:true,get:function(){return __m0[\"collateStringRanks\"];}});\nObject.defineProperty(__exports,\"rankSortStrings\",{enumerable:true,get:function(){return __m0[\"rankSortStrings\"];}});\nconst __m1=__req(\"packages/core/src/compute/sortspec.js\");\nObject.defineProperty(__exports,\"collationDescriptor\",{enumerable:true,get:function(){return __m1[\"collationDescriptor\"];}});\nObject.defineProperty(__exports,\"isPortableSort\",{enumerable:true,get:function(){return __m1[\"isPortableSort\"];}});\nObject.defineProperty(__exports,\"isPortableSortSet\",{enumerable:true,get:function(){return __m1[\"isPortableSortSet\"];}});\nObject.defineProperty(__exports,\"describeSortEntry\",{enumerable:true,get:function(){return __m1[\"describeSortEntry\"];}});\nObject.defineProperty(__exports,\"describeSort\",{enumerable:true,get:function(){return __m1[\"describeSort\"];}});\nconst __m2=__req(\"packages/core/src/compute/filter.js\");\nObject.defineProperty(__exports,\"evaluateFilters\",{enumerable:true,get:function(){return __m2[\"evaluateFilters\"];}});\nObject.defineProperty(__exports,\"evaluateCondition\",{enumerable:true,get:function(){return __m2[\"evaluateCondition\"];}});\nObject.defineProperty(__exports,\"compact\",{enumerable:true,get:function(){return __m2[\"compact\"];}});\nObject.defineProperty(__exports,\"testValue\",{enumerable:true,get:function(){return __m2[\"testValue\"];}});\nObject.defineProperty(__exports,\"compilePredicate\",{enumerable:true,get:function(){return __m2[\"compilePredicate\"];}});\nObject.defineProperty(__exports,\"releaseMask\",{enumerable:true,get:function(){return __m2[\"releaseMask\"];}});\nObject.defineProperty(__exports,\"pruneColumn\",{enumerable:true,get:function(){return __m2[\"pruneColumn\"];}});\nObject.defineProperty(__exports,\"mentionsColumn\",{enumerable:true,get:function(){return __m2[\"mentionsColumn\"];}});\nconst __m3=__req(\"packages/core/src/compute/group.js\");\nObject.defineProperty(__exports,\"groupByColumns\",{enumerable:true,get:function(){return __m3[\"groupByColumns\"];}});\nObject.defineProperty(__exports,\"packKeys\",{enumerable:true,get:function(){return __m3[\"packKeys\"];}});\nconst __m4=__req(\"packages/core/src/compute/facet.js\");\nObject.defineProperty(__exports,\"facet\",{enumerable:true,get:function(){return __m4[\"facet\"];}});\nObject.defineProperty(__exports,\"computeBounds\",{enumerable:true,get:function(){return __m4[\"computeBounds\"];}});\nObject.defineProperty(__exports,\"countInto\",{enumerable:true,get:function(){return __m4[\"countInto\"];}});\nObject.defineProperty(__exports,\"bucketOf\",{enumerable:true,get:function(){return __m4[\"bucketOf\"];}});\nObject.defineProperty(__exports,\"facetKind\",{enumerable:true,get:function(){return __m4[\"facetKind\"];}});\nObject.defineProperty(__exports,\"cardinalityOf\",{enumerable:true,get:function(){return __m4[\"cardinalityOf\"];}});\nObject.defineProperty(__exports,\"pickGranularity\",{enumerable:true,get:function(){return __m4[\"pickGranularity\"];}});\nObject.defineProperty(__exports,\"floorTo\",{enumerable:true,get:function(){return __m4[\"floorTo\"];}});\nObject.defineProperty(__exports,\"advance\",{enumerable:true,get:function(){return __m4[\"advance\"];}});\nObject.defineProperty(__exports,\"STRATEGIES\",{enumerable:true,get:function(){return __m4[\"STRATEGIES\"];}});\nObject.defineProperty(__exports,\"GRANULARITIES\",{enumerable:true,get:function(){return __m4[\"GRANULARITIES\"];}});\nObject.defineProperty(__exports,\"DEFAULT_BUCKETS\",{enumerable:true,get:function(){return __m4[\"DEFAULT_BUCKETS\"];}});\nObject.defineProperty(__exports,\"DEFAULT_CARDINALITY_LIMIT\",{enumerable:true,get:function(){return __m4[\"DEFAULT_CARDINALITY_LIMIT\"];}});\nObject.defineProperty(__exports,\"QUANTILE_SAMPLE\",{enumerable:true,get:function(){return __m4[\"QUANTILE_SAMPLE\"];}});\nconst __m5=__req(\"packages/core/src/compute/total.js\");\nObject.defineProperty(__exports,\"TOTAL_FNS\",{enumerable:true,get:function(){return __m5[\"TOTAL_FNS\"];}});\nObject.defineProperty(__exports,\"TOTAL_LABELS\",{enumerable:true,get:function(){return __m5[\"TOTAL_LABELS\"];}});\nObject.defineProperty(__exports,\"totalLabel\",{enumerable:true,get:function(){return __m5[\"totalLabel\"];}});\nObject.defineProperty(__exports,\"total\",{enumerable:true,get:function(){return __m5[\"total\"];}});\nObject.defineProperty(__exports,\"collectValues\",{enumerable:true,get:function(){return __m5[\"collectValues\"];}});\nconst __m6=__req(\"packages/core/src/compute/pivot.js\");\nObject.defineProperty(__exports,\"pivot\",{enumerable:true,get:function(){return __m6[\"pivot\"];}});\nObject.defineProperty(__exports,\"resolvePivotKeys\",{enumerable:true,get:function(){return __m6[\"resolvePivotKeys\"];}});\nObject.defineProperty(__exports,\"pivotKey\",{enumerable:true,get:function(){return __m6[\"pivotKey\"];}});\nObject.defineProperty(__exports,\"joinPath\",{enumerable:true,get:function(){return __m6[\"joinPath\"];}});\nObject.defineProperty(__exports,\"KEY_DELIMITER\",{enumerable:true,get:function(){return __m6[\"KEY_DELIMITER\"];}});\nObject.defineProperty(__exports,\"DEFAULT_PATH_SEPARATOR\",{enumerable:true,get:function(){return __m6[\"DEFAULT_PATH_SEPARATOR\"];}});\nObject.defineProperty(__exports,\"DEFAULT_MAX_COLUMNS\",{enumerable:true,get:function(){return __m6[\"DEFAULT_MAX_COLUMNS\"];}});\nconst __m7=__req(\"packages/core/src/compute/pivotmatrix.js\");\nObject.defineProperty(__exports,\"pivotMatrix\",{enumerable:true,get:function(){return __m7[\"pivotMatrix\"];}});\nObject.defineProperty(__exports,\"resolveAxis\",{enumerable:true,get:function(){return __m7[\"resolveAxis\"];}});\nObject.defineProperty(__exports,\"cellKey\",{enumerable:true,get:function(){return __m7[\"cellKey\"];}});\nObject.defineProperty(__exports,\"marginKey\",{enumerable:true,get:function(){return __m7[\"marginKey\"];}});\nObject.defineProperty(__exports,\"GRAND_PATH\",{enumerable:true,get:function(){return __m7[\"GRAND_PATH\"];}});\nconst __m8=__req(\"packages/core/src/compute/reference.js\");\nObject.defineProperty(__exports,\"referenceSort\",{enumerable:true,get:function(){return __m8[\"referenceSort\"];}});\nObject.defineProperty(__exports,\"referenceFilter\",{enumerable:true,get:function(){return __m8[\"referenceFilter\"];}});\nObject.defineProperty(__exports,\"referenceGroup\",{enumerable:true,get:function(){return __m8[\"referenceGroup\"];}});\nObject.defineProperty(__exports,\"referenceTotal\",{enumerable:true,get:function(){return __m8[\"referenceTotal\"];}});\nObject.defineProperty(__exports,\"referencePasses\",{enumerable:true,get:function(){return __m8[\"referencePasses\"];}});\nObject.defineProperty(__exports,\"referenceValue\",{enumerable:true,get:function(){return __m8[\"referenceValue\"];}});\nconst __m9=__req(\"packages/core/src/compute/handle.js\");\nObject.defineProperty(__exports,\"identity\",{enumerable:true,get:function(){return __m9[\"identity\"];}});\nObject.defineProperty(__exports,\"rowCount\",{enumerable:true,get:function(){return __m9[\"rowCount\"];}});\nObject.defineProperty(__exports,\"presenceReader\",{enumerable:true,get:function(){return __m9[\"presenceReader\"];}});\nObject.defineProperty(__exports,\"bitReader\",{enumerable:true,get:function(){return __m9[\"bitReader\"];}});\nObject.defineProperty(__exports,\"valueReader\",{enumerable:true,get:function(){return __m9[\"valueReader\"];}});\nObject.defineProperty(__exports,\"valueComparator\",{enumerable:true,get:function(){return __m9[\"valueComparator\"];}});\nObject.defineProperty(__exports,\"numericTotalOrder\",{enumerable:true,get:function(){return __m9[\"numericTotalOrder\"];}});\nObject.defineProperty(__exports,\"dictRanks\",{enumerable:true,get:function(){return __m9[\"dictRanks\"];}});\nObject.defineProperty(__exports,\"dictSize\",{enumerable:true,get:function(){return __m9[\"dictSize\"];}});\nObject.defineProperty(__exports,\"dictValue\",{enumerable:true,get:function(){return __m9[\"dictValue\"];}});\nObject.defineProperty(__exports,\"multiValue\",{enumerable:true,get:function(){return __m9[\"multiValue\"];}});\nObject.defineProperty(__exports,\"isMissing\",{enumerable:true,get:function(){return __m9[\"isMissing\"];}});\nconst __m10=__req(\"packages/core/src/compute/sketch.js\");\nObject.defineProperty(__exports,\"Welford\",{enumerable:true,get:function(){return __m10[\"Welford\"];}});\nObject.defineProperty(__exports,\"Reservoir\",{enumerable:true,get:function(){return __m10[\"Reservoir\"];}});\nObject.defineProperty(__exports,\"HyperLogLog\",{enumerable:true,get:function(){return __m10[\"HyperLogLog\"];}});\nObject.defineProperty(__exports,\"SpaceSaving\",{enumerable:true,get:function(){return __m10[\"SpaceSaving\"];}});\nObject.defineProperty(__exports,\"KLL\",{enumerable:true,get:function(){return __m10[\"KLL\"];}});\nObject.defineProperty(__exports,\"hash32\",{enumerable:true,get:function(){return __m10[\"hash32\"];}});\nObject.defineProperty(__exports,\"SKETCH_BOUNDS\",{enumerable:true,get:function(){return __m10[\"SKETCH_BOUNDS\"];}});\nconst __m11=__req(\"packages/core/src/compute/windowed.js\");\nObject.defineProperty(__exports,\"Window\",{enumerable:true,get:function(){return __m11[\"Window\"];}});\nObject.defineProperty(__exports,\"WINDOW_KINDS\",{enumerable:true,get:function(){return __m11[\"WINDOW_KINDS\"];}});\nObject.defineProperty(__exports,\"openWindow\",{enumerable:true,get:function(){return __m11[\"openWindow\"];}});\nconst __m12=__req(\"packages/core/src/compute/statistics.js\");\nObject.defineProperty(__exports,\"MAINTENANCE\",{enumerable:true,get:function(){return __m12[\"MAINTENANCE\"];}});\nObject.defineProperty(__exports,\"APPROXIMATE\",{enumerable:true,get:function(){return __m12[\"APPROXIMATE\"];}});\nObject.defineProperty(__exports,\"maintenanceOf\",{enumerable:true,get:function(){return __m12[\"maintenanceOf\"];}});\nconst __m13=__req(\"packages/core/src/compute/anomaly.js\");\nObject.defineProperty(__exports,\"ANOMALY_METHODS\",{enumerable:true,get:function(){return __m13[\"ANOMALY_METHODS\"];}});\nObject.defineProperty(__exports,\"modifiedZScores\",{enumerable:true,get:function(){return __m13[\"modifiedZScores\"];}});\nObject.defineProperty(__exports,\"iqrFences\",{enumerable:true,get:function(){return __m13[\"iqrFences\"];}});\nObject.defineProperty(__exports,\"mahalanobis\",{enumerable:true,get:function(){return __m13[\"mahalanobis\"];}});\nObject.defineProperty(__exports,\"ROLLING_ANOMALY_METHODS\",{enumerable:true,get:function(){return __m13[\"ROLLING_ANOMALY_METHODS\"];}});\nObject.defineProperty(__exports,\"rollingAnomalies\",{enumerable:true,get:function(){return __m13[\"rollingAnomalies\"];}});\nObject.defineProperty(__exports,\"anomalyCondition\",{enumerable:true,get:function(){return __m13[\"anomalyCondition\"];}});\nconst __m14=__req(\"packages/core/src/compute/forecast.js\");\nObject.defineProperty(__exports,\"FORECAST_METHODS\",{enumerable:true,get:function(){return __m14[\"FORECAST_METHODS\"];}});\nObject.defineProperty(__exports,\"forecast\",{enumerable:true,get:function(){return __m14[\"forecast\"];}});\n});\n__def(\"packages/worker/src/kernel.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"loadCompute\",{enumerable:true,get:function(){return loadCompute;}});\nObject.defineProperty(__exports,\"setCompute\",{enumerable:true,get:function(){return setCompute;}});\nObject.defineProperty(__exports,\"dispatch\",{enumerable:true,get:function(){return dispatch;}});\nObject.defineProperty(__exports,\"handleMessage\",{enumerable:true,get:function(){return handleMessage;}});\nObject.defineProperty(__exports,\"installKernel\",{enumerable:true,get:function(){return installKernel;}});\nconst __m0=__req(\"packages/worker/src/transport.js\");\nconst PROTOCOL=__m0[\"PROTOCOL\"];\nconst OPS=__m0[\"OPS\"];\nconst CONTROL=__m0[\"CONTROL\"];\nconst ERRORS=__m0[\"ERRORS\"];\nconst unpackHandle=__m0[\"unpackHandle\"];\nconst unpackHandles=__m0[\"unpackHandles\"];\nconst createMaskPool=__m0[\"createMaskPool\"];\nconst collectTransfers=__m0[\"collectTransfers\"];\nconst __m1=__req(\"packages/core/src/store/columnpack.js\");\nconst packChunk=__m1[\"packChunk\"];\nconst packedTransfers=__m1[\"packedTransfers\"];\nlet computeModule=null;\nlet computePromise=null;\nlet computeError=null;\nasync function loadCompute(loader){\nif(computeModule)return computeModule;\nif(!computePromise){\nconst load=loader||(()=>Promise.resolve(__req(\"packages/core/src/compute/index.js\")));\ncomputePromise=Promise.resolve()\n.then(load)\n.then((mod)=>{computeModule=mod;return mod;})\n.catch((err)=>{\ncomputeError=err;\ncomputeModule=null;\nreturn null;\n});\n}\nreturn computePromise;\n}\nfunction setCompute(mod){\ncomputeModule=mod;\ncomputePromise=mod?Promise.resolve(mod):null;\ncomputeError=mod?null:computeError;\n}\nfunction filterContext(handles,count,locale){\nconst byId=new Map();\nfor(const h of handles)if(h)byId.set(h.id,h);\nreturn{\nhandle(colId){return byId.get(colId);},\ncount,\npool:createMaskPool(),\nlocale,\n};\n}\nfunction dispatch(request,compute){\nconst{op,args}=request;\nif(op===OPS.COLUMNIZE){\nreturn packChunk(args.schema||[],args.rows||[],args.opts||{});\n}\nconst fn=compute[op];\nif(typeof fn!=='function'){\nconst err=new Error(`[lattice] compute kernel '${op}' is not exported`);\n(err).code=ERRORS.NO_KERNEL;\nthrow err;\n}\nswitch(op){\ncase OPS.COLLATE_STRING_RANKS:\nreturn fn(args.table||[],(args.table||[]).length,args.locale);\ncase OPS.SORT_COLUMN:\nreturn fn(unpackHandle(args.handle),args.order??null,args.opts||{});\ncase OPS.SORT_MULTI:{\nconst handles=unpackHandles(args.handles||[]);\nconst entries=(args.entries||[]).map((e)=>({\n...e,\nhandle:handles[e.index],\n}));\nreturn fn(handles,entries,args.order??null);\n}\ncase OPS.EVALUATE_FILTERS:\nreturn fn(args.filters,filterContext(unpackHandles(args.handles||[]),args.count,args.locale));\ncase OPS.COMPACT:\nreturn fn(args.mask,args.count,undefined);\ncase OPS.GROUP_BY_COLUMNS:\nreturn fn(unpackHandles(args.handles||[]),args.order??null,args.opts||{});\ncase OPS.TOTAL:\nreturn fn(unpackHandle(args.handle),args.indices??null,args.fn);\ncase OPS.PIVOT:\nreturn fn(unpackHandles(args.handles||[]),args.order??null,args.opts||{});\ncase OPS.FACET:\nreturn fn(unpackHandle(args.handle),args.indices??null,args.count,args.opts||{});\ndefault:{\nconst err=new Error(`[lattice] unknown worker op '${op}'`);\n(err).code=ERRORS.PROTOCOL;\nthrow err;\n}\n}\n}\nasync function handleMessage(message,opts={}){\nif(!message||message.lattice!==PROTOCOL)return null;\nconst{id,op}=message;\nif(op===CONTROL.CANCEL){\nopts.cancelled?.add(message.target);\nreturn null;\n}\nif(op===CONTROL.PING){\nreturn{reply:{lattice:PROTOCOL,id,ok:true,result:'pong'},transfer:[]};\n}\nif(op===OPS.COLUMNIZE){\nif(opts.cancelled?.has(id)){opts.cancelled.delete(id);return null;}\ntry{\nconst result=packChunk(message.args.schema||[],message.args.rows||[],message.args.opts||{});\nif(opts.cancelled?.has(id)){\nopts.cancelled.delete(id);\nreturn{reply:{lattice:PROTOCOL,id,ok:false,error:{code:ERRORS.ABORTED,message:'[lattice] request superseded'}},transfer:[]};\n}\nreturn{reply:{lattice:PROTOCOL,id,ok:true,result},transfer:packedTransfers(result)};\n}catch(err){\nconst e=(err);\nreturn{\nreply:{lattice:PROTOCOL,id,ok:false,error:{code:e.code||ERRORS.KERNEL,message:e.message||String(err),stack:e.stack}},\ntransfer:[],\n};\n}\n}\nconst compute=await loadCompute(opts.loader);\nif(!compute){\nreturn{\nreply:{\nlattice:PROTOCOL,\nid,\nok:false,\nerror:{\ncode:ERRORS.NO_COMPUTE,\nmessage:`[lattice] compute kernels unavailable in worker: ${computeError?computeError.message:'module not found'}`,\n},\n},\ntransfer:[],\n};\n}\nif(opts.cancelled?.has(id)){\nopts.cancelled.delete(id);\nreturn{reply:{lattice:PROTOCOL,id,ok:false,error:{code:ERRORS.ABORTED,message:'[lattice] request superseded'}},transfer:[]};\n}\ntry{\nconst result=dispatch(message,compute);\nif(opts.cancelled?.has(id)){\nopts.cancelled.delete(id);\nreturn{reply:{lattice:PROTOCOL,id,ok:false,error:{code:ERRORS.ABORTED,message:'[lattice] request superseded'}},transfer:[]};\n}\nreturn{reply:{lattice:PROTOCOL,id,ok:true,result},transfer:collectTransfers(result)};\n}catch(err){\nconst e=(err);\nreturn{\nreply:{\nlattice:PROTOCOL,\nid,\nok:false,\nerror:{code:e.code||ERRORS.KERNEL,message:e.message||String(err),stack:e.stack},\n},\ntransfer:[],\n};\n}\n}\nfunction installKernel(scope,opts={}){\nconst cancelled=new Set();\nconst onMessage=async(event)=>{\nconst outcome=await handleMessage(event.data,{loader:opts.loader,cancelled});\nif(!outcome)return;\nscope.postMessage(outcome.reply,outcome.transfer);\n};\nscope.addEventListener('message',onMessage);\nloadCompute(opts.loader).then((mod)=>{\nscope.postMessage({lattice:PROTOCOL,id:0,op:CONTROL.READY,compute:!!mod});\n});\nreturn()=>scope.removeEventListener('message',onMessage);\n}\n});\nvar __entry=__req(\"packages/worker/src/kernel.js\");\nroot[\"__latticeKernel\"]=__entry;\n})(typeof globalThis!=='undefined'?globalThis:this);\n__latticeKernel.installKernel(self);\n",{type:'classic'});
+__req("packages/worker/src/inline.js").setWorkerSource("(function(root){\n'use strict';\nvar __mods=Object.create(null);\nvar __cache=Object.create(null);\nfunction __def(id,fn){__mods[id]=fn;}\nfunction __req(id){\nvar hit=__cache[id];\nif(hit)return hit;\nvar exports=Object.create(null);\n__cache[id]=exports;\nvar fn=__mods[id];\nif(!fn)throw new Error('[lattice] missing module: '+id);\nfn(exports,__req);\nreturn exports;\n}\n__def(\"packages/core/src/internal/util.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"VERSION\",{enumerable:true,get:function(){return VERSION;}});\nObject.defineProperty(__exports,\"reportedWarnings\",{enumerable:true,get:function(){return reportedWarnings;}});\nObject.defineProperty(__exports,\"warnOnce\",{enumerable:true,get:function(){return warnOnce;}});\nObject.defineProperty(__exports,\"infoOnce\",{enumerable:true,get:function(){return infoOnce;}});\nObject.defineProperty(__exports,\"resetWarnings\",{enumerable:true,get:function(){return resetWarnings;}});\nObject.defineProperty(__exports,\"fail\",{enumerable:true,get:function(){return fail;}});\nObject.defineProperty(__exports,\"invariant\",{enumerable:true,get:function(){return invariant;}});\nObject.defineProperty(__exports,\"DEV\",{enumerable:true,get:function(){return DEV;}});\nObject.defineProperty(__exports,\"isObject\",{enumerable:true,get:function(){return isObject;}});\nObject.defineProperty(__exports,\"isFunction\",{enumerable:true,get:function(){return isFunction;}});\nObject.defineProperty(__exports,\"isNil\",{enumerable:true,get:function(){return isNil;}});\nObject.defineProperty(__exports,\"isBlank\",{enumerable:true,get:function(){return isBlank;}});\nObject.defineProperty(__exports,\"isCtor\",{enumerable:true,get:function(){return isCtor;}});\nObject.defineProperty(__exports,\"pathGetter\",{enumerable:true,get:function(){return pathGetter;}});\nObject.defineProperty(__exports,\"pathSetter\",{enumerable:true,get:function(){return pathSetter;}});\nObject.defineProperty(__exports,\"getPath\",{enumerable:true,get:function(){return getPath;}});\nObject.defineProperty(__exports,\"setPath\",{enumerable:true,get:function(){return setPath;}});\nObject.defineProperty(__exports,\"humanise\",{enumerable:true,get:function(){return humanise;}});\nObject.defineProperty(__exports,\"escapeHtml\",{enumerable:true,get:function(){return escapeHtml;}});\nObject.defineProperty(__exports,\"titleCase\",{enumerable:true,get:function(){return titleCase;}});\nObject.defineProperty(__exports,\"expand\",{enumerable:true,get:function(){return expand;}});\nObject.defineProperty(__exports,\"toArray\",{enumerable:true,get:function(){return toArray;}});\nObject.defineProperty(__exports,\"merge\",{enumerable:true,get:function(){return merge;}});\nObject.defineProperty(__exports,\"mergeRow\",{enumerable:true,get:function(){return mergeRow;}});\nObject.defineProperty(__exports,\"Lru\",{enumerable:true,get:function(){return Lru;}});\nObject.defineProperty(__exports,\"collator\",{enumerable:true,get:function(){return collator;}});\nObject.defineProperty(__exports,\"defaultCompare\",{enumerable:true,get:function(){return defaultCompare;}});\nObject.defineProperty(__exports,\"now\",{enumerable:true,get:function(){return now;}});\nObject.defineProperty(__exports,\"nextFrame\",{enumerable:true,get:function(){return nextFrame;}});\nObject.defineProperty(__exports,\"cancelFrame\",{enumerable:true,get:function(){return cancelFrame;}});\nObject.defineProperty(__exports,\"frameBatched\",{enumerable:true,get:function(){return frameBatched;}});\nObject.defineProperty(__exports,\"settleDebounce\",{enumerable:true,get:function(){return settleDebounce;}});\nObject.defineProperty(__exports,\"whenIdle\",{enumerable:true,get:function(){return whenIdle;}});\nObject.defineProperty(__exports,\"uid\",{enumerable:true,get:function(){return uid;}});\nconst STAMPED_VERSION=\"1.56.0\";\nasync function resolveVersion(){\nif(STAMPED_VERSION!=='0.0.0-source')return STAMPED_VERSION;\ntry{\nif(typeof process==='undefined'||!process.versions||!process.versions.node){\nreturn STAMPED_VERSION;\n}\nconst mod=await import('node:'+'module');\nconst req=mod.createRequire((typeof document!=='undefined'&&document.currentScript?document.currentScript.src:''));\nconst fs=req('node:'+'fs');\nconst url=new URL('../../../../package.json',(typeof document!=='undefined'&&document.currentScript?document.currentScript.src:''));\nconst text=fs.readFileSync(url,'utf8');\nreturn JSON.parse(text).version||STAMPED_VERSION;\n}catch{\nreturn STAMPED_VERSION;\n}\n}\nconst VERSION=\"1.56.0\";\nconst warned=new Set();\nconst WARNED_LIMIT=2000;\nfunction rememberWarned(key){\nwarned.add(key);\nif(warned.size>WARNED_LIMIT){\nconst oldest=warned.values().next().value;\nif(oldest!==undefined)warned.delete(oldest);\n}\n}\nconst reported=[];\nconst REPORT_LIMIT=500;\nfunction record(key,level,message){\nreported.push({\nkey,\nlevel,\nmessage:message.map((m)=>(typeof m==='string'?m:safeString(m))).join(' '),\nat:Date.now(),\n});\nif(reported.length>REPORT_LIMIT)reported.shift();\n}\nfunction safeString(value){\nif(value instanceof Error)return value.message;\ntry{return JSON.stringify(value);}catch{return String(value);}\n}\nfunction reportedWarnings(){return reported.map((r)=>({...r}));}\nfunction warnOnce(key,...message){\nif(warned.has(key))return;\nrememberWarned(key);\nrecord(key,'warn',message);\nconsole.warn('[lattice]',...message);\n}\nfunction infoOnce(key,...message){\nif(warned.has(key))return;\nrememberWarned(key);\nrecord(key,'info',message);\nconsole.info('[lattice]',...message);\n}\nfunction resetWarnings(){\nwarned.clear();\nreported.length=0;\n}\nfunction fail(message,extra){\nconst err=new Error(`[lattice] ${message}`);\nif(extra!==undefined)err.cause=extra;\nthrow err;\n}\nfunction invariant(condition,message){\nif(!condition)fail(message);\n}\nconst DEV=(()=>{\ntry{\nreturn!(typeof process!=='undefined'&&process.env\n&&process.env.NODE_ENV==='production');\n}catch{\nreturn true;\n}\n})();\nfunction isObject(v){\nreturn v!==null&&typeof v==='object'&&!Array.isArray(v);\n}\nfunction isFunction(v){\nreturn typeof v==='function';\n}\nfunction isNil(v){\nreturn v===null||v===undefined;\n}\nfunction isBlank(v){\nreturn v===null||v===undefined||v==='';\n}\nfunction isCtor(v){\nif(typeof v!=='function')return false;\nif(/^class[\\s{]/.test(Function.prototype.toString.call(v)))return true;\nreturn!!(v.prototype&&Object.getOwnPropertyNames(v.prototype).length>1);\n}\nconst pathCache=new Map();\nfunction pathGetter(path){\nlet fn=pathCache.get(path);\nif(fn)return fn;\nif(!path.includes('.')){\nfn=(o)=>(o==null?undefined:o[path]);\n}else{\nconst parts=path.split('.');\nconst n=parts.length;\nfn=(o)=>{\nlet cur=o;\nfor(let i=0;i<n;i++){\nif(cur==null)return undefined;\ncur=cur[parts[i]];\n}\nreturn cur;\n};\n}\npathCache.set(path,fn);\nreturn fn;\n}\nconst setterCache=new Map();\nfunction pathSetter(path){\nlet fn=setterCache.get(path);\nif(fn)return fn;\nif(!path.includes('.')){\nfn=(o,v)=>{if(o!=null)o[path]=v;};\n}else{\nconst parts=path.split('.');\nconst last=parts.length-1;\nfn=(o,v)=>{\nlet cur=o;\nfor(let i=0;i<last;i++){\nif(cur==null)return;\nconst k=parts[i];\nif(cur[k]==null)cur[k]={};\ncur=cur[k];\n}\nif(cur!=null)cur[parts[last]]=v;\n};\n}\nsetterCache.set(path,fn);\nreturn fn;\n}\nfunction getPath(obj,path){\nreturn pathGetter(path)(obj);\n}\nfunction setPath(obj,path,value){\npathSetter(path)(obj,value);\n}\nfunction humanise(field){\nif(!field)return'';\nconst leaf=field.includes('.')?field.slice(field.lastIndexOf('.')+1):field;\nreturn leaf\n.replace(/[_-]+/g,' ')\n.replace(/([a-z0-9])([A-Z])/g,'$1 $2')\n.replace(/([A-Z]+)([A-Z][a-z])/g,'$1 $2')\n.replace(/\\s+/g,' ')\n.trim()\n.replace(/^./,(c)=>c.toUpperCase());\n}\nconst ESCAPES={'&':'&amp;','<':'&lt;','>':'&gt;','\"':'&quot;',\"'\":'&#39;'};\nfunction escapeHtml(s){\nconst str=s==null?'':String(s);\nreturn/[&<>\"']/.test(str)?str.replace(/[&<>\"']/g,(c)=>ESCAPES[c]):str;\n}\nfunction titleCase(s){\nreturn String(s).replace(/\\w\\S*/g,(t)=>t[0].toUpperCase()+t.slice(1).toLowerCase());\n}\nfunction expand(value,key,whenTrue){\nif(value===undefined)return undefined;\nif(value===true)return{enabled:true,...whenTrue};\nif(value===false)return{enabled:false};\nif(isObject(value))return value;\nreturn{[key]:value,enabled:true};\n}\nfunction toArray(v){\nif(v===undefined||v===null)return[];\nreturn Array.isArray(v)?v:[v];\n}\nconst MERGE_FORBIDDEN_KEYS=Object.freeze(new Set(['__proto__','constructor','prototype']));\nfunction merge(a,b){\nif(!isObject(a))return isObject(b)?{...b}:b;\nif(!isObject(b))return b===undefined?a:b;\nconst out={...a};\nfor(const k of Object.keys(b)){\nif(MERGE_FORBIDDEN_KEYS.has(k))continue;\nconst bv=b[k];\nif(bv===undefined)continue;\nout[k]=isObject(bv)&&isObject(out[k])?merge(out[k],bv):bv;\n}\nreturn out;\n}\nfunction mergeRow(previous,patch){\nif(!isObject(previous)||!isObject(patch)||previous===patch)return patch;\nconst out=Object.create(Object.getPrototypeOf(previous));\nObject.assign(out,previous,patch);\nreturn out;\n}\nclass Lru{\n#max;\n#map=new Map();\n#onEvict;\nconstructor(max=256,onEvict=null){\nthis.#max=max;\nthis.#onEvict=onEvict;\n}\nget size(){\nreturn this.#map.size;\n}\nget max(){\nreturn this.#max;\n}\nset max(v){\nthis.#max=v;\nthis.#trim();\n}\nhas(k){\nreturn this.#map.has(k);\n}\nget(k){\nconst m=this.#map;\nif(!m.has(k))return undefined;\nconst v=m.get(k);\nm.delete(k);\nm.set(k,v);\nreturn v;\n}\npeek(k){\nreturn this.#map.get(k);\n}\nset(k,v){\nconst m=this.#map;\nif(m.has(k))m.delete(k);\nm.set(k,v);\nthis.#trim();\nreturn v;\n}\ndelete(k){\nconst v=this.#map.get(k);\nif(this.#map.delete(k)&&this.#onEvict)this.#onEvict(v,k);\nreturn v;\n}\nclear(){\nif(this.#onEvict)for(const[k,v]of this.#map)this.#onEvict(v,k);\nthis.#map.clear();\n}\nkeys(){\nreturn this.#map.keys();\n}\nvalues(){\nreturn this.#map.values();\n}\n#trim(){\nconst m=this.#map;\nwhile(m.size>this.#max){\nconst oldest=m.keys().next().value;\nconst v=m.get(oldest);\nm.delete(oldest);\nif(this.#onEvict)this.#onEvict(v,oldest);\n}\n}\n}\nconst collators=new Map();\nfunction collator(locale,opts){\nconst key=`${locale||''}|${opts?JSON.stringify(opts):''}`;\nlet c=collators.get(key);\nif(!c){\nc=new Intl.Collator(locale||undefined,{\nnumeric:true,sensitivity:'variant',...opts,\n});\ncollators.set(key,c);\n}\nreturn c;\n}\nfunction defaultCompare(a,b){\nif(a===b)return 0;\nif(a===null||a===undefined)return 1;\nif(b===null||b===undefined)return-1;\nif(typeof a==='number'&&typeof b==='number'){\nif(Number.isNaN(a))return Number.isNaN(b)?0:1;\nif(Number.isNaN(b))return-1;\nreturn a<b?-1:a>b?1:0;\n}\nconst sa=String(a);\nconst sb=String(b);\nreturn sa<sb?-1:sa>sb?1:0;\n}\nfunction now(){\nreturn typeof performance!=='undefined'&&performance.now\n?performance.now()\n:Date.now();\n}\nconst hasRaf=typeof requestAnimationFrame==='function';\nfunction nextFrame(fn){\nif(hasRaf)return requestAnimationFrame(fn);\nreturn setTimeout(()=>fn(now()),16);\n}\nfunction cancelFrame(handle){\nif(handle==null)return;\nif(hasRaf)cancelAnimationFrame(handle);\nelse clearTimeout(handle);\n}\nfunction frameBatched(fn){\nlet handle=null;\nlet lastArgs=null;\nconst run=()=>{\nhandle=null;\nconst a=lastArgs;\nlastArgs=null;\nfn(...(a||[]));\n};\nconst wrapped=(...args)=>{\nlastArgs=args;\nif(handle===null)handle=nextFrame(run);\n};\nwrapped.cancel=()=>{\ncancelFrame(handle);\nhandle=null;\nlastArgs=null;\n};\nwrapped.flush=()=>{\nif(handle!==null){\ncancelFrame(handle);\nrun();\n}\n};\nreturn wrapped;\n}\nfunction settleDebounce(fn,waitMs){\nlet timer=null;\nlet held=null;\nconst trailing=()=>{\ntimer=null;\nif(held===null)return;\nconst args=held;\nheld=null;\nfn(...args);\narm();\n};\nconst arm=()=>{\ntimer=setTimeout(trailing,waitMs);\nif(typeof timer?.unref==='function')timer.unref();\n};\nconst wrapped=(...args)=>{\nif(timer===null){\nfn(...args);\narm();\n}else{\nheld=args;\nclearTimeout(timer);\narm();\n}\n};\nwrapped.flush=()=>{\nif(timer!==null)clearTimeout(timer);\ntimer=null;\nif(held===null)return;\nconst args=held;\nheld=null;\nfn(...args);\n};\nwrapped.cancel=()=>{\nif(timer!==null)clearTimeout(timer);\ntimer=null;\nheld=null;\n};\nwrapped.pending=()=>timer!==null||held!==null;\nreturn wrapped;\n}\nfunction whenIdle(fn,timeout=50){\nif(typeof requestIdleCallback==='function'){\nreturn requestIdleCallback(fn,{timeout});\n}\nreturn setTimeout(()=>fn({timeRemaining:()=>0,didTimeout:true}),1);\n}\nlet idSeq=0;\nfunction uid(prefix='l'){\nreturn`${prefix}${(++idSeq).toString(36)}`;\n}\n});\n__def(\"packages/worker/src/transport.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"PROTOCOL\",{enumerable:true,get:function(){return PROTOCOL;}});\nObject.defineProperty(__exports,\"OPS\",{enumerable:true,get:function(){return OPS;}});\nObject.defineProperty(__exports,\"CONTROL\",{enumerable:true,get:function(){return CONTROL;}});\nObject.defineProperty(__exports,\"ERRORS\",{enumerable:true,get:function(){return ERRORS;}});\nObject.defineProperty(__exports,\"packHandle\",{enumerable:true,get:function(){return packHandle;}});\nObject.defineProperty(__exports,\"packHandles\",{enumerable:true,get:function(){return packHandles;}});\nObject.defineProperty(__exports,\"TransportedDictionary\",{enumerable:true,get:function(){return TransportedDictionary;}});\nObject.defineProperty(__exports,\"unpackHandle\",{enumerable:true,get:function(){return unpackHandle;}});\nObject.defineProperty(__exports,\"unpackHandles\",{enumerable:true,get:function(){return unpackHandles;}});\nObject.defineProperty(__exports,\"createMaskPool\",{enumerable:true,get:function(){return createMaskPool;}});\nObject.defineProperty(__exports,\"isTransferable\",{enumerable:true,get:function(){return isTransferable;}});\nObject.defineProperty(__exports,\"collectTransfers\",{enumerable:true,get:function(){return collectTransfers;}});\nObject.defineProperty(__exports,\"isPortable\",{enumerable:true,get:function(){return isPortable;}});\nObject.defineProperty(__exports,\"filterColumnIds\",{enumerable:true,get:function(){return filterColumnIds;}});\nconst __m0=__req(\"packages/core/src/internal/util.js\");\nconst collator=__m0[\"collator\"];\nconst isFunction=__m0[\"isFunction\"];\nconst PROTOCOL=1;\nconst OPS=Object.freeze({\nSORT_COLUMN:'sortColumn',\nSORT_MULTI:'sortMulti',\nEVALUATE_FILTERS:'evaluateFilters',\nCOMPACT:'compact',\nGROUP_BY_COLUMNS:'groupByColumns',\nTOTAL:'total',\nPIVOT:'pivot',\nFACET:'facet',\nCOLUMNIZE:'columnize',\nCOLLATE_STRING_RANKS:'collateStringRanks',\n});\nconst CONTROL=Object.freeze({\nREADY:'ready',\nCANCEL:'cancel',\nPING:'ping',\n});\nconst ERRORS=Object.freeze({\nNO_COMPUTE:'E_NO_COMPUTE',\nNO_KERNEL:'E_NO_KERNEL',\nABORTED:'E_ABORTED',\nKERNEL:'E_KERNEL',\nPROTOCOL:'E_PROTOCOL',\n});\nfunction packHandle(handle){\nif(handle==null)return null;\nconst presence=handle.presence;\nreturn{\nid:handle.id,\nkind:handle.kind,\nnullable:!!handle.nullable,\nvalues:handle.values??null,\npresence:presence?(presence.words??presence):null,\npresenceBits:presence?(presence.size??(presence.words??presence).length*8):0,\ndict:handle.dict?sliceDictionary(handle.dict):null,\noffsets:handle.offsets??null,\nversion:handle.version??0,\n};\n}\nfunction sliceDictionary(dict){\nif(Array.isArray(dict))return dict;\nif(isFunction(dict.values))return dict.values();\nreturn[];\n}\nfunction packHandles(handles){\nconst out=new Array(handles.length);\nfor(let i=0;i<handles.length;i++)out[i]=packHandle(handles[i]);\nreturn out;\n}\nclass TransportedBitset{\n#words;\n#bits;\nconstructor(words,bits){\nthis.#words=words;\nthis.#bits=bits;\n}\nget words(){return this.#words;}\nget size(){return this.#bits;}\nget(i){return(this.#words[i>>>3]&(1<<(i&7)))!==0;}\ncount(){\nconst w=this.#words;\nlet n=0;\nfor(let i=0;i<w.length;i++){\nlet v=w[i];\nwhile(v){v&=v-1;n++;}\n}\nreturn n;\n}\n}\nclass TransportedDictionary{\n#values;\n#index=null;\n#version=0;\n#ranks=new Map();\nconstructor(values){\nthis.#values=values||[];\n}\nget size(){return this.#values.length;}\nget version(){return this.#version;}\ncodeOf(value){\nif(this.#index===null){\nthis.#index=new Map();\nfor(let i=0;i<this.#values.length;i++)this.#index.set(this.#values[i],i);\n}\nconst found=this.#index.get(value);\nif(found!==undefined)return found;\nconst code=this.#values.length;\nthis.#values.push(value);\nthis.#index.set(value,code);\nthis.#version++;\nreturn code;\n}\nvalueOf(code){return this.#values[code];}\nvalues(){return this.#values;}\nranks(locale){\nconst key=locale||'';\nconst cached=this.#ranks.get(key);\nif(cached&&cached.version===this.#version)return cached.ranks;\nconst n=this.#values.length;\nconst order=new Uint32Array(n);\nfor(let i=0;i<n;i++)order[i]=i;\nconst cmp=collator(locale).compare;\nconst vals=this.#values;\nconst sorted=Array.from(order).sort((a,b)=>{\nconst av=vals[a];\nconst bv=vals[b];\nif(av===bv)return 0;\nif(av===null||av===undefined)return 1;\nif(bv===null||bv===undefined)return-1;\nreturn cmp(String(av),String(bv));\n});\nconst ranks=new Uint32Array(n);\nfor(let r=0;r<sorted.length;r++)ranks[sorted[r]]=r;\nthis.#ranks.set(key,{version:this.#version,ranks});\nreturn ranks;\n}\n}\nfunction unpackHandle(packed){\nif(packed==null)return null;\nconst presence=packed.presence\n?new TransportedBitset(packed.presence,packed.presenceBits||packed.presence.length*8)\n:null;\nconst dict=packed.dict?new TransportedDictionary(packed.dict):null;\nconst values=packed.values;\nconst offsets=packed.offsets??null;\nconst kind=packed.kind;\nconst get=(physical)=>{\nif(presence&&!presence.get(physical))return null;\nswitch(kind){\ncase'dictionary':\nreturn dict?dict.valueOf(values[physical]):values[physical];\ncase'bitset':\nreturn(values[physical>>>3]&(1<<(physical&7)))!==0;\ncase'multi':{\nif(!offsets)return null;\nconst from=offsets[physical];\nconst to=offsets[physical+1];\nconst out=new Array(to-from);\nfor(let i=from;i<to;i++)out[i-from]=dict?dict.valueOf(values[i]):values[i];\nreturn out;\n}\ndefault:\nreturn values[physical];\n}\n};\nreturn{\nid:packed.id,\nkind,\nnullable:packed.nullable,\nvalues,\npresence,\ndict,\noffsets,\nget,\nversion:packed.version,\n};\n}\nfunction unpackHandles(packed){\nconst out=new Array(packed.length);\nfor(let i=0;i<packed.length;i++)out[i]=unpackHandle(packed[i]);\nreturn out;\n}\nfunction createMaskPool(){\nconst masks=[];\nconst indices=[];\nreturn{\nmask(n){\nfor(let i=0;i<masks.length;i++){\nif(masks[i].length>=n){\nconst buf=masks.splice(i,1)[0].subarray(0,n);\nbuf.fill(0);\nreturn buf;\n}\n}\nreturn new Uint8Array(n);\n},\nindices(n){\nfor(let i=0;i<indices.length;i++){\nif(indices[i].length>=n)return indices.splice(i,1)[0].subarray(0,n);\n}\nreturn new Uint32Array(n);\n},\nrelease(buf){\nif(!buf)return;\nif(buf instanceof Uint8Array)masks.push(buf);\nelse if(buf instanceof Uint32Array)indices.push(buf);\n},\nclear(){masks.length=0;indices.length=0;},\n};\n}\nfunction isTransferable(v){\nif(!ArrayBuffer.isView(v))return false;\nconst buf=(v).buffer;\nif(!buf)return false;\nreturn typeof SharedArrayBuffer==='undefined'||!(buf instanceof SharedArrayBuffer);\n}\nfunction collectTransfers(value,out=[]){\nconst add=(v)=>{\nif(!isTransferable(v))return;\nconst buf=(v).buffer;\nif(!out.includes(buf))out.push(buf);\n};\nif(value==null)return out;\nif(ArrayBuffer.isView(value)){add(value);return out;}\nif(Array.isArray(value)){\nfor(const item of value)add(item);\nreturn out;\n}\nif(typeof value==='object'){\nfor(const key of Object.keys(value)){\nconst item=(value)[key];\nif(Array.isArray(item))for(const sub of item)add(sub);\nelse add(item);\n}\n}\nreturn out;\n}\nfunction isPortable(value,depth=0){\nif(value==null)return true;\nconst t=typeof value;\nif(t==='function'||t==='symbol')return false;\nif(t!=='object')return true;\nif(depth>4)return true;\nif(ArrayBuffer.isView(value)||value instanceof ArrayBuffer||value instanceof Date)return true;\nif(Array.isArray(value)){\nfor(const item of value)if(!isPortable(item,depth+1))return false;\nreturn true;\n}\nfor(const key of Object.keys(value)){\nif(!isPortable((value)[key],depth+1))return false;\n}\nreturn true;\n}\nfunction filterColumnIds(filters,out=new Set()){\nif(!filters||typeof filters!=='object')return out;\nconst node=(filters);\nif(typeof node.col==='string')out.add(node.col);\nconst conditions=node.conditions;\nif(Array.isArray(conditions))for(const child of conditions)filterColumnIds(child,out);\nreturn out;\n}\n});\n__def(\"packages/core/src/store/bitset.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"Bitset\",{enumerable:true,get:function(){return Bitset;}});\nconst WORD_BITS=8;\nclass Bitset{\nstatic#POP=new Uint8Array(256);\nstatic{\nfor(let i=1;i<256;i++)Bitset.#POP[i]=Bitset.#POP[i>>1]+(i&1);\n}\n#words;\n#bits;\nconstructor(bits=0){\nconst n=Math.max(0,bits|0);\nthis.#bits=n;\nthis.#words=new Uint8Array(Math.ceil(n/WORD_BITS));\n}\nget size(){return this.#bits;}\nget words(){return this.#words;}\nget bytes(){return this.#words?this.#words.byteLength:0;}\nget(i){\nif(i<0||i>=this.#bits)return 0;\nreturn(this.#words[i>>3]>>(i&7))&1;\n}\nset(i){\nif(i>=0&&i<this.#bits)this.#words[i>>3]|=1<<(i&7);\nreturn this;\n}\nclear(i){\nif(i>=0&&i<this.#bits)this.#words[i>>3]&=~(1<<(i&7));\nreturn this;\n}\nassign(i,bit){return bit?this.set(i):this.clear(i);}\nfill(bit=false){\nthis.#words.fill(bit?0xff:0);\nif(bit)this.#maskTail();\nreturn this;\n}\ngrow(bits){\nconst n=Math.max(0,bits|0);\nif(n<=this.#bits)return this;\nconst need=Math.ceil(n/WORD_BITS);\nif(need>this.#words.length){\nconst next=new Uint8Array(need);\nnext.set(this.#words);\nthis.#words=next;\n}\nthis.#bits=n;\nreturn this;\n}\ncount(){\nconst w=this.#words;\nconst pop=Bitset.#POP;\nlet total=0;\nfor(let i=0;i<w.length;i++)total+=pop[w[i]];\nreturn total;\n}\nand(other){\nconst b=other instanceof Bitset?other.words:other;\nconst w=this.#words;\nconst shared=Math.min(w.length,b.length);\nfor(let i=0;i<shared;i++)w[i]&=b[i];\nfor(let i=shared;i<w.length;i++)w[i]=0;\nreturn this;\n}\nor(other){\nconst b=other instanceof Bitset?other.words:other;\nconst w=this.#words;\nconst shared=Math.min(w.length,b.length);\nfor(let i=0;i<shared;i++)w[i]|=b[i];\nreturn this;\n}\nnot(){\nconst w=this.#words;\nfor(let i=0;i<w.length;i++)w[i]=~w[i]&0xff;\nthis.#maskTail();\nreturn this;\n}\nclone(){\nconst out=new Bitset(this.#bits);\nout.words.set(this.#words.subarray(0,out.words.length));\nreturn out;\n}\nrelease(){\nthis.#words=new Uint8Array(0);\nthis.#bits=0;\n}\n#maskTail(){\nconst used=this.#bits&7;\nif(used===0)return;\nconst last=(this.#bits>>3);\nif(last<this.#words.length)this.#words[last]&=(1<<used)-1;\n}\nstatic from(bools){\nconst arr=Array.isArray(bools)?bools:Array.from(bools);\nconst out=new Bitset(arr.length);\nfor(let i=0;i<arr.length;i++)if(arr[i])out.set(i);\nreturn out;\n}\n}\n});\n__def(\"packages/core/src/store/dictionary.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"Dictionary\",{enumerable:true,get:function(){return Dictionary;}});\nconst __m0=__req(\"packages/core/src/internal/util.js\");\nconst collator=__m0[\"collator\"];\nconst defaultCompare=__m0[\"defaultCompare\"];\nclass Dictionary{\n#values;\n#codes=new Map();\n#version=0;\n#ranks=null;\n#ranksVersion=-1;\n#ranksLocale='\\u0000';\nconstructor(values=[]){\nthis.#values=[];\nfor(let i=0;i<values.length;i++){\nconst v=values[i];\nif(this.#codes.has(v))continue;\nthis.#codes.set(v,this.#values.length);\nthis.#values.push(v);\n}\n}\nget size(){return this.#values.length;}\nget version(){return this.#version;}\nget bytes(){\nlet total=this.#values.length*8;\nfor(let i=0;i<this.#values.length;i++){\nconst v=this.#values[i];\nif(typeof v==='string')total+=v.length*2;\ntotal+=16;\n}\nreturn total;\n}\ncodeOf(value){\nconst existing=this.#codes.get(value);\nif(existing!==undefined)return existing;\nconst code=this.#values.length;\nthis.#values.push(value);\nthis.#codes.set(value,code);\nthis.#version++;\nreturn code;\n}\nlookup(value){\nconst code=this.#codes.get(value);\nreturn code===undefined?-1:code;\n}\nhas(value){return this.#codes.has(value);}\nvalueOf(code){return this.#values[code];}\nvalues(){return this.#values;}\nranks(locale){\nconst key=locale||'';\nif(this.#ranks&&this.#ranksVersion===this.#version&&this.#ranksLocale===key){\nreturn this.#ranks;\n}\nconst n=this.#values.length;\nconst order=new Array(n);\nfor(let i=0;i<n;i++)order[i]=i;\nconst cmp=collator(locale).compare;\nconst values=this.#values;\norder.sort((a,b)=>this.#compare(values[a],values[b],cmp));\nconst ranks=new Uint32Array(n);\nfor(let rank=0;rank<n;rank++)ranks[order[rank]]=rank;\nthis.#ranks=ranks;\nthis.#ranksVersion=this.#version;\nthis.#ranksLocale=key;\nreturn ranks;\n}\n#compare(a,b,compare){\nif(typeof a==='string'&&typeof b==='string')return compare(a,b);\nreturn defaultCompare(a,b);\n}\n}\n});\n__def(\"packages/core/src/store/multivalue.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"MultiValue\",{enumerable:true,get:function(){return MultiValue;}});\nclass MultiValue{\n#values;\n#offsets;\n#rows=0;\n#fill=0;\nconstructor(capacity={}){\nconst rows=Math.max(1,capacity.rows??16);\nconst values=Math.max(1,capacity.values??rows);\nthis.#values=new Int32Array(values);\nthis.#offsets=new Uint32Array(rows+1);\n}\nget values(){return this.#values;}\nget offsets(){return this.#offsets;}\nget rows(){return this.#rows;}\nget length(){return this.#fill;}\nget bytes(){return this.#values.byteLength+this.#offsets.byteLength;}\ncount(r){\nif(r<0||r>=this.#rows)return 0;\nreturn this.#offsets[r+1]-this.#offsets[r];\n}\nat(r){\nif(r<0||r>=this.#rows)return this.#values.subarray(0,0);\nreturn this.#values.subarray(this.#offsets[r],this.#offsets[r+1]);\n}\nhas(r,code){\nif(r<0||r>=this.#rows)return false;\nconst v=this.#values;\nconst end=this.#offsets[r+1];\nfor(let i=this.#offsets[r];i<end;i++)if(v[i]===code)return true;\nreturn false;\n}\nhasAny(r,codes){\nfor(let i=0;i<codes.length;i++)if(this.has(r,codes[i]))return true;\nreturn false;\n}\nhasAll(r,codes){\nfor(let i=0;i<codes.length;i++)if(!this.has(r,codes[i]))return false;\nreturn true;\n}\nhasNone(r,codes){return!this.hasAny(r,codes);}\npush(codes){\nconst r=this.#rows;\nconst n=codes.length;\nthis.#ensureRows(r+1);\nthis.#ensureValues(this.#fill+n);\nconst start=this.#fill;\nfor(let i=0;i<n;i++)this.#values[start+i]=codes[i]|0;\nthis.#fill+=n;\nthis.#rows=r+1;\nthis.#offsets[r]=start;\nthis.#offsets[r+1]=this.#fill;\nreturn r;\n}\nwrite(r,codes){\nif(r===this.#rows){this.push(codes);return;}\nif(r<0||r>this.#rows)return;\nconst start=this.#offsets[r];\nconst end=this.#offsets[r+1];\nconst n=codes.length;\nif(end-start===n){\nfor(let i=0;i<n;i++)this.#values[start+i]=codes[i]|0;\nreturn;\n}\nthis.#rebuild(r,codes);\n}\ncompact(remap,liveCount,dead){\nconst oldValues=this.#values;\nconst oldOffsets=this.#offsets;\nconst oldRows=this.#rows;\nconst values=new Int32Array(Math.max(1,this.#fill));\nconst offsets=new Uint32Array(liveCount+1);\nlet w=0;\nfor(let p=0;p<oldRows;p++){\nif(remap[p]===dead)continue;\nconst start=oldOffsets[p];\nconst end=oldOffsets[p+1];\noffsets[remap[p]]=w;\nfor(let i=start;i<end;i++)values[w++]=oldValues[i];\noffsets[remap[p]+1]=w;\n}\nthis.#values=values;\nthis.#offsets=offsets;\nthis.#rows=liveCount;\nthis.#fill=w;\n}\nrelease(){\nthis.#values=new Int32Array(0);\nthis.#offsets=new Uint32Array(1);\nthis.#rows=0;\nthis.#fill=0;\n}\n#ensureRows(rows){\nif(rows+1<=this.#offsets.length)return;\nlet cap=this.#offsets.length-1;\nwhile(cap<rows)cap=cap*2||16;\nconst next=new Uint32Array(cap+1);\nnext.set(this.#offsets);\nthis.#offsets=next;\n}\n#ensureValues(n){\nif(n<=this.#values.length)return;\nlet cap=this.#values.length;\nwhile(cap<n)cap=cap*2||16;\nconst next=new Int32Array(cap);\nnext.set(this.#values);\nthis.#values=next;\n}\n#rebuild(r,codes){\nconst oldValues=this.#values;\nconst oldOffsets=this.#offsets;\nconst rows=this.#rows;\nconst delta=codes.length-(oldOffsets[r+1]-oldOffsets[r]);\nconst values=new Int32Array(Math.max(1,this.#fill+delta));\nconst offsets=new Uint32Array(oldOffsets.length);\nlet w=0;\nfor(let p=0;p<rows;p++){\noffsets[p]=w;\nif(p===r){\nfor(let i=0;i<codes.length;i++)values[w++]=codes[i]|0;\n}else{\nfor(let i=oldOffsets[p];i<oldOffsets[p+1];i++)values[w++]=oldValues[i];\n}\noffsets[p+1]=w;\n}\nthis.#values=values;\nthis.#offsets=offsets;\nthis.#fill=w;\n}\n}\n});\n__def(\"packages/core/src/compute/handle.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"identity\",{enumerable:true,get:function(){return identity;}});\nObject.defineProperty(__exports,\"rowCount\",{enumerable:true,get:function(){return rowCount;}});\nObject.defineProperty(__exports,\"bitReader\",{enumerable:true,get:function(){return bitReader;}});\nObject.defineProperty(__exports,\"presenceReader\",{enumerable:true,get:function(){return presenceReader;}});\nObject.defineProperty(__exports,\"dictSize\",{enumerable:true,get:function(){return dictSize;}});\nObject.defineProperty(__exports,\"dictValue\",{enumerable:true,get:function(){return dictValue;}});\nObject.defineProperty(__exports,\"multiValue\",{enumerable:true,get:function(){return multiValue;}});\nObject.defineProperty(__exports,\"valueReader\",{enumerable:true,get:function(){return valueReader;}});\nObject.defineProperty(__exports,\"numericTotalOrder\",{enumerable:true,get:function(){return numericTotalOrder;}});\nObject.defineProperty(__exports,\"valueComparator\",{enumerable:true,get:function(){return valueComparator;}});\nObject.defineProperty(__exports,\"dictRanks\",{enumerable:true,get:function(){return dictRanks;}});\nObject.defineProperty(__exports,\"isMissing\",{enumerable:true,get:function(){return isMissing;}});\nconst __m0=__req(\"packages/core/src/internal/util.js\");\nconst collator=__m0[\"collator\"];\nconst defaultCompare=__m0[\"defaultCompare\"];\nconst warnOnce=__m0[\"warnOnce\"];\nfunction identity(n){\nconst out=new Uint32Array(n);\nfor(let i=0;i<n;i++)out[i]=i;\nreturn out;\n}\nfunction rowCount(handle,opts){\nif(opts&&typeof opts.count==='number')return opts.count;\nif(!handle)return 0;\nif(typeof handle.count==='number')return handle.count;\nif(typeof handle.length==='number')return handle.length;\nconst values=handle.values;\nif(handle.kind==='multi'&&handle.offsets)return Math.max(0,handle.offsets.length-1);\nif(!values)return handle.presence&&typeof handle.presence.size==='number'?handle.presence.size:0;\nif(handle.kind==='bitset'){\nif(typeof values.size==='number')return values.size;\nif(handle.presence&&typeof handle.presence.size==='number')return handle.presence.size;\nwarnOnce(`count:${handle.id}`,`column \"${handle.id}\" is bitset-backed with no declared row count; assuming ${values.length*8}`);\nreturn values.length*8;\n}\nreturn values.length;\n}\nconst bitOrders=new WeakMap();\nfunction bitOrderOf(bitset){\nconst ctor=bitset.constructor;\nif(!ctor)return'unknown';\nconst cached=bitOrders.get(ctor);\nif(cached)return cached;\nlet order='unknown';\ntry{\nlet probe=null;\nif(typeof ctor.from==='function')probe=ctor.from([false,true]);\nelse{\nprobe=new ctor(8);\nprobe.set(1);\n}\nconst words=probe&&probe.words;\nif(words&&words.length){\nif(words[0]===0x02)order='lsb';\nelse if(words[0]===0x40)order='msb';\n}\n}catch{\norder='unknown';\n}\nbitOrders.set(ctor,order);\nreturn order;\n}\nfunction bitReader(bits){\nif(!bits)return()=>0;\nconst raw=bits instanceof Uint8Array?bits:bits.words;\nif(raw instanceof Uint8Array){\nconst order=bits instanceof Uint8Array?'lsb':bitOrderOf(bits);\nif(order==='lsb')return(i)=>(raw[i>>>3]>>>(i&7))&1;\nif(order==='msb')return(i)=>(raw[i>>>3]>>>(7-(i&7)))&1;\n}\nif(typeof bits.get==='function')return(i)=>(bits.get(i)?1:0);\nreturn()=>0;\n}\nfunction presenceReader(handle){\nif(!handle||!handle.presence)return null;\nreturn bitReader(handle.presence);\n}\nfunction dictSize(dict){\nif(!dict)return 0;\nif(typeof dict.size==='number')return dict.size;\nif(typeof dict.values==='function')return dict.values().length;\nreturn 0;\n}\nfunction dictValue(dict,code){\nif(!dict)return null;\nif(typeof dict.valueOf==='function')return dict.valueOf(code);\nif(typeof dict.values==='function')return dict.values()[code];\nreturn null;\n}\nfunction multiValue(handle,i){\nconst offsets=handle.offsets;\nconst values=handle.values;\nif(!offsets||!values)return[];\nconst from=offsets[i];\nconst to=offsets[i+1];\nif(!(to>from))return[];\nconst dict=handle.dict;\nconst out=new Array(to-from);\nfor(let k=from;k<to;k++)out[k-from]=dict?dictValue(dict,values[k]):values[k];\nreturn out;\n}\nfunction valueReader(handle){\nif(!handle)return()=>undefined;\nconst values=handle.values;\nconst present=presenceReader(handle);\nconst kind=handle.kind;\nif(kind==='dictionary'){\nconst dict=handle.dict;\nif(present)return(i)=>(present(i)?dictValue(dict,values[i]):null);\nreturn(i)=>dictValue(dict,values[i]);\n}\nif(kind==='bitset'){\nconst bit=bitReader(values);\nif(present)return(i)=>(present(i)?bit(i)===1:null);\nreturn(i)=>bit(i)===1;\n}\nif(kind==='multi'){\nif(present)return(i)=>(present(i)?multiValue(handle,i):null);\nreturn(i)=>multiValue(handle,i);\n}\nif(!values&&typeof handle.get==='function'){\nconst get=handle.get.bind(handle);\nreturn(i)=>{\nconst v=get(i);\nreturn v===undefined?null:v;\n};\n}\nif(present){\nreturn(i)=>{\nif(!present(i))return null;\nconst v=values[i];\nreturn v===undefined?null:v;\n};\n}\nreturn(i)=>{\nconst v=values[i];\nreturn v===undefined?null:v;\n};\n}\nfunction numericTotalOrder(a,b){\nif(a<b)return-1;\nif(a>b)return 1;\nif(a===b){\nconst na=Object.is(a,-0);\nconst nb=Object.is(b,-0);\nif(na===nb)return 0;\nreturn na?-1:1;\n}\nconst an=Number.isNaN(a);\nconst bn=Number.isNaN(b);\nif(an&&bn)return 0;\nreturn an?1:-1;\n}\nfunction valueComparator(locale){\nconst coll=collator(locale);\nreturn(a,b)=>{\nif(a===b)return 0;\nconst ta=typeof a;\nconst tb=typeof b;\nif(ta==='string'&&tb==='string')return coll.compare(a,b);\nif(ta==='number'&&tb==='number')return numericTotalOrder(a,b);\nif(ta==='boolean'&&tb==='boolean')return a===b?0:a?1:-1;\nif(a instanceof Date||b instanceof Date){\nconst na=a instanceof Date?a.getTime():Number(a);\nconst nb=b instanceof Date?b.getTime():Number(b);\nreturn numericTotalOrder(na,nb);\n}\nreturn defaultCompare(a,b);\n};\n}\nfunction dictRanks(dict,locale){\nif(dict&&typeof dict.ranks==='function')return dict.ranks(locale);\nconst table=dict&&typeof dict.values==='function'?dict.values():[];\nconst n=table.length;\nconst cmp=valueComparator(locale);\nconst order=new Array(n);\nfor(let i=0;i<n;i++)order[i]=i;\norder.sort((a,b)=>cmp(table[a],table[b])||a-b);\nconst ranks=new Uint32Array(n);\nfor(let r=0;r<n;r++)ranks[order[r]]=r;\nreturn ranks;\n}\nfunction isMissing(v){\nreturn v===null||v===undefined||(typeof v==='number'&&Number.isNaN(v));\n}\n});\n__def(\"packages/core/src/compute/sort.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"radixSortFloat64\",{enumerable:true,get:function(){return radixSortFloat64;}});\nObject.defineProperty(__exports,\"radixSortInt32\",{enumerable:true,get:function(){return radixSortInt32;}});\nObject.defineProperty(__exports,\"rankSortDictionary\",{enumerable:true,get:function(){return rankSortDictionary;}});\nObject.defineProperty(__exports,\"mergeSortComparator\",{enumerable:true,get:function(){return mergeSortComparator;}});\nObject.defineProperty(__exports,\"rankSortStrings\",{enumerable:true,get:function(){return rankSortStrings;}});\nObject.defineProperty(__exports,\"collateStringRanks\",{enumerable:true,get:function(){return collateStringRanks;}});\nObject.defineProperty(__exports,\"sortColumn\",{enumerable:true,get:function(){return sortColumn;}});\nObject.defineProperty(__exports,\"sortMulti\",{enumerable:true,get:function(){return sortMulti;}});\nconst __m0=__req(\"packages/core/src/compute/handle.js\");\nconst bitReader=__m0[\"bitReader\"];\nconst dictRanks=__m0[\"dictRanks\"];\nconst dictSize=__m0[\"dictSize\"];\nconst identity=__m0[\"identity\"];\nconst isMissing=__m0[\"isMissing\"];\nconst presenceReader=__m0[\"presenceReader\"];\nconst rowCount=__m0[\"rowCount\"];\nconst valueComparator=__m0[\"valueComparator\"];\nconst valueReader=__m0[\"valueReader\"];\nconst EMPTY_INDICES=new Uint32Array(0);\nconst SCRATCH=new ArrayBuffer(8);\nconst SCRATCH_F64=new Float64Array(SCRATCH);\nconst SCRATCH_U32=new Uint32Array(SCRATCH);\nconst HI=(()=>{\nSCRATCH_F64[0]=-1;\nreturn(SCRATCH_U32[1]&0x80000000)!==0?1:0;\n})();\nconst LO=HI===1?0:1;\nfunction transformDouble(value,out){\nSCRATCH_F64[0]=value;\nlet hi=SCRATCH_U32[HI];\nlet lo=SCRATCH_U32[LO];\nif((hi&0x80000000)!==0){\nhi=~hi>>>0;\nlo=~lo>>>0;\n}else{\nhi=(hi^0x80000000)>>>0;\n}\nout[0]=lo;\nout[1]=hi;\n}\nfunction radixLsd64(idx,lo,hi,n){\nif(n<2)return idx;\nconst hist=new Uint32Array(256*8);\nfor(let i=0;i<n;i++){\nconst l=lo[i];\nconst h=hi[i];\nhist[l&0xff]++;\nhist[256+((l>>>8)&0xff)]++;\nhist[512+((l>>>16)&0xff)]++;\nhist[768+((l>>>24)&0xff)]++;\nhist[1024+(h&0xff)]++;\nhist[1280+((h>>>8)&0xff)]++;\nhist[1536+((h>>>16)&0xff)]++;\nhist[1792+((h>>>24)&0xff)]++;\n}\nlet srcIdx=idx;\nlet srcLo=lo;\nlet srcHi=hi;\nlet dstIdx=new Uint32Array(n);\nlet dstLo=new Uint32Array(n);\nlet dstHi=new Uint32Array(n);\nconst offset=new Uint32Array(256);\nfor(let pass=0;pass<8;pass++){\nconst base=pass<<8;\nconst shift=(pass&3)<<3;\nconst useHi=pass>=4;\nlet skip=false;\nfor(let b=0;b<256;b++){\nif(hist[base+b]===n){skip=true;break;}\n}\nif(skip)continue;\nlet sum=0;\nfor(let b=0;b<256;b++){\noffset[b]=sum;\nsum+=hist[base+b];\n}\nfor(let i=0;i<n;i++){\nconst l=srcLo[i];\nconst h=srcHi[i];\nconst digit=((useHi?h:l)>>>shift)&0xff;\nconst p=offset[digit]++;\ndstIdx[p]=srcIdx[i];\ndstLo[p]=l;\ndstHi[p]=h;\n}\nlet t=srcIdx;srcIdx=dstIdx;dstIdx=t;\nt=srcLo;srcLo=dstLo;dstLo=t;\nt=srcHi;srcHi=dstHi;dstHi=t;\n}\nreturn srcIdx;\n}\nfunction radixLsd32(idx,keys,n){\nif(n<2)return idx;\nconst hist=new Uint32Array(256*4);\nfor(let i=0;i<n;i++){\nconst k=keys[i];\nhist[k&0xff]++;\nhist[256+((k>>>8)&0xff)]++;\nhist[512+((k>>>16)&0xff)]++;\nhist[768+((k>>>24)&0xff)]++;\n}\nlet srcIdx=idx;\nlet srcKeys=keys;\nlet dstIdx=new Uint32Array(n);\nlet dstKeys=new Uint32Array(n);\nconst offset=new Uint32Array(256);\nfor(let pass=0;pass<4;pass++){\nconst base=pass<<8;\nconst shift=pass<<3;\nlet skip=false;\nfor(let b=0;b<256;b++){\nif(hist[base+b]===n){skip=true;break;}\n}\nif(skip)continue;\nlet sum=0;\nfor(let b=0;b<256;b++){\noffset[b]=sum;\nsum+=hist[base+b];\n}\nfor(let i=0;i<n;i++){\nconst k=srcKeys[i];\nconst p=offset[(k>>>shift)&0xff]++;\ndstIdx[p]=srcIdx[i];\ndstKeys[p]=k;\n}\nlet t=srcIdx;srcIdx=dstIdx;dstIdx=t;\nt=srcKeys;srcKeys=dstKeys;dstKeys=t;\n}\nreturn srcIdx;\n}\nfunction countingSort(idx,keys,n,radix){\nconst counts=new Uint32Array(radix+1);\nfor(let i=0;i<n;i++)counts[keys[i]]++;\nlet sum=0;\nfor(let k=0;k<=radix;k++){\nconst c=counts[k];\ncounts[k]=sum;\nsum+=c;\n}\nconst out=new Uint32Array(n);\nfor(let i=0;i<n;i++)out[counts[keys[i]]++]=idx[i];\nreturn out;\n}\nfunction sortUint32Keys(idx,keys,n,radix){\nif(n<2)return idx;\nif(radix<=65536||radix<=n*2)return countingSort(idx,keys,n,radix);\nreturn radixLsd32(idx,keys,n);\n}\nfunction exact(buffer,n){\nif(buffer.length===n&&buffer.byteOffset===0)return buffer;\nreturn Uint32Array.prototype.slice.call(buffer,0,n);\n}\nfunction radixSortFloat64(values,order,descending=false){\nconst src=order||identity(values.length);\nconst n=src.length;\nif(n<2)return Uint32Array.from(src);\nconst idx=new Uint32Array(n);\nconst lo=new Uint32Array(n);\nconst hi=new Uint32Array(n);\nconst nans=new Uint32Array(n);\nconst pair=new Uint32Array(2);\nlet m=0;\nlet nanCount=0;\nfor(let i=0;i<n;i++){\nconst row=src[i];\nconst v=values[row];\nif(Number.isNaN(v)){nans[nanCount++]=row;continue;}\ntransformDouble(v,pair);\nif(descending){\nlo[m]=~pair[0]>>>0;\nhi[m]=~pair[1]>>>0;\n}else{\nlo[m]=pair[0];\nhi[m]=pair[1];\n}\nidx[m++]=row;\n}\nconst sorted=radixLsd64(idx.subarray(0,m),lo.subarray(0,m),hi.subarray(0,m),m);\nif(nanCount===0)return exact(sorted,m);\nconst out=new Uint32Array(n);\nout.set(sorted.subarray(0,m),0);\nout.set(nans.subarray(0,nanCount),m);\nreturn out;\n}\nfunction radixSortInt32(values,order,descending=false){\nconst src=order||identity(values.length);\nconst n=src.length;\nif(n<2)return Uint32Array.from(src);\nconst idx=Uint32Array.from(src);\nconst keys=new Uint32Array(n);\nfor(let i=0;i<n;i++){\nconst k=(values[idx[i]]^0x80000000)>>>0;\nkeys[i]=descending?(~k>>>0):k;\n}\nreturn exact(radixLsd32(idx,keys,n),n);\n}\nfunction rankSortDictionary(handle,order,opts={}){\nconst src=order||identity(rowCount(handle,opts));\nconst n=src.length;\nif(n<2)return Uint32Array.from(src);\nconst ranks=dictRanks(handle.dict,opts.locale);\nconst codes=handle.values;\nconst present=presenceReader(handle);\nconst size=Math.max(dictSize(handle.dict),ranks.length);\nconst absentRank=size;\nconst idx=Uint32Array.from(src);\nconst keys=new Uint32Array(n);\nconst descending=!!opts.descending;\nfor(let i=0;i<n;i++){\nconst row=idx[i];\nlet rank=present&&present(row)===0?absentRank:ranks[codes[row]];\nif(rank===undefined)rank=absentRank;\nkeys[i]=descending?absentRank-rank:rank;\n}\nreturn exact(sortUint32Keys(idx,keys,n,size+1),n);\n}\nfunction mergeSortComparator(values,order,compare){\nconst n=order.length;\nlet src=Uint32Array.from(order);\nif(n<2)return src;\nlet dst=new Uint32Array(n);\nfor(let width=1;width<n;width<<=1){\nfor(let start=0;start<n;start+=width<<1){\nconst mid=Math.min(start+width,n);\nconst end=Math.min(start+(width<<1),n);\nlet i=start;\nlet j=mid;\nlet k=start;\nwhile(i<mid&&j<end){\ndst[k++]=compare(values[src[i]],values[src[j]])<=0?src[i++]:src[j++];\n}\nwhile(i<mid)dst[k++]=src[i++];\nwhile(j<end)dst[k++]=src[j++];\n}\nconst t=src;src=dst;dst=t;\n}\nreturn src;\n}\nfunction sortBitsetColumn(handle,idx,descending){\nconst bit=bitReader(handle.values);\nconst n=idx.length;\nconst out=new Uint32Array(n);\nconst first=descending?1:0;\nlet k=0;\nfor(let i=0;i<n;i++)if(bit(idx[i])===first)out[k++]=idx[i];\nfor(let i=0;i<n;i++)if(bit(idx[i])!==first)out[k++]=idx[i];\nreturn out;\n}\nfunction indexableValues(handle,idx){\nconst values=handle.values;\nconst kind=handle.kind;\nconst direct=(kind==='object'||kind===undefined)&&(Array.isArray(values)||ArrayBuffer.isView(values));\nif(direct&&!handle.presence)return values;\nconst reader=valueReader(handle);\nconst materialised=new Array(rowCount(handle)||0);\nfor(let i=0;i<idx.length;i++){\nconst row=idx[i];\nmaterialised[row]=reader(row);\n}\nreturn materialised;\n}\nfunction allStrings(values,idx){\nfor(let i=0;i<idx.length;i++){\nif(typeof values[idx[i]]!=='string')return false;\n}\nreturn true;\n}\nfunction rankSortStrings(idx,codes,ranks,d,descending){\nconst n=idx.length;\nconst idxOut=Uint32Array.from(idx);\nif(n<2||d<1)return idxOut;\nconst keys=new Uint32Array(n);\nconst top=d-1;\nfor(let i=0;i<n;i++){\nconst rank=ranks[codes[i]];\nkeys[i]=descending?top-rank:rank;\n}\nreturn exact(sortUint32Keys(idxOut,keys,n,d),n);\n}\nfunction collateStringRanks(table,d,locale){\nconst compare=valueComparator(locale);\nconst order=new Array(d);\nfor(let i=0;i<d;i++)order[i]=i;\norder.sort((a,b)=>compare(table[a],table[b])||a-b);\nconst ranks=new Uint32Array(d);\nfor(let r=0;r<d;r++)ranks[order[r]]=r;\nreturn ranks;\n}\nfunction keyedSortStrings(values,idx,opts){\nconst n=idx.length;\nconst codeOf=new Map();\nconst table=[];\nconst codes=new Uint32Array(n);\nfor(let i=0;i<n;i++){\nconst v=values[idx[i]];\nlet c=codeOf.get(v);\nif(c===undefined){c=table.length;codeOf.set(v,c);table.push(v);}\ncodes[i]=c;\n}\nconst d=table.length;\nconst ranks=collateStringRanks(table,d,opts.locale);\nreturn rankSortStrings(idx,codes,ranks,d,!!opts.descending);\n}\nfunction sortByComparator(handle,idx,opts){\nconst values=indexableValues(handle,idx);\nif(idx.length>=2&&allStrings(values,idx)){\nconst index=handle.stringRank;\nif(index&&index.version===handle.version&&index.usable(idx,values,opts.locale)){\nreturn index.sort(idx,opts);\n}\nreturn keyedSortStrings(values,idx,opts);\n}\nconst base=valueComparator(opts.locale);\nconst compare=opts.descending?(a,b)=>base(b,a):base;\nreturn mergeSortComparator(values,idx,compare);\n}\nfunction sortByCompare(handle,idx,opts){\nconst values=indexableValues(handle,idx);\nconst user=opts.compare;\nconst descending=!!opts.descending;\nconst compare=descending\n?(a,b)=>-user(a,b,undefined,undefined,true)\n:(a,b)=>user(a,b,undefined,undefined,false);\nreturn mergeSortComparator(values,idx,compare);\n}\nfunction partitionPresent(handle,idx){\nconst n=idx.length;\nconst present=presenceReader(handle);\nconst values=handle.values;\nconst checkNaN=handle.kind==='float64'&&!!values;\nconst looseKind=handle.kind==='object'||handle.kind==='multi'||handle.kind===undefined;\nif(!present&&!checkNaN&&!looseKind)return{present:idx,absent:EMPTY_INDICES};\nconst keep=new Uint32Array(n);\nconst drop=new Uint32Array(n);\nlet p=0;\nlet a=0;\nif(present&&checkNaN){\nfor(let i=0;i<n;i++){\nconst row=idx[i];\nif(present(row)===1&&!Number.isNaN(values[row]))keep[p++]=row;else drop[a++]=row;\n}\n}else if(checkNaN&&!present){\nfor(let i=0;i<n;i++){\nconst row=idx[i];\nif(!Number.isNaN(values[row]))keep[p++]=row;else drop[a++]=row;\n}\n}else if(present&&!looseKind){\nfor(let i=0;i<n;i++){\nconst row=idx[i];\nif(present(row)===1)keep[p++]=row;else drop[a++]=row;\n}\n}else{\nconst reader=valueReader(handle);\nfor(let i=0;i<n;i++){\nconst row=idx[i];\nif(!isMissing(reader(row)))keep[p++]=row;else drop[a++]=row;\n}\n}\nif(a===0)return{present:idx,absent:EMPTY_INDICES};\nreturn{present:keep.subarray(0,p),absent:drop.subarray(0,a)};\n}\nfunction joinRuns(sorted,absent,nullsFirst){\nif(absent.length===0)return sorted;\nconst out=new Uint32Array(sorted.length+absent.length);\nif(nullsFirst){\nout.set(absent,0);\nout.set(sorted,absent.length);\n}else{\nout.set(sorted,0);\nout.set(absent,sorted.length);\n}\nreturn out;\n}\nfunction sortColumn(handle,order,opts={}){\nconst src=order||identity(rowCount(handle,opts));\nif(!handle||src.length<2)return Uint32Array.from(src);\nconst{present,absent}=partitionPresent(handle,src);\nif(present.length===0)return Uint32Array.from(src);\nconst descending=!!opts.descending;\nlet sorted;\nif(typeof opts.compare==='function'){\nsorted=sortByCompare(handle,present,opts);\n}else{\nswitch(handle.kind){\ncase'float64':\nsorted=radixSortFloat64(handle.values,present,descending);\nbreak;\ncase'int32':\nsorted=radixSortInt32(handle.values,present,descending);\nbreak;\ncase'dictionary':\nsorted=rankSortDictionary(handle,present,opts);\nbreak;\ncase'bitset':\nsorted=sortBitsetColumn(handle,present,descending);\nbreak;\ndefault:\nsorted=sortByComparator(handle,present,opts);\nbreak;\n}\n}\nreturn joinRuns(sorted,absent,!!opts.nullsFirst);\n}\nfunction sortMulti(handles,entries,order,opts={}){\nconst list=entries||[];\nconst first=(list.length&&(list[0].handle||byId(handles,list[0].col)))||(handles&&handles[0]);\nlet current=order||identity(rowCount(first,opts));\nfor(let i=list.length-1;i>=0;i--){\nconst entry=list[i];\nconst handle=entry.handle||byId(handles,entry.col)||(handles&&handles[i]);\nif(!handle)continue;\ncurrent=sortColumn(handle,current,{\ndescending:entry.descending!==undefined?!!entry.descending:entry.dir==='desc',\nnullsFirst:!!entry.nullsFirst,\nlocale:entry.locale!==undefined?entry.locale:opts.locale,\ncompare:entry.compare,\n});\n}\nreturn current instanceof Uint32Array?current:Uint32Array.from(current);\n}\nfunction byId(handles,id){\nif(!handles||id===undefined)return undefined;\nfor(let i=0;i<handles.length;i++)if(handles[i]&&handles[i].id===id)return handles[i];\nreturn undefined;\n}\n});\n__def(\"packages/core/src/store/stringrank.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"DEFAULT_MAX_DISTINCT\",{enumerable:true,get:function(){return DEFAULT_MAX_DISTINCT;}});\nObject.defineProperty(__exports,\"StringRankIndex\",{enumerable:true,get:function(){return StringRankIndex;}});\nconst __m0=__req(\"packages/core/src/compute/sort.js\");\nconst collateStringRanks=__m0[\"collateStringRanks\"];\nconst rankSortStrings=__m0[\"rankSortStrings\"];\nconst DEFAULT_MAX_DISTINCT=100000;\nclass StringRankIndex{\n#table=[];\n#codeOf=new Map();\n#codeByRow;\n#length=0;\n#generation=0;\n#stamp=-1;\n#maxDistinct;\n#capped=false;\n#ranks=null;\n#ranksGeneration=-1;\n#ranksLocale='\\u0000';\nconstructor(maxDistinct=DEFAULT_MAX_DISTINCT){\nthis.#maxDistinct=maxDistinct>0?maxDistinct:DEFAULT_MAX_DISTINCT;\nthis.#codeByRow=new Uint32Array(0);\n}\nget version(){return this.#stamp;}\nset version(version){this.#stamp=version;}\nget generation(){return this.#generation;}\nget size(){return this.#table.length;}\nget capped(){return this.#capped;}\nget length(){return this.#length;}\nget bytes(){\nlet total=this.#codeByRow.byteLength;\nconst table=this.#table;\nfor(let i=0;i<table.length;i++)total+=table[i].length*2+24;\nreturn total;\n}\n#intern(value,capOnGrowth){\nconst existing=this.#codeOf.get(value);\nif(existing!==undefined)return existing;\nif(this.#capped)return-1;\nif(capOnGrowth&&this.#table.length>=this.#maxDistinct){\nthis.#capped=true;\nreturn-1;\n}\nconst code=this.#table.length;\nthis.#table.push(value);\nthis.#codeOf.set(value,code);\nthis.#generation++;\nreturn code;\n}\nbuild(values,count){\nconst n=count|0;\nthis.#table=[];\nthis.#codeOf=new Map();\nthis.#generation=0;\nthis.#capped=false;\nthis.#ranks=null;\nthis.#ranksGeneration=-1;\nthis.#codeByRow=new Uint32Array(n);\nfor(let row=0;row<n;row++){\nconst v=values[row];\nconst code=typeof v==='string'?this.#intern(v,false):-1;\nthis.#codeByRow[row]=code<0?0:code;\n}\nthis.#length=n;\n}\nappend(values,from,count){\nconst to=(from|0)+(count|0);\nif(to>this.#codeByRow.length){\nconst next=new Uint32Array(to);\nnext.set(this.#codeByRow.subarray(0,this.#length));\nthis.#codeByRow=next;\n}\nfor(let row=from|0;row<to;row++){\nconst v=values[row];\nconst code=typeof v==='string'?this.#intern(v,true):-1;\nthis.#codeByRow[row]=code<0?0:code;\n}\nthis.#length=Math.max(this.#length,to);\n}\nranks(locale){\nconst key=locale||'';\nif(this.#ranks&&this.#ranksGeneration===this.#generation&&this.#ranksLocale===key){\nreturn this.#ranks;\n}\nconst ranks=collateStringRanks(this.#table,this.#table.length,locale);\nthis.#ranks=ranks;\nthis.#ranksGeneration=this.#generation;\nthis.#ranksLocale=key;\nreturn ranks;\n}\nusable(idx,values,locale){\nif(this.#capped||this.#table.length===0)return false;\nconst codeByRow=this.#codeByRow;\nconst table=this.#table;\nconst covered=this.#length;\nfor(let i=0;i<idx.length;i++){\nconst row=idx[i];\nif(row>=covered)return false;\nif(table[codeByRow[row]]!==values[row])return false;\n}\nreturn true;\n}\nsort(idx,opts){\nconst ranks=this.ranks(opts.locale);\nconst d=this.#table.length;\nconst n=idx.length;\nconst codes=new Uint32Array(n);\nconst codeByRow=this.#codeByRow;\nfor(let i=0;i<n;i++)codes[i]=codeByRow[idx[i]];\nreturn rankSortStrings(idx,codes,ranks,d,!!opts.descending);\n}\n}\n});\n__def(\"packages/core/src/store/columnstore.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"REMOVED\",{enumerable:true,get:function(){return REMOVED;}});\nObject.defineProperty(__exports,\"toFloat\",{enumerable:true,get:function(){return toFloat;}});\nObject.defineProperty(__exports,\"ColumnHandle\",{enumerable:true,get:function(){return ColumnHandle;}});\nObject.defineProperty(__exports,\"ColumnStore\",{enumerable:true,get:function(){return ColumnStore;}});\nconst __m0=__req(\"packages/core/src/internal/util.js\");\nconst warnOnce=__m0[\"warnOnce\"];\nconst isFunction=__m0[\"isFunction\"];\nconst pathGetter=__m0[\"pathGetter\"];\nconst __m1=__req(\"packages/core/src/store/bitset.js\");\nconst Bitset=__m1[\"Bitset\"];\nconst __m2=__req(\"packages/core/src/store/dictionary.js\");\nconst Dictionary=__m2[\"Dictionary\"];\nconst __m3=__req(\"packages/core/src/store/multivalue.js\");\nconst MultiValue=__m3[\"MultiValue\"];\nconst __m4=__req(\"packages/core/src/store/stringrank.js\");\nconst StringRankIndex=__m4[\"StringRankIndex\"];\nconst REMOVED=0xFFFFFFFF;\nconst DEFAULT_CAPACITY=1024;\nconst DEFAULT_COLUMNAR_BELOW=5000;\nconst DEFAULT_COMPACT_RATIO=0.2;\nconst KINDS=new Set(['float64','int32','bitset','dictionary','object','multi']);\nfunction absent(v){return v===null||v===undefined;}\nfunction toFloat(v){\nif(typeof v==='number')return v;\nif(v instanceof Date)return v.getTime();\nif(typeof v==='boolean')return v?1:0;\nconst n=Number(v);\nreturn Number.isNaN(n)&&typeof v==='string'?Date.parse(v):n;\n}\nfunction toInt(v){\nconst n=toFloat(v);\nreturn Number.isFinite(n)?n|0:0;\n}\nfunction toMembers(v){\nif(absent(v))return[];\nreturn Array.isArray(v)?v:[v];\n}\nfunction decodeFrom(old,p){\nswitch(old.kind){\ncase'float64':\ncase'int32':return old.buf[p];\ncase'bitset':return old.bits.get(p)===1;\ncase'dictionary':return old.dict.valueOf(old.buf[p]);\ncase'multi':{\nconst codes=old.mv.at(p);\nconst out=new Array(codes.length);\nfor(let i=0;i<codes.length;i++)out[i]=old.dict.valueOf(codes[i]);\nreturn out;\n}\ndefault:return old.buf[p];\n}\n}\nfunction decodePacked(frag,i){\nswitch(frag.kind){\ncase'float64':\ncase'int32':return frag.values[i];\ncase'bitset':return(frag.values[i>>3]&(1<<(i&7)))!==0;\ncase'dictionary':return(frag.table||[])[frag.values[i]];\ncase'multi':{\nconst start=frag.offsets[i];\nconst end=frag.offsets[i+1];\nconst table=frag.table||[];\nconst out=new Array(end-start);\nfor(let k=start;k<end;k++)out[k-start]=table[frag.values[k]];\nreturn out;\n}\ndefault:return frag.values[i];\n}\n}\nclass ColumnHandle{\n#id;\n#kind;\n#target;\n#nullable;\n#read;\n#host;\n#seed;\n#columnar=false;\n#buf=null;\n#bits=null;\n#mv=null;\n#dict=null;\n#stringRank=null;\n#stringRankOn;\n#stringRankMax;\n#stringRankVersion=-1;\n#presence=null;\n#capacity=0;\n#version=0;\n#overlay=null;\n#cache=null;\n#released=false;\nconstructor(schema,host){\nthis.#id=schema.id;\nconst kind=KINDS.has(schema.kind)?schema.kind:'object';\nif(schema.kind&&!KINDS.has(schema.kind)){\nwarnOnce(`store.kind.${schema.id}`,\n`column \"${schema.id}\" declares unknown storage kind \"${schema.kind}\"; falling back to object`);\n}\nthis.#target=kind;\nthis.#kind=kind;\nthis.#nullable=schema.nullable!==false;\nthis.#seed=schema.dictionary??null;\nthis.#host=host;\nthis.#read=isFunction(schema.read)\n?schema.read\n:pathGetter(schema.field||schema.id);\nthis.#stringRankOn=schema.stringRankIndex!=='off';\nthis.#stringRankMax=typeof schema.stringRankMaxDistinct==='number'\n?schema.stringRankMaxDistinct\n:0;\nthis.#overlay=new Map();\n}\nget id(){return this.#id;}\nget kind(){return this.#columnar?this.#kind:'object';}\nget target(){return this.#target;}\nget nullable(){return this.#nullable;}\nget values(){\nif(this.#released)return null;\nif(!this.#columnar)return this.#lazy().values;\nif(this.#kind==='bitset')return this.#bits.words;\nif(this.#kind==='multi')return this.#mv.values;\nreturn this.#buf;\n}\nget presence(){\nif(this.#released||!this.#nullable)return null;\nreturn this.#columnar?this.#presence:this.#lazy().presence;\n}\nget dict(){\nif(this.#released||!this.#columnar)return null;\nreturn this.#kind==='dictionary'||this.#kind==='multi'?this.#dict:null;\n}\nget stringRank(){\nif(this.#released||!this.#stringRankOn)return null;\nif(this.kind!=='object')return null;\nconst values=this.values;\nconst n=this.#host.physical();\nif(!values||n===0)return null;\nif(this.#stringRank===null){\nif(typeof values[0]!=='string')return null;\nconst index=new StringRankIndex(this.#resolveStringRankMax());\nindex.build(values,n);\nindex.version=this.#version;\nthis.#stringRank=index;\nthis.#stringRankVersion=this.#version;\nreturn index.capped?null:index;\n}\nif(this.#stringRank.length<n){\nthis.#stringRank.append(values,this.#stringRank.length,n-this.#stringRank.length);\n}\nthis.#stringRank.version=this.#version;\nthis.#stringRankVersion=this.#version;\nreturn this.#stringRank.capped?null:this.#stringRank;\n}\n#resolveStringRankMax(){return this.#stringRankMax;}\n#dropStringRank(){\nthis.#stringRank=null;\nthis.#stringRankVersion=-1;\n}\nget offsets(){\nif(this.#released||!this.#columnar||this.#kind!=='multi')return null;\nreturn this.#mv.offsets;\n}\nget version(){return this.#version;}\nget bytes(){\nlet total=0;\nif(this.#buf)total+=this.#buf.byteLength??this.#buf.length*8;\nif(this.#bits)total+=this.#bits.bytes;\nif(this.#mv)total+=this.#mv.bytes;\nif(this.#presence)total+=this.#presence.bytes;\nif(this.#dict)total+=this.#dict.bytes;\nif(this.#overlay)total+=this.#overlay.size*24;\nreturn total;\n}\nget(physical){\nif(this.#released)return undefined;\nif(physical<0||physical>=this.#host.physical())return undefined;\nif(!this.#columnar)return this.#rowValue(physical);\nif(this.#nullable&&this.#presence.get(physical)===0)return null;\nswitch(this.#kind){\ncase'float64':\ncase'int32':return this.#buf[physical];\ncase'bitset':return this.#bits.get(physical)===1;\ncase'dictionary':return this.#dict.valueOf(this.#buf[physical]);\ncase'multi':{\nconst codes=this.#mv.at(physical);\nconst out=new Array(codes.length);\nfor(let i=0;i<codes.length;i++)out[i]=this.#dict.valueOf(codes[i]);\nreturn out;\n}\ndefault:return this.#buf[physical];\n}\n}\nset(physical,value){\nif(this.#released)return;\nif(this.#columnar)this.#writeValue(physical,value);\nelse this.#overlay.set(physical,value===undefined?null:value);\nif(this.#stringRank)this.#dropStringRank();\nthis.#version++;\n}\nread(row){return this.#read(row);}\nappendColumn(objects,from,n){\nif(this.#released||n<=0)return;\nif(!this.#columnar){this.#version++;return;}\nconst read=this.#read;\nconst nullable=this.#nullable;\nconst presence=this.#presence;\nlet sawAbsent=false;\nswitch(this.#kind){\ncase'float64':{\nconst buf=this.#buf;\nfor(let i=0;i<n;i++){\nconst v=read(objects[i]);\nif(typeof v==='number'){\nif(nullable)presence.set(from+i);\nbuf[from+i]=v;\ncontinue;\n}\nconst gone=v===null||v===undefined;\nif(nullable)presence.assign(from+i,!gone);\nelse if(gone)sawAbsent=true;\nbuf[from+i]=gone?NaN:toFloat(v);\n}\nbreak;\n}\ncase'int32':{\nconst buf=this.#buf;\nfor(let i=0;i<n;i++){\nconst v=read(objects[i]);\nconst gone=v===null||v===undefined;\nif(nullable)presence.assign(from+i,!gone);\nelse if(gone)sawAbsent=true;\nbuf[from+i]=gone?0:toInt(v);\n}\nbreak;\n}\ncase'bitset':{\nconst bits=this.#bits;\nfor(let i=0;i<n;i++){\nconst v=read(objects[i]);\nconst gone=v===null||v===undefined;\nif(nullable)presence.assign(from+i,!gone);\nelse if(gone)sawAbsent=true;\nbits.assign(from+i,!gone&&!!v);\n}\nbreak;\n}\ncase'dictionary':{\nconst buf=this.#buf;\nconst dict=this.#dict;\nfor(let i=0;i<n;i++){\nconst v=read(objects[i]);\nconst gone=v===null||v===undefined;\nif(nullable)presence.assign(from+i,!gone);\nelse if(gone)sawAbsent=true;\nbuf[from+i]=gone?0:dict.codeOf(v);\n}\nbreak;\n}\ncase'multi':{\nconst mv=this.#mv;\nconst dict=this.#dict;\nfor(let i=0;i<n;i++){\nconst v=read(objects[i]);\nconst gone=v===null||v===undefined;\nif(nullable)presence.assign(from+i,!gone);\nelse if(gone)sawAbsent=true;\nconst members=toMembers(v);\nconst codes=new Array(members.length);\nfor(let k=0;k<members.length;k++)codes[k]=dict.codeOf(members[k]);\nmv.write(from+i,codes);\n}\nbreak;\n}\ndefault:{\nconst buf=this.#buf;\nfor(let i=0;i<n;i++){\nconst v=read(objects[i]);\nconst gone=v===null||v===undefined;\nif(nullable)presence.assign(from+i,!gone);\nelse if(gone)sawAbsent=true;\nbuf[from+i]=gone?null:v;\n}\nbreak;\n}\n}\nif(sawAbsent){\nwarnOnce(`store.null.${this.#id}`,\n`column \"${this.#id}\" is declared non-nullable but received null; storing a filler value`);\n}\nif(this.#stringRank&&this.#kind==='object'){\nthis.#stringRank.append(this.#buf,from,n);\nthis.#stringRank.version=this.#version+1;\nthis.#stringRankVersion=this.#version+1;\n}\nthis.#version++;\n}\nappendPacked(frag,from,n){\nif(this.#released||n<=0||!frag)return;\nif(!this.#columnar){this.#version++;return;}\nconst presence=this.#presence;\nconst fragPresence=frag.presence;\nif(presence){\nif(fragPresence){\nfor(let i=0;i<n;i++)presence.assign(from+i,(fragPresence[i>>3]&(1<<(i&7)))!==0);\n}else{\nfor(let i=0;i<n;i++)presence.set(from+i);\n}\n}\nconst kindsAgree=frag.kind===this.#kind;\nif(kindsAgree&&(this.#kind==='float64'||this.#kind==='int32')){\nthis.#buf.set(frag.values,from);\nthis.#version++;\nreturn;\n}\nif(kindsAgree&&this.#kind==='bitset'){\nconst words=frag.values;\nfor(let i=0;i<n;i++)this.#bits.assign(from+i,(words[i>>3]&(1<<(i&7)))!==0);\nthis.#version++;\nreturn;\n}\nif(kindsAgree&&this.#kind==='dictionary'){\nconst table=frag.table||[];\nconst remap=new Uint32Array(table.length);\nfor(let t=0;t<table.length;t++)remap[t]=this.#dict.codeOf(table[t]);\nconst codes=frag.values;\nconst buf=this.#buf;\nconst pres=presence;\nfor(let i=0;i<n;i++){\nif(pres&&(fragPresence?(fragPresence[i>>3]&(1<<(i&7)))===0:false)){buf[from+i]=0;continue;}\nbuf[from+i]=remap[codes[i]]??0;\n}\nthis.#version++;\nreturn;\n}\nif(kindsAgree&&this.#kind==='multi'){\nconst table=frag.table||[];\nconst remap=new Uint32Array(table.length);\nfor(let t=0;t<table.length;t++)remap[t]=this.#dict.codeOf(table[t]);\nconst flat=frag.values;\nconst offsets=frag.offsets;\nfor(let i=0;i<n;i++){\nconst start=offsets[i];\nconst end=offsets[i+1];\nconst codes=new Array(end-start);\nfor(let k=start;k<end;k++)codes[k-start]=remap[flat[k]]??0;\nthis.#mv.write(from+i,codes);\n}\nthis.#version++;\nreturn;\n}\nfor(let i=0;i<n;i++){\nconst gone=fragPresence\n?(fragPresence[i>>3]&(1<<(i&7)))===0\n:(frag.kind==='object'?frag.values[i]===null:false);\nthis.#writeValue(from+i,gone?null:decodePacked(frag,i));\n}\nthis.#version++;\n}\ntouch(){this.#version++;}\ncolumnarise(capacity,fill){\nif(this.#columnar||this.#released)return;\nconst values=new Array(fill);\nfor(let p=0;p<fill;p++)values[p]=this.#rowValue(p);\nthis.#kind=this.#target;\nthis.#columnar=true;\nthis.#alloc(capacity);\nfor(let p=0;p<fill;p++)this.#writeValue(p,values[p]);\nthis.#overlay.clear();\nthis.#cache=null;\nthis.#dropStringRank();\nthis.#version++;\n}\ngrow(capacity){\nif(!this.#columnar||this.#released||capacity<=this.#capacity)return;\nswitch(this.#kind){\ncase'float64':case'int32':case'dictionary':{\nconst next=new this.#buf.constructor(capacity);\nnext.set(this.#buf);\nthis.#buf=next;\nbreak;\n}\ncase'bitset':this.#bits.grow(capacity);break;\ncase'multi':break;\ndefault:this.#buf.length=capacity;break;\n}\nif(this.#presence)this.#presence.grow(capacity);\nthis.#capacity=capacity;\nthis.#version++;\n}\nconvert(kind){\nif(this.#released||!KINDS.has(kind))return false;\nthis.#target=kind;\nif(!this.#columnar||kind===this.#kind)return false;\nconst old={kind:this.#kind,buf:this.#buf,bits:this.#bits,mv:this.#mv,dict:this.#dict};\nconst n=this.#host.physical();\nconst presence=this.#presence;\nthis.#kind=kind;\nthis.#alloc(this.#capacity);\nfor(let p=0;p<n;p++){\nconst gone=presence!==null&&presence.get(p)===0;\nif(gone&&kind!=='multi')continue;\nthis.#writeValue(p,gone?null:decodeFrom(old,p));\n}\nthis.#dropStringRank();\nthis.#version++;\nreturn true;\n}\ncompact(remap,oldFill,liveCount){\nif(this.#released)return;\nthis.#dropStringRank();\nif(!this.#columnar){\nconst overlay=this.#overlay;\nif(overlay.size){\nconst next=new Map();\nfor(const[p,v]of overlay)if(remap[p]!==REMOVED)next.set(remap[p],v);\nthis.#overlay=next;\n}\nthis.#cache=null;\nthis.#version++;\nreturn;\n}\nswitch(this.#kind){\ncase'float64':case'int32':case'dictionary':case'object':{\nconst buf=this.#buf;\nfor(let p=0;p<oldFill;p++)if(remap[p]!==REMOVED)buf[remap[p]]=buf[p];\nif(this.#kind==='object')for(let p=liveCount;p<oldFill;p++)buf[p]=undefined;\nbreak;\n}\ncase'bitset':{\nconst bits=this.#bits;\nfor(let p=0;p<oldFill;p++)if(remap[p]!==REMOVED)bits.assign(remap[p],bits.get(p)===1);\nfor(let p=liveCount;p<oldFill;p++)bits.clear(p);\nbreak;\n}\ncase'multi':this.#mv.compact(remap,liveCount,REMOVED);break;\ndefault:break;\n}\nif(this.#presence){\nconst pres=this.#presence;\nfor(let p=0;p<oldFill;p++)if(remap[p]!==REMOVED)pres.assign(remap[p],pres.get(p)===1);\nfor(let p=liveCount;p<oldFill;p++)pres.clear(p);\n}\nthis.#version++;\n}\nrelease(){\nif(this.#released)return;\nthis.#released=true;\nthis.#buf=null;\nif(this.#bits)this.#bits.release();\nthis.#bits=null;\nif(this.#mv)this.#mv.release();\nthis.#mv=null;\nif(this.#presence)this.#presence.release();\nthis.#presence=null;\nthis.#dict=null;\nthis.#stringRank=null;\nthis.#overlay=new Map();\nthis.#cache=null;\nthis.#capacity=0;\nthis.#version++;\n}\n#alloc(capacity){\nconst cap=Math.max(1,capacity);\nthis.#buf=null;\nthis.#bits=null;\nthis.#mv=null;\nswitch(this.#kind){\ncase'float64':this.#buf=new Float64Array(cap);break;\ncase'int32':this.#buf=new Int32Array(cap);break;\ncase'bitset':this.#bits=new Bitset(cap);break;\ncase'dictionary':\nthis.#buf=new Uint32Array(cap);\nthis.#dict=this.#dict??new Dictionary(this.#seed??[]);\nbreak;\ncase'multi':\nthis.#mv=new MultiValue({rows:cap,values:cap});\nthis.#dict=this.#dict??new Dictionary(this.#seed??[]);\nbreak;\ndefault:this.#buf=new Array(cap);break;\n}\nif(this.#kind!=='dictionary'&&this.#kind!=='multi')this.#dict=null;\nif(this.#nullable){\nif(this.#presence)this.#presence.grow(cap);\nelse this.#presence=new Bitset(cap);\n}\nthis.#capacity=cap;\n}\n#writeValue(p,value){\nconst gone=absent(value);\nif(this.#nullable)this.#presence.assign(p,!gone);\nelse if(gone){\nwarnOnce(`store.null.${this.#id}`,\n`column \"${this.#id}\" is declared non-nullable but received null; storing a filler value`);\n}\nswitch(this.#kind){\ncase'float64':this.#buf[p]=gone?NaN:toFloat(value);break;\ncase'int32':this.#buf[p]=gone?0:toInt(value);break;\ncase'bitset':this.#bits.assign(p,!gone&&!!value);break;\ncase'dictionary':this.#buf[p]=gone?0:this.#dict.codeOf(value);break;\ncase'multi':{\nconst members=toMembers(value);\nconst codes=new Array(members.length);\nfor(let i=0;i<members.length;i++)codes[i]=this.#dict.codeOf(members[i]);\nthis.#mv.write(p,codes);\nbreak;\n}\ndefault:this.#buf[p]=gone?null:value;break;\n}\n}\n#rowValue(p){\nif(this.#overlay.has(p))return this.#overlay.get(p);\nconst v=this.#read(this.#host.rowAt(p));\nreturn v===undefined?null:v;\n}\n#lazy(){\nif(this.#cache&&this.#cache.version===this.#version)return this.#cache;\nconst n=this.#host.physical();\nconst values=new Array(n);\nconst presence=this.#nullable?new Bitset(n):null;\nfor(let p=0;p<n;p++){\nconst v=this.#rowValue(p);\nvalues[p]=v;\nif(presence&&!absent(v))presence.set(p);\n}\nthis.#cache={version:this.#version,values,presence};\nreturn this.#cache;\n}\n}\nclass ColumnStore{\n#schema;\n#handles=new Map();\n#list=[];\n#rows=[];\n#fill=0;\n#capacity=0;\n#live=0;\n#dead=0;\n#tombs=new Bitset(0);\n#columnar=false;\n#retainSource=true;\n#columnarBelow;\n#initial;\n#ratio;\n#destroyed=false;\nconstructor(schema,opts={}){\nthis.#schema=Array.isArray(schema)?schema:[];\nthis.#initial=Math.max(1,opts.initialCapacity??DEFAULT_CAPACITY);\nthis.#retainSource=opts.retainSource!==false;\nthis.#columnarBelow=this.#retainSource?(opts.columnarBelow??DEFAULT_COLUMNAR_BELOW):0;\nthis.#ratio=opts.compactRatio??DEFAULT_COMPACT_RATIO;\nconst host={\nrowAt:(p)=>this.#rows[p],\nphysical:()=>this.#fill,\n};\nfor(const entry of this.#schema){\nif(!entry||!entry.id)continue;\nif(this.#handles.has(entry.id)){\nwarnOnce(`store.dup.${entry.id}`,`duplicate column id \"${entry.id}\" in the store schema; ignoring the second`);\ncontinue;\n}\nconst handle=new ColumnHandle(entry,host);\nthis.#handles.set(entry.id,handle);\nthis.#list.push(handle);\n}\nif(this.#columnarBelow<=0)this.#columnarise();\n}\nget count(){return this.#live;}\nget physical(){return this.#fill;}\nget capacity(){return this.#columnar?this.#capacity:this.#rows.length;}\nget tombstones(){return this.#dead;}\nget columnar(){return this.#columnar;}\nget destroyed(){return this.#destroyed;}\nget bytes(){\nlet total=this.#tombs.bytes+this.#rows.length*8;\nfor(const h of this.#list)total+=h.bytes;\nreturn total;\n}\nappend(objects){\nconst from=this.#fill;\nif(this.#destroyed||!objects)return{from,to:from};\nconst n=objects.length|0;\nif(n===0)return{from,to:from};\nif(this.#retainSource)for(let i=0;i<n;i++)this.#rows[from+i]=objects[i];\nthis.#fill=from+n;\nthis.#live+=n;\nthis.#tombs.grow(this.#fill);\nif(!this.#columnar){\nif(this.#fill>=this.#columnarBelow)this.#columnarise();\nelse for(const h of this.#list)h.touch();\nreturn{from,to:this.#fill};\n}\nthis.#ensure(this.#fill);\nconst cols=this.#list;\nfor(let c=0;c<cols.length;c++)cols[c].appendColumn(objects,from,n);\nreturn{from,to:this.#fill};\n}\nappendPacked(chunk,objects){\nconst from=this.#fill;\nif(this.#destroyed||!chunk)return{from,to:from};\nconst n=chunk.count|0;\nif(n===0)return{from,to:from};\nif(this.#retainSource&&objects){\nfor(let i=0;i<n;i++)this.#rows[from+i]=objects[i];\n}\nthis.#fill=from+n;\nthis.#live+=n;\nthis.#tombs.grow(this.#fill);\nif(!this.#columnar)this.#columnarise();\nthis.#ensure(this.#fill);\nconst byId=new Map();\nfor(const col of chunk.columns)byId.set(col.id,col);\nfor(const h of this.#list){\nconst frag=byId.get(h.id);\nif(frag)h.appendPacked(frag,from,n);\nelse{\nh.grow(this.#capacity);\n}\n}\nreturn{from,to:this.#fill};\n}\nsource(physical){\nif(this.#retainSource)return this.#rows[physical];\nif(physical<0||physical>=this.#fill)return undefined;\nreturn this.#reconstruct(physical);\n}\nsetSource(physical,object){\nif(this.#destroyed)return;\nif(physical<0||physical>=this.#fill)return;\nif(!this.#retainSource)return;\nthis.#rows[physical]=object;\n}\nget(colId,physical){\nconst h=this.#handles.get(colId);\nreturn h?h.get(physical):undefined;\n}\nset(colId,physical,value){\nif(this.#destroyed)return;\nif(physical<0||physical>=this.#fill)return;\nconst h=this.#handles.get(colId);\nif(!h){\nwarnOnce(`store.set.${colId}`,`set() on unknown column \"${colId}\"`);\nreturn;\n}\nh.set(physical,value);\n}\nremove(physical){\nif(this.#destroyed||physical<0||physical>=this.#fill)return false;\nif(this.#tombs.get(physical)===1)return false;\nthis.#tombs.set(physical);\nthis.#dead++;\nthis.#live--;\nreturn true;\n}\nlive(physical){\nif(physical<0||physical>=this.#fill)return false;\nreturn this.#tombs.get(physical)===0;\n}\ncompact(opts={}){\nif(this.#destroyed||this.#dead===0)return null;\nif(!opts.force&&this.#dead/this.#fill<this.#ratio)return null;\nconst oldFill=this.#fill;\nconst remap=new Uint32Array(oldFill);\nlet w=0;\nfor(let p=0;p<oldFill;p++)remap[p]=this.#tombs.get(p)===1?REMOVED:w++;\nfor(const h of this.#list)h.compact(remap,oldFill,w);\nif(this.#retainSource){\nconst rows=this.#rows;\nfor(let p=0;p<oldFill;p++)if(remap[p]!==REMOVED)rows[remap[p]]=rows[p];\nrows.length=w;\n}\nthis.#fill=w;\nthis.#live=w;\nthis.#dead=0;\nthis.#tombs=new Bitset(Math.max(this.#capacity,w));\nreturn remap;\n}\ncolumn(colId){return this.#handles.get(colId);}\ncolumns(){return this.#list.slice();}\nliveIndices(){\nconst out=new Uint32Array(this.#live);\nif(this.#dead===0){\nfor(let p=0;p<this.#fill;p++)out[p]=p;\nreturn out;\n}\nlet k=0;\nfor(let p=0;p<this.#fill;p++)if(this.#tombs.get(p)===0)out[k++]=p;\nreturn out;\n}\nconvert(colId,kind){\nconst h=this.#handles.get(colId);\nreturn h?h.convert(kind):false;\n}\ndestroy(){\nif(this.#destroyed)return;\nthis.#destroyed=true;\nfor(const h of this.#list)h.release();\nthis.#handles.clear();\nthis.#list.length=0;\nthis.#rows.length=0;\nthis.#tombs.release();\nthis.#fill=0;\nthis.#live=0;\nthis.#dead=0;\nthis.#capacity=0;\n}\n#ensure(n){\nif(n<=this.#capacity)return;\nlet cap=this.#capacity||this.#initial;\nwhile(cap<n)cap*=2;\nfor(const h of this.#list)h.grow(cap);\nthis.#tombs.grow(cap);\nthis.#capacity=cap;\n}\n#reconstruct(physical){\nconst out={};\nfor(const h of this.#list)out[h.id]=h.get(physical);\nreturn out;\n}\n#columnarise(){\nif(this.#columnar)return;\nlet cap=this.#initial;\nwhile(cap<this.#fill)cap*=2;\nthis.#columnar=true;\nthis.#capacity=cap;\nthis.#tombs.grow(cap);\nfor(const h of this.#list)h.columnarise(cap,this.#fill);\n}\n}\n});\n__def(\"packages/core/src/store/ingest.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"INGEST_DEFAULTS\",{enumerable:true,get:function(){return INGEST_DEFAULTS;}});\nObject.defineProperty(__exports,\"inferKind\",{enumerable:true,get:function(){return inferKind;}});\nObject.defineProperty(__exports,\"decideText\",{enumerable:true,get:function(){return decideText;}});\nObject.defineProperty(__exports,\"createReaders\",{enumerable:true,get:function(){return createReaders;}});\nObject.defineProperty(__exports,\"Ingest\",{enumerable:true,get:function(){return Ingest;}});\nObject.defineProperty(__exports,\"ingest\",{enumerable:true,get:function(){return ingest;}});\nObject.defineProperty(__exports,\"ingestSync\",{enumerable:true,get:function(){return ingestSync;}});\nconst __m0=__req(\"packages/core/src/internal/util.js\");\nconst now=__m0[\"now\"];\nconst nextFrame=__m0[\"nextFrame\"];\nconst infoOnce=__m0[\"infoOnce\"];\nconst warnOnce=__m0[\"warnOnce\"];\nconst isFunction=__m0[\"isFunction\"];\nconst pathGetter=__m0[\"pathGetter\"];\nconst __m1=__req(\"packages/core/src/store/columnstore.js\");\nconst ColumnStore=__m1[\"ColumnStore\"];\nconst INGEST_DEFAULTS=Object.freeze({\nchunkMs:8,\nchunkRows:512,\nsampleSize:100,\ndictionaryRatio:0.1,\ncolumnarBelow:5000,\ninitialCapacity:1024,\n});\nfunction inferKind(samples,hints={}){\nif(hints.multi)return'multi';\nif(samples.length===0)return'object';\nlet numbers=0;let booleans=0;let strings=0;let dates=0;let arrays=0;\nfor(let i=0;i<samples.length;i++){\nconst v=samples[i];\nif(typeof v==='number')numbers++;\nelse if(typeof v==='boolean')booleans++;\nelse if(typeof v==='string')strings++;\nelse if(v instanceof Date)dates++;\nelse if(Array.isArray(v))arrays++;\n}\nconst n=samples.length;\nif(numbers===n)return'float64';\nif(booleans===n)return'bitset';\nif(dates===n)return'float64';\nif(strings===n)return'text';\nif(arrays===n)return'multi';\nreturn'object';\n}\nfunction decideText(distinct,rows,ratio){\nif(rows<=0)return'dictionary';\nreturn distinct<ratio*rows?'dictionary':'object';\n}\nfunction createReaders(columns,computed,context){\nconst readers=new Map();\nconst base=new Map();\nfor(const col of columns){\nif(col.computed)continue;\nconst read=isFunction(col.read)?col.read:pathGetter(col.field||col.id);\nbase.set(col.id,read);\nreaders.set(col.id,read);\n}\nconst order=computed?.order??[];\nconst fns=computed?.fns??{};\nconst deps=computed?.deps??{};\nconst wrapDeps=computed?.wrapDeps??null;\nconst active=order.filter((id)=>isFunction(fns[id]));\nconst wildcard=active.some((id)=>deps[id]==='*');\nlet memo=new WeakMap();\nconst resolve=(data)=>{\nconst values={};\nif(wildcard)for(const[id,read]of base)values[id]=read(data);\nfor(const id of active){\nconst declared=deps[id];\nlet bag;\nif(declared==='*'){\nbag=values;\n}else{\nbag={};\nconst list=declared||[];\nfor(let i=0;i<list.length;i++){\nconst d=list[i];\nbag[d]=d in values?values[d]:base.get(d)?.(data);\n}\n}\nvalues[id]=fns[id](wrapDeps?wrapDeps(bag,id):bag,{\ndata,row:null,column:null,grid:null,context,\n});\n}\nreturn values;\n};\nconst valuesFor=(data)=>{\nif(data===null||(typeof data!=='object'&&typeof data!=='function'))return resolve(data);\nlet v=memo.get(data);\nif(v===undefined){v=resolve(data);memo.set(data,v);}\nreturn v;\n};\nfor(const id of active){\nreaders.set(id,\n(data)=>valuesFor(data)[id]);\n}\nreturn{\nreaders,\nreset(){memo=new WeakMap();},\n};\n}\nclass ColumnPlan{\nspec;\nread;\nkind;\ninferred;\nnullable;\ncandidate=false;\ndistinct=null;\nchange=null;\nreason='';\nconstructor(spec,read){\nthis.spec=spec;\nthis.read=read;\nthis.kind='object';\nthis.inferred=false;\nthis.nullable=spec.nullable!==false;\n}\n}\nclass Ingest{\n#rows;\n#plans=[];\n#store=null;\n#readers;\n#cursor=0;\n#opts;\n#done=false;\n#cancelled=false;\n#elapsed=0;\n#columnar;\nconstructor(rows,plan={},opts={}){\nthis.#rows=Array.isArray(rows)?rows:Array.from(rows||[]);\nthis.#opts={...INGEST_DEFAULTS,...opts};\nconst columns=plan.columns??[];\nthis.#readers=createReaders(columns,plan.computed??null,plan.context);\nthis.#columnar=this.#rows.length>=this.#opts.columnarBelow;\nthis.#planColumns(columns,plan.computed??null);\nthis.#store=new ColumnStore(this.#plans.map((p)=>({\nid:p.spec.id,\nkind:p.kind,\nnullable:p.nullable,\nread:p.read,\ndictionary:p.spec.dictionary,\n})),{\ninitialCapacity:this.#opts.initialCapacity,\ncolumnarBelow:this.#opts.columnarBelow,\n});\n}\nget store(){return this.#store;}\nget done(){return this.#done||this.#cancelled;}\nget progress(){return this.#cursor;}\nslice(){\nif(this.done)return false;\nif(this.#opts.signal?.aborted){this.#cancelled=true;return false;}\nconst started=now();\nconst{chunkMs,chunkRows}=this.#opts;\nconst total=this.#rows.length;\ndo{\nconst end=Math.min(this.#cursor+chunkRows,total);\nthis.#store.append(this.#rows.slice(this.#cursor,end));\nthis.#measure(this.#cursor,end);\nthis.#cursor=end;\nthis.#readers.reset();\nthis.#reviewCardinality(false);\n}while(this.#cursor<total&&now()-started<chunkMs);\nthis.#elapsed+=now()-started;\nthis.#opts.onProgress?.({loaded:this.#cursor,total});\nif(this.#cursor>=total){\nthis.#reviewCardinality(true);\nthis.#done=true;\nreturn false;\n}\nreturn true;\n}\ncancel(){this.#cancelled=true;}\nresult(){\nreturn{\nstore:this.#store,\nschema:this.#plans.map((p)=>({\nid:p.spec.id,kind:p.kind,nullable:p.nullable,read:p.read,\ndictionary:p.spec.dictionary,\n})),\ndecisions:this.#plans.map((p)=>({\nid:p.spec.id,\nkind:p.kind,\nnullable:p.nullable,\ninferred:p.inferred,\ndistinct:p.candidate||p.change?this.#distinctOf(p):null,\nchange:p.change,\nreason:p.reason,\n})),\ncount:this.#store.count,\nelapsed:this.#elapsed,\ncancelled:this.#cancelled,\n};\n}\n#planColumns(columns,computed){\nconst rows=this.#rows;\nconst sampleN=Math.min(this.#opts.sampleSize,rows.length);\nconst ratio=this.#opts.dictionaryRatio;\nconst pure=computed?.pure instanceof Set\n?computed.pure\n:new Set(computed?.pure??computed?.order??[]);\nfor(const spec of columns){\nif(!spec||!spec.id)continue;\nif(spec.computed&&(spec.pure===false||(computed&&!pure.has(spec.id)))){\nwarnOnce(`ingest.impure.${spec.id}`,\n`column \"${spec.id}\" is an impure computed column and is not materialised into the store`);\ncontinue;\n}\nconst read=this.#readers.readers.get(spec.id)\n??(isFunction(spec.read)?spec.read:pathGetter(spec.field||spec.id));\nconst plan=new ColumnPlan(spec,read);\nif(spec.kind){\nplan.kind=spec.kind;\nplan.reason='declared by the caller';\n}else if(spec.dictionary){\nplan.kind=spec.multi?'multi':'dictionary';\nplan.reason='value table supplied (lookup column)';\n}else{\nconst samples=[];\nfor(let i=0;i<sampleN&&samples.length<this.#opts.sampleSize;i++){\nconst v=read(rows[i]);\nif(v!==null&&v!==undefined)samples.push(v);\n}\nplan.inferred=true;\nconst kind=inferKind(samples,{multi:spec.multi});\nif(kind==='text'){\nconst distinct=new Set(samples).size;\nplan.kind=decideText(distinct,samples.length,ratio);\nplan.candidate=this.#columnar;\nplan.reason=`sampled ${distinct} distinct in ${samples.length}`;\n}else{\nplan.kind=kind;\nplan.reason=`inferred from ${samples.length} sampled values`;\nif(kind==='object'&&samples.length){\ninfoOnce(`ingest.mixed.${spec.id}`,\n`column \"${spec.id}\" holds mixed or unrecognised value types; storing as an object array. Declare a type to avoid this.`);\n}\n}\nif(plan.kind==='object'&&plan.candidate)plan.distinct=new Set(samples);\n}\nthis.#plans.push(plan);\n}\n}\n#measure(from,to){\nconst rows=this.#rows;\nfor(const plan of this.#plans){\nif(!plan.candidate||!plan.distinct)continue;\nconst set=plan.distinct;\nfor(let i=from;i<to;i++){\nconst v=plan.read(rows[i]);\nif(v!==null&&v!==undefined)set.add(v);\n}\n}\n}\n#distinctOf(plan){\nif(plan.distinct)return plan.distinct.size;\nconst handle=this.#store.column(plan.spec.id);\nreturn handle?.dict?handle.dict.size:0;\n}\n#reviewCardinality(final){\nconst ratio=this.#opts.dictionaryRatio;\nconst total=this.#rows.length;\nfor(const plan of this.#plans){\nif(!plan.candidate)continue;\nconst distinct=this.#distinctOf(plan);\nif(plan.kind==='dictionary'&&distinct>=ratio*total){\nconst handle=this.#store.column(plan.spec.id);\nplan.distinct=new Set(handle?.dict?handle.dict.values():[]);\nthis.#store.convert(plan.spec.id,'object');\nplan.kind='object';\nplan.change='demoted';\nplan.reason=`${distinct} distinct values is at or above ${ratio*100}% of ${total} rows`;\ncontinue;\n}\nif(plan.kind==='object'&&distinct>=ratio*total){\nplan.candidate=false;\nplan.distinct=null;\nplan.reason=`${distinct} distinct values is at or above ${ratio*100}% of ${total} rows`;\ncontinue;\n}\nif(final&&plan.kind==='object'&&distinct<ratio*total){\nthis.#store.convert(plan.spec.id,'dictionary');\nplan.kind='dictionary';\nplan.change=plan.change==='demoted'?null:'promoted';\nplan.reason=`${distinct} distinct values is below ${ratio*100}% of ${total} rows`;\nplan.distinct=null;\n}\nif(final)plan.candidate=false;\n}\n}\n}\nasync function ingest(rows,plan={},opts={}){\nconst run=new Ingest(rows,plan,opts);\nconst frame=opts.scheduler?.frame??nextFrame;\nwhile(run.slice()){\nawait new Promise((resolve)=>{frame(resolve);});\n}\nreturn run.result();\n}\nfunction ingestSync(rows,plan={},opts={}){\nconst run=new Ingest(rows,plan,{...opts,chunkMs:Infinity});\nwhile(run.slice());\nreturn run.result();\n}\n});\n__def(\"packages/core/src/store/columnpack.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"isPortableSchema\",{enumerable:true,get:function(){return isPortableSchema;}});\nObject.defineProperty(__exports,\"packChunk\",{enumerable:true,get:function(){return packChunk;}});\nObject.defineProperty(__exports,\"packedTransfers\",{enumerable:true,get:function(){return packedTransfers;}});\nconst __m0=__req(\"packages/core/src/internal/util.js\");\nconst pathGetter=__m0[\"pathGetter\"];\nconst __m1=__req(\"packages/core/src/store/ingest.js\");\nconst inferKind=__m1[\"inferKind\"];\nconst decideText=__m1[\"decideText\"];\nconst INGEST_DEFAULTS=__m1[\"INGEST_DEFAULTS\"];\nconst __m2=__req(\"packages/core/src/store/columnstore.js\");\nconst toFloat=__m2[\"toFloat\"];\nconst PORTABLE_KINDS=new Set(['float64','int32','bitset','dictionary','object','multi']);\nfunction isPortableSchema(schema){\nif(!Array.isArray(schema)||schema.length===0)return false;\nfor(const col of schema){\nif(!col||typeof col.id!=='string')return false;\nif(typeof col.field!=='string'||col.field==='')return false;\nif(col.kind&&!PORTABLE_KINDS.has(col.kind))return false;\n}\nreturn true;\n}\nfunction toInt(v){\nconst n=toFloat(v);\nreturn Number.isFinite(n)?n|0:0;\n}\nfunction toMembers(v){\nif(v===null||v===undefined)return[];\nreturn Array.isArray(v)?v:[v];\n}\nfunction resolveKind(col,values,rows,ratio){\nif(col.kind)return col.kind;\nconst samples=[];\nfor(let i=0;i<values.length&&samples.length<INGEST_DEFAULTS.sampleSize;i++){\nconst v=values[i];\nif(v!==null&&v!==undefined)samples.push(v);\n}\nconst kind=inferKind(samples,{multi:col.multi});\nif(kind!=='text')return kind;\nconst distinct=new Set(samples).size;\nreturn decideText(distinct,samples.length,ratio);\n}\nfunction packChunk(schema,rows,opts={}){\nconst n=rows.length|0;\nconst ratio=opts.dictionaryRatio??INGEST_DEFAULTS.dictionaryRatio;\nconst columns=[];\nfor(const col of schema){\nconst read=pathGetter(col.field||col.id);\nconst nullable=col.nullable!==false;\nconst raw=new Array(n);\nfor(let i=0;i<n;i++){\nconst v=read(rows[i]);\nraw[i]=v===undefined?null:v;\n}\nconst kind=resolveKind(col,raw,n,ratio);\nconst presence=nullable?new Uint8Array((n+7)>>3):null;\nconst present=(i)=>{if(presence)presence[i>>3]|=1<<(i&7);};\nlet packed;\nswitch(kind){\ncase'float64':{\nconst values=new Float64Array(n);\nfor(let i=0;i<n;i++){\nconst v=raw[i];\nconst gone=v===null;\nif(!gone)present(i);\nvalues[i]=gone?NaN:toFloat(v);\n}\npacked={id:col.id,kind,nullable,values,presence,offsets:null,table:null};\nbreak;\n}\ncase'int32':{\nconst values=new Int32Array(n);\nfor(let i=0;i<n;i++){\nconst v=raw[i];\nconst gone=v===null;\nif(!gone)present(i);\nvalues[i]=gone?0:toInt(v);\n}\npacked={id:col.id,kind,nullable,values,presence,offsets:null,table:null};\nbreak;\n}\ncase'bitset':{\nconst words=new Uint8Array((n+7)>>3);\nfor(let i=0;i<n;i++){\nconst v=raw[i];\nconst gone=v===null;\nif(!gone)present(i);\nif(!gone&&!!v)words[i>>3]|=1<<(i&7);\n}\npacked={id:col.id,kind,nullable,values:words,presence,offsets:null,table:null};\nbreak;\n}\ncase'dictionary':{\nconst codes=new Uint32Array(n);\nconst table=[];\nconst index=new Map();\nfor(let i=0;i<n;i++){\nconst v=raw[i];\nif(v===null){codes[i]=0;continue;}\npresent(i);\nlet code=index.get(v);\nif(code===undefined){code=table.length;table.push(v);index.set(v,code);}\ncodes[i]=code;\n}\npacked={id:col.id,kind,nullable,values:codes,presence,offsets:null,table};\nbreak;\n}\ncase'multi':{\nconst table=[];\nconst index=new Map();\nconst offsets=new Uint32Array(n+1);\nconst flat=[];\nfor(let i=0;i<n;i++){\nconst v=raw[i];\noffsets[i]=flat.length;\nconst gone=v===null;\nif(!gone)present(i);\nconst members=toMembers(v);\nfor(let k=0;k<members.length;k++){\nconst m=members[k];\nlet code=index.get(m);\nif(code===undefined){code=table.length;table.push(m);index.set(m,code);}\nflat.push(code);\n}\n}\noffsets[n]=flat.length;\npacked={id:col.id,kind,nullable,values:Int32Array.from(flat),presence,offsets,table};\nbreak;\n}\ndefault:{\nconst values=new Array(n);\nfor(let i=0;i<n;i++){\nconst v=raw[i];\nif(v!==null)present(i);\nvalues[i]=v;\n}\npacked={id:col.id,kind:'object',nullable,values,presence,offsets:null,table:null};\nbreak;\n}\n}\ncolumns.push(packed);\n}\nreturn{count:n,columns};\n}\nfunction packedTransfers(chunk){\nconst out=[];\nif(!chunk||!Array.isArray(chunk.columns))return out;\nconst add=(v)=>{\nif(ArrayBuffer.isView(v)&&v.buffer&&!out.includes(v.buffer))out.push(v.buffer);\n};\nfor(const col of chunk.columns){\nadd(col.values);\nadd(col.presence);\nadd(col.offsets);\n}\nreturn out;\n}\n});\n__def(\"packages/core/src/compute/sortspec.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"collationDescriptor\",{enumerable:true,get:function(){return collationDescriptor;}});\nObject.defineProperty(__exports,\"isPortableSort\",{enumerable:true,get:function(){return isPortableSort;}});\nObject.defineProperty(__exports,\"isPortableSortSet\",{enumerable:true,get:function(){return isPortableSortSet;}});\nObject.defineProperty(__exports,\"describeSortEntry\",{enumerable:true,get:function(){return describeSortEntry;}});\nObject.defineProperty(__exports,\"describeSort\",{enumerable:true,get:function(){return describeSort;}});\nfunction collationDescriptor(locale){\nreturn{locale:locale===undefined?undefined:String(locale),numeric:true,sensitivity:'variant'};\n}\nfunction isPortableSort(entry){\nreturn!!entry&&typeof entry.compare!=='function';\n}\nfunction isPortableSortSet(entries){\nif(!entries)return true;\nfor(let i=0;i<entries.length;i++)if(!isPortableSort(entries[i]))return false;\nreturn true;\n}\nfunction describeSortEntry(entry,locale){\nconst col=entry.col!==undefined?entry.col:(entry.handle&&entry.handle.id);\nconst chosen=entry.locale!==undefined?entry.locale:locale;\nreturn{\ncol,\ndescending:entry.descending!==undefined?!!entry.descending:entry.dir==='desc',\nnullsFirst:!!entry.nullsFirst,\ncollation:collationDescriptor(chosen),\n};\n}\nfunction describeSort(entries,locale){\nconst list=entries||[];\nconst out=new Array(list.length);\nfor(let i=0;i<list.length;i++)out[i]=describeSortEntry(list[i],locale);\nreturn out;\n}\n});\n__def(\"packages/core/src/format/date.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"scanPattern\",{enumerable:true,get:function(){return scanPattern;}});\nObject.defineProperty(__exports,\"toDate\",{enumerable:true,get:function(){return toDate;}});\nObject.defineProperty(__exports,\"compilePattern\",{enumerable:true,get:function(){return compilePattern;}});\nObject.defineProperty(__exports,\"compileDate\",{enumerable:true,get:function(){return compileDate;}});\nObject.defineProperty(__exports,\"toIsoDate\",{enumerable:true,get:function(){return toIsoDate;}});\nObject.defineProperty(__exports,\"toIsoDateTime\",{enumerable:true,get:function(){return toIsoDateTime;}});\nObject.defineProperty(__exports,\"compareIso\",{enumerable:true,get:function(){return compareIso;}});\nconst __m0=__req(\"packages/core/src/internal/util.js\");\nconst isNil=__m0[\"isNil\"];\nconst warnOnce=__m0[\"warnOnce\"];\nconst TOKENS=[\n'yyyy','yy','MMMM','MMM','MM','M','dd','d',\n'EEEE','EEE','HH','H','hh','h','mm','m','ss','s','SSS','a',\n];\nfunction scanPattern(pattern){\nconst out=[];\nlet i=0;\nlet literal='';\nconst flush=()=>{if(literal){out.push({token:null,text:literal});literal='';}};\nwhile(i<pattern.length){\nconst ch=pattern[i];\nif(ch===\"'\"){\nif(pattern[i+1]===\"'\"){literal+=\"'\";i+=2;continue;}\nconst end=pattern.indexOf(\"'\",i+1);\nif(end===-1){literal+=pattern.slice(i+1);i=pattern.length;continue;}\nliteral+=pattern.slice(i+1,end);\ni=end+1;\ncontinue;\n}\nconst token=TOKENS.find((t)=>pattern.startsWith(t,i));\nif(token){flush();out.push({token,text:token});i+=token.length;continue;}\nif(/[A-Za-z]/.test(ch)){\nwarnOnce(\n`date.pattern.token:${ch}`,\n`the date pattern \"${pattern}\" contains '${ch}', which is not a supported token, `\n+'so it is rendered as text. Quote it as a literal to silence this. '\n+`Supported: ${TOKENS.join(' ')}.`,\n);\n}\nliteral+=ch;\ni+=1;\n}\nflush();\nreturn out;\n}\nconst WALL_CLOCK=/^(\\d{4})-(\\d{2})-(\\d{2})(?:[T ](\\d{2}):(\\d{2})(?::(\\d{2}))?(?:\\.\\d+)?)?$/;\nfunction toDate(value){\nif(isNil(value)||value==='')return null;\nif(value instanceof Date)return Number.isNaN(value.getTime())?null:value;\nif(typeof value==='number')return Number.isNaN(value)?null:new Date(value);\nif(typeof value==='string'){\nconst wall=WALL_CLOCK.exec(value.trim());\nif(wall){\nconst[,y,mo,d,h='0',mi='0',sec='0']=wall;\nreturn new Date(+y,+mo-1,+d,+h,+mi,+sec);\n}\nconst d=new Date(value);\nreturn Number.isNaN(d.getTime())?null:d;\n}\nreturn null;\n}\nfunction pad(n,w){return String(n).padStart(w,'0');}\nfunction fieldReader(timeZone){\nif(!timeZone){\nreturn(d)=>({\nyear:d.getFullYear(),month:d.getMonth()+1,day:d.getDate(),\nhour:d.getHours(),minute:d.getMinutes(),second:d.getSeconds(),\nms:d.getMilliseconds(),weekday:d.getDay(),\n});\n}\nconst zoned=new Intl.DateTimeFormat('en-US',{\ntimeZone,year:'numeric',month:'2-digit',day:'2-digit',\nhour:'2-digit',minute:'2-digit',second:'2-digit',hour12:false,weekday:'short',\n});\nconst days={Sun:0,Mon:1,Tue:2,Wed:3,Thu:4,Fri:5,Sat:6};\nreturn(d)=>{\nconst f={year:0,month:1,day:1,hour:0,minute:0,second:0,ms:d.getMilliseconds(),weekday:0};\nfor(const part of zoned.formatToParts(d)){\nswitch(part.type){\ncase'year':f.year=Number(part.value);break;\ncase'month':f.month=Number(part.value);break;\ncase'day':f.day=Number(part.value);break;\ncase'hour':f.hour=Number(part.value)%24;break;\ncase'minute':f.minute=Number(part.value);break;\ncase'second':f.second=Number(part.value);break;\ncase'weekday':f.weekday=days[part.value]??0;break;\ndefault:break;\n}\n}\nreturn f;\n};\n}\nfunction compilePattern(pattern,locale,timeZone){\nconst segments=scanPattern(pattern);\nconst read=fieldReader(timeZone);\nconst used=new Set(segments.filter((s)=>s.token).map((s)=>s.token));\nconst monthShort=used.has('MMM')?new Intl.DateTimeFormat(locale,{month:'short',timeZone}):null;\nconst monthLong=used.has('MMMM')?new Intl.DateTimeFormat(locale,{month:'long',timeZone}):null;\nconst dayShort=used.has('EEE')?new Intl.DateTimeFormat(locale,{weekday:'short',timeZone}):null;\nconst dayLong=used.has('EEEE')?new Intl.DateTimeFormat(locale,{weekday:'long',timeZone}):null;\nreturn(d)=>{\nconst f=read(d);\nlet out='';\nfor(const seg of segments){\nif(!seg.token){out+=seg.text;continue;}\nswitch(seg.token){\ncase'yyyy':out+=pad(f.year,4);break;\ncase'yy':out+=pad(f.year%100,2);break;\ncase'MMMM':out+=monthLong.format(d);break;\ncase'MMM':out+=monthShort.format(d);break;\ncase'MM':out+=pad(f.month,2);break;\ncase'M':out+=String(f.month);break;\ncase'dd':out+=pad(f.day,2);break;\ncase'd':out+=String(f.day);break;\ncase'EEEE':out+=dayLong.format(d);break;\ncase'EEE':out+=dayShort.format(d);break;\ncase'HH':out+=pad(f.hour,2);break;\ncase'H':out+=String(f.hour);break;\ncase'hh':out+=pad(f.hour%12===0?12:f.hour%12,2);break;\ncase'h':out+=String(f.hour%12===0?12:f.hour%12);break;\ncase'mm':out+=pad(f.minute,2);break;\ncase'm':out+=String(f.minute);break;\ncase'ss':out+=pad(f.second,2);break;\ncase's':out+=String(f.second);break;\ncase'SSS':out+=pad(f.ms,3);break;\ncase'a':out+=f.hour<12?'AM':'PM';break;\ndefault:out+=seg.text;break;\n}\n}\nreturn out;\n};\n}\nconst UNITS=[\n['year',365*24*3600e3],\n['month',30*24*3600e3],\n['week',7*24*3600e3],\n['day',24*3600e3],\n['hour',3600e3],\n['minute',60e3],\n['second',1e3],\n];\nfunction compileDate(spec,locale){\nconst s=spec||{};\nconst loc=s.locale||locale||undefined;\nconst nullDisplay=s.nullDisplay??'';\nconst timeZone=s.timeZone;\nlet absolute;\nif(s.pattern){\nabsolute=compilePattern(s.pattern,loc,timeZone);\n}else if(s.dateStyle||s.timeStyle){\nconst opts={timeZone};\nif(s.dateStyle)opts.dateStyle=s.dateStyle;\nif(s.timeStyle)opts.timeStyle=s.timeStyle;\nconst dtf=new Intl.DateTimeFormat(loc,opts);\nabsolute=(d)=>dtf.format(d);\n}else{\nconst dtf=new Intl.DateTimeFormat(loc,{dateStyle:'medium',timeZone});\nabsolute=(d)=>dtf.format(d);\n}\nconst relative=s.relative?new Intl.RelativeTimeFormat(loc,{numeric:'auto'}):null;\nconst thresholdDays=typeof s.relative==='object'&&s.relative\n?(s.relative.threshold??7)\n:7;\nconst thresholdMs=thresholdDays*24*3600e3;\nconst format=(value,params)=>{\nconst d=toDate(value);\nif(!d)return nullDisplay;\nif(relative){\nconst now=params&&typeof params.now==='number'?params.now:Date.now();\nconst delta=d.getTime()-now;\nif(Math.abs(delta)<thresholdMs){\nfor(const[unit,ms]of UNITS){\nif(Math.abs(delta)>=ms||unit==='second'){\nreturn relative.format(Math.round(delta/ms),unit);\n}\n}\n}\n}\nreturn absolute(d);\n};\nformat.spec=s;\nreturn format;\n}\nfunction toIsoDate(value){\nif(isNil(value)||value==='')return null;\nif(typeof value==='string'){\nconst match=/^(\\d{4}-\\d{2}-\\d{2})/.exec(value.trim());\nif(match)return match[1];\nconst parsed=toDate(value);\nreturn parsed?toIsoDate(parsed):null;\n}\nconst date=toDate(value);\nif(!date)return null;\nconst pad=(n)=>String(n).padStart(2,'0');\nreturn`${date.getFullYear()}-${pad(date.getMonth()+1)}-${pad(date.getDate())}`;\n}\nfunction toIsoDateTime(value,timeZone){\nif(isNil(value)||value==='')return null;\nif(typeof value==='string'){\nconst text=value.trim();\nif(ZONE_SUFFIX.test(text)){\nconst instant=toDate(text);\nreturn instant?wallClockIn(instant,timeZone):null;\n}\nconst match=/^(\\d{4}-\\d{2}-\\d{2})[T ](\\d{2}):(\\d{2})(?::(\\d{2}))?/.exec(text);\nif(match){\nconst[,day,hour,minute,second]=match;\nreturn`${day}T${hour}:${minute}${second&&second!=='00'?`:${second}`:''}`;\n}\nif(/^\\d{4}-\\d{2}-\\d{2}$/.test(text))return`${text}T00:00`;\nconst parsed=toDate(text);\nreturn parsed?toIsoDateTime(parsed):null;\n}\nconst date=toDate(value);\nif(!date)return null;\nreturn wallClockIn(date,timeZone);\n}\nconst ZONE_SUFFIX=/(?:Z|[+-]\\d{2}:?\\d{2})$/i;\nfunction wallClockIn(date,timeZone){\nconst pad=(n)=>String(n).padStart(2,'0');\nif(timeZone){\ntry{\nconst parts=new Intl.DateTimeFormat('en-CA',{\ntimeZone,\nyear:'numeric',month:'2-digit',day:'2-digit',\nhour:'2-digit',minute:'2-digit',second:'2-digit',\nhour12:false,\n}).formatToParts(date).reduce((out,part)=>{\nif(part.type!=='literal')out[part.type]=part.value;\nreturn out;\n},{});\nconst hour=parts.hour==='24'?'00':parts.hour;\nconst seconds=Number(parts.second);\nreturn`${parts.year}-${parts.month}-${parts.day}T${hour}:${parts.minute}`\n+(seconds?`:${parts.second}`:'');\n}catch{\n}\n}\nconst day=`${date.getFullYear()}-${pad(date.getMonth()+1)}-${pad(date.getDate())}`;\nconst seconds=date.getSeconds();\nconst clock=`${pad(date.getHours())}:${pad(date.getMinutes())}${seconds?`:${pad(seconds)}`:''}`;\nreturn`${day}T${clock}`;\n}\nfunction compareIso(a,b){\nconst left=isNil(a)||a===''?null:String(a);\nconst right=isNil(b)||b===''?null:String(b);\nif(left===null)return right===null?0:1;\nif(right===null)return-1;\nreturn left<right?-1:left>right?1:0;\n}\n});\n__def(\"packages/core/src/compute/filter.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"releaseMask\",{enumerable:true,get:function(){return releaseMask;}});\nObject.defineProperty(__exports,\"compilePredicate\",{enumerable:true,get:function(){return compilePredicate;}});\nObject.defineProperty(__exports,\"testValue\",{enumerable:true,get:function(){return testValue;}});\nObject.defineProperty(__exports,\"evaluateCondition\",{enumerable:true,get:function(){return evaluateCondition;}});\nObject.defineProperty(__exports,\"evaluateFilters\",{enumerable:true,get:function(){return evaluateFilters;}});\nObject.defineProperty(__exports,\"pruneColumn\",{enumerable:true,get:function(){return pruneColumn;}});\nObject.defineProperty(__exports,\"mentionsColumn\",{enumerable:true,get:function(){return mentionsColumn;}});\nObject.defineProperty(__exports,\"compact\",{enumerable:true,get:function(){return compact;}});\nconst __m0=__req(\"packages/core/src/internal/util.js\");\nconst isBlank=__m0[\"isBlank\"];\nconst toArray=__m0[\"toArray\"];\nconst warnOnce=__m0[\"warnOnce\"];\nconst __m1=__req(\"packages/core/src/format/date.js\");\nconst toIsoDate=__m1[\"toIsoDate\"];\nconst __m2=__req(\"packages/core/src/compute/handle.js\");\nconst bitReader=__m2[\"bitReader\"];\nconst dictSize=__m2[\"dictSize\"];\nconst dictValue=__m2[\"dictValue\"];\nconst presenceReader=__m2[\"presenceReader\"];\nconst valueComparator=__m2[\"valueComparator\"];\nconst valueReader=__m2[\"valueReader\"];\nconst ISO_DAY=/^\\d{4}-\\d{2}-\\d{2}$/;\nconst NULL_KEY='\\u0000null\\u0000';\nfunction acquireMask(ctx,n){\nconst pool=ctx&&ctx.pool;\nif(pool){\nconst take=pool.mask||pool.acquireMask||pool.acquire||pool.take;\nif(typeof take==='function'){\nconst mask=take.call(pool,n);\nif(mask&&mask.length>=n)return mask;\n}\n}\nreturn new Uint8Array(n);\n}\nfunction releaseMask(ctx,mask){\nconst pool=ctx&&ctx.pool;\nif(!pool||!mask)return;\nconst give=pool.release||pool.releaseMask||pool.free||pool.recycle;\nif(typeof give==='function')give.call(pool,mask);\n}\nfunction fillMask(mask,n,value){\nmask.fill(value,0,n);\nreturn mask;\n}\nfunction unorderable(v){\nreturn v===null||v===undefined||(typeof v==='number'&&Number.isNaN(v));\n}\nfunction coerceTarget(value,type){\nif(value===null||value===undefined)return value;\nif(type==='number')return typeof value==='number'?value:Number(value);\nif(type==='date'||type==='dateString'){\nconst iso=toIsoDate(value);\nreturn iso===null?toMillis(value):iso;\n}\nif(type==='boolean'){\nif(typeof value==='boolean')return value;\nif(value==='true'||value===1)return true;\nif(value==='false'||value===0)return false;\nreturn!!value;\n}\nreturn value;\n}\nfunction toMillis(value){\nif(value instanceof Date)return value.getTime();\nif(typeof value==='number')return value;\nreturn Date.parse(String(value));\n}\nfunction toNumber(value){\nif(typeof value==='number')return value;\nif(value instanceof Date)return value.getTime();\nif(value===null||value===undefined||value==='')return NaN;\nreturn Number(value);\n}\nfunction textOf(v,caseSensitive){\nconst s=typeof v==='string'?v:String(v);\nreturn caseSensitive?s:s.toLowerCase();\n}\nfunction setKey(v,caseSensitive){\nif(v===null||v===undefined)return NULL_KEY;\nif(typeof v==='string')return caseSensitive?v:v.toLowerCase();\nif(v instanceof Date)return v.getTime();\nreturn v;\n}\nfunction buildSet(value,caseSensitive,type){\nconst set=new Set();\nfor(const raw of toArray(value)){\nconst entry=coerceTarget(raw,type);\nset.add(setKey(entry,caseSensitive));\nif(typeof entry==='string'&&entry!==''&&Number.isFinite(Number(entry)))set.add(Number(entry));\nelse if(typeof entry==='number'&&Number.isFinite(entry))set.add(setKey(String(entry),caseSensitive));\n}\nreturn set;\n}\nfunction valueEquals(a,b,caseSensitive){\nif(a===null||a===undefined||b===null||b===undefined){\nreturn(a===null||a===undefined)&&(b===null||b===undefined);\n}\nconst ta=typeof a;\nconst tb=typeof b;\nif(ta==='string'&&tb==='string')return caseSensitive?a===b:a.toLowerCase()===b.toLowerCase();\nif(a instanceof Date||b instanceof Date)return toMillis(a)===toMillis(b);\nif(ta==='number'&&tb==='number')return a===b||(Number.isNaN(a)&&Number.isNaN(b));\nif(ta==='number'&&tb==='string')return a===Number(b);\nif(ta==='string'&&tb==='number')return Number(a)===b;\nif(ta==='boolean'||tb==='boolean')return a===b;\nif(Array.isArray(a)&&Array.isArray(b)){\nreturn a.length===b.length&&a.every((x,i)=>valueEquals(x,b[i],caseSensitive));\n}\nreturn a===b;\n}\nfunction compileRegExp(value,caseSensitive){\ntry{\nif(value instanceof RegExp){\nconst flags=value.flags.replace(/[gy]/g,'');\nreturn new RegExp(value.source,caseSensitive?flags:flags.includes('i')?flags:`${flags}i`);\n}\nreturn new RegExp(String(value),caseSensitive?'':'i');\n}catch(err){\nwarnOnce(`regex:${String(value)}`,`filter operator \"matches\" received an invalid pattern: ${String(value)}`,err);\nreturn null;\n}\n}\nfunction compilePredicate(condition,locale){\nconst predicate=compileValuePredicate(condition,locale);\nconst type=condition&&condition.type;\nif(type!=='date'&&type!=='dateString')return predicate;\nreturn(v)=>predicate(typeof v==='string'&&ISO_DAY.test(v)?v:(toIsoDate(v)??v));\n}\nfunction compileValuePredicate(condition,locale){\nconst op=condition&&condition.op;\nconst caseSensitive=!!(condition&&condition.caseSensitive);\nconst type=condition&&condition.type;\nconst cmp=valueComparator(locale);\nconst not=(p)=>(v)=>!p(v);\nswitch(op){\ncase'eq':{\nconst target=coerceTarget(condition.value,type);\nreturn(v)=>valueEquals(v,target,caseSensitive);\n}\ncase'ne':{\nconst target=coerceTarget(condition.value,type);\nreturn(v)=>!valueEquals(v,target,caseSensitive);\n}\ncase'lt':case'lte':case'gt':case'gte':{\nconst target=coerceTarget(condition.value,type);\nif(unorderable(target))return()=>false;\nconst want=op==='lt'?-1:op==='lte'?0:op==='gt'?1:2;\nreturn(v)=>{\nif(unorderable(v))return false;\nconst c=cmp(v,target);\nreturn want===-1?c<0:want===0?c<=0:want===1?c>0:c>=0;\n};\n}\ncase'between':case'notBetween':{\nconst pair=toArray(condition.value);\nconst lo=coerceTarget(pair[0],type);\nconst hi=coerceTarget(pair[1],type);\nconst bounds=condition.bounds||'[]';\nconst loInclusive=bounds.charAt(0)!=='(';\nconst hiInclusive=bounds.charAt(1)!==')';\nif(unorderable(lo)||unorderable(hi))return op==='between'?()=>false:()=>true;\nconst inRange=(v)=>{\nif(unorderable(v))return false;\nconst a=cmp(v,lo);\nconst b=cmp(v,hi);\nreturn(loInclusive?a>=0:a>0)&&(hiInclusive?b<=0:b<0);\n};\nreturn op==='between'?inRange:not(inRange);\n}\ncase'in':case'notIn':{\nconst set=buildSet(condition.value,caseSensitive,type);\nconst member=(v)=>set.has(setKey(v,caseSensitive));\nreturn op==='in'?member:not(member);\n}\ncase'contains':case'notContains':{\nconst needle=textOf(coerceTarget(condition.value,type),caseSensitive);\nconst has=(v)=>(v===null||v===undefined?false:textOf(v,caseSensitive).includes(needle));\nreturn op==='contains'?has:not(has);\n}\ncase'startsWith':{\nconst needle=textOf(coerceTarget(condition.value,type),caseSensitive);\nreturn(v)=>(v===null||v===undefined?false:textOf(v,caseSensitive).startsWith(needle));\n}\ncase'endsWith':{\nconst needle=textOf(coerceTarget(condition.value,type),caseSensitive);\nreturn(v)=>(v===null||v===undefined?false:textOf(v,caseSensitive).endsWith(needle));\n}\ncase'matches':{\nconst re=compileRegExp(condition.value,caseSensitive);\nif(!re)return()=>false;\nreturn(v)=>(v===null||v===undefined?false:re.test(String(v)));\n}\ncase'blank':\nreturn(v)=>isBlank(v)||(Array.isArray(v)&&v.length===0);\ncase'notBlank':\nreturn(v)=>!(isBlank(v)||(Array.isArray(v)&&v.length===0));\ncase'containsAny':case'containsNone':{\nconst set=buildSet(condition.value,caseSensitive,type);\nconst any=(v)=>{\nconst list=v===null||v===undefined?[]:toArray(v);\nfor(let i=0;i<list.length;i++)if(set.has(setKey(list[i],caseSensitive)))return true;\nreturn false;\n};\nreturn op==='containsAny'?any:not(any);\n}\ncase'containsAll':{\nconst wanted=toArray(condition.value).map((x)=>setKey(coerceTarget(x,type),caseSensitive));\nreturn(v)=>{\nconst list=v===null||v===undefined?[]:toArray(v);\nif(wanted.length===0)return true;\nconst have=new Set(list.map((x)=>setKey(x,caseSensitive)));\nfor(let i=0;i<wanted.length;i++)if(!have.has(wanted[i]))return false;\nreturn true;\n};\n}\ndefault:\nwarnOnce(`op:${String(op)}`,`unknown filter operator \"${String(op)}\"; the condition passes every row`);\nreturn()=>true;\n}\n}\nfunction testValue(value,condition,locale){\nreturn compilePredicate(condition,locale)(value);\n}\nfunction presenceCondition(handle,wantPresent,mask,count){\nconst present=presenceReader(handle);\nif(present){\nconst target=wantPresent?1:0;\nfor(let i=0;i<count;i++)mask[i]=present(i)===target?1:0;\nreturn mask;\n}\nconst kind=handle.kind;\nif(kind==='float64'||kind==='int32'||kind==='bitset'){\nreturn fillMask(mask,count,wantPresent?1:0);\n}\nconst read=valueReader(handle);\nfor(let i=0;i<count;i++){\nconst v=read(i);\nconst blank=isBlank(v)||(Array.isArray(v)&&v.length===0);\nmask[i]=blank===wantPresent?0:1;\n}\nreturn mask;\n}\nfunction dictionaryCondition(handle,pred,mask,count){\nconst dict=handle.dict;\nconst size=dictSize(dict);\nconst allowed=new Uint8Array(size);\nfor(let code=0;code<size;code++)allowed[code]=pred(dictValue(dict,code))?1:0;\nconst codes=handle.values;\nconst present=presenceReader(handle);\nif(!present){\nfor(let i=0;i<count;i++)mask[i]=allowed[codes[i]];\nreturn mask;\n}\nconst absentAnswer=pred(null)?1:0;\nfor(let i=0;i<count;i++)mask[i]=present(i)===1?allowed[codes[i]]:absentAnswer;\nreturn mask;\n}\nfunction booleanCondition(handle,pred,mask,count){\nconst bit=bitReader(handle.values);\nconst whenTrue=pred(true)?1:0;\nconst whenFalse=pred(false)?1:0;\nconst present=presenceReader(handle);\nif(!present){\nfor(let i=0;i<count;i++)mask[i]=bit(i)===1?whenTrue:whenFalse;\nreturn mask;\n}\nconst absentAnswer=pred(null)?1:0;\nfor(let i=0;i<count;i++){\nmask[i]=present(i)===0?absentAnswer:(bit(i)===1?whenTrue:whenFalse);\n}\nreturn mask;\n}\nfunction numericCondition(handle,condition,pred,mask,count){\nconst values=handle.values;\nconst type=condition.type;\nconst op=condition.op;\nlet handled=true;\nswitch(op){\ncase'eq':case'ne':{\nconst target=toNumber(coerceTarget(condition.value,type));\nconst wantNaN=typeof condition.value==='number'&&Number.isNaN(condition.value);\nconst invert=op==='ne'?1:0;\nif(wantNaN){\nfor(let i=0;i<count;i++)mask[i]=(Number.isNaN(values[i])?1:0)^invert;\n}else{\nfor(let i=0;i<count;i++)mask[i]=((values[i]===target)?1:0)^invert;\n}\nbreak;\n}\ncase'lt':{\nconst t=toNumber(coerceTarget(condition.value,type));\nfor(let i=0;i<count;i++)mask[i]=values[i]<t?1:0;\nbreak;\n}\ncase'lte':{\nconst t=toNumber(coerceTarget(condition.value,type));\nfor(let i=0;i<count;i++)mask[i]=values[i]<=t?1:0;\nbreak;\n}\ncase'gt':{\nconst t=toNumber(coerceTarget(condition.value,type));\nfor(let i=0;i<count;i++)mask[i]=values[i]>t?1:0;\nbreak;\n}\ncase'gte':{\nconst t=toNumber(coerceTarget(condition.value,type));\nfor(let i=0;i<count;i++)mask[i]=values[i]>=t?1:0;\nbreak;\n}\ncase'between':case'notBetween':{\nconst pair=toArray(condition.value);\nconst lo=toNumber(coerceTarget(pair[0],type));\nconst hi=toNumber(coerceTarget(pair[1],type));\nconst bounds=condition.bounds||'[]';\nconst loInclusive=bounds.charAt(0)!=='(';\nconst hiInclusive=bounds.charAt(1)!==')';\nconst invert=op==='notBetween'?1:0;\nif(loInclusive&&hiInclusive){\nfor(let i=0;i<count;i++)mask[i]=(((values[i]>=lo)&(values[i]<=hi))?1:0)^invert;\n}else if(loInclusive){\nfor(let i=0;i<count;i++)mask[i]=(((values[i]>=lo)&(values[i]<hi))?1:0)^invert;\n}else if(hiInclusive){\nfor(let i=0;i<count;i++)mask[i]=(((values[i]>lo)&(values[i]<=hi))?1:0)^invert;\n}else{\nfor(let i=0;i<count;i++)mask[i]=(((values[i]>lo)&(values[i]<hi))?1:0)^invert;\n}\nbreak;\n}\ncase'in':case'notIn':{\nconst set=new Set();\nfor(const raw of toArray(condition.value)){\nconst n=toNumber(coerceTarget(raw,type));\nif(!Number.isNaN(n))set.add(n);\n}\nconst invert=op==='notIn'?1:0;\nfor(let i=0;i<count;i++)mask[i]=(set.has(values[i])?1:0)^invert;\nbreak;\n}\ndefault:\nhandled=false;\nbreak;\n}\nif(!handled)return false;\nconst present=presenceReader(handle);\nif(present){\nconst absentAnswer=pred(null)?1:0;\nfor(let i=0;i<count;i++)if(present(i)===0)mask[i]=absentAnswer;\n}\nreturn true;\n}\nfunction genericCondition(handle,pred,mask,count){\nconst read=valueReader(handle);\nfor(let i=0;i<count;i++)mask[i]=pred(read(i))?1:0;\nreturn mask;\n}\nfunction evaluateCondition(condition,ctx,out){\nconst count=ctx.count|0;\nconst mask=out||acquireMask(ctx,count);\nif(!condition)return fillMask(mask,count,1);\nconst handle=typeof ctx.handle==='function'?ctx.handle(condition.col):undefined;\nconst custom=typeof ctx.custom==='function'?ctx.custom:null;\nif(!handle){\nif(custom){\nfor(let i=0;i<count;i++)mask[i]=custom(condition,i)?1:0;\nreturn mask;\n}\nwarnOnce(`filter:col:${String(condition.col)}`,\n`filter references unknown column \"${String(condition.col)}\"; the condition passes every row`);\nreturn fillMask(mask,count,1);\n}\nconst op=condition.op;\nif(op==='blank'||op==='notBlank')return presenceCondition(handle,op==='notBlank',mask,count);\nconst pred=compilePredicate(condition,ctx.locale);\nswitch(handle.kind){\ncase'dictionary':\nreturn dictionaryCondition(handle,pred,mask,count);\ncase'bitset':\nreturn booleanCondition(handle,pred,mask,count);\ncase'float64':case'int32':\nif(numericCondition(handle,condition,pred,mask,count))return mask;\nreturn genericCondition(handle,pred,mask,count);\ndefault:\nreturn genericCondition(handle,pred,mask,count);\n}\n}\nfunction evaluateNode(node,ctx,count){\nif(!node)return fillMask(acquireMask(ctx,count),count,1);\nif(Array.isArray(node.conditions)){\nconst children=node.conditions.filter((c)=>c!=null);\nconst op=node.op==='or'?'or':node.op==='not'?'not':'and';\nif(children.length===0)return fillMask(acquireMask(ctx,count),count,1);\nconst acc=evaluateNode(children[0],ctx,count);\nfor(let k=1;k<children.length;k++){\nconst rhs=evaluateNode(children[k],ctx,count);\nif(op==='or')for(let i=0;i<count;i++)acc[i]|=rhs[i];\nelse for(let i=0;i<count;i++)acc[i]&=rhs[i];\nreleaseMask(ctx,rhs);\n}\nif(op==='not')for(let i=0;i<count;i++)acc[i]^=1;\nreturn acc;\n}\nreturn evaluateCondition(node,ctx,acquireMask(ctx,count));\n}\nfunction evaluateFilters(filters,ctx){\nreturn evaluateNode(filters,ctx,ctx.count|0);\n}\nfunction pruneColumn(filters,colId){\nif(!filters||!colId)return filters||null;\nconst node=(filters);\nif(Array.isArray(node.conditions)){\nconst op=node.op==='or'?'or':node.op==='not'?'not':'and';\nif(op!=='and'){\nreturn mentionsColumn(node,colId)?null:filters;\n}\nconst kept=[];\nfor(const child of node.conditions){\nconst pruned=pruneColumn(child,colId);\nif(pruned)kept.push(pruned);\n}\nif(!kept.length)return null;\nreturn{...node,op:'and',conditions:kept};\n}\nreturn node.col===colId?null:filters;\n}\nfunction mentionsColumn(filters,colId){\nif(!filters||typeof filters!=='object')return false;\nconst node=(filters);\nif(node.col===colId)return true;\nif(Array.isArray(node.conditions)){\nfor(const child of node.conditions)if(mentionsColumn(child,colId))return true;\n}\nreturn false;\n}\nfunction compact(mask,count,out){\nif(out&&out.length>=count){\nlet k=0;\nfor(let i=0;i<count;i++)if(mask[i])out[k++]=i;\nreturn out.subarray(0,k);\n}\nlet survivors=0;\nfor(let i=0;i<count;i++)survivors+=mask[i]?1:0;\nconst result=new Uint32Array(survivors);\nlet k=0;\nfor(let i=0;i<count;i++)if(mask[i])result[k++]=i;\nreturn result;\n}\n});\n__def(\"packages/core/src/compute/group.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"packKeys\",{enumerable:true,get:function(){return packKeys;}});\nObject.defineProperty(__exports,\"groupByColumns\",{enumerable:true,get:function(){return groupByColumns;}});\nconst __m0=__req(\"packages/core/src/compute/handle.js\");\nconst dictSize=__m0[\"dictSize\"];\nconst identity=__m0[\"identity\"];\nconst presenceReader=__m0[\"presenceReader\"];\nconst rowCount=__m0[\"rowCount\"];\nconst valueReader=__m0[\"valueReader\"];\nconst KEY_SEPARATOR='\\u001F';\nconst NULL_MARKER='\\u0000';\nconst MAX_DIRECT_COUNTS=1<<20;\nfunction packKeys(handles,idx,n,project){\nconst k=handles.length;\nconst base=handles.map((h)=>valueReader(h));\nconst projected=Array.isArray(project)&&project.some(Boolean);\nconst readers=projected\n?base.map((r,j)=>(project[j]?(i)=>project[j](r(i)):r))\n:base;\nconst allDictionary=!projected&&k>0&&handles.every((h)=>h&&h.kind==='dictionary'&&h.dict);\nif(allDictionary){\nconst cards=handles.map((h)=>dictSize(h.dict)+1);\nlet product=1;\nfor(let j=0;j<k;j++)product*=cards[j];\nif(product<=Number.MAX_SAFE_INTEGER){\nconst codes=handles.map((h)=>h.values);\nconst presence=handles.map((h)=>presenceReader(h));\nconst keyOf=(row)=>{\nlet key=0;\nfor(let j=0;j<k;j++){\nconst present=presence[j];\nconst code=present&&present(row)===0?cards[j]-1:codes[j][row];\nkey=key*cards[j]+code;\n}\nreturn key;\n};\nconst packed=new Float64Array(n);\nfor(let i=0;i<n;i++)packed[i]=keyOf(idx[i]);\nreturn{packed,strings:null,product,readers,keyOf};\n}\n}\nconst keyOf=(row)=>{\nlet key='';\nfor(let j=0;j<k;j++){\nconst v=readers[j](row);\nkey+=(j===0?'':KEY_SEPARATOR)+(v===null||v===undefined?NULL_MARKER:String(v));\n}\nreturn key;\n};\nconst strings=new Array(n);\nfor(let i=0;i<n;i++)strings[i]=keyOf(idx[i]);\nreturn{packed:null,strings,product:Infinity,readers,keyOf};\n}\nfunction scatterBuckets(idx,ids,n,groups){\nconst offsets=new Uint32Array(groups+1);\nfor(let i=0;i<n;i++)offsets[ids[i]+1]++;\nfor(let g=0;g<groups;g++)offsets[g+1]+=offsets[g];\nconst scattered=new Uint32Array(n);\nconst cursor=offsets.slice(0,groups);\nfor(let i=0;i<n;i++)scattered[cursor[ids[i]]++]=idx[i];\nconst buckets=new Array(groups);\nfor(let g=0;g<groups;g++)buckets[g]=scattered.subarray(offsets[g],offsets[g+1]);\nreturn buckets;\n}\nfunction groupByColumns(handles,order,opts={}){\nconst list=handles||[];\nconst idx=order||identity(rowCount(list[0],opts));\nconst n=idx.length;\nif(list.length===0||n===0)return{keys:[],buckets:[]};\nconst{packed,strings,product,readers}=packKeys(list,idx,n,opts.project);\nconst ids=new Uint32Array(n);\nlet groups=0;\nlet packedKeys=null;\nif(packed&&product<=Math.max(1024,Math.min(MAX_DIRECT_COUNTS,n*4))){\nconst size=product;\nconst seen=new Int32Array(size).fill(-1);\nfor(let i=0;i<n;i++)seen[packed[i]]=0;\nfor(let key=0;key<size;key++)if(seen[key]===0)seen[key]=groups++;\nfor(let i=0;i<n;i++)ids[i]=seen[packed[i]];\npackedKeys=new Float64Array(groups);\nfor(let key=0;key<size;key++)if(seen[key]>=0)packedKeys[seen[key]]=key;\n}else if(packed){\nconst seen=new Map();\nfor(let i=0;i<n;i++){\nconst key=packed[i];\nlet id=seen.get(key);\nif(id===undefined){id=groups++;seen.set(key,id);}\nids[i]=id;\n}\npackedKeys=new Float64Array(groups);\nfor(const[key,id]of seen)packedKeys[id]=key;\n}else{\nconst seen=new Map();\nfor(let i=0;i<n;i++){\nconst key=strings[i];\nlet id=seen.get(key);\nif(id===undefined){id=groups++;seen.set(key,id);}\nids[i]=id;\n}\n}\nconst buckets=scatterBuckets(idx,ids,n,groups);\nconst keys=new Array(groups);\nfor(let g=0;g<groups;g++){\nconst row=buckets[g][0];\nconst tuple=new Array(readers.length);\nfor(let j=0;j<readers.length;j++)tuple[j]=readers[j](row);\nkeys[g]=tuple;\n}\nconst result={keys,buckets};\nif(packedKeys)result.packed=packedKeys;\nreturn result;\n}\n});\n__def(\"packages/core/src/compute/facet.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"STRATEGIES\",{enumerable:true,get:function(){return STRATEGIES;}});\nObject.defineProperty(__exports,\"GRANULARITIES\",{enumerable:true,get:function(){return GRANULARITIES;}});\nObject.defineProperty(__exports,\"DEFAULT_BUCKETS\",{enumerable:true,get:function(){return DEFAULT_BUCKETS;}});\nObject.defineProperty(__exports,\"DEFAULT_CARDINALITY_LIMIT\",{enumerable:true,get:function(){return DEFAULT_CARDINALITY_LIMIT;}});\nObject.defineProperty(__exports,\"QUANTILE_SAMPLE\",{enumerable:true,get:function(){return QUANTILE_SAMPLE;}});\nObject.defineProperty(__exports,\"facetKind\",{enumerable:true,get:function(){return facetKind;}});\nObject.defineProperty(__exports,\"orderedReader\",{enumerable:true,get:function(){return orderedReader;}});\nObject.defineProperty(__exports,\"toNumeric\",{enumerable:true,get:function(){return toNumeric;}});\nObject.defineProperty(__exports,\"cardinalityOf\",{enumerable:true,get:function(){return cardinalityOf;}});\nObject.defineProperty(__exports,\"pickGranularity\",{enumerable:true,get:function(){return pickGranularity;}});\nObject.defineProperty(__exports,\"floorTo\",{enumerable:true,get:function(){return floorTo;}});\nObject.defineProperty(__exports,\"advance\",{enumerable:true,get:function(){return advance;}});\nObject.defineProperty(__exports,\"computeBounds\",{enumerable:true,get:function(){return computeBounds;}});\nObject.defineProperty(__exports,\"countInto\",{enumerable:true,get:function(){return countInto;}});\nObject.defineProperty(__exports,\"bucketOf\",{enumerable:true,get:function(){return bucketOf;}});\nObject.defineProperty(__exports,\"facet\",{enumerable:true,get:function(){return facet;}});\nObject.defineProperty(__exports,\"default\",{enumerable:true,get:function(){return __default;}});\nconst __m0=__req(\"packages/core/src/compute/handle.js\");\nconst presenceReader=__m0[\"presenceReader\"];\nconst valueReader=__m0[\"valueReader\"];\nconst dictSize=__m0[\"dictSize\"];\nconst dictValue=__m0[\"dictValue\"];\nconst STRATEGIES=Object.freeze(['equal','quantile','log']);\nconst GRANULARITIES=Object.freeze(['hour','day','week','month','quarter','year']);\nconst DEFAULT_BUCKETS=20;\nconst DEFAULT_CARDINALITY_LIMIT=50;\nconst QUANTILE_SAMPLE=10_000;\nfunction facetKind(handle,type){\nif(!handle)return'none';\nconst base=type&&type.base;\nif(base==='date'||base==='datetime'||base==='time'||base==='dateString')return'date';\nswitch(handle.kind){\ncase'bitset':return'boolean';\ncase'float64':case'int32':return'numeric';\ncase'dictionary':return'category';\ncase'multi':return'category';\ndefault:\nif(base==='number')return'numeric';\nif(base==='boolean')return'boolean';\nif(base==='text')return'category';\nreturn'none';\n}\n}\nfunction orderedReader(handle){\nconst values=handle.values;\nconst kind=handle.kind;\nif((kind==='float64'||kind==='int32')&&values)return(i)=>values[i];\nconst read=valueReader(handle);\nreturn(i)=>toNumeric(read(i));\n}\nfunction toNumeric(v){\nif(typeof v==='number')return v;\nif(v instanceof Date)return v.getTime();\nif(v===null||v===undefined||v==='')return NaN;\nif(typeof v==='boolean')return v?1:0;\nif(typeof v==='string'){\nconst n=Number(v);\nif(Number.isFinite(n))return n;\nconst t=Date.parse(v);\nreturn Number.isFinite(t)?t:NaN;\n}\nreturn NaN;\n}\nfunction cardinalityOf(handle,indices,count,limit=DEFAULT_CARDINALITY_LIMIT){\nif(!handle)return{cardinality:0,exact:true};\nif(handle.dict)return{cardinality:dictSize(handle.dict),exact:true};\nif(handle.kind==='bitset')return{cardinality:2,exact:true};\nconst read=valueReader(handle);\nconst n=indices?indices.length:count;\nconst seen=new Set();\nfor(let k=0;k<n;k++){\nconst v=read(indices?indices[k]:k);\nif(v===null||v===undefined)continue;\nseen.add(v);\nif(seen.size>limit)return{cardinality:seen.size,exact:false};\n}\nreturn{cardinality:seen.size,exact:true};\n}\nconst HOUR_MS=3600_000;\nconst DAY_MS=86_400_000;\nfunction pickGranularity(span,target=DEFAULT_BUCKETS){\nconst ms=Number.isFinite(span)&&span>0?span:0;\nconst wide=Math.max(1,target)*2;\nif(ms/HOUR_MS<=wide)return'hour';\nif(ms/DAY_MS<=wide)return'day';\nif(ms/(7*DAY_MS)<=wide)return'week';\nif(ms/(30*DAY_MS)<=wide)return'month';\nif(ms/(91*DAY_MS)<=wide)return'quarter';\nreturn'year';\n}\nfunction floorTo(ms,granularity){\nif(!Number.isFinite(ms))return NaN;\nconst d=new Date(ms);\nswitch(granularity){\ncase'hour':d.setMinutes(0,0,0);return d.getTime();\ncase'day':d.setHours(0,0,0,0);return d.getTime();\ncase'week':{\nd.setHours(0,0,0,0);\nconst back=(d.getDay()+6)%7;\nd.setDate(d.getDate()-back);\nreturn d.getTime();\n}\ncase'month':d.setDate(1);d.setHours(0,0,0,0);return d.getTime();\ncase'quarter':\nd.setMonth(Math.floor(d.getMonth()/3)*3,1);\nd.setHours(0,0,0,0);\nreturn d.getTime();\ndefault:d.setMonth(0,1);d.setHours(0,0,0,0);return d.getTime();\n}\n}\nfunction advance(ms,granularity){\nconst d=new Date(ms);\nswitch(granularity){\ncase'hour':d.setHours(d.getHours()+1);break;\ncase'day':d.setDate(d.getDate()+1);break;\ncase'week':d.setDate(d.getDate()+7);break;\ncase'month':d.setMonth(d.getMonth()+1);break;\ncase'quarter':d.setMonth(d.getMonth()+3);break;\ndefault:d.setFullYear(d.getFullYear()+1);break;\n}\nreturn d.getTime();\n}\nfunction numericExtent(handle,indices,count){\nconst read=orderedReader(handle);\nconst present=presenceReader(handle);\nconst n=indices?indices.length:count;\nlet min=Infinity;\nlet max=-Infinity;\nlet nulls=0;\nlet finite=0;\nfor(let k=0;k<n;k++){\nconst i=indices?indices[k]:k;\nif(present&&!present(i)){nulls++;continue;}\nconst v=read(i);\nif(!Number.isFinite(v)){nulls++;continue;}\nif(v<min)min=v;\nif(v>max)max=v;\nfinite++;\n}\nreturn{min,max,nulls,finite};\n}\nfunction sortedSample(handle,indices,count,cap){\nconst read=orderedReader(handle);\nconst present=presenceReader(handle);\nconst n=indices?indices.length:count;\nconst step=n>cap?n/cap:1;\nconst out=[];\nfor(let s=0;s<n;s+=step){\nconst i=indices?indices[Math.floor(s)]:Math.floor(s);\nif(present&&!present(i))continue;\nconst v=read(i);\nif(Number.isFinite(v))out.push(v);\n}\nconst arr=Float64Array.from(out);\narr.sort();\nreturn arr;\n}\nfunction computeBounds(handle,indices,count,opts={}){\nconst kind=opts.kind||facetKind(handle,opts.type);\nif(kind==='none'||!handle)return{kind:'none',buckets:[],suppressed:'type'};\nif(kind==='boolean')return boundsForBoolean(handle,indices,count);\nif(kind==='category')return boundsForCategory(handle,indices,count,opts);\nreturn boundsForOrdered(handle,indices,count,kind,opts);\n}\nfunction boundsForBoolean(handle,indices,count){\nconst present=presenceReader(handle);\nlet nulls=0;\nif(present){\nconst n=indices?indices.length:count;\nfor(let k=0;k<n;k++)if(!present(indices?indices[k]:k))nulls++;\n}\nconst buckets=[{value:false,label:'false'},{value:true,label:'true'}];\nif(nulls>0)buckets.push({null:true,label:'Empty'});\nreturn{kind:'boolean',buckets};\n}\nfunction boundsForCategory(handle,indices,count,opts){\nconst limit=opts.cardinalityLimit??DEFAULT_CARDINALITY_LIMIT;\nconst{cardinality}=cardinalityOf(handle,indices,count,limit);\nif(cardinality>limit&&(opts.aboveLimit||'suppress')==='suppress'){\nreturn{kind:'category',buckets:[],suppressed:'cardinality',cardinality};\n}\nconst read=valueReader(handle);\nconst n=indices?indices.length:count;\nconst tally=new Map();\nlet nulls=0;\nfor(let k=0;k<n;k++){\nconst v=read(indices?indices[k]:k);\nif(v===null||v===undefined||v===''){nulls++;continue;}\nif(Array.isArray(v)){\nif(!v.length){nulls++;continue;}\nfor(const m of v)tally.set(m,(tally.get(m)||0)+1);\ncontinue;\n}\ntally.set(v,(tally.get(v)||0)+1);\n}\nlet entries=[...tally.entries()];\nif(opts.order==='alpha'){\nentries.sort((a,b)=>String(a[0]).localeCompare(String(b[0])));\n}else{\nentries.sort((a,b)=>b[1]-a[1]);\n}\nlet remainder=0;\nlet dropped=0;\nif(entries.length>limit){\ndropped=entries.length-limit;\nfor(let i=limit;i<entries.length;i++)remainder+=entries[i][1];\nentries=entries.slice(0,limit);\n}\nconst buckets=entries.map(([value])=>({value,label:String(value)}));\nif(remainder>0)buckets.push({remainder:true,label:`Other (${dropped} values)`});\nif(nulls>0)buckets.push({null:true,label:'Empty'});\nreturn{kind:'category',buckets,cardinality};\n}\nfunction boundsForOrdered(handle,indices,count,kind,opts){\nconst{min,max,nulls,finite}=numericExtent(handle,indices,count);\nif(!finite){\nreturn{kind,buckets:nulls?[{null:true,label:'Empty'}]:[],empty:true};\n}\nconst wanted=Math.max(1,Math.floor(opts.buckets||DEFAULT_BUCKETS));\nlet buckets=[];\nif(kind==='date'){\nconst granularity=GRANULARITIES.includes(opts.granularity)\n?opts.granularity:pickGranularity(max-min,wanted);\nlet edge=floorTo(min,granularity);\nwhile(edge<=max&&buckets.length<4096){\nconst next=advance(edge,granularity);\nif(!(next>edge))break;\nbuckets.push({from:edge,to:next});\nedge=next;\n}\nreturn{kind,buckets:withNull(buckets,nulls),granularity};\n}\nconst strategy=STRATEGIES.includes(opts.strategy)?opts.strategy:'equal';\nif(strategy==='quantile'){\nconst sample=sortedSample(handle,indices,count,QUANTILE_SAMPLE);\nif(sample.length){\nconst edges=[sample[0]];\nfor(let b=1;b<wanted;b++){\nconst v=sample[Math.min(sample.length-1,Math.floor((b/wanted)*sample.length))];\nif(v>edges[edges.length-1])edges.push(v);\n}\nedges.push(max);\nfor(let b=0;b<edges.length-1;b++)buckets.push({from:edges[b],to:edges[b+1]});\n}\n}else if(strategy==='log'&&min>0){\nconst lo=Math.log10(min);\nconst hi=Math.log10(max);\nconst step=(hi-lo)/wanted||1;\nfor(let b=0;b<wanted;b++){\nbuckets.push({from:10**(lo+b*step),to:10**(lo+(b+1)*step)});\n}\n}\nif(!buckets.length){\nconst width=(max-min)/wanted||1;\nfor(let b=0;b<wanted;b++)buckets.push({from:min+b*width,to:min+(b+1)*width});\n}\nbuckets[buckets.length-1].to=max;\nreturn{kind,buckets:withNull(buckets,nulls),strategy,min,max};\n}\nfunction withNull(buckets,nulls){\nreturn nulls>0?[...buckets,{null:true,label:'Empty'}]:buckets;\n}\nfunction countInto(handle,indices,count,bounds,out){\nconst buckets=(bounds&&bounds.buckets)||[];\nconst counts=out&&out.length>=buckets.length?out.subarray(0,buckets.length)\n:new Uint32Array(buckets.length);\ncounts.fill(0);\nif(!handle||!buckets.length)return counts;\nconst nullBucket=buckets.length-1;\nconst hasNull=!!buckets[nullBucket]&&buckets[nullBucket].null===true;\nconst n=indices?indices.length:count;\nif(bounds.kind==='boolean'){\nconst read=valueReader(handle);\nfor(let k=0;k<n;k++){\nconst v=read(indices?indices[k]:k);\nif(v===null||v===undefined){if(hasNull)counts[nullBucket]++;continue;}\ncounts[v?1:0]++;\n}\nreturn counts;\n}\nif(bounds.kind==='category'){\nconst slot=new Map();\nfor(let b=0;b<buckets.length;b++){\nif(!buckets[b].null&&!buckets[b].remainder)slot.set(buckets[b].value,b);\n}\nconst remainderAt=buckets.findIndex((b)=>b.remainder);\nconst read=valueReader(handle);\nfor(let k=0;k<n;k++){\nconst v=read(indices?indices[k]:k);\nif(v===null||v===undefined||v===''){if(hasNull)counts[nullBucket]++;continue;}\nif(Array.isArray(v)){\nif(!v.length){if(hasNull)counts[nullBucket]++;continue;}\nfor(const m of v){\nconst at=slot.get(m);\nif(at!==undefined)counts[at]++;\nelse if(remainderAt>=0)counts[remainderAt]++;\n}\ncontinue;\n}\nconst at=slot.get(v);\nif(at!==undefined)counts[at]++;\nelse if(remainderAt>=0)counts[remainderAt]++;\n}\nreturn counts;\n}\nconst ordered=hasNull?buckets.length-1:buckets.length;\nconst edges=new Float64Array(ordered+1);\nfor(let b=0;b<ordered;b++)edges[b]=buckets[b].from;\nedges[ordered]=ordered?buckets[ordered-1].to:0;\nconst read=orderedReader(handle);\nconst present=presenceReader(handle);\nfor(let k=0;k<n;k++){\nconst i=indices?indices[k]:k;\nif(present&&!present(i)){if(hasNull)counts[nullBucket]++;continue;}\nconst v=read(i);\nif(!Number.isFinite(v)){if(hasNull)counts[nullBucket]++;continue;}\nconst at=bucketOf(edges,ordered,v);\nif(at>=0)counts[at]++;\n}\nreturn counts;\n}\nfunction bucketOf(edges,ordered,v){\nif(!ordered)return-1;\nif(v<edges[0])return-1;\nif(v>=edges[ordered])return v===edges[ordered]?ordered-1:-1;\nlet lo=0;\nlet hi=ordered-1;\nwhile(lo<hi){\nconst mid=(lo+hi+1)>>>1;\nif(v>=edges[mid])lo=mid;else hi=mid-1;\n}\nreturn lo;\n}\nfunction facet(handle,indices,count,opts={}){\nconst bounds=opts.bounds||computeBounds(handle,opts.boundsIndices??indices,count,opts);\nreturn{bounds,counts:countInto(handle,indices,count,bounds)};\n}\nconst __default=facet;\n});\n__def(\"packages/core/src/compute/special.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"logGamma\",{enumerable:true,get:function(){return logGamma;}});\nObject.defineProperty(__exports,\"incompleteBeta\",{enumerable:true,get:function(){return incompleteBeta;}});\nObject.defineProperty(__exports,\"normalQuantile\",{enumerable:true,get:function(){return normalQuantile;}});\nObject.defineProperty(__exports,\"normalCdf\",{enumerable:true,get:function(){return normalCdf;}});\nObject.defineProperty(__exports,\"studentT\",{enumerable:true,get:function(){return studentT;}});\nObject.defineProperty(__exports,\"studentTQuantile\",{enumerable:true,get:function(){return studentTQuantile;}});\nObject.defineProperty(__exports,\"regularizedGammaP\",{enumerable:true,get:function(){return regularizedGammaP;}});\nObject.defineProperty(__exports,\"chiSquareCdf\",{enumerable:true,get:function(){return chiSquareCdf;}});\nObject.defineProperty(__exports,\"chiSquareUpperTail\",{enumerable:true,get:function(){return chiSquareUpperTail;}});\nconst LANCZOS=Object.freeze([\n676.5203681218851,-1259.1392167224028,771.32342877765313,\n-176.61502916214059,12.507343278686905,-0.13857109526572012,\n9.9843695780195716e-6,1.5056327351493116e-7,\n]);\nconst EPS=3e-12;\nconst TINY=1e-300;\nfunction logGamma(x){\nif(x<0.5)return Math.log(Math.PI/Math.sin(Math.PI*x))-logGamma(1-x);\nconst z=x-1;\nlet a=0.99999999999980993;\nconst t=z+7.5;\nfor(let i=0;i<LANCZOS.length;i++)a+=LANCZOS[i]/(z+i+1);\nreturn 0.5*Math.log(2*Math.PI)+(z+0.5)*Math.log(t)-t+Math.log(a);\n}\nfunction betaContinuedFraction(a,b,x){\nconst qab=a+b;\nconst qap=a+1;\nconst qam=a-1;\nlet c=1;\nlet d=1-(qab*x)/qap;\nif(Math.abs(d)<TINY)d=TINY;\nd=1/d;\nlet h=d;\nfor(let m=1;m<=300;m++){\nconst m2=2*m;\nlet aa=(m*(b-m)*x)/((qam+m2)*(a+m2));\nd=1+aa*d;\nif(Math.abs(d)<TINY)d=TINY;\nc=1+aa/c;\nif(Math.abs(c)<TINY)c=TINY;\nd=1/d;\nh*=d*c;\naa=(-(a+m)*(qab+m)*x)/((a+m2)*(qap+m2));\nd=1+aa*d;\nif(Math.abs(d)<TINY)d=TINY;\nc=1+aa/c;\nif(Math.abs(c)<TINY)c=TINY;\nd=1/d;\nconst step=d*c;\nh*=step;\nif(Math.abs(step-1)<EPS)break;\n}\nreturn h;\n}\nfunction incompleteBeta(a,b,x){\nif(!(a>0)||!(b>0)||!Number.isFinite(x))return Number.NaN;\nif(x<=0)return 0;\nif(x>=1)return 1;\nconst front=Math.exp(\nlogGamma(a+b)-logGamma(a)-logGamma(b)+a*Math.log(x)+b*Math.log(1-x),\n);\nreturn x<(a+1)/(a+b+2)\n?(front*betaContinuedFraction(a,b,x))/a\n:1-(front*betaContinuedFraction(b,a,1-x))/b;\n}\nfunction normalQuantile(p){\nif(!(p>0)||!(p<1))return p===0?-Infinity:(p===1?Infinity:Number.NaN);\nconst a=[-3.969683028665376e+1,2.209460984245205e+2,-2.759285104469687e+2,\n1.383577518672690e+2,-3.066479806614716e+1,2.506628277459239];\nconst b=[-5.447609879822406e+1,1.615858368580409e+2,-1.556989798598866e+2,\n6.680131188771972e+1,-1.328068155288572e+1];\nconst c=[-7.784894002430293e-3,-3.223964580411365e-1,-2.400758277161838,\n-2.549732539343734,4.374664141464968,2.938163982698783];\nconst d=[7.784695709041462e-3,3.224671290700398e-1,2.445134137142996,\n3.754408661907416];\nconst low=0.02425;\nlet q;\nlet r;\nlet x;\nif(p<low){\nq=Math.sqrt(-2*Math.log(p));\nx=(((((c[0]*q+c[1])*q+c[2])*q+c[3])*q+c[4])*q+c[5])\n/ ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1);\n}else if(p<=1-low){\nq=p-0.5;\nr=q*q;\nx=((((((a[0]*r+a[1])*r+a[2])*r+a[3])*r+a[4])*r+a[5])*q)\n/ (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1);\n}else{\nq=Math.sqrt(-2*Math.log(1-p));\nx=-(((((c[0]*q+c[1])*q+c[2])*q+c[3])*q+c[4])*q+c[5])\n/ ((((d[0] * q + d[1]) * q + d[2]) * q + d[3]) * q + 1);\n}\nconst e=0.5*erfc(-x/Math.SQRT2)-p;\nconst u=e*Math.sqrt(2*Math.PI)*Math.exp((x*x)/2);\nreturn x-u/(1+(x*u)/2);\n}\nfunction erfc(x){\nconst z=Math.abs(x);\nconst t=2/(2+z);\nconst ty=4*t-2;\nconst cof=[-1.3026537197817094,6.4196979235649026e-1,1.9476473204185836e-2,\n-9.561514786808631e-3,-9.46595344482036e-4,3.66839497852761e-4,\n4.2523324806907e-5,-2.0278578112534e-5,-1.624290004647e-6,\n1.303655835580e-6,1.5626441722e-8,-8.5238095915e-8,6.529054439e-9,\n5.059343495e-9,-9.91364156e-10,-2.27365122e-10,9.6467911e-11,\n2.394038e-12,-6.886027e-12,8.94487e-13,3.13092e-13,-1.12708e-13,\n3.81e-16,7.106e-15];\nlet dd=0;\nlet dv=0;\nlet tmp;\nfor(let j=cof.length-1;j>0;j--){\ntmp=dv;\ndv=ty*dv-dd+cof[j];\ndd=tmp;\n}\nconst ans=t*Math.exp(-z*z+0.5*(cof[0]+ty*dv)-dd);\nreturn x>=0?ans:2-ans;\n}\nfunction normalCdf(x){\nreturn 0.5*erfc(-x/Math.SQRT2);\n}\nfunction studentT(t,df){\nif(!(df>0)||!Number.isFinite(t))return Number.NaN;\nconst tail=0.5*incompleteBeta(df/2,0.5,df/(df+t*t));\nreturn t>0?1-tail:tail;\n}\nfunction studentTQuantile(p,df){\nif(!(p>0)||!(p<1)||!(df>0))return Number.NaN;\nif(df>1e7)return normalQuantile(p);\nlet lo=-1e4;\nlet hi=1e4;\nlet x=normalQuantile(p);\nconst logBeta=logGamma(df/2)+logGamma(0.5)-logGamma((df+1)/2);\nfor(let i=0;i<60;i++){\nconst cdf=studentT(x,df);\nif(cdf<p)lo=x;else hi=x;\nconst pdf=Math.exp(-((df+1)/2)*Math.log(1+(x*x)/df)-logBeta)\n/ Math.sqrt(df);\nconst step=pdf>0?(cdf-p)/pdf:0;\nif(Math.abs(step)<1e-12)break;\nconst next=x-step;\nx=next>lo&&next<hi&&Number.isFinite(next)?next:(lo+hi)/2;\nif(hi-lo<1e-12)break;\n}\nreturn x;\n}\nfunction gammaSeries(a,x){\nlet ap=a;\nlet sum=1/a;\nlet del=sum;\nfor(let n=0;n<300;n++){\nap+=1;\ndel*=x/ap;\nsum+=del;\nif(Math.abs(del)<Math.abs(sum)*EPS)break;\n}\nreturn sum*Math.exp(-x+a*Math.log(x)-logGamma(a));\n}\nfunction gammaContinuedFraction(a,x){\nlet b=x+1-a;\nlet c=1/TINY;\nlet d=1/b;\nlet h=d;\nfor(let i=1;i<=300;i++){\nconst an=-i*(i-a);\nb+=2;\nd=an*d+b;\nif(Math.abs(d)<TINY)d=TINY;\nc=b+an/c;\nif(Math.abs(c)<TINY)c=TINY;\nd=1/d;\nconst del=d*c;\nh*=del;\nif(Math.abs(del-1)<EPS)break;\n}\nreturn Math.exp(-x+a*Math.log(x)-logGamma(a))*h;\n}\nfunction regularizedGammaP(a,x){\nif(!(a>0)||!(x>=0)||!Number.isFinite(x))return Number.NaN;\nif(x===0)return 0;\nreturn x<a+1?gammaSeries(a,x):1-gammaContinuedFraction(a,x);\n}\nfunction chiSquareCdf(x,df){\nif(!(df>0))return Number.NaN;\nreturn regularizedGammaP(df/2,x/2);\n}\nfunction chiSquareUpperTail(x,df){\nconst cdf=chiSquareCdf(x,df);\nreturn Number.isNaN(cdf)?Number.NaN:Math.min(1,Math.max(0,1-cdf));\n}\n});\n__def(\"packages/core/src/compute/linalg.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"cholesky\",{enumerable:true,get:function(){return cholesky;}});\nObject.defineProperty(__exports,\"choleskySolve\",{enumerable:true,get:function(){return choleskySolve;}});\nObject.defineProperty(__exports,\"choleskyInverse\",{enumerable:true,get:function(){return choleskyInverse;}});\nObject.defineProperty(__exports,\"normalEquations\",{enumerable:true,get:function(){return normalEquations;}});\nObject.defineProperty(__exports,\"matVec\",{enumerable:true,get:function(){return matVec;}});\nObject.defineProperty(__exports,\"quadForm\",{enumerable:true,get:function(){return quadForm;}});\nfunction cholesky(a){\nconst n=a.length;\nconst l=Array.from({length:n},()=>new Array(n).fill(0));\nfor(let i=0;i<n;i++){\nfor(let j=0;j<=i;j++){\nlet sum=a[i][j];\nfor(let k=0;k<j;k++)sum-=l[i][k]*l[j][k];\nif(i===j){\nif(!(sum>0))return null;\nl[i][j]=Math.sqrt(sum);\n}else{\nl[i][j]=sum/l[j][j];\n}\n}\n}\nreturn l;\n}\nfunction choleskySolve(l,b){\nconst n=l.length;\nconst y=new Array(n).fill(0);\nfor(let i=0;i<n;i++){\nlet sum=b[i];\nfor(let k=0;k<i;k++)sum-=l[i][k]*y[k];\ny[i]=sum/l[i][i];\n}\nconst x=new Array(n).fill(0);\nfor(let i=n-1;i>=0;i--){\nlet sum=y[i];\nfor(let k=i+1;k<n;k++)sum-=l[k][i]*x[k];\nx[i]=sum/l[i][i];\n}\nreturn x;\n}\nfunction choleskyInverse(l){\nconst n=l.length;\nconst inv=Array.from({length:n},()=>new Array(n).fill(0));\nfor(let c=0;c<n;c++){\nconst e=new Array(n).fill(0);\ne[c]=1;\nconst col=choleskySolve(l,e);\nfor(let r=0;r<n;r++)inv[r][c]=col[r];\n}\nreturn inv;\n}\nfunction normalEquations(x,y,w){\nconst n=x.length;\nconst p=n?x[0].length:0;\nconst xtwx=Array.from({length:p},()=>new Array(p).fill(0));\nconst xtwy=new Array(p).fill(0);\nfor(let i=0;i<n;i++){\nconst wi=w?w[i]:1;\nconst row=x[i];\nfor(let a=0;a<p;a++){\nconst wxa=wi*row[a];\nxtwy[a]+=wxa*y[i];\nfor(let b=a;b<p;b++)xtwx[a][b]+=wxa*row[b];\n}\n}\nfor(let a=0;a<p;a++)for(let b=0;b<a;b++)xtwx[a][b]=xtwx[b][a];\nreturn{xtwx,xtwy};\n}\nfunction matVec(m,v){\nreturn m.map((row)=>row.reduce((sum,cell,j)=>sum+cell*v[j],0));\n}\nfunction quadForm(x,m){\nlet sum=0;\nfor(let a=0;a<x.length;a++){\nlet inner=0;\nfor(let b=0;b<x.length;b++)inner+=m[a][b]*x[b];\nsum+=x[a]*inner;\n}\nreturn sum;\n}\n});\n__def(\"packages/core/src/compute/sketch.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"Welford\",{enumerable:true,get:function(){return Welford;}});\nObject.defineProperty(__exports,\"Reservoir\",{enumerable:true,get:function(){return Reservoir;}});\nObject.defineProperty(__exports,\"hash32\",{enumerable:true,get:function(){return hash32;}});\nObject.defineProperty(__exports,\"HyperLogLog\",{enumerable:true,get:function(){return HyperLogLog;}});\nObject.defineProperty(__exports,\"SpaceSaving\",{enumerable:true,get:function(){return SpaceSaving;}});\nObject.defineProperty(__exports,\"KLL\",{enumerable:true,get:function(){return KLL;}});\nObject.defineProperty(__exports,\"SKETCH_BOUNDS\",{enumerable:true,get:function(){return SKETCH_BOUNDS;}});\nObject.defineProperty(__exports,\"default\",{enumerable:true,get:function(){return __default;}});\nclass Welford{\n#n=0;\n#mean=0;\n#m2=0;\nstatic get errorBound(){\nreturn Object.freeze({\nkind:'exact',metric:'none',value:0,\nstatement:'mean and variance match a full recompute to float rounding',\n});\n}\nget count(){return this.#n;}\nadd(x){\nif(!Number.isFinite(x))return;\nthis.#n++;\nconst delta=x-this.#mean;\nthis.#mean+=delta/this.#n;\nthis.#m2+=delta*(x-this.#mean);\n}\nmerge(other){\nif(other.#n===0)return;\nif(this.#n===0){this.#n=other.#n;this.#mean=other.#mean;this.#m2=other.#m2;return;}\nconst n=this.#n+other.#n;\nconst delta=other.#mean-this.#mean;\nthis.#mean+=delta*(other.#n/n);\nthis.#m2+=other.#m2+delta*delta*(this.#n*other.#n/n);\nthis.#n=n;\n}\nmean(){return this.#n?this.#mean:null;}\nvariance(){return this.#n>1?this.#m2/(this.#n-1):null;}\nvarianceP(){return this.#n?this.#m2/this.#n:null;}\nstddev(){const v=this.variance();return v===null?null:Math.sqrt(v);}\nstddevP(){const v=this.varianceP();return v===null?null:Math.sqrt(v);}\n}\nclass Reservoir{\n#items=[];\n#seen=0;\n#capacity;\n#rng;\nconstructor(capacity,rng=Math.random){\nif(!(capacity>0))throw new RangeError('reservoir capacity must be positive');\nthis.#capacity=Math.floor(capacity);\nthis.#rng=rng;\n}\nstatic get errorBound(){\nreturn Object.freeze({\nkind:'probabilistic',metric:'none',value:0,\nstatement:'uniform sample: each element included with probability capacity/n; sample statistics are unbiased estimators',\n});\n}\nget seen(){return this.#seen;}\nget size(){return this.#items.length;}\nadd(x){\nif(!Number.isFinite(x))return;\nthis.#seen++;\nif(this.#items.length<this.#capacity){\nthis.#items.push(x);\nreturn;\n}\nconst j=Math.floor(this.#rng()*this.#seen);\nif(j<this.#capacity)this.#items[j]=x;\n}\nsample(){return this.#items.slice();}\nmean(){\nif(!this.#items.length)return null;\nlet s=0;\nfor(const v of this.#items)s+=v;\nreturn s/this.#items.length;\n}\nquantile(p){\nconst n=this.#items.length;\nif(!n)return null;\nconst sorted=this.#items.slice().sort((a,b)=>a-b);\nif(n===1)return sorted[0];\nconst h=(n-1)*Math.min(1,Math.max(0,p));\nconst lo=Math.floor(h);\nconst hi=Math.ceil(h);\nreturn lo===hi?sorted[lo]:sorted[lo]+(h-lo)*(sorted[hi]-sorted[lo]);\n}\n}\nfunction fmix32(h){\nh^=h>>>16;\nh=Math.imul(h,0x85ebca6b);\nh^=h>>>13;\nh=Math.imul(h,0xc2b2ae35);\nh^=h>>>15;\nreturn h>>>0;\n}\nfunction hash32(v){\nif(typeof v==='number'){\nconst buf=new DataView(new ArrayBuffer(8));\nbuf.setFloat64(0,v===0?0:v);\nreturn fmix32(buf.getUint32(0)^buf.getUint32(4));\n}\nconst s=typeof v==='string'?v:String(v);\nlet h=0x811c9dc5;\nfor(let i=0;i<s.length;i++){\nh^=s.charCodeAt(i);\nh=Math.imul(h,0x01000193);\n}\nreturn fmix32(h);\n}\nclass HyperLogLog{\n#p;\n#m;\n#registers;\nconstructor(precision=14){\nconst p=Math.floor(precision);\nif(p<4||p>16)throw new RangeError('HLL precision must be 4..16');\nthis.#p=p;\nthis.#m=1<<p;\nthis.#registers=new Uint8Array(this.#m);\n}\nstatic errorBoundFor(precision=14){\nconst m=1<<Math.floor(precision);\nconst rse=1.04/Math.sqrt(m);\nreturn Object.freeze({\nkind:'probabilistic',metric:'relative',value:rse,\nstatement:`distinct count within ~${(rse*100).toFixed(2)}% relative standard error (m=${m} buckets)`,\n});\n}\nerrorBound(){return HyperLogLog.errorBoundFor(this.#p);}\nadd(v){\nconst h=hash32(v);\nconst idx=h&(this.#m-1);\nconst rest=(h>>>this.#p)|(1<<(32-this.#p));\nlet rank=1;\nlet x=rest;\nwhile((x&1)===0){rank++;x>>>=1;}\nif(rank>this.#registers[idx])this.#registers[idx]=rank;\n}\ncount(){\nconst m=this.#m;\nconst q=32-this.#p;\nconst hist=new Float64Array(q+2);\nfor(let i=0;i<m;i++)hist[this.#registers[i]]++;\nlet z=m*tau(1-hist[q+1]/m);\nfor(let k=q;k>=1;k--)z=0.5*(z+hist[k]);\nz+=m*sigma(hist[0]/m);\nconst estimate=(ERTL_ALPHA_INF*m*m)/z;\nreturn Math.round(estimate);\n}\n}\nconst ERTL_ALPHA_INF=0.5/Math.log(2);\nfunction sigma(x){\nif(x===1)return Infinity;\nlet y=1;\nlet z=x;\nlet prev;\ndo{\nx*=x;\nprev=z;\nz+=x*y;\ny+=y;\n}while(z!==prev);\nreturn z;\n}\nfunction tau(x){\nif(x===0||x===1)return 0;\nlet y=1;\nlet z=1-x;\nlet prev;\ndo{\nx=Math.sqrt(x);\nprev=z;\ny*=0.5;\nz-=(1-x)**2*y;\n}while(z!==prev);\nreturn z/3;\n}\nclass SpaceSaving{\n#counters=new Map();\n#capacity;\n#n=0;\nconstructor(capacity){\nif(!(capacity>0))throw new RangeError('Space-Saving capacity must be positive');\nthis.#capacity=Math.floor(capacity);\n}\nerrorBoundFor(n){\nconst value=n/this.#capacity;\nreturn Object.freeze({\nkind:'deterministic',metric:'absolute',value,\nstatement:`each count overestimates the truth by at most N/m = ${value.toFixed(2)} (N=${n}, m=${this.#capacity})`,\n});\n}\nget seen(){return this.#n;}\nadd(item){\nthis.#n++;\nconst existing=this.#counters.get(item);\nif(existing){existing.count++;return;}\nif(this.#counters.size<this.#capacity){\nthis.#counters.set(item,{count:1,error:0});\nreturn;\n}\nlet minItem;\nlet minCount=Infinity;\nfor(const[k,v]of this.#counters){\nif(v.count<minCount){minCount=v.count;minItem=k;}\n}\nthis.#counters.delete(minItem);\nthis.#counters.set(item,{count:minCount+1,error:minCount});\n}\ntop(k=this.#capacity){\nconst all=[...this.#counters.entries()]\n.map(([item,v])=>({item,count:v.count,error:v.error}))\n.sort((a,b)=>b.count-a.count);\nreturn all.slice(0,Math.max(0,Math.floor(k)));\n}\n}\nclass KLL{\n#k;\n#levels=[[]];\n#n=0;\n#rng;\n#capacityFactor;\nconstructor(k=200,rng=Math.random){\nthis.#k=Math.max(8,Math.floor(k));\nthis.#rng=rng;\nthis.#capacityFactor=2/3;\n}\nstatic errorBoundFor(k=200){\nconst eps=1/Math.max(8,Math.floor(k));\nreturn Object.freeze({\nkind:'probabilistic',metric:'rank',value:eps,\nstatement:`queried quantile's true rank within ~${(eps*100).toFixed(2)}% of N of the requested rank (k=${k})`,\n});\n}\nerrorBound(){return KLL.errorBoundFor(this.#k);}\nget count(){return this.#n;}\n#levelCapacity(height){\nconst top=this.#levels.length-1;\nconst depthFromTop=top-height;\nconst cap=Math.ceil(this.#k*this.#capacityFactor**depthFromTop);\nreturn Math.max(2,cap);\n}\nadd(x){\nif(!Number.isFinite(x))return;\nthis.#n++;\nthis.#levels[0].push(x);\nif(this.#levels[0].length>=this.#levelCapacity(0))this.#compact(0);\n}\n#compact(height){\nconst level=this.#levels[height];\nlevel.sort((a,b)=>a-b);\nif(height+1>=this.#levels.length)this.#levels.push([]);\nconst up=this.#levels[height+1];\nconst offset=this.#rng()<0.5?0:1;\nfor(let i=offset;i<level.length;i+=2)up.push(level[i]);\nthis.#levels[height]=[];\nfor(let h=0;h<this.#levels.length;h++){\nif(this.#levels[h].length>=this.#levelCapacity(h)){this.#compact(h);return;}\n}\n}\n#weighted(){\nconst out=[];\nfor(let h=0;h<this.#levels.length;h++){\nconst w=1<<h;\nfor(const v of this.#levels[h])out.push({v,w});\n}\nreturn out;\n}\nquantile(p){\nconst items=this.#weighted();\nif(!items.length)return null;\nitems.sort((a,b)=>a.v-b.v);\nlet totalW=0;\nfor(const it of items)totalW+=it.w;\nconst target=Math.min(1,Math.max(0,p))*totalW;\nlet cum=0;\nfor(const it of items){\ncum+=it.w;\nif(cum>=target)return it.v;\n}\nreturn items[items.length-1].v;\n}\nrank(x){\nlet cum=0;\nfor(let h=0;h<this.#levels.length;h++){\nconst w=1<<h;\nfor(const v of this.#levels[h])if(v<=x)cum+=w;\n}\nreturn cum;\n}\n}\nconst SKETCH_BOUNDS=Object.freeze({\ndistinct:HyperLogLog.errorBoundFor(14),\nmedian:KLL.errorBoundFor(200),\np25:KLL.errorBoundFor(200),\np75:KLL.errorBoundFor(200),\np90:KLL.errorBoundFor(200),\np95:KLL.errorBoundFor(200),\np99:KLL.errorBoundFor(200),\niqr:KLL.errorBoundFor(200),\ntopK:Object.freeze({\nkind:'deterministic',metric:'absolute',value:0,\nstatement:'each count overestimates the truth by at most N/m; top-K exact when the K-th item exceeds N/m',\n}),\n});\nconst __default={\nWelford,Reservoir,HyperLogLog,SpaceSaving,KLL,hash32,SKETCH_BOUNDS,\n};\n});\n__def(\"packages/core/src/compute/statistics.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"KENDALL_LIMIT\",{enumerable:true,get:function(){return KENDALL_LIMIT;}});\nObject.defineProperty(__exports,\"MAINTENANCE\",{enumerable:true,get:function(){return MAINTENANCE;}});\nObject.defineProperty(__exports,\"APPROXIMATE\",{enumerable:true,get:function(){return APPROXIMATE;}});\nObject.defineProperty(__exports,\"maintenanceOf\",{enumerable:true,get:function(){return maintenanceOf;}});\nObject.defineProperty(__exports,\"numbers\",{enumerable:true,get:function(){return numbers;}});\nObject.defineProperty(__exports,\"frequencies\",{enumerable:true,get:function(){return frequencies;}});\nObject.defineProperty(__exports,\"herfindahl\",{enumerable:true,get:function(){return herfindahl;}});\nObject.defineProperty(__exports,\"entropy\",{enumerable:true,get:function(){return entropy;}});\nObject.defineProperty(__exports,\"evenness\",{enumerable:true,get:function(){return evenness;}});\nObject.defineProperty(__exports,\"topShare\",{enumerable:true,get:function(){return topShare;}});\nObject.defineProperty(__exports,\"gini\",{enumerable:true,get:function(){return gini;}});\nObject.defineProperty(__exports,\"moments\",{enumerable:true,get:function(){return moments;}});\nObject.defineProperty(__exports,\"quantileSorted\",{enumerable:true,get:function(){return quantileSorted;}});\nObject.defineProperty(__exports,\"quantile\",{enumerable:true,get:function(){return quantile;}});\nObject.defineProperty(__exports,\"STAT_FNS\",{enumerable:true,get:function(){return STAT_FNS;}});\nObject.defineProperty(__exports,\"STAT_LABELS\",{enumerable:true,get:function(){return STAT_LABELS;}});\nObject.defineProperty(__exports,\"weightedAverage\",{enumerable:true,get:function(){return weightedAverage;}});\nObject.defineProperty(__exports,\"extremeRow\",{enumerable:true,get:function(){return extremeRow;}});\nObject.defineProperty(__exports,\"correlation\",{enumerable:true,get:function(){return correlation;}});\nObject.defineProperty(__exports,\"trimmedMean\",{enumerable:true,get:function(){return trimmedMean;}});\nObject.defineProperty(__exports,\"winsorizedMean\",{enumerable:true,get:function(){return winsorizedMean;}});\nObject.defineProperty(__exports,\"modifiedZOutliers\",{enumerable:true,get:function(){return modifiedZOutliers;}});\nObject.defineProperty(__exports,\"jarqueBera\",{enumerable:true,get:function(){return jarqueBera;}});\nObject.defineProperty(__exports,\"weightedQuantile\",{enumerable:true,get:function(){return weightedQuantile;}});\nObject.defineProperty(__exports,\"pairs\",{enumerable:true,get:function(){return pairs;}});\nObject.defineProperty(__exports,\"covariance\",{enumerable:true,get:function(){return covariance;}});\nObject.defineProperty(__exports,\"regression\",{enumerable:true,get:function(){return regression;}});\nObject.defineProperty(__exports,\"fitLinearModel\",{enumerable:true,get:function(){return fitLinearModel;}});\nObject.defineProperty(__exports,\"ADF_CT_CRITICAL\",{enumerable:true,get:function(){return ADF_CT_CRITICAL;}});\nObject.defineProperty(__exports,\"augmentedDickeyFuller\",{enumerable:true,get:function(){return augmentedDickeyFuller;}});\nObject.defineProperty(__exports,\"autocorrelations\",{enumerable:true,get:function(){return autocorrelations;}});\nObject.defineProperty(__exports,\"spearman\",{enumerable:true,get:function(){return spearman;}});\nObject.defineProperty(__exports,\"kendall\",{enumerable:true,get:function(){return kendall;}});\nObject.defineProperty(__exports,\"seriesStats\",{enumerable:true,get:function(){return seriesStats;}});\nObject.defineProperty(__exports,\"D2_N2\",{enumerable:true,get:function(){return D2_N2;}});\nObject.defineProperty(__exports,\"D4_N2\",{enumerable:true,get:function(){return D4_N2;}});\nObject.defineProperty(__exports,\"movingRanges\",{enumerable:true,get:function(){return movingRanges;}});\nObject.defineProperty(__exports,\"withinSigma\",{enumerable:true,get:function(){return withinSigma;}});\nObject.defineProperty(__exports,\"capability\",{enumerable:true,get:function(){return capability;}});\nObject.defineProperty(__exports,\"controlLimits\",{enumerable:true,get:function(){return controlLimits;}});\nObject.defineProperty(__exports,\"westernElectricViolations\",{enumerable:true,get:function(){return westernElectricViolations;}});\nObject.defineProperty(__exports,\"nelsonViolations\",{enumerable:true,get:function(){return nelsonViolations;}});\nObject.defineProperty(__exports,\"CONTROL_RULE_SETS\",{enumerable:true,get:function(){return CONTROL_RULE_SETS;}});\nObject.defineProperty(__exports,\"controlViolations\",{enumerable:true,get:function(){return controlViolations;}});\nObject.defineProperty(__exports,\"countOutside\",{enumerable:true,get:function(){return countOutside;}});\nObject.defineProperty(__exports,\"histogram\",{enumerable:true,get:function(){return histogram;}});\nObject.defineProperty(__exports,\"DEFAULT_CONFIDENCE\",{enumerable:true,get:function(){return DEFAULT_CONFIDENCE;}});\nObject.defineProperty(__exports,\"meanInterval\",{enumerable:true,get:function(){return meanInterval;}});\nObject.defineProperty(__exports,\"proportionInterval\",{enumerable:true,get:function(){return proportionInterval;}});\nObject.defineProperty(__exports,\"slopeInterval\",{enumerable:true,get:function(){return slopeInterval;}});\nObject.defineProperty(__exports,\"capabilityInterval\",{enumerable:true,get:function(){return capabilityInterval;}});\nObject.defineProperty(__exports,\"standardizedMeanDifference\",{enumerable:true,get:function(){return standardizedMeanDifference;}});\nObject.defineProperty(__exports,\"normalTotalVariation\",{enumerable:true,get:function(){return normalTotalVariation;}});\nObject.defineProperty(__exports,\"frequencyMap\",{enumerable:true,get:function(){return frequencyMap;}});\nObject.defineProperty(__exports,\"categoricalDistance\",{enumerable:true,get:function(){return categoricalDistance;}});\nObject.defineProperty(__exports,\"SUBSET_RELIABILITY_FLOOR\",{enumerable:true,get:function(){return SUBSET_RELIABILITY_FLOOR;}});\nObject.defineProperty(__exports,\"compareColumn\",{enumerable:true,get:function(){return compareColumn;}});\nObject.defineProperty(__exports,\"isNumericColumn\",{enumerable:true,get:function(){return isNumericColumn;}});\nObject.defineProperty(__exports,\"populationRead\",{enumerable:true,get:function(){return populationRead;}});\nconst __m0=__req(\"packages/core/src/compute/handle.js\");\nconst presenceReader=__m0[\"presenceReader\"];\nconst valueReader=__m0[\"valueReader\"];\nconst __m1=__req(\"packages/core/src/compute/special.js\");\nconst studentTQuantile=__m1[\"studentTQuantile\"];\nconst studentT=__m1[\"studentT\"];\nconst normalQuantile=__m1[\"normalQuantile\"];\nconst normalCdf=__m1[\"normalCdf\"];\nconst chiSquareUpperTail=__m1[\"chiSquareUpperTail\"];\nconst __m2=__req(\"packages/core/src/compute/linalg.js\");\nconst cholesky=__m2[\"cholesky\"];\nconst choleskySolve=__m2[\"choleskySolve\"];\nconst choleskyInverse=__m2[\"choleskyInverse\"];\nconst normalEquations=__m2[\"normalEquations\"];\nconst quadForm=__m2[\"quadForm\"];\nconst __m3=__req(\"packages/core/src/compute/sketch.js\");\nconst SKETCH_BOUNDS=__m3[\"SKETCH_BOUNDS\"];\nconst KENDALL_LIMIT=5000;\nconst MAINTENANCE=Object.freeze({\nvariance:'rescan',\nvarianceP:'rescan',\nstddev:'rescan',\nstddevP:'rescan',\nsumSquares:'rescan',\nweightedAvg:'rescan',\nmedian:'rescan',\np25:'rescan',\np75:'rescan',\np90:'rescan',\np95:'rescan',\np99:'rescan',\niqr:'rescan',\nmode:'rescan',\ndistinct:'rescan',\nrange:'rescan',\nskewness:'rescan',\nkurtosis:'rescan',\ngeomean:'rescan',\nharmean:'rescan',\nmad:'rescan',\nargmin:'rescan',\nargmax:'rescan',\nhhi:'rescan',\nentropy:'rescan',\nevenness:'rescan',\ntop3Share:'rescan',\ntop10Share:'rescan',\ngini:'rescan',\ntrimmedMean:'rescan',\nwinsorizedMean:'rescan',\nrobustOutliers:'rescan',\njarqueBera:'rescan',\npassRate:'rescan',\nfailureCount:'rescan',\n});\nconst APPROXIMATE=Object.freeze({\ndistinct:Object.freeze({sketch:'HyperLogLog',bound:SKETCH_BOUNDS.distinct}),\nmedian:Object.freeze({sketch:'KLL',bound:SKETCH_BOUNDS.median}),\np25:Object.freeze({sketch:'KLL',bound:SKETCH_BOUNDS.p25}),\np75:Object.freeze({sketch:'KLL',bound:SKETCH_BOUNDS.p75}),\np90:Object.freeze({sketch:'KLL',bound:SKETCH_BOUNDS.p90}),\np95:Object.freeze({sketch:'KLL',bound:SKETCH_BOUNDS.p95}),\np99:Object.freeze({sketch:'KLL',bound:SKETCH_BOUNDS.p99}),\niqr:Object.freeze({sketch:'KLL',bound:SKETCH_BOUNDS.iqr}),\ntop3Share:Object.freeze({sketch:'SpaceSaving',bound:SKETCH_BOUNDS.topK}),\ntop10Share:Object.freeze({sketch:'SpaceSaving',bound:SKETCH_BOUNDS.topK}),\n});\nfunction maintenanceOf(fn){\nconst exact=fn==='sum'||fn==='avg'||fn==='countValues'||fn==='min'||fn==='max'\n?'maintained'\n:(Object.prototype.hasOwnProperty.call(MAINTENANCE,fn)?MAINTENANCE[fn]:null);\nconst approximate=Object.prototype.hasOwnProperty.call(APPROXIMATE,fn)?APPROXIMATE[fn]:null;\nreturn{stat:fn,exact,approximate};\n}\nfunction numbers(handle,indices){\nconst n=indices.length;\nconst out=new Float64Array(n);\nlet count=0;\nconst numeric=handle&&(handle.kind==='float64'||handle.kind==='int32');\nif(numeric){\nconst values=handle.values;\nconst present=presenceReader(handle);\nfor(let i=0;i<n;i++){\nconst row=indices[i];\nif(present&&present(row)!==1)continue;\nconst v=values[row];\nif(Number.isNaN(v))continue;\nout[count++]=v;\n}\nreturn out.subarray(0,count);\n}\nconst read=valueReader(handle);\nfor(let i=0;i<n;i++){\nconst raw=read(indices[i]);\nif(raw===null||raw===undefined||raw==='')continue;\nconst v=typeof raw==='number'?raw:Number(raw);\nif(!Number.isFinite(v))continue;\nout[count++]=v;\n}\nreturn out.subarray(0,count);\n}\nfunction frequencies(handle,indices){\nconst seen=new Map();\nconst read=valueReader(handle);\nlet total=0;\nfor(let i=0;i<indices.length;i++){\nconst raw=read(indices[i]);\nif(raw===null||raw===undefined||raw==='')continue;\nif(typeof raw==='number'&&Number.isNaN(raw))continue;\nconst key=typeof raw==='object'?String(raw):raw;\nseen.set(key,(seen.get(key)||0)+1);\ntotal++;\n}\nconst counts=[...seen.values()].sort((a,b)=>b-a);\nreturn{counts,total,distinct:counts.length};\n}\nfunction sharesOf(freq){\nreturn freq.total>0?freq.counts.map((c)=>c/freq.total):[];\n}\nfunction herfindahl(handle,indices){\nconst freq=frequencies(handle,indices);\nif(!freq.total)return null;\nlet sum=0;\nfor(const share of sharesOf(freq))sum+=share*share;\nreturn sum;\n}\nfunction entropy(handle,indices){\nconst freq=frequencies(handle,indices);\nif(!freq.total)return null;\nlet sum=0;\nfor(const share of sharesOf(freq))if(share>0)sum-=share*Math.log2(share);\nreturn sum;\n}\nfunction evenness(handle,indices){\nconst freq=frequencies(handle,indices);\nif(!freq.total||freq.distinct<2)return freq.total?1:null;\nlet sum=0;\nfor(const share of sharesOf(freq))if(share>0)sum-=share*Math.log2(share);\nreturn sum/Math.log2(freq.distinct);\n}\nfunction topShare(handle,indices,n=3){\nconst freq=frequencies(handle,indices);\nif(!freq.total)return null;\nconst take=Math.max(1,Math.floor(n));\nlet held=0;\nfor(let i=0;i<Math.min(take,freq.counts.length);i++)held+=freq.counts[i];\nreturn held/freq.total;\n}\nfunction gini(handle,indices){\nconst values=numbers(handle,indices);\nconst n=values.length;\nif(!n)return null;\nconst sorted=values.slice().sort();\nif(sorted[0]<0)return null;\nlet total=0;\nlet weighted=0;\nfor(let i=0;i<n;i++){\ntotal+=sorted[i];\nweighted+=(i+1)*sorted[i];\n}\nif(total===0)return 0;\nreturn(2*weighted)/(n*total)-(n+1)/n;\n}\nfunction moments(values){\nlet n=0;\nlet mean=0;\nlet m2=0;\nfor(let i=0;i<values.length;i++){\nconst x=values[i];\nn++;\nconst delta=x-mean;\nmean+=delta/n;\nm2+=delta*(x-mean);\n}\nreturn{n,mean,m2};\n}\nfunction quantileSorted(sorted,p){\nconst n=sorted.length;\nif(!n)return NaN;\nif(n===1)return sorted[0];\nconst h=(n-1)*Math.min(1,Math.max(0,p));\nconst lo=Math.floor(h);\nconst hi=Math.ceil(h);\nif(lo===hi)return sorted[lo];\nreturn sorted[lo]+(h-lo)*(sorted[hi]-sorted[lo]);\n}\nfunction quantile(values,p){\nif(!values.length)return NaN;\nconst sorted=values.slice().sort();\nreturn quantileSorted(sorted,p);\n}\nfunction specTally(handle,indices){\nconst read=valueReader(handle);\nlet pass=0;\nlet fail=0;\nlet warn=0;\nfor(let k=0;k<indices.length;k++){\nconst raw=read(indices[k]);\nif(raw===null||raw===undefined||raw==='')continue;\nconst token=String(raw).toUpperCase();\nif(token==='PASS')pass++;\nelse if(token==='FAIL')fail++;\nelse if(token==='WARN')warn++;\n}\nreturn{pass:pass+warn,fail,warn,judged:pass+warn+fail};\n}\nconst STAT_FNS=Object.freeze({\nhhi:(h,i)=>herfindahl(h,i),\nentropy:(h,i)=>entropy(h,i),\nevenness:(h,i)=>evenness(h,i),\ntop3Share:(h,i)=>topShare(h,i,3),\ntop10Share:(h,i)=>topShare(h,i,10),\ngini:(h,i)=>gini(h,i),\ntrimmedMean:(h,i)=>trimmedMean(numbers(h,i),0.1),\nwinsorizedMean:(h,i)=>winsorizedMean(numbers(h,i),0.1),\nrobustOutliers:(h,i)=>modifiedZOutliers(numbers(h,i),3.5),\njarqueBera:(h,i)=>jarqueBera(numbers(h,i)),\nvariance:(h,i)=>{\nconst{n,m2}=moments(numbers(h,i));\nreturn n>1?m2/(n-1):null;\n},\nvarianceP:(h,i)=>{\nconst{n,m2}=moments(numbers(h,i));\nreturn n>0?m2/n:null;\n},\nstddev:(h,i)=>{\nconst{n,m2}=moments(numbers(h,i));\nreturn n>1?Math.sqrt(m2/(n-1)):null;\n},\nstddevP:(h,i)=>{\nconst{n,m2}=moments(numbers(h,i));\nreturn n>0?Math.sqrt(m2/n):null;\n},\nmedian:(h,i)=>{\nconst values=numbers(h,i);\nreturn values.length?quantile(values,0.5):null;\n},\np25:(h,i)=>{\nconst values=numbers(h,i);\nreturn values.length?quantile(values,0.25):null;\n},\np75:(h,i)=>{\nconst values=numbers(h,i);\nreturn values.length?quantile(values,0.75):null;\n},\np90:(h,i)=>{\nconst values=numbers(h,i);\nreturn values.length?quantile(values,0.9):null;\n},\np95:(h,i)=>{\nconst values=numbers(h,i);\nreturn values.length?quantile(values,0.95):null;\n},\np99:(h,i)=>{\nconst values=numbers(h,i);\nreturn values.length?quantile(values,0.99):null;\n},\niqr:(h,i)=>{\nconst values=numbers(h,i);\nif(!values.length)return null;\nconst sorted=values.slice().sort();\nreturn quantileSorted(sorted,0.75)-quantileSorted(sorted,0.25);\n},\nmad:(h,i)=>{\nconst values=numbers(h,i);\nif(!values.length)return null;\nconst middle=quantile(values,0.5);\nconst deviations=new Float64Array(values.length);\nfor(let k=0;k<values.length;k++)deviations[k]=Math.abs(values[k]-middle);\nreturn quantile(deviations,0.5);\n},\nrange:(h,i)=>{\nconst values=numbers(h,i);\nif(!values.length)return null;\nlet lo=Infinity;\nlet hi=-Infinity;\nfor(let k=0;k<values.length;k++){\nif(values[k]<lo)lo=values[k];\nif(values[k]>hi)hi=values[k];\n}\nreturn hi-lo;\n},\ndistinct:(h,i)=>{\nconst read=valueReader(h);\nconst seen=new Set();\nfor(let k=0;k<i.length;k++){\nconst v=read(i[k]);\nif(v===null||v===undefined||v==='')continue;\nseen.add(v instanceof Date?v.getTime():v);\n}\nreturn seen.size;\n},\nmode:(h,i)=>{\nconst read=valueReader(h);\nconst counts=new Map();\nfor(let k=0;k<i.length;k++){\nconst v=read(i[k]);\nif(v===null||v===undefined||v==='')continue;\nconst id=v instanceof Date?v.getTime():v;\ncounts.set(id,(counts.get(id)||0)+1);\n}\nlet best=null;\nlet most=1;\nfor(const[value,times]of counts){\nif(times>most){\nmost=times;\nbest=value;\n}\n}\nreturn best;\n},\nskewness:(h,i)=>{\nconst values=numbers(h,i);\nconst{n,mean,m2}=moments(values);\nif(n<3||m2<=0)return null;\nconst sd=Math.sqrt(m2/(n-1));\nlet sum=0;\nfor(let k=0;k<values.length;k++)sum+=((values[k]-mean)/sd)**3;\nreturn(n/((n-1)*(n-2)))*sum;\n},\nkurtosis:(h,i)=>{\nconst values=numbers(h,i);\nconst{n,mean,m2}=moments(values);\nif(n<4||m2<=0)return null;\nconst sd=Math.sqrt(m2/(n-1));\nlet sum=0;\nfor(let k=0;k<values.length;k++)sum+=((values[k]-mean)/sd)**4;\nconst a=(n*(n+1))/((n-1)*(n-2)*(n-3));\nconst b=(3*(n-1)**2)/((n-2)*(n-3));\nreturn a*sum-b;\n},\ngeomean:(h,i)=>{\nconst values=numbers(h,i);\nif(!values.length)return null;\nlet sum=0;\nfor(let k=0;k<values.length;k++){\nif(values[k]<=0)return null;\nsum+=Math.log(values[k]);\n}\nreturn Math.exp(sum/values.length);\n},\nharmean:(h,i)=>{\nconst values=numbers(h,i);\nif(!values.length)return null;\nlet sum=0;\nfor(let k=0;k<values.length;k++){\nif(values[k]===0)return null;\nsum+=1/values[k];\n}\nreturn values.length/sum;\n},\nsumSquares:(h,i)=>{\nconst values=numbers(h,i);\nlet sum=0;\nfor(let k=0;k<values.length;k++)sum+=values[k]*values[k];\nreturn sum;\n},\npassRate:(h,i)=>{\nconst{pass,judged}=specTally(h,i);\nreturn judged?pass/judged:null;\n},\nfailureCount:(h,i)=>specTally(h,i).fail,\n});\nconst STAT_LABELS=Object.freeze({\nhhi:'Concentration (HHI)',\nentropy:'Entropy',\nevenness:'Evenness',\ntop3Share:'Top 3 share',\ntop10Share:'Top 10 share',\ngini:'Gini coefficient',\ntrimmedMean:'Trimmed mean',\nwinsorizedMean:'Winsorized mean',\nrobustOutliers:'Outliers (robust)',\njarqueBera:'Jarque–Bera',\nmedian:'Median',\np25:'25th percentile',\np75:'75th percentile',\np90:'90th percentile',\np95:'95th percentile',\np99:'99th percentile',\niqr:'Interquartile range',\nmad:'Median absolute deviation',\nvariance:'Variance',\nvarianceP:'Variance (population)',\nstddev:'Standard deviation',\nstddevP:'Standard deviation (population)',\nrange:'Range',\ndistinct:'Distinct',\nmode:'Mode',\nskewness:'Skewness',\nkurtosis:'Kurtosis',\ngeomean:'Geometric mean',\nharmean:'Harmonic mean',\nsumSquares:'Sum of squares',\nweightedAvg:'Weighted average',\nargmin:'Lowest by',\nargmax:'Highest by',\npassRate:'Pass rate',\nfailureCount:'Failures',\n});\nfunction weightedAverage(handle,weights,indices){\nconst readValue=valueReader(handle);\nconst readWeight=valueReader(weights);\nlet top=0;\nlet bottom=0;\nfor(let i=0;i<indices.length;i++){\nconst row=indices[i];\nconst value=Number(readValue(row));\nconst weight=Number(readWeight(row));\nif(!Number.isFinite(value)||!Number.isFinite(weight))continue;\ntop+=value*weight;\nbottom+=weight;\n}\nreturn bottom===0?null:top/bottom;\n}\nfunction extremeRow(handle,indices,largest){\nconst read=valueReader(handle);\nlet best=null;\nlet bestValue=largest?-Infinity:Infinity;\nfor(let i=0;i<indices.length;i++){\nconst row=indices[i];\nconst value=Number(read(row));\nif(!Number.isFinite(value))continue;\nif(largest?value>bestValue:value<bestValue){\nbestValue=value;\nbest=row;\n}\n}\nreturn best;\n}\nfunction correlation(a,b,indices){\nconst readA=valueReader(a);\nconst readB=valueReader(b);\nlet n=0;\nlet sx=0;\nlet sy=0;\nlet sxx=0;\nlet syy=0;\nlet sxy=0;\nfor(let i=0;i<indices.length;i++){\nconst row=indices[i];\nconst x=Number(readA(row));\nconst y=Number(readB(row));\nif(!Number.isFinite(x)||!Number.isFinite(y))continue;\nn++;\nsx+=x;\nsy+=y;\nsxx+=x*x;\nsyy+=y*y;\nsxy+=x*y;\n}\nif(n<2)return null;\nconst top=n*sxy-sx*sy;\nconst bottom=Math.sqrt((n*sxx-sx*sx)*(n*syy-sy*sy));\nif(bottom===0)return null;\nconst r=top/bottom;\nreturn Math.max(-1,Math.min(1,r));\n}\nfunction trimmedMean(values,share=0.1){\nconst n=values.length;\nif(!n)return null;\nconst sorted=Array.from(values).sort((a,b)=>a-b);\nconst cut=Math.floor(n*Math.min(0.49,Math.max(0,share)));\nconst kept=sorted.slice(cut,n-cut);\nif(!kept.length)return quantileSorted(sorted,0.5);\nlet sum=0;\nfor(const v of kept)sum+=v;\nreturn sum/kept.length;\n}\nfunction winsorizedMean(values,share=0.1){\nconst n=values.length;\nif(!n)return null;\nconst sorted=Array.from(values).sort((a,b)=>a-b);\nconst cut=Math.floor(n*Math.min(0.49,Math.max(0,share)));\nconst low=sorted[cut];\nconst high=sorted[n-1-cut];\nlet sum=0;\nfor(const v of sorted)sum+=Math.min(high,Math.max(low,v));\nreturn sum/n;\n}\nfunction modifiedZOutliers(values,threshold=3.5){\nconst n=values.length;\nif(!n)return null;\nconst sorted=Array.from(values).sort((a,b)=>a-b);\nconst middle=quantileSorted(sorted,0.5);\nconst deviations=sorted.map((v)=>Math.abs(v-middle)).sort((a,b)=>a-b);\nconst mad=quantileSorted(deviations,0.5);\nif(mad===0)return null;\nlet count=0;\nfor(const v of sorted)if(Math.abs((0.6745*(v-middle))/mad)>threshold)count++;\nreturn count;\n}\nfunction jarqueBera(values){\nconst n=values.length;\nif(n<8)return null;\nlet mean=0;\nfor(const v of values)mean+=v;\nmean/=n;\nlet m2=0;\nlet m3=0;\nlet m4=0;\nfor(const v of values){\nconst d=v-mean;\nm2+=d*d;\nm3+=d*d*d;\nm4+=d*d*d*d;\n}\nm2/=n;\nm3/=n;\nm4/=n;\nif(m2===0)return null;\nconst skew=m3/m2**1.5;\nconst excess=m4/(m2*m2)-3;\nreturn(n/6)*(skew*skew+(excess*excess)/4);\n}\nfunction weightedQuantile(values,weights,p){\nconst paired=[];\nlet total=0;\nfor(let i=0;i<values.length;i++){\nconst v=Number(values[i]);\nconst w=Number(weights[i]);\nif(!Number.isFinite(v)||!Number.isFinite(w)||w<=0)continue;\npaired.push([v,w]);\ntotal+=w;\n}\nif(!paired.length||total<=0)return null;\npaired.sort((a,b)=>a[0]-b[0]);\nif(paired.length===1)return paired[0][0];\nconst at=[];\nlet seen=0;\nfor(const[,w]of paired){\nat.push((seen+w/2)/total);\nseen+=w;\n}\nconst target=Math.max(0,Math.min(1,p));\nif(target<=at[0])return paired[0][0];\nif(target>=at[at.length-1])return paired[paired.length-1][0];\nfor(let i=1;i<at.length;i++){\nif(target>at[i])continue;\nconst span=at[i]-at[i-1];\nconst within=span>0?(target-at[i-1])/span:0;\nreturn paired[i-1][0]+(paired[i][0]-paired[i-1][0])*within;\n}\nreturn paired[paired.length-1][0];\n}\nfunction pairs(a,b,indices){\nconst readA=valueReader(a);\nconst readB=valueReader(b);\nconst xs=new Float64Array(indices.length);\nconst ys=new Float64Array(indices.length);\nlet n=0;\nfor(let i=0;i<indices.length;i++){\nconst row=indices[i];\nconst x=Number(readA(row));\nconst y=Number(readB(row));\nif(!Number.isFinite(x)||!Number.isFinite(y))continue;\nxs[n]=x;\nys[n]=y;\nn++;\n}\nreturn{xs:xs.subarray(0,n),ys:ys.subarray(0,n),n};\n}\nfunction covariance(a,b,indices,population=false){\nconst{xs,ys,n}=pairs(a,b,indices);\nif(n<2)return null;\nlet mx=0;\nlet my=0;\nfor(let i=0;i<n;i++){mx+=xs[i];my+=ys[i];}\nmx/=n;\nmy/=n;\nlet sum=0;\nfor(let i=0;i<n;i++)sum+=(xs[i]-mx)*(ys[i]-my);\nreturn sum/(population?n:n-1);\n}\nfunction regression(a,b,indices){\nconst{xs,ys,n}=pairs(a,b,indices);\nif(n<2)return null;\nlet mx=0;\nlet my=0;\nfor(let i=0;i<n;i++){mx+=xs[i];my+=ys[i];}\nmx/=n;\nmy/=n;\nlet sxx=0;\nlet sxy=0;\nlet syy=0;\nfor(let i=0;i<n;i++){\nconst dx=xs[i]-mx;\nconst dy=ys[i]-my;\nsxx+=dx*dx;\nsxy+=dx*dy;\nsyy+=dy*dy;\n}\nif(sxx===0)return null;\nconst slope=sxy/sxx;\nconst intercept=my-slope*mx;\nconst r2=syy===0?1:Math.max(0,Math.min(1,(sxy*sxy)/(sxx*syy)));\nconst residual=Math.max(0,syy-slope*sxy);\nconst stdError=n>2?Math.sqrt(residual/(n-2)/sxx):0;\nreturn{slope,intercept,r2,stdError,n};\n}\nconst SUPPORTED_METHODS=new Set(['ols','wls','robust']);\nconst DEFERRED_METHODS=new Set(['quantile']);\nconst OUT_OF_SCOPE_METHODS=new Set(['ridge','lasso','elasticnet','mixed','gls']);\nconst HUBER_C=1.345;\nfunction solveWls(design,y,w){\nconst{xtwx,xtwy}=normalEquations(design,y,w);\nconst l=cholesky(xtwx);\nif(!l)return null;\nconst beta=choleskySolve(l,xtwy);\nconst cov=choleskyInverse(l);\nconst fitted=matVecRows(design,beta);\nconst residuals=y.map((yi,i)=>yi-fitted[i]);\nreturn{beta,cov,fitted,residuals};\n}\nfunction matVecRows(rows,v){\nreturn rows.map((row)=>row.reduce((sum,cell,j)=>sum+cell*v[j],0));\n}\nfunction auxiliaryR2(predictors,j){\nconst n=predictors.length;\nconst y=predictors.map((row)=>row[j]);\nconst design=predictors.map((row)=>[1,...row.filter((unused,c)=>c!==j)]);\nconst fit=solveWls(design,y,null);\nif(!fit)return 1;\nconst ybar=y.reduce((s,v)=>s+v,0)/n;\nlet rss=0;\nlet tss=0;\nfor(let i=0;i<n;i++){rss+=fit.residuals[i]**2;tss+=(y[i]-ybar)**2;}\nif(tss===0)return 1;\nreturn Math.max(0,Math.min(1,1-rss/tss));\n}\nfunction madScale(values){\nconst sorted=[...values].sort((a,b)=>a-b);\nconst med=medianOfSorted(sorted);\nconst dev=values.map((v)=>Math.abs(v-med)).sort((a,b)=>a-b);\nreturn medianOfSorted(dev)/0.6745;\n}\nfunction medianOfSorted(sorted){\nconst n=sorted.length;\nif(!n)return 0;\nconst mid=Math.floor(n/2);\nreturn n%2?sorted[mid]:(sorted[mid-1]+sorted[mid])/2;\n}\nfunction fitLinearModel(matrix,y,opts={}){\nconst method=opts.method||'ols';\nif(OUT_OF_SCOPE_METHODS.has(method)){\nthrow new Error(`[lattice] regression method \"${method}\" is out of scope; use ols, wls or robust.`);\n}\nif(DEFERRED_METHODS.has(method)){\nthrow new Error(`[lattice] quantile regression is coming next and not yet available; use ols, wls or robust.`);\n}\nif(!SUPPORTED_METHODS.has(method)){\nthrow new Error(`[lattice] unknown regression method \"${method}\"; use ols, wls or robust.`);\n}\nconst n=Array.isArray(y)?y.length:0;\nconst k=n&&Array.isArray(matrix[0])?matrix[0].length:0;\nconst p=k+1;\nif(!(n>p))return null;\nfor(let i=0;i<n;i++){\nif(!Number.isFinite(y[i]))return null;\nif(!Array.isArray(matrix[i])||matrix[i].length!==k)return null;\nfor(let j=0;j<k;j++)if(!Number.isFinite(matrix[i][j]))return null;\n}\nlet weights=null;\nif(method==='wls'){\nweights=opts.weights;\nif(!Array.isArray(weights)||weights.length!==n)return null;\nfor(let i=0;i<n;i++)if(!(weights[i]>0)||!Number.isFinite(weights[i]))return null;\n}\nconst design=matrix.map((row)=>[1,...row]);\nlet fit;\nlet robustWeights=null;\nif(method==='robust'){\nfit=solveWls(design,y,null);\nif(!fit)return null;\nfor(let iter=0;iter<50;iter++){\nconst scale=madScale(fit.residuals);\nif(!(scale>0))break;\nconst w=fit.residuals.map((r)=>{\nconst u=Math.abs(r/scale);\nreturn u<=HUBER_C?1:HUBER_C/u;\n});\nconst next=solveWls(design,y,w);\nif(!next)return null;\nconst moved=next.beta.reduce((m,b,j)=>Math.max(m,Math.abs(b-fit.beta[j])),0);\nfit=next;\nrobustWeights=w;\nif(moved<1e-10)break;\n}\n}else{\nfit=solveWls(design,y,weights);\nif(!fit)return null;\n}\nconst w=method==='robust'?robustWeights:weights;\nconst{beta,cov,fitted,residuals}=fit;\nlet rss=0;\nlet sw=0;\nlet swy=0;\nfor(let i=0;i<n;i++){\nconst wi=w?w[i]:1;\nrss+=wi*residuals[i]**2;\nsw+=wi;\nswy+=wi*y[i];\n}\nconst ybar=swy/sw;\nlet tss=0;\nfor(let i=0;i<n;i++){const wi=w?w[i]:1;tss+=wi*(y[i]-ybar)**2;}\nconst df=n-p;\nconst sigma2=rss/df;\nconst r2=tss===0?1:Math.max(0,Math.min(1,1-rss/tss));\nconst adjR2=1-(1-r2)*(n-1)/df;\nconst names=Array.isArray(opts.names)&&opts.names.length===k\n?opts.names:matrix[0].map((unused,j)=>`x${j+1}`);\nconst conf=level(opts.confidence);\nconst tCrit=df>0?studentTQuantile(1-(1-conf)/2,df):Infinity;\nconst coefficients=beta.map((estimate,j)=>{\nconst stdError=Math.sqrt(Math.max(0,sigma2*cov[j][j]));\nconst t=stdError>0?estimate/stdError:(estimate===0?0:Infinity);\nconst pv=Number.isFinite(t)?2*(1-studentT(Math.abs(t),df)):0;\nconst half=Number.isFinite(tCrit)?tCrit*stdError:null;\nreturn{\nname:j===0?'(intercept)':names[j-1],\nestimate,\nstdError,\nt,\np:Math.max(0,Math.min(1,pv)),\nlower:half===null?null:estimate-half,\nupper:half===null?null:estimate+half,\n};\n});\nconst leverage=new Array(n);\nconst cooksD=new Array(n);\nfor(let i=0;i<n;i++){\nconst wi=w?w[i]:1;\nconst h=Math.max(0,Math.min(1,wi*quadForm(design[i],cov)));\nleverage[i]=h;\nconst denom=(1-h)**2;\ncooksD[i]=(denom>0&&sigma2>0)\n?(residuals[i]**2/(p*sigma2))*(h/denom)\n:null;\n}\nconst vif=matrix[0].map((unused,j)=>{\nif(k<2)return 1;\nconst rj=auxiliaryR2(matrix,j);\nreturn rj>=1?Infinity:1/(1-rj);\n});\nlet hetero=null;\n{\nconst e2=residuals.map((r)=>r*r);\nconst aux=solveWls(design,e2,null);\nif(aux){\nconst e2bar=e2.reduce((s,v)=>s+v,0)/n;\nlet arss=0;\nlet atss=0;\nfor(let i=0;i<n;i++){arss+=aux.residuals[i]**2;atss+=(e2[i]-e2bar)**2;}\nconst auxR2=atss===0?0:Math.max(0,Math.min(1,1-arss/atss));\nconst statistic=n*auxR2;\nconst pv=chiSquareUpperTail(statistic,k);\nhetero={statistic,df:k,p:pv,heteroscedastic:pv<0.05};\n}\n}\nlet band=null;\nif(k===1){\nconst order=matrix.map((row,i)=>i).sort((i,j)=>matrix[i][0]-matrix[j][0]);\nband={\nconfidence:conf,\npoints:order.map((i)=>{\nconst xo=design[i];\nconst se=Math.sqrt(Math.max(0,sigma2*quadForm(xo,cov)));\nreturn{x:matrix[i][0],yhat:fitted[i],lower:fitted[i]-tCrit*se,upper:fitted[i]+tCrit*se};\n}),\n};\n}\nreturn{\nmethod,\ncoefficients,\nr2,\nadjR2,\nn,\ndf,\nsigma2,\nfitted,\nresiduals,\nleverage,\ncooksD,\nvif,\nheteroscedasticity:hetero,\nband,\nweights:w?[...w]:null,\n};\n}\nfunction ranksOf(values){\nconst n=values.length;\nconst order=Array.from({length:n},(unused,i)=>i)\n.sort((i,j)=>values[i]-values[j]);\nconst ranks=new Float64Array(n);\nlet i=0;\nwhile(i<n){\nlet j=i;\nwhile(j+1<n&&values[order[j+1]]===values[order[i]])j++;\nconst shared=(i+j)/2+1;\nfor(let k=i;k<=j;k++)ranks[order[k]]=shared;\ni=j+1;\n}\nreturn ranks;\n}\nconst ADF_CT_CRITICAL=Object.freeze({'1%':-3.9638,'5%':-3.4126,'10%':-3.1279});\nfunction adfInterpolatedP(stat){\nconst levels=[0.01,0.05,0.10];\nconst crit=[ADF_CT_CRITICAL['1%'],ADF_CT_CRITICAL['5%'],ADF_CT_CRITICAL['10%']];\nif(stat<=crit[0]){\nconst slope=(Math.log(levels[1])-Math.log(levels[0]))/(crit[1]-crit[0]);\nreturn Math.max(1e-4,Math.min(0.01,Math.exp(Math.log(levels[0])+slope*(stat-crit[0]))));\n}\nif(stat>=crit[2]){\nconst slope=(Math.log(levels[2])-Math.log(levels[1]))/(crit[2]-crit[1]);\nreturn Math.max(0.10,Math.min(0.999,Math.exp(Math.log(levels[2])+slope*(stat-crit[2]))));\n}\nconst i=stat<crit[1]?0:1;\nconst t=(stat-crit[i])/(crit[i+1]-crit[i]);\nreturn Math.exp(Math.log(levels[i])+t*(Math.log(levels[i+1])-Math.log(levels[i])));\n}\nfunction augmentedDickeyFuller(x,opts={}){\nconst series=[];\nfor(let i=0;i<x.length;i++){\nconst v=Number(x[i]);\nif(Number.isFinite(v))series.push(v);\n}\nconst n=series.length;\nconst m=n-1;\nif(n<8||m<6)return null;\nconst xdiff=new Array(m);\nfor(let i=0;i<m;i++)xdiff[i]=series[i+1]-series[i];\nlet maxlag=Number.isFinite(opts.maxlag)\n?Math.floor(opts.maxlag)\n:Math.ceil(12*(n/100)**0.25);\nmaxlag=Math.max(0,Math.min(maxlag,Math.floor((m-5)/2)));\nconst fit=(p,start)=>{\nconst rows=[];\nconst y=[];\nfor(let j=start;j<m;j++){\nconst row=[(j-start)+1,series[j]];\nfor(let d=1;d<=p;d++)row.push(xdiff[j-d]);\nrows.push(row);\ny.push(xdiff[j]);\n}\nreturn fitLinearModel(rows,y,{method:'ols'});\n};\nconst nFixed=m-maxlag;\nlet bestLag=0;\nlet bestAic=Infinity;\nfor(let p=0;p<=maxlag;p++){\nconst model=fit(p,maxlag);\nif(!model)continue;\nconst params=p+3;\nconst rss=model.sigma2*(nFixed-params);\nif(!(rss>0))continue;\nconst aic=nFixed*Math.log(rss/nFixed)+2*params;\nif(aic<bestAic){bestAic=aic;bestLag=p;}\n}\nconst finalModel=fit(bestLag,bestLag);\nif(!finalModel||!finalModel.coefficients[2])return null;\nconst statistic=finalModel.coefficients[2].t;\nconst pValue=adfInterpolatedP(statistic);\nconst stationary=statistic<ADF_CT_CRITICAL['5%'];\nreturn{\nstatistic,\nusedLag:bestLag,\nnobs:m-bestLag,\ncriticalValues:{...ADF_CT_CRITICAL},\npValue,\npApproximate:true,\nstationary,\nverdict:stationary?'stationary':'non-stationary',\nregression:'ct',\n};\n}\nfunction autocorrelations(x,opts={}){\nconst y=[];\nfor(let i=0;i<x.length;i++){\nconst v=Number(x[i]);\nif(Number.isFinite(v))y.push(v);\n}\nconst n=y.length;\nif(n<3)return null;\nlet maxlag=Number.isFinite(opts.maxlag)?Math.floor(opts.maxlag):Math.min(10,n-1);\nmaxlag=Math.max(1,Math.min(maxlag,n-1));\nlet mean=0;\nfor(const v of y)mean+=v;\nmean/=n;\nconst dev=y.map((v)=>v-mean);\nlet c0=0;\nfor(const d of dev)c0+=d*d;\nc0/=n;\nconst acf=new Array(maxlag+1).fill(0);\nacf[0]=1;\nfor(let k=1;k<=maxlag;k++){\nlet s=0;\nfor(let t=k;t<n;t++)s+=dev[t]*dev[t-k];\nacf[k]=c0>0?(s/n)/c0:0;\n}\nconst pacf=new Array(maxlag+1).fill(0);\npacf[0]=1;\nlet prev=[];\nfor(let k=1;k<=maxlag;k++){\nlet num=acf[k];\nfor(let j=1;j<k;j++)num-=prev[j-1]*acf[k-j];\nlet den=1;\nfor(let j=1;j<k;j++)den-=prev[j-1]*acf[j];\nconst phikk=den!==0?num/den:0;\nconst cur=new Array(k);\nfor(let j=1;j<k;j++)cur[j-1]=prev[j-1]-phikk*prev[k-1-j];\ncur[k-1]=phikk;\npacf[k]=phikk;\nprev=cur;\n}\nconst bound=1.96/Math.sqrt(n);\nreturn{acf,pacf,bounds:{upper:bound,lower:-bound},n,nlags:maxlag,approximate:true};\n}\nfunction spearman(a,b,indices){\nconst{xs,ys,n}=pairs(a,b,indices);\nif(n<2)return null;\nconst rx=ranksOf(xs);\nconst ry=ranksOf(ys);\nlet mx=0;\nlet my=0;\nfor(let i=0;i<n;i++){mx+=rx[i];my+=ry[i];}\nmx/=n;\nmy/=n;\nlet sxy=0;\nlet sxx=0;\nlet syy=0;\nfor(let i=0;i<n;i++){\nconst dx=rx[i]-mx;\nconst dy=ry[i]-my;\nsxy+=dx*dy;\nsxx+=dx*dx;\nsyy+=dy*dy;\n}\nif(sxx===0||syy===0)return null;\nreturn Math.max(-1,Math.min(1,sxy/Math.sqrt(sxx*syy)));\n}\nfunction kendall(a,b,indices){\nconst{xs,ys,n}=pairs(a,b,indices);\nif(n<2||n>KENDALL_LIMIT)return null;\nlet concordant=0;\nlet discordant=0;\nlet tiedXOnly=0;\nlet tiedYOnly=0;\nfor(let i=0;i<n;i++){\nfor(let j=i+1;j<n;j++){\nconst dx=Math.sign(xs[i]-xs[j]);\nconst dy=Math.sign(ys[i]-ys[j]);\nconst product=dx*dy;\nif(product>0)concordant++;\nelse if(product<0)discordant++;\nelse if(dx===0&&dy===0){}\nelse if(dx===0)tiedXOnly++;\nelse tiedYOnly++;\n}\n}\nconst orderedByX=concordant+discordant+tiedYOnly;\nconst orderedByY=concordant+discordant+tiedXOnly;\nif(orderedByX===0||orderedByY===0)return null;\nreturn(concordant-discordant)/Math.sqrt(orderedByX*orderedByY);\n}\nfunction seriesStats(ordered,opts={}){\nconst n=ordered.length;\nif(n<2)return null;\nconst first=ordered[0];\nconst last=ordered[n-1];\nconst returns=[];\nfor(let i=1;i<n;i++){\nconst previous=ordered[i-1];\nif(previous===0)continue;\nreturns.push((ordered[i]-previous)/Math.abs(previous));\n}\nlet volatility=null;\nif(returns.length>1){\nlet mean=0;\nfor(const r of returns)mean+=r;\nmean/=returns.length;\nlet m2=0;\nfor(const r of returns)m2+=(r-mean)**2;\nvolatility=Math.sqrt(m2/(returns.length-1));\n}\nconst periods=Number(opts.periodsPerYear)>0?Number(opts.periodsPerYear):null;\nlet peak=ordered[0];\nlet peakAt=0;\nlet worst=0;\nlet worstFrom=0;\nlet worstTo=0;\nfor(let i=1;i<n;i++){\nif(ordered[i]>peak){peak=ordered[i];peakAt=i;continue;}\nif(peak<=0)continue;\nconst fall=(peak-ordered[i])/peak;\nif(fall>worst){worst=fall;worstFrom=peakAt;worstTo=i;}\n}\nlet autocorrelation=null;\nif(n>2){\nlet mean=0;\nfor(let i=0;i<n;i++)mean+=ordered[i];\nmean/=n;\nlet top=0;\nlet bottom=0;\nfor(let i=0;i<n;i++){\nconst d=ordered[i]-mean;\nbottom+=d*d;\nif(i>0)top+=d*(ordered[i-1]-mean);\n}\nautocorrelation=bottom>0?top/bottom:null;\n}\nlet up=0;\nlet down=0;\nfor(const r of returns){if(r>0)up++;else if(r<0)down++;}\nlet growth=null;\nif(first>0&&last>0){\nconst perPeriod=(last/first)**(1/(n-1))-1;\ngrowth=periods?(1+perPeriod)**periods-1:perPeriod;\n}\nreturn{\nn,\nfirst,\nlast,\nchange:last-first,\nchangePercent:first===0?null:((last-first)/Math.abs(first))*100,\nvolatility,\nannualisedVolatility:volatility!==null&&periods?volatility*Math.sqrt(periods):null,\ngrowth,\nmaxDrawdown:worst,\nmaxDrawdownFrom:worstFrom,\nmaxDrawdownTo:worstTo,\nautocorrelation,\nupDays:up,\ndownDays:down,\n};\n}\nconst D2_N2=1.128;\nconst D4_N2=3.267;\nfunction movingRanges(ordered){\nconst n=ordered.length;\nif(n<2)return null;\nconst ranges=[];\nfor(let i=1;i<n;i++)ranges.push(Math.abs(ordered[i]-ordered[i-1]));\nconst centre=ranges.reduce((t,r)=>t+r,0)/ranges.length;\nreturn{ranges,centre,upper:D4_N2*centre,lower:0};\n}\nfunction withinSigma(ordered){\nconst n=ordered.length;\nif(n<2)return null;\nlet total=0;\nfor(let i=1;i<n;i++)total+=Math.abs(ordered[i]-ordered[i-1]);\nconst meanRange=total/(n-1);\nreturn{sigma:meanRange/D2_N2,meanRange};\n}\nfunction capability(ordered,spec){\nconst n=ordered.length;\nif(n<2||!spec)return null;\nconst lower=Number.isFinite(Number(spec.lower))?Number(spec.lower):null;\nconst upper=Number.isFinite(Number(spec.upper))?Number(spec.upper):null;\nif(lower===null&&upper===null)return null;\nlet mean=0;\nfor(let i=0;i<n;i++)mean+=ordered[i];\nmean/=n;\nlet m2=0;\nfor(let i=0;i<n;i++)m2+=(ordered[i]-mean)**2;\nconst overall=Math.sqrt(m2/(n-1));\nconst within=withinSigma(ordered);\nconst sigmaWithin=within?within.sigma:null;\nconst indices=(sigma)=>{\nif(!sigma||sigma<=0)return{index:null,k:null};\nconst both=lower!==null&&upper!==null;\nconst index=both?(upper-lower)/(6*sigma):null;\nconst upperSide=upper!==null?(upper-mean)/(3*sigma):Infinity;\nconst lowerSide=lower!==null?(mean-lower)/(3*sigma):Infinity;\nreturn{index,k:Math.min(upperSide,lowerSide)};\n};\nconst short=indices(sigmaWithin);\nconst long=indices(overall);\nlet outOfSpec=0;\nfor(let i=0;i<n;i++){\nif(lower!==null&&ordered[i]<lower){outOfSpec++;continue;}\nif(upper!==null&&ordered[i]>upper)outOfSpec++;\n}\nreturn{\nn,\nmean,\nlower,\nupper,\ntarget:Number.isFinite(Number(spec.target))?Number(spec.target):null,\nsigmaWithin,\nsigmaOverall:overall,\ncp:short.index,\ncpk:short.k,\npp:long.index,\nppk:long.k,\noutOfSpec,\ndefectRate:n?outOfSpec/n:null,\n};\n}\nfunction controlLimits(ordered){\nconst n=ordered.length;\nif(n<2)return null;\nconst within=withinSigma(ordered);\nif(!within||!(within.sigma>0))return null;\nlet centre=0;\nfor(let i=0;i<n;i++)centre+=ordered[i];\ncentre/=n;\nreturn{\ncentre,\nsigma:within.sigma,\nupper:centre+3*within.sigma,\nlower:centre-3*within.sigma,\n};\n}\nfunction westernElectricViolations(ordered,limits){\nif(!limits||!(limits.sigma>0))return[];\nconst n=ordered.length;\nconst{centre,sigma}=limits;\nconst z=(i)=>(ordered[i]-centre)/sigma;\nconst out=[];\nfor(let i=0;i<n;i++){\nif(Math.abs(z(i))>3){\nout.push({index:i,rule:1,description:'beyond three sigma'});\n}\nif(i>=2){\nfor(const side of[1,-1]){\nlet hits=0;\nfor(let k=i-2;k<=i;k++)if(z(k)*side>2)hits++;\nif(hits>=2){\nout.push({index:i,rule:2,description:'two of three past two sigma'});\nbreak;\n}\n}\n}\nif(i>=4){\nfor(const side of[1,-1]){\nlet hits=0;\nfor(let k=i-4;k<=i;k++)if(z(k)*side>1)hits++;\nif(hits>=4){\nout.push({index:i,rule:3,description:'four of five past one sigma'});\nbreak;\n}\n}\n}\nif(i>=7){\nfor(const side of[1,-1]){\nlet all=true;\nfor(let k=i-7;k<=i;k++)if(z(k)*side<=0){all=false;break;}\nif(all){\nout.push({index:i,rule:4,description:'eight in a row on one side'});\nbreak;\n}\n}\n}\n}\nreturn out;\n}\nfunction nelsonViolations(ordered,limits){\nif(!limits||!(limits.sigma>0))return[];\nconst n=ordered.length;\nconst{centre,sigma}=limits;\nconst z=(i)=>(ordered[i]-centre)/sigma;\nconst oneSide=(from,to,past,need)=>{\nfor(const side of[1,-1]){\nlet hits=0;\nfor(let k=from;k<=to;k++)if(z(k)*side>past)hits++;\nif(hits>=need)return true;\n}\nreturn false;\n};\nconst out=[];\nfor(let i=0;i<n;i++){\nif(Math.abs(z(i))>3)out.push({index:i,rule:1,description:'beyond three sigma'});\nif(i>=8){\nfor(const side of[1,-1]){\nlet all=true;\nfor(let k=i-8;k<=i;k++)if(z(k)*side<=0){all=false;break;}\nif(all){out.push({index:i,rule:2,description:'nine in a row on one side'});break;}\n}\n}\nif(i>=5){\nfor(const dir of[1,-1]){\nlet all=true;\nfor(let k=i-4;k<=i;k++){\nif((ordered[k]-ordered[k-1])*dir<=0){all=false;break;}\n}\nif(all){\nout.push({index:i,rule:3,description:dir>0?'six rising':'six falling'});\nbreak;\n}\n}\n}\nif(i>=13){\nlet alternating=true;\nfor(let k=i-12;k<=i;k++){\nconst a=ordered[k]-ordered[k-1];\nconst b=ordered[k+1<=i?k+1:k]-ordered[k];\nif(k+1>i)break;\nif(a===0||b===0||(a>0)===(b>0)){alternating=false;break;}\n}\nif(alternating)out.push({index:i,rule:4,description:'fourteen alternating'});\n}\nif(i>=2&&oneSide(i-2,i,2,2)){\nout.push({index:i,rule:5,description:'two of three past two sigma'});\n}\nif(i>=4&&oneSide(i-4,i,1,4)){\nout.push({index:i,rule:6,description:'four of five past one sigma'});\n}\nif(i>=14){\nlet inside=true;\nfor(let k=i-14;k<=i;k++)if(Math.abs(z(k))>=1){inside=false;break;}\nif(inside)out.push({index:i,rule:7,description:'fifteen within one sigma'});\n}\nif(i>=7){\nlet outside=true;\nfor(let k=i-7;k<=i;k++)if(Math.abs(z(k))<=1){outside=false;break;}\nif(outside)out.push({index:i,rule:8,description:'eight beyond one sigma'});\n}\n}\nreturn out;\n}\nconst CONTROL_RULE_SETS=Object.freeze(['westernElectric','nelson']);\nfunction controlViolations(ordered,limits,ruleSet='westernElectric'){\nreturn String(ruleSet)==='nelson'\n?nelsonViolations(ordered,limits)\n:westernElectricViolations(ordered,limits);\n}\nfunction countOutside(values,low,high){\nlet count=0;\nfor(let i=0;i<values.length;i++){\nif(values[i]<low||values[i]>high)count++;\n}\nreturn count;\n}\nfunction histogram(sorted,q1,q3,cap=20){\nconst n=sorted.length;\nif(!n)return[];\nconst min=sorted[0];\nconst max=sorted[n-1];\nif(max===min)return[{from:min,to:max,count:n}];\nconst iqr=q3-q1;\nconst fence=1.5*iqr;\nlet lo=iqr>0?Math.max(min,q1-fence):min;\nlet hi=iqr>0?Math.min(max,q3+fence):max;\nif(!(hi>lo)){lo=min;hi=max;}\nconst width=iqr>0?(2*iqr)/Math.cbrt(n):(hi-lo)/(Math.ceil(Math.log2(n))+1);\nconst count=width>0\n?Math.min(cap,Math.max(1,Math.ceil((hi-lo)/width)))\n:1;\nconst step=(hi-lo)/count;\nconst bins=[];\nfor(let i=0;i<count;i++){\nbins.push({from:lo+i*step,to:lo+(i+1)*step,count:0});\n}\nfor(let i=0;i<n;i++){\nconst at=Math.min(count-1,Math.max(0,Math.floor((sorted[i]-lo)/step)));\nbins[at].count++;\n}\nbins[0].from=min;\nbins[count-1].to=max;\nreturn bins;\n}\nconst DEFAULT_CONFIDENCE=0.95;\nfunction level(conf){\nconst c=Number(conf);\nreturn Number.isFinite(c)&&c>0&&c<1?c:DEFAULT_CONFIDENCE;\n}\nfunction meanInterval(values,conf=DEFAULT_CONFIDENCE){\nconst n=values.length;\nif(n<2)return null;\nlet sum=0;\nfor(let i=0;i<n;i++)sum+=values[i];\nconst mean=sum/n;\nlet ss=0;\nfor(let i=0;i<n;i++){const d=values[i]-mean;ss+=d*d;}\nconst sd=Math.sqrt(ss/(n-1));\nconst c=level(conf);\nconst t=studentTQuantile(1-(1-c)/2,n-1);\nconst margin=(t*sd)/Math.sqrt(n);\nreturn{mean,lower:mean-margin,upper:mean+margin,margin,n,confidence:c};\n}\nfunction proportionInterval(successes,n,conf=DEFAULT_CONFIDENCE){\nconst k=Number(successes);\nconst total=Number(n);\nif(!(total>0)||!(k>=0)||k>total)return null;\nconst c=level(conf);\nconst z=normalQuantile(1-(1-c)/2);\nconst p=k/total;\nconst z2=z*z;\nconst denominator=1+z2/total;\nconst centre=(p+z2/(2*total))/denominator;\nconst half=(z/denominator)\n*Math.sqrt((p*(1-p))/total+z2/(4*total*total));\nreturn{\nproportion:p,\nlower:Math.max(0,centre-half),\nupper:Math.min(1,centre+half),\nn:total,\nconfidence:c,\n};\n}\nfunction slopeInterval(fit,conf=DEFAULT_CONFIDENCE){\nif(!fit||!(fit.n>2)||!Number.isFinite(fit.stdError))return null;\nconst c=level(conf);\nconst t=studentTQuantile(1-(1-c)/2,fit.n-2);\nconst margin=t*fit.stdError;\nreturn{\nslope:fit.slope,\nlower:fit.slope-margin,\nupper:fit.slope+margin,\nmargin,\nconfidence:c,\n};\n}\nfunction capabilityInterval(index,n,conf=DEFAULT_CONFIDENCE){\nconst k=Number(index);\nconst count=Number(n);\nif(!Number.isFinite(k)||!(count>1))return null;\nconst c=level(conf);\nconst z=normalQuantile(1-(1-c)/2);\nconst margin=z*Math.sqrt(1/(9*count)+(k*k)/(2*(count-1)));\nreturn{index:k,lower:k-margin,upper:k+margin,margin,n:count,confidence:c};\n}\nfunction standardizedMeanDifference(population,subsetMean){\nif(!population||!(population.sd>0))return null;\nif(!Number.isFinite(subsetMean)||!Number.isFinite(population.mean))return null;\nreturn(subsetMean-population.mean)/population.sd;\n}\nfunction normalTotalVariation(d){\nif(!Number.isFinite(d))return 0;\nreturn Math.min(1,Math.max(0,2*normalCdf(Math.abs(d)/2)-1));\n}\nfunction frequencyMap(handle,indices){\nconst map=new Map();\nconst read=valueReader(handle);\nlet total=0;\nfor(let i=0;i<indices.length;i++){\nconst raw=read(indices[i]);\nif(raw===null||raw===undefined||raw==='')continue;\nif(typeof raw==='number'&&Number.isNaN(raw))continue;\nconst key=raw instanceof Date?raw.getTime()\n:(typeof raw==='object'?String(raw):raw);\nmap.set(key,(map.get(key)||0)+1);\ntotal++;\n}\nreturn{map,total};\n}\nfunction categoricalDistance(subset,subsetTotal,population,populationTotal){\nif(!(subsetTotal>0)||!(populationTotal>0))return null;\nlet sum=0;\nconst keys=new Set(subset.keys());\nfor(const k of population.keys())keys.add(k);\nfor(const k of keys){\nconst a=(subset.get(k)||0)/subsetTotal;\nconst b=(population.get(k)||0)/populationTotal;\nsum+=Math.abs(a-b);\n}\nreturn sum/2;\n}\nconst SUBSET_RELIABILITY_FLOOR=10;\nfunction compareColumn(handle,subsetIndices,populationStats){\nconst numeric=populationStats&&populationStats.numeric;\nif(numeric){\nconst values=numbers(handle,subsetIndices);\nconst{n,mean}=moments(values);\nconst d=n>0\n?standardizedMeanDifference(\n{mean:populationStats.mean,sd:populationStats.sd},mean,\n)\n:null;\nreturn{\nmeasure:'standardizedMeanDifference',\nmagnitude:d,\ndistance:d===null?0:normalTotalVariation(d),\ndirection:d===null?0:Math.sign(d),\nsubsetN:n,\npopulationN:populationStats.n||0,\nreliable:n>=SUBSET_RELIABILITY_FLOOR,\n};\n}\nconst{map,total}=frequencyMap(handle,subsetIndices);\nconst tvd=categoricalDistance(map,total,populationStats.map,populationStats.total);\nreturn{\nmeasure:'categoricalTotalVariation',\nmagnitude:tvd,\ndistance:tvd===null?0:tvd,\ndirection:0,\nsubsetN:total,\npopulationN:populationStats.total||0,\nreliable:total>=SUBSET_RELIABILITY_FLOOR,\n};\n}\nfunction isNumericColumn(handle,indices){\nif(handle&&(handle.kind==='float64'||handle.kind==='int32'))return true;\nconst read=valueReader(handle);\nlet seen=0;\nlet numeric=0;\nfor(let i=0;i<indices.length&&seen<200;i++){\nconst raw=read(indices[i]);\nif(raw===null||raw===undefined||raw==='')continue;\nif(raw instanceof Date)return false;\nseen++;\nconst v=typeof raw==='number'?raw:Number(raw);\nif(Number.isFinite(v))numeric++;\n}\nif(seen===0)return false;\nreturn numeric/seen>=0.9;\n}\nfunction populationRead(handle,populationIndices){\nif(isNumericColumn(handle,populationIndices)){\nconst values=numbers(handle,populationIndices);\nconst{n,mean,m2}=moments(values);\nreturn{numeric:true,mean,sd:n>0?Math.sqrt(m2/n):0,n};\n}\nconst{map,total}=frequencyMap(handle,populationIndices);\nreturn{numeric:false,map,total};\n}\n});\n__def(\"packages/core/src/compute/total.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"TOTAL_FNS\",{enumerable:true,get:function(){return TOTAL_FNS;}});\nObject.defineProperty(__exports,\"TOTAL_LABELS\",{enumerable:true,get:function(){return TOTAL_LABELS;}});\nObject.defineProperty(__exports,\"totalLabel\",{enumerable:true,get:function(){return totalLabel;}});\nObject.defineProperty(__exports,\"aggregatesFor\",{enumerable:true,get:function(){return aggregatesFor;}});\nObject.defineProperty(__exports,\"aggregateAllowed\",{enumerable:true,get:function(){return aggregateAllowed;}});\nObject.defineProperty(__exports,\"collectValues\",{enumerable:true,get:function(){return collectValues;}});\nObject.defineProperty(__exports,\"total\",{enumerable:true,get:function(){return total;}});\nconst __m0=__req(\"packages/core/src/internal/util.js\");\nconst isFunction=__m0[\"isFunction\"];\nconst warnOnce=__m0[\"warnOnce\"];\nconst __m1=__req(\"packages/core/src/compute/handle.js\");\nconst presenceReader=__m1[\"presenceReader\"];\nconst valueComparator=__m1[\"valueComparator\"];\nconst valueReader=__m1[\"valueReader\"];\nconst __m2=__req(\"packages/core/src/compute/statistics.js\");\nconst STAT_FNS=__m2[\"STAT_FNS\"];\nconst STAT_LABELS=__m2[\"STAT_LABELS\"];\nfunction isNumericBacking(handle){\nreturn!!handle&&(handle.kind==='float64'||handle.kind==='int32');\n}\nfunction sum(handle,indices){\nconst n=indices.length;\nlet acc=0;\nif(isNumericBacking(handle)){\nconst values=handle.values;\nconst present=presenceReader(handle);\nif(!present){\nfor(let i=0;i<n;i++){\nconst v=values[indices[i]];\nif(!Number.isNaN(v))acc+=v;\n}\nreturn acc;\n}\nfor(let i=0;i<n;i++){\nconst row=indices[i];\nif(present(row)===1){\nconst v=values[row];\nif(!Number.isNaN(v))acc+=v;\n}\n}\nreturn acc;\n}\nconst read=valueReader(handle);\nfor(let i=0;i<n;i++){\nconst v=numberOf(read(indices[i]));\nif(v!==null)acc+=v;\n}\nreturn acc;\n}\nsum.kernel=true;\nfunction countValues(handle,indices){\nconst n=indices.length;\nlet count=0;\nif(isNumericBacking(handle)){\nconst values=handle.values;\nconst present=presenceReader(handle);\nif(!present){\nfor(let i=0;i<n;i++)if(!Number.isNaN(values[indices[i]]))count++;\nreturn count;\n}\nfor(let i=0;i<n;i++){\nconst row=indices[i];\nif(present(row)===1&&!Number.isNaN(values[row]))count++;\n}\nreturn count;\n}\nconst read=valueReader(handle);\nfor(let i=0;i<n;i++){\nconst v=read(indices[i]);\nif(v!==null&&v!==undefined&&!(typeof v==='number'&&Number.isNaN(v)))count++;\n}\nreturn count;\n}\ncountValues.kernel=true;\nfunction count(handle,indices){\nreturn indices.length;\n}\ncount.kernel=true;\nfunction avg(handle,indices){\nconst values=countValues(handle,indices);\nif(values===0)return null;\nreturn sum(handle,indices)/values;\n}\navg.kernel=true;\nfunction extreme(handle,indices,direction,locale){\nconst n=indices.length;\nif(isNumericBacking(handle)){\nconst values=handle.values;\nconst present=presenceReader(handle);\nlet best=null;\nif(!present){\nfor(let i=0;i<n;i++){\nconst v=values[indices[i]];\nif(Number.isNaN(v))continue;\nif(best===null||(direction<0?v<best:v>best))best=v;\n}\nreturn best;\n}\nfor(let i=0;i<n;i++){\nconst row=indices[i];\nif(present(row)===0)continue;\nconst v=values[row];\nif(Number.isNaN(v))continue;\nif(best===null||(direction<0?v<best:v>best))best=v;\n}\nreturn best;\n}\nconst read=valueReader(handle);\nconst cmp=valueComparator(locale);\nlet best=null;\nfor(let i=0;i<n;i++){\nconst v=read(indices[i]);\nif(v===null||v===undefined||(typeof v==='number'&&Number.isNaN(v)))continue;\nif(best===null||(direction<0?cmp(v,best)<0:cmp(v,best)>0))best=v;\n}\nreturn best;\n}\nfunction min(handle,indices,ctx){\nreturn extreme(handle,indices,-1,ctx&&ctx.locale);\n}\nmin.kernel=true;\nfunction max(handle,indices,ctx){\nreturn extreme(handle,indices,1,ctx&&ctx.locale);\n}\nmax.kernel=true;\nfunction first(handle,indices){\nif(indices.length===0)return null;\nreturn valueReader(handle)(indices[0]);\n}\nfirst.kernel=true;\nfunction last(handle,indices){\nif(indices.length===0)return null;\nreturn valueReader(handle)(indices[indices.length-1]);\n}\nlast.kernel=true;\nfunction numberOf(v){\nif(typeof v==='number')return Number.isNaN(v)?null:v;\nif(v===null||v===undefined||v===''||typeof v==='boolean')return null;\nif(v instanceof Date)return v.getTime();\nconst n=Number(v);\nreturn Number.isNaN(n)?null:n;\n}\nconst TOTAL_FNS={\nsum,min,max,avg,count,first,last,countValues,\n...STAT_FNS,\n};\nconst TOTAL_LABELS=Object.freeze({\n...STAT_LABELS,\nsum:'Sum',\navg:'Average',\nmin:'Min',\nmax:'Max',\ncount:'Count',\ncountValues:'Count of values',\nfirst:'First',\nlast:'Last',\n});\nfunction totalLabel(fn){\nif(!fn)return'';\nif(typeof fn==='string')return TOTAL_LABELS[fn]||fn;\nreturn'Total';\n}\nconst CHOOSER_ORDER=Object.freeze([\n'sum','avg','min','max','count','countValues','first','last',\n]);\nfunction aggregatesFor(column){\nconst supported=column&&column.dataType\n&&column.dataType.totals&&column.dataType.totals.supported;\nif(Array.isArray(supported))return supported.slice();\nconst named=CHOOSER_ORDER.filter((name)=>name in TOTAL_FNS);\nfor(const name of Object.keys(TOTAL_FNS))if(!named.includes(name))named.push(name);\nreturn named;\n}\nfunction aggregateAllowed(column,name){\nif(typeof name!=='string')return true;\nreturn aggregatesFor(column).includes(name);\n}\nfunction collectValues(handle,indices){\nconst read=valueReader(handle);\nconst out=[];\nfor(let i=0;i<indices.length;i++){\nconst v=read(indices[i]);\nif(v===null||v===undefined)continue;\nout.push(v);\n}\nreturn out;\n}\nfunction total(handle,indices,fn,ctx){\nconst list=indices||[];\nif(typeof fn==='string'){\nconst kernel=TOTAL_FNS[fn];\nif(!kernel){\nwarnOnce(`total:${fn}`,`unknown total function \"${fn}\"; register it in config.totalFns`);\nreturn null;\n}\nreturn kernel(handle,list,ctx);\n}\nif(isFunction(fn)){\nif(fn.kernel===true)return fn(handle,list,ctx);\nreturn fn(collectValues(handle,list),ctx||{});\n}\nreturn null;\n}\n});\n__def(\"packages/core/src/compute/pivot.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"KEY_DELIMITER\",{enumerable:true,get:function(){return KEY_DELIMITER;}});\nObject.defineProperty(__exports,\"DEFAULT_PATH_SEPARATOR\",{enumerable:true,get:function(){return DEFAULT_PATH_SEPARATOR;}});\nObject.defineProperty(__exports,\"DEFAULT_MAX_COLUMNS\",{enumerable:true,get:function(){return DEFAULT_MAX_COLUMNS;}});\nObject.defineProperty(__exports,\"pivotKey\",{enumerable:true,get:function(){return pivotKey;}});\nObject.defineProperty(__exports,\"joinPath\",{enumerable:true,get:function(){return joinPath;}});\nObject.defineProperty(__exports,\"resolvePivotKeys\",{enumerable:true,get:function(){return resolvePivotKeys;}});\nObject.defineProperty(__exports,\"pivot\",{enumerable:true,get:function(){return pivot;}});\nconst __m0=__req(\"packages/core/src/internal/util.js\");\nconst warnOnce=__m0[\"warnOnce\"];\nconst __m1=__req(\"packages/core/src/compute/handle.js\");\nconst valueComparator=__m1[\"valueComparator\"];\nconst __m2=__req(\"packages/core/src/compute/group.js\");\nconst packKeys=__m2[\"packKeys\"];\nconst __m3=__req(\"packages/core/src/compute/total.js\");\nconst total=__m3[\"total\"];\nconst KEY_DELIMITER='|';\nconst DEFAULT_PATH_SEPARATOR='/';\nconst DEFAULT_MAX_COLUMNS=2000;\nfunction pivotKey(groupPath,pivotPath,colId){\nreturn`${groupPath}${KEY_DELIMITER}${pivotPath}${KEY_DELIMITER}${colId}`;\n}\nfunction joinPath(parts,separator){\nlet out='';\nfor(let i=0;i<parts.length;i++){\nconst v=parts[i];\nout+=(i===0?'':separator)+(v===null||v===undefined?'':String(v));\n}\nreturn out;\n}\nfunction resolvePivotKeys(handles,order,opts={}){\nconst separator=opts.separator||DEFAULT_PATH_SEPARATOR;\nconst n=order.length;\nconst{keyOf,readers}=packKeys(handles,order,0);\nconst seen=new Map();\nconst tuples=[];\nconst rawKeys=[];\nfor(let i=0;i<n;i++){\nconst row=order[i];\nconst key=keyOf(row);\nif(seen.has(key))continue;\nseen.set(key,tuples.length);\nrawKeys.push(key);\nconst tuple=new Array(readers.length);\nfor(let j=0;j<readers.length;j++)tuple[j]=readers[j](row);\ntuples.push(tuple);\n}\nconst cmp=valueComparator(opts.locale);\nconst rank=tuples.map((_,i)=>i);\nrank.sort((a,b)=>{\nconst ta=tuples[a];\nconst tb=tuples[b];\nfor(let j=0;j<ta.length;j++){\nconst c=compareNullable(ta[j],tb[j],cmp);\nif(c!==0)return c;\n}\nreturn a-b;\n});\nconst keys=new Array(rank.length);\nconst paths=new Array(rank.length);\nconst idByKey=new Map();\nfor(let position=0;position<rank.length;position++){\nconst from=rank[position];\nkeys[position]=tuples[from];\npaths[position]=joinPath(tuples[from],separator);\nidByKey.set(rawKeys[from],position);\n}\nconst idOf=(row)=>{\nconst id=idByKey.get(keyOf(row));\nreturn id===undefined?-1:id;\n};\nreturn{keys,paths,idOf};\n}\nfunction compareNullable(a,b,cmp){\nconst na=a===null||a===undefined;\nconst nb=b===null||b===undefined;\nif(na||nb)return na&&nb?0:na?1:-1;\nreturn cmp(a,b);\n}\nfunction resolveValueColumns(opts){\nconst declared=opts.values||opts.totals||[];\nif(declared.length&&typeof declared[0]==='object'&&declared[0]!==null){\nreturn declared.filter((entry)=>entry&&entry.handle);\n}\nconst resolve=typeof opts.handle==='function'?opts.handle:null;\nif(!resolve){\nif(declared.length){\nwarnOnce('pivot:handles',\n'pivot was given total column ids but no handle(colId) resolver, so no cell values were reduced. Pass values: [{ colId, handle, fn }] or opts.handle.');\n}\nreturn[];\n}\nconst totalOf=typeof opts.totalOf==='function'?opts.totalOf:null;\nconst out=[];\nfor(const colId of declared){\nconst handle=resolve(colId);\nif(!handle)continue;\nout.push({colId,handle,fn:totalOf?totalOf(colId):'sum'});\n}\nreturn out;\n}\nfunction normaliseArgs(a,b,c){\nif(Array.isArray(a)){\nconst opts=c||{};\nreturn{...opts,pivotHandles:a,order:b||null,groups:opts.groups||null};\n}\nreturn a||{};\n}\nfunction pivot(input,orderArg,optsArg){\nconst opts=normaliseArgs(input,orderArg,optsArg);\nconst separator=opts.separator||DEFAULT_PATH_SEPARATOR;\nconst valueColumns=resolveValueColumns(opts);\nconst maxColumns=opts.maxColumns===undefined?DEFAULT_MAX_COLUMNS:opts.maxColumns;\nconst groups=opts.groups&&opts.groups.buckets?opts.groups:null;\nconst buckets=groups?groups.buckets:[opts.order||new Uint32Array(0)];\nconst groupPaths=opts.groupPaths\n||(groups?groups.keys.map((tuple)=>joinPath(tuple,separator)):['']);\nconst scope=concatIndices(buckets);\nconst{keys,paths,idOf}=resolvePivotKeys(opts.pivotHandles||[],scope,opts);\nconst columns=paths.length*Math.max(1,valueColumns.length);\nconst fields=derivedFields(paths,valueColumns,separator);\nif(maxColumns&&columns>maxColumns){\nconst empty=new Map();\nreturn{\nkeys,\npaths,\nfields,\ngroupPaths,\ncolumns,\nvalues:empty,\ncells:empty,\nerror:{\ncode:'pivot-max-columns',\nmessage:`[lattice] pivot would generate ${columns} columns, above pivot.maxColumns of ${maxColumns}. Narrow the pivot columns or raise the limit.`,\ncolumns,\nmaxColumns,\n},\n};\n}\nconst cells=new Map();\nconst keyCount=paths.length;\nfor(let g=0;g<buckets.length;g++){\nconst bucket=buckets[g];\nconst groupPath=groupPaths[g]===undefined?'':groupPaths[g];\nconst n=bucket.length;\nif(n===0)continue;\nconst ids=new Int32Array(n);\nconst counts=new Uint32Array(keyCount+1);\nfor(let i=0;i<n;i++){\nconst id=idOf(bucket[i]);\nids[i]=id;\nif(id>=0)counts[id+1]++;\n}\nfor(let k=0;k<keyCount;k++)counts[k+1]+=counts[k];\nconst scattered=new Uint32Array(n);\nconst cursor=counts.slice(0,keyCount);\nfor(let i=0;i<n;i++){\nconst id=ids[i];\nif(id>=0)scattered[cursor[id]++]=bucket[i];\n}\nfor(let k=0;k<keyCount;k++){\nconst from=counts[k];\nconst to=counts[k+1];\nif(to===from)continue;\nconst slice=scattered.subarray(from,to);\nfor(let c=0;c<valueColumns.length;c++){\nconst column=valueColumns[c];\nconst result=total(column.handle,slice,column.fn,opts.totalContext||{locale:opts.locale});\ncells.set(pivotKey(groupPath,paths[k],column.colId),result);\n}\n}\n}\nreturn{keys,paths,fields,groupPaths,columns,values:cells,cells,error:null};\n}\nfunction derivedFields(paths,valueColumns,separator){\nif(valueColumns.length===0)return paths.slice();\nconst out=[];\nfor(const path of paths){\nfor(const column of valueColumns)out.push(`${path}${separator}${column.colId}`);\n}\nreturn out;\n}\nfunction concatIndices(buckets){\nif(buckets.length===1)return buckets[0]||new Uint32Array(0);\nlet n=0;\nfor(const b of buckets)n+=b?b.length:0;\nconst out=new Uint32Array(n);\nlet at=0;\nfor(const b of buckets){\nif(!b||b.length===0)continue;\nout.set(b,at);\nat+=b.length;\n}\nreturn out;\n}\n});\n__def(\"packages/core/src/compute/pivotmatrix.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"GRAND_PATH\",{enumerable:true,get:function(){return GRAND_PATH;}});\nObject.defineProperty(__exports,\"resolveAxis\",{enumerable:true,get:function(){return resolveAxis;}});\nObject.defineProperty(__exports,\"pivotMatrix\",{enumerable:true,get:function(){return pivotMatrix;}});\nObject.defineProperty(__exports,\"cellKey\",{enumerable:true,get:function(){return cellKey;}});\nObject.defineProperty(__exports,\"marginKey\",{enumerable:true,get:function(){return marginKey;}});\nconst __m0=__req(\"packages/core/src/compute/handle.js\");\nconst valueComparator=__m0[\"valueComparator\"];\nconst __m1=__req(\"packages/core/src/compute/total.js\");\nconst total=__m1[\"total\"];\nconst __m2=__req(\"packages/core/src/compute/group.js\");\nconst packKeys=__m2[\"packKeys\"];\nconst __m3=__req(\"packages/core/src/compute/pivot.js\");\nconst joinPath=__m3[\"joinPath\"];\nconst DEFAULT_PATH_SEPARATOR=__m3[\"DEFAULT_PATH_SEPARATOR\"];\nconst DEFAULT_MAX_COLUMNS=__m3[\"DEFAULT_MAX_COLUMNS\"];\nconst GRAND_PATH='';\nfunction resolveAxis(handles,leaves,opts={}){\nconst separator=opts.separator||DEFAULT_PATH_SEPARATOR;\nconst list=handles||[];\nconst order=leaves instanceof Uint32Array?leaves:Uint32Array.from(leaves||[]);\nconst n=order.length;\nif(list.length===0){\nreturn{tuples:[[]],paths:[GRAND_PATH],buckets:[order]};\n}\nconst{keyOf,readers}=packKeys(list,order,0);\nconst seen=new Map();\nconst tuples=[];\nconst rawKeys=[];\nconst rowsByKey=[];\nfor(let i=0;i<n;i++){\nconst row=order[i];\nconst key=keyOf(row);\nlet at=seen.get(key);\nif(at===undefined){\nat=tuples.length;\nseen.set(key,at);\nrawKeys.push(key);\nconst tuple=new Array(readers.length);\nfor(let j=0;j<readers.length;j++)tuple[j]=readers[j](row);\ntuples.push(tuple);\nrowsByKey.push([]);\n}\nrowsByKey[at].push(row);\n}\nconst cmp=valueComparator(opts.locale);\nconst rank=tuples.map((_,i)=>i);\nrank.sort((a,b)=>{\nconst ta=tuples[a];\nconst tb=tuples[b];\nfor(let j=0;j<ta.length;j++){\nconst c=compareNullable(ta[j],tb[j],cmp);\nif(c!==0)return c;\n}\nreturn a-b;\n});\nconst outTuples=new Array(rank.length);\nconst paths=new Array(rank.length);\nconst buckets=new Array(rank.length);\nfor(let position=0;position<rank.length;position++){\nconst from=rank[position];\noutTuples[position]=tuples[from];\npaths[position]=joinPath(tuples[from],separator);\nbuckets[position]=Uint32Array.from(rowsByKey[from]);\n}\nreturn{tuples:outTuples,paths,buckets};\n}\nfunction compareNullable(a,b,cmp){\nconst na=a===null||a===undefined;\nconst nb=b===null||b===undefined;\nif(na||nb)return na&&nb?0:na?1:-1;\nreturn cmp(a,b);\n}\nfunction intersect(a,b,bSet){\nconst out=[];\nfor(let i=0;i<a.length;i++){\nif(bSet.has(a[i]))out.push(a[i]);\n}\nreturn Uint32Array.from(out);\n}\nfunction reduceCell(handle,leaves,fn,ctx){\nconst value=leaves.length?total(handle,leaves,fn,ctx):null;\nreturn{value,leaves,count:leaves.length};\n}\nfunction pivotMatrix(input){\nconst opts=(input&&input.opts)||{};\nconst separator=opts.separator||DEFAULT_PATH_SEPARATOR;\nconst ctx=opts.totalContext||{locale:opts.locale};\nconst measures=(input.measures||[]).filter((m)=>m&&m.handle);\nconst leaves=input.leaves instanceof Uint32Array\n?input.leaves\n:Uint32Array.from(input.leaves||[]);\nconst rowAxis=resolveAxis(input.rowHandles||[],leaves,{...opts,separator});\nconst columnAxis=resolveAxis(input.columnHandles||[],leaves,{...opts,separator});\nconst maxColumns=opts.maxColumns===undefined?DEFAULT_MAX_COLUMNS:opts.maxColumns;\nconst columns=columnAxis.paths.length*Math.max(1,measures.length);\nconst empty=new Map();\nif(maxColumns&&columns>maxColumns){\nreturn{\nrowAxis,\ncolumnAxis,\nmeasures:measures.map((m)=>({colId:m.colId,fn:m.fn})),\nbody:empty,\nrowMargin:empty,\ncolumnMargin:empty,\ngrand:empty,\ncolumns,\nerror:{\ncode:'pivot-max-columns',\nmessage:`[lattice] pivot would generate ${columns} columns, above pivot.maxColumns of `\n+`${maxColumns}. Narrow the pivot columns or raise the limit.`,\ncolumns,\nmaxColumns,\n},\n};\n}\nconst body=new Map();\nconst rowMargin=new Map();\nconst columnMargin=new Map();\nconst grand=new Map();\nconst columnSets=columnAxis.buckets.map((b)=>new Set(b));\nfor(let c=0;c<columnAxis.paths.length;c++){\nconst columnLeaves=columnAxis.buckets[c];\nconst columnPath=columnAxis.paths[c];\nfor(const m of measures){\ncolumnMargin.set(marginKey(columnPath,m.colId),reduceCell(m.handle,columnLeaves,m.fn,ctx));\n}\n}\nfor(let r=0;r<rowAxis.paths.length;r++){\nconst rowLeaves=rowAxis.buckets[r];\nconst rowPath=rowAxis.paths[r];\nfor(const m of measures){\nrowMargin.set(marginKey(rowPath,m.colId),reduceCell(m.handle,rowLeaves,m.fn,ctx));\n}\nfor(let c=0;c<columnAxis.paths.length;c++){\nconst cellLeaves=intersect(rowLeaves,columnAxis.buckets[c],columnSets[c]);\nif(cellLeaves.length===0)continue;\nconst columnPath=columnAxis.paths[c];\nfor(const m of measures){\nbody.set(cellKey(rowPath,columnPath,m.colId),reduceCell(m.handle,cellLeaves,m.fn,ctx));\n}\n}\n}\nfor(const m of measures){\ngrand.set(m.colId,reduceCell(m.handle,leaves,m.fn,ctx));\n}\nreturn{\nrowAxis,\ncolumnAxis,\nmeasures:measures.map((m)=>({colId:m.colId,fn:m.fn})),\nbody,\nrowMargin,\ncolumnMargin,\ngrand,\ncolumns,\nerror:null,\n};\n}\nfunction cellKey(rowPath,columnPath,colId){\nreturn`${rowPath}\\u0000${columnPath}\\u0000${colId}`;\n}\nfunction marginKey(path,colId){\nreturn`${path}\\u0000${colId}`;\n}\n});\n__def(\"packages/core/src/compute/reference.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"referenceValue\",{enumerable:true,get:function(){return referenceValue;}});\nObject.defineProperty(__exports,\"referenceSort\",{enumerable:true,get:function(){return referenceSort;}});\nObject.defineProperty(__exports,\"referenceFilter\",{enumerable:true,get:function(){return referenceFilter;}});\nObject.defineProperty(__exports,\"referencePasses\",{enumerable:true,get:function(){return referencePasses;}});\nObject.defineProperty(__exports,\"referenceGroup\",{enumerable:true,get:function(){return referenceGroup;}});\nObject.defineProperty(__exports,\"referenceTotal\",{enumerable:true,get:function(){return referenceTotal;}});\nconst __m0=__req(\"packages/core/src/internal/util.js\");\nconst getPath=__m0[\"getPath\"];\nconst __m1=__req(\"packages/core/src/compute/handle.js\");\nconst isMissing=__m1[\"isMissing\"];\nconst valueComparator=__m1[\"valueComparator\"];\nconst __m2=__req(\"packages/core/src/compute/filter.js\");\nconst testValue=__m2[\"testValue\"];\nconst KEY_SEPARATOR=String.fromCharCode(0x1f);\nconst NULL_MARKER=String.fromCharCode(0x00);\nfunction referenceValue(row,col){\nconst v=col.includes('.')?getPath(row,col):(row==null?undefined:row[col]);\nreturn v===undefined?null:v;\n}\nfunction referenceSort(rows,entries,opts={}){\nconst list=entries||[];\nlet order=rows.map((_,i)=>i);\nif(list.length===0)return order;\nfor(let e=list.length-1;e>=0;e--){\norder=referenceSortOne(rows,order,list[e],opts);\n}\nreturn order;\n}\nfunction referenceSortOne(rows,order,entry,opts){\nconst locale=entry.locale!==undefined?entry.locale:opts.locale;\nconst base=valueComparator(locale);\nconst descending=entry.descending!==undefined?!!entry.descending:entry.dir==='desc';\nconst present=[];\nconst absent=[];\nfor(const i of order){\nconst v=referenceValue(rows[i],entry.col);\nif(isMissing(v))absent.push(i);else present.push(i);\n}\nconst position=new Map();\nfor(let p=0;p<present.length;p++)position.set(present[p],p);\nconst compare=(a,b)=>{\nconst va=referenceValue(rows[a],entry.col);\nconst vb=referenceValue(rows[b],entry.col);\nlet c;\nif(typeof entry.compare==='function'){\nc=entry.compare(va,vb,rows[a],rows[b],descending);\nif(descending)c=-c;\n}else{\nc=descending?base(vb,va):base(va,vb);\n}\nreturn c!==0?c:position.get(a)-position.get(b);\n};\npresent.sort(compare);\nreturn entry.nullsFirst?absent.concat(present):present.concat(absent);\n}\nfunction referenceFilter(rows,filters,opts={}){\nconst out=[];\nfor(let i=0;i<rows.length;i++){\nif(referencePasses(rows[i],filters,opts,i))out.push(i);\n}\nreturn out;\n}\nfunction referencePasses(row,node,opts,index){\nif(!node)return true;\nif(Array.isArray(node.conditions)){\nconst children=node.conditions.filter((c)=>c!=null);\nif(children.length===0)return true;\nif(node.op==='or')return children.some((c)=>referencePasses(row,c,opts,index));\nconst all=children.every((c)=>referencePasses(row,c,opts,index));\nreturn node.op==='not'?!all:all;\n}\nif(node.col===undefined&&typeof opts.custom==='function')return!!opts.custom(node,row,index);\nreturn testValue(referenceValue(row,node.col),node,opts.locale);\n}\nfunction referenceGroup(rows,cols,order,project){\nconst source=order||rows.map((_,i)=>i);\nconst seen=new Map();\nconst keys=[];\nconst buckets=[];\nfor(const i of source){\nconst tuple=cols.map((col,j)=>{\nconst v=referenceValue(rows[i],col);\nreturn(project&&project[j])?project[j](v):v;\n});\nconst key=tuple\n.map((v)=>(v===null||v===undefined?NULL_MARKER:String(v)))\n.join(KEY_SEPARATOR);\nlet at=seen.get(key);\nif(at===undefined){\nat=keys.length;\nseen.set(key,at);\nkeys.push(tuple);\nbuckets.push([]);\n}\nbuckets[at].push(i);\n}\nreturn{keys,buckets};\n}\nfunction referenceTotal(values,fn,opts={}){\nconst cmp=valueComparator(opts.locale);\nconst live=values.filter((v)=>!isMissing(v));\nconst numbers=live.map(toNumberOrNull).filter((v)=>v!==null);\nswitch(fn){\ncase'count':return values.length;\ncase'countValues':return live.length;\ncase'sum':return numbers.reduce((a,b)=>a+b,0);\ncase'avg':return live.length===0?null:numbers.reduce((a,b)=>a+b,0)/live.length;\ncase'min':return live.length===0?null:live.reduce((a,b)=>(cmp(b,a)<0?b:a));\ncase'max':return live.length===0?null:live.reduce((a,b)=>(cmp(b,a)>0?b:a));\ncase'first':return values.length===0?null:normaliseNull(values[0]);\ncase'last':return values.length===0?null:normaliseNull(values[values.length-1]);\ndefault:return null;\n}\n}\nfunction toNumberOrNull(v){\nif(typeof v==='number')return Number.isNaN(v)?null:v;\nif(v===null||v===undefined||v===''||typeof v==='boolean')return null;\nif(v instanceof Date)return v.getTime();\nconst n=Number(v);\nreturn Number.isNaN(n)?null:n;\n}\nfunction normaliseNull(v){\nreturn v===undefined?null:v;\n}\n});\n__def(\"packages/core/src/compute/windowed.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"Window\",{enumerable:true,get:function(){return Window;}});\nObject.defineProperty(__exports,\"WINDOW_KINDS\",{enumerable:true,get:function(){return WINDOW_KINDS;}});\nObject.defineProperty(__exports,\"openWindow\",{enumerable:true,get:function(){return openWindow;}});\nObject.defineProperty(__exports,\"default\",{enumerable:true,get:function(){return __default;}});\nconst __m0=__req(\"packages/core/src/compute/sketch.js\");\nconst Welford=__m0[\"Welford\"];\nclass Window{\n#kind;\n#span;\n#ticks=[];\n#now;\n#opened;\nconstructor(kind,span=0,now=Date.now){\nif(kind!=='count'&&kind!=='time'&&kind!=='session'){\nthrow new RangeError(`unknown window kind: ${kind}`);\n}\nif((kind==='count'||kind==='time')&&!(span>0)){\nthrow new RangeError(`a ${kind} window needs a positive span`);\n}\nthis.#kind=kind;\nthis.#span=Math.floor(span);\nthis.#now=now;\nthis.#opened=now();\n}\nget size(){return this.#ticks.length;}\npush(v,t=this.#now()){\nif(!Number.isFinite(v))return;\nthis.#ticks.push({t,v});\nthis.#evict(t);\n}\n#evict(nowT){\nif(this.#kind==='count'){\nwhile(this.#ticks.length>this.#span)this.#ticks.shift();\n}else if(this.#kind==='time'){\nconst cutoff=nowT-this.#span;\nwhile(this.#ticks.length&&this.#ticks[0].t<cutoff)this.#ticks.shift();\n}\n}\nspec(){\nconst span=this.#kind==='session'?this.#now()-this.#opened:this.#span;\nreturn{kind:this.#kind,span,size:this.#ticks.length};\n}\nvalues(){return this.#ticks.map((tk)=>tk.v);}\naggregate(){\nconst spec=this.spec();\nif(!this.#ticks.length){\nreturn{over:spec,count:0,sum:null,mean:null,min:null,max:null,variance:null,stddev:null};\n}\nconst w=new Welford();\nlet sum=0;\nlet min=Infinity;\nlet max=-Infinity;\nfor(const{v}of this.#ticks){\nsum+=v;\nif(v<min)min=v;\nif(v>max)max=v;\nw.add(v);\n}\nreturn{\nover:spec,\ncount:this.#ticks.length,\nsum,\nmean:w.mean(),\nmin,\nmax,\nvariance:w.variance(),\nstddev:w.stddev(),\n};\n}\nreduce(fn){\nconst agg=this.aggregate();\nconst map={\nsum:agg.sum,avg:agg.mean,mean:agg.mean,min:agg.min,max:agg.max,\ncount:agg.count,variance:agg.variance,stddev:agg.stddev,\n};\nif(!(fn in map))throw new RangeError(`unknown windowed aggregate: ${fn}`);\nreturn{value:map[fn],over:agg.over};\n}\n}\nconst WINDOW_KINDS=Object.freeze(['count','time','session']);\nfunction openWindow(opts,now=Date.now){\nconst span=opts.kind==='time'&&opts.minutes!=null\n?opts.minutes*60_000\n:opts.span??0;\nreturn new Window(opts.kind,span,now);\n}\nconst __default={Window,WINDOW_KINDS,openWindow};\n});\n__def(\"packages/core/src/compute/anomaly.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"MAD_SCALE\",{enumerable:true,get:function(){return MAD_SCALE;}});\nObject.defineProperty(__exports,\"DEFAULT_MODIFIED_Z_THRESHOLD\",{enumerable:true,get:function(){return DEFAULT_MODIFIED_Z_THRESHOLD;}});\nObject.defineProperty(__exports,\"DEFAULT_IQR_K\",{enumerable:true,get:function(){return DEFAULT_IQR_K;}});\nObject.defineProperty(__exports,\"DEFAULT_CHI_SQUARE_P\",{enumerable:true,get:function(){return DEFAULT_CHI_SQUARE_P;}});\nObject.defineProperty(__exports,\"ANOMALY_METHODS\",{enumerable:true,get:function(){return ANOMALY_METHODS;}});\nObject.defineProperty(__exports,\"robustSpread\",{enumerable:true,get:function(){return robustSpread;}});\nObject.defineProperty(__exports,\"modifiedZScores\",{enumerable:true,get:function(){return modifiedZScores;}});\nObject.defineProperty(__exports,\"iqrFences\",{enumerable:true,get:function(){return iqrFences;}});\nObject.defineProperty(__exports,\"chiSquareCdf\",{enumerable:true,get:function(){return chiSquareCdf;}});\nObject.defineProperty(__exports,\"chiSquareQuantile\",{enumerable:true,get:function(){return chiSquareQuantile;}});\nObject.defineProperty(__exports,\"mahalanobis\",{enumerable:true,get:function(){return mahalanobis;}});\nObject.defineProperty(__exports,\"DEFAULT_ROLLING_WINDOW\",{enumerable:true,get:function(){return DEFAULT_ROLLING_WINDOW;}});\nObject.defineProperty(__exports,\"ROLLING_ANOMALY_METHODS\",{enumerable:true,get:function(){return ROLLING_ANOMALY_METHODS;}});\nObject.defineProperty(__exports,\"rollingAnomalies\",{enumerable:true,get:function(){return rollingAnomalies;}});\nObject.defineProperty(__exports,\"anomalyCondition\",{enumerable:true,get:function(){return anomalyCondition;}});\nconst __m0=__req(\"packages/core/src/compute/statistics.js\");\nconst quantileSorted=__m0[\"quantileSorted\"];\nconst __m1=__req(\"packages/core/src/compute/special.js\");\nconst logGamma=__m1[\"logGamma\"];\nconst MAD_SCALE=0.6745;\nconst DEFAULT_MODIFIED_Z_THRESHOLD=3.5;\nconst DEFAULT_IQR_K=1.5;\nconst DEFAULT_CHI_SQUARE_P=0.975;\nconst ANOMALY_METHODS=Object.freeze(['modifiedZScore','iqr','mahalanobis']);\nfunction robustSpread(values){\nconst n=values.length;\nif(!n)return null;\nconst sorted=Array.from(values,Number).sort((a,b)=>a-b);\nconst median=quantileSorted(sorted,0.5);\nconst deviations=sorted.map((v)=>Math.abs(v-median)).sort((a,b)=>a-b);\nconst mad=quantileSorted(deviations,0.5);\nreturn{median,mad};\n}\nfunction modifiedZScores(values,opts={}){\nconst threshold=Number.isFinite(opts.threshold)?opts.threshold:DEFAULT_MODIFIED_Z_THRESHOLD;\nconst n=values.length;\nconst scores=new Array(n).fill(null);\nconst flags=new Array(n).fill(false);\nconst finite=[];\nfor(let i=0;i<n;i++){\nconst v=Number(values[i]);\nif(Number.isFinite(v))finite.push(v);\n}\nif(!finite.length)return{median:null,mad:null,threshold,scores,flags,flagged:0};\nconst spread=robustSpread(finite);\nif(spread.mad===0)return{median:spread.median,mad:0,threshold,scores,flags,flagged:0};\nlet flagged=0;\nfor(let i=0;i<n;i++){\nconst v=Number(values[i]);\nif(!Number.isFinite(v))continue;\nconst score=(MAD_SCALE*(v-spread.median))/spread.mad;\nscores[i]=score;\nif(Math.abs(score)>threshold){flags[i]=true;flagged++;}\n}\nreturn{median:spread.median,mad:spread.mad,threshold,scores,flags,flagged};\n}\nfunction iqrFences(values,opts={}){\nconst k=Number.isFinite(opts.k)?opts.k:DEFAULT_IQR_K;\nconst finite=[];\nfor(let i=0;i<values.length;i++){\nconst v=Number(values[i]);\nif(Number.isFinite(v))finite.push(v);\n}\nif(!finite.length)return null;\nconst sorted=finite.sort((a,b)=>a-b);\nconst q1=quantileSorted(sorted,0.25);\nconst q3=quantileSorted(sorted,0.75);\nconst iqr=q3-q1;\nreturn{q1,q3,iqr,lower:q1-k*iqr,upper:q3+k*iqr,k};\n}\nfunction regularizedGammaP(a,x){\nif(x<=0)return 0;\nconst gln=logGamma(a);\nif(x<a+1){\nlet ap=a;\nlet sum=1/a;\nlet term=sum;\nfor(let i=0;i<1000;i++){\nap+=1;\nterm*=x/ap;\nsum+=term;\nif(Math.abs(term)<Math.abs(sum)*1e-15)break;\n}\nreturn sum*Math.exp(-x+a*Math.log(x)-gln);\n}\nconst tiny=1e-300;\nlet b=x+1-a;\nlet c=1/tiny;\nlet d=1/b;\nlet h=d;\nfor(let i=1;i<1000;i++){\nconst an=-i*(i-a);\nb+=2;\nd=an*d+b;\nif(Math.abs(d)<tiny)d=tiny;\nc=b+an/c;\nif(Math.abs(c)<tiny)c=tiny;\nd=1/d;\nconst delta=d*c;\nh*=delta;\nif(Math.abs(delta-1)<1e-15)break;\n}\nconst q=Math.exp(-x+a*Math.log(x)-gln)*h;\nreturn 1-q;\n}\nfunction chiSquareCdf(x,df){\nif(x<=0)return 0;\nreturn regularizedGammaP(df/2,x/2);\n}\nfunction chiSquareQuantile(df,p=DEFAULT_CHI_SQUARE_P){\nif(!(p>0)||!(p<1))return NaN;\nlet lo=0;\nlet hi=Math.max(1,df);\nwhile(chiSquareCdf(hi,df)<p)hi*=2;\nfor(let i=0;i<200;i++){\nconst mid=(lo+hi)/2;\nif(chiSquareCdf(mid,df)<p)lo=mid;else hi=mid;\nif(hi-lo<1e-10)break;\n}\nreturn(lo+hi)/2;\n}\nfunction invertMatrix(matrix){\nconst k=matrix.length;\nconst a=matrix.map((row,i)=>{\nconst copy=row.slice();\nfor(let j=0;j<k;j++)copy.push(i===j?1:0);\nreturn copy;\n});\nfor(let col=0;col<k;col++){\nlet pivot=col;\nfor(let r=col+1;r<k;r++){\nif(Math.abs(a[r][col])>Math.abs(a[pivot][col]))pivot=r;\n}\nif(Math.abs(a[pivot][col])<1e-12)return null;\nif(pivot!==col){const t=a[pivot];a[pivot]=a[col];a[col]=t;}\nconst div=a[col][col];\nfor(let j=0;j<2*k;j++)a[col][j]/=div;\nfor(let r=0;r<k;r++){\nif(r===col)continue;\nconst factor=a[r][col];\nif(factor===0)continue;\nfor(let j=0;j<2*k;j++)a[r][j]-=factor*a[col][j];\n}\n}\nreturn a.map((row)=>row.slice(k));\n}\nfunction meanAndCovariance(rows,k){\nconst n=rows.length;\nconst mean=new Array(k).fill(0);\nfor(const row of rows)for(let j=0;j<k;j++)mean[j]+=row[j];\nfor(let j=0;j<k;j++)mean[j]/=n;\nconst cov=Array.from({length:k},()=>new Array(k).fill(0));\nfor(const row of rows){\nfor(let a=0;a<k;a++){\nconst da=row[a]-mean[a];\nfor(let b=a;b<k;b++){\ncov[a][b]+=da*(row[b]-mean[b]);\n}\n}\n}\nconst denom=n>1?n-1:1;\nfor(let a=0;a<k;a++){\nfor(let b=a;b<k;b++){\ncov[a][b]/=denom;\ncov[b][a]=cov[a][b];\n}\n}\nreturn{mean,cov};\n}\nfunction mahalanobis(matrix,opts={}){\nconst p=Number.isFinite(opts.p)?opts.p:DEFAULT_CHI_SQUARE_P;\nconst ridgeFraction=Number.isFinite(opts.ridge)?opts.ridge:1e-6;\nconst n=matrix.length;\nif(!n)return null;\nconst k=matrix[0].length;\nif(!k)return null;\nconst distances=new Array(n).fill(null);\nconst squared=new Array(n).fill(null);\nconst flags=new Array(n).fill(false);\nconst completeIndex=[];\nconst complete=[];\nfor(let i=0;i<n;i++){\nconst row=matrix[i];\nlet ok=row.length===k;\nconst coords=new Array(k);\nfor(let j=0;ok&&j<k;j++){\nconst v=Number(row[j]);\nif(!Number.isFinite(v))ok=false;else coords[j]=v;\n}\nif(ok){completeIndex.push(i);complete.push(coords);}\n}\nconst df=k;\nconst cutoff=chiSquareQuantile(df,p);\nif(complete.length<=k){\nreturn{center:[],df,cutoff,singular:true,used:complete.length,distances,squared,flags,flagged:0};\n}\nconst{mean,cov}=meanAndCovariance(complete,k);\nlet inverse=invertMatrix(cov);\nlet singular=false;\nif(!inverse){\nsingular=true;\nlet trace=0;\nfor(let j=0;j<k;j++)trace+=cov[j][j];\nconst ridge=(trace/k)*ridgeFraction||ridgeFraction;\nconst nudged=cov.map((row,i)=>row.map((v,j)=>(i===j?v+ridge:v)));\ninverse=invertMatrix(nudged);\nif(!inverse){\nreturn{center:mean,df,cutoff,singular:true,used:complete.length,distances,squared,flags,flagged:0};\n}\n}\nlet flagged=0;\nfor(let c=0;c<complete.length;c++){\nconst row=complete[c];\nconst dev=new Array(k);\nfor(let j=0;j<k;j++)dev[j]=row[j]-mean[j];\nlet d2=0;\nfor(let a=0;a<k;a++){\nlet sa=0;\nfor(let b=0;b<k;b++)sa+=inverse[a][b]*dev[b];\nd2+=dev[a]*sa;\n}\nif(d2<0)d2=0;\nconst at=completeIndex[c];\nsquared[at]=d2;\ndistances[at]=Math.sqrt(d2);\nif(d2>cutoff){flags[at]=true;flagged++;}\n}\nreturn{\ncenter:mean,df,cutoff,singular,used:complete.length,distances,squared,flags,flagged,\n};\n}\nconst DEFAULT_ROLLING_WINDOW=20;\nconst ROLLING_ANOMALY_METHODS=Object.freeze(['rollingModifiedZScore','rollingIqr']);\nfunction rollingAnomalies(values,opts={}){\nconst method=opts.method==='rollingIqr'?'rollingIqr':'rollingModifiedZScore';\nconst windowLen=Number.isFinite(opts.windowLen)&&opts.windowLen>=1\n?Math.floor(opts.windowLen):DEFAULT_ROLLING_WINDOW;\nconst threshold=Number.isFinite(opts.threshold)?opts.threshold:DEFAULT_MODIFIED_Z_THRESHOLD;\nconst k=Number.isFinite(opts.k)?opts.k:DEFAULT_IQR_K;\nconst minPeriods=Number.isFinite(opts.minPeriods)&&opts.minPeriods>=1\n?Math.floor(opts.minPeriods):windowLen;\nconst n=values.length;\nconst scores=new Array(n).fill(null);\nconst flags=new Array(n).fill(false);\nlet flagged=0;\nfor(let i=0;i<n;i++){\nconst v=Number(values[i]);\nif(!Number.isFinite(v))continue;\nconst start=Math.max(0,i-windowLen+1);\nconst win=[];\nfor(let j=start;j<=i;j++){\nconst w=Number(values[j]);\nif(Number.isFinite(w))win.push(w);\n}\nif(win.length<minPeriods)continue;\nif(method==='rollingIqr'){\nconst fences=iqrFences(win,{k});\nif(!fences)continue;\nif(v<fences.lower||v>fences.upper){flags[i]=true;flagged++;}\n}else{\nconst spread=robustSpread(win);\nif(!spread||spread.mad===0)continue;\nconst score=(MAD_SCALE*(v-spread.median))/spread.mad;\nscores[i]=score;\nif(Math.abs(score)>threshold){flags[i]=true;flagged++;}\n}\n}\nreturn{method,windowLen,minPeriods,threshold,k,scores,flags,flagged};\n}\nfunction anomalyCondition(opts={}){\nconst spec=opts||{};\nconst field=spec.field;\nif(typeof field!=='string'||!field){\nthrow new TypeError('[lattice] anomalyCondition: a string `field` naming the numeric property to monitor is required');\n}\nconst method=spec.method||'modifiedZScore';\nconst known=ANOMALY_METHODS.includes(method)||ROLLING_ANOMALY_METHODS.includes(method);\nif(!known||method==='mahalanobis'){\nthrow new RangeError(`[lattice] anomalyCondition: unknown or unsupported method '${method}'`);\n}\nconst orderBy=typeof spec.orderBy==='string'?spec.orderBy:null;\nconst latest=spec.latest===true;\nconst isRolling=ROLLING_ANOMALY_METHODS.includes(method);\nconst read=(row)=>Number(row==null?NaN:row[field]);\nreturn(rows)=>{\nconst list=Array.isArray(rows)?rows.slice():[...rows];\nif(orderBy){\nlist.sort((a,b)=>{\nconst av=a==null?undefined:a[orderBy];\nconst bv=b==null?undefined:b[orderBy];\nif(av===bv)return 0;\nif(av===undefined||av===null)return-1;\nif(bv===undefined||bv===null)return 1;\nreturn av<bv?-1:1;\n});\n}\nconst values=list.map(read);\nlet flags;\nlet scores;\nif(isRolling){\nconst r=rollingAnomalies(values,{\nmethod,windowLen:spec.windowLen,threshold:spec.threshold,k:spec.k,minPeriods:spec.minPeriods,\n});\n({flags,scores}=r);\n}else if(method==='iqr'){\nconst fences=iqrFences(values,{k:spec.k});\nflags=values.map((v)=>(fences?Number.isFinite(v)&&(v<fences.lower||v>fences.upper):false));\nscores=values.map(()=>null);\n}else{\nconst z=modifiedZScores(values,{threshold:spec.threshold});\n({flags,scores}=z);\n}\nif(latest){\nconst i=flags.length-1;\nif(i<0||!flags[i])return false;\nreturn{method,field,flagged:[{row:list[i],score:scores[i]}]};\n}\nconst flaggedRows=[];\nfor(let i=0;i<flags.length;i++){\nif(flags[i])flaggedRows.push({row:list[i],score:scores[i]});\n}\nreturn flaggedRows.length?{method,field,flagged:flaggedRows}:false;\n};\n}\n});\n__def(\"packages/core/src/compute/forecast.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"FORECAST_METHODS\",{enumerable:true,get:function(){return FORECAST_METHODS;}});\nObject.defineProperty(__exports,\"forecast\",{enumerable:true,get:function(){return forecast;}});\nObject.defineProperty(__exports,\"default\",{enumerable:true,get:function(){return __default;}});\nconst __m0=__req(\"packages/core/src/compute/special.js\");\nconst normalQuantile=__m0[\"normalQuantile\"];\nconst studentTQuantile=__m0[\"studentTQuantile\"];\nconst __m1=__req(\"packages/core/src/internal/util.js\");\nconst warnOnce=__m1[\"warnOnce\"];\nconst FORECAST_METHODS=Object.freeze([\n'movingAverage','ses','holt','holtWinters','linear',\n]);\nconst SMOOTH_LO=1e-4;\nconst SMOOTH_HI=1-1e-4;\nfunction normalise(seq){\nconst rows=[];\nfor(let i=0;i<seq.length;i++){\nconst el=seq[i];\nif(el!==null&&typeof el==='object'){\nconst at=Number.isFinite(el.at)?el.at:i;\nconst value=Number.isFinite(el.value)?el.value:null;\nrows.push({at,value});\n}else{\nrows.push({at:i,value:Number.isFinite(el)?Number(el):null});\n}\n}\nreturn rows;\n}\nfunction axis(rows){\nconst finite=rows.filter((r)=>r.value!==null);\nconst first=finite[0];\nconst last=finite[finite.length-1];\nconst span=last.at-first.at;\nconst step=finite.length>1&&span>0?span/(finite.length-1):1;\nreturn{lastAt:last.at,step};\n}\nfunction clamp(x){return Math.min(SMOOTH_HI,Math.max(SMOOTH_LO,x));}\nfunction goldenMin(f,lo=SMOOTH_LO,hi=SMOOTH_HI,iters=80){\nconst invphi=(Math.sqrt(5)-1)/2;\nlet a=lo;\nlet b=hi;\nlet c=b-invphi*(b-a);\nlet d=a+invphi*(b-a);\nlet fc=f(c);\nlet fd=f(d);\nfor(let i=0;i<iters;i++){\nif(fc<fd){b=d;d=c;fd=fc;c=b-invphi*(b-a);fc=f(c);}\nelse{a=c;c=d;fc=fd;d=a+invphi*(b-a);fd=f(d);}\n}\nreturn(a+b)/2;\n}\nfunction runSes(y,alpha){\nlet level=null;\nlet sse=0;\nlet m=0;\nfor(let i=0;i<y.length;i++){\nconst v=y[i];\nif(v===null)continue;\nif(level===null){level=v;continue;}\nsse+=(v-level)**2;\nm+=1;\nlevel=alpha*v+(1-alpha)*level;\n}\nreturn{level,sse,m};\n}\nfunction runHolt(y,alpha,beta){\nlet level=null;\nlet trend=null;\nlet sse=0;\nlet m=0;\nfor(let i=0;i<y.length;i++){\nconst v=y[i];\nif(v===null){if(level!==null&&trend!==null)level+=trend;continue;}\nif(level===null){level=v;continue;}\nif(trend===null){trend=v-level;}\nconst forecast=level+trend;\nsse+=(v-forecast)**2;\nm+=1;\nconst prev=level;\nlevel=alpha*v+(1-alpha)*(prev+trend);\ntrend=beta*(level-prev)+(1-beta)*trend;\n}\nreturn{level,trend,sse,m};\n}\nfunction runHoltWinters(y,m,alpha,beta,gamma){\nconst n=y.length;\nif(n<2*m)return null;\nconst seasonMean=(from)=>{\nlet s=0;\nlet c=0;\nfor(let i=from;i<from+m&&i<n;i++)if(y[i]!==null){s+=y[i];c+=1;}\nreturn c?s/c:null;\n};\nconst m0=seasonMean(0);\nconst m1=seasonMean(m);\nif(m0===null||m1===null)return null;\nlet level=m0;\nlet trend=(m1-m0)/m;\nconst season=new Array(m).fill(0);\nfor(let i=0;i<m;i++)season[i]=(y[i]===null?0:y[i]-level);\nconst bias=season.reduce((a,b)=>a+b,0)/m;\nfor(let i=0;i<m;i++)season[i]-=bias;\nlet sse=0;\nlet count=0;\nfor(let t=m;t<n;t++){\nconst phase=t%m;\nconst s=season[phase];\nconst v=y[t];\nif(v===null){level+=trend;continue;}\nconst forecast=level+trend+s;\nsse+=(v-forecast)**2;\ncount+=1;\nconst prevLevel=level;\nlevel=alpha*(v-s)+(1-alpha)*(level+trend);\ntrend=beta*(level-prevLevel)+(1-beta)*trend;\nseason[phase]=gamma*(v-level)+(1-gamma)*s;\n}\nreturn{level,trend,season,phase:(n-1)%m,sse,count};\n}\nfunction esBand(sigma2,c,z){\nlet acc=1;\nfor(const cj of c)acc+=cj*cj;\nconst se=Math.sqrt(sigma2*acc);\nreturn{se,margin:z*se};\n}\nfunction forecast(seq,opts={}){\nif(!seq||typeof seq.length!=='number'||seq.length===0)return null;\nconst method=FORECAST_METHODS.includes(opts.method)?opts.method:'linear';\nconst horizon=Math.max(1,Math.floor(Number(opts.horizon)||1));\nconst conf=Number.isFinite(opts.confidence)&&opts.confidence>0&&opts.confidence<1\n?opts.confidence:0.95;\nconst tail=1-(1-conf)/2;\nconst rows=normalise(seq);\nconst y=rows.map((r)=>r.value);\nconst finite=y.filter((v)=>v!==null);\nconst n=finite.length;\nconst{lastAt,step}=n?axis(rows):{lastAt:0,step:1};\nconst atOf=(h)=>lastAt+h*step;\nif(method==='linear')return forecastLinear(rows,n,horizon,conf,tail,atOf);\nif(method==='movingAverage')return forecastMovingAverage(finite,n,horizon,conf,tail,opts,atOf);\nif(method==='ses')return forecastSes(y,n,horizon,conf,tail,opts,atOf);\nif(method==='holt')return forecastHolt(y,n,horizon,conf,tail,opts,atOf);\nreturn forecastHoltWinters(y,n,horizon,conf,tail,opts,atOf);\n}\nfunction forecastLinear(rows,n,horizon,conf,tail,atOf){\nif(n<2)return null;\nlet mx=0;\nlet my=0;\nfor(const r of rows)if(r.value!==null){mx+=r.at;my+=r.value;}\nmx/=n;\nmy/=n;\nlet sxx=0;\nlet sxy=0;\nlet syy=0;\nfor(const r of rows){\nif(r.value===null)continue;\nconst dx=r.at-mx;\nconst dy=r.value-my;\nsxx+=dx*dx;\nsxy+=dx*dy;\nsyy+=dy*dy;\n}\nif(sxx===0)return null;\nconst slope=sxy/sxx;\nconst intercept=my-slope*mx;\nconst r2=syy===0?1:Math.max(0,Math.min(1,(sxy*sxy)/(sxx*syy)));\nconst sse=Math.max(0,syy-slope*sxy);\nconst s=n>2?Math.sqrt(sse/(n-2)):null;\nconst t=n>2?studentTQuantile(tail,n-2):null;\nconst points=[];\nfor(let h=1;h<=horizon;h++){\nconst x0=atOf(h);\nconst mean=intercept+slope*x0;\nlet lower=null;\nlet upper=null;\nlet lowerMean=null;\nlet upperMean=null;\nlet se=null;\nif(s!==null){\nconst leverage=1/n+((x0-mx)**2)/sxx;\nconst sePred=s*Math.sqrt(1+leverage);\nconst seMean=s*Math.sqrt(leverage);\nse=sePred;\nlower=mean-t*sePred;\nupper=mean+t*sePred;\nlowerMean=mean-t*seMean;\nupperMean=mean+t*seMean;\n}\npoints.push({step:h,at:x0,mean,lower,upper,lowerMean,upperMean,se});\n}\nreturn{\nmethod:'linear',horizon,confidence:conf,n,sigma:s,r2,\nparams:{slope,intercept},points,\n};\n}\nfunction forecastMovingAverage(finite,n,horizon,conf,tail,opts,atOf){\nif(n<1)return null;\nconst k=Math.max(1,Math.min(n,Math.floor(Number(opts.windowLen)||n)));\nconst recent=finite.slice(n-k);\nlet sum=0;\nfor(const v of recent)sum+=v;\nconst mean=sum/k;\nlet se=null;\nlet t=null;\nif(k>1){\nlet ss=0;\nfor(const v of recent)ss+=(v-mean)**2;\nconst s=Math.sqrt(ss/(k-1));\nse=s*Math.sqrt(1+1/k);\nt=studentTQuantile(tail,k-1);\n}\nconst margin=se===null?null:t*se;\nconst points=[];\nfor(let h=1;h<=horizon;h++){\npoints.push({\nstep:h,at:atOf(h),mean,\nlower:margin===null?null:mean-margin,\nupper:margin===null?null:mean+margin,\nse,\n});\n}\nreturn{\nmethod:'movingAverage',horizon,confidence:conf,n,\nsigma:se===null?null:se,params:{windowLen:k},points,\n};\n}\nfunction forecastSes(y,n,horizon,conf,tail,opts,atOf){\nif(n<1)return null;\nlet alpha=Number.isFinite(opts.alpha)?clamp(opts.alpha):null;\nif(alpha===null)alpha=goldenMin((x)=>runSes(y,x).sse);\nconst run=runSes(y,alpha);\nconst z=normalQuantile(tail);\nconst sigma2=run.m>0?run.sse/run.m:null;\nconst points=[];\nfor(let h=1;h<=horizon;h++){\nconst mean=run.level;\nlet lower=null;\nlet upper=null;\nlet se=null;\nif(sigma2!==null){\nconst c=[];\nfor(let j=1;j<h;j++)c.push(alpha);\nconst band=esBand(sigma2,c,z);\nse=band.se;\nlower=mean-band.margin;\nupper=mean+band.margin;\n}\npoints.push({step:h,at:atOf(h),mean,lower,upper,se});\n}\nreturn{\nmethod:'ses',horizon,confidence:conf,n,\nsigma:sigma2===null?null:Math.sqrt(sigma2),params:{alpha},points,\n};\n}\nfunction forecastHolt(y,n,horizon,conf,tail,opts,atOf){\nif(n<2)return null;\nlet alpha=Number.isFinite(opts.alpha)?clamp(opts.alpha):null;\nlet beta=Number.isFinite(opts.beta)?clamp(opts.beta):null;\nif(alpha===null||beta===null){\nlet a=alpha===null?0.5:alpha;\nlet b=beta===null?0.5:beta;\nfor(let round=0;round<6;round++){\nif(alpha===null)a=goldenMin((x)=>runHolt(y,x,b).sse);\nif(beta===null)b=goldenMin((x)=>runHolt(y,a,x).sse);\n}\nalpha=alpha===null?a:alpha;\nbeta=beta===null?b:beta;\n}\nconst run=runHolt(y,alpha,beta);\nconst z=normalQuantile(tail);\nconst sigma2=run.m>0?run.sse/run.m:null;\nconst phi=alpha*beta;\nconst points=[];\nfor(let h=1;h<=horizon;h++){\nconst mean=run.level+h*run.trend;\nlet lower=null;\nlet upper=null;\nlet se=null;\nif(sigma2!==null){\nconst c=[];\nfor(let j=1;j<h;j++)c.push(alpha+j*phi);\nconst band=esBand(sigma2,c,z);\nse=band.se;\nlower=mean-band.margin;\nupper=mean+band.margin;\n}\npoints.push({step:h,at:atOf(h),mean,lower,upper,se});\n}\nreturn{\nmethod:'holt',horizon,confidence:conf,n,\nsigma:sigma2===null?null:Math.sqrt(sigma2),params:{alpha,beta},points,\n};\n}\nfunction forecastHoltWinters(y,n,horizon,conf,tail,opts,atOf){\nconst m=Math.floor(Number(opts.period));\nif(!(m>=2)){\nwarnOnce('forecast.holtWinters.period','forecast: holtWinters needs a period (opts.period >= 2)');\nreturn null;\n}\nif(n<2*m)return null;\nlet alpha=Number.isFinite(opts.alpha)?clamp(opts.alpha):null;\nlet beta=Number.isFinite(opts.beta)?clamp(opts.beta):null;\nlet gamma=Number.isFinite(opts.gamma)?clamp(opts.gamma):null;\nconst sseAt=(a,b,g)=>{\nconst r=runHoltWinters(y,m,a,b,g);\nreturn r?r.sse:Infinity;\n};\nif(alpha===null||beta===null||gamma===null){\nlet a=alpha===null?0.5:alpha;\nlet b=beta===null?0.5:beta;\nlet g=gamma===null?0.5:gamma;\nfor(let round=0;round<8;round++){\nif(alpha===null)a=goldenMin((x)=>sseAt(x,b,g));\nif(beta===null)b=goldenMin((x)=>sseAt(a,x,g));\nif(gamma===null)g=goldenMin((x)=>sseAt(a,b,x));\n}\nalpha=alpha===null?a:alpha;\nbeta=beta===null?b:beta;\ngamma=gamma===null?g:gamma;\n}\nconst run=runHoltWinters(y,m,alpha,beta,gamma);\nif(!run)return null;\nconst z=normalQuantile(tail);\nconst sigma2=run.count>0?run.sse/run.count:null;\nconst phi=alpha*beta;\nconst gs=gamma*(1-alpha);\nconst points=[];\nfor(let h=1;h<=horizon;h++){\nconst s=run.season[(run.phase+h)%m];\nconst mean=run.level+h*run.trend+s;\nlet lower=null;\nlet upper=null;\nlet se=null;\nif(sigma2!==null){\nconst c=[];\nfor(let j=1;j<h;j++)c.push(alpha+j*phi+(j%m===0?gs:0));\nconst band=esBand(sigma2,c,z);\nse=band.se;\nlower=mean-band.margin;\nupper=mean+band.margin;\n}\npoints.push({step:h,at:atOf(h),mean,lower,upper,se});\n}\nreturn{\nmethod:'holtWinters',horizon,confidence:conf,n,\nsigma:sigma2===null?null:Math.sqrt(sigma2),\nparams:{alpha,beta,gamma,period:m},points,\n};\n}\nconst __default={FORECAST_METHODS,forecast};\n});\n__def(\"packages/core/src/compute/index.js\",function(__exports,__req){\n'use strict';\nconst __m0=__req(\"packages/core/src/compute/sort.js\");\nObject.defineProperty(__exports,\"sortColumn\",{enumerable:true,get:function(){return __m0[\"sortColumn\"];}});\nObject.defineProperty(__exports,\"sortMulti\",{enumerable:true,get:function(){return __m0[\"sortMulti\"];}});\nObject.defineProperty(__exports,\"radixSortFloat64\",{enumerable:true,get:function(){return __m0[\"radixSortFloat64\"];}});\nObject.defineProperty(__exports,\"radixSortInt32\",{enumerable:true,get:function(){return __m0[\"radixSortInt32\"];}});\nObject.defineProperty(__exports,\"rankSortDictionary\",{enumerable:true,get:function(){return __m0[\"rankSortDictionary\"];}});\nObject.defineProperty(__exports,\"mergeSortComparator\",{enumerable:true,get:function(){return __m0[\"mergeSortComparator\"];}});\nObject.defineProperty(__exports,\"collateStringRanks\",{enumerable:true,get:function(){return __m0[\"collateStringRanks\"];}});\nObject.defineProperty(__exports,\"rankSortStrings\",{enumerable:true,get:function(){return __m0[\"rankSortStrings\"];}});\nconst __m1=__req(\"packages/core/src/compute/sortspec.js\");\nObject.defineProperty(__exports,\"collationDescriptor\",{enumerable:true,get:function(){return __m1[\"collationDescriptor\"];}});\nObject.defineProperty(__exports,\"isPortableSort\",{enumerable:true,get:function(){return __m1[\"isPortableSort\"];}});\nObject.defineProperty(__exports,\"isPortableSortSet\",{enumerable:true,get:function(){return __m1[\"isPortableSortSet\"];}});\nObject.defineProperty(__exports,\"describeSortEntry\",{enumerable:true,get:function(){return __m1[\"describeSortEntry\"];}});\nObject.defineProperty(__exports,\"describeSort\",{enumerable:true,get:function(){return __m1[\"describeSort\"];}});\nconst __m2=__req(\"packages/core/src/compute/filter.js\");\nObject.defineProperty(__exports,\"evaluateFilters\",{enumerable:true,get:function(){return __m2[\"evaluateFilters\"];}});\nObject.defineProperty(__exports,\"evaluateCondition\",{enumerable:true,get:function(){return __m2[\"evaluateCondition\"];}});\nObject.defineProperty(__exports,\"compact\",{enumerable:true,get:function(){return __m2[\"compact\"];}});\nObject.defineProperty(__exports,\"testValue\",{enumerable:true,get:function(){return __m2[\"testValue\"];}});\nObject.defineProperty(__exports,\"compilePredicate\",{enumerable:true,get:function(){return __m2[\"compilePredicate\"];}});\nObject.defineProperty(__exports,\"releaseMask\",{enumerable:true,get:function(){return __m2[\"releaseMask\"];}});\nObject.defineProperty(__exports,\"pruneColumn\",{enumerable:true,get:function(){return __m2[\"pruneColumn\"];}});\nObject.defineProperty(__exports,\"mentionsColumn\",{enumerable:true,get:function(){return __m2[\"mentionsColumn\"];}});\nconst __m3=__req(\"packages/core/src/compute/group.js\");\nObject.defineProperty(__exports,\"groupByColumns\",{enumerable:true,get:function(){return __m3[\"groupByColumns\"];}});\nObject.defineProperty(__exports,\"packKeys\",{enumerable:true,get:function(){return __m3[\"packKeys\"];}});\nconst __m4=__req(\"packages/core/src/compute/facet.js\");\nObject.defineProperty(__exports,\"facet\",{enumerable:true,get:function(){return __m4[\"facet\"];}});\nObject.defineProperty(__exports,\"computeBounds\",{enumerable:true,get:function(){return __m4[\"computeBounds\"];}});\nObject.defineProperty(__exports,\"countInto\",{enumerable:true,get:function(){return __m4[\"countInto\"];}});\nObject.defineProperty(__exports,\"bucketOf\",{enumerable:true,get:function(){return __m4[\"bucketOf\"];}});\nObject.defineProperty(__exports,\"facetKind\",{enumerable:true,get:function(){return __m4[\"facetKind\"];}});\nObject.defineProperty(__exports,\"cardinalityOf\",{enumerable:true,get:function(){return __m4[\"cardinalityOf\"];}});\nObject.defineProperty(__exports,\"pickGranularity\",{enumerable:true,get:function(){return __m4[\"pickGranularity\"];}});\nObject.defineProperty(__exports,\"floorTo\",{enumerable:true,get:function(){return __m4[\"floorTo\"];}});\nObject.defineProperty(__exports,\"advance\",{enumerable:true,get:function(){return __m4[\"advance\"];}});\nObject.defineProperty(__exports,\"STRATEGIES\",{enumerable:true,get:function(){return __m4[\"STRATEGIES\"];}});\nObject.defineProperty(__exports,\"GRANULARITIES\",{enumerable:true,get:function(){return __m4[\"GRANULARITIES\"];}});\nObject.defineProperty(__exports,\"DEFAULT_BUCKETS\",{enumerable:true,get:function(){return __m4[\"DEFAULT_BUCKETS\"];}});\nObject.defineProperty(__exports,\"DEFAULT_CARDINALITY_LIMIT\",{enumerable:true,get:function(){return __m4[\"DEFAULT_CARDINALITY_LIMIT\"];}});\nObject.defineProperty(__exports,\"QUANTILE_SAMPLE\",{enumerable:true,get:function(){return __m4[\"QUANTILE_SAMPLE\"];}});\nconst __m5=__req(\"packages/core/src/compute/total.js\");\nObject.defineProperty(__exports,\"TOTAL_FNS\",{enumerable:true,get:function(){return __m5[\"TOTAL_FNS\"];}});\nObject.defineProperty(__exports,\"TOTAL_LABELS\",{enumerable:true,get:function(){return __m5[\"TOTAL_LABELS\"];}});\nObject.defineProperty(__exports,\"totalLabel\",{enumerable:true,get:function(){return __m5[\"totalLabel\"];}});\nObject.defineProperty(__exports,\"total\",{enumerable:true,get:function(){return __m5[\"total\"];}});\nObject.defineProperty(__exports,\"collectValues\",{enumerable:true,get:function(){return __m5[\"collectValues\"];}});\nconst __m6=__req(\"packages/core/src/compute/pivot.js\");\nObject.defineProperty(__exports,\"pivot\",{enumerable:true,get:function(){return __m6[\"pivot\"];}});\nObject.defineProperty(__exports,\"resolvePivotKeys\",{enumerable:true,get:function(){return __m6[\"resolvePivotKeys\"];}});\nObject.defineProperty(__exports,\"pivotKey\",{enumerable:true,get:function(){return __m6[\"pivotKey\"];}});\nObject.defineProperty(__exports,\"joinPath\",{enumerable:true,get:function(){return __m6[\"joinPath\"];}});\nObject.defineProperty(__exports,\"KEY_DELIMITER\",{enumerable:true,get:function(){return __m6[\"KEY_DELIMITER\"];}});\nObject.defineProperty(__exports,\"DEFAULT_PATH_SEPARATOR\",{enumerable:true,get:function(){return __m6[\"DEFAULT_PATH_SEPARATOR\"];}});\nObject.defineProperty(__exports,\"DEFAULT_MAX_COLUMNS\",{enumerable:true,get:function(){return __m6[\"DEFAULT_MAX_COLUMNS\"];}});\nconst __m7=__req(\"packages/core/src/compute/pivotmatrix.js\");\nObject.defineProperty(__exports,\"pivotMatrix\",{enumerable:true,get:function(){return __m7[\"pivotMatrix\"];}});\nObject.defineProperty(__exports,\"resolveAxis\",{enumerable:true,get:function(){return __m7[\"resolveAxis\"];}});\nObject.defineProperty(__exports,\"cellKey\",{enumerable:true,get:function(){return __m7[\"cellKey\"];}});\nObject.defineProperty(__exports,\"marginKey\",{enumerable:true,get:function(){return __m7[\"marginKey\"];}});\nObject.defineProperty(__exports,\"GRAND_PATH\",{enumerable:true,get:function(){return __m7[\"GRAND_PATH\"];}});\nconst __m8=__req(\"packages/core/src/compute/reference.js\");\nObject.defineProperty(__exports,\"referenceSort\",{enumerable:true,get:function(){return __m8[\"referenceSort\"];}});\nObject.defineProperty(__exports,\"referenceFilter\",{enumerable:true,get:function(){return __m8[\"referenceFilter\"];}});\nObject.defineProperty(__exports,\"referenceGroup\",{enumerable:true,get:function(){return __m8[\"referenceGroup\"];}});\nObject.defineProperty(__exports,\"referenceTotal\",{enumerable:true,get:function(){return __m8[\"referenceTotal\"];}});\nObject.defineProperty(__exports,\"referencePasses\",{enumerable:true,get:function(){return __m8[\"referencePasses\"];}});\nObject.defineProperty(__exports,\"referenceValue\",{enumerable:true,get:function(){return __m8[\"referenceValue\"];}});\nconst __m9=__req(\"packages/core/src/compute/handle.js\");\nObject.defineProperty(__exports,\"identity\",{enumerable:true,get:function(){return __m9[\"identity\"];}});\nObject.defineProperty(__exports,\"rowCount\",{enumerable:true,get:function(){return __m9[\"rowCount\"];}});\nObject.defineProperty(__exports,\"presenceReader\",{enumerable:true,get:function(){return __m9[\"presenceReader\"];}});\nObject.defineProperty(__exports,\"bitReader\",{enumerable:true,get:function(){return __m9[\"bitReader\"];}});\nObject.defineProperty(__exports,\"valueReader\",{enumerable:true,get:function(){return __m9[\"valueReader\"];}});\nObject.defineProperty(__exports,\"valueComparator\",{enumerable:true,get:function(){return __m9[\"valueComparator\"];}});\nObject.defineProperty(__exports,\"numericTotalOrder\",{enumerable:true,get:function(){return __m9[\"numericTotalOrder\"];}});\nObject.defineProperty(__exports,\"dictRanks\",{enumerable:true,get:function(){return __m9[\"dictRanks\"];}});\nObject.defineProperty(__exports,\"dictSize\",{enumerable:true,get:function(){return __m9[\"dictSize\"];}});\nObject.defineProperty(__exports,\"dictValue\",{enumerable:true,get:function(){return __m9[\"dictValue\"];}});\nObject.defineProperty(__exports,\"multiValue\",{enumerable:true,get:function(){return __m9[\"multiValue\"];}});\nObject.defineProperty(__exports,\"isMissing\",{enumerable:true,get:function(){return __m9[\"isMissing\"];}});\nconst __m10=__req(\"packages/core/src/compute/sketch.js\");\nObject.defineProperty(__exports,\"Welford\",{enumerable:true,get:function(){return __m10[\"Welford\"];}});\nObject.defineProperty(__exports,\"Reservoir\",{enumerable:true,get:function(){return __m10[\"Reservoir\"];}});\nObject.defineProperty(__exports,\"HyperLogLog\",{enumerable:true,get:function(){return __m10[\"HyperLogLog\"];}});\nObject.defineProperty(__exports,\"SpaceSaving\",{enumerable:true,get:function(){return __m10[\"SpaceSaving\"];}});\nObject.defineProperty(__exports,\"KLL\",{enumerable:true,get:function(){return __m10[\"KLL\"];}});\nObject.defineProperty(__exports,\"hash32\",{enumerable:true,get:function(){return __m10[\"hash32\"];}});\nObject.defineProperty(__exports,\"SKETCH_BOUNDS\",{enumerable:true,get:function(){return __m10[\"SKETCH_BOUNDS\"];}});\nconst __m11=__req(\"packages/core/src/compute/windowed.js\");\nObject.defineProperty(__exports,\"Window\",{enumerable:true,get:function(){return __m11[\"Window\"];}});\nObject.defineProperty(__exports,\"WINDOW_KINDS\",{enumerable:true,get:function(){return __m11[\"WINDOW_KINDS\"];}});\nObject.defineProperty(__exports,\"openWindow\",{enumerable:true,get:function(){return __m11[\"openWindow\"];}});\nconst __m12=__req(\"packages/core/src/compute/statistics.js\");\nObject.defineProperty(__exports,\"MAINTENANCE\",{enumerable:true,get:function(){return __m12[\"MAINTENANCE\"];}});\nObject.defineProperty(__exports,\"APPROXIMATE\",{enumerable:true,get:function(){return __m12[\"APPROXIMATE\"];}});\nObject.defineProperty(__exports,\"maintenanceOf\",{enumerable:true,get:function(){return __m12[\"maintenanceOf\"];}});\nconst __m13=__req(\"packages/core/src/compute/anomaly.js\");\nObject.defineProperty(__exports,\"ANOMALY_METHODS\",{enumerable:true,get:function(){return __m13[\"ANOMALY_METHODS\"];}});\nObject.defineProperty(__exports,\"modifiedZScores\",{enumerable:true,get:function(){return __m13[\"modifiedZScores\"];}});\nObject.defineProperty(__exports,\"iqrFences\",{enumerable:true,get:function(){return __m13[\"iqrFences\"];}});\nObject.defineProperty(__exports,\"mahalanobis\",{enumerable:true,get:function(){return __m13[\"mahalanobis\"];}});\nObject.defineProperty(__exports,\"ROLLING_ANOMALY_METHODS\",{enumerable:true,get:function(){return __m13[\"ROLLING_ANOMALY_METHODS\"];}});\nObject.defineProperty(__exports,\"rollingAnomalies\",{enumerable:true,get:function(){return __m13[\"rollingAnomalies\"];}});\nObject.defineProperty(__exports,\"anomalyCondition\",{enumerable:true,get:function(){return __m13[\"anomalyCondition\"];}});\nconst __m14=__req(\"packages/core/src/compute/forecast.js\");\nObject.defineProperty(__exports,\"FORECAST_METHODS\",{enumerable:true,get:function(){return __m14[\"FORECAST_METHODS\"];}});\nObject.defineProperty(__exports,\"forecast\",{enumerable:true,get:function(){return __m14[\"forecast\"];}});\n});\n__def(\"packages/worker/src/kernel.js\",function(__exports,__req){\n'use strict';\nObject.defineProperty(__exports,\"loadCompute\",{enumerable:true,get:function(){return loadCompute;}});\nObject.defineProperty(__exports,\"setCompute\",{enumerable:true,get:function(){return setCompute;}});\nObject.defineProperty(__exports,\"dispatch\",{enumerable:true,get:function(){return dispatch;}});\nObject.defineProperty(__exports,\"handleMessage\",{enumerable:true,get:function(){return handleMessage;}});\nObject.defineProperty(__exports,\"installKernel\",{enumerable:true,get:function(){return installKernel;}});\nconst __m0=__req(\"packages/worker/src/transport.js\");\nconst PROTOCOL=__m0[\"PROTOCOL\"];\nconst OPS=__m0[\"OPS\"];\nconst CONTROL=__m0[\"CONTROL\"];\nconst ERRORS=__m0[\"ERRORS\"];\nconst unpackHandle=__m0[\"unpackHandle\"];\nconst unpackHandles=__m0[\"unpackHandles\"];\nconst createMaskPool=__m0[\"createMaskPool\"];\nconst collectTransfers=__m0[\"collectTransfers\"];\nconst __m1=__req(\"packages/core/src/store/columnpack.js\");\nconst packChunk=__m1[\"packChunk\"];\nconst packedTransfers=__m1[\"packedTransfers\"];\nlet computeModule=null;\nlet computePromise=null;\nlet computeError=null;\nasync function loadCompute(loader){\nif(computeModule)return computeModule;\nif(!computePromise){\nconst load=loader||(()=>Promise.resolve(__req(\"packages/core/src/compute/index.js\")));\ncomputePromise=Promise.resolve()\n.then(load)\n.then((mod)=>{computeModule=mod;return mod;})\n.catch((err)=>{\ncomputeError=err;\ncomputeModule=null;\nreturn null;\n});\n}\nreturn computePromise;\n}\nfunction setCompute(mod){\ncomputeModule=mod;\ncomputePromise=mod?Promise.resolve(mod):null;\ncomputeError=mod?null:computeError;\n}\nfunction filterContext(handles,count,locale){\nconst byId=new Map();\nfor(const h of handles)if(h)byId.set(h.id,h);\nreturn{\nhandle(colId){return byId.get(colId);},\ncount,\npool:createMaskPool(),\nlocale,\n};\n}\nfunction dispatch(request,compute){\nconst{op,args}=request;\nif(op===OPS.COLUMNIZE){\nreturn packChunk(args.schema||[],args.rows||[],args.opts||{});\n}\nconst fn=compute[op];\nif(typeof fn!=='function'){\nconst err=new Error(`[lattice] compute kernel '${op}' is not exported`);\n(err).code=ERRORS.NO_KERNEL;\nthrow err;\n}\nswitch(op){\ncase OPS.COLLATE_STRING_RANKS:\nreturn fn(args.table||[],(args.table||[]).length,args.locale);\ncase OPS.SORT_COLUMN:\nreturn fn(unpackHandle(args.handle),args.order??null,args.opts||{});\ncase OPS.SORT_MULTI:{\nconst handles=unpackHandles(args.handles||[]);\nconst entries=(args.entries||[]).map((e)=>({\n...e,\nhandle:handles[e.index],\n}));\nreturn fn(handles,entries,args.order??null);\n}\ncase OPS.EVALUATE_FILTERS:\nreturn fn(args.filters,filterContext(unpackHandles(args.handles||[]),args.count,args.locale));\ncase OPS.COMPACT:\nreturn fn(args.mask,args.count,undefined);\ncase OPS.GROUP_BY_COLUMNS:\nreturn fn(unpackHandles(args.handles||[]),args.order??null,args.opts||{});\ncase OPS.TOTAL:\nreturn fn(unpackHandle(args.handle),args.indices??null,args.fn);\ncase OPS.PIVOT:\nreturn fn(unpackHandles(args.handles||[]),args.order??null,args.opts||{});\ncase OPS.FACET:\nreturn fn(unpackHandle(args.handle),args.indices??null,args.count,args.opts||{});\ndefault:{\nconst err=new Error(`[lattice] unknown worker op '${op}'`);\n(err).code=ERRORS.PROTOCOL;\nthrow err;\n}\n}\n}\nasync function handleMessage(message,opts={}){\nif(!message||message.lattice!==PROTOCOL)return null;\nconst{id,op}=message;\nif(op===CONTROL.CANCEL){\nopts.cancelled?.add(message.target);\nreturn null;\n}\nif(op===CONTROL.PING){\nreturn{reply:{lattice:PROTOCOL,id,ok:true,result:'pong'},transfer:[]};\n}\nif(op===OPS.COLUMNIZE){\nif(opts.cancelled?.has(id)){opts.cancelled.delete(id);return null;}\ntry{\nconst result=packChunk(message.args.schema||[],message.args.rows||[],message.args.opts||{});\nif(opts.cancelled?.has(id)){\nopts.cancelled.delete(id);\nreturn{reply:{lattice:PROTOCOL,id,ok:false,error:{code:ERRORS.ABORTED,message:'[lattice] request superseded'}},transfer:[]};\n}\nreturn{reply:{lattice:PROTOCOL,id,ok:true,result},transfer:packedTransfers(result)};\n}catch(err){\nconst e=(err);\nreturn{\nreply:{lattice:PROTOCOL,id,ok:false,error:{code:e.code||ERRORS.KERNEL,message:e.message||String(err),stack:e.stack}},\ntransfer:[],\n};\n}\n}\nconst compute=await loadCompute(opts.loader);\nif(!compute){\nreturn{\nreply:{\nlattice:PROTOCOL,\nid,\nok:false,\nerror:{\ncode:ERRORS.NO_COMPUTE,\nmessage:`[lattice] compute kernels unavailable in worker: ${computeError?computeError.message:'module not found'}`,\n},\n},\ntransfer:[],\n};\n}\nif(opts.cancelled?.has(id)){\nopts.cancelled.delete(id);\nreturn{reply:{lattice:PROTOCOL,id,ok:false,error:{code:ERRORS.ABORTED,message:'[lattice] request superseded'}},transfer:[]};\n}\ntry{\nconst result=dispatch(message,compute);\nif(opts.cancelled?.has(id)){\nopts.cancelled.delete(id);\nreturn{reply:{lattice:PROTOCOL,id,ok:false,error:{code:ERRORS.ABORTED,message:'[lattice] request superseded'}},transfer:[]};\n}\nreturn{reply:{lattice:PROTOCOL,id,ok:true,result},transfer:collectTransfers(result)};\n}catch(err){\nconst e=(err);\nreturn{\nreply:{\nlattice:PROTOCOL,\nid,\nok:false,\nerror:{code:e.code||ERRORS.KERNEL,message:e.message||String(err),stack:e.stack},\n},\ntransfer:[],\n};\n}\n}\nfunction installKernel(scope,opts={}){\nconst cancelled=new Set();\nconst onMessage=async(event)=>{\nconst outcome=await handleMessage(event.data,{loader:opts.loader,cancelled});\nif(!outcome)return;\nscope.postMessage(outcome.reply,outcome.transfer);\n};\nscope.addEventListener('message',onMessage);\nloadCompute(opts.loader).then((mod)=>{\nscope.postMessage({lattice:PROTOCOL,id:0,op:CONTROL.READY,compute:!!mod});\n});\nreturn()=>scope.removeEventListener('message',onMessage);\n}\n});\nvar __entry=__req(\"packages/worker/src/kernel.js\");\nroot[\"__latticeKernel\"]=__entry;\n})(typeof globalThis!=='undefined'?globalThis:this);\n__latticeKernel.installKernel(self);\n",{type:'classic'});
 }catch(err){}
 const __entry=__req("packages/dom/src/index.js");
 export const