quario 0.6.0 → 0.7.0

package/lib/plan.js

@@ -3,7 +3,8 @@
  * each node against its closed key set — in the documented key order, which is
  * the order the allowed-key list spells out — and compiles the closures that
  * render it, collecting problems instead of throwing. `validate()` reads the
- * problems, `events()` the closures. One traversal, read two ways: a schema key
+ * problems, `events()` the closures, and `plan()` hands over both plus the
+ * advisory warnings the same descent noticed. One traversal, read two ways: a schema key
  * is checked once, beside the code that compiles it, and never in two walkers.
  * (The safety suite greps every source file for the forbidden string-to-code
  * constructs, so they must not appear even in a comment.)
@@ -13,8 +14,9 @@
  * returns and taking the layers it builds on, composed by `plan()` at the foot
  * of the file:
  *
- *   1. `planState`  — what the whole descent accumulates: problems, names,
- *                     functions, and the stubs a failed compile stands in
+ *   1. `planState`  — what the whole descent accumulates: problems, warnings,
+ *                     names, functions, and the stubs a failed compile
+ *                     stands in
  *   2. `primitives` — authored source to located evaluator; the only layer that
  *                     throws, which is why every reader wraps it in `attempt`
  *   3. `readers`    — one per kind of declared value: each checks, compiles and
@@ -49,7 +51,7 @@ import { ANCHORS, BLOCKED, NAME, RESERVED, record } from "./names.js";
 import { MATH } from "./math.js";
 import { REDUCERS, reducerFor } from "./reducers.js";
 import { aggregateValue, withRow } from "./scope.js";
