@datakable/core 1.0.1 → 2.0.0

package/dist/intercept/cell-batch.cjs

@@ -36,10 +36,10 @@ var CELL_FALLBACK = {
   sortBy: void 0
 };
 var CELL_FALLBACK_TEXT = {
-  accessor: "the failed cells read as undefined",
-  format: "the failed cells render ''",
-  filterFn: "the failed rows are treated as non-matching",
-  sortBy: "the failed rows sort as missing values (last)"
+  accessor: "cells-undefined",
+  format: "cells-empty",
+  filterFn: "rows-unmatched",
+  sortBy: "rows-last"
 };
 var CellFailures = class {
   constructor(sample = 5) {

package/dist/intercept/cell-batch.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/intercept/cell-batch.ts"],"sourcesContent":["import { keepDiagnostics } from '../diagnostics/catalog'\nimport type { Emit, EmitOptions } from '../diagnostics/types'\nimport { errorName } from './classify'\nimport { boundaryDiagnostics } from './codes'\n\n// CellFailures emits DK_CALLBACK_FAILED: keep its definition wherever this module is bundled (a\n// feature entry alone brings the feature runtime, and with it the column cache, #5).\nkeepDiagnostics(boundaryDiagnostics)\n\n/** The cell slots of `column:batch`. */\nexport type CellSlot = 'accessor' | 'format' | 'filterFn' | 'sortBy'\n\n/**\n * Per failed cell (§3.4): `''` (format) / `undefined` (accessor) / non-matching (filter fn) /\n * `undefined`, sorted last as a missing value (sortBy).\n */\nexport const CELL_FALLBACK = {\n  accessor: undefined,\n  format: '',\n  filterFn: false,\n  sortBy: undefined,\n} as const\n\nconst CELL_FALLBACK_TEXT: Record<CellSlot, string> = {\n  accessor: 'the failed cells read as undefined',\n  format: \"the failed cells render ''\",\n  filterFn: 'the failed rows are treated as non-matching',\n  sortBy: 'the failed rows sort as missing values (last)',\n}\n\n/**\n * Failures of one column's cells in one pipeline run, recorded as numbers (§3.4): a count, the\n * first `sample` row indices and the first error. No per-cell allocation; `where` and text are\n * built only in {@link CellFailures.report}. Reuse one instance per column across runs.\n */\nexport class CellFailures {\n  count = 0\n  private first: unknown\n  private readonly rows: Uint32Array\n\n  constructor(sample = 5) {\n    this.rows = new Uint32Array(sample)\n  }\n\n  add(row: number, error: unknown): void {\n    if (this.count === 0) this.first = error\n    if (this.count < this.rows.length) this.rows[this.count] = row\n    this.count++\n  }\n\n  /** The recorded sample of failing row indices (a view; valid until the next reset). */\n  sample(): Uint32Array {\n    return this.rows.subarray(0, Math.min(this.count, this.rows.length))\n  }\n\n  reset(): void {\n    this.count = 0\n    this.first = undefined\n  }\n\n  /**\n   * Emits one `DK_CALLBACK_FAILED` for this column (if any cell failed), then resets. `where` is the\n   * slot path `columns[<index>].<slot>`; `field` replaces the slot name in that path when the\n   * failing column field differs (`key` for a key column whose getter threw).\n   */\n  report(\n    emit: Emit,\n    columnIndex: number,\n    columnId: string,\n    slot: CellSlot,\n    options?: EmitOptions,\n    field: string = slot,\n  ): void {\n    if (this.count === 0) return\n    const name = errorName(this.first)\n    emit(\n      'DK_CALLBACK_FAILED',\n      {\n        slot: `columns[${columnIndex}].${field}`,\n        column: columnId,\n        rows: Array.from(this.sample()),\n        count: this.count,\n        fallback: CELL_FALLBACK_TEXT[slot],\n        ...(name === undefined ? {} : { errorName: name }),\n      },\n      { ...options, cause: this.first },\n    )\n    this.reset()\n  }\n}\n\n/**\n * The body of a `column:batch`: runs `cell` for each row in `rows` and writes `out[row]`. A throwing\n * cell gets `fallback` and is recorded in `failures` — the loop never throws per cell and never\n * dispatches an interceptor per cell. Call `failures.report(...)` once after the loop.\n */\nexport function runCells<R>(\n  rows: Uint32Array,\n  cell: (row: number) => R,\n  out: { [row: number]: R },\n  fallback: R,\n  failures: CellFailures,\n): void {\n  for (let i = 0; i < rows.length; i++) {\n    const row = rows[i] as number\n    try {\n      out[row] = cell(row)\n    } catch (e) {\n      out[row] = fallback\n      failures.add(row, e)\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAAgC;AAEhC,sBAA0B;AAC1B,mBAAoC;AAAA,IAIpC,gCAAgB,gCAAmB;AAS5B,IAAM,gBAAgB;AAAA,EAC3B,UAAU;AAAA,EACV,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,QAAQ;AACV;AAEA,IAAM,qBAA+C;AAAA,EACnD,UAAU;AAAA,EACV,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,QAAQ;AACV;AAOO,IAAM,eAAN,MAAmB;AAAA,EAKxB,YAAY,SAAS,GAAG;AAJxB,iBAAQ;AAKN,SAAK,OAAO,IAAI,YAAY,MAAM;AAAA,EACpC;AAAA,EAEA,IAAI,KAAa,OAAsB;AACrC,QAAI,KAAK,UAAU,EAAG,MAAK,QAAQ;AACnC,QAAI,KAAK,QAAQ,KAAK,KAAK,OAAQ,MAAK,KAAK,KAAK,KAAK,IAAI;AAC3D,SAAK;AAAA,EACP;AAAA;AAAA,EAGA,SAAsB;AACpB,WAAO,KAAK,KAAK,SAAS,GAAG,KAAK,IAAI,KAAK,OAAO,KAAK,KAAK,MAAM,CAAC;AAAA,EACrE;AAAA,EAEA,QAAc;AACZ,SAAK,QAAQ;AACb,SAAK,QAAQ;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OACE,MACA,aACA,UACA,MACA,SACA,QAAgB,MACV;AACN,QAAI,KAAK,UAAU,EAAG;AACtB,UAAM,WAAO,2BAAU,KAAK,KAAK;AACjC;AAAA,MACE;AAAA,MACA;AAAA,QACE,MAAM,WAAW,WAAW,KAAK,KAAK;AAAA,QACtC,QAAQ;AAAA,QACR,MAAM,MAAM,KAAK,KAAK,OAAO,CAAC;AAAA,QAC9B,OAAO,KAAK;AAAA,QACZ,UAAU,mBAAmB,IAAI;AAAA,QACjC,GAAI,SAAS,SAAY,CAAC,IAAI,EAAE,WAAW,KAAK;AAAA,MAClD;AAAA,MACA,EAAE,GAAG,SAAS,OAAO,KAAK,MAAM;AAAA,IAClC;AACA,SAAK,MAAM;AAAA,EACb;AACF;AAOO,SAAS,SACd,MACA,MACA,KACA,UACA,UACM;AACN,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,UAAM,MAAM,KAAK,CAAC;AAClB,QAAI;AACF,UAAI,GAAG,IAAI,KAAK,GAAG;AAAA,IACrB,SAAS,GAAG;AACV,UAAI,GAAG,IAAI;AACX,eAAS,IAAI,KAAK,CAAC;AAAA,IACrB;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../../src/intercept/cell-batch.ts"],"sourcesContent":["import { keepDiagnostics } from '../diagnostics/catalog'\nimport type { Emit, EmitOptions } from '../diagnostics/types'\nimport { errorName } from './classify'\nimport { boundaryDiagnostics } from './codes'\n\n// CellFailures emits DK_CALLBACK_FAILED: keep its definition wherever this module is bundled (a\n// feature entry alone brings the feature runtime, and with it the column cache, #5).\nkeepDiagnostics(boundaryDiagnostics)\n\n/** The cell slots of `column:batch`. */\nexport type CellSlot = 'accessor' | 'format' | 'filterFn' | 'sortBy'\n\n/**\n * Per failed cell (§3.4): `''` (format) / `undefined` (accessor) / non-matching (filter fn) /\n * `undefined`, sorted last as a missing value (sortBy).\n */\nexport const CELL_FALLBACK = {\n  accessor: undefined,\n  format: '',\n  filterFn: false,\n  sortBy: undefined,\n} as const\n\n/** Prose keys (diagnostics/prose.ts) of each slot's fallback. */\nconst CELL_FALLBACK_TEXT: Record<CellSlot, string> = {\n  accessor: 'cells-undefined',\n  format: 'cells-empty',\n  filterFn: 'rows-unmatched',\n  sortBy: 'rows-last',\n}\n\n/**\n * Failures of one column's cells in one pipeline run, recorded as numbers (§3.4): a count, the\n * first `sample` row indices and the first error. No per-cell allocation; `where` and text are\n * built only in {@link CellFailures.report}. Reuse one instance per column across runs.\n */\nexport class CellFailures {\n  count = 0\n  private first: unknown\n  private readonly rows: Uint32Array\n\n  constructor(sample = 5) {\n    this.rows = new Uint32Array(sample)\n  }\n\n  add(row: number, error: unknown): void {\n    if (this.count === 0) this.first = error\n    if (this.count < this.rows.length) this.rows[this.count] = row\n    this.count++\n  }\n\n  /** The recorded sample of failing row indices (a view; valid until the next reset). */\n  sample(): Uint32Array {\n    return this.rows.subarray(0, Math.min(this.count, this.rows.length))\n  }\n\n  reset(): void {\n    this.count = 0\n    this.first = undefined\n  }\n\n  /**\n   * Emits one `DK_CALLBACK_FAILED` for this column (if any cell failed), then resets. `where` is the\n   * slot path `columns[<index>].<slot>`; `field` replaces the slot name in that path when the\n   * failing column field differs (`key` for a key column whose getter threw).\n   */\n  report(\n    emit: Emit,\n    columnIndex: number,\n    columnId: string,\n    slot: CellSlot,\n    options?: EmitOptions,\n    field: string = slot,\n  ): void {\n    if (this.count === 0) return\n    const name = errorName(this.first)\n    emit(\n      'DK_CALLBACK_FAILED',\n      {\n        slot: `columns[${columnIndex}].${field}`,\n        column: columnId,\n        rows: Array.from(this.sample()),\n        count: this.count,\n        fallback: CELL_FALLBACK_TEXT[slot],\n        ...(name === undefined ? {} : { errorName: name }),\n      },\n      { ...options, cause: this.first },\n    )\n    this.reset()\n  }\n}\n\n/**\n * The body of a `column:batch`: runs `cell` for each row in `rows` and writes `out[row]`. A throwing\n * cell gets `fallback` and is recorded in `failures` — the loop never throws per cell and never\n * dispatches an interceptor per cell. Call `failures.report(...)` once after the loop.\n */\nexport function runCells<R>(\n  rows: Uint32Array,\n  cell: (row: number) => R,\n  out: { [row: number]: R },\n  fallback: R,\n  failures: CellFailures,\n): void {\n  for (let i = 0; i < rows.length; i++) {\n    const row = rows[i] as number\n    try {\n      out[row] = cell(row)\n    } catch (e) {\n      out[row] = fallback\n      failures.add(row, e)\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAAgC;AAEhC,sBAA0B;AAC1B,mBAAoC;AAAA,IAIpC,gCAAgB,gCAAmB;AAS5B,IAAM,gBAAgB;AAAA,EAC3B,UAAU;AAAA,EACV,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,QAAQ;AACV;AAGA,IAAM,qBAA+C;AAAA,EACnD,UAAU;AAAA,EACV,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,QAAQ;AACV;AAOO,IAAM,eAAN,MAAmB;AAAA,EAKxB,YAAY,SAAS,GAAG;AAJxB,iBAAQ;AAKN,SAAK,OAAO,IAAI,YAAY,MAAM;AAAA,EACpC;AAAA,EAEA,IAAI,KAAa,OAAsB;AACrC,QAAI,KAAK,UAAU,EAAG,MAAK,QAAQ;AACnC,QAAI,KAAK,QAAQ,KAAK,KAAK,OAAQ,MAAK,KAAK,KAAK,KAAK,IAAI;AAC3D,SAAK;AAAA,EACP;AAAA;AAAA,EAGA,SAAsB;AACpB,WAAO,KAAK,KAAK,SAAS,GAAG,KAAK,IAAI,KAAK,OAAO,KAAK,KAAK,MAAM,CAAC;AAAA,EACrE;AAAA,EAEA,QAAc;AACZ,SAAK,QAAQ;AACb,SAAK,QAAQ;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OACE,MACA,aACA,UACA,MACA,SACA,QAAgB,MACV;AACN,QAAI,KAAK,UAAU,EAAG;AACtB,UAAM,WAAO,2BAAU,KAAK,KAAK;AACjC;AAAA,MACE;AAAA,MACA;AAAA,QACE,MAAM,WAAW,WAAW,KAAK,KAAK;AAAA,QACtC,QAAQ;AAAA,QACR,MAAM,MAAM,KAAK,KAAK,OAAO,CAAC;AAAA,QAC9B,OAAO,KAAK;AAAA,QACZ,UAAU,mBAAmB,IAAI;AAAA,QACjC,GAAI,SAAS,SAAY,CAAC,IAAI,EAAE,WAAW,KAAK;AAAA,MAClD;AAAA,MACA,EAAE,GAAG,SAAS,OAAO,KAAK,MAAM;AAAA,IAClC;AACA,SAAK,MAAM;AAAA,EACb;AACF;AAOO,SAAS,SACd,MACA,MACA,KACA,UACA,UACM;AACN,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,UAAM,MAAM,KAAK,CAAC;AAClB,QAAI;AACF,UAAI,GAAG,IAAI,KAAK,GAAG;AAAA,IACrB,SAAS,GAAG;AACV,UAAI,GAAG,IAAI;AACX,eAAS,IAAI,KAAK,CAAC;AAAA,IACrB;AAAA,EACF;AACF;","names":[]}

package/dist/intercept/cell-batch.js

@@ -10,10 +10,10 @@ var CELL_FALLBACK = {
   sortBy: void 0
 };
 var CELL_FALLBACK_TEXT = {
-  accessor: "the failed cells read as undefined",
-  format: "the failed cells render ''",
-  filterFn: "the failed rows are treated as non-matching",
-  sortBy: "the failed rows sort as missing values (last)"
+  accessor: "cells-undefined",
+  format: "cells-empty",
+  filterFn: "rows-unmatched",
+  sortBy: "rows-last"
 };
 var CellFailures = class {
   constructor(sample = 5) {

package/dist/intercept/cell-batch.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/intercept/cell-batch.ts"],"sourcesContent":["import { keepDiagnostics } from '../diagnostics/catalog'\nimport type { Emit, EmitOptions } from '../diagnostics/types'\nimport { errorName } from './classify'\nimport { boundaryDiagnostics } from './codes'\n\n// CellFailures emits DK_CALLBACK_FAILED: keep its definition wherever this module is bundled (a\n// feature entry alone brings the feature runtime, and with it the column cache, #5).\nkeepDiagnostics(boundaryDiagnostics)\n\n/** The cell slots of `column:batch`. */\nexport type CellSlot = 'accessor' | 'format' | 'filterFn' | 'sortBy'\n\n/**\n * Per failed cell (§3.4): `''` (format) / `undefined` (accessor) / non-matching (filter fn) /\n * `undefined`, sorted last as a missing value (sortBy).\n */\nexport const CELL_FALLBACK = {\n  accessor: undefined,\n  format: '',\n  filterFn: false,\n  sortBy: undefined,\n} as const\n\nconst CELL_FALLBACK_TEXT: Record<CellSlot, string> = {\n  accessor: 'the failed cells read as undefined',\n  format: \"the failed cells render ''\",\n  filterFn: 'the failed rows are treated as non-matching',\n  sortBy: 'the failed rows sort as missing values (last)',\n}\n\n/**\n * Failures of one column's cells in one pipeline run, recorded as numbers (§3.4): a count, the\n * first `sample` row indices and the first error. No per-cell allocation; `where` and text are\n * built only in {@link CellFailures.report}. Reuse one instance per column across runs.\n */\nexport class CellFailures {\n  count = 0\n  private first: unknown\n  private readonly rows: Uint32Array\n\n  constructor(sample = 5) {\n    this.rows = new Uint32Array(sample)\n  }\n\n  add(row: number, error: unknown): void {\n    if (this.count === 0) this.first = error\n    if (this.count < this.rows.length) this.rows[this.count] = row\n    this.count++\n  }\n\n  /** The recorded sample of failing row indices (a view; valid until the next reset). */\n  sample(): Uint32Array {\n    return this.rows.subarray(0, Math.min(this.count, this.rows.length))\n  }\n\n  reset(): void {\n    this.count = 0\n    this.first = undefined\n  }\n\n  /**\n   * Emits one `DK_CALLBACK_FAILED` for this column (if any cell failed), then resets. `where` is the\n   * slot path `columns[<index>].<slot>`; `field` replaces the slot name in that path when the\n   * failing column field differs (`key` for a key column whose getter threw).\n   */\n  report(\n    emit: Emit,\n    columnIndex: number,\n    columnId: string,\n    slot: CellSlot,\n    options?: EmitOptions,\n    field: string = slot,\n  ): void {\n    if (this.count === 0) return\n    const name = errorName(this.first)\n    emit(\n      'DK_CALLBACK_FAILED',\n      {\n        slot: `columns[${columnIndex}].${field}`,\n        column: columnId,\n        rows: Array.from(this.sample()),\n        count: this.count,\n        fallback: CELL_FALLBACK_TEXT[slot],\n        ...(name === undefined ? {} : { errorName: name }),\n      },\n      { ...options, cause: this.first },\n    )\n    this.reset()\n  }\n}\n\n/**\n * The body of a `column:batch`: runs `cell` for each row in `rows` and writes `out[row]`. A throwing\n * cell gets `fallback` and is recorded in `failures` — the loop never throws per cell and never\n * dispatches an interceptor per cell. Call `failures.report(...)` once after the loop.\n */\nexport function runCells<R>(\n  rows: Uint32Array,\n  cell: (row: number) => R,\n  out: { [row: number]: R },\n  fallback: R,\n  failures: CellFailures,\n): void {\n  for (let i = 0; i < rows.length; i++) {\n    const row = rows[i] as number\n    try {\n      out[row] = cell(row)\n    } catch (e) {\n      out[row] = fallback\n      failures.add(row, e)\n    }\n  }\n}\n"],"mappings":";AAAA,SAAS,uBAAuB;AAEhC,SAAS,iBAAiB;AAC1B,SAAS,2BAA2B;AAIpC,gBAAgB,mBAAmB;AAS5B,IAAM,gBAAgB;AAAA,EAC3B,UAAU;AAAA,EACV,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,QAAQ;AACV;AAEA,IAAM,qBAA+C;AAAA,EACnD,UAAU;AAAA,EACV,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,QAAQ;AACV;AAOO,IAAM,eAAN,MAAmB;AAAA,EAKxB,YAAY,SAAS,GAAG;AAJxB,iBAAQ;AAKN,SAAK,OAAO,IAAI,YAAY,MAAM;AAAA,EACpC;AAAA,EAEA,IAAI,KAAa,OAAsB;AACrC,QAAI,KAAK,UAAU,EAAG,MAAK,QAAQ;AACnC,QAAI,KAAK,QAAQ,KAAK,KAAK,OAAQ,MAAK,KAAK,KAAK,KAAK,IAAI;AAC3D,SAAK;AAAA,EACP;AAAA;AAAA,EAGA,SAAsB;AACpB,WAAO,KAAK,KAAK,SAAS,GAAG,KAAK,IAAI,KAAK,OAAO,KAAK,KAAK,MAAM,CAAC;AAAA,EACrE;AAAA,EAEA,QAAc;AACZ,SAAK,QAAQ;AACb,SAAK,QAAQ;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OACE,MACA,aACA,UACA,MACA,SACA,QAAgB,MACV;AACN,QAAI,KAAK,UAAU,EAAG;AACtB,UAAM,OAAO,UAAU,KAAK,KAAK;AACjC;AAAA,MACE;AAAA,MACA;AAAA,QACE,MAAM,WAAW,WAAW,KAAK,KAAK;AAAA,QACtC,QAAQ;AAAA,QACR,MAAM,MAAM,KAAK,KAAK,OAAO,CAAC;AAAA,QAC9B,OAAO,KAAK;AAAA,QACZ,UAAU,mBAAmB,IAAI;AAAA,QACjC,GAAI,SAAS,SAAY,CAAC,IAAI,EAAE,WAAW,KAAK;AAAA,MAClD;AAAA,MACA,EAAE,GAAG,SAAS,OAAO,KAAK,MAAM;AAAA,IAClC;AACA,SAAK,MAAM;AAAA,EACb;AACF;AAOO,SAAS,SACd,MACA,MACA,KACA,UACA,UACM;AACN,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,UAAM,MAAM,KAAK,CAAC;AAClB,QAAI;AACF,UAAI,GAAG,IAAI,KAAK,GAAG;AAAA,IACrB,SAAS,GAAG;AACV,UAAI,GAAG,IAAI;AACX,eAAS,IAAI,KAAK,CAAC;AAAA,IACrB;AAAA,EACF;AACF;","names":[]}
+{"version":3,"sources":["../../src/intercept/cell-batch.ts"],"sourcesContent":["import { keepDiagnostics } from '../diagnostics/catalog'\nimport type { Emit, EmitOptions } from '../diagnostics/types'\nimport { errorName } from './classify'\nimport { boundaryDiagnostics } from './codes'\n\n// CellFailures emits DK_CALLBACK_FAILED: keep its definition wherever this module is bundled (a\n// feature entry alone brings the feature runtime, and with it the column cache, #5).\nkeepDiagnostics(boundaryDiagnostics)\n\n/** The cell slots of `column:batch`. */\nexport type CellSlot = 'accessor' | 'format' | 'filterFn' | 'sortBy'\n\n/**\n * Per failed cell (§3.4): `''` (format) / `undefined` (accessor) / non-matching (filter fn) /\n * `undefined`, sorted last as a missing value (sortBy).\n */\nexport const CELL_FALLBACK = {\n  accessor: undefined,\n  format: '',\n  filterFn: false,\n  sortBy: undefined,\n} as const\n\n/** Prose keys (diagnostics/prose.ts) of each slot's fallback. */\nconst CELL_FALLBACK_TEXT: Record<CellSlot, string> = {\n  accessor: 'cells-undefined',\n  format: 'cells-empty',\n  filterFn: 'rows-unmatched',\n  sortBy: 'rows-last',\n}\n\n/**\n * Failures of one column's cells in one pipeline run, recorded as numbers (§3.4): a count, the\n * first `sample` row indices and the first error. No per-cell allocation; `where` and text are\n * built only in {@link CellFailures.report}. Reuse one instance per column across runs.\n */\nexport class CellFailures {\n  count = 0\n  private first: unknown\n  private readonly rows: Uint32Array\n\n  constructor(sample = 5) {\n    this.rows = new Uint32Array(sample)\n  }\n\n  add(row: number, error: unknown): void {\n    if (this.count === 0) this.first = error\n    if (this.count < this.rows.length) this.rows[this.count] = row\n    this.count++\n  }\n\n  /** The recorded sample of failing row indices (a view; valid until the next reset). */\n  sample(): Uint32Array {\n    return this.rows.subarray(0, Math.min(this.count, this.rows.length))\n  }\n\n  reset(): void {\n    this.count = 0\n    this.first = undefined\n  }\n\n  /**\n   * Emits one `DK_CALLBACK_FAILED` for this column (if any cell failed), then resets. `where` is the\n   * slot path `columns[<index>].<slot>`; `field` replaces the slot name in that path when the\n   * failing column field differs (`key` for a key column whose getter threw).\n   */\n  report(\n    emit: Emit,\n    columnIndex: number,\n    columnId: string,\n    slot: CellSlot,\n    options?: EmitOptions,\n    field: string = slot,\n  ): void {\n    if (this.count === 0) return\n    const name = errorName(this.first)\n    emit(\n      'DK_CALLBACK_FAILED',\n      {\n        slot: `columns[${columnIndex}].${field}`,\n        column: columnId,\n        rows: Array.from(this.sample()),\n        count: this.count,\n        fallback: CELL_FALLBACK_TEXT[slot],\n        ...(name === undefined ? {} : { errorName: name }),\n      },\n      { ...options, cause: this.first },\n    )\n    this.reset()\n  }\n}\n\n/**\n * The body of a `column:batch`: runs `cell` for each row in `rows` and writes `out[row]`. A throwing\n * cell gets `fallback` and is recorded in `failures` — the loop never throws per cell and never\n * dispatches an interceptor per cell. Call `failures.report(...)` once after the loop.\n */\nexport function runCells<R>(\n  rows: Uint32Array,\n  cell: (row: number) => R,\n  out: { [row: number]: R },\n  fallback: R,\n  failures: CellFailures,\n): void {\n  for (let i = 0; i < rows.length; i++) {\n    const row = rows[i] as number\n    try {\n      out[row] = cell(row)\n    } catch (e) {\n      out[row] = fallback\n      failures.add(row, e)\n    }\n  }\n}\n"],"mappings":";AAAA,SAAS,uBAAuB;AAEhC,SAAS,iBAAiB;AAC1B,SAAS,2BAA2B;AAIpC,gBAAgB,mBAAmB;AAS5B,IAAM,gBAAgB;AAAA,EAC3B,UAAU;AAAA,EACV,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,QAAQ;AACV;AAGA,IAAM,qBAA+C;AAAA,EACnD,UAAU;AAAA,EACV,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,QAAQ;AACV;AAOO,IAAM,eAAN,MAAmB;AAAA,EAKxB,YAAY,SAAS,GAAG;AAJxB,iBAAQ;AAKN,SAAK,OAAO,IAAI,YAAY,MAAM;AAAA,EACpC;AAAA,EAEA,IAAI,KAAa,OAAsB;AACrC,QAAI,KAAK,UAAU,EAAG,MAAK,QAAQ;AACnC,QAAI,KAAK,QAAQ,KAAK,KAAK,OAAQ,MAAK,KAAK,KAAK,KAAK,IAAI;AAC3D,SAAK;AAAA,EACP;AAAA;AAAA,EAGA,SAAsB;AACpB,WAAO,KAAK,KAAK,SAAS,GAAG,KAAK,IAAI,KAAK,OAAO,KAAK,KAAK,MAAM,CAAC;AAAA,EACrE;AAAA,EAEA,QAAc;AACZ,SAAK,QAAQ;AACb,SAAK,QAAQ;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OACE,MACA,aACA,UACA,MACA,SACA,QAAgB,MACV;AACN,QAAI,KAAK,UAAU,EAAG;AACtB,UAAM,OAAO,UAAU,KAAK,KAAK;AACjC;AAAA,MACE;AAAA,MACA;AAAA,QACE,MAAM,WAAW,WAAW,KAAK,KAAK;AAAA,QACtC,QAAQ;AAAA,QACR,MAAM,MAAM,KAAK,KAAK,OAAO,CAAC;AAAA,QAC9B,OAAO,KAAK;AAAA,QACZ,UAAU,mBAAmB,IAAI;AAAA,QACjC,GAAI,SAAS,SAAY,CAAC,IAAI,EAAE,WAAW,KAAK;AAAA,MAClD;AAAA,MACA,EAAE,GAAG,SAAS,OAAO,KAAK,MAAM;AAAA,IAClC;AACA,SAAK,MAAM;AAAA,EACb;AACF;AAOO,SAAS,SACd,MACA,MACA,KACA,UACA,UACM;AACN,WAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;AACpC,UAAM,MAAM,KAAK,CAAC;AAClB,QAAI;AACF,UAAI,GAAG,IAAI,KAAK,GAAG;AAAA,IACrB,SAAS,GAAG;AACV,UAAI,GAAG,IAAI;AACX,eAAS,IAAI,KAAK,CAAC;AAAA,IACrB;AAAA,EACF;AACF;","names":[]}

package/dist/intercept/codes.cjs

@@ -25,6 +25,7 @@ __export(codes_exports, {
 });
 module.exports = __toCommonJS(codes_exports);
 var import_catalog = require("../diagnostics/catalog.cjs");
+var import_process_guard = require("../diagnostics/process-guard.cjs");
 var rowList = (rows, count) => {
   if (!rows || rows.length === 0) return "";
   const list = rows.map((r) => `#${r}`).join(", ");

package/dist/intercept/codes.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/intercept/codes.ts"],"sourcesContent":["import { type DiagnosticMessages, defineDiagnostic } from '../diagnostics/catalog'\n\ndeclare module '../diagnostics/catalog' {\n  interface DiagnosticCatalog {\n    DK_CALLBACK_FAILED: {\n      /** The callback's option path, e.g. `columns[2].format`, `fetcher`, `searchFn`. */\n      slot: string\n      /**\n       * A callback passed to a method rather than set as an option: the method (`table.setState`);\n       * `slot` is then the argument (`updater`).\n       */\n      op?: string\n      /** Column id, for cell slots. */\n      column?: string\n      /** A sample of the failing row indices (first few, in order). */\n      rows?: readonly number[]\n      /** How many calls failed (cells in a column batch; 1 for a single call). */\n      count: number\n      /** The slot fallback that was applied. */\n      fallback: string\n      /** `error.name` only; the full error is `context.cause`. */\n      errorName?: string\n    }\n    DK_UNKNOWN: {\n      op: string\n      slot?: string\n      errorName?: string\n      fallback: string\n    }\n  }\n}\n\nconst rowList = (rows: readonly number[] | undefined, count: number) => {\n  if (!rows || rows.length === 0) return ''\n  const list = rows.map((r) => `#${r}`).join(', ')\n  return ` (${count > rows.length ? `first: ${list}, …` : `rows ${list}`})`\n}\n\n/** Message text (§8.2): development builds, or production via `@datakable/core/messages`. */\nexport const boundaryMessages: DiagnosticMessages<'DK_CALLBACK_FAILED' | 'DK_UNKNOWN'> = {\n  DK_CALLBACK_FAILED: {\n    problem: (d) =>\n      `${d.op === undefined ? '' : `${d.op}() `}${d.slot}${d.column === undefined ? '' : ` (column \"${d.column}\")`} threw` +\n      `${d.errorName ? ` ${d.errorName}` : ''} for ` +\n      `${d.count === 1 ? '1 row' : `${d.count} rows`}${rowList(d.rows, d.count)}`,\n    impact: (d) => `${d.fallback}; the rest of the table is unaffected`,\n    fix: (d) => [\n      `make ${d.op === undefined ? d.slot : `the ${d.slot} passed to ${d.op}()`} total: guard null / undefined / unexpected types and return a fallback ` +\n        'instead of throwing',\n      d.rows && d.rows.length > 0\n        ? `reproduce with table.explainRow() on row #${d.rows[0]}; the original error is context.cause`\n        : 'the original error is context.cause (passed to onDiagnostic)',\n    ],\n  },\n  DK_UNKNOWN: {\n    problem: (d) =>\n      `${d.errorName ?? 'a non-Error value'} was thrown during ${d.op}` +\n      `${d.slot ? ` at ${d.slot}` : ''} from code DataKable could not classify`,\n    impact: (d) => `${d.fallback}; the table keeps working`,\n    fix: (d) => [\n      'inspect context.cause (passed to onDiagnostic) for the original error and its stack',\n      `if your code runs inside ${d.op} (a callback, interceptor or plugin), catch errors there ` +\n        'and return a fallback',\n      'if the stack points into DataKable, report it as a bug',\n    ],\n  },\n}\n\n/** Codes owned by the errorBoundary (spec §3.4, §8.3, §8.6). `DK_INTERNAL` lives in diagnostics/codes.ts. */\nexport const boundaryDiagnostics = [\n  defineDiagnostic(\n    {\n      code: 'DK_CALLBACK_FAILED',\n      level: 'error',\n      where: (d) =>\n        d.op === undefined\n          ? { kind: 'option', path: d.slot }\n          : { kind: 'operation', op: d.op, slot: d.slot },\n    },\n    (process.env.NODE_ENV !== \"production\") && boundaryMessages.DK_CALLBACK_FAILED,\n  ),\n  defineDiagnostic(\n    {\n      code: 'DK_UNKNOWN',\n      level: 'error',\n      where: (d) =>\n        d.slot ? { kind: 'operation', op: d.op, slot: d.slot } : { kind: 'operation', op: d.op },\n    },\n    (process.env.NODE_ENV !== \"production\") && boundaryMessages.DK_UNKNOWN,\n  ),\n]\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAA0D;AAgC1D,IAAM,UAAU,CAAC,MAAqC,UAAkB;AACtE,MAAI,CAAC,QAAQ,KAAK,WAAW,EAAG,QAAO;AACvC,QAAM,OAAO,KAAK,IAAI,CAAC,MAAM,IAAI,CAAC,EAAE,EAAE,KAAK,IAAI;AAC/C,SAAO,KAAK,QAAQ,KAAK,SAAS,UAAU,IAAI,aAAQ,QAAQ,IAAI,EAAE;AACxE;AAGO,IAAM,mBAA4E;AAAA,EACvF,oBAAoB;AAAA,IAClB,SAAS,CAAC,MACR,GAAG,EAAE,OAAO,SAAY,KAAK,GAAG,EAAE,EAAE,KAAK,GAAG,EAAE,IAAI,GAAG,EAAE,WAAW,SAAY,KAAK,aAAa,EAAE,MAAM,IAAI,SACzG,EAAE,YAAY,IAAI,EAAE,SAAS,KAAK,EAAE,QACpC,EAAE,UAAU,IAAI,UAAU,GAAG,EAAE,KAAK,OAAO,GAAG,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC;AAAA,IAC3E,QAAQ,CAAC,MAAM,GAAG,EAAE,QAAQ;AAAA,IAC5B,KAAK,CAAC,MAAM;AAAA,MACV,QAAQ,EAAE,OAAO,SAAY,EAAE,OAAO,OAAO,EAAE,IAAI,cAAc,EAAE,EAAE,IAAI;AAAA,MAEzE,EAAE,QAAQ,EAAE,KAAK,SAAS,IACtB,6CAA6C,EAAE,KAAK,CAAC,CAAC,0CACtD;AAAA,IACN;AAAA,EACF;AAAA,EACA,YAAY;AAAA,IACV,SAAS,CAAC,MACR,GAAG,EAAE,aAAa,mBAAmB,sBAAsB,EAAE,EAAE,GAC5D,EAAE,OAAO,OAAO,EAAE,IAAI,KAAK,EAAE;AAAA,IAClC,QAAQ,CAAC,MAAM,GAAG,EAAE,QAAQ;AAAA,IAC5B,KAAK,CAAC,MAAM;AAAA,MACV;AAAA,MACA,4BAA4B,EAAE,EAAE;AAAA,MAEhC;AAAA,IACF;AAAA,EACF;AACF;AAGO,IAAM,sBAAsB;AAAA,MACjC;AAAA,IACE;AAAA,MACE,MAAM;AAAA,MACN,OAAO;AAAA,MACP,OAAO,CAAC,MACN,EAAE,OAAO,SACL,EAAE,MAAM,UAAU,MAAM,EAAE,KAAK,IAC/B,EAAE,MAAM,aAAa,IAAI,EAAE,IAAI,MAAM,EAAE,KAAK;AAAA,IACpD;AAAA,IACC,QAAQ,IAAI,aAAa,gBAAiB,iBAAiB;AAAA,EAC9D;AAAA,MACA;AAAA,IACE;AAAA,MACE,MAAM;AAAA,MACN,OAAO;AAAA,MACP,OAAO,CAAC,MACN,EAAE,OAAO,EAAE,MAAM,aAAa,IAAI,EAAE,IAAI,MAAM,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,IAAI,EAAE,GAAG;AAAA,IAC3F;AAAA,IACC,QAAQ,IAAI,aAAa,gBAAiB,iBAAiB;AAAA,EAC9D;AACF;","names":[]}
+{"version":3,"sources":["../../src/intercept/codes.ts"],"sourcesContent":["import { type DiagnosticMessages, defineDiagnostic } from '../diagnostics/catalog'\nimport '../diagnostics/process-guard'\n\ndeclare module '../diagnostics/catalog' {\n  interface DiagnosticCatalog {\n    DK_CALLBACK_FAILED: {\n      /** The callback's option path, e.g. `columns[2].format`, `fetcher`, `searchFn`. */\n      slot: string\n      /**\n       * A callback passed to a method rather than set as an option: the method (`table.setState`);\n       * `slot` is then the argument (`updater`).\n       */\n      op?: string\n      /** Column id, for cell slots. */\n      column?: string\n      /** A sample of the failing row indices (first few, in order). */\n      rows?: readonly number[]\n      /** How many calls failed (cells in a column batch; 1 for a single call). */\n      count: number\n      /** The slot fallback that was applied. */\n      fallback: string\n      /** `error.name` only; the full error is `context.cause`. */\n      errorName?: string\n    }\n    DK_UNKNOWN: {\n      op: string\n      slot?: string\n      errorName?: string\n      fallback: string\n    }\n  }\n}\n\nconst rowList = (rows: readonly number[] | undefined, count: number) => {\n  if (!rows || rows.length === 0) return ''\n  const list = rows.map((r) => `#${r}`).join(', ')\n  return ` (${count > rows.length ? `first: ${list}, …` : `rows ${list}`})`\n}\n\n/** Message text (§8.2): development builds, or production via `@datakable/core/messages`. */\nexport const boundaryMessages: DiagnosticMessages<'DK_CALLBACK_FAILED' | 'DK_UNKNOWN'> = {\n  DK_CALLBACK_FAILED: {\n    problem: (d) =>\n      `${d.op === undefined ? '' : `${d.op}() `}${d.slot}${d.column === undefined ? '' : ` (column \"${d.column}\")`} threw` +\n      `${d.errorName ? ` ${d.errorName}` : ''} for ` +\n      `${d.count === 1 ? '1 row' : `${d.count} rows`}${rowList(d.rows, d.count)}`,\n    impact: (d) => `${d.fallback}; the rest of the table is unaffected`,\n    fix: (d) => [\n      `make ${d.op === undefined ? d.slot : `the ${d.slot} passed to ${d.op}()`} total: guard null / undefined / unexpected types and return a fallback ` +\n        'instead of throwing',\n      d.rows && d.rows.length > 0\n        ? `reproduce with table.explainRow() on row #${d.rows[0]}; the original error is context.cause`\n        : 'the original error is context.cause (passed to onDiagnostic)',\n    ],\n  },\n  DK_UNKNOWN: {\n    problem: (d) =>\n      `${d.errorName ?? 'a non-Error value'} was thrown during ${d.op}` +\n      `${d.slot ? ` at ${d.slot}` : ''} from code DataKable could not classify`,\n    impact: (d) => `${d.fallback}; the table keeps working`,\n    fix: (d) => [\n      'inspect context.cause (passed to onDiagnostic) for the original error and its stack',\n      `if your code runs inside ${d.op} (a callback, interceptor or plugin), catch errors there ` +\n        'and return a fallback',\n      'if the stack points into DataKable, report it as a bug',\n    ],\n  },\n}\n\n/** Codes owned by the errorBoundary (spec §3.4, §8.3, §8.6). `DK_INTERNAL` lives in diagnostics/codes.ts. */\nexport const boundaryDiagnostics = [\n  defineDiagnostic(\n    {\n      code: 'DK_CALLBACK_FAILED',\n      level: 'error',\n      where: (d) =>\n        d.op === undefined\n          ? { kind: 'option', path: d.slot }\n          : { kind: 'operation', op: d.op, slot: d.slot },\n    },\n    (process.env.NODE_ENV !== \"production\") && boundaryMessages.DK_CALLBACK_FAILED,\n  ),\n  defineDiagnostic(\n    {\n      code: 'DK_UNKNOWN',\n      level: 'error',\n      where: (d) =>\n        d.slot ? { kind: 'operation', op: d.op, slot: d.slot } : { kind: 'operation', op: d.op },\n    },\n    (process.env.NODE_ENV !== \"production\") && boundaryMessages.DK_UNKNOWN,\n  ),\n]\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAA0D;AAC1D,2BAAO;AAgCP,IAAM,UAAU,CAAC,MAAqC,UAAkB;AACtE,MAAI,CAAC,QAAQ,KAAK,WAAW,EAAG,QAAO;AACvC,QAAM,OAAO,KAAK,IAAI,CAAC,MAAM,IAAI,CAAC,EAAE,EAAE,KAAK,IAAI;AAC/C,SAAO,KAAK,QAAQ,KAAK,SAAS,UAAU,IAAI,aAAQ,QAAQ,IAAI,EAAE;AACxE;AAGO,IAAM,mBAA4E;AAAA,EACvF,oBAAoB;AAAA,IAClB,SAAS,CAAC,MACR,GAAG,EAAE,OAAO,SAAY,KAAK,GAAG,EAAE,EAAE,KAAK,GAAG,EAAE,IAAI,GAAG,EAAE,WAAW,SAAY,KAAK,aAAa,EAAE,MAAM,IAAI,SACzG,EAAE,YAAY,IAAI,EAAE,SAAS,KAAK,EAAE,QACpC,EAAE,UAAU,IAAI,UAAU,GAAG,EAAE,KAAK,OAAO,GAAG,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC;AAAA,IAC3E,QAAQ,CAAC,MAAM,GAAG,EAAE,QAAQ;AAAA,IAC5B,KAAK,CAAC,MAAM;AAAA,MACV,QAAQ,EAAE,OAAO,SAAY,EAAE,OAAO,OAAO,EAAE,IAAI,cAAc,EAAE,EAAE,IAAI;AAAA,MAEzE,EAAE,QAAQ,EAAE,KAAK,SAAS,IACtB,6CAA6C,EAAE,KAAK,CAAC,CAAC,0CACtD;AAAA,IACN;AAAA,EACF;AAAA,EACA,YAAY;AAAA,IACV,SAAS,CAAC,MACR,GAAG,EAAE,aAAa,mBAAmB,sBAAsB,EAAE,EAAE,GAC5D,EAAE,OAAO,OAAO,EAAE,IAAI,KAAK,EAAE;AAAA,IAClC,QAAQ,CAAC,MAAM,GAAG,EAAE,QAAQ;AAAA,IAC5B,KAAK,CAAC,MAAM;AAAA,MACV;AAAA,MACA,4BAA4B,EAAE,EAAE;AAAA,MAEhC;AAAA,IACF;AAAA,EACF;AACF;AAGO,IAAM,sBAAsB;AAAA,MACjC;AAAA,IACE;AAAA,MACE,MAAM;AAAA,MACN,OAAO;AAAA,MACP,OAAO,CAAC,MACN,EAAE,OAAO,SACL,EAAE,MAAM,UAAU,MAAM,EAAE,KAAK,IAC/B,EAAE,MAAM,aAAa,IAAI,EAAE,IAAI,MAAM,EAAE,KAAK;AAAA,IACpD;AAAA,IACC,QAAQ,IAAI,aAAa,gBAAiB,iBAAiB;AAAA,EAC9D;AAAA,MACA;AAAA,IACE;AAAA,MACE,MAAM;AAAA,MACN,OAAO;AAAA,MACP,OAAO,CAAC,MACN,EAAE,OAAO,EAAE,MAAM,aAAa,IAAI,EAAE,IAAI,MAAM,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,IAAI,EAAE,GAAG;AAAA,IAC3F;AAAA,IACC,QAAQ,IAAI,aAAa,gBAAiB,iBAAiB;AAAA,EAC9D;AACF;","names":[]}

package/dist/intercept/codes.js

@@ -1,5 +1,6 @@
 // src/intercept/codes.ts
 import { defineDiagnostic } from "../diagnostics/catalog.js";
+import "../diagnostics/process-guard.js";
 var rowList = (rows, count) => {
   if (!rows || rows.length === 0) return "";
   const list = rows.map((r) => `#${r}`).join(", ");

package/dist/intercept/codes.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/intercept/codes.ts"],"sourcesContent":["import { type DiagnosticMessages, defineDiagnostic } from '../diagnostics/catalog'\n\ndeclare module '../diagnostics/catalog' {\n  interface DiagnosticCatalog {\n    DK_CALLBACK_FAILED: {\n      /** The callback's option path, e.g. `columns[2].format`, `fetcher`, `searchFn`. */\n      slot: string\n      /**\n       * A callback passed to a method rather than set as an option: the method (`table.setState`);\n       * `slot` is then the argument (`updater`).\n       */\n      op?: string\n      /** Column id, for cell slots. */\n      column?: string\n      /** A sample of the failing row indices (first few, in order). */\n      rows?: readonly number[]\n      /** How many calls failed (cells in a column batch; 1 for a single call). */\n      count: number\n      /** The slot fallback that was applied. */\n      fallback: string\n      /** `error.name` only; the full error is `context.cause`. */\n      errorName?: string\n    }\n    DK_UNKNOWN: {\n      op: string\n      slot?: string\n      errorName?: string\n      fallback: string\n    }\n  }\n}\n\nconst rowList = (rows: readonly number[] | undefined, count: number) => {\n  if (!rows || rows.length === 0) return ''\n  const list = rows.map((r) => `#${r}`).join(', ')\n  return ` (${count > rows.length ? `first: ${list}, …` : `rows ${list}`})`\n}\n\n/** Message text (§8.2): development builds, or production via `@datakable/core/messages`. */\nexport const boundaryMessages: DiagnosticMessages<'DK_CALLBACK_FAILED' | 'DK_UNKNOWN'> = {\n  DK_CALLBACK_FAILED: {\n    problem: (d) =>\n      `${d.op === undefined ? '' : `${d.op}() `}${d.slot}${d.column === undefined ? '' : ` (column \"${d.column}\")`} threw` +\n      `${d.errorName ? ` ${d.errorName}` : ''} for ` +\n      `${d.count === 1 ? '1 row' : `${d.count} rows`}${rowList(d.rows, d.count)}`,\n    impact: (d) => `${d.fallback}; the rest of the table is unaffected`,\n    fix: (d) => [\n      `make ${d.op === undefined ? d.slot : `the ${d.slot} passed to ${d.op}()`} total: guard null / undefined / unexpected types and return a fallback ` +\n        'instead of throwing',\n      d.rows && d.rows.length > 0\n        ? `reproduce with table.explainRow() on row #${d.rows[0]}; the original error is context.cause`\n        : 'the original error is context.cause (passed to onDiagnostic)',\n    ],\n  },\n  DK_UNKNOWN: {\n    problem: (d) =>\n      `${d.errorName ?? 'a non-Error value'} was thrown during ${d.op}` +\n      `${d.slot ? ` at ${d.slot}` : ''} from code DataKable could not classify`,\n    impact: (d) => `${d.fallback}; the table keeps working`,\n    fix: (d) => [\n      'inspect context.cause (passed to onDiagnostic) for the original error and its stack',\n      `if your code runs inside ${d.op} (a callback, interceptor or plugin), catch errors there ` +\n        'and return a fallback',\n      'if the stack points into DataKable, report it as a bug',\n    ],\n  },\n}\n\n/** Codes owned by the errorBoundary (spec §3.4, §8.3, §8.6). `DK_INTERNAL` lives in diagnostics/codes.ts. */\nexport const boundaryDiagnostics = [\n  defineDiagnostic(\n    {\n      code: 'DK_CALLBACK_FAILED',\n      level: 'error',\n      where: (d) =>\n        d.op === undefined\n          ? { kind: 'option', path: d.slot }\n          : { kind: 'operation', op: d.op, slot: d.slot },\n    },\n    (process.env.NODE_ENV !== \"production\") && boundaryMessages.DK_CALLBACK_FAILED,\n  ),\n  defineDiagnostic(\n    {\n      code: 'DK_UNKNOWN',\n      level: 'error',\n      where: (d) =>\n        d.slot ? { kind: 'operation', op: d.op, slot: d.slot } : { kind: 'operation', op: d.op },\n    },\n    (process.env.NODE_ENV !== \"production\") && boundaryMessages.DK_UNKNOWN,\n  ),\n]\n"],"mappings":";AAAA,SAAkC,wBAAwB;AAgC1D,IAAM,UAAU,CAAC,MAAqC,UAAkB;AACtE,MAAI,CAAC,QAAQ,KAAK,WAAW,EAAG,QAAO;AACvC,QAAM,OAAO,KAAK,IAAI,CAAC,MAAM,IAAI,CAAC,EAAE,EAAE,KAAK,IAAI;AAC/C,SAAO,KAAK,QAAQ,KAAK,SAAS,UAAU,IAAI,aAAQ,QAAQ,IAAI,EAAE;AACxE;AAGO,IAAM,mBAA4E;AAAA,EACvF,oBAAoB;AAAA,IAClB,SAAS,CAAC,MACR,GAAG,EAAE,OAAO,SAAY,KAAK,GAAG,EAAE,EAAE,KAAK,GAAG,EAAE,IAAI,GAAG,EAAE,WAAW,SAAY,KAAK,aAAa,EAAE,MAAM,IAAI,SACzG,EAAE,YAAY,IAAI,EAAE,SAAS,KAAK,EAAE,QACpC,EAAE,UAAU,IAAI,UAAU,GAAG,EAAE,KAAK,OAAO,GAAG,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC;AAAA,IAC3E,QAAQ,CAAC,MAAM,GAAG,EAAE,QAAQ;AAAA,IAC5B,KAAK,CAAC,MAAM;AAAA,MACV,QAAQ,EAAE,OAAO,SAAY,EAAE,OAAO,OAAO,EAAE,IAAI,cAAc,EAAE,EAAE,IAAI;AAAA,MAEzE,EAAE,QAAQ,EAAE,KAAK,SAAS,IACtB,6CAA6C,EAAE,KAAK,CAAC,CAAC,0CACtD;AAAA,IACN;AAAA,EACF;AAAA,EACA,YAAY;AAAA,IACV,SAAS,CAAC,MACR,GAAG,EAAE,aAAa,mBAAmB,sBAAsB,EAAE,EAAE,GAC5D,EAAE,OAAO,OAAO,EAAE,IAAI,KAAK,EAAE;AAAA,IAClC,QAAQ,CAAC,MAAM,GAAG,EAAE,QAAQ;AAAA,IAC5B,KAAK,CAAC,MAAM;AAAA,MACV;AAAA,MACA,4BAA4B,EAAE,EAAE;AAAA,MAEhC;AAAA,IACF;AAAA,EACF;AACF;AAGO,IAAM,sBAAsB;AAAA,EACjC;AAAA,IACE;AAAA,MACE,MAAM;AAAA,MACN,OAAO;AAAA,MACP,OAAO,CAAC,MACN,EAAE,OAAO,SACL,EAAE,MAAM,UAAU,MAAM,EAAE,KAAK,IAC/B,EAAE,MAAM,aAAa,IAAI,EAAE,IAAI,MAAM,EAAE,KAAK;AAAA,IACpD;AAAA,IACC,QAAQ,IAAI,aAAa,gBAAiB,iBAAiB;AAAA,EAC9D;AAAA,EACA;AAAA,IACE;AAAA,MACE,MAAM;AAAA,MACN,OAAO;AAAA,MACP,OAAO,CAAC,MACN,EAAE,OAAO,EAAE,MAAM,aAAa,IAAI,EAAE,IAAI,MAAM,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,IAAI,EAAE,GAAG;AAAA,IAC3F;AAAA,IACC,QAAQ,IAAI,aAAa,gBAAiB,iBAAiB;AAAA,EAC9D;AACF;","names":[]}
+{"version":3,"sources":["../../src/intercept/codes.ts"],"sourcesContent":["import { type DiagnosticMessages, defineDiagnostic } from '../diagnostics/catalog'\nimport '../diagnostics/process-guard'\n\ndeclare module '../diagnostics/catalog' {\n  interface DiagnosticCatalog {\n    DK_CALLBACK_FAILED: {\n      /** The callback's option path, e.g. `columns[2].format`, `fetcher`, `searchFn`. */\n      slot: string\n      /**\n       * A callback passed to a method rather than set as an option: the method (`table.setState`);\n       * `slot` is then the argument (`updater`).\n       */\n      op?: string\n      /** Column id, for cell slots. */\n      column?: string\n      /** A sample of the failing row indices (first few, in order). */\n      rows?: readonly number[]\n      /** How many calls failed (cells in a column batch; 1 for a single call). */\n      count: number\n      /** The slot fallback that was applied. */\n      fallback: string\n      /** `error.name` only; the full error is `context.cause`. */\n      errorName?: string\n    }\n    DK_UNKNOWN: {\n      op: string\n      slot?: string\n      errorName?: string\n      fallback: string\n    }\n  }\n}\n\nconst rowList = (rows: readonly number[] | undefined, count: number) => {\n  if (!rows || rows.length === 0) return ''\n  const list = rows.map((r) => `#${r}`).join(', ')\n  return ` (${count > rows.length ? `first: ${list}, …` : `rows ${list}`})`\n}\n\n/** Message text (§8.2): development builds, or production via `@datakable/core/messages`. */\nexport const boundaryMessages: DiagnosticMessages<'DK_CALLBACK_FAILED' | 'DK_UNKNOWN'> = {\n  DK_CALLBACK_FAILED: {\n    problem: (d) =>\n      `${d.op === undefined ? '' : `${d.op}() `}${d.slot}${d.column === undefined ? '' : ` (column \"${d.column}\")`} threw` +\n      `${d.errorName ? ` ${d.errorName}` : ''} for ` +\n      `${d.count === 1 ? '1 row' : `${d.count} rows`}${rowList(d.rows, d.count)}`,\n    impact: (d) => `${d.fallback}; the rest of the table is unaffected`,\n    fix: (d) => [\n      `make ${d.op === undefined ? d.slot : `the ${d.slot} passed to ${d.op}()`} total: guard null / undefined / unexpected types and return a fallback ` +\n        'instead of throwing',\n      d.rows && d.rows.length > 0\n        ? `reproduce with table.explainRow() on row #${d.rows[0]}; the original error is context.cause`\n        : 'the original error is context.cause (passed to onDiagnostic)',\n    ],\n  },\n  DK_UNKNOWN: {\n    problem: (d) =>\n      `${d.errorName ?? 'a non-Error value'} was thrown during ${d.op}` +\n      `${d.slot ? ` at ${d.slot}` : ''} from code DataKable could not classify`,\n    impact: (d) => `${d.fallback}; the table keeps working`,\n    fix: (d) => [\n      'inspect context.cause (passed to onDiagnostic) for the original error and its stack',\n      `if your code runs inside ${d.op} (a callback, interceptor or plugin), catch errors there ` +\n        'and return a fallback',\n      'if the stack points into DataKable, report it as a bug',\n    ],\n  },\n}\n\n/** Codes owned by the errorBoundary (spec §3.4, §8.3, §8.6). `DK_INTERNAL` lives in diagnostics/codes.ts. */\nexport const boundaryDiagnostics = [\n  defineDiagnostic(\n    {\n      code: 'DK_CALLBACK_FAILED',\n      level: 'error',\n      where: (d) =>\n        d.op === undefined\n          ? { kind: 'option', path: d.slot }\n          : { kind: 'operation', op: d.op, slot: d.slot },\n    },\n    (process.env.NODE_ENV !== \"production\") && boundaryMessages.DK_CALLBACK_FAILED,\n  ),\n  defineDiagnostic(\n    {\n      code: 'DK_UNKNOWN',\n      level: 'error',\n      where: (d) =>\n        d.slot ? { kind: 'operation', op: d.op, slot: d.slot } : { kind: 'operation', op: d.op },\n    },\n    (process.env.NODE_ENV !== \"production\") && boundaryMessages.DK_UNKNOWN,\n  ),\n]\n"],"mappings":";AAAA,SAAkC,wBAAwB;AAC1D,OAAO;AAgCP,IAAM,UAAU,CAAC,MAAqC,UAAkB;AACtE,MAAI,CAAC,QAAQ,KAAK,WAAW,EAAG,QAAO;AACvC,QAAM,OAAO,KAAK,IAAI,CAAC,MAAM,IAAI,CAAC,EAAE,EAAE,KAAK,IAAI;AAC/C,SAAO,KAAK,QAAQ,KAAK,SAAS,UAAU,IAAI,aAAQ,QAAQ,IAAI,EAAE;AACxE;AAGO,IAAM,mBAA4E;AAAA,EACvF,oBAAoB;AAAA,IAClB,SAAS,CAAC,MACR,GAAG,EAAE,OAAO,SAAY,KAAK,GAAG,EAAE,EAAE,KAAK,GAAG,EAAE,IAAI,GAAG,EAAE,WAAW,SAAY,KAAK,aAAa,EAAE,MAAM,IAAI,SACzG,EAAE,YAAY,IAAI,EAAE,SAAS,KAAK,EAAE,QACpC,EAAE,UAAU,IAAI,UAAU,GAAG,EAAE,KAAK,OAAO,GAAG,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC;AAAA,IAC3E,QAAQ,CAAC,MAAM,GAAG,EAAE,QAAQ;AAAA,IAC5B,KAAK,CAAC,MAAM;AAAA,MACV,QAAQ,EAAE,OAAO,SAAY,EAAE,OAAO,OAAO,EAAE,IAAI,cAAc,EAAE,EAAE,IAAI;AAAA,MAEzE,EAAE,QAAQ,EAAE,KAAK,SAAS,IACtB,6CAA6C,EAAE,KAAK,CAAC,CAAC,0CACtD;AAAA,IACN;AAAA,EACF;AAAA,EACA,YAAY;AAAA,IACV,SAAS,CAAC,MACR,GAAG,EAAE,aAAa,mBAAmB,sBAAsB,EAAE,EAAE,GAC5D,EAAE,OAAO,OAAO,EAAE,IAAI,KAAK,EAAE;AAAA,IAClC,QAAQ,CAAC,MAAM,GAAG,EAAE,QAAQ;AAAA,IAC5B,KAAK,CAAC,MAAM;AAAA,MACV;AAAA,MACA,4BAA4B,EAAE,EAAE;AAAA,MAEhC;AAAA,IACF;AAAA,EACF;AACF;AAGO,IAAM,sBAAsB;AAAA,EACjC;AAAA,IACE;AAAA,MACE,MAAM;AAAA,MACN,OAAO;AAAA,MACP,OAAO,CAAC,MACN,EAAE,OAAO,SACL,EAAE,MAAM,UAAU,MAAM,EAAE,KAAK,IAC/B,EAAE,MAAM,aAAa,IAAI,EAAE,IAAI,MAAM,EAAE,KAAK;AAAA,IACpD;AAAA,IACC,QAAQ,IAAI,aAAa,gBAAiB,iBAAiB;AAAA,EAC9D;AAAA,EACA;AAAA,IACE;AAAA,MACE,MAAM;AAAA,MACN,OAAO;AAAA,MACP,OAAO,CAAC,MACN,EAAE,OAAO,EAAE,MAAM,aAAa,IAAI,EAAE,IAAI,MAAM,EAAE,KAAK,IAAI,EAAE,MAAM,aAAa,IAAI,EAAE,GAAG;AAAA,IAC3F;AAAA,IACC,QAAQ,IAAI,aAAa,gBAAiB,iBAAiB;AAAA,EAC9D;AACF;","names":[]}

package/dist/intercept/fallbacks.cjs

@@ -34,46 +34,38 @@ function allRows(n) {
   return out;
 }
 var builtins = {
-  "table:init": {
-    describe: "table creation continued without the failed step",
-    value: () => void 0
-  },
-  "table:setOptions": { describe: "the previous options were kept", value: () => void 0 },
-  "table:destroy": {
-    describe: "teardown continued; the table is destroyed",
-    value: () => void 0
-  },
-  "state:dispatch": {
-    describe: "the update was dropped (state unchanged)",
-    value: () => void 0
-  },
+  // `describe`: prose keys (diagnostics/prose.ts); a plugin's own fallback may use plain text.
+  "table:init": { describe: "init-continued", value: () => void 0 },
+  "table:setOptions": { describe: "options-kept", value: () => void 0 },
+  "table:destroy": { describe: "destroy-continued", value: () => void 0 },
+  "state:dispatch": { describe: "update-dropped", value: () => void 0 },
   "data:ingest": {
-    describe: "the previous data was kept",
+    describe: "data-kept",
     value: (ctx) => ctx.meta.get(FALLBACK) ?? []
   },
   "pipeline:run": {
-    describe: "the last good row model was kept",
+    describe: "row-model-kept",
     value: (ctx) => ctx.meta.get(FALLBACK) ?? allRows(ctx.input.rowCount)
   },
   "pipeline:step": {
-    describe: "the step passed its input through",
+    describe: "step-passthrough",
     value: (ctx) => ctx.input.indices
   },
   "column:batch": {
-    describe: "the column's cells use the slot fallback ('' for format, undefined for accessor, non-matching for filterFn, missing (sorted last) for sortBy)",
+    describe: "batch-fallback",
     value: () => void 0
   },
   "async:request": {
-    describe: "the previous results were kept (status: 'error')",
+    describe: "results-kept",
     value: (ctx) => Promise.resolve(ctx.meta.get(FALLBACK))
   },
   "diagnostic:emit": {
-    describe: "the diagnostic was dropped (the logger never kills the table)",
+    describe: "diagnostic-dropped",
     silent: true,
     value: () => void 0
   }
 };
-var NONE = { describe: "the operation returned undefined", value: () => void 0 };
+var NONE = { describe: "returned-undefined", value: () => void 0 };
 var registry = new Map(Object.entries(builtins));
 function registerFallback(op, fallback) {
   registry.set(op, fallback);

package/dist/intercept/fallbacks.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/intercept/fallbacks.ts"],"sourcesContent":["import type { InterceptorContext } from './context'\nimport type { BuiltinOperations, OpName, OpResult } from './operations'\n\n/**\n * What the errorBoundary returns when an op fails (§3.4 registry table). `describe` becomes the\n * diagnostic's `impact`.\n */\nexport interface Fallback<O extends OpName = OpName> {\n  readonly describe: string\n  /**\n   * Report without the diagnostics pipeline: one `console.error` per table. Used by\n   * `diagnostic:emit`, where reporting through the pipeline could recurse.\n   */\n  readonly silent?: boolean\n  value(ctx: InterceptorContext<O>): OpResult<O>\n}\n\n/**\n * `ctx.meta` key for a caller-supplied fallback value: the previous data (`data:ingest`), the last\n * good row model (`pipeline:run`), the previous results (`async:request`). Set it before `run`.\n */\nexport const FALLBACK = 'datakable:fallback'\n\n/**\n * `ctx.meta` key the errorBoundary sets (to the error) when it replaced the op's result with the\n * fallback, so the caller can tell a fallback from a real result (e.g. a failed `data:ingest` sets\n * `status: 'error'`, §6.6).\n */\nexport const FAILED = 'datakable:failed'\n\nfunction allRows(n: number): Uint32Array {\n  const out = new Uint32Array(n)\n  for (let i = 0; i < n; i++) out[i] = i\n  return out\n}\n\nconst builtins: { [K in keyof BuiltinOperations]: Fallback<K> } = {\n  'table:init': {\n    describe: 'table creation continued without the failed step',\n    value: () => undefined,\n  },\n  'table:setOptions': { describe: 'the previous options were kept', value: () => undefined },\n  'table:destroy': {\n    describe: 'teardown continued; the table is destroyed',\n    value: () => undefined,\n  },\n  'state:dispatch': {\n    describe: 'the update was dropped (state unchanged)',\n    value: () => undefined,\n  },\n  'data:ingest': {\n    describe: 'the previous data was kept',\n    value: (ctx) => (ctx.meta.get(FALLBACK) as readonly unknown[] | undefined) ?? [],\n  },\n  'pipeline:run': {\n    describe: 'the last good row model was kept',\n    value: (ctx) =>\n      (ctx.meta.get(FALLBACK) as Uint32Array | undefined) ?? allRows(ctx.input.rowCount),\n  },\n  'pipeline:step': {\n    describe: 'the step passed its input through',\n    value: (ctx) => ctx.input.indices,\n  },\n  'column:batch': {\n    describe:\n      \"the column's cells use the slot fallback ('' for format, undefined for accessor, \" +\n      'non-matching for filterFn, missing (sorted last) for sortBy)',\n    value: () => undefined,\n  },\n  'async:request': {\n    describe: \"the previous results were kept (status: 'error')\",\n    value: (ctx) => Promise.resolve(ctx.meta.get(FALLBACK)),\n  },\n  'diagnostic:emit': {\n    describe: 'the diagnostic was dropped (the logger never kills the table)',\n    silent: true,\n    value: () => undefined,\n  },\n}\n\nconst NONE: Fallback = { describe: 'the operation returned undefined', value: () => undefined }\n\nconst registry = new Map<string, Fallback>(Object.entries(builtins) as [string, Fallback][])\n\n/**\n * Sets the fallback of an op (ops registered by plugins / `@datakable/react`). Process-wide like\n * the op registry; the last registration wins.\n */\nexport function registerFallback<O extends OpName>(op: O, fallback: Fallback<O>): void {\n  registry.set(op, fallback as unknown as Fallback)\n}\n\n/** The registered fallback, or one that returns `undefined` for ops without an entry. */\nexport function getFallback(op: string): Fallback {\n  return registry.get(op) ?? NONE\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAqBO,IAAM,WAAW;AAOjB,IAAM,SAAS;AAEtB,SAAS,QAAQ,GAAwB;AACvC,QAAM,MAAM,IAAI,YAAY,CAAC;AAC7B,WAAS,IAAI,GAAG,IAAI,GAAG,IAAK,KAAI,CAAC,IAAI;AACrC,SAAO;AACT;AAEA,IAAM,WAA4D;AAAA,EAChE,cAAc;AAAA,IACZ,UAAU;AAAA,IACV,OAAO,MAAM;AAAA,EACf;AAAA,EACA,oBAAoB,EAAE,UAAU,kCAAkC,OAAO,MAAM,OAAU;AAAA,EACzF,iBAAiB;AAAA,IACf,UAAU;AAAA,IACV,OAAO,MAAM;AAAA,EACf;AAAA,EACA,kBAAkB;AAAA,IAChB,UAAU;AAAA,IACV,OAAO,MAAM;AAAA,EACf;AAAA,EACA,eAAe;AAAA,IACb,UAAU;AAAA,IACV,OAAO,CAAC,QAAS,IAAI,KAAK,IAAI,QAAQ,KAAwC,CAAC;AAAA,EACjF;AAAA,EACA,gBAAgB;AAAA,IACd,UAAU;AAAA,IACV,OAAO,CAAC,QACL,IAAI,KAAK,IAAI,QAAQ,KAAiC,QAAQ,IAAI,MAAM,QAAQ;AAAA,EACrF;AAAA,EACA,iBAAiB;AAAA,IACf,UAAU;AAAA,IACV,OAAO,CAAC,QAAQ,IAAI,MAAM;AAAA,EAC5B;AAAA,EACA,gBAAgB;AAAA,IACd,UACE;AAAA,IAEF,OAAO,MAAM;AAAA,EACf;AAAA,EACA,iBAAiB;AAAA,IACf,UAAU;AAAA,IACV,OAAO,CAAC,QAAQ,QAAQ,QAAQ,IAAI,KAAK,IAAI,QAAQ,CAAC;AAAA,EACxD;AAAA,EACA,mBAAmB;AAAA,IACjB,UAAU;AAAA,IACV,QAAQ;AAAA,IACR,OAAO,MAAM;AAAA,EACf;AACF;AAEA,IAAM,OAAiB,EAAE,UAAU,oCAAoC,OAAO,MAAM,OAAU;AAE9F,IAAM,WAAW,IAAI,IAAsB,OAAO,QAAQ,QAAQ,CAAyB;AAMpF,SAAS,iBAAmC,IAAO,UAA6B;AACrF,WAAS,IAAI,IAAI,QAA+B;AAClD;AAGO,SAAS,YAAY,IAAsB;AAChD,SAAO,SAAS,IAAI,EAAE,KAAK;AAC7B;","names":[]}
+{"version":3,"sources":["../../src/intercept/fallbacks.ts"],"sourcesContent":["import type { InterceptorContext } from './context'\nimport type { BuiltinOperations, OpName, OpResult } from './operations'\n\n/**\n * What the errorBoundary returns when an op fails (§3.4 registry table). `describe` becomes the\n * diagnostic's `impact`.\n */\nexport interface Fallback<O extends OpName = OpName> {\n  readonly describe: string\n  /**\n   * Report without the diagnostics pipeline: one `console.error` per table. Used by\n   * `diagnostic:emit`, where reporting through the pipeline could recurse.\n   */\n  readonly silent?: boolean\n  value(ctx: InterceptorContext<O>): OpResult<O>\n}\n\n/**\n * `ctx.meta` key for a caller-supplied fallback value: the previous data (`data:ingest`), the last\n * good row model (`pipeline:run`), the previous results (`async:request`). Set it before `run`.\n */\nexport const FALLBACK = 'datakable:fallback'\n\n/**\n * `ctx.meta` key the errorBoundary sets (to the error) when it replaced the op's result with the\n * fallback, so the caller can tell a fallback from a real result (e.g. a failed `data:ingest` sets\n * `status: 'error'`, §6.6).\n */\nexport const FAILED = 'datakable:failed'\n\nfunction allRows(n: number): Uint32Array {\n  const out = new Uint32Array(n)\n  for (let i = 0; i < n; i++) out[i] = i\n  return out\n}\n\nconst builtins: { [K in keyof BuiltinOperations]: Fallback<K> } = {\n  // `describe`: prose keys (diagnostics/prose.ts); a plugin's own fallback may use plain text.\n  'table:init': { describe: 'init-continued', value: () => undefined },\n  'table:setOptions': { describe: 'options-kept', value: () => undefined },\n  'table:destroy': { describe: 'destroy-continued', value: () => undefined },\n  'state:dispatch': { describe: 'update-dropped', value: () => undefined },\n  'data:ingest': {\n    describe: 'data-kept',\n    value: (ctx) => (ctx.meta.get(FALLBACK) as readonly unknown[] | undefined) ?? [],\n  },\n  'pipeline:run': {\n    describe: 'row-model-kept',\n    value: (ctx) =>\n      (ctx.meta.get(FALLBACK) as Uint32Array | undefined) ?? allRows(ctx.input.rowCount),\n  },\n  'pipeline:step': {\n    describe: 'step-passthrough',\n    value: (ctx) => ctx.input.indices,\n  },\n  'column:batch': {\n    describe: 'batch-fallback',\n    value: () => undefined,\n  },\n  'async:request': {\n    describe: 'results-kept',\n    value: (ctx) => Promise.resolve(ctx.meta.get(FALLBACK)),\n  },\n  'diagnostic:emit': {\n    describe: 'diagnostic-dropped',\n    silent: true,\n    value: () => undefined,\n  },\n}\n\nconst NONE: Fallback = { describe: 'returned-undefined', value: () => undefined }\n\nconst registry = new Map<string, Fallback>(Object.entries(builtins) as [string, Fallback][])\n\n/**\n * Sets the fallback of an op (ops registered by plugins / `@datakable/react`). Process-wide like\n * the op registry; the last registration wins.\n */\nexport function registerFallback<O extends OpName>(op: O, fallback: Fallback<O>): void {\n  registry.set(op, fallback as unknown as Fallback)\n}\n\n/** The registered fallback, or one that returns `undefined` for ops without an entry. */\nexport function getFallback(op: string): Fallback {\n  return registry.get(op) ?? NONE\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAqBO,IAAM,WAAW;AAOjB,IAAM,SAAS;AAEtB,SAAS,QAAQ,GAAwB;AACvC,QAAM,MAAM,IAAI,YAAY,CAAC;AAC7B,WAAS,IAAI,GAAG,IAAI,GAAG,IAAK,KAAI,CAAC,IAAI;AACrC,SAAO;AACT;AAEA,IAAM,WAA4D;AAAA;AAAA,EAEhE,cAAc,EAAE,UAAU,kBAAkB,OAAO,MAAM,OAAU;AAAA,EACnE,oBAAoB,EAAE,UAAU,gBAAgB,OAAO,MAAM,OAAU;AAAA,EACvE,iBAAiB,EAAE,UAAU,qBAAqB,OAAO,MAAM,OAAU;AAAA,EACzE,kBAAkB,EAAE,UAAU,kBAAkB,OAAO,MAAM,OAAU;AAAA,EACvE,eAAe;AAAA,IACb,UAAU;AAAA,IACV,OAAO,CAAC,QAAS,IAAI,KAAK,IAAI,QAAQ,KAAwC,CAAC;AAAA,EACjF;AAAA,EACA,gBAAgB;AAAA,IACd,UAAU;AAAA,IACV,OAAO,CAAC,QACL,IAAI,KAAK,IAAI,QAAQ,KAAiC,QAAQ,IAAI,MAAM,QAAQ;AAAA,EACrF;AAAA,EACA,iBAAiB;AAAA,IACf,UAAU;AAAA,IACV,OAAO,CAAC,QAAQ,IAAI,MAAM;AAAA,EAC5B;AAAA,EACA,gBAAgB;AAAA,IACd,UAAU;AAAA,IACV,OAAO,MAAM;AAAA,EACf;AAAA,EACA,iBAAiB;AAAA,IACf,UAAU;AAAA,IACV,OAAO,CAAC,QAAQ,QAAQ,QAAQ,IAAI,KAAK,IAAI,QAAQ,CAAC;AAAA,EACxD;AAAA,EACA,mBAAmB;AAAA,IACjB,UAAU;AAAA,IACV,QAAQ;AAAA,IACR,OAAO,MAAM;AAAA,EACf;AACF;AAEA,IAAM,OAAiB,EAAE,UAAU,sBAAsB,OAAO,MAAM,OAAU;AAEhF,IAAM,WAAW,IAAI,IAAsB,OAAO,QAAQ,QAAQ,CAAyB;AAMpF,SAAS,iBAAmC,IAAO,UAA6B;AACrF,WAAS,IAAI,IAAI,QAA+B;AAClD;AAGO,SAAS,YAAY,IAAsB;AAChD,SAAO,SAAS,IAAI,EAAE,KAAK;AAC7B;","names":[]}

package/dist/intercept/fallbacks.js

@@ -7,46 +7,38 @@ function allRows(n) {
   return out;
 }
 var builtins = {
-  "table:init": {
-    describe: "table creation continued without the failed step",
-    value: () => void 0
-  },
-  "table:setOptions": { describe: "the previous options were kept", value: () => void 0 },
-  "table:destroy": {
-    describe: "teardown continued; the table is destroyed",
-    value: () => void 0
-  },
-  "state:dispatch": {
-    describe: "the update was dropped (state unchanged)",
-    value: () => void 0
-  },
+  // `describe`: prose keys (diagnostics/prose.ts); a plugin's own fallback may use plain text.
+  "table:init": { describe: "init-continued", value: () => void 0 },
+  "table:setOptions": { describe: "options-kept", value: () => void 0 },
+  "table:destroy": { describe: "destroy-continued", value: () => void 0 },
+  "state:dispatch": { describe: "update-dropped", value: () => void 0 },
   "data:ingest": {
-    describe: "the previous data was kept",
+    describe: "data-kept",
     value: (ctx) => ctx.meta.get(FALLBACK) ?? []
   },
   "pipeline:run": {
-    describe: "the last good row model was kept",
+    describe: "row-model-kept",
     value: (ctx) => ctx.meta.get(FALLBACK) ?? allRows(ctx.input.rowCount)
   },
   "pipeline:step": {
-    describe: "the step passed its input through",
+    describe: "step-passthrough",
     value: (ctx) => ctx.input.indices
   },
   "column:batch": {
-    describe: "the column's cells use the slot fallback ('' for format, undefined for accessor, non-matching for filterFn, missing (sorted last) for sortBy)",
+    describe: "batch-fallback",
     value: () => void 0
   },
   "async:request": {
-    describe: "the previous results were kept (status: 'error')",
+    describe: "results-kept",
     value: (ctx) => Promise.resolve(ctx.meta.get(FALLBACK))
   },
   "diagnostic:emit": {
-    describe: "the diagnostic was dropped (the logger never kills the table)",
+    describe: "diagnostic-dropped",
     silent: true,
     value: () => void 0
   }
 };
-var NONE = { describe: "the operation returned undefined", value: () => void 0 };
+var NONE = { describe: "returned-undefined", value: () => void 0 };
 var registry = new Map(Object.entries(builtins));
 function registerFallback(op, fallback) {
   registry.set(op, fallback);

package/dist/intercept/fallbacks.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/intercept/fallbacks.ts"],"sourcesContent":["import type { InterceptorContext } from './context'\nimport type { BuiltinOperations, OpName, OpResult } from './operations'\n\n/**\n * What the errorBoundary returns when an op fails (§3.4 registry table). `describe` becomes the\n * diagnostic's `impact`.\n */\nexport interface Fallback<O extends OpName = OpName> {\n  readonly describe: string\n  /**\n   * Report without the diagnostics pipeline: one `console.error` per table. Used by\n   * `diagnostic:emit`, where reporting through the pipeline could recurse.\n   */\n  readonly silent?: boolean\n  value(ctx: InterceptorContext<O>): OpResult<O>\n}\n\n/**\n * `ctx.meta` key for a caller-supplied fallback value: the previous data (`data:ingest`), the last\n * good row model (`pipeline:run`), the previous results (`async:request`). Set it before `run`.\n */\nexport const FALLBACK = 'datakable:fallback'\n\n/**\n * `ctx.meta` key the errorBoundary sets (to the error) when it replaced the op's result with the\n * fallback, so the caller can tell a fallback from a real result (e.g. a failed `data:ingest` sets\n * `status: 'error'`, §6.6).\n */\nexport const FAILED = 'datakable:failed'\n\nfunction allRows(n: number): Uint32Array {\n  const out = new Uint32Array(n)\n  for (let i = 0; i < n; i++) out[i] = i\n  return out\n}\n\nconst builtins: { [K in keyof BuiltinOperations]: Fallback<K> } = {\n  'table:init': {\n    describe: 'table creation continued without the failed step',\n    value: () => undefined,\n  },\n  'table:setOptions': { describe: 'the previous options were kept', value: () => undefined },\n  'table:destroy': {\n    describe: 'teardown continued; the table is destroyed',\n    value: () => undefined,\n  },\n  'state:dispatch': {\n    describe: 'the update was dropped (state unchanged)',\n    value: () => undefined,\n  },\n  'data:ingest': {\n    describe: 'the previous data was kept',\n    value: (ctx) => (ctx.meta.get(FALLBACK) as readonly unknown[] | undefined) ?? [],\n  },\n  'pipeline:run': {\n    describe: 'the last good row model was kept',\n    value: (ctx) =>\n      (ctx.meta.get(FALLBACK) as Uint32Array | undefined) ?? allRows(ctx.input.rowCount),\n  },\n  'pipeline:step': {\n    describe: 'the step passed its input through',\n    value: (ctx) => ctx.input.indices,\n  },\n  'column:batch': {\n    describe:\n      \"the column's cells use the slot fallback ('' for format, undefined for accessor, \" +\n      'non-matching for filterFn, missing (sorted last) for sortBy)',\n    value: () => undefined,\n  },\n  'async:request': {\n    describe: \"the previous results were kept (status: 'error')\",\n    value: (ctx) => Promise.resolve(ctx.meta.get(FALLBACK)),\n  },\n  'diagnostic:emit': {\n    describe: 'the diagnostic was dropped (the logger never kills the table)',\n    silent: true,\n    value: () => undefined,\n  },\n}\n\nconst NONE: Fallback = { describe: 'the operation returned undefined', value: () => undefined }\n\nconst registry = new Map<string, Fallback>(Object.entries(builtins) as [string, Fallback][])\n\n/**\n * Sets the fallback of an op (ops registered by plugins / `@datakable/react`). Process-wide like\n * the op registry; the last registration wins.\n */\nexport function registerFallback<O extends OpName>(op: O, fallback: Fallback<O>): void {\n  registry.set(op, fallback as unknown as Fallback)\n}\n\n/** The registered fallback, or one that returns `undefined` for ops without an entry. */\nexport function getFallback(op: string): Fallback {\n  return registry.get(op) ?? NONE\n}\n"],"mappings":";AAqBO,IAAM,WAAW;AAOjB,IAAM,SAAS;AAEtB,SAAS,QAAQ,GAAwB;AACvC,QAAM,MAAM,IAAI,YAAY,CAAC;AAC7B,WAAS,IAAI,GAAG,IAAI,GAAG,IAAK,KAAI,CAAC,IAAI;AACrC,SAAO;AACT;AAEA,IAAM,WAA4D;AAAA,EAChE,cAAc;AAAA,IACZ,UAAU;AAAA,IACV,OAAO,MAAM;AAAA,EACf;AAAA,EACA,oBAAoB,EAAE,UAAU,kCAAkC,OAAO,MAAM,OAAU;AAAA,EACzF,iBAAiB;AAAA,IACf,UAAU;AAAA,IACV,OAAO,MAAM;AAAA,EACf;AAAA,EACA,kBAAkB;AAAA,IAChB,UAAU;AAAA,IACV,OAAO,MAAM;AAAA,EACf;AAAA,EACA,eAAe;AAAA,IACb,UAAU;AAAA,IACV,OAAO,CAAC,QAAS,IAAI,KAAK,IAAI,QAAQ,KAAwC,CAAC;AAAA,EACjF;AAAA,EACA,gBAAgB;AAAA,IACd,UAAU;AAAA,IACV,OAAO,CAAC,QACL,IAAI,KAAK,IAAI,QAAQ,KAAiC,QAAQ,IAAI,MAAM,QAAQ;AAAA,EACrF;AAAA,EACA,iBAAiB;AAAA,IACf,UAAU;AAAA,IACV,OAAO,CAAC,QAAQ,IAAI,MAAM;AAAA,EAC5B;AAAA,EACA,gBAAgB;AAAA,IACd,UACE;AAAA,IAEF,OAAO,MAAM;AAAA,EACf;AAAA,EACA,iBAAiB;AAAA,IACf,UAAU;AAAA,IACV,OAAO,CAAC,QAAQ,QAAQ,QAAQ,IAAI,KAAK,IAAI,QAAQ,CAAC;AAAA,EACxD;AAAA,EACA,mBAAmB;AAAA,IACjB,UAAU;AAAA,IACV,QAAQ;AAAA,IACR,OAAO,MAAM;AAAA,EACf;AACF;AAEA,IAAM,OAAiB,EAAE,UAAU,oCAAoC,OAAO,MAAM,OAAU;AAE9F,IAAM,WAAW,IAAI,IAAsB,OAAO,QAAQ,QAAQ,CAAyB;AAMpF,SAAS,iBAAmC,IAAO,UAA6B;AACrF,WAAS,IAAI,IAAI,QAA+B;AAClD;AAGO,SAAS,YAAY,IAAsB;AAChD,SAAO,SAAS,IAAI,EAAE,KAAK;AAC7B;","names":[]}
+{"version":3,"sources":["../../src/intercept/fallbacks.ts"],"sourcesContent":["import type { InterceptorContext } from './context'\nimport type { BuiltinOperations, OpName, OpResult } from './operations'\n\n/**\n * What the errorBoundary returns when an op fails (§3.4 registry table). `describe` becomes the\n * diagnostic's `impact`.\n */\nexport interface Fallback<O extends OpName = OpName> {\n  readonly describe: string\n  /**\n   * Report without the diagnostics pipeline: one `console.error` per table. Used by\n   * `diagnostic:emit`, where reporting through the pipeline could recurse.\n   */\n  readonly silent?: boolean\n  value(ctx: InterceptorContext<O>): OpResult<O>\n}\n\n/**\n * `ctx.meta` key for a caller-supplied fallback value: the previous data (`data:ingest`), the last\n * good row model (`pipeline:run`), the previous results (`async:request`). Set it before `run`.\n */\nexport const FALLBACK = 'datakable:fallback'\n\n/**\n * `ctx.meta` key the errorBoundary sets (to the error) when it replaced the op's result with the\n * fallback, so the caller can tell a fallback from a real result (e.g. a failed `data:ingest` sets\n * `status: 'error'`, §6.6).\n */\nexport const FAILED = 'datakable:failed'\n\nfunction allRows(n: number): Uint32Array {\n  const out = new Uint32Array(n)\n  for (let i = 0; i < n; i++) out[i] = i\n  return out\n}\n\nconst builtins: { [K in keyof BuiltinOperations]: Fallback<K> } = {\n  // `describe`: prose keys (diagnostics/prose.ts); a plugin's own fallback may use plain text.\n  'table:init': { describe: 'init-continued', value: () => undefined },\n  'table:setOptions': { describe: 'options-kept', value: () => undefined },\n  'table:destroy': { describe: 'destroy-continued', value: () => undefined },\n  'state:dispatch': { describe: 'update-dropped', value: () => undefined },\n  'data:ingest': {\n    describe: 'data-kept',\n    value: (ctx) => (ctx.meta.get(FALLBACK) as readonly unknown[] | undefined) ?? [],\n  },\n  'pipeline:run': {\n    describe: 'row-model-kept',\n    value: (ctx) =>\n      (ctx.meta.get(FALLBACK) as Uint32Array | undefined) ?? allRows(ctx.input.rowCount),\n  },\n  'pipeline:step': {\n    describe: 'step-passthrough',\n    value: (ctx) => ctx.input.indices,\n  },\n  'column:batch': {\n    describe: 'batch-fallback',\n    value: () => undefined,\n  },\n  'async:request': {\n    describe: 'results-kept',\n    value: (ctx) => Promise.resolve(ctx.meta.get(FALLBACK)),\n  },\n  'diagnostic:emit': {\n    describe: 'diagnostic-dropped',\n    silent: true,\n    value: () => undefined,\n  },\n}\n\nconst NONE: Fallback = { describe: 'returned-undefined', value: () => undefined }\n\nconst registry = new Map<string, Fallback>(Object.entries(builtins) as [string, Fallback][])\n\n/**\n * Sets the fallback of an op (ops registered by plugins / `@datakable/react`). Process-wide like\n * the op registry; the last registration wins.\n */\nexport function registerFallback<O extends OpName>(op: O, fallback: Fallback<O>): void {\n  registry.set(op, fallback as unknown as Fallback)\n}\n\n/** The registered fallback, or one that returns `undefined` for ops without an entry. */\nexport function getFallback(op: string): Fallback {\n  return registry.get(op) ?? NONE\n}\n"],"mappings":";AAqBO,IAAM,WAAW;AAOjB,IAAM,SAAS;AAEtB,SAAS,QAAQ,GAAwB;AACvC,QAAM,MAAM,IAAI,YAAY,CAAC;AAC7B,WAAS,IAAI,GAAG,IAAI,GAAG,IAAK,KAAI,CAAC,IAAI;AACrC,SAAO;AACT;AAEA,IAAM,WAA4D;AAAA;AAAA,EAEhE,cAAc,EAAE,UAAU,kBAAkB,OAAO,MAAM,OAAU;AAAA,EACnE,oBAAoB,EAAE,UAAU,gBAAgB,OAAO,MAAM,OAAU;AAAA,EACvE,iBAAiB,EAAE,UAAU,qBAAqB,OAAO,MAAM,OAAU;AAAA,EACzE,kBAAkB,EAAE,UAAU,kBAAkB,OAAO,MAAM,OAAU;AAAA,EACvE,eAAe;AAAA,IACb,UAAU;AAAA,IACV,OAAO,CAAC,QAAS,IAAI,KAAK,IAAI,QAAQ,KAAwC,CAAC;AAAA,EACjF;AAAA,EACA,gBAAgB;AAAA,IACd,UAAU;AAAA,IACV,OAAO,CAAC,QACL,IAAI,KAAK,IAAI,QAAQ,KAAiC,QAAQ,IAAI,MAAM,QAAQ;AAAA,EACrF;AAAA,EACA,iBAAiB;AAAA,IACf,UAAU;AAAA,IACV,OAAO,CAAC,QAAQ,IAAI,MAAM;AAAA,EAC5B;AAAA,EACA,gBAAgB;AAAA,IACd,UAAU;AAAA,IACV,OAAO,MAAM;AAAA,EACf;AAAA,EACA,iBAAiB;AAAA,IACf,UAAU;AAAA,IACV,OAAO,CAAC,QAAQ,QAAQ,QAAQ,IAAI,KAAK,IAAI,QAAQ,CAAC;AAAA,EACxD;AAAA,EACA,mBAAmB;AAAA,IACjB,UAAU;AAAA,IACV,QAAQ;AAAA,IACR,OAAO,MAAM;AAAA,EACf;AACF;AAEA,IAAM,OAAiB,EAAE,UAAU,sBAAsB,OAAO,MAAM,OAAU;AAEhF,IAAM,WAAW,IAAI,IAAsB,OAAO,QAAQ,QAAQ,CAAyB;AAMpF,SAAS,iBAAmC,IAAO,UAA6B;AACrF,WAAS,IAAI,IAAI,QAA+B;AAClD;AAGO,SAAS,YAAY,IAAsB;AAChD,SAAO,SAAS,IAAI,EAAE,KAAK;AAC7B;","names":[]}

package/dist/intercept/runtime.cjs

@@ -24,6 +24,7 @@ __export(runtime_exports, {
 });
 module.exports = __toCommonJS(runtime_exports);
 var import_build = require("../diagnostics/build.cjs");
+var import_process_guard = require("../diagnostics/process-guard.cjs");
 var import_operations = require("./operations.cjs");
 var NOT_CALLED = 0;
 var CALLED = 1;
@@ -85,10 +86,10 @@ function createInterceptorRuntime(options = {}) {
       );
     }
   });
-  const onHotWarning = options.onHotWarning ?? ((w) => {
+  const onHotWarning = process.env.NODE_ENV !== "production" ? options.onHotWarning ?? ((w) => {
     if (emit) emit("DK_HOT_INTERCEPTOR", { interceptor: w.interceptor.name, op: w.op });
     else console.warn(`[DataKable] ${w.message}`);
-  });
+  }) : void 0;
   const report = (error, i, ctx) => {
     try {
       onError(error, i, ctx);
@@ -99,9 +100,9 @@ function createInterceptorRuntime(options = {}) {
   let list = [];
   let boundary;
   const chains = /* @__PURE__ */ new Map();
-  const warned = /* @__PURE__ */ new WeakMap();
+  const warned = process.env.NODE_ENV !== "production" ? /* @__PURE__ */ new WeakMap() : void 0;
   function warnHot(i, op) {
-    if (!(process.env.NODE_ENV !== "production")) return;
+    if (!(process.env.NODE_ENV !== "production") || !warned || !onHotWarning) return;
     let ops = warned.get(i);
     if (ops?.has(op)) return;
     if (!ops) {
@@ -121,7 +122,7 @@ function createInterceptorRuntime(options = {}) {
   function compile(op) {
     const info = (0, import_operations.getOperation)(op);
     if (!info) {
-      throw (0, import_build.internalError)(op, `Unknown operation "${op}": register it with registerOperation()`);
+      throw (0, import_build.internalError)(op, `unknown-op|${op}`);
     }
     const mine = list.filter((i) => attaches(i, op));
     if (boundary && attaches(boundary, op)) mine.unshift(boundary);
@@ -151,10 +152,7 @@ function createInterceptorRuntime(options = {}) {
     setInterceptors,
     installBoundary(b) {
       if (boundary) {
-        throw (0, import_build.internalError)(
-          "*",
-          `A boundary interceptor is already installed ("${boundary.name}"); "${b.name}" was rejected`
-        );
+        throw (0, import_build.internalError)("*", `boundary-twice|${boundary.name}|${b.name}`);
       }
       boundary = b;
       compileAll();

package/dist/intercept/runtime.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/intercept/runtime.ts"],"sourcesContent":["import { DatakableError, internalError } from '../diagnostics/build'\nimport type { Emit } from '../diagnostics/types'\nimport type { InterceptorContext } from './context'\nimport type { Interceptor } from './define'\nimport { getOperation, listOperations, type OpName, type OpResult } from './operations'\n\nexport type Core<O extends OpName> = (ctx: InterceptorContext<O>) => OpResult<O>\n\nexport interface HotOpWarning {\n  interceptor: Interceptor<OpName>\n  op: string\n  message: string\n}\n\nexport interface InterceptorRuntimeOptions {\n  interceptors?: readonly Interceptor<OpName>[]\n  /**\n   * The table's diagnostic emitter. When given, the default hooks below report through it:\n   * `DK_INTERCEPTOR_FAILED` and (dev only) `DK_HOT_INTERCEPTOR`. Without it they use the console.\n   */\n  emit?: Emit\n  /**\n   * An interceptor threw (or its promise rejected); it was skipped. Overrides the default report\n   * (`DK_INTERCEPTOR_FAILED` via `emit`, else console.error).\n   */\n  onInterceptorError?: (\n    error: unknown,\n    interceptor: Interceptor<OpName>,\n    ctx: InterceptorContext,\n  ) => void\n  /**\n   * An interceptor is attached to a hot op without `hot: true` (checked when the op's chain is\n   * compiled, once per interceptor + op). Overrides the default (`DK_HOT_INTERCEPTOR` via `emit`).\n   */\n  onHotWarning?: (warning: HotOpWarning) => void\n  /** Called each time a chain is compiled (tracing / tests). `length` counts the boundary too. */\n  onCompile?: (op: string, length: number) => void\n}\n\nexport interface InterceptorRuntime {\n  /** Runs `core` for `op` through the compiled chain. */\n  run<O extends OpName>(op: O, ctx: InterceptorContext<O>, core: NoInfer<Core<O>>): OpResult<O>\n  /** Replaces the user / feature interceptors and recompiles. The boundary slot is kept. */\n  setInterceptors(interceptors: readonly Interceptor<OpName>[]): void\n  /** Installs the outermost, non-removable interceptor (errorBoundary, T06). Once only. */\n  installBoundary(boundary: Interceptor<OpName>): void\n}\n\ntype AnyCtx = InterceptorContext\ntype AnyCore = (ctx: AnyCtx) => unknown\ntype Chain = (ctx: AnyCtx, core: AnyCore) => unknown\n\nconst NOT_CALLED = 0\nconst CALLED = 1\nconst FAILED_INSIDE = 2\n\nconst direct: Chain = (ctx, core) => core(ctx)\n\nconst isThenable = (v: unknown): v is PromiseLike<unknown> =>\n  v != null && typeof (v as { then?: unknown }).then === 'function'\n\nconst attaches = (i: Interceptor<OpName>, op: string) =>\n  i.on === '*' || (i.on as readonly string[]).includes(op)\n\n/**\n * Wraps one interceptor around `inner`. Skip semantics (§3.4): if the interceptor throws before\n * calling `next`, `next` runs directly; if it throws after, the result `next` produced is kept so\n * the core never runs twice. An error that came out of `next` belongs to an inner layer and is\n * rethrown untouched. Async results get the same rules on rejection.\n */\nfunction wrap(\n  i: Interceptor<OpName>,\n  inner: Chain,\n  mayBeAsync: boolean,\n  report: (error: unknown, i: Interceptor<OpName>, ctx: AnyCtx) => void,\n): Chain {\n  const intercept = i.intercept as (ctx: AnyCtx, next: () => unknown) => unknown\n  return (ctx, core) => {\n    let state = NOT_CALLED\n    let out: unknown\n    const next = () => {\n      state = CALLED\n      try {\n        out = inner(ctx, core)\n      } catch (e) {\n        state = FAILED_INSIDE\n        throw e\n      }\n      if (mayBeAsync && isThenable(out)) {\n        const p = Promise.resolve(out).then(undefined, (e: unknown) => {\n          state = FAILED_INSIDE\n          throw e\n        })\n        // Handled here so an interceptor that drops `next()` never causes an unhandled rejection;\n        // whoever awaits `p` still sees the rejection.\n        p.catch(() => {})\n        out = p\n      }\n      return out\n    }\n    const recover = (e: unknown) => {\n      if (state === FAILED_INSIDE) throw e\n      report(e, i, ctx)\n      return state === CALLED ? out : inner(ctx, core)\n    }\n    let r: unknown\n    try {\n      r = intercept(ctx, next)\n    } catch (e) {\n      return recover(e)\n    }\n    return mayBeAsync && isThenable(r) ? Promise.resolve(r).then(undefined, recover) : r\n  }\n}\n\nexport function createInterceptorRuntime(\n  options: InterceptorRuntimeOptions = {},\n): InterceptorRuntime {\n  const { emit, onCompile } = options\n  const onError =\n    options.onInterceptorError ??\n    ((error: unknown, i: Interceptor<OpName>, ctx: AnyCtx) => {\n      if (emit) {\n        emit(\n          'DK_INTERCEPTOR_FAILED',\n          { interceptor: i.name, op: ctx.op, slot: ctx.where },\n          { cause: error, run: ctx.run, trigger: ctx.trigger, phase: ctx.phase },\n        )\n      } else {\n        console.error(\n          `[DataKable] interceptor \"${i.name}\" failed on ${ctx.op} and was skipped`,\n          error,\n        )\n      }\n    })\n  const onHotWarning =\n    options.onHotWarning ??\n    ((w: HotOpWarning) => {\n      if (emit) emit('DK_HOT_INTERCEPTOR', { interceptor: w.interceptor.name, op: w.op })\n      else console.warn(`[DataKable] ${w.message}`)\n    })\n  const report = (error: unknown, i: Interceptor<OpName>, ctx: AnyCtx) => {\n    try {\n      onError(error, i, ctx)\n    } catch (e) {\n      // The reporter must never break the operation it reports on — except `strict: true`, whose\n      // DatakableError is the requested behaviour.\n      if (e instanceof DatakableError) throw e\n    }\n  }\n\n  let list: readonly Interceptor<OpName>[] = []\n  let boundary: Interceptor<OpName> | undefined\n  const chains = new Map<string, Chain>()\n  /** (interceptor, op) pairs already warned about, so recompiles do not repeat the warning. */\n  const warned = new WeakMap<Interceptor<OpName>, Set<string>>()\n\n  function warnHot(i: Interceptor<OpName>, op: string) {\n    if (!(process.env.NODE_ENV !== \"production\")) return // dev-only warning: drops the text below from production bundles\n    let ops = warned.get(i)\n    if (ops?.has(op)) return\n    if (!ops) {\n      ops = new Set()\n      warned.set(i, ops)\n    }\n    ops.add(op)\n    try {\n      onHotWarning({\n        interceptor: i,\n        op,\n        message:\n          `Interceptor \"${i.name}\" is attached to hot op \"${op}\" without hot: true. ` +\n          // Measured by intercept/chain.bench.ts (Apple M4 Pro, Node 25.2.1). Inline here, inside\n          // the (process.env.NODE_ENV !== \"production\")-only function, so production bundles carry none of it.\n          'It runs once per column per pipeline run; measured cost: ~10 ns per call per ' +\n          'interceptor (+15% on a per-cell format call, spec §9.2) on top of the interceptor ' +\n          'body, which runs columns × pipeline runs times. ' +\n          'Never loop per cell inside it. Set hot: true to accept the cost, ' +\n          'or attach it to a cold op.',\n      })\n    } catch {\n      // A warning must never break compilation.\n    }\n  }\n\n  function compile(op: string): Chain {\n    const info = getOperation(op)\n    if (!info) {\n      throw internalError(op, `Unknown operation \"${op}\": register it with registerOperation()`)\n    }\n    const mine = list.filter((i) => attaches(i, op))\n    if (boundary && attaches(boundary, op)) mine.unshift(boundary)\n    // Checked here, not when the list is set, so ops registered after creation are covered too.\n    if ((process.env.NODE_ENV !== \"production\") && info.hot) for (const i of mine) if (!i.hot) warnHot(i, op)\n    const mayBeAsync = info.kind !== 'sync'\n    const chain = mine.reduceRight<Chain>((inner, i) => wrap(i, inner, mayBeAsync, report), direct)\n    chains.set(op, chain)\n    onCompile?.(op, mine.length)\n    return chain\n  }\n\n  function compileAll() {\n    chains.clear()\n    for (const op of listOperations()) compile(op)\n  }\n\n  function setInterceptors(next: readonly Interceptor<OpName>[]) {\n    list = [...next]\n    compileAll()\n  }\n\n  setInterceptors(options.interceptors ?? [])\n\n  return {\n    run(op, ctx, core) {\n      const chain = chains.get(op) ?? compile(op)\n      return chain(ctx, core as AnyCore) as OpResult<typeof op>\n    },\n    setInterceptors,\n    installBoundary(b) {\n      if (boundary) {\n        throw internalError(\n          '*',\n          `A boundary interceptor is already installed (\"${boundary.name}\"); ` +\n            `\"${b.name}\" was rejected`,\n        )\n      }\n      boundary = b\n      compileAll()\n    },\n  }\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../../src/intercept/runtime.ts"],"sourcesContent":["import { DatakableError, internalError } from '../diagnostics/build'\nimport '../diagnostics/process-guard'\nimport type { Emit } from '../diagnostics/types'\nimport type { InterceptorContext } from './context'\nimport type { Interceptor } from './define'\nimport { getOperation, listOperations, type OpName, type OpResult } from './operations'\n\nexport type Core<O extends OpName> = (ctx: InterceptorContext<O>) => OpResult<O>\n\nexport interface HotOpWarning {\n  interceptor: Interceptor<OpName>\n  op: string\n  message: string\n}\n\nexport interface InterceptorRuntimeOptions {\n  interceptors?: readonly Interceptor<OpName>[]\n  /**\n   * The table's diagnostic emitter. When given, the default hooks below report through it:\n   * `DK_INTERCEPTOR_FAILED` and (dev only) `DK_HOT_INTERCEPTOR`. Without it they use the console.\n   */\n  emit?: Emit\n  /**\n   * An interceptor threw (or its promise rejected); it was skipped. Overrides the default report\n   * (`DK_INTERCEPTOR_FAILED` via `emit`, else console.error).\n   */\n  onInterceptorError?: (\n    error: unknown,\n    interceptor: Interceptor<OpName>,\n    ctx: InterceptorContext,\n  ) => void\n  /**\n   * An interceptor is attached to a hot op without `hot: true` (checked when the op's chain is\n   * compiled, once per interceptor + op). Overrides the default (`DK_HOT_INTERCEPTOR` via `emit`).\n   */\n  onHotWarning?: (warning: HotOpWarning) => void\n  /** Called each time a chain is compiled (tracing / tests). `length` counts the boundary too. */\n  onCompile?: (op: string, length: number) => void\n}\n\nexport interface InterceptorRuntime {\n  /** Runs `core` for `op` through the compiled chain. */\n  run<O extends OpName>(op: O, ctx: InterceptorContext<O>, core: NoInfer<Core<O>>): OpResult<O>\n  /** Replaces the user / feature interceptors and recompiles. The boundary slot is kept. */\n  setInterceptors(interceptors: readonly Interceptor<OpName>[]): void\n  /** Installs the outermost, non-removable interceptor (errorBoundary, T06). Once only. */\n  installBoundary(boundary: Interceptor<OpName>): void\n}\n\ntype AnyCtx = InterceptorContext\ntype AnyCore = (ctx: AnyCtx) => unknown\ntype Chain = (ctx: AnyCtx, core: AnyCore) => unknown\n\nconst NOT_CALLED = 0\nconst CALLED = 1\nconst FAILED_INSIDE = 2\n\nconst direct: Chain = (ctx, core) => core(ctx)\n\nconst isThenable = (v: unknown): v is PromiseLike<unknown> =>\n  v != null && typeof (v as { then?: unknown }).then === 'function'\n\nconst attaches = (i: Interceptor<OpName>, op: string) =>\n  i.on === '*' || (i.on as readonly string[]).includes(op)\n\n/**\n * Wraps one interceptor around `inner`. Skip semantics (§3.4): if the interceptor throws before\n * calling `next`, `next` runs directly; if it throws after, the result `next` produced is kept so\n * the core never runs twice. An error that came out of `next` belongs to an inner layer and is\n * rethrown untouched. Async results get the same rules on rejection.\n */\nfunction wrap(\n  i: Interceptor<OpName>,\n  inner: Chain,\n  mayBeAsync: boolean,\n  report: (error: unknown, i: Interceptor<OpName>, ctx: AnyCtx) => void,\n): Chain {\n  const intercept = i.intercept as (ctx: AnyCtx, next: () => unknown) => unknown\n  return (ctx, core) => {\n    let state = NOT_CALLED\n    let out: unknown\n    const next = () => {\n      state = CALLED\n      try {\n        out = inner(ctx, core)\n      } catch (e) {\n        state = FAILED_INSIDE\n        throw e\n      }\n      if (mayBeAsync && isThenable(out)) {\n        const p = Promise.resolve(out).then(undefined, (e: unknown) => {\n          state = FAILED_INSIDE\n          throw e\n        })\n        // Handled here so an interceptor that drops `next()` never causes an unhandled rejection;\n        // whoever awaits `p` still sees the rejection.\n        p.catch(() => {})\n        out = p\n      }\n      return out\n    }\n    const recover = (e: unknown) => {\n      if (state === FAILED_INSIDE) throw e\n      report(e, i, ctx)\n      return state === CALLED ? out : inner(ctx, core)\n    }\n    let r: unknown\n    try {\n      r = intercept(ctx, next)\n    } catch (e) {\n      return recover(e)\n    }\n    return mayBeAsync && isThenable(r) ? Promise.resolve(r).then(undefined, recover) : r\n  }\n}\n\nexport function createInterceptorRuntime(\n  options: InterceptorRuntimeOptions = {},\n): InterceptorRuntime {\n  const { emit, onCompile } = options\n  const onError =\n    options.onInterceptorError ??\n    ((error: unknown, i: Interceptor<OpName>, ctx: AnyCtx) => {\n      if (emit) {\n        emit(\n          'DK_INTERCEPTOR_FAILED',\n          { interceptor: i.name, op: ctx.op, slot: ctx.where },\n          { cause: error, run: ctx.run, trigger: ctx.trigger, phase: ctx.phase },\n        )\n      } else {\n        console.error(\n          `[DataKable] interceptor \"${i.name}\" failed on ${ctx.op} and was skipped`,\n          error,\n        )\n      }\n    })\n  // Dev-only (DK_HOT_INTERCEPTOR): `undefined` in production, with the code and its text.\n  const onHotWarning = (process.env.NODE_ENV !== \"production\")\n    ? (options.onHotWarning ??\n      ((w: HotOpWarning) => {\n        if (emit) emit('DK_HOT_INTERCEPTOR', { interceptor: w.interceptor.name, op: w.op })\n        else console.warn(`[DataKable] ${w.message}`)\n      }))\n    : undefined\n  const report = (error: unknown, i: Interceptor<OpName>, ctx: AnyCtx) => {\n    try {\n      onError(error, i, ctx)\n    } catch (e) {\n      // The reporter must never break the operation it reports on — except `strict: true`, whose\n      // DatakableError is the requested behaviour.\n      if (e instanceof DatakableError) throw e\n    }\n  }\n\n  let list: readonly Interceptor<OpName>[] = []\n  let boundary: Interceptor<OpName> | undefined\n  const chains = new Map<string, Chain>()\n  /** (interceptor, op) pairs already warned about, so recompiles do not repeat the warning. */\n  const warned = (process.env.NODE_ENV !== \"production\") ? new WeakMap<Interceptor<OpName>, Set<string>>() : undefined\n\n  function warnHot(i: Interceptor<OpName>, op: string) {\n    if (!(process.env.NODE_ENV !== \"production\") || !warned || !onHotWarning) return // dev-only: production bundles drop the text below\n    let ops = warned.get(i)\n    if (ops?.has(op)) return\n    if (!ops) {\n      ops = new Set()\n      warned.set(i, ops)\n    }\n    ops.add(op)\n    try {\n      onHotWarning({\n        interceptor: i,\n        op,\n        message:\n          `Interceptor \"${i.name}\" is attached to hot op \"${op}\" without hot: true. ` +\n          // Measured by intercept/chain.bench.ts (Apple M4 Pro, Node 25.2.1). Inline here, inside\n          // the (process.env.NODE_ENV !== \"production\")-only function, so production bundles carry none of it.\n          'It runs once per column per pipeline run; measured cost: ~10 ns per call per ' +\n          'interceptor (+15% on a per-cell format call, spec §9.2) on top of the interceptor ' +\n          'body, which runs columns × pipeline runs times. ' +\n          'Never loop per cell inside it. Set hot: true to accept the cost, ' +\n          'or attach it to a cold op.',\n      })\n    } catch {\n      // A warning must never break compilation.\n    }\n  }\n\n  function compile(op: string): Chain {\n    const info = getOperation(op)\n    if (!info) {\n      throw internalError(op, `unknown-op|${op}`)\n    }\n    const mine = list.filter((i) => attaches(i, op))\n    if (boundary && attaches(boundary, op)) mine.unshift(boundary)\n    // Checked here, not when the list is set, so ops registered after creation are covered too.\n    if ((process.env.NODE_ENV !== \"production\") && info.hot) for (const i of mine) if (!i.hot) warnHot(i, op)\n    const mayBeAsync = info.kind !== 'sync'\n    const chain = mine.reduceRight<Chain>((inner, i) => wrap(i, inner, mayBeAsync, report), direct)\n    chains.set(op, chain)\n    onCompile?.(op, mine.length)\n    return chain\n  }\n\n  function compileAll() {\n    chains.clear()\n    for (const op of listOperations()) compile(op)\n  }\n\n  function setInterceptors(next: readonly Interceptor<OpName>[]) {\n    list = [...next]\n    compileAll()\n  }\n\n  setInterceptors(options.interceptors ?? [])\n\n  return {\n    run(op, ctx, core) {\n      const chain = chains.get(op) ?? compile(op)\n      return chain(ctx, core as AnyCore) as OpResult<typeof op>\n    },\n    setInterceptors,\n    installBoundary(b) {\n      if (boundary) {\n        throw internalError('*', `boundary-twice|${boundary.name}|${b.name}`)\n      }\n      boundary = b\n      compileAll()\n    },\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAA8C;AAC9C,2BAAO;AAIP,wBAAyE;AAgDzE,IAAM,aAAa;AACnB,IAAM,SAAS;AACf,IAAM,gBAAgB;AAEtB,IAAM,SAAgB,CAAC,KAAK,SAAS,KAAK,GAAG;AAE7C,IAAM,aAAa,CAAC,MAClB,KAAK,QAAQ,OAAQ,EAAyB,SAAS;AAEzD,IAAM,WAAW,CAAC,GAAwB,OACxC,EAAE,OAAO,OAAQ,EAAE,GAAyB,SAAS,EAAE;AAQzD,SAAS,KACP,GACA,OACA,YACA,QACO;AACP,QAAM,YAAY,EAAE;AACpB,SAAO,CAAC,KAAK,SAAS;AACpB,QAAI,QAAQ;AACZ,QAAI;AACJ,UAAM,OAAO,MAAM;AACjB,cAAQ;AACR,UAAI;AACF,cAAM,MAAM,KAAK,IAAI;AAAA,MACvB,SAAS,GAAG;AACV,gBAAQ;AACR,cAAM;AAAA,MACR;AACA,UAAI,cAAc,WAAW,GAAG,GAAG;AACjC,cAAM,IAAI,QAAQ,QAAQ,GAAG,EAAE,KAAK,QAAW,CAAC,MAAe;AAC7D,kBAAQ;AACR,gBAAM;AAAA,QACR,CAAC;AAGD,UAAE,MAAM,MAAM;AAAA,QAAC,CAAC;AAChB,cAAM;AAAA,MACR;AACA,aAAO;AAAA,IACT;AACA,UAAM,UAAU,CAAC,MAAe;AAC9B,UAAI,UAAU,cAAe,OAAM;AACnC,aAAO,GAAG,GAAG,GAAG;AAChB,aAAO,UAAU,SAAS,MAAM,MAAM,KAAK,IAAI;AAAA,IACjD;AACA,QAAI;AACJ,QAAI;AACF,UAAI,UAAU,KAAK,IAAI;AAAA,IACzB,SAAS,GAAG;AACV,aAAO,QAAQ,CAAC;AAAA,IAClB;AACA,WAAO,cAAc,WAAW,CAAC,IAAI,QAAQ,QAAQ,CAAC,EAAE,KAAK,QAAW,OAAO,IAAI;AAAA,EACrF;AACF;AAEO,SAAS,yBACd,UAAqC,CAAC,GAClB;AACpB,QAAM,EAAE,MAAM,UAAU,IAAI;AAC5B,QAAM,UACJ,QAAQ,uBACP,CAAC,OAAgB,GAAwB,QAAgB;AACxD,QAAI,MAAM;AACR;AAAA,QACE;AAAA,QACA,EAAE,aAAa,EAAE,MAAM,IAAI,IAAI,IAAI,MAAM,IAAI,MAAM;AAAA,QACnD,EAAE,OAAO,OAAO,KAAK,IAAI,KAAK,SAAS,IAAI,SAAS,OAAO,IAAI,MAAM;AAAA,MACvE;AAAA,IACF,OAAO;AACL,cAAQ;AAAA,QACN,4BAA4B,EAAE,IAAI,eAAe,IAAI,EAAE;AAAA,QACvD;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAEF,QAAM,eAAgB,QAAQ,IAAI,aAAa,eAC1C,QAAQ,iBACR,CAAC,MAAoB;AACpB,QAAI,KAAM,MAAK,sBAAsB,EAAE,aAAa,EAAE,YAAY,MAAM,IAAI,EAAE,GAAG,CAAC;AAAA,QAC7E,SAAQ,KAAK,eAAe,EAAE,OAAO,EAAE;AAAA,EAC9C,KACA;AACJ,QAAM,SAAS,CAAC,OAAgB,GAAwB,QAAgB;AACtE,QAAI;AACF,cAAQ,OAAO,GAAG,GAAG;AAAA,IACvB,SAAS,GAAG;AAGV,UAAI,aAAa,4BAAgB,OAAM;AAAA,IACzC;AAAA,EACF;AAEA,MAAI,OAAuC,CAAC;AAC5C,MAAI;AACJ,QAAM,SAAS,oBAAI,IAAmB;AAEtC,QAAM,SAAU,QAAQ,IAAI,aAAa,eAAgB,oBAAI,QAA0C,IAAI;AAE3G,WAAS,QAAQ,GAAwB,IAAY;AACnD,QAAI,EAAE,QAAQ,IAAI,aAAa,iBAAiB,CAAC,UAAU,CAAC,aAAc;AAC1E,QAAI,MAAM,OAAO,IAAI,CAAC;AACtB,QAAI,KAAK,IAAI,EAAE,EAAG;AAClB,QAAI,CAAC,KAAK;AACR,YAAM,oBAAI,IAAI;AACd,aAAO,IAAI,GAAG,GAAG;AAAA,IACnB;AACA,QAAI,IAAI,EAAE;AACV,QAAI;AACF,mBAAa;AAAA,QACX,aAAa;AAAA,QACb;AAAA,QACA,SACE,gBAAgB,EAAE,IAAI,4BAA4B,EAAE;AAAA,MAQxD,CAAC;AAAA,IACH,QAAQ;AAAA,IAER;AAAA,EACF;AAEA,WAAS,QAAQ,IAAmB;AAClC,UAAM,WAAO,gCAAa,EAAE;AAC5B,QAAI,CAAC,MAAM;AACT,gBAAM,4BAAc,IAAI,cAAc,EAAE,EAAE;AAAA,IAC5C;AACA,UAAM,OAAO,KAAK,OAAO,CAAC,MAAM,SAAS,GAAG,EAAE,CAAC;AAC/C,QAAI,YAAY,SAAS,UAAU,EAAE,EAAG,MAAK,QAAQ,QAAQ;AAE7D,QAAK,QAAQ,IAAI,aAAa,gBAAiB,KAAK;AAAK,iBAAW,KAAK,KAAM,KAAI,CAAC,EAAE,IAAK,SAAQ,GAAG,EAAE;AAAA;AACxG,UAAM,aAAa,KAAK,SAAS;AACjC,UAAM,QAAQ,KAAK,YAAmB,CAAC,OAAO,MAAM,KAAK,GAAG,OAAO,YAAY,MAAM,GAAG,MAAM;AAC9F,WAAO,IAAI,IAAI,KAAK;AACpB,gBAAY,IAAI,KAAK,MAAM;AAC3B,WAAO;AAAA,EACT;AAEA,WAAS,aAAa;AACpB,WAAO,MAAM;AACb,eAAW,UAAM,kCAAe,EAAG,SAAQ,EAAE;AAAA,EAC/C;AAEA,WAAS,gBAAgB,MAAsC;AAC7D,WAAO,CAAC,GAAG,IAAI;AACf,eAAW;AAAA,EACb;AAEA,kBAAgB,QAAQ,gBAAgB,CAAC,CAAC;AAE1C,SAAO;AAAA,IACL,IAAI,IAAI,KAAK,MAAM;AACjB,YAAM,QAAQ,OAAO,IAAI,EAAE,KAAK,QAAQ,EAAE;AAC1C,aAAO,MAAM,KAAK,IAAe;AAAA,IACnC;AAAA,IACA;AAAA,IACA,gBAAgB,GAAG;AACjB,UAAI,UAAU;AACZ,kBAAM,4BAAc,KAAK,kBAAkB,SAAS,IAAI,IAAI,EAAE,IAAI,EAAE;AAAA,MACtE;AACA,iBAAW;AACX,iBAAW;AAAA,IACb;AAAA,EACF;AACF;","names":[]}

package/dist/intercept/runtime.js

@@ -1,5 +1,6 @@
 // src/intercept/runtime.ts
 import { DatakableError, internalError } from "../diagnostics/build.js";
+import "../diagnostics/process-guard.js";
 import { getOperation, listOperations } from "./operations.js";
 var NOT_CALLED = 0;
 var CALLED = 1;
@@ -61,10 +62,10 @@ function createInterceptorRuntime(options = {}) {
       );
     }
   });
-  const onHotWarning = options.onHotWarning ?? ((w) => {
+  const onHotWarning = process.env.NODE_ENV !== "production" ? options.onHotWarning ?? ((w) => {
     if (emit) emit("DK_HOT_INTERCEPTOR", { interceptor: w.interceptor.name, op: w.op });
     else console.warn(`[DataKable] ${w.message}`);
-  });
+  }) : void 0;
   const report = (error, i, ctx) => {
     try {
       onError(error, i, ctx);
@@ -75,9 +76,9 @@ function createInterceptorRuntime(options = {}) {
   let list = [];
   let boundary;
   const chains = /* @__PURE__ */ new Map();
-  const warned = /* @__PURE__ */ new WeakMap();
+  const warned = process.env.NODE_ENV !== "production" ? /* @__PURE__ */ new WeakMap() : void 0;
   function warnHot(i, op) {
-    if (!(process.env.NODE_ENV !== "production")) return;
+    if (!(process.env.NODE_ENV !== "production") || !warned || !onHotWarning) return;
     let ops = warned.get(i);
     if (ops?.has(op)) return;
     if (!ops) {
@@ -97,7 +98,7 @@ function createInterceptorRuntime(options = {}) {
   function compile(op) {
     const info = getOperation(op);
     if (!info) {
-      throw internalError(op, `Unknown operation "${op}": register it with registerOperation()`);
+      throw internalError(op, `unknown-op|${op}`);
     }
     const mine = list.filter((i) => attaches(i, op));
     if (boundary && attaches(boundary, op)) mine.unshift(boundary);
@@ -127,10 +128,7 @@ function createInterceptorRuntime(options = {}) {
     setInterceptors,
     installBoundary(b) {
       if (boundary) {
-        throw internalError(
-          "*",
-          `A boundary interceptor is already installed ("${boundary.name}"); "${b.name}" was rejected`
-        );
+        throw internalError("*", `boundary-twice|${boundary.name}|${b.name}`);
       }
       boundary = b;
       compileAll();

package/dist/intercept/runtime.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/intercept/runtime.ts"],"sourcesContent":["import { DatakableError, internalError } from '../diagnostics/build'\nimport type { Emit } from '../diagnostics/types'\nimport type { InterceptorContext } from './context'\nimport type { Interceptor } from './define'\nimport { getOperation, listOperations, type OpName, type OpResult } from './operations'\n\nexport type Core<O extends OpName> = (ctx: InterceptorContext<O>) => OpResult<O>\n\nexport interface HotOpWarning {\n  interceptor: Interceptor<OpName>\n  op: string\n  message: string\n}\n\nexport interface InterceptorRuntimeOptions {\n  interceptors?: readonly Interceptor<OpName>[]\n  /**\n   * The table's diagnostic emitter. When given, the default hooks below report through it:\n   * `DK_INTERCEPTOR_FAILED` and (dev only) `DK_HOT_INTERCEPTOR`. Without it they use the console.\n   */\n  emit?: Emit\n  /**\n   * An interceptor threw (or its promise rejected); it was skipped. Overrides the default report\n   * (`DK_INTERCEPTOR_FAILED` via `emit`, else console.error).\n   */\n  onInterceptorError?: (\n    error: unknown,\n    interceptor: Interceptor<OpName>,\n    ctx: InterceptorContext,\n  ) => void\n  /**\n   * An interceptor is attached to a hot op without `hot: true` (checked when the op's chain is\n   * compiled, once per interceptor + op). Overrides the default (`DK_HOT_INTERCEPTOR` via `emit`).\n   */\n  onHotWarning?: (warning: HotOpWarning) => void\n  /** Called each time a chain is compiled (tracing / tests). `length` counts the boundary too. */\n  onCompile?: (op: string, length: number) => void\n}\n\nexport interface InterceptorRuntime {\n  /** Runs `core` for `op` through the compiled chain. */\n  run<O extends OpName>(op: O, ctx: InterceptorContext<O>, core: NoInfer<Core<O>>): OpResult<O>\n  /** Replaces the user / feature interceptors and recompiles. The boundary slot is kept. */\n  setInterceptors(interceptors: readonly Interceptor<OpName>[]): void\n  /** Installs the outermost, non-removable interceptor (errorBoundary, T06). Once only. */\n  installBoundary(boundary: Interceptor<OpName>): void\n}\n\ntype AnyCtx = InterceptorContext\ntype AnyCore = (ctx: AnyCtx) => unknown\ntype Chain = (ctx: AnyCtx, core: AnyCore) => unknown\n\nconst NOT_CALLED = 0\nconst CALLED = 1\nconst FAILED_INSIDE = 2\n\nconst direct: Chain = (ctx, core) => core(ctx)\n\nconst isThenable = (v: unknown): v is PromiseLike<unknown> =>\n  v != null && typeof (v as { then?: unknown }).then === 'function'\n\nconst attaches = (i: Interceptor<OpName>, op: string) =>\n  i.on === '*' || (i.on as readonly string[]).includes(op)\n\n/**\n * Wraps one interceptor around `inner`. Skip semantics (§3.4): if the interceptor throws before\n * calling `next`, `next` runs directly; if it throws after, the result `next` produced is kept so\n * the core never runs twice. An error that came out of `next` belongs to an inner layer and is\n * rethrown untouched. Async results get the same rules on rejection.\n */\nfunction wrap(\n  i: Interceptor<OpName>,\n  inner: Chain,\n  mayBeAsync: boolean,\n  report: (error: unknown, i: Interceptor<OpName>, ctx: AnyCtx) => void,\n): Chain {\n  const intercept = i.intercept as (ctx: AnyCtx, next: () => unknown) => unknown\n  return (ctx, core) => {\n    let state = NOT_CALLED\n    let out: unknown\n    const next = () => {\n      state = CALLED\n      try {\n        out = inner(ctx, core)\n      } catch (e) {\n        state = FAILED_INSIDE\n        throw e\n      }\n      if (mayBeAsync && isThenable(out)) {\n        const p = Promise.resolve(out).then(undefined, (e: unknown) => {\n          state = FAILED_INSIDE\n          throw e\n        })\n        // Handled here so an interceptor that drops `next()` never causes an unhandled rejection;\n        // whoever awaits `p` still sees the rejection.\n        p.catch(() => {})\n        out = p\n      }\n      return out\n    }\n    const recover = (e: unknown) => {\n      if (state === FAILED_INSIDE) throw e\n      report(e, i, ctx)\n      return state === CALLED ? out : inner(ctx, core)\n    }\n    let r: unknown\n    try {\n      r = intercept(ctx, next)\n    } catch (e) {\n      return recover(e)\n    }\n    return mayBeAsync && isThenable(r) ? Promise.resolve(r).then(undefined, recover) : r\n  }\n}\n\nexport function createInterceptorRuntime(\n  options: InterceptorRuntimeOptions = {},\n): InterceptorRuntime {\n  const { emit, onCompile } = options\n  const onError =\n    options.onInterceptorError ??\n    ((error: unknown, i: Interceptor<OpName>, ctx: AnyCtx) => {\n      if (emit) {\n        emit(\n          'DK_INTERCEPTOR_FAILED',\n          { interceptor: i.name, op: ctx.op, slot: ctx.where },\n          { cause: error, run: ctx.run, trigger: ctx.trigger, phase: ctx.phase },\n        )\n      } else {\n        console.error(\n          `[DataKable] interceptor \"${i.name}\" failed on ${ctx.op} and was skipped`,\n          error,\n        )\n      }\n    })\n  const onHotWarning =\n    options.onHotWarning ??\n    ((w: HotOpWarning) => {\n      if (emit) emit('DK_HOT_INTERCEPTOR', { interceptor: w.interceptor.name, op: w.op })\n      else console.warn(`[DataKable] ${w.message}`)\n    })\n  const report = (error: unknown, i: Interceptor<OpName>, ctx: AnyCtx) => {\n    try {\n      onError(error, i, ctx)\n    } catch (e) {\n      // The reporter must never break the operation it reports on — except `strict: true`, whose\n      // DatakableError is the requested behaviour.\n      if (e instanceof DatakableError) throw e\n    }\n  }\n\n  let list: readonly Interceptor<OpName>[] = []\n  let boundary: Interceptor<OpName> | undefined\n  const chains = new Map<string, Chain>()\n  /** (interceptor, op) pairs already warned about, so recompiles do not repeat the warning. */\n  const warned = new WeakMap<Interceptor<OpName>, Set<string>>()\n\n  function warnHot(i: Interceptor<OpName>, op: string) {\n    if (!(process.env.NODE_ENV !== \"production\")) return // dev-only warning: drops the text below from production bundles\n    let ops = warned.get(i)\n    if (ops?.has(op)) return\n    if (!ops) {\n      ops = new Set()\n      warned.set(i, ops)\n    }\n    ops.add(op)\n    try {\n      onHotWarning({\n        interceptor: i,\n        op,\n        message:\n          `Interceptor \"${i.name}\" is attached to hot op \"${op}\" without hot: true. ` +\n          // Measured by intercept/chain.bench.ts (Apple M4 Pro, Node 25.2.1). Inline here, inside\n          // the (process.env.NODE_ENV !== \"production\")-only function, so production bundles carry none of it.\n          'It runs once per column per pipeline run; measured cost: ~10 ns per call per ' +\n          'interceptor (+15% on a per-cell format call, spec §9.2) on top of the interceptor ' +\n          'body, which runs columns × pipeline runs times. ' +\n          'Never loop per cell inside it. Set hot: true to accept the cost, ' +\n          'or attach it to a cold op.',\n      })\n    } catch {\n      // A warning must never break compilation.\n    }\n  }\n\n  function compile(op: string): Chain {\n    const info = getOperation(op)\n    if (!info) {\n      throw internalError(op, `Unknown operation \"${op}\": register it with registerOperation()`)\n    }\n    const mine = list.filter((i) => attaches(i, op))\n    if (boundary && attaches(boundary, op)) mine.unshift(boundary)\n    // Checked here, not when the list is set, so ops registered after creation are covered too.\n    if ((process.env.NODE_ENV !== \"production\") && info.hot) for (const i of mine) if (!i.hot) warnHot(i, op)\n    const mayBeAsync = info.kind !== 'sync'\n    const chain = mine.reduceRight<Chain>((inner, i) => wrap(i, inner, mayBeAsync, report), direct)\n    chains.set(op, chain)\n    onCompile?.(op, mine.length)\n    return chain\n  }\n\n  function compileAll() {\n    chains.clear()\n    for (const op of listOperations()) compile(op)\n  }\n\n  function setInterceptors(next: readonly Interceptor<OpName>[]) {\n    list = [...next]\n    compileAll()\n  }\n\n  setInterceptors(options.interceptors ?? [])\n\n  return {\n    run(op, ctx, core) {\n      const chain = chains.get(op) ?? compile(op)\n      return chain(ctx, core as AnyCore) as OpResult<typeof op>\n    },\n    setInterceptors,\n    installBoundary(b) {\n      if (boundary) {\n        throw internalError(\n          '*',\n          `A boundary interceptor is already installed (\"${boundary.name}\"); ` +\n            `\"${b.name}\" was rejected`,\n        )\n      }\n      boundary = b\n      compileAll()\n    },\n  }\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../../src/intercept/runtime.ts"],"sourcesContent":["import { DatakableError, internalError } from '../diagnostics/build'\nimport '../diagnostics/process-guard'\nimport type { Emit } from '../diagnostics/types'\nimport type { InterceptorContext } from './context'\nimport type { Interceptor } from './define'\nimport { getOperation, listOperations, type OpName, type OpResult } from './operations'\n\nexport type Core<O extends OpName> = (ctx: InterceptorContext<O>) => OpResult<O>\n\nexport interface HotOpWarning {\n  interceptor: Interceptor<OpName>\n  op: string\n  message: string\n}\n\nexport interface InterceptorRuntimeOptions {\n  interceptors?: readonly Interceptor<OpName>[]\n  /**\n   * The table's diagnostic emitter. When given, the default hooks below report through it:\n   * `DK_INTERCEPTOR_FAILED` and (dev only) `DK_HOT_INTERCEPTOR`. Without it they use the console.\n   */\n  emit?: Emit\n  /**\n   * An interceptor threw (or its promise rejected); it was skipped. Overrides the default report\n   * (`DK_INTERCEPTOR_FAILED` via `emit`, else console.error).\n   */\n  onInterceptorError?: (\n    error: unknown,\n    interceptor: Interceptor<OpName>,\n    ctx: InterceptorContext,\n  ) => void\n  /**\n   * An interceptor is attached to a hot op without `hot: true` (checked when the op's chain is\n   * compiled, once per interceptor + op). Overrides the default (`DK_HOT_INTERCEPTOR` via `emit`).\n   */\n  onHotWarning?: (warning: HotOpWarning) => void\n  /** Called each time a chain is compiled (tracing / tests). `length` counts the boundary too. */\n  onCompile?: (op: string, length: number) => void\n}\n\nexport interface InterceptorRuntime {\n  /** Runs `core` for `op` through the compiled chain. */\n  run<O extends OpName>(op: O, ctx: InterceptorContext<O>, core: NoInfer<Core<O>>): OpResult<O>\n  /** Replaces the user / feature interceptors and recompiles. The boundary slot is kept. */\n  setInterceptors(interceptors: readonly Interceptor<OpName>[]): void\n  /** Installs the outermost, non-removable interceptor (errorBoundary, T06). Once only. */\n  installBoundary(boundary: Interceptor<OpName>): void\n}\n\ntype AnyCtx = InterceptorContext\ntype AnyCore = (ctx: AnyCtx) => unknown\ntype Chain = (ctx: AnyCtx, core: AnyCore) => unknown\n\nconst NOT_CALLED = 0\nconst CALLED = 1\nconst FAILED_INSIDE = 2\n\nconst direct: Chain = (ctx, core) => core(ctx)\n\nconst isThenable = (v: unknown): v is PromiseLike<unknown> =>\n  v != null && typeof (v as { then?: unknown }).then === 'function'\n\nconst attaches = (i: Interceptor<OpName>, op: string) =>\n  i.on === '*' || (i.on as readonly string[]).includes(op)\n\n/**\n * Wraps one interceptor around `inner`. Skip semantics (§3.4): if the interceptor throws before\n * calling `next`, `next` runs directly; if it throws after, the result `next` produced is kept so\n * the core never runs twice. An error that came out of `next` belongs to an inner layer and is\n * rethrown untouched. Async results get the same rules on rejection.\n */\nfunction wrap(\n  i: Interceptor<OpName>,\n  inner: Chain,\n  mayBeAsync: boolean,\n  report: (error: unknown, i: Interceptor<OpName>, ctx: AnyCtx) => void,\n): Chain {\n  const intercept = i.intercept as (ctx: AnyCtx, next: () => unknown) => unknown\n  return (ctx, core) => {\n    let state = NOT_CALLED\n    let out: unknown\n    const next = () => {\n      state = CALLED\n      try {\n        out = inner(ctx, core)\n      } catch (e) {\n        state = FAILED_INSIDE\n        throw e\n      }\n      if (mayBeAsync && isThenable(out)) {\n        const p = Promise.resolve(out).then(undefined, (e: unknown) => {\n          state = FAILED_INSIDE\n          throw e\n        })\n        // Handled here so an interceptor that drops `next()` never causes an unhandled rejection;\n        // whoever awaits `p` still sees the rejection.\n        p.catch(() => {})\n        out = p\n      }\n      return out\n    }\n    const recover = (e: unknown) => {\n      if (state === FAILED_INSIDE) throw e\n      report(e, i, ctx)\n      return state === CALLED ? out : inner(ctx, core)\n    }\n    let r: unknown\n    try {\n      r = intercept(ctx, next)\n    } catch (e) {\n      return recover(e)\n    }\n    return mayBeAsync && isThenable(r) ? Promise.resolve(r).then(undefined, recover) : r\n  }\n}\n\nexport function createInterceptorRuntime(\n  options: InterceptorRuntimeOptions = {},\n): InterceptorRuntime {\n  const { emit, onCompile } = options\n  const onError =\n    options.onInterceptorError ??\n    ((error: unknown, i: Interceptor<OpName>, ctx: AnyCtx) => {\n      if (emit) {\n        emit(\n          'DK_INTERCEPTOR_FAILED',\n          { interceptor: i.name, op: ctx.op, slot: ctx.where },\n          { cause: error, run: ctx.run, trigger: ctx.trigger, phase: ctx.phase },\n        )\n      } else {\n        console.error(\n          `[DataKable] interceptor \"${i.name}\" failed on ${ctx.op} and was skipped`,\n          error,\n        )\n      }\n    })\n  // Dev-only (DK_HOT_INTERCEPTOR): `undefined` in production, with the code and its text.\n  const onHotWarning = (process.env.NODE_ENV !== \"production\")\n    ? (options.onHotWarning ??\n      ((w: HotOpWarning) => {\n        if (emit) emit('DK_HOT_INTERCEPTOR', { interceptor: w.interceptor.name, op: w.op })\n        else console.warn(`[DataKable] ${w.message}`)\n      }))\n    : undefined\n  const report = (error: unknown, i: Interceptor<OpName>, ctx: AnyCtx) => {\n    try {\n      onError(error, i, ctx)\n    } catch (e) {\n      // The reporter must never break the operation it reports on — except `strict: true`, whose\n      // DatakableError is the requested behaviour.\n      if (e instanceof DatakableError) throw e\n    }\n  }\n\n  let list: readonly Interceptor<OpName>[] = []\n  let boundary: Interceptor<OpName> | undefined\n  const chains = new Map<string, Chain>()\n  /** (interceptor, op) pairs already warned about, so recompiles do not repeat the warning. */\n  const warned = (process.env.NODE_ENV !== \"production\") ? new WeakMap<Interceptor<OpName>, Set<string>>() : undefined\n\n  function warnHot(i: Interceptor<OpName>, op: string) {\n    if (!(process.env.NODE_ENV !== \"production\") || !warned || !onHotWarning) return // dev-only: production bundles drop the text below\n    let ops = warned.get(i)\n    if (ops?.has(op)) return\n    if (!ops) {\n      ops = new Set()\n      warned.set(i, ops)\n    }\n    ops.add(op)\n    try {\n      onHotWarning({\n        interceptor: i,\n        op,\n        message:\n          `Interceptor \"${i.name}\" is attached to hot op \"${op}\" without hot: true. ` +\n          // Measured by intercept/chain.bench.ts (Apple M4 Pro, Node 25.2.1). Inline here, inside\n          // the (process.env.NODE_ENV !== \"production\")-only function, so production bundles carry none of it.\n          'It runs once per column per pipeline run; measured cost: ~10 ns per call per ' +\n          'interceptor (+15% on a per-cell format call, spec §9.2) on top of the interceptor ' +\n          'body, which runs columns × pipeline runs times. ' +\n          'Never loop per cell inside it. Set hot: true to accept the cost, ' +\n          'or attach it to a cold op.',\n      })\n    } catch {\n      // A warning must never break compilation.\n    }\n  }\n\n  function compile(op: string): Chain {\n    const info = getOperation(op)\n    if (!info) {\n      throw internalError(op, `unknown-op|${op}`)\n    }\n    const mine = list.filter((i) => attaches(i, op))\n    if (boundary && attaches(boundary, op)) mine.unshift(boundary)\n    // Checked here, not when the list is set, so ops registered after creation are covered too.\n    if ((process.env.NODE_ENV !== \"production\") && info.hot) for (const i of mine) if (!i.hot) warnHot(i, op)\n    const mayBeAsync = info.kind !== 'sync'\n    const chain = mine.reduceRight<Chain>((inner, i) => wrap(i, inner, mayBeAsync, report), direct)\n    chains.set(op, chain)\n    onCompile?.(op, mine.length)\n    return chain\n  }\n\n  function compileAll() {\n    chains.clear()\n    for (const op of listOperations()) compile(op)\n  }\n\n  function setInterceptors(next: readonly Interceptor<OpName>[]) {\n    list = [...next]\n    compileAll()\n  }\n\n  setInterceptors(options.interceptors ?? [])\n\n  return {\n    run(op, ctx, core) {\n      const chain = chains.get(op) ?? compile(op)\n      return chain(ctx, core as AnyCore) as OpResult<typeof op>\n    },\n    setInterceptors,\n    installBoundary(b) {\n      if (boundary) {\n        throw internalError('*', `boundary-twice|${boundary.name}|${b.name}`)\n      }\n      boundary = b\n      compileAll()\n    },\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/messages/index.cjs

@@ -26,6 +26,7 @@ module.exports = __toCommonJS(messages_exports);
 var import_codes = require("../catalog/codes.cjs");
 var import_catalog = require("../diagnostics/catalog.cjs");
 var import_codes2 = require("../diagnostics/codes.cjs");
+var import_prose = require("../diagnostics/prose.cjs");
 var import_redact = require("../diagnostics/redact.cjs");
 var import_codes3 = require("../feature/codes.cjs");
 var import_codes4 = require("../features/column-filters/codes.cjs");
@@ -64,7 +65,9 @@ var allMessages = [
   import_codes6.searchMessages,
   import_codes7.sortingMessages,
   import_codes5.paginationMessages,
-  import_env_codes.envMessages
+  import_env_codes.envMessages,
+  // The detail sentences production keeps as keys (`fallback: 'cells-undefined'`).
+  import_prose.proseMessages
 ];
 (0, import_catalog.installMessages)(...allMessages);
 // Annotate the CommonJS export names for ESM import in node: