@ifc-lite/viewer 1.26.0 → 1.28.0

package/src/lib/length-unit-scale.ts

@@ -0,0 +1,41 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Model length-unit → metres scale, memoised per `IfcDataStore`.
+ *
+ * The viewer's render + authoring space is **metres**: the geometry
+ * pipeline bakes the file's length-unit scale into tessellated vertices,
+ * raycast hit-points come back in metres, and `spatialHierarchy.
+ * storeyElevations` are pre-scaled. But raw coordinate reads straight off
+ * the STEP model — split footprints, placement chains — arrive in the
+ * file's **native** units (e.g. millimetres). Multiply those by this
+ * factor to bring them into the same metre space as everything else.
+ *
+ * Returns `1` when the scale can't be determined (already-metres models,
+ * or bounded-geometry mode having released the source buffer) — the
+ * safe identity that leaves native-unit reads untouched.
+ */
+
+import { extractLengthUnitScale, type IfcDataStore } from '@ifc-lite/parser';
+
+const scaleCache = new WeakMap<IfcDataStore, number>();
+
+export function getModelLengthUnitScale(dataStore: IfcDataStore | null | undefined): number {
+  if (!dataStore) return 1;
+  const cached = scaleCache.get(dataStore);
+  if (cached !== undefined) return cached;
+
+  // The columnar parser stashes the scale on the store; the wasm fast
+  // path does not, so fall back to extracting it from the source bytes.
+  let scale = typeof dataStore.lengthUnitScale === 'number' ? dataStore.lengthUnitScale : undefined;
+  if (scale === undefined || !Number.isFinite(scale) || scale <= 0) {
+    if (!dataStore.source?.length || !dataStore.entityIndex) return 1;
+    scale = extractLengthUnitScale(dataStore.source, dataStore.entityIndex);
+  }
+  if (!Number.isFinite(scale) || scale <= 0) scale = 1;
+
+  scaleCache.set(dataStore, scale);
+  return scale;
+}

package/src/lib/lists/adapter.ts

@@ -11,10 +11,31 @@
  * and Tag which are not stored during the fast initial parse.
  */
 
-import type { IfcDataStore } from '@ifc-lite/parser';
-import { extractPropertiesOnDemand, extractQuantitiesOnDemand, extractEntityAttributesOnDemand } from '@ifc-lite/parser';
+import type { IfcDataStore, MaterialInfo } from '@ifc-lite/parser';
+import {
+  extractPropertiesOnDemand,
+  extractQuantitiesOnDemand,
+  extractEntityAttributesOnDemand,
+  extractMaterialsOnDemand,
+  extractClassificationsOnDemand,
+} from '@ifc-lite/parser';
 import type { PropertySet, QuantitySet } from '@ifc-lite/data';
-import type { ListDataProvider } from '@ifc-lite/lists';
+import { ENTITY_ATTRIBUTES } from '@ifc-lite/lists';
+import type { ListDataProvider, ListClassificationRef, DiscoveredColumns } from '@ifc-lite/lists';
+
+/** Collect every material-name string an element exposes — top-level
+ *  material plus layer / constituent / profile names and list members. */
+function materialNamesOf(info: MaterialInfo | null): string[] {
+  if (!info) return [];
+  const names: string[] = [];
+  const push = (s: string | undefined) => { if (s) names.push(s); };
+  push(info.name);
+  for (const l of info.layers ?? []) { push(l.materialName); push(l.name); }
+  for (const c of info.constituents ?? []) { push(c.materialName); push(c.name); }
+  for (const p of info.profiles ?? []) { push(p.materialName); push(p.name); }
+  for (const m of info.materials ?? []) push(m.name);
+  return names;
+}
 
 /**
  * Create a ListDataProvider backed by an IfcDataStore.
@@ -26,6 +47,10 @@ export function createListDataProvider(store: IfcDataStore): ListDataProvider {
   // but are needed for list display. Cache avoids re-parsing per column.
   const attrCache = new Map<number, { description: string; objectType: string; tag: string }>();
 
+  // Lazily materialised list of every non-empty express id — used for
+  // class-less list targeting. Cached because the provider outlives a run.
+  let allIdsCache: number[] | null = null;
+
   function getOnDemandAttrs(id: number): { description: string; objectType: string; tag: string } {
     const cached = attrCache.get(id);
     if (cached) return cached;
@@ -42,6 +67,23 @@ export function createListDataProvider(store: IfcDataStore): ListDataProvider {
     return empty;
   }
 
+  // Complete column discovery is cached — the provider outlives a builder
+  // open, and the scan touches every entity that declares a pset/qto.
+  let columnsCache: DiscoveredColumns | null = null;
+
+  const usesOnDemandProps = !!store.onDemandPropertyMap && store.source?.length > 0;
+  const usesOnDemandQtos = !!store.onDemandQuantityMap && store.source?.length > 0;
+
+  function getPropertySetsFor(entityId: number): PropertySet[] {
+    if (usesOnDemandProps) return extractPropertiesOnDemand(store, entityId) as PropertySet[];
+    return store.properties?.getForEntity(entityId) ?? [];
+  }
+
+  function getQuantitySetsFor(entityId: number): QuantitySet[] {
+    if (usesOnDemandQtos) return extractQuantitiesOnDemand(store, entityId) as QuantitySet[];
+    return store.quantities?.getForEntity(entityId) ?? [];
+  }
+
   return {
     getEntitiesByType: (type) => store.entities.getByType(type),
 
@@ -52,18 +94,101 @@ export function createListDataProvider(store: IfcDataStore): ListDataProvider {
     getEntityTag: (id) => getOnDemandAttrs(id).tag,
     getEntityTypeName: (id) => store.entities.getTypeName(id),
 
-    getPropertySets(entityId: number): PropertySet[] {
-      if (store.onDemandPropertyMap && store.source?.length > 0) {
-        return extractPropertiesOnDemand(store, entityId) as PropertySet[];
+    getPropertySets: getPropertySetsFor,
+    getQuantitySets: getQuantitySetsFor,
+
+    getAllEntityIds(): number[] {
+      if (allIdsCache) return allIdsCache;
+      // Restrict "all elements" to geometry-bearing (selectable) products.
+      // The raw expressId column also holds relationships, property sets,
+      // materials, classifications and other non-element records — a
+      // class-less list should not surface those as rows.
+      const ids: number[] = [];
+      const col = store.entities.expressId;
+      for (let i = 0; i < col.length; i++) {
+        const id = col[i];
+        if (id && store.entities.hasGeometry(id)) ids.push(id);
       }
-      return store.properties?.getForEntity(entityId) ?? [];
+      allIdsCache = ids;
+      return ids;
+    },
+
+    getMaterialNames(entityId: number): string[] {
+      return materialNamesOf(extractMaterialsOnDemand(store, entityId));
+    },
+
+    getClassifications(entityId: number): ListClassificationRef[] {
+      return extractClassificationsOnDemand(store, entityId).map((c) => ({
+        system: c.system,
+        code: c.identification,
+        name: c.name,
+      }));
     },
 
-    getQuantitySets(entityId: number): QuantitySet[] {
-      if (store.onDemandQuantityMap && store.source?.length > 0) {
-        return extractQuantitiesOnDemand(store, entityId) as QuantitySet[];
+    getStoreyName(entityId: number): string {
+      const hierarchy = store.spatialHierarchy;
+      if (!hierarchy) return '';
+      const storeyId = hierarchy.elementToStorey.get(entityId);
+      if (!storeyId) return '';
+      return store.entities.getName(storeyId) || '';
+    },
+
+    discoverAllColumns(): DiscoveredColumns {
+      if (columnsCache) return columnsCache;
+
+      const properties = new Map<string, Set<string>>();
+      const quantities = new Map<string, Set<string>>();
+
+      const ingestProps = (id: number) => {
+        for (const set of getPropertySetsFor(id)) {
+          if (!set.name) continue;
+          let bucket = properties.get(set.name);
+          if (!bucket) { bucket = new Set(); properties.set(set.name, bucket); }
+          for (const p of set.properties) if (p.name) bucket.add(p.name);
+        }
+      };
+      const ingestQtos = (id: number) => {
+        for (const set of getQuantitySetsFor(id)) {
+          if (!set.name) continue;
+          let bucket = quantities.get(set.name);
+          if (!bucket) { bucket = new Set(); quantities.set(set.name, bucket); }
+          for (const q of set.quantities) if (q.name) bucket.add(q.name);
+        }
+      };
+
+      // On-demand path: scan exactly the entities that declare a pset/qto —
+      // the minimal complete set (every distinct set/property in the model).
+      if (usesOnDemandProps && store.onDemandPropertyMap) {
+        for (const id of store.onDemandPropertyMap.keys()) ingestProps(id);
+      }
+      if (usesOnDemandQtos && store.onDemandQuantityMap) {
+        for (const id of store.onDemandQuantityMap.keys()) ingestQtos(id);
       }
-      return store.quantities?.getForEntity(entityId) ?? [];
+      // Table path (e.g. server-loaded models): scan the entity column using
+      // the pre-built tables. Capped so it can't run away on huge models.
+      if (!usesOnDemandProps || !usesOnDemandQtos) {
+        const col = store.entities.expressId;
+        const CAP = 100_000;
+        for (let i = 0, seen = 0; i < col.length && seen < CAP; i++) {
+          const id = col[i];
+          if (!id) continue;
+          seen++;
+          if (!usesOnDemandProps) ingestProps(id);
+          if (!usesOnDemandQtos) ingestQtos(id);
+        }
+      }
+
+      const toSorted = (m: Map<string, Set<string>>) => {
+        const out = new Map<string, string[]>();
+        for (const [k, s] of m) out.set(k, Array.from(s).sort());
+        return out;
+      };
+      columnsCache = {
+        attributes: [...ENTITY_ATTRIBUTES],
+        properties: toSorted(properties),
+        quantities: toSorted(quantities),
+      };
+      return columnsCache;
     },
   };
 }

package/src/lib/lists/export/csv.ts

@@ -0,0 +1,47 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import type { CellValue } from '@ifc-lite/lists';
+import { displayCell, type ExportModel } from './model';
+
+function esc(s: string, delim: string): string {
+  return /["\r\n]/.test(s) || s.includes(delim) ? `"${s.replace(/"/g, '""')}"` : s;
+}
+
+/**
+ * CSV faithful to the configured columns. When grouped, a leading "Group"
+ * column preserves the grouping as data (so it stays re-importable), rows are
+ * ordered by group, and a TOTAL row carries the grand count + sums.
+ */
+export function toCsv(model: ExportModel, delimiter = ','): string {
+  const grouped = model.groups !== null;
+  const header = [...(grouped ? ['Group'] : []), ...model.columns.map((c) => c.label)];
+  const lines = [header.map((h) => esc(h, delimiter)).join(delimiter)];
+
+  const line = (groupLabel: string | null, values: CellValue[]) => {
+    const cells = grouped ? [esc(groupLabel ?? '', delimiter)] : [];
+    for (let i = 0; i < model.columns.length; i++) cells.push(esc(displayCell(values[i]), delimiter));
+    return cells.join(delimiter);
+  };
+
+  if (grouped && model.groups) {
+    for (const g of model.groups) for (const r of g.rows) lines.push(line(g.label, r));
+  } else {
+    for (const r of model.rows) lines.push(line(null, r));
+  }
+
+  if (model.sumColumnIds.length > 0) {
+    const totalLabel = `TOTAL (${model.totals.count})`;
+    const cells = grouped ? [esc(totalLabel, delimiter)] : [];
+    for (let i = 0; i < model.columns.length; i++) {
+      const c = model.columns[i];
+      if (c.summed) cells.push(esc(displayCell(model.totals.sums[c.id]), delimiter));
+      else if (!grouped && i === 0) cells.push(esc(totalLabel, delimiter));
+      else cells.push('');
+    }
+    lines.push(cells.join(delimiter));
+  }
+
+  return lines.join('\r\n');
+}

package/src/lib/lists/export/index.ts

@@ -0,0 +1,49 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * List results export — CSV / Excel / PDF, all driven by one normalised model
+ * (columns, grouping, sums, totals). Excel and PDF writers (and their heavy
+ * libs) are lazy-loaded so they never touch the initial bundle.
+ */
+
+import { toCsv } from './csv';
+import type { ExportModel } from './model';
+
+export type ExportFormat = 'csv' | 'xlsx' | 'pdf';
+
+export const EXPORT_LABELS: Record<ExportFormat, string> = {
+  csv: 'CSV (.csv)',
+  xlsx: 'Excel (.xlsx)',
+  pdf: 'PDF (.pdf)',
+};
+
+function slug(s: string): string {
+  return (s || 'list').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 60) || 'list';
+}
+
+function download(blob: Blob, filename: string): void {
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement('a');
+  a.href = url;
+  a.download = filename;
+  a.click();
+  setTimeout(() => URL.revokeObjectURL(url), 1500);
+}
+
+export async function exportList(format: ExportFormat, model: ExportModel): Promise<void> {
+  const name = slug(model.title);
+  if (format === 'csv') {
+    download(new Blob([toCsv(model)], { type: 'text/csv;charset=utf-8;' }), `${name}.csv`);
+  } else if (format === 'xlsx') {
+    const { toXlsx } = await import('./xlsx');
+    download(await toXlsx(model), `${name}.xlsx`);
+  } else {
+    const { toPdf } = await import('./pdf');
+    download(await toPdf(model), `${name}.pdf`);
+  }
+}
+
+export { buildExportModel } from './model';
+export type { ExportModel } from './model';

