@crossworks/content-core 0.230.43

package/src/doc-to-markdown.test.ts

@@ -0,0 +1,194 @@
+/**
+ * docToMarkdown contract tests. The bar is round-trip STABILITY against
+ * markdownToDoc: serializing a doc back to markdown and re-parsing must yield
+ * the same doc (modulo regenerated block ids and an aside's decorative angle).
+ * If these hold across the full dialect, the serializer is faithful.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { markdownToDoc } from './markdown-to-doc';
+import { docToMarkdown } from './doc-to-markdown';
+
+type N = {
+  type?: string;
+  attrs?: Record<string, unknown>;
+  content?: N[];
+  text?: string;
+  marks?: unknown;
+};
+
+/** Merge consecutive text nodes that share the exact mark set. Adjacent
+ *  same-mark text nodes are semantically identical regardless of how the
+ *  parser split them (escapes emit separate text tokens), so collapsing them
+ *  is the right granularity for a semantic comparison. */
+function coalesce(nodes: N[]): N[] {
+  const out: N[] = [];
+  for (const n of nodes) {
+    const prev = out[out.length - 1];
+    if (
+      n.type === 'text' &&
+      prev?.type === 'text' &&
+      JSON.stringify(prev.marks ?? null) === JSON.stringify(n.marks ?? null)
+    ) {
+      prev.text = (prev.text ?? '') + (n.text ?? '');
+    } else {
+      out.push(n);
+    }
+  }
+  return out;
+}
+
+/** Strip the volatile bits before comparing: block `id`s (regenerated every
+ *  parse) and an aside's `angle` (a `:::aside` fence always re-parses to 135,
+ *  by design — colour IS preserved); and coalesce text runs (see above). */
+function normalize(node: N): N {
+  const attrs = node.attrs ? { ...node.attrs } : undefined;
+  if (attrs) {
+    delete attrs.id;
+    if (node.type === 'aside') delete attrs.angle;
+  }
+  const out: N = { type: node.type };
+  if (attrs && Object.keys(attrs).length) out.attrs = attrs;
+  if (node.text !== undefined) out.text = node.text;
+  if (node.marks !== undefined) out.marks = node.marks;
+  if (node.content) out.content = coalesce(node.content.map(normalize));
+  return out;
+}
+
+/** markdownToDoc(m) and markdownToDoc(docToMarkdown(markdownToDoc(m))) agree. */
+function roundTrips(md: string): void {
+  const once = markdownToDoc(md) as N;
+  const back = docToMarkdown(once);
+  const twice = markdownToDoc(back) as N;
+  expect(normalize(twice)).toEqual(normalize(once));
+}
+
+describe('docToMarkdown — round-trip stability', () => {
+  it('headings + paragraphs', () => {
+    roundTrips('# Title\n\nA paragraph of plain text.\n\n## Sub\n\nMore text.');
+  });
+
+  it('inline marks: bold, italic, strike, code, link', () => {
+    roundTrips('Some **bold**, *italic*, ~~struck~~, `code`, and a [link](https://x.io/a).');
+  });
+
+  it('nested + combined marks', () => {
+    roundTrips('A ***bold-italic*** word and a **[bold link](https://x.io)**.');
+  });
+
+  it('highlight and themed colour spans', () => {
+    roundTrips(
+      'Plain ==highlight== then [coloured]{color=chart-2} and [both]{color=chart-1 highlight=chart-3}.',
+    );
+  });
+
+  it('bullet, ordered, and task lists (incl. nesting)', () => {
+    roundTrips('- one\n- two\n  - nested\n\n1. first\n2. second\n\n- [ ] todo\n- [x] done');
+  });
+
+  it('blockquote, code block, horizontal rule', () => {
+    roundTrips('> quoted line\n> second line\n\n```ts\nconst x = 1;\n```\n\n---\n\nafter');
+  });
+
+  it('tables', () => {
+    roundTrips('| Name | Role |\n| --- | --- |\n| Ash | Analyst |\n| Jay | Owner |');
+  });
+
+  it('callouts and asides', () => {
+    roundTrips(
+      ':::info\nHeads up — something to note.\n:::\n\n:::aside chart-3\nA themed aside.\n:::',
+    );
+  });
+
+  it('columns', () => {
+    roundTrips(':::columns\nLeft column text.\n+++\nRight column text.\n:::');
+  });
+
+  it('math (inline + block)', () => {
+    roundTrips('Inline $E=mc^2$ here.\n\n$$\n\\int_0^1 x\\,dx\n$$');
+  });
+
+  it('reference links: mention, uploaded image, file embed, sub-page card', () => {
+    roundTrips(
+      'ping [Sarah](mention:entity:n-1) about [the plan](mention:node:p-2)\n\n' +
+        '![gantry](media:f-1)\n\n[spec.pdf](media:f-2)\n\n[Sub plan](page:p-9)',
+    );
+  });
+
+  it('an inline media:/page: link inside prose stays a plain link (block forms are standalone lines)', () => {
+    roundTrips('see [spec.pdf](media:f-2) inline here');
+    const doc = markdownToDoc('see [spec.pdf](media:f-2) inline here') as N;
+    expect(doc.content?.[0]?.type).toBe('paragraph');
+  });
+
+  it('diagrams (```mermaid fence)', () => {
+    roundTrips('```mermaid\nflowchart LR\n  A[Ingest] --> B{Extract}\n  B --> C[Recall]\n```');
+  });
+
+  it('diagram source containing backtick runs widens the fence', () => {
+    const source = 'flowchart LR\n  A["uses ``` inside"] --> B[ok]';
+    const doc = { type: 'doc', content: [{ type: 'diagram', attrs: { source } }] };
+    const md = docToMarkdown(doc);
+    expect(md.startsWith('````mermaid\n')).toBe(true);
+    const back = markdownToDoc(md) as N;
+    expect(back.content?.[0]?.type).toBe('diagram');
+    expect(back.content?.[0]?.attrs?.source).toBe(source);
+  });
+
+  it('text that LOOKS like markdown stays literal', () => {
+    roundTrips('A line with a literal * star and _under_score_ and [brackets] and # hash.');
+  });
+
+  it('a paragraph starting with block markers stays a paragraph', () => {
+    roundTrips('- not a list, just a dash sentence.');
+    roundTrips('# not a heading either');
+    roundTrips('1. not an ordered item');
+  });
+
+  it('the full kitchen sink in one doc', () => {
+    roundTrips(
+      [
+        '# Report',
+        '',
+        'Intro with **bold** and a [link](https://x.io).',
+        '',
+        ':::warning',
+        'Careful here.',
+        ':::',
+        '',
+        '- alpha',
+        '- beta',
+        '  - beta.1',
+        '',
+        '| A | B |',
+        '| --- | --- |',
+        '| 1 | 2 |',
+        '',
+        '> a quote',
+        '',
+        '```js',
+        'return 42;',
+        '```',
+      ].join('\n'),
+    );
+  });
+});
+
+describe('docToMarkdown — direct output + edges', () => {
+  it('passes a string through unchanged and tolerates junk', () => {
+    expect(docToMarkdown('# already markdown')).toBe('# already markdown');
+    expect(docToMarkdown(null)).toBe('');
+    expect(docToMarkdown(42)).toBe('');
+    expect(docToMarkdown({ type: 'doc' })).toBe('');
+  });
+
+  it('produces clean markdown for a simple doc', () => {
+    const md = docToMarkdown(markdownToDoc('# Hi\n\nHello **world**.'));
+    expect(md).toBe('# Hi\n\nHello **world**.');
+  });
+
+  it('round-trips through a note-shaped export (doc → md → doc)', () => {
+    const md = '## Notes\n\n- buy milk\n- [x] ship it\n\nDone.';
+    expect(docToMarkdown(markdownToDoc(md))).toContain('- [x] ship it');
+  });
+});

