quario 0.1.0 → 0.3.0

package/lib/plan.js

@@ -31,21 +31,32 @@
 // Each engine's own predicate, not the union `locate.js` exports: every call
 // site knows which engine it just called, and asking that one is what stops a
 // sjabloon-shaped error being trusted where an xprsn error was expected.
-import { isDiagnostic as isQueryDiagnostic, query } from "padvinder";
-import { compile, isDiagnostic as isXprsnDiagnostic } from "xprsn";
-import { isDiagnostic as isTemplateDiagnostic, template } from "sjabloon";
-import { err, locate } from "./locate.js";
+import { isDiagnostic as isQueryDiagnostic, query, relocate as relocateQuery } from "padvinder";
+import {
+  compile,
+  isDiagnostic as isXprsnDiagnostic,
+  relocate as relocateXprsn,
+  signatures,
+} from "xprsn";
+import {
+  isDiagnostic as isTemplateDiagnostic,
+  relocate as relocateTemplate,
+  template,
+} from "sjabloon";
+import { LOCATION, fault, isDiagnostic, locate } from "./locate.js";
 import { ANCHORS, BLOCKED, NAME, RESERVED, record } from "./names.js";
 import { AGG, REDUCERS, RUN, aggregateValue, withRow } from "./scope.js";
 import { opt, sniff } from "./stream.js";
-import { checkImageStyle, checkStyle } from "./style.js";
-
-// Default traversal budget for the data query. Render input is untrusted, so
-// without a bound a deep document exhausts the native stack as an opaque
-// RangeError; with it, padvinder throws a typed PADVINDER_MAX_DEPTH diagnostic
-// long before that. Hosts override (or effectively disable) it per key through
-// `options.query`. 500 is ~4x inside the stack limit and far beyond report data.
-let QUERY = { maxDepth: 500 };
+import {
+  checkBorderSides,
+  checkCellStyle,
+  checkImageStyle,
+  checkReportStyle,
+  checkRowStyle,
+  checkSlotImageStyle,
+  checkSlotStyle,
+  checkStyle,
+} from "./style.js";
 
 // Tolerance on the column-width sum. Widths are literal numbers an author may
 // write as thirds, so an exact comparison rejects 33.3 x 3 for a rounding error
@@ -67,19 +78,58 @@ let isExpr = (value) => typeof value === "string" && value[0] === "=";
 let collect = (from, into) => {
   for (let name of from) into.add(name);
 };
-/** @type {(from: Iterable<string>, bound: Set<string>, into: Set<string>) => void} */
-let collectFree = (from, bound, into) => {
-  for (let name of from) {
-    // oxlint-disable-next-line no-unused-expressions
-    bound.has(name) || into.add(name);
-  }
-};
 /** @type {(visible: any, scope: any) => any} */
 let hidden = (visible, scope) => visible && visible(scope) === false;
+
+// A text item's closed key set, and the same set inside a split, where the
+// slot's width share joins it.
+let TEXT_KEYS = ["type", "value", "visible", "style"];
+let TEXT_SLOT_KEYS = [...TEXT_KEYS, "width"];
+let IMAGE_KEYS = ["type", "source", "fit", "alt", "visible", "style"];
+let IMAGE_SLOT_KEYS = [...IMAGE_KEYS, "width"];
+
+// Which detail events carry the row's running values: the ones holding a cell.
+// A split's bracket holds none, so run rides the item and image events inside
+// it rather than the bracket around them.
+/** @type {(event: any) => boolean} */
+let carriesRun = (event) => event.type === "item" || event.type === "image";
 /** @type {(value: any, path: string, role: string, itemsOf: any) => any} */
 let maybeItems = (value, path, role, itemsOf) =>
   value != null ? itemsOf(value, path, role) : null;
 
+// The width-share rule, shared by a table's columns and a split's slots: the
+// two carry the same percentages under the same arithmetic, and one reader for
+// both is what keeps them from drifting into two rules wearing one name.
+/** @type {(sized: boolean, noun: string) => string} */
+let shareMsg = (sized, noun) =>
+  sized
+    ? "expected " + noun + " widths to total at most 100"
+    : "expected " +
+      noun +
+      " widths to total under 100, leaving room for the " +
+      noun +
+      "s without one";
+// The authored shares worth summing, or null when there is nothing to decide.
+// Nothing authored is nothing to check; a width out of range (a NaN, per the
+// width verdict) already carries its own problem, and one nobody can read
+// leaves it undecidable whether its part is one of those needing room.
+/** @type {(parts: { width?: any }[]) => number[] | null} */
+let sharesOf = (parts) => {
+  let shares = parts.map((part) => part.width).filter((width) => width != null);
+  return !shares.length || shares.some(Number.isNaN) ? null : shares;
+};
+// Authored shares must leave room for the parts without one. Widths are
+// literal, so the sum is known here; a tolerance keeps three at 33.3 from
+// summing to 100.00000000000001 and failing on IEEE 754 alone.
+/** @type {(bad: any, parts: { width?: any }[], path: string, noun: string) => void} */
+let checkShares = (bad, parts, path, noun) => {
+  let shares = sharesOf(parts);
+  if (!shares) return;
+  let total = shares.reduce((all, width) => all + width, 0);
+  let sized = shares.length === parts.length;
+  if (total > (sized ? 100 + WIDTH_EPS : 100 - WIDTH_EPS)) bad(path, shareMsg(sized, noun));
+};
+
 // One pass over a report's constants: it checks each value, copies it, and
 // freezes the copy. Copying is what keeps a consumer from reaching back into
 // the compiled schema through a nested object; freezing is what stops them