-import { opt, sniff } from "./stream.js";
+import { oneValue, opt, sameStyle, sniff } from "./stream.js";
 import {
   checkBorderSides,
   checkCellStyle,
@@ -64,8 +66,12 @@ import {
   coveredNames,
   fanBox,
   guarded,
+  checkRunStyle,
   isBoxName,
   isExpr,
+  isRunName,
+  isValueName,
+  kindOf,
   positivePts,
   resolveFormat,
   SKIP,
@@ -96,7 +102,9 @@ let NO_ROW_ENTRIES = { box: [], rest: [] };
 let NO_ROW_STYLE = { box: NIL, names: [], rest: NIL };
 // A cell that declares no readable style block: nothing to resolve, and no
 // box name to keep any of its row's box off it.
-let NO_CELL_LOOK = { styles: NIL, box: /** @type {string[]} */ ([]) };
+// What a node that declares no readable `style` block wears: no resolved
+// object, no unresolved one for a run to layer over, and no box names.
+let NO_LOOK = { styles: NIL, raw: NIL, box: /** @type {string[]} */ ([]) };
 // An absent `total` is the block with no rows. `rows: []` is a definition
 // error, so an empty one can only have come from absence and nothing has to
 // tell the two apart downstream.
@@ -104,6 +112,17 @@ let NO_CELL_LOOK = { styles: NIL, box: /** @type {string[]} */ ([]) };
 let NO_TOTALS = Object.freeze({ visible: null, rows: Object.freeze([]) });
 /** @type {any} */
 let EMPTY = () => [];
+// One styled run of a cell's value: its compiled template, and the unresolved
+// style block it layers over the cell's -- null where it declares none, which
+// is the whole of a cell written as one template string.
+/** @typedef {{ tpl: (scope: Scope) => any, raw: ((scope: Scope) => any) | null }} StyledRun */
+// A node's compiled style: the resolved block a target reads, the unresolved
+// one a styled run of its value layers over, and the box names it declared.
+/** @typedef {{ styles: (scope: Scope) => any, raw: (scope: Scope) => any, box: string[] }} Look */
+/** @type {StyledRun} */
+let NO_STYLED_RUN = { tpl: EMPTY, raw: null };
+/** @type {StyledRun[]} */
+let NO_STYLED_RUNS = [NO_STYLED_RUN];
 // What `$.params` reads when a report declares none.
 let NONE = Object.freeze({});
 
@@ -155,25 +174,64 @@ let shareMsg = (sized, 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.
+// What the authored shares come to, 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} */
+// `sized` is whether every part authored one, which is the question both
+// halves of the rule turn on. The one arithmetic, so the error below and the
+// warning beside it can never drift into two rules wearing one name.
+/** @type {(parts: { width?: any }[]) => { total: number, sized: boolean } | null} */
 let sharesOf = (parts) => {
   let shares = parts.map((part) => part.width).filter((width) => width != null);
-  return !shares.length || shares.some(Number.isNaN) ? null : shares;
+  if (!shares.length || shares.some(Number.isNaN)) return null;
+  let total = shares.reduce((all, width) => all + width, 0);
+  return { total, sized: shares.length === parts.length };
 };
 // 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));
+  let sum = sharesOf(parts);
+  if (!sum) return;
+  if (sum.total > (sum.sized ? 100 + WIDTH_EPS : 100 - WIDTH_EPS))
+    bad(path, shareMsg(sum.sized, noun));
+};
+// A sum written back to an author: the tolerance above admits thirds, so the
+// wording must too rather than reporting the 99.89999999999999 nobody typed.
+// Rounding, not the tolerance -- the tolerance decides, this only says.
+/** @type {(value: number) => number} */
+let rounded = (value) => +value.toFixed(4);
+// The other side of the same rule, and the only side that is not a definition
+// error: every column sized and the sum short leaves the trailing width to
+// nobody, because there is no width-less column to divide it (SCHEMA.md,
+// "Table detail"). A table only. A split's slots carry the same percentages
+// under the same arithmetic, but the spec states this consequence for the
+// table alone, and a warning is only worth as much as the sentence it can
+// point at.
+/** @type {(warn: any, columns: { width?: any }[], path: string) => void} */
+let underCommitted = (warn, columns, path) => {
+  let sum = sharesOf(columns);
+  if (!sum || !sum.sized || sum.total >= 100 - WIDTH_EPS) return;
+  warn(
+    path,
+    "every column is sized and the widths total " +
+      rounded(sum.total) +
+      ", leaving the trailing " +
+      rounded(100 - sum.total) +
+      " of the table width unused",
+  );
+};
+
+// Whether a style block settles on the money kind from the document alone --
+// the question `currency` is read under (SCHEMA.md, "Style declarations"). An
+// `=` format resolves at render, so a block that defers its kind has not named
+// another one, and silence is the only honest answer for it.
+/** @type {(block: any) => boolean} */
+let formatsMoney = (block) => {
+  let format = Object.hasOwn(block, "format") ? block.format : undefined;
+  return isExpr(format) || kindOf(format) === "currency";
 };
 
 // One pass over a report's constants: it checks each value, copies it, and
@@ -338,6 +396,16 @@ let planState = (schema, funcs) => {
   };
   /** @type {(path: string, msg: string) => void} */
   let bad = (path, msg) => problems.push({ path, message: path + ": " + msg });
+  // The advisory half of the same descent: the document declares something
+  // nothing will read. Not a problem at another severity -- a `Problem` carries
+  // the engine's located `diagnostic` when one authenticated the fault, and
+  // nothing raises here, so the type says what arrives (SCHEMA.md,
+  // "Validation"). Kept in its own list, which is what leaves `problems`'
+  // fatal contract untouched.
+  /** @type {{ path: string, source?: string, message: string }[]} */
+  let warnings = [];
+  /** @type {(path: string, msg: string) => void} */
+  let warn = (path, msg) => warnings.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} */
@@ -377,11 +445,13 @@ let planState = (schema, funcs) => {
     functions,
     BND,
     problems,
+    warnings,
     runNames,
     anchors,
     anchorsOf,
     add,
     bad,
+    warn,
     attempt,
     // The band-height rule, carried by the descent rather than walked
     // separately: `traverse` arms it from the report header and offers it each
@@ -511,7 +581,7 @@ let primitives = ({ FNS, BND, names, functions, anchorsOf }) => {
  * @param {State} state
  * @param {Primitives} primitives
  */
-let readers = ({ bad, attempt }, { prop, cell, parseFold }, /** @type {any} */ options) => {
+let readers = ({ bad, warn, attempt }, { prop, cell, parseFold }, /** @type {any} */ options) => {
   /** @type {(value: any, path: string) => boolean} */
   let obj = (value, path) => {
     if (record(value)) return true;
@@ -598,6 +668,27 @@ let readers = ({ bad, attempt }, { prop, cell, parseFold }, /** @type {any} */ o
     }
     return value;
   };
+  // `currency` is read only under `format: "currency"`; declared without that
+  // kind it contributes nothing (SCHEMA.md, "Style declarations"), which is a
+  // warning rather than a definition error because the kind is a *later* edit
+  // away and an editor session must never refuse a document mid-edit.
+  //
+  // The `currency` is read off `entries` rather than off the block, so one the
+  // vocabulary already refused earns no second entry about that declaration:
+  // `entries` is exactly what survived `check`. The `format` beside it is read
+  // as written, because a `format` that was refused is a kind the engine will
+  // not have either -- the code is unread all the same, and saying so is not a
+  // second entry about the same key.
+  /** @type {(block: any, path: string, entries: StyleEntry[]) => void} */
+  let unreadCurrency = (block, path, entries) => {
+    if (!entries.some(([name]) => name === "currency")) return;
+    if (formatsMoney(block)) return;
+    warn(
+      path + ".currency",
+      'currency is read only under format: "currency", so this declaration' +
+        " contributes nothing; declare that kind or drop the code",
+    );
+  };
   // A declared style block resolves to plain data — the closed vocabulary's
   // names in declaration order, null when empty — and stays data; a render
   // target maps it to its own formatting model (the HTML target to inline
@@ -622,6 +713,7 @@ let readers = ({ bad, attempt }, { prop, cell, parseFold }, /** @type {any} */ o
         entries.push([name, expr ? guarded(name, resolve) : resolve, expr]);
       }
     }
+    unreadCurrency(block, path, entries);
     return entries;
   };
   // The names are written in declaration order, which the stream promises, so
@@ -636,14 +728,19 @@ let readers = ({ bad, attempt }, { prop, cell, parseFold }, /** @type {any} */ o
   // block. The instance's options come with it, for the cell that declares no
   // code of its own and takes the instance's (docs/adr/0056).
   /** @type {(entries: StyleEntry[]) => (scope: Scope) => Scope} */
-  let styleFn = (entries) => (scope) => {
+  let blockFn = (entries) => (scope) => {
     /** @type {Scope} */
     let style = {};
     for (let [name, value] of entries) {
       let resolved = value(scope);
       if (resolved !== SKIP) style[name] = resolved;
     }
-    return resolveFormat(style, options);
+    return style;
+  };
+  /** @type {(entries: StyleEntry[]) => (scope: Scope) => Scope} */
+  let styleFn = (entries) => {
+    let block = blockFn(entries);
+    return (scope) => resolveFormat(block(scope), options);
   };
   /**
    * @type {(block: any, path: string, check: (name: string, value: any) => string | null)
@@ -652,14 +749,23 @@ let readers = ({ bad, attempt }, { prop, cell, parseFold }, /** @type {any} */ o
   // A compiled block, constant-folded when nothing in it defers to render, so
   // a literal style is resolved once and every node that wears it is handed
   // the same frozen object.
-  /** @type {(entries: StyleEntry[]) => (scope: Scope) => any} */
-  let folded = (entries) => {
+  /** @type {(entries: StyleEntry[], fn: (entries: StyleEntry[]) => (scope: Scope) => any) => (scope: Scope) => any} */
+  let foldWith = (entries, fn) => {
     if (!entries.length) return NIL;
-    let resolve = styleFn(entries);
+    let resolve = fn(entries);
     if (entries.some((entry) => entry[2])) return resolve;
     let constant = Object.freeze(resolve({}));
     return () => constant;
   };
+  /** @type {(entries: StyleEntry[]) => (scope: Scope) => any} */
+  let folded = (entries) => foldWith(entries, styleFn);
+  // The same block with `format` left as the author wrote it. A styled run
+  // layers over the cell's declarations and *then* resolves, so a run naming a
+  // `currency` under an inherited kind takes its digit count from the code it
+  // named rather than from the one the cell wore (docs/adr/0056, ADR 0061).
+  // Nothing outside that composition reads it.
+  /** @type {(entries: StyleEntry[]) => (scope: Scope) => any} */
+  let foldedRaw = (entries) => foldWith(entries, blockFn);
   /**
    * @type {(block: any, path: string, check: (name: string, value: any) => string | null)
    *   => StyleEntry[]}
@@ -734,30 +840,127 @@ let readers = ({ bad, attempt }, { prop, cell, parseFold }, /** @type {any} */ o
     let entries = entriesOf(def, path, check);
     return entries ? folded(entries) : NIL;
   };
-  // A cell's compiled style with the box names it declared kept beside it.
-  // Those names are what settles which of its row's box reaches it -- the
-  // question `layer` used to ask of the resolved object at render, asked once
-  // here instead (docs/adr/0056).
-  /** @type {(def: any, path: string) => { styles: (scope: Scope) => any, box: string[] }} */
-  let cellLook = (def, path) => {
-    let entries = entriesOf(def, path, checkCellStyle);
-    if (!entries) return NO_CELL_LOOK;
+  // A cell's compiled style with the box names it declared kept beside it, and
+  // the unresolved block a styled run of its value layers over. Those names are
+  // what settles which of its row's box reaches it -- the question `layer` used
+  // to ask of the resolved object at render, asked once here instead
+  // (docs/adr/0062).
+  /** @type {(def: any, path: string, check: (name: string, value: any) => string | null) => Look} */
+  let lookOf = (def, path, check) => {
+    let entries = entriesOf(def, path, check);
+    if (!entries) return NO_LOOK;
     return {
       styles: folded(entries),
+      // Only the inline half is offered to a styled run: a run carries that
+      // half and nothing else, so a cell's padding, border or `align` must not
+      // ride down onto a stretch of its text (SCHEMA.md, "Style
+      // declarations"). Narrowed here, at compile, rather than per render.
+      raw: foldedRaw(entries.filter(([name]) => isRunName(name))),
       box: entries.filter(([name]) => isBoxName(name)).map(([name]) => name),
     };
   };
+  // Every cell-bearing node reads the same three keys in the same documented
+  // order -- value, visible, style -- and each reader reports as it reads, so
+  // that order is the order problems and warnings come out in. Stated once, so
+  // a fourth cell site cannot quietly report them in another.
+  /**
+   * @type {(def: any, path: string, check: (name: string, value: any) => string | null,
+   *   valuePath?: string) => { styled: StyledRun[], visible: Eval | null, look: Look }}
+   */
+  let cellParts = (def, path, check, valuePath = path + ".value") => {
+    let styled = cellValue(def.value, valuePath);
+    let visible = visibleOf(def, path);
+    unreadFormat(def.value, def.style, path);
+    return { styled, visible, look: lookOf(def, path, check) };
+  };
   /** The same, for the blocks that sit on a table row. */
   /** @type {(def: any, path: string) => RowStyles} */
   let rowStylesOf = (def, path) => foldRow(rowEntriesOf(def, path));
-  // A cell value: one sjabloon template. Emphasis is the cell's own `style`;
-  // markup in literal text is meaningful only to the HTML target.
-  /** @type {(value: any, path: string) => (scope: Scope, opts?: any) => any} */
-  let cellValue = (value, path) => {
+  // One sjabloon template, and nothing else: an image item's `alt` is a textual
+  // stand-in rather than a rendered line, so styling a fragment of one means
+  // nothing in any target that has a place for it (SCHEMA.md, "Cell values").
+  /** @type {(value: any, path: string) => (scope: Scope) => any} */
+  let textValue = (value, path) => {
     if (typeof value === "string") return attempt(() => cell(value, path), EMPTY);
     bad(path, "expected a template string");
     return EMPTY;
   };
+  // Whether a template can *never* render as a single value token, which is the
+  // only answer this channel is certain of without data. Text before the first
+  // `{{` or after the last `}}` renders on every row whatever the blocks
+  // between them do, so a source that does not open and close on a tag can
+  // never be one value; one that does may be, and `plan()` has no data to
+  // settle it. That is the whole of why the warning below is incomplete by
+  // construction (SCHEMA.md, "Validation").
+  //
+  // The two delimiters are the one place quario names sjabloon's syntax rather
+  // than asking for it, and hard constraint 2 is why that is written down here
+  // instead of passing unremarked. It is a *shape* test and not a parse:
+  // nothing is tokenised, extracted or evaluated, the compile above stays the
+  // only thing that reads the source, and the answer decides an advisory alone.
+  // It has no false positives -- text outside every tag cannot be conditional,
+  // since a block opens with `{{#`, and sjabloon strips no whitespace around a
+  // standalone tag -- so a wrong answer costs a missing warning, never a
+  // warning on a correct document. A value that is not one template is not this
+  // question at all: a run array's runs each answer it for themselves.
+  /** @type {(src: any) => boolean} */
+  let neverPresents = (src) =>
+    typeof src === "string" && !(src.startsWith("{{") && src.endsWith("}}"));
+  // A `format` on a run that can never render one value token is unread by the
+  // rule that declaration states, so it contributes nothing. It warns where it
+  // is *declared*, like every other entry on this channel -- not at the value
+  // whose token count caused it (quario-xdap.10).
+  /** @type {(src: any, block: any, path: string) => void} */
+  let unreadFormat = (src, block, path) => {
+    if (!record(block) || !Object.hasOwn(block, "format") || !neverPresents(src)) return;
+    warn(
+      path + ".style.format",
+      "format is read only where its run renders a single value token, so this" +
+        " declaration contributes nothing; split the value into styled runs, or" +
+        " drop the declaration",
+    );
+  };
+  // One styled run: a template and the inline half of the vocabulary. A closed
+  // two-key object -- `{{#if}}` already conditions a run's own text, so there
+  // is no `visible` on one (SCHEMA.md, "Cell values").
+  /** @type {(def: any, path: string) => StyledRun} */
+  let styledRunOf = (def, path) => {
+    if (!record(def)) {
+      bad(path, "expected an object");
+      return NO_STYLED_RUN;
+    }
+    keys(def, ["value", "style"], path);
+    let tpl = textValue(def.value, path + ".value");
+    unreadFormat(def.value, def.style, path);
+    let entries = entriesOf(def, path, checkRunStyle);
+    return { tpl, raw: entries ? foldedRaw(entries) : null };
+  };
+  // A cell value: one sjabloon template, or a non-empty array of styled runs.
+  // A cell written as one template string is one implicit run, so every rule
+  // about a run reads the same for both spellings (ADR 0061). Markup in literal
+  // text is meaningful only to the HTML target; a run is not.
+  /** @type {(value: any, path: string) => StyledRun[]} */
+  let cellValue = (value, path) => {
+    if (typeof value === "string")
+      return [{ tpl: attempt(() => cell(value, path), EMPTY), raw: null }];
+    if (Array.isArray(value)) {
+      if (!value.length) {
+        bad(path, "expected at least one styled run");
+        return NO_STYLED_RUNS;
+      }
+      return value.map((styled, i) => styledRunOf(styled, path + "[" + i + "]"));
+    }
+    bad(path, "expected a template string or an array of styled runs");
+    return NO_STYLED_RUNS;
+  };
+  // A styled run's resolved style: the cell's own declarations with the run's
+  // over them, composed while `format` is still as written so the kind resolves
+  // once, over the pair. A run that declares no block of its own wears the
+  // cell's answer unchanged, which is what makes a run-less cell's stream
+  // byte-identical to what it always was.
+  /** @type {(own: any, ownRaw: any, styled: StyledRun, scope: Scope) => any} */
+  let styledRunLook = (own, ownRaw, styled, scope) =>
+    styled.raw ? resolveFormat({ ...ownRaw, ...styled.raw(scope) }, options) : own;
   /** @type {(seen: Set<string> | undefined, name: string, foldPath: string) => void} */
   let noteRun = (seen, name, foldPath) => {
     if (!seen) return;
@@ -864,12 +1067,15 @@ let readers = ({ bad, attempt }, { prop, cell, parseFold }, /** @type {any} */ o
     columnsOf,
     takeOf,
     stylesOf,
-    cellLook,
+    lookOf,
+    cellParts,
+    styledRunLook,
     rowStylesOf,
     rowEntriesOf,
     underRow,
     foldRow,
     cellValue,
+    textValue,
     foldsOf,
     sortOf,
   };
@@ -884,17 +1090,104 @@ let readers = ({ bad, attempt }, { prop, cell, parseFold }, /** @type {any} */ o
  * @param {State} state
  * @param {Readers} readers
  */
-let nodes = ({ bad }, { arr, obj, keys, expression, cellValue, visibleOf, stylesOf, cellLook }) => {
+let nodes = (
+  { bad },
+  {
+    arr,
+    obj,
+    keys,
+    expression,
+    cellValue,
+    cellParts,
+    textValue,
+    visibleOf,
+    stylesOf,
+    lookOf,
+    styledRunLook,
+  },
+) => {
   // `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. The anchor story lives on
   // `cell` in primitives: the scope chain itself carries `$` and `@`.
+  // The declaration presents a value, so it needs one value to speak about: a
+  // style governing tokens that are not exactly one value token is read without
+  // its `format`, and without the `currency` that rides only under that kind.
+  // The engine settles it per render and omits the pair from the stream, so no
+  // target decides it and none can disagree with another (ADR 0061).
+  /** @type {(style: any) => any} */
+  let withoutValueNames = (style) => {
+    /** @type {any} */
+    let out = {};
+    for (let name of Object.keys(style)) if (!isValueName(name)) out[name] = style[name];
+    return Object.keys(out).length ? Object.freeze(out) : null;
+  };
+  /** @type {(style: any, one: boolean) => any} */
+  let presented = (style, one) => {
+    if (!style || one) return style;
+    return Object.keys(style).some(isValueName) ? withoutValueNames(style) : style;
+  };
+
+  // A cell's styled runs, flattened into the one `tokens` array the stream
+  // carries. A token gains a `style` only where its run resolves differently
+  // from the cell's own, so a consumer that has never heard of a run reads
+  // `cell.style`, joins the tokens and is correct rather than merely unbroken
+  // (ADR 0061).
+  // What the cell's own style governs is the flattened token list, so the cell
+  // is its own implicit run for the rule above -- counted rather than
+  // concatenated, since only "exactly one, and a value" is being asked.
+  /** @type {(rendered: { tokens: any[] }[]) => boolean} */
+  let flatOneValue = (rendered) => {
+    let count = 0;
+    /** @type {any} */
+    let sole = null;
+    for (let { tokens } of rendered) {
+      count += tokens.length;
+      if (tokens.length === 1) sole = tokens[0];
+    }
+    return count === 1 && "value" in sole;
+  };
+  // One run's tokens, each wearing that run's style where it resolves
+  // differently from the cell's.
+  /** @type {(out: any[], worn: { tokens: any[], style: any }, style: any) => void} */
+  let wearing = (out, worn, style) => {
+    let look = presented(worn.style, oneValue(worn.tokens));
+    let wears = !sameStyle(look, style);
+    for (let token of worn.tokens) out.push(wears ? { ...token, style: look } : token);
+  };
+  /** @type {(styled: StyledRun[], scope: Scope, own: any, ownRaw: (scope: Scope) => any) => any} */
+  let composed = (styled, scope, own, ownRaw) => {
+    // The inline half of the cell's own block, unresolved, read once for every
+    // run to layer over.
+    let raw = ownRaw(scope);
+    let rendered = styled.map((one) => ({
+      tokens: one.tpl(scope),
+      style: styledRunLook(own, raw, one, scope),
+    }));
+    let style = presented(own, flatOneValue(rendered));
+    /** @type {any[]} */
+    let tokens = [];
+    for (let worn of rendered) wearing(tokens, worn, style);
+    return opt({ tokens }, { style });
+  };
+
   /**
-   * @type {(tpl: any, visible: Eval | null, styles: (scope: Scope) => any)
+   * @type {(styled: StyledRun[], visible: Eval | null, look: Look)
    *   => (scope: Scope) => any}
    */
-  let cellShape = (tpl, visible, styles) => (scope) =>
-    opt({ tokens: hidden(visible, scope) ? [] : tpl(scope) }, { style: styles(scope) });
+  let cellShape = (styled, visible, look) => (scope) => {
+    let own = look.styles(scope);
+    // A hidden cell keeps its slot with no tokens, and no tokens is no value
+    // for a declaration to present.
+    if (hidden(visible, scope)) return opt({ tokens: [] }, { style: presented(own, false) });
+    // A cell written as one template string is one implicit run wearing the
+    // cell's own style, so it never composes and never carries a token style.
+    if (styled.length === 1 && !styled[0].raw) {
+      let tokens = styled[0].tpl(scope);
+      return opt({ tokens }, { style: presented(own, oneValue(tokens)) });
+    }
+    return composed(styled, scope, own, look.raw);
+  };
 
   // A table cell: the shape of a total cell and of an object column header.
   /**
@@ -902,10 +1195,8 @@ let nodes = ({ bad }, { arr, obj, keys, expression, cellValue, visibleOf, styles
    *   { cell: (scope: Scope) => any, box: string[] }}
    */
   let cellOf = (def, path, valuePath = path + ".value") => {
-    let tpl = cellValue(def.value, valuePath);
-    let visible = visibleOf(def, path);
-    let look = cellLook(def, path);
-    return { cell: cellShape(tpl, visible, look.styles), box: look.box };
+    let { styled, visible, look } = cellParts(def, path, checkCellStyle, valuePath);
+    return { cell: cellShape(styled, visible, look), box: look.box };
   };
 
   /** @type {(def: any, path: string) => number} */
@@ -927,10 +1218,10 @@ let nodes = ({ bad }, { arr, obj, keys, expression, cellValue, visibleOf, styles
    */
   let headerOf = (def, path) => {
     if (typeof def === "string")
-      return { cell: cellShape(cellValue(def, path), null, NIL), span: 1, box: NO_CELL_LOOK.box };
+      return { cell: cellShape(cellValue(def, path), null, NO_LOOK), span: 1, box: NO_LOOK.box };
     if (!record(def)) {
       bad(path, "expected a template string or object");
-      return { cell: cellShape(EMPTY, null, NIL), span: 1, box: NO_CELL_LOOK.box };
+      return { cell: cellShape(NO_STYLED_RUNS, null, NO_LOOK), span: 1, box: NO_LOOK.box };
     }
     keys(def, ["value", "style", "span"], path);
     return { ...cellOf(def, path), span: spanOf(def, path) };
@@ -971,15 +1262,13 @@ let nodes = ({ bad }, { arr, obj, keys, expression, cellValue, visibleOf, styles
     if (!obj(def, path)) return null;
     keys(def, ["header", "value", "visible", "style", "width"], path);
     let header = headerSlot(def.header, path + ".header", slot);
-    let tpl = cellValue(def.value, path + ".value");
-    let visible = visibleOf(def, path);
-    let look = cellLook(def, path);
+    let { styled, visible, look } = cellParts(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, look.styles),
+      cell: cellShape(styled, visible, look),
       box: look.box,
       width: widthOf(def.width, path),
       path,
@@ -1004,13 +1293,8 @@ let nodes = ({ bad }, { arr, obj, keys, expression, cellValue, visibleOf, styles
   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,
-      inSlot ? visible : null,
-      stylesOf(def, path, inSlot ? checkSlotStyle : checkItemStyle),
-    );
+    let { styled, visible, look } = cellParts(def, path, inSlot ? checkSlotStyle : checkItemStyle);
+    let shape = cellShape(styled, inSlot ? visible : null, look);
     // The cell shape first, then the item's own fields, so a cell reads
     // the same wherever it appears in the stream.
     return (scope) => {
@@ -1039,7 +1323,7 @@ let nodes = ({ bad }, { arr, obj, keys, expression, cellValue, visibleOf, styles
     bad(path, 'unknown fit "' + fit + '"');
   };
   /** @type {(def: any, path: string) => any} */
-  let altOf = (def, path) => (def.alt != null ? cellValue(def.alt, path + ".alt") : null);
+  let altOf = (def, path) => (def.alt != null ? textValue(def.alt, path + ".alt") : null);
   /** @type {(alt: any, scope: Scope) => any} */
   let imageAlt = (alt, scope) => alt && alt(scope);
   /** @type {(fields: any, scope: Scope, bytes: any) => any} */
@@ -1094,13 +1378,13 @@ let nodes = ({ bad }, { arr, obj, keys, expression, cellValue, visibleOf, styles
     // 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 look = lookOf(def, path, imageLook(inSlot));
     let render = renderImage({
       source,
       fit: def.fit ?? "natural",
       alt,
       visible,
-      styles,
+      styles: look.styles,
       path,
       sourceSpec: def.source,
       role,
@@ -1110,7 +1394,7 @@ let nodes = ({ bad }, { arr, obj, keys, expression, cellValue, visibleOf, styles
     // 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);
+    let empty = cellShape(NO_STYLED_RUNS, null, look);
     return (scope) => render(scope) ?? { ...empty(scope), type: "item", role };
   };
 
@@ -1222,7 +1506,7 @@ let nodes = ({ bad }, { arr, obj, keys, expression, cellValue, visibleOf, styles
  * @param {Nodes} nodes
  */
 let bands = (
-  { bad, pin, runNames },
+  { bad, warn, pin, runNames },
   {
     arr,
     obj,
@@ -1321,6 +1605,7 @@ let bands = (
       .map((def, i) => columnOf(def, "detail.columns[" + i + "]", slots[i]))
       .filter((column) => column != null);
     checkShares(bad, columns, "detail.columns", "column");
+    underCommitted(warn, columns, "detail.columns");
     return { defs, columns };
   };
   /** @type {(totals: any[], prefix: string) => any[]} */
@@ -1425,7 +1710,7 @@ let bands = (
   let tableBand = (columns, total, rowVisible, rowStyles, headerStyles) => {
     // Which of each row box reaches which cell, settled once per table over
     // the names both sides declared -- so nothing at render reads a resolved
-    // object to find out who owns a border side (docs/adr/0056).
+    // object to find out who owns a border side (docs/adr/0062).
     let rowFan = columns.map((column) => boxReaching(rowStyles.names, column.box));
     let headers = columns.filter((column) => column.header);
     let headerFan = headers.map((column) => boxReaching(headerStyles.names, column.header.box));
@@ -1817,6 +2102,7 @@ export let plan = (schema, funcs, options) => {
   return {
     compiled: traverse(state, read, node, band, schema, options),
     problems: state.problems,
+    warnings: state.warnings,
     anchors: state.anchors,
     names: state.names,
     // Registry metadata comes from xprsn's one signature convention, described