package/src/lib/lists/export/model.ts

@@ -0,0 +1,111 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Normalised export model shared by the CSV / Excel / PDF writers. Built from
+ * the on-screen list view so every export honours the configured columns
+ * (order, labels, widths), the active grouping, and the summed columns —
+ * grouped sections with per-group count + subtotals, plus grand totals.
+ */
+
+import type { CellValue, ColumnDefinition, ListRow, ListGrouping } from '@ifc-lite/lists';
+
+export interface ExportColumn {
+  id: string;
+  label: string;
+  numeric: boolean;
+  summed: boolean;
+  /** Pixel width from the table (for proportional column sizing in exports). */
+  width: number;
+}
+
+export interface ExportGroup {
+  label: string;
+  count: number;
+  sums: Record<string, number>;
+  rows: CellValue[][];
+}
+
+export interface ExportModel {
+  title: string;
+  generatedAt: string;
+  columns: ExportColumn[];
+  /** Grouped sections (with member rows), or null when the list isn't grouped. */
+  groups: ExportGroup[] | null;
+  /** All rows in display order (flat) — used by writers that don't section. */
+  rows: CellValue[][];
+  groupColumnId: string | null;
+  sumColumnIds: string[];
+  totals: { count: number; sums: Record<string, number> };
+}
+
+export interface BuildModelInput {
+  title: string;
+  columns: ColumnDefinition[];
+  /** Rows already filtered + sorted exactly as shown on screen. */
+  rows: ListRow[];
+  grouping?: ListGrouping;
+  numericCols: boolean[];
+  columnWidths: number[];
+  generatedAt: string;
+}
+
+/** Format a cell for text-based exports (CSV/PDF). Excel keeps raw numbers. */
+export function displayCell(value: CellValue): string {
+  if (value === null || value === undefined) return '';
+  if (typeof value === 'boolean') return value ? 'Yes' : 'No';
+  if (typeof value === 'number') {
+    if (Number.isInteger(value)) return value.toLocaleString();
+    return value.toFixed(4).replace(/\.?0+$/, '');
+  }
+  return String(value);
+}
+
+export function buildExportModel(input: BuildModelInput): ExportModel {
+  const { columns, rows, grouping, numericCols, columnWidths, title, generatedAt } = input;
+  const sumColumnIds = grouping?.sumColumnIds ?? [];
+  const exportCols: ExportColumn[] = columns.map((c, i) => ({
+    id: c.id,
+    label: c.label ?? c.propertyName,
+    numeric: !!numericCols[i],
+    summed: sumColumnIds.includes(c.id),
+    width: columnWidths[i] ?? 120,
+  }));
+
+  const sumIdx = sumColumnIds
+    .map((id) => ({ id, idx: columns.findIndex((c) => c.id === id) }))
+    .filter((s) => s.idx >= 0);
+  const zeroSums = (): Record<string, number> => Object.fromEntries(sumIdx.map((s) => [s.id, 0]));
+  const addSums = (acc: Record<string, number>, values: CellValue[]) => {
+    for (const s of sumIdx) {
+      const v = values[s.idx];
+      if (typeof v === 'number' && Number.isFinite(v)) acc[s.id] += v;
+    }
+  };
+
+  const totals = { count: rows.length, sums: zeroSums() };
+  const flatRows: CellValue[][] = [];
+  for (const r of rows) { flatRows.push(r.values); addSums(totals.sums, r.values); }
+
+  const groupColumnId = grouping?.columnId && columns.some((c) => c.id === grouping.columnId)
+    ? grouping.columnId : null;
+
+  let groups: ExportGroup[] | null = null;
+  if (groupColumnId) {
+    const groupIdx = columns.findIndex((c) => c.id === groupColumnId);
+    const byKey = new Map<string, ExportGroup>();
+    for (const r of rows) {
+      const raw = r.values[groupIdx];
+      const label = raw === null || raw === undefined || raw === '' ? '(none)' : displayCell(raw);
+      let g = byKey.get(label);
+      if (!g) { g = { label, count: 0, sums: zeroSums(), rows: [] }; byKey.set(label, g); }
+      g.count++;
+      g.rows.push(r.values);
+      addSums(g.sums, r.values);
+    }
+    groups = Array.from(byKey.values()).sort((a, b) => b.count - a.count || a.label.localeCompare(b.label));
+  }
+
+  return { title, generatedAt, columns: exportCols, groups, rows: flatRows, groupColumnId, sumColumnIds, totals };
+}