@@ -202,18 +252,42 @@ let planState = (schema, funcs) => {
   let BND = new Set(ANCHORS);
   bindHandles(schema, BND);
 
-  /** @type {string[]} */
+  // Structured problems: the path was a live value at every site that reports
+  // one, so it is kept as a field rather than recovered from the message. The
+  // message stays the whole located string — `validate()`'s view is
+  // `problems.map((p) => p.message)`, unchanged.
+  /** @type {{ path: string, source?: string, message: string, diagnostic?: any }[]} */
   let problems = [];
   // Kept so `events()` rethrows the engine's located error, not a bare one.
   /** @type {any} */
   let firstDiag = null;
+  // Where a caught error says it happened: `locate()` stamps that on the copy
+  // it throws, so nothing here parses a message back apart.
+  /** @type {(error: any) => { path: string, source?: any }} */
+  let where = (error) => (error && error[LOCATION]) || { path: "" };
+  // A caught error carries its location as data (locate.js), so the problem
+  // keeps the path and source structurally; the diagnostic rides along per
+  // problem — every problem keeps its offsets, not only the first.
+  /** @type {(msg: string, error?: any) => any} */
+  let located = (msg, error) => {
+    let at = where(error);
+    /** @type {any} */
+    let problem = { path: at.path, message: msg };
+    if (at.source !== undefined) problem.source = String(at.source);
+    if (isDiagnostic(error)) problem.diagnostic = error;
+    return problem;
+  };
   /** @type {(msg: string, error?: any) => void} */
   let add = (msg, error) => {
-    if (!problems.length && error && Object.hasOwn(error, "code")) firstDiag = error;
-    problems.push(msg);
+    // Identity, not shape: locate() copies an untrusted host throw with
+    // `new error.constructor(...)`, so a host class that stamps `code` on
+    // itself produces a copy shaped like a diagnostic. Only an error the
+    // engines authenticated is worth rethrowing as one (quario-lkz).
+    if (!problems.length && isDiagnostic(error)) firstDiag = error;
+    problems.push(located(msg, error));
   };
   /** @type {(path: string, msg: string) => void} */
-  let bad = (path, msg) => add(path + ": " + msg);
+  let bad = (path, msg) => problems.push({ path, message: path + ": " + msg });
   // Record a throwing compile step and stand in a stub, so the traversal reports
   // the whole definition rather than only its first fault.
   /** @type {<T>(fn: () => T, fallback: T) => T} */
@@ -231,6 +305,22 @@ let planState = (schema, funcs) => {
   /** @type {Set<string>} */
   let runNames = new Set();
 
+  // Which anchors each compiled source actually reads, keyed by its schema
+  // path. Retention, not computation: the engines report every root-name read
+  // in `.reads` — the unfiltered view `bound` keeps out of `.names` — and this
+  // keeps the anchor-and-handle subset a consumer placing a node needs.
+  /** @type {Map<string, Set<string>>} */
+  let anchors = new Map();
+  /** @type {(path: string, reads: { name: string }[]) => void} */
+  let anchorsOf = (path, reads) => {
+    for (let { name } of reads) {
+      if (!BND.has(name)) continue;
+      let set = anchors.get(path);
+      if (!set) anchors.set(path, (set = new Set()));
+      set.add(name);
+    }
+  };
+
   return {
     FNS,
     names,
@@ -238,6 +328,8 @@ let planState = (schema, funcs) => {
     BND,
     problems,
     runNames,
+    anchors,
+    anchorsOf,
     add,
     bad,
     attempt,
@@ -255,7 +347,7 @@ let compileProp = (source, path, FNS, BND) => {
   try {
     return compile(source.slice(1), FNS, { bound: BND });
   } catch (error) {
-    locate(path, source, error, 1, isXprsnDiagnostic(error));
+    locate(path, source, error, isXprsnDiagnostic(error) && relocateXprsn, 1);
   }
 };
 /** @type {(expression: any, path: string, source: any) => Eval} */
@@ -263,23 +355,23 @@ let runProp = (expression, path, source) => (scope) => {
   try {
     return expression(scope);
   } catch (error) {
-    locate(path, source, error, 1, expression.isDiagnostic(error));
+    locate(path, source, error, expression.isDiagnostic(error) && relocateXprsn, 1);
   }
 };
-/** @type {(src: string, path: string, source: any, FNS: any) => any} */
-let compileCell = (src, path, source, FNS) => {
+/** @type {(src: string, path: string, source: any, FNS: any, BND: Set<string>) => any} */
+let compileCell = (src, path, source, FNS, BND) => {
   try {
-    return template(src, FNS);
+    return template(src, FNS, { bound: BND });
   } catch (error) {
-    locate(path, source, error, 0, isTemplateDiagnostic(error));
+    locate(path, source, error, isTemplateDiagnostic(error) && relocateTemplate);
   }
 };
-/** @type {(tokens: any, path: string, source: any) => (scope: Scope, opts?: any) => any} */
-let runCell = (tokens, path, source) => (scope, opts) => {
+/** @type {(tokens: any, path: string, source: any) => (scope: Scope) => any} */
+let runCell = (tokens, path, source) => (scope) => {
   try {
-    return tokens(scope, opts);
+    return tokens.scoped(scope);
   } catch (error) {
-    locate(path, source, error, 0, isTemplateDiagnostic(error));
+    locate(path, source, error, tokens.isDiagnostic(error) && relocateTemplate);
   }
 };
 /** @type {(source: any) => string} */
@@ -293,16 +385,16 @@ let splitFold = (spec) => {
 /** @type {(colon: number, path: string) => void} */
 let checkCount = (colon, path) => {
   // oxlint-disable-next-line no-unused-expressions
-  colon < 0 || err(path + ": count does not take an expression");
+  colon < 0 || fault(path, "count does not take an expression");
 };
 /** @type {(src: string, fn: string, path: string) => void} */
 let checkExprFold = (src, fn, path) => {
   // oxlint-disable-next-line no-unused-expressions
-  (src.startsWith("=") && src.length > 1) || err(path + ': expected "' + fn + ':=<expression>"');
+  (src.startsWith("=") && src.length > 1) || fault(path, 'expected "' + fn + ':=<expression>"');
 };
 
 /** @param {State} state */
-let primitives = ({ FNS, BND, names, functions }) => {
+let primitives = ({ FNS, BND, names, functions, anchorsOf }) => {
   // A computed property: a literal, or an `=` xprsn expression. xprsn's
   // `bound` keeps engine-provided anchors/handles out of the reported `names`.
   /** @type {(spec: any, path: string) => Eval} */
@@ -311,23 +403,27 @@ let primitives = ({ FNS, BND, names, functions }) => {
     let expression = compileProp(source, path, FNS, BND);
     collect(expression.names, names);
     collect(expression.functions, functions);
+    anchorsOf(path, expression.reads);
     return runProp(expression, path, source);
   };
 
-  // A text cell: a sjabloon template, compiled with the token edition. Rendered
-  // with distinct `{ root, item }` anchors, so `@` is the current row and `$`
-  // is the report root. sjabloon already excludes its own loop vars / `$` / `@`;
-  // we drop quario's engine names (run, group handles) from the reported
-  // `names` too. A render yields the cell's public token stream: literal runs
-  // verbatim plus each interpolation's pre-stringify value. Templates have no
-  // raw form — a `{{{ }}}` tag is a located SJABLOON_RAW_TAG definition error —
-  // so escaping is entirely a render-target concern at the markup edge,
-  // with no exceptions to carry through the stream.
-  /** @type {(str: any, path: string) => (scope: Scope, opts?: any) => any} */
+  // A text cell: a sjabloon template, compiled with the token edition and
+  // rendered over quario's own scope chain, which already binds the anchors:
+  // `$` at the render base, `@` on the detail row, neither anywhere else — so
+  // a group or report band leaves `@` unbound and a stray `@.field` throws.
+  // sjabloon's `bound` excludes its loop vars / `$` / `@` and quario's engine
+  // names alike from the reported `names`. A render yields the cell's public
+  // token stream: literal runs verbatim plus each interpolation's
+  // pre-stringify value. Templates have no raw form — a `{{{ }}}` tag is a
+  // located SJABLOON_RAW_TAG definition error — so escaping is entirely a
+  // render-target concern at the markup edge, with no exceptions to carry
+  // through the stream.
+  /** @type {(str: any, path: string) => (scope: Scope) => any} */
   let cell = (source, path) => {
-    let tokens = compileCell(asText(source), path, source, FNS);
-    collectFree(tokens.names, BND, names);
+    let tokens = compileCell(asText(source), path, source, FNS, BND);
+    collect(tokens.names, names);
     collect(tokens.functions, functions);
+    anchorsOf(path, tokens.reads);
     return runCell(tokens, path, source);
   };
 
@@ -337,7 +433,7 @@ let primitives = ({ FNS, BND, names, functions }) => {
   let parseFold = (spec, path, allowed) => {
     let { fn, src, colon } = splitFold(spec);
     // oxlint-disable-next-line no-unused-expressions
-    allowed.has(fn) || err(path + ': unknown reducer "' + fn + '"');
+    allowed.has(fn) || fault(path, 'unknown reducer "' + fn + '"');
     if (fn === "count") checkCount(colon, path);
     else checkExprFold(src, fn, path);
     return { fn, per: src ? prop(src, path) : null };
@@ -371,10 +467,16 @@ let readers = ({ bad, attempt }, { prop, cell, parseFold }) => {
   };
   // Every schema object is a closed set, so typos and misplaced fields
   // (page.size, sort on a table detail) fail loud instead of doing nothing.
+  // One schema path from a parent's and a key. The document root's path is the
+  // empty string, so the dot is conditional -- `style.family`, never
+  // `.style.family`. Every reader that can be reached with the root joins
+  // through here rather than restating the rule.
+  /** @type {(path: string, key: string) => string} */
+  let pathTo = (path, key) => (path ? path + "." + key : key);
   /** @type {(value: any, allowed: string[], path: string) => void} */
   let keys = (value, allowed, path) => {
     for (let key of Object.keys(value))
-      if (!allowed.includes(key)) bad(path ? path + "." + key : key, 'unknown key "' + key + '"');
+      if (!allowed.includes(key)) bad(pathTo(path, key), 'unknown key "' + key + '"');
   };
   /** @type {(name: string, path: string, reserved?: Set<string> | null) => void} */
   let checkName = (name, path, reserved) => {
@@ -448,7 +550,7 @@ let readers = ({ bad, attempt }, { prop, cell, parseFold }) => {
     /** @type {[string, Eval][]} */
     let entries = [];
     for (let [name, value] of Object.entries(block)) {
-      let stylePath = path + ".style." + name;
+      let stylePath = path + "." + name;
       let problem = check(name, value);
       if (problem) bad(stylePath, problem);
       else entries.push([name, attempt(() => prop(value, stylePath), NIL)]);
@@ -470,6 +572,7 @@ let readers = ({ bad, attempt }, { prop, cell, parseFold }) => {
    */
   let compileStyles = (block, path, check) => {
     let entries = readStyles(block, path, check);
+    for (let [name, msg] of checkBorderSides(block, check)) bad(path + "." + name, msg);
     if (!entries.length) return NIL;
     let resolve = styleFn(entries);
     if (isComputed(block)) return resolve;
@@ -482,8 +585,9 @@ let readers = ({ bad, attempt }, { prop, cell, parseFold }) => {
    */
   let stylesOf = (def, path, check = checkStyle) => {
     let block = def.style;
-    if (block == null || !obj(block, path + ".style")) return NIL;
-    return compileStyles(block, path, check);
+    let stylePath = pathTo(path, "style");
+    if (block == null || !obj(block, stylePath)) return NIL;
+    return compileStyles(block, stylePath, check);
   };
   // A cell value: one sjabloon template. Emphasis is the cell's own `style`;
   // markup in literal text is meaningful only to the HTML target.
@@ -617,28 +721,26 @@ let readers = ({ bad, attempt }, { prop, cell, parseFold }) => {
 let nodes = ({ bad }, { arr, obj, keys, expression, cellValue, visibleOf, stylesOf }) => {
   // `tokens` plus its truthy `style`. A hidden cell keeps its slot with no
   // tokens so a column keeps its alignment; items pass `visible` null and drop
-  // themselves instead, having no slot to keep.
+  // themselves instead, having no slot to keep. The anchor story lives on
+  // `cell` in primitives: the scope chain itself carries `$` and `@`.
   /**
    * @type {(tpl: any, visible: Eval | null, styles: (scope: Scope) => any)
-   *   => (scope: Scope, item?: any) => any}
+   *   => (scope: Scope) => any}
    */
-  let cellShape = (tpl, visible, styles) => (scope, item) =>
-    opt(
-      { tokens: hidden(visible, scope) ? [] : tpl(scope, { root: scope["$"], item }) },
-      { style: styles(scope) },
-    );
+  let cellShape = (tpl, visible, styles) => (scope) =>
+    opt({ tokens: hidden(visible, scope) ? [] : tpl(scope) }, { style: styles(scope) });
 
   // A table cell: the shape of a total cell and of an object column header.
-  /** @type {(def: any, path: string, valuePath?: string) => (scope: Scope, item?: any) => any} */
+  /** @type {(def: any, path: string, valuePath?: string) => (scope: Scope) => any} */
   let cellOf = (def, path, valuePath = path + ".value") => {
     let tpl = cellValue(def.value, valuePath);
     let visible = visibleOf(def, path);
-    return cellShape(tpl, visible, stylesOf(def, path));
+    return cellShape(tpl, visible, stylesOf(def, path, checkCellStyle));
   };
 
   // A cell without a row, so `@` stays unbound. A bare string is shorthand for
   // `{ value }` and keeps its authored path, so problems locate where written.
-  /** @type {(def: any, path: string) => (scope: Scope, item?: any) => any} */
+  /** @type {(def: any, path: string) => (scope: Scope) => any} */
   let headerOf = (def, path) => {
     if (typeof def === "string") return cellShape(cellValue(def, path), null, NIL);
     if (!record(def)) {
@@ -664,14 +766,14 @@ let nodes = ({ bad }, { arr, obj, keys, expression, cellValue, visibleOf, styles
     let header = headerOf(def.header, path + ".header");
     let tpl = cellValue(def.value, path + ".value");
     let visible = visibleOf(def, path);
-    let styles = stylesOf(def, path);
+    let styles = stylesOf(def, path, checkCellStyle);
     // A width is a percentage of the table width, resolved by every target.
     // The range verdict is owned here: an unreadable width comes back as NaN,
     // so the total check below reads the verdict instead of re-deciding it.
-    return { header, cell: cellShape(tpl, visible, styles), width: widthOf(def.width, path) };
+    return { header, cell: cellShape(tpl, visible, styles), width: widthOf(def.width, path), path };
   };
 
-  /** @type {(def: any, path: string) => ((scope: Scope, item?: any) => any) | null} */
+  /** @type {(def: any, path: string) => ((scope: Scope) => any) | null} */
   let totalOf = (def, path) => {
     if (!obj(def, path)) return null;
     keys(def, ["value", "visible", "style"], path);
@@ -679,29 +781,42 @@ let nodes = ({ bad }, { arr, obj, keys, expression, cellValue, visibleOf, styles
   };
 
   // A text item: a cell with no slot to keep, so a hidden one drops itself
-  // instead of keeping empty tokens the way a table cell does.
-  /** @type {(def: any, path: string, role: string) => (scope: Scope, item?: any) => any} */
-  let textOf = (def, path, role) => {
-    keys(def, ["type", "value", "visible", "style"], path);
-    // The fallback shape, so an unknown `type` is reported here -- after this
-    // node's key set, in the documented key order -- and then read as text, so
-    // the rest of its keys are checked rather than left behind the one problem.
-    if (def.type !== "text")
-      bad(path + ".type", def.type == null ? "required" : 'unknown item type "' + def.type + '"');
+  // instead of keeping empty tokens the way a table cell does. Inside a split
+  // it is the other way round -- a slot holds its place with empty tokens, so
+  // the line's geometry does not move with the data (SCHEMA.md, "Split item").
+  /** @type {(def: any, path: string, role: string, inSlot?: boolean) => (scope: Scope) => any} */
+  let textOf = (def, path, role, inSlot = false) => {
+    keys(def, inSlot ? TEXT_SLOT_KEYS : TEXT_KEYS, path);
+    checkTextType(def.type, path);
     let tpl = cellValue(def.value, path + ".value");
     let visible = visibleOf(def, path);
-    let shape = cellShape(tpl, null, stylesOf(def, path));
+    let shape = cellShape(
+      tpl,
+      inSlot ? visible : null,
+      stylesOf(def, path, inSlot ? checkSlotStyle : checkStyle),
+    );
     // The cell shape first, then the item's own fields, so a cell reads
     // the same wherever it appears in the stream.
-    return (scope, item) => {
-      if (hidden(visible, scope)) return null;
-      let event = shape(scope, item);
+    return (scope) => {
+      if (!inSlot && hidden(visible, scope)) return null;
+      let event = shape(scope);
       event.type = "item";
       event.role = role;
+      event.path = path;
       return event;
     };
   };
 
+  // The fallback shape's verdict on a `type` it does not name, reported after
+  // this node's key set and in the documented key order -- and then read as
+  // text, so the rest of its keys are checked rather than left behind the one
+  // problem.
+  /** @type {(type: any, path: string) => void} */
+  let checkTextType = (type, path) => {
+    if (type === "text") return;
+    bad(path + ".type", type == null ? "required" : 'unknown item type "' + type + '"');
+  };
+
   /** @type {(fit: any, path: string) => void} */
   let checkFit = (fit, path) => {
     if (fit == null || fit === "natural" || fit === "width") return;
@@ -709,10 +824,10 @@ let nodes = ({ bad }, { arr, obj, keys, expression, cellValue, visibleOf, styles
   };
   /** @type {(def: any, path: string) => any} */
   let altOf = (def, path) => (def.alt != null ? cellValue(def.alt, path + ".alt") : null);
-  /** @type {(alt: any, scope: Scope, item?: any) => any} */
-  let imageAlt = (alt, scope, item) => alt && alt(scope, { root: scope["$"], item });
-  /** @type {(fields: any, scope: Scope, item: any, bytes: any) => any} */
-  let imageEvent = (fields, scope, item, bytes) => {
+  /** @type {(alt: any, scope: Scope) => any} */
+  let imageAlt = (alt, scope) => alt && alt(scope);
+  /** @type {(fields: any, scope: Scope, bytes: any) => any} */
+  let imageEvent = (fields, scope, bytes) => {
     // The bytes stay bytes. Sniffing reads their magic numbers -- it never
     // decodes the image, and nothing here turns them into a string -- and
     // the answer rides on the event so no target sniffs a second time.
@@ -728,52 +843,127 @@ let nodes = ({ bad }, { arr, obj, keys, expression, cellValue, visibleOf, styles
         TypeError("expected a Uint8Array of PNG or JPEG bytes"),
       );
     return opt(
-      { type: "image", role: fields.role, bytes, format, fit: fields.fit },
-      { alt: imageAlt(fields.alt, scope, item), style: fields.styles(scope) },
+      { type: "image", role: fields.role, bytes, format, fit: fields.fit, path: fields.path },
+      { alt: imageAlt(fields.alt, scope), style: fields.styles(scope) },
     );
   };
-  /** @type {(fields: any) => (scope: Scope, item?: any) => any} */
-  let renderImage = (fields) => (scope, item) => {
+  /** @type {(fields: any) => (scope: Scope) => any} */
+  let renderImage = (fields) => (scope) => {
     if (hidden(fields.visible, scope)) return null;
     let bytes = fields.source(scope);
     // Nullish is the missing-data twin of `visible: false`: no event and no
     // error, so a report whose input sometimes lacks a logo needs no guard.
     if (bytes == null) return null;
-    return imageEvent(fields, scope, item, bytes);
+    return imageEvent(fields, scope, bytes);
   };
   // An image item: bytes an `=` expression yields, sized by `fit`, with an
   // optional textual stand-in. JSON has no way to write bytes, so `source` is
   // expression-only; the vocabulary an image accepts is `style.js`'s to narrow.
-  /** @type {(def: any, path: string, role: string) => (scope: Scope, item?: any) => any} */
-  let imageOf = (def, path, role) => {
-    keys(def, ["type", "source", "fit", "alt", "visible", "style"], path);
+  /** @type {(inSlot: boolean) => (name: string, value: any) => string | null} */
+  let imageLook = (inSlot) => (inSlot ? checkSlotImageStyle : checkImageStyle);
+  /** @type {(def: any, path: string, role: string, inSlot?: boolean) => (scope: Scope) => any} */
+  let imageOf = (def, path, role, inSlot = false) => {
+    keys(def, inSlot ? IMAGE_SLOT_KEYS : IMAGE_KEYS, path);
     let source = expression(def.source, path + ".source");
     checkFit(def.fit, path + ".fit");
-    return renderImage({
+    // Read in the documented key order, and each read once: `stylesOf` reports
+    // as it reads, so compiling it twice would report this node's style
+    // problems twice, and reading it early would report them out of order.
+    let alt = altOf(def, path);
+    let visible = visibleOf(def, path);
+    let styles = stylesOf(def, path, imageLook(inSlot));
+    let render = renderImage({
       source,
       fit: def.fit ?? "natural",
-      alt: altOf(def, path),
-      visible: visibleOf(def, path),
-      styles: stylesOf(def, path, checkImageStyle),
+      alt,
+      visible,
+      styles,
       path,
       sourceSpec: def.source,
       role,
     });
+    if (!inSlot) return render;
+    // A slot keeps its place whatever the data does: a hidden image, or a
+    // nullish source, leaves the same empty-token placeholder a hidden text
+    // slot leaves, so the widths either side of it do not move. `cellShape`
+    // with no template is that placeholder, so the two cannot drift.
+    let empty = cellShape(EMPTY, null, styles);
+    return (scope) => render(scope) ?? { ...empty(scope), type: "item", role };
+  };
+
+  // One slot of a split: an ordinary item, plus the width share that is a slot
+  // property rather than an item one -- which is why `width` reaches an item's
+  // key set only here (docs/adr/0029).
+  /**
+   * @type {(def: any, path: string, role: string)
+   *   => { render: (scope: Scope) => any, width: any } | null}
+   */
+  let slotOf = (def, path, role) => {
+    if (!obj(def, path)) return null;
+    // Placement inside placement is the coordinate system quario does not
+    // have, so the nesting verdict is named rather than left to read as an
+    // unknown item type.
+    if (def.type === "split") {
+      bad(path + ".type", "a split cannot nest");
+      return null;
+    }
+    return {
+      render: (def.type === "image" ? imageOf : textOf)(def, path, role, true),
+      width: widthOf(def.width, path),
+    };
+  };
+
+  // A split: slots placed across the content width, bracketed in the stream so
+  // every slot crosses as the ordinary item or image event it already is.
+  /** @type {(def: any, path: string, role: string) => (scope: Scope) => any} */
+  let splitOf = (def, path, role) => {
+    keys(def, ["type", "slots", "visible", "style"], path);
+    let list = arr(def.slots, path + ".slots", true);
+    let defs = list || [];
+    // Two is the floor: a one-slot split is a text item wearing more syntax,
+    // and permitting it would be a second way to say one thing. Read off the
+    // array `arr` accepted, so a missing `slots` reports "required" once
+    // rather than that and this.
+    if (list && defs.length < 2) bad(path + ".slots", "expected at least two slots");
+    let slots = defs
+      .map((slot, i) => slotOf(slot, path + ".slots[" + i + "]", role))
+      .filter((slot) => slot != null);
+    checkShares(bad, slots, path + ".slots", "slot");
+    let visible = visibleOf(def, path);
+    let styles = stylesOf(def, path);
+    // Every width is a literal the traversal already resolved, so the geometry
+    // the bracket carries is the same array on every render -- built here
+    // rather than rebuilt per row in a detail band. Frozen because one array
+    // now reaches every render: a consumer must not be able to reach back
+    // through an event and change what a later render sees.
+    let geometry = Object.freeze(
+      slots.map((slot) => Object.freeze(opt({}, { width: slot.width }))),
+    );
+    return (scope) => {
+      if (hidden(visible, scope)) return null;
+      let out = [opt({ type: "split-start", role, slots: geometry }, { style: styles(scope) })];
+      for (let slot of slots) out.push(slot.render(scope));
+      out.push({ type: "split-end" });
+      return out;
+    };
   };
 
-  /** @type {(def: any, itemPath: string, role: string) => ((scope: Scope, item?: any) => any) | null} */
+  /** @type {(def: any, itemPath: string, role: string) => ((scope: Scope) => any) | null} */
   let itemOf = (def, itemPath, role) => {
     if (!obj(def, itemPath)) return null;
     // `type` picks the item's shape; `textOf` owns the verdict on the ones
     // it does not name, having the closed key set that reports first.
+    if (def.type === "split") return splitOf(def, itemPath, role);
     return (def.type === "image" ? imageOf : textOf)(def, itemPath, role);
   };
-  /** @type {(list: ((scope: Scope, item?: any) => any)[]) => (scope: Scope, item?: any) => Generator<any>} */
+  /** @type {(list: ((scope: Scope) => any)[]) => (scope: Scope) => Generator<any>} */
   let yieldItems = (list) =>
-    function* (scope, item) {
+    function* (scope) {
       for (let render of list) {
-        let event = render(scope, item);
-        if (event) yield event;
+        let event = render(scope);
+        // A split renders to its whole bracket; every other item to one event.
+        if (Array.isArray(event)) yield* event;
+        else if (event) yield event;
       }
     };
 
@@ -781,10 +971,10 @@ let nodes = ({ bad }, { arr, obj, keys, expression, cellValue, visibleOf, styles
   // `q-<role>` class, which print CSS targets for styling and breaks.
   /**
    * @type {(value: any, path: string, role: string)
-   *   => (scope: Scope, item?: any) => Generator<any>}
+   *   => (scope: Scope) => Generator<any>}
    */
   let itemsOf = (value, path, role) => {
-    /** @type {((scope: Scope, item?: any) => any)[]} */
+    /** @type {((scope: Scope) => any)[]} */
     let list = [];
     for (let [i, def] of (arr(value, path) || []).entries()) {
       let render = itemOf(def, path + "[" + i + "]", role);
@@ -812,14 +1002,15 @@ let bands = (
   { columnOf, itemsOf, totalOf },
 ) => {
   // Stacked items, one pass per row.
-  /** @type {(items: (scope: Scope, item?: any) => Generator<any>) => Band} */
+  /** @type {(items: (scope: Scope) => Generator<any>) => Band} */
   let itemsBand = (items) =>
     function* (rows, scope, runners) {
       for (let row of rows) {
         let scopeOfRow = runners.bind(scope, row);
         // Detail items carry the row's run values as data; group and report
         // band items never do (they have no current row).
-        for (let event of items(scopeOfRow, row)) yield opt(event, { run: scopeOfRow.run });
+        for (let event of items(scopeOfRow))
+          yield carriesRun(event) ? opt(event, { run: scopeOfRow.run }) : event;
       }
     };
 
@@ -830,32 +1021,16 @@ let bands = (
     keys(value.row, ["visible", "style"], "detail.row");
     return {
       rowVisible: visibleOf(value.row, "detail.row"),
-      rowStyles: stylesOf(value.row, "detail.row"),
+      rowStyles: stylesOf(value.row, "detail.row", checkRowStyle),
     };
   };
-  /** @type {(sized: boolean) => string} */
-  let shareMsg = (sized) =>
-    sized
-      ? "expected column widths to total at most 100"
-      : "expected column widths to total under 100, leaving room for the columns without one";
-  /** @type {(columns: any[], shares: number[]) => void} */
-  let warnShares = (columns, shares) => {
-    let total = shares.reduce((all, width) => all + width, 0);
-    let sized = shares.length === columns.length;
-    if (total > (sized ? 100 + WIDTH_EPS : 100 - WIDTH_EPS)) bad("detail.columns", shareMsg(sized));
-  };
-  /** @type {(columns: any[]) => void} */
-  let checkShares = (columns) => {
-    // Authored shares must leave room for the columns without one. Widths are
-    // literal, so the sum is known here; a tolerance keeps three columns at
-    // 33.3 from summing to 100.00000000000001 and failing on IEEE 754 alone.
-    // Skipped outright when any authored width is out of range (a NaN, per
-    // columnOf's verdict): the document already carries that problem, and a
-    // width nobody can read leaves it undecidable whether its column is one
-    // of the ones needing room.
-    let shares = columns.map((column) => column.width).filter((width) => width != null);
-    if (!shares.length || shares.some(Number.isNaN)) return;
-    warnShares(columns, shares);
+  // The header-row box: `style` only, a different path from each column's
+  // `header` cell. Absent when the table declares none.
+  /** @type {(value: any) => (scope: Scope) => any} */
+  let headerLook = (value) => {
+    if (value.header == null || !obj(value.header, "detail.header")) return NIL;
+    keys(value.header, ["style"], "detail.header");
+    return stylesOf(value.header, "detail.header", checkRowStyle);
   };
   /** @type {(value: any) => { defs: any[] | null, columns: any[] }} */
   let tableColumns = (value) => {
@@ -864,22 +1039,54 @@ let bands = (
     let columns = (defs || [])
       .map((def, i) => columnOf(def, "detail.columns[" + i + "]"))
       .filter((column) => column != null);
-    checkShares(columns);
+    checkShares(bad, columns, "detail.columns", "column");
     return { defs, columns };
   };
-  /** @type {(totals: any[] | null, defs: any[] | null) => void} */
-  let checkTotalCount = (totals, defs) => {
-    if (totals && defs && totals.length !== defs.length)
-      bad("detail.total", "expected one cell per column");
+  /** @type {(totals: any[], prefix: string) => any[]} */
+  let mapTotals = (totals, prefix) =>
+    totals
+      .map((def, i) => {
+        let path = prefix + "[" + i + "]";
+        let cell = totalOf(def, path);
+        return cell && { cell, path };
+      })
+      .filter((entry) => entry != null);
+  /** @type {(rows: any[] | null) => any[]} */
+  let nonempty = (rows) => {
+    if (rows && !rows.length) bad("detail.total", "expected at least one total row");
+    return rows || [];
   };
-  /** @type {(totals: any[]) => any[]} */
-  let mapTotals = (totals) =>
-    totals.map((def, i) => totalOf(def, "detail.total[" + i + "]")).filter((cell) => cell != null);
-  /** @type {(value: any, defs: any[] | null) => any[] | null} */
-  let tableTotals = (value, defs) => {
-    let totals = arr(value.total, "detail.total");
-    checkTotalCount(totals, defs);
-    return totals ? mapTotals(totals) : null;
+  /**
+   * @type {(value: any, defs: any[] | null) =>
+   *   { styles: (scope: Scope) => any, visible: any, cells: any[] }[] | null}
+   */
+  let tableTotals = (value, defs) =>
+    value.total == null
+      ? null
+      : nonempty(arr(value.total, "detail.total", true)).map((def, r) =>
+          totalRowOf(def, "detail.total[" + r + "]", defs),
+        );
+  /** @type {(cells: any[], defs: any[] | null) => boolean} */
+  let aligned = (cells, defs) => !defs || cells.length === defs.length;
+  /** @type {(cells: any[] | null, defs: any[] | null, path: string) => any[]} */
+  let counted = (cells, defs, path) => {
+    if (!cells) return [];
+    if (!aligned(cells, defs)) bad(path + ".cells", "expected one cell per column");
+    return cells;
+  };
+  /**
+   * @type {(def: any, path: string, defs: any[] | null) =>
+   *   { styles: (scope: Scope) => any, visible: any, cells: any[] }}
+   */
+  let totalRowOf = (def, path, defs) => {
+    if (!obj(def, path)) return { styles: NIL, visible: null, cells: [] };
+    keys(def, ["cells", "style", "visible"], path);
+    let cells = counted(arr(def.cells, path + ".cells", true), defs, path);
+    return {
+      styles: stylesOf(def, path, checkRowStyle),
+      visible: visibleOf(def, path),
+      cells: mapTotals(cells, path + ".cells"),
+    };
   };
   /**
    * @type {(rows: any[], scope: Scope, runners: RunnerSet, columns: any[],
@@ -890,30 +1097,57 @@ let bands = (
       let scopeOfRow = runners.bind(scope, row);
       if (!hidden(rowVisible, scopeOfRow))
         yield opt(
-          { type: "row", cells: columns.map((column) => column.cell(scopeOfRow, row)) },
+          {
+            type: "row",
+            cells: columns.map((column) =>
+              Object.assign(column.cell(scopeOfRow), { path: column.path }),
+            ),
+          },
           { style: rowStyles(scopeOfRow), run: scopeOfRow.run },
         );
     }
   }
-  /** @type {(columns: any[], total: any[] | null, rowVisible: Eval | null, rowStyles: (scope: Scope) => any) => Band} */
-  let tableBand = (columns, total, rowVisible, rowStyles) =>
+  /**
+   * @type {(total: { styles: (scope: Scope) => any, visible: any, cells: any[] }[] | null,
+   *   scope: Scope) => Generator<any>}
+   */
+  function* emitTotals(total, scope) {
+    if (!total) return;
+    for (let row of total) {
+      if (hidden(row.visible, scope)) continue;
+      yield opt(
+        {
+          type: "total-row",
+          cells: row.cells.map(({ cell, path }) => Object.assign(cell(scope), { path })),
+        },
+        { style: row.styles(scope) },
+      );
+    }
+  }
+  /** @type {(columns: any[], total: { styles: (scope: Scope) => any, visible: any, cells: any[] }[] | null, rowVisible: Eval | null, rowStyles: (scope: Scope) => any, headerStyles: (scope: Scope) => any) => Band} */
+  let tableBand = (columns, total, rowVisible, rowStyles, headerStyles) =>
     function* (rows, scope, runners) {
-      yield {
-        type: "table-start",
-        columns: columns.map((column) =>
-          opt({ header: column.header(scope) }, { width: column.width }),
-        ),
-      };
+      yield opt(
+        {
+          type: "table-start",
+          path: "detail",
+          columns: columns.map((column) =>
+            opt({ header: column.header(scope), path: column.path }, { width: column.width }),
+          ),
+        },
+        { style: headerStyles(scope) },
+      );
       yield* tableRows(rows, scope, runners, columns, rowVisible, rowStyles);
-      if (total) yield { type: "total-row", cells: total.map((cell) => cell(scope)) };
+      yield* emitTotals(total, scope);
       yield { type: "table-end" };
     };
   /** @type {(value: any) => Band} */
   let tableOf = (value) => {
-    keys(value, ["row", "columns", "total"], "detail");
+    keys(value, ["header", "row", "columns", "total"], "detail");
+    let headerStyles = headerLook(value);
     let { rowVisible, rowStyles } = rowLook(value);
     let { defs, columns } = tableColumns(value);
-    return tableBand(columns, tableTotals(value, defs), rowVisible, rowStyles);
+    return tableBand(columns, tableTotals(value, defs), rowVisible, rowStyles, headerStyles);
   };
 
   // The detail band is polymorphic: an array of items stacks them per row, a
@@ -983,7 +1217,14 @@ let bands = (
         // A group band has no current row, so `@` stays unbound here.
         let { groupScope, aggregates, rows: ordered } = openInstance(ctx, key, groupRows, scope);
         yield opt(
-          { type: "group-start", name: ctx.name, depth: ctx.index, key, aggregates },
+          {
+            type: "group-start",
+            name: ctx.name,
+            depth: ctx.index,
+            key,
+            aggregates,
+            path: ctx.path,
+          },
           { break: ctx.pageBreak, reset: ctx.reset, columns: ctx.columns },
         );
         yield* ctx.header(groupScope);
@@ -1027,6 +1268,7 @@ let bands = (
       footer: itemsOf(def.footer, path + ".footer", "group-footer"),
       inner: bandOf(defs, index + 1, detail, columned || columns != null),
       name: def.name,
+      path,
       pageBreak: def.break,
       reset: def.reset,
       columns,
@@ -1053,9 +1295,12 @@ let bands = (
 /** @type {(source: string, options: any) => any} */
 let compileQuery = (source, options) => {
   try {
-    return query(source, undefined, { ...QUERY, ...(options && options.query) });
+    // padvinder itself defaults maxDepth to 500 (safety by construction since
+    // 0.6.0), so untrusted deep documents throw typed with no quario-side
+    // budget; hosts override per key — Infinity opts a budget out.
+    return query(source, undefined, options && options.query);
   } catch (error) {
-    locate("data", source, error, 0, isQueryDiagnostic(error));
+    locate("data", source, error, isQueryDiagnostic(error) && relocateQuery);
   }
 };
 /** @type {(schema: any, obj: any, named: any, bad: any) => any} */
@@ -1074,17 +1319,87 @@ let selectOf = (schema, bad, attempt, options) => {
 };
 /** @type {(value: any, path: string, expression: any) => any} */
 let maybeExpr = (value, path, expression) => (value != null ? expression(value, path) : null);
-/** @type {(schema: any, obj: any, keys: any, itemsOf: any) => { pageHeader: any, pageFooter: any }} */
-let pageBands = (schema, obj, keys, itemsOf) => {
+/** @type {(n: any) => boolean} */
+let posPts = (n) => typeof n === "number" && Number.isFinite(n) && n > 0;
+/** @type {(n: any) => boolean} */
+let padPts = (n) => typeof n === "number" && Number.isFinite(n) && n >= 0;
+/** @type {(height: any, bad: any) => number | null} */
+let headerHeightOf = (height, bad) => {
+  if (height == null) bad("header.height", "required");
+  else if (!posPts(height)) bad("header.height", "expected a positive number of points");
+  return posPts(height) ? height : null;
+};
+/** @type {(itemsOf: any) => { items: any, height: number | null }} */
+let emptyHeader = (itemsOf) => ({ items: itemsOf(null, "header", "report-header"), height: null });
+/** @type {(value: any, keys: any, itemsOf: any, bad: any) => { items: any, height: number | null }} */
+let reportHeaderOf = (value, keys, itemsOf, bad) => {
+  if (value == null || Array.isArray(value))
+    return { items: itemsOf(value, "header", "report-header"), height: null };
+  if (!record(value)) {
+    bad("header", "expected an array of items or { height, items }");
+    return emptyHeader(itemsOf);
+  }
+  keys(value, ["height", "items"], "header");
+  return {
+    items: itemsOf(value.items, "header.items", "report-header"),
+    height: headerHeightOf(value.height, bad),
+  };
+};
+
+/** @type {(margin: any, bad: any) => number | null} */
+let pageMarginOf = (margin, bad) => {
+  if (margin != null && !padPts(margin))
+    bad("page.margin", "expected a non-negative number of points");
+  return padPts(margin) ? margin : null;
+};
+/** @type {(schema: any, obj: any, keys: any, itemsOf: any, bad: any) => { pageHeader: any, pageFooter: any, margin: number | null }} */
+let pageBands = (schema, obj, keys, itemsOf, bad) => {
   if (schema.page == null || !obj(schema.page, "page"))
-    return { pageHeader: null, pageFooter: null };
-  keys(schema.page, ["header", "footer"], "page");
+    return { pageHeader: null, pageFooter: null, margin: null };
+  keys(schema.page, ["header", "footer", "margin"], "page");
   return {
     pageHeader: maybeItems(schema.page.header, "page.header", "page-header", itemsOf),
     pageFooter: maybeItems(schema.page.footer, "page.footer", "page-footer", itemsOf),
+    margin: pageMarginOf(schema.page.margin, bad),
   };
 };
 
+/** @type {(def: any) => boolean} */
+let shown = (def) => !(def && def.visible === false);
+/** @type {(list: any, path: string) => [any, string] | null} */
+let firstOccupying = (list, path) => {
+  if (!Array.isArray(list)) return null;
+  let i = list.findIndex(shown);
+  return i < 0 ? null : [list[i], path + "[" + i + "]"];
+};
+/** @type {(schema: any) => any} */
+let firstGroupHeader = (schema) => {
+  let groups = schema.groups;
+  return Array.isArray(groups) && groups[0] ? groups[0].header : null;
+};
+/** @type {(schema: any) => [any, string] | null} */
+let nextAfterHeader = (schema) =>
+  firstOccupying(firstGroupHeader(schema), "groups[0].header") ||
+  firstOccupying(schema.detail, "detail");
+/** @type {(n: any) => boolean} */
+let nonzeroLead = (n) => typeof n === "number" && n !== 0;
+/** @type {(next: [any, string], bad: any) => void} */
+let refuseLiteralLead = (next, bad) => {
+  if (nonzeroLead(next[0].style?.spaceBefore))
+    bad(next[1] + ".style.spaceBefore", "must be 0 after a height-declared header");
+};
+/** @type {(schema: any, headerHeight: number | null, bad: any) => void} */
+let refusePinnedLead = (schema, headerHeight, bad) => {
+  if (headerHeight == null) return;
+  let next = nextAfterHeader(schema);
+  if (next) refuseLiteralLead(next, bad);
+};
+/** @type {(headerHeight: number | null, schema: any, bad: any) => void} */
+let needPinnedMargin = (headerHeight, schema, bad) => {
+  if (headerHeight != null && schema.page?.margin == null)
+    bad("page.margin", "required when header declares height");
+};
+
 /**
  * The root descent, in the schema's documented key order. `params` and `data`
  * are checked here the way every other key is — by compiling what they declare
@@ -1102,7 +1417,7 @@ let pageBands = (schema, obj, keys, itemsOf) => {
  */
 let traverse = (
   { add, bad, attempt, runNames },
-  { arr, obj, keys, named, expression, columnsOf, takeOf, foldsOf, sortOf },
+  { arr, obj, keys, named, expression, columnsOf, takeOf, foldsOf, sortOf, stylesOf },
   { itemsOf },
   { bandOf },
   schema,
@@ -1122,6 +1437,7 @@ let traverse = (
       "take",
       "aggregates",
       "run",
+      "style",
       "header",
       "empty",
       "columns",
@@ -1142,7 +1458,14 @@ let traverse = (
   let take = takeOf(schema.take, "take");
   let aggs = foldsOf(schema.aggregates, "aggregates", AGG, new Set(["params", "input"]));
   let running = foldsOf(schema.run, "run", RUN, null, runNames);
-  let header = itemsOf(schema.header, "header", "report-header");
+  // The report default: one style block for the whole document, narrowed to
+  // the declarations a typeface is made of. It resolves once per render in
+  // report scope rather than per node, which is why it crosses the seam as a
+  // `report-start` field instead of being merged into every item's style --
+  // nothing here allocates per cell (docs/adr/0033).
+  let style = stylesOf(schema, "", checkReportStyle);
+  let { items: header, height: headerHeight } = reportHeaderOf(schema.header, keys, itemsOf, bad);
+  refusePinnedLead(schema, headerHeight, bad);
   // Null when undeclared, so the render decides on the compiled band rather
   // than reading `schema.empty` a second time from outside the traversal.
   let empty = maybeItems(schema.empty, "empty", "empty", itemsOf);
@@ -1151,7 +1474,8 @@ let traverse = (
   let footer = itemsOf(schema.footer, "footer", "report-footer");
   // Page bands compile like any other band, but render per page, so the
   // stream hands paginated targets closures instead of events.
-  let { pageHeader, pageFooter } = pageBands(schema, obj, keys, itemsOf);
+  let { pageHeader, pageFooter, margin } = pageBands(schema, obj, keys, itemsOf, bad);
+  needPinnedMargin(headerHeight, schema, bad);
   return {
     select,
     params,
@@ -1160,13 +1484,16 @@ let traverse = (
     take,
     aggs,
     running,
+    style,
     header,
+    headerHeight,
     empty,
     columns,
     footer,
     band,
     pageHeader,
     pageFooter,
+    margin,
   };
 };
 
@@ -1189,8 +1516,15 @@ export let plan = (schema, funcs, options) => {
   return {
     compiled: traverse(state, read, node, band, schema, options),
     problems: state.problems,
+    anchors: state.anchors,
     names: state.names,
-    functions: state.functions,
+    // Registry metadata comes from xprsn's one signature convention, described
+    // over just the called subset — every called name resolved from the
+    // registry at compile time, and the rebuilt object keeps the flat name
+    // set's call-first-seen order.
+    functions: signatures(
+      Object.fromEntries(Array.from(state.functions, (name) => [name, state.FNS[name]])),
+    ),
     diagnostic: state.diagnostic,
   };
 };