package/src/doc-to-markdown.ts

@@ -0,0 +1,315 @@
+/**
+ * docToMarkdown — the inverse of `markdownToDoc`. Serializes a ProseMirror /
+ * TipTap page doc back into Saskia's rich-markdown dialect, so page content can
+ * be exported into a note or a file (the missing direction: there was
+ * `markdownToDoc` for authoring and `docToText` for the brain, but nothing that
+ * round-trips a page's body back to editable markdown).
+ *
+ * Correctness bar: round-trip STABILITY. For any markdown `m`,
+ *   markdownToDoc(docToMarkdown(markdownToDoc(m))) ≈ markdownToDoc(m)
+ * (block ids regenerate, and an aside's decorative `angle` collapses to the
+ * fence default — everything else is preserved). The round-trip tests assert
+ * exactly that.
+ *
+ * Strategy:
+ *  - Every node type produced by markdownToDoc has an inverse here; unknown
+ *    nodes degrade to their text/children rather than throwing (mirrors the
+ *    defensive stance of markdownToDoc + docToText).
+ *  - Literal text is backslash-escaped for every char that could re-trigger an
+ *    inline construct (`` ` `` * _ ~ = [ ] $ | < >), plus leading block markers
+ *    (#, -, +, n., :::). `marked` turns `\x` back into `x`, so escaping is
+ *    liberal but loss-free.
+ *  - Marks wrap a text run from the inside out — code → link → colour-span →
+ *    highlight → strike → italic → bold — the order that re-lexes to the same
+ *    flat mark set.
+ *
+ * Pure + DB-free, like markdownToDoc, so it's safe to call from the tool runtime.
+ */
+
+type PMMark = { type?: string; attrs?: Record<string, unknown> };
+type PMNode = {
+  type?: string;
+  attrs?: Record<string, unknown>;
+  content?: PMNode[];
+  text?: string;
+  marks?: PMMark[];
+};
+
+function s(v: unknown): string {
+  return typeof v === 'string' ? v : v == null ? '' : String(v);
+}
+
+/* ───────────────────────────── inline ───────────────────────────── */
+
+/** Escape every char that could re-trigger an inline construct on re-parse.
+ *  Backslash first so we don't double-escape our own escapes. */
+function escapeInline(text: string): string {
+  return text.replace(/\\/g, '\\\\').replace(/[`*_~=[\]$|<>]/g, '\\$&');
+}
+
+/** Neutralize a leading block marker so a paragraph's text doesn't re-parse as
+ *  a heading / list / quote / fence. Inline escaping already handled =,*,_,~,
+ *  [,<,>,|,$,`; this covers #, -, +, numbered, and the `:::` fence opener. */
+function escapeLeading(text: string): string {
+  return text
+    .replace(/^(#{1,6})(\s|$)/, '\\$1$2')
+    .replace(/^([-+]+)(\s|$)/, '\\$1$2')
+    .replace(/^(\d+)([.)])(\s)/, '$1\\$2$3')
+    .replace(/^(:::+)/, '\\$1');
+}
+
+/** Wrap a code span in a backtick fence long enough to contain it. */
+function codeSpan(raw: string): string {
+  const runs = raw.match(/`+/g);
+  const n = (runs ? Math.max(...runs.map((r) => r.length)) : 0) + 1;
+  const fence = '`'.repeat(n);
+  const pad = /^`|`$|^\s|\s$/.test(raw) ? ' ' : '';
+  return `${fence}${pad}${raw}${pad}${fence}`;
+}
+
+/** Wrap a single text run in its marks, inside-out. */
+function wrapMarks(raw: string, marks: PMMark[]): string {
+  const find = (t: string) => marks.find((m) => m.type === t);
+
+  let out = find('code') ? codeSpan(raw) : escapeInline(raw);
+
+  const link = find('link');
+  if (link) out = `[${out}](${s(link.attrs?.href)})`;
+
+  const color = find('textColor');
+  const highlight = find('highlight');
+  const hlColor = s(highlight?.attrs?.color) || undefined;
+  if ((color && color.attrs?.color) || hlColor) {
+    const parts: string[] = [];
+    if (color?.attrs?.color) parts.push(`color=${s(color.attrs.color)}`);
+    if (hlColor) parts.push(`highlight=${hlColor}`);
+    out = `[${out}]{${parts.join(' ')}}`;
+  }
+  // Plain highlight (==text==) only when it carries no colour token.
+  if (highlight && !hlColor) out = `==${out}==`;
+
+  if (find('strike')) out = `~~${out}~~`;
+  if (find('italic')) out = `*${out}*`;
+  if (find('bold')) out = `**${out}**`;
+  return out;
+}
+
+const markSig = (marks?: PMMark[]) => JSON.stringify(marks ?? []);
+
+/** An image node: uploaded (nodeId-backed) images serialize as a `media:`
+ *  reference so they survive markdown round-trips; URL images keep their src. */
+function imageToMd(node: PMNode): string {
+  const alt = s(node.attrs?.alt).replace(/[[\]]/g, '\\$&');
+  const nodeId = s(node.attrs?.nodeId);
+  const drawId = s(node.attrs?.drawId);
+  if (drawId) return `![${alt}](draw:${drawId})`;
+  return `![${alt}](${nodeId ? `media:${nodeId}` : s(node.attrs?.src)})`;
+}
+
+/** Serialize a run of inline nodes (text + atoms) to a markdown string. */
+function inlineNodes(nodes: PMNode[] | undefined): string {
+  const list = nodes ?? [];
+  let out = '';
+  let i = 0;
+  while (i < list.length) {
+    const n = list[i]!;
+    if (n.type === 'text') {
+      // Coalesce adjacent text nodes sharing the exact mark set (markdownToDoc
+      // emits one node per run, so this also keeps round-trips node-stable).
+      const sig = markSig(n.marks);
+      let raw = s(n.text);
+      let j = i + 1;
+      while (j < list.length && list[j]!.type === 'text' && markSig(list[j]!.marks) === sig) {
+        raw += s(list[j]!.text);
+        j++;
+      }
+      out += wrapMarks(raw, n.marks ?? []);
+      i = j;
+      continue;
+    }
+    switch (n.type) {
+      case 'hardBreak':
+        out += '\\\n';
+        break;
+      case 'inlineMath':
+        out += `$${s(n.attrs?.latex)}$`;
+        break;
+      case 'image':
+        out += imageToMd(n);
+        break;
+      case 'mention': {
+        // Round-trip syntax: [label](mention:<ref>:<id>) — the chip survives a
+        // markdown edit instead of flattening to its label. `ref` ('node' |
+        // 'entity') rides in the scheme so the extractor edge kind is kept.
+        const id = s(n.attrs?.id);
+        const label = s(n.attrs?.label ?? n.attrs?.id).replace(/[[\]]/g, '\\$&');
+        if (id) {
+          const ref = s(n.attrs?.ref) || 'entity';
+          out += `[${label}](mention:${ref}:${id})`;
+        } else {
+          out += escapeInline(s(n.attrs?.label ?? ''));
+        }
+        break;
+      }
+      default:
+        if (n.text) out += escapeInline(s(n.text));
+        else if (n.content) out += inlineNodes(n.content);
+    }
+    i++;
+  }
+  return out;
+}
+
+/* ───────────────────────────── blocks ───────────────────────────── */
+
+/** Join a sequence of block nodes with blank lines, dropping empties. */
+function blocksToMd(nodes: PMNode[] | undefined): string {
+  return (nodes ?? [])
+    .map(blockToMd)
+    .filter((b) => b !== '')
+    .join('\n\n');
+}
+
+/** Prefix every line of `body` with `first` (line 0) / `rest` (continuations). */
+function indentLines(body: string, first: string, rest: string): string {
+  return body
+    .split('\n')
+    .map((l, i) => (i === 0 ? first + l : l ? rest + l : ''))
+    .join('\n');
+}
+
+function listToMd(node: PMNode, ordered: boolean): string {
+  return (node.content ?? [])
+    .map((item, idx) => {
+      const marker = ordered ? `${idx + 1}. ` : '- ';
+      return indentLines(blocksToMd(item.content), marker, ' '.repeat(marker.length));
+    })
+    .join('\n');
+}
+
+function taskListToMd(node: PMNode): string {
+  return (node.content ?? [])
+    .map((item) => {
+      const marker = item.attrs?.checked ? '- [x] ' : '- [ ] ';
+      return indentLines(blocksToMd(item.content), marker, ' '.repeat(marker.length));
+    })
+    .join('\n');
+}
+
+/** A table cell's content flattened to a single inline string (cells are
+ *  single paragraphs; `|` is already inline-escaped, breaks collapse to space). */
+function cellText(cell: PMNode): string {
+  return blocksToMd(cell.content).replace(/\\\n/g, ' ').replace(/\n+/g, ' ').trim();
+}
+
+function tableToMd(node: PMNode): string {
+  const rows = node.content ?? [];
+  if (rows.length === 0) return '';
+  const renderRow = (row: PMNode) => `| ${(row.content ?? []).map(cellText).join(' | ')} |`;
+  const header = rows[0]!;
+  const cols = (header.content ?? []).length || 1;
+  const sep = `| ${Array(cols).fill('---').join(' | ')} |`;
+  return [renderRow(header), sep, ...rows.slice(1).map(renderRow)].join('\n');
+}
+
+function blockToMd(node: PMNode): string {
+  switch (node.type) {
+    case 'paragraph':
+      return escapeLeading(inlineNodes(node.content));
+    case 'heading': {
+      const level = Math.min(Math.max(Number(node.attrs?.level) || 1, 1), 6);
+      return `${'#'.repeat(level)} ${inlineNodes(node.content)}`;
+    }
+    case 'horizontalRule':
+      return '---';
+    case 'codeBlock':
+    case 'code_block': {
+      const lang = s(node.attrs?.language);
+      const text = (node.content ?? []).map((c) => s(c.text)).join('');
+      const runs = text.match(/`+/g);
+      const fence = '`'.repeat(
+        Math.max(3, (runs ? Math.max(...runs.map((r) => r.length)) : 0) + 1),
+      );
+      return `${fence}${lang}\n${text}\n${fence}`;
+    }
+    case 'blockquote':
+      return indentLines(blocksToMd(node.content), '> ', '> ')
+        .split('\n')
+        .map((l) => (l === '' ? '>' : l))
+        .join('\n');
+    case 'bulletList':
+    case 'bullet_list':
+      return listToMd(node, false);
+    case 'orderedList':
+    case 'ordered_list':
+      return listToMd(node, true);
+    case 'taskList':
+    case 'task_list':
+      return taskListToMd(node);
+    case 'table':
+      return tableToMd(node);
+    case 'callout': {
+      const variant = s(node.attrs?.variant) || 'info';
+      return `:::${variant}\n${blocksToMd(node.content)}\n:::`;
+    }
+    case 'aside': {
+      const color = s(node.attrs?.color);
+      return `:::aside${color ? ` ${color}` : ''}\n${blocksToMd(node.content)}\n:::`;
+    }
+    case 'columnList':
+    case 'column_list': {
+      const cols = (node.content ?? []).map((c) => blocksToMd(c.content));
+      return `:::columns\n${cols.join('\n+++\n')}\n:::`;
+    }
+    case 'image':
+    case 'pageImage':
+      return imageToMd(node);
+    case 'fileEmbed': {
+      // Round-trip syntax: a standalone-line [filename](media:<fileId>) link.
+      // Without it the chip VANISHES from any markdown-mediated rewrite.
+      const name = (s(node.attrs?.filename) || 'file').replace(/[[\]]/g, '\\$&');
+      const target = s(node.attrs?.nodeId) ? `media:${s(node.attrs?.nodeId)}` : s(node.attrs?.href);
+      return `[${name}](${target})`;
+    }
+    case 'childPage': {
+      // Round-trip syntax: a standalone-line [Title](page:<pageId>) link. The
+      // title is a display cache (the NodeView refreshes it on mount); the id
+      // is the payload. The icon attr regenerates the same way.
+      const title = (s(node.attrs?.title) || 'Untitled page').replace(/[[\]]/g, '\\$&');
+      return `[${title}](page:${s(node.attrs?.pageId)})`;
+    }
+    case 'blockMath': {
+      const latex = s(node.attrs?.latex);
+      return latex.includes('\n') ? `$$\n${latex}\n$$` : `$$${latex}$$`;
+    }
+    case 'diagram': {
+      const source = s(node.attrs?.source);
+      const runs = source.match(/`+/g);
+      const fence = '`'.repeat(
+        Math.max(3, (runs ? Math.max(...runs.map((r) => r.length)) : 0) + 1),
+      );
+      return `${fence}mermaid\n${source}\n${fence}`;
+    }
+    default:
+      // Unknown / future node: keep its text content if any.
+      if (node.content) return blocksToMd(node.content);
+      return node.text ? escapeInline(s(node.text)) : '';
+  }
+}
+
+/**
+ * Serialize a ProseMirror page doc to rich-markdown. Accepts a doc object
+ * (`{ type: 'doc', content: [...] }`), a bare content array, or a string
+ * (returned as-is). Never throws.
+ */
+export function docToMarkdown(doc: unknown): string {
+  if (typeof doc === 'string') return doc;
+  if (!doc || typeof doc !== 'object') return '';
+  const node = doc as PMNode;
+  const content = Array.isArray(node.content)
+    ? node.content
+    : Array.isArray(doc)
+      ? (doc as PMNode[])
+      : [];
+  return blocksToMd(content).replace(/[ \t]+$/gm, '');
+}

package/src/formula-dimensions.test.ts

@@ -0,0 +1,103 @@
+import { describe, expect, it } from 'vitest';
+import { parseFormulaSpec } from './formula-spec';
+import { checkDimensions, normaliseUnit } from './formula-dimensions';
+
+const LIQUID = '{Cd} * {Kvn} * {rho_l} * ({An} / {C1}) * SQRT(2 * {gc} * {Pgauge} / {rho_l})';
+
+function spec(gcUnit: string, resultUnit = 'lb/sec') {
+  const r = parseFormulaSpec({
+    id: 'api581',
+    unitSystem: 'USC',
+    variables: [
+      { symbol: 'Cd', role: 'constant', value: 0.61 },
+      { symbol: 'Kvn', role: 'constant', value: 1 },
+      { symbol: 'C1', role: 'constant', value: 12, unit: 'in/ft' },
+      { symbol: 'gc', role: 'constant', value: 32.2, unit: gcUnit },
+      { symbol: 'An', role: 'input', value: 0.11, unit: 'in2' },
+      { symbol: 'rho_l', role: 'input', unit: 'lb/ft3' },
+      { symbol: 'Pgauge', role: 'input', unit: 'lbf/in2 (g)' },
+    ],
+    expressions: [{ id: 'liquid', expression: LIQUID, unit: resultUnit }],
+  });
+  if (!r.ok) throw new Error(r.errors.join('; '));
+  return r.spec;
+}
+
+describe('normaliseUnit — the conventions printed tables actually use', () => {
+  it('reads hyphen as multiply and implicit exponents', () => {
+    expect(normaliseUnit('lbm-ft/(lbf-s2)')).toBe('lbm ft/(lbf s^2)');
+    expect(normaliseUnit('lb/ft3')).toBe('lb/ft^3');
+    expect(normaliseUnit('in2')).toBe('in^2');
+  });
+  it('drops a pressure-basis qualifier, which is not a dimension', () => {
+    expect(normaliseUnit('lbf/in2 (abs)')).toBe('lbf/in^2');
+    expect(normaliseUnit('lbf/in2 (g)')).toBe('lbf/in^2');
+  });
+  it('maps Rankine, which would otherwise parse as roentgen', () => {
+    expect(normaliseUnit('R')).toBe('degR');
+  });
+  it('treats unitless markers as no unit', () => {
+    expect(normaliseUnit('')).toBeNull();
+    expect(normaliseUnit('unitless')).toBeNull();
+  });
+});
+
+describe('checkDimensions', () => {
+  it('accepts the release-rate equation with g_c labelled correctly', () => {
+    expect(checkDimensions(spec('lbm-ft/(lbf-s2)'))).toEqual([]);
+  });
+
+  it('REJECTS g_c mislabelled as an acceleration — the audit finding', () => {
+    // Numerically identical in USC, so every value stayed right and every test
+    // passed. Only the dimensions expose it.
+    const issues = checkDimensions(spec('ft/s2'));
+    expect(issues).toHaveLength(1);
+    expect(issues[0]?.kind).toBe('mismatch');
+    expect(issues[0]?.id).toBe('liquid');
+    expect(issues[0]?.detail).toMatch(/a term is missing, or a variable's unit is wrong/);
+  });
+
+  it('catches a wrongly declared result unit', () => {
+    const issues = checkDimensions(spec('lbm-ft/(lbf-s2)', 'ft'));
+    expect(issues[0]?.kind).toBe('mismatch');
+    expect(issues[0]?.declared).toBe('ft');
+  });
+
+  it('catches a dropped term — the error no proofreading reliably finds', () => {
+    const r = parseFormulaSpec({
+      id: 'd',
+      variables: [
+        { symbol: 'rho', role: 'input', unit: 'lb/ft3' },
+        { symbol: 'A', role: 'input', unit: 'in2' },
+        { symbol: 'v', role: 'input', unit: 'ft/s' },
+      ],
+      // Mass flow is rho * A * v. Dropping `{v}` still computes a number.
+      expressions: [{ id: 'w', expression: '{rho} * {A}', unit: 'lb/sec' }],
+    });
+    if (!r.ok) throw new Error(r.errors.join('; '));
+    expect(checkDimensions(r.spec)[0]?.kind).toBe('mismatch');
+  });
+
+  it('reports an unreadable unit once, rather than as a cascade', () => {
+    const r = parseFormulaSpec({
+      id: 'u',
+      variables: [{ symbol: 'x', role: 'input', unit: 'widgets per fortnight' }],
+      expressions: [{ id: 'e', expression: '{x} * 2', unit: 'lb/sec' }],
+    });
+    if (!r.ok) throw new Error(r.errors.join('; '));
+    const issues = checkDimensions(r.spec);
+    expect(issues).toHaveLength(1);
+    expect(issues[0]?.kind).toBe('unparseable-unit');
+    expect(issues[0]?.id).toBe('x');
+  });
+
+  it('says nothing about a spec that declares no units', () => {
+    const r = parseFormulaSpec({
+      id: 'n',
+      variables: [{ symbol: 'a', role: 'input' }],
+      expressions: [{ id: 'e', expression: '{a} * 2' }],
+    });
+    if (!r.ok) throw new Error(r.errors.join('; '));
+    expect(checkDimensions(r.spec)).toEqual([]);
+  });
+});