package/src/lib/lists/export/pdf.ts

@@ -0,0 +1,67 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import type { CellValue } from '@ifc-lite/lists';
+import { displayCell, type ExportModel } from './model';
+
+/** Quality tabular PDF report: title + meta, dark header, grouped sections
+ *  (bold group rows carrying per-group count + subtotals), right-aligned
+ *  numerics, a grand-total foot, and page numbers. */
+export async function toPdf(model: ExportModel): Promise<Blob> {
+  const { jsPDF } = await import('jspdf');
+  const autoTable = (await import('jspdf-autotable')).default;
+
+  const landscape = model.columns.length > 5;
+  const doc = new jsPDF({ orientation: landscape ? 'landscape' : 'portrait', unit: 'pt', format: 'a4' });
+
+  doc.setFont('helvetica', 'bold'); doc.setFontSize(14);
+  doc.text(model.title || 'List', 40, 42);
+  doc.setFont('helvetica', 'normal'); doc.setFontSize(9); doc.setTextColor(130);
+  doc.text(`${model.totals.count.toLocaleString()} elements · ${model.generatedAt}`, 40, 58);
+  doc.setTextColor(0);
+
+  const head = [model.columns.map((c) => c.label)];
+  const cell = (vals: CellValue[], i: number) => displayCell(vals[i]);
+  const body: Array<Array<string | { content: string; styles: Record<string, unknown> }>> = [];
+
+  if (model.groups) {
+    for (const g of model.groups) {
+      body.push(model.columns.map((c, i) => ({
+        content: i === 0 ? `${g.label}  (${g.count})` : (c.summed ? displayCell(g.sums[c.id]) : ''),
+        styles: { fontStyle: 'bold', fillColor: [226, 232, 240] as unknown as number[] },
+      })));
+      for (const r of g.rows) body.push(model.columns.map((_, i) => cell(r, i)));
+    }
+  } else {
+    for (const r of model.rows) body.push(model.columns.map((_, i) => cell(r, i)));
+  }
+
+  const foot = model.sumColumnIds.length > 0
+    ? [model.columns.map((c, i) => (c.summed ? displayCell(model.totals.sums[c.id]) : (i === 0 ? `Total (${model.totals.count})` : '')))]
+    : undefined;
+
+  const columnStyles: Record<number, { halign: 'right' }> = {};
+  model.columns.forEach((c, i) => { if (c.numeric) columnStyles[i] = { halign: 'right' }; });
+
+  autoTable(doc, {
+    head,
+    body,
+    foot,
+    startY: 72,
+    margin: { left: 40, right: 40, top: 70, bottom: 40 },
+    styles: { fontSize: 8, cellPadding: 3, overflow: 'ellipsize', lineColor: [226, 232, 240], lineWidth: 0.5 },
+    headStyles: { fillColor: [51, 65, 85], textColor: 255, fontStyle: 'bold' },
+    footStyles: { fillColor: [241, 245, 249], textColor: 20, fontStyle: 'bold' },
+    columnStyles,
+    didDrawPage: () => {
+      doc.setFontSize(8); doc.setTextColor(150);
+      const w = doc.internal.pageSize.getWidth();
+      const h = doc.internal.pageSize.getHeight();
+      doc.text(`Page ${doc.getNumberOfPages()}`, w - 60, h - 20);
+      doc.setTextColor(0);
+    },
+  });
+
+  return doc.output('blob');
+}

package/src/lib/lists/export/xlsx.ts

@@ -0,0 +1,83 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import type { CellValue } from '@ifc-lite/lists';
+import { displayCell, type ExportModel, type ExportColumn } from './model';
+
+const XLSX_MIME = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+const NUM_FMT = '#,##0.####';
+
+/** px → Excel column-width units (≈ 7px per char). */
+const excelWidth = (px: number): number => Math.max(8, Math.min(80, Math.round(px / 7)));
+
+/** Excel keeps real numbers (so the recipient can re-aggregate); other types
+ *  fall back to the same display string the table shows. */
+function cellValue(v: CellValue, c: ExportColumn): string | number | null {
+  if (v === null || v === undefined) return null;
+  if (c.numeric && typeof v === 'number' && Number.isFinite(v)) return v;
+  return displayCell(v);
+}
+
+export async function toXlsx(model: ExportModel): Promise<Blob> {
+  const ExcelJS = (await import('exceljs')).default;
+  const wb = new ExcelJS.Workbook();
+  wb.creator = 'IFC-Lite';
+  const ws = wb.addWorksheet((model.title || 'List').slice(0, 31), {
+    views: [{ state: 'frozen', ySplit: 4 }],
+  });
+
+  const cols = model.columns;
+  const ncol = cols.length;
+
+  // Title + meta.
+  ws.addRow([model.title || 'List']);
+  ws.mergeCells(1, 1, 1, ncol);
+  ws.getCell(1, 1).font = { bold: true, size: 14 };
+  ws.addRow([`${model.totals.count.toLocaleString()} elements · ${model.generatedAt}`]);
+  ws.mergeCells(2, 1, 2, ncol);
+  ws.getCell(2, 1).font = { italic: true, size: 9, color: { argb: 'FF94A3B8' } };
+  ws.addRow([]);
+
+  // Header.
+  const header = ws.addRow(cols.map((c) => c.label));
+  header.font = { bold: true, color: { argb: 'FFFFFFFF' } };
+  header.eachCell((cell) => {
+    cell.fill = { type: 'pattern', pattern: 'solid', fgColor: { argb: 'FF334155' } };
+    cell.alignment = { vertical: 'middle' };
+  });
+
+  // Column widths + numeric formatting/alignment.
+  cols.forEach((c, i) => {
+    const col = ws.getColumn(i + 1);
+    col.width = excelWidth(c.width);
+    if (c.numeric) { col.numFmt = NUM_FMT; col.alignment = { horizontal: 'right' }; }
+  });
+
+  const addDataRow = (values: CellValue[], outline?: number) => {
+    const r = ws.addRow(cols.map((c, i) => cellValue(values[i], c)));
+    if (outline) r.outlineLevel = outline;
+  };
+
+  if (model.groups) {
+    for (const g of model.groups) {
+      const gr = ws.addRow(cols.map((c, i) => (i === 0 ? `${g.label} (${g.count})` : (c.summed ? g.sums[c.id] : null))));
+      gr.font = { bold: true };
+      gr.eachCell((cell) => { cell.fill = { type: 'pattern', pattern: 'solid', fgColor: { argb: 'FFE2E8F0' } }; });
+      for (const row of g.rows) addDataRow(row, 1);
+    }
+    ws.properties.outlineLevelRow = 1;
+  } else {
+    for (const row of model.rows) addDataRow(row);
+  }
+
+  // Grand total.
+  if (model.sumColumnIds.length > 0) {
+    const tr = ws.addRow(cols.map((c, i) => (c.summed ? model.totals.sums[c.id] : (i === 0 ? `Total (${model.totals.count})` : null))));
+    tr.font = { bold: true };
+    tr.eachCell((cell) => { cell.border = { top: { style: 'double', color: { argb: 'FF334155' } } }; });
+  }
+
+  const buf = await wb.xlsx.writeBuffer();
+  return new Blob([buf], { type: XLSX_MIME });
+}

package/src/lib/lists/index.ts

@@ -14,10 +14,12 @@ export type {
   ConditionOperator,
   DiscoveredColumns,
   EntityAttribute,
+  ListGrouping,
 } from '@ifc-lite/lists';
 export {
   ENTITY_ATTRIBUTES,
   executeList,
+  summariseListRows,
   listResultToCSV,
   discoverColumns,
   LIST_PRESETS,

package/src/lib/llm/script-edit-ops.ts

@@ -456,6 +456,29 @@ export function applyScriptEditOperations(params: {
     return { ok: true, content, selection, revision, appliedOpIds, changes, status: 'ok' };
   }
 
+  if (operations.length > 1 && operations.some((op) => op.type === 'replaceAll')) {
+    const diagnostic = createPatchDiagnostic(
+      'patch_semantic_error',
+      'A replaceAll edit must be the only operation in its batch; it cannot be combined with positional ops.',
+      'error',
+      {
+        failureKind: 'mixed_repair_scopes',
+        fixHint:
+          'Emit replaceAll on its own, or use only positional ops (insert/replaceRange/append) in one batch.',
+      },
+    );
+    return {
+      ok: false,
+      content: params.content,
+      selection: params.selection,
+      revision,
+      appliedOpIds: [],
+      status: 'semantic_error',
+      error: diagnostic.message,
+      diagnostic,
+    };
+  }
+
   if (params.intent === 'repair') {
     const metadataError = validateRepairBatchMetadata(operations);
     if (metadataError) {

package/src/lib/llm/stream-client.ts

@@ -139,7 +139,14 @@ export async function readSseStream(
         if (!line.startsWith('data: ')) continue;
         const data = line.slice(6);
         if (data === '[DONE]') continue;
-        try { onEvent(data); } catch { /* skip malformed */ }
+        try {
+          onEvent(data);
+        } catch (err) {
+          // Malformed JSON payloads are expected and skipped, but a genuine
+          // callback failure (onChunk/onUsageInfo/logCacheHit/fullText) would
+          // otherwise be silently dropped — surface it for diagnosability.
+          console.debug('[sse] skipped event', err);
+        }
       }
     }
   };