@aglyn/plugins-ai 1.0.0-beta.230 → 1.0.0-beta.231

package/src/lib/runtime/ai-doctrine-validators.js

@@ -18,6 +18,7 @@ import { _ as _extends } from "@swc/helpers/_/_extends";
 import { formatBytes, measureNodeMap, nodeMapBytes } from "@aglyn/aglyn/app-utils/measure-node-map";
 import { MEDIA_CDN_VARIANT_WIDTHS, parseMediaRef } from "@aglyn/aglyn/app-utils/media-ref";
 import { ESTIMATED_PAGE_TRANSFER_BYTES } from "@aglyn/aglyn/app-utils/plan-entitlements";
+import { createIdUrlSafe } from "@aglyn/aglyn/foundation/constants/app";
 import { FREE_AI_TASTE_CREDITS_PER_MONTH } from "../plan-entitlements.js";
 import { REUSABLE_INSTANCE_COMPONENT_ID, REUSABLE_INSTANCE_PROP_VALUES_KEY } from "@aglyn/aglyn/app-utils/reusable-component-keys";
 import { parseBreakpointSpan } from "@aglyn/shared-data-enums/breakpoint-span";
@@ -27,7 +28,7 @@ import { aiCreationNoun, aiPlanCanPlaceForm, aiPlanUncreatable, aiPlanUncreatabl
 import { aiFreeSiteSectionsWithin } from "../model/ai-site-job.js";
 import { AI_INSTANCE_REF_PROP, validateAiNodeTree } from "./ai-node-tree.js";
 import { AI_PAGE_SCROLL_TO_PROP, aiPageLinkTarget, aiStoredScrollTargets } from "./ai-page-links.js";
-import { AI_EMAIL_CLIP_BYTES, AI_OUTPUT_BUDGETS, AI_OUTPUT_SURFACE, isHeadlineVariant } from "./ai-palette.js";
+import { AI_EMAIL_CLIP_BYTES, AI_OUTPUT_BUDGETS, AI_OUTPUT_SURFACE, AI_TEXT_LIMITS, isHeadlineVariant } from "./ai-palette.js";
 import { AI_PALETTE, AI_SX_TOKENS } from "./ai-palette.generated.js";
 /** Each rule's title, in the words the proposal and the docs page use. */ export const AI_DOCTRINE_RULES = {
     1: 'Repeats become one reusable component',
@@ -170,13 +171,13 @@ function listNames(ids, tree) {
  * the outermost repeat: the header inside each of twelve cards repeats
  * because the card does, and the fix is the card. `groupOf` counts each
  * group's repeats apart; absent, the whole tree is one group.
- */ function repeatedShapes(tree, index, minNodes, minCount, groupOf = ()=>tree.rootId) {
+ */ function repeatedShapes(tree, index, minNodes, minCount, groupOf = ()=>tree.rootId, skip = ()=>false) {
     const byShape = new Map();
     for (const visit of index.visits){
         var _index_sizeOf_get, _byShape_get;
         if (visit.id === tree.rootId) continue;
         if (((_index_sizeOf_get = index.sizeOf.get(visit.id)) != null ? _index_sizeOf_get : 0) < minNodes) continue;
-        if (repeatedByData(tree, visit)) continue;
+        if (repeatedByData(tree, visit) || skip(visit)) continue;
         const shape = JSON.stringify([
             groupOf(visit),
             index.shapeOf.get(visit.id)
@@ -202,6 +203,71 @@ function listNames(ids, tree) {
             ids
         }));
 }
+/** Elements that frame and space what they hold, as rule 1 reads a frame. */ const REPEAT_FRAMES = new Set([
+    'muiBox',
+    'muiStack',
+    'muiContainer',
+    'muiGrid',
+    'section',
+    'muiList'
+]);
+/**
+ * What rule 1 does not call a block (AGL-3660), however like another it is:
+ *
+ *  - a part of the page's OUTLINE — anything holding a heading at h1 or h2.
+ *    Three sections that each open with an h2 over a row of items share a
+ *    shape because a page has sections, and a component cannot carry the
+ *    page's outline: a heading inside one is no heading of the page.
+ *  - a FRAME OF ITEMS — a Grid container, a List, or a Stack of like
+ *    elements — and any frame that holds only such frames. What repeats in
+ *    it is its items, which are judged on their own: two rows of three
+ *    instances of two different components are not one block.
+ *
+ * So rule 1 still refuses three like cards, and the same card on two pages;
+ * it no longer refuses a page for having more than two sections, or more than
+ * two groups.
+ */ function aiRepeatFrameOrSection(tree) {
+    var _ref;
+    const memo = new Map();
+    const childrenOf = (id)=>{
+        var _ref;
+        var _tree_nodes_id;
+        return ((_ref = (_tree_nodes_id = tree.nodes[id]) == null ? void 0 : _tree_nodes_id.nodes) != null ? _ref : []).filter((child)=>tree.nodes[child]);
+    };
+    const holdsOutline = (id)=>{
+        const node = tree.nodes[id];
+        const level = node ? aiHeadingLevel(node) : null;
+        return level !== null && level <= 2 || childrenOf(id).some(holdsOutline);
+    };
+    const itemFrame = (id)=>{
+        var _node_props;
+        const node = tree.nodes[id];
+        if (!node) return false;
+        if (node.componentId === 'muiGrid' && ((_node_props = node.props) == null ? void 0 : _node_props['container']) === true) return true;
+        if (node.componentId === 'muiList') return true;
+        const children = childrenOf(id);
+        // A Stack of like blocks — cards, rows, panels — and never of lines of text.
+        const kinds = new Set(children.map((child)=>tree.nodes[child].componentId));
+        return node.componentId === 'muiStack' && children.length >= 2 && kinds.size === 1 && children.every((child)=>{
+            var _tree_nodes_child_nodes;
+            return ((_tree_nodes_child_nodes = tree.nodes[child].nodes) != null ? _tree_nodes_child_nodes : []).length > 0;
+        });
+    };
+    const parentOf = new Map();
+    for (const [id, node] of Object.entries(tree.nodes))for (const child of (_ref = node == null ? void 0 : node.nodes) != null ? _ref : [])parentOf.set(child, id);
+    const exempt = (id)=>{
+        const known = memo.get(id);
+        if (known !== undefined) return known;
+        const node = tree.nodes[id];
+        const children = childrenOf(id);
+        const parent = parentOf.get(id);
+        const result = // An item of a frame is an item, whatever heading it carries.
+        holdsOutline(id) && !(parent !== undefined && itemFrame(parent)) || itemFrame(id) || !!node && REPEAT_FRAMES.has(node.componentId) && children.length > 0 && children.every(exempt);
+        memo.set(id, result);
+        return result;
+    };
+    return (visit)=>exempt(visit.id);
+}
 /**
  * Rule 1. A block repeated on one page, or a block this page shares with
  * another page generated beside it, is one component placed as instances.
@@ -211,7 +277,18 @@ function listNames(ids, tree) {
  */ export function detectRepeatedSubtrees(tree, otherPages = [], context = {}) {
     if (context.reusableComponents === false) return [];
     const index = indexShapes(tree);
-    const violations = repeatedShapes(tree, index, AI_REPEAT_MIN_NODES, AI_REPEAT_MIN_COUNT).map(({ ids })=>{
+    const violations = repeatedShapes(tree, index, AI_REPEAT_MIN_NODES, AI_REPEAT_MIN_COUNT, // Counted within the band of the page it sits in (AGL-3660), as rule 8
+    // counts a typed list: a heading over its words in the About band and in
+    // the Services band are two parts of two stories, not one block placed twice.
+    (visit)=>{
+        var _reverse_find;
+        return (_reverse_find = [
+            ...visit.ancestors
+        ].reverse().find((id)=>{
+            var _tree_nodes_id;
+            return ((_tree_nodes_id = tree.nodes[id]) == null ? void 0 : _tree_nodes_id.componentId) === 'section';
+        })) != null ? _reverse_find : tree.rootId;
+    }, aiRepeatFrameOrSection(tree)).map(({ ids })=>{
         const name = displayName(tree.nodes[ids[0]].componentId);
         return {
             rule: 1,
@@ -1258,6 +1335,192 @@ const GRID = 'muiGrid';
     }
     return violations;
 }
+/** The breakpoints a size names, in the order the renderer's string writes them. */ const GRID_SIZE_BREAKPOINTS = [
+    'xs',
+    'sm',
+    'md',
+    'lg',
+    'xl'
+];
+/**
+ * A size the model wrote as an object of breakpoints (`{ "xs": 12, "md": 4 }`),
+ * which the palette validator drops because a size is stored as one string,
+ * written as that string (`xs:12 md:4`). Anything else is not read.
+ */ function writtenGridSizeText(size) {
+    if (!isRecord(size)) return null;
+    const pairs = [];
+    for (const [breakpoint, value] of Object.entries(size)){
+        const span = typeof value === 'string' && value.trim() !== '' ? Number(value) : value;
+        if (!GRID_SIZE_BREAKPOINTS.includes(breakpoint) || typeof span !== 'number' || !Number.isInteger(span)) return null;
+        pairs.push(`${breakpoint}:${span}`);
+    }
+    pairs.sort((a, b)=>GRID_SIZE_BREAKPOINTS.indexOf(a.split(':')[0]) - GRID_SIZE_BREAKPOINTS.indexOf(b.split(':')[0]));
+    return pairs.length ? pairs.join(' ') : null;
+}
+/**
+ * Rule 12's `grid-item-size`, settled before the check reads it where it has
+ * one answer (AGL-3596), as `aiSettlePlanRefs` settles a plan. The re-ask for
+ * it states the very size to write, and a production Home page was refused and
+ * refunded after its re-ask still left a container's items unsized: the model
+ * breaks a different rule each run, and a rule whose answer the validator
+ * already knows is applied rather than asked for.
+ *
+ * For every Grid container, its items are read exactly as
+ * `detectUnresponsiveGrids` counts them, a Box or a Stack holding nothing but
+ * sized Grid items lending its items to the container:
+ *
+ * - an item whose size is missing, or is not full width on a phone, takes the
+ *   size the model wrote as an object of breakpoints where that one is full
+ *   width on a phone, and otherwise the size the re-ask would ask for
+ *   (`gridItemSizeFor`);
+ * - an element that is no Grid, directly in the container, is wrapped in a new
+ *   Grid item of that size, minted the way the palette validator mints ids;
+ * - a container of several items none of which steps down to columns at a
+ *   larger width takes that size on every item, which is what the re-ask asks;
+ * - a `container` written as the text "true" in any case or spacing
+ *   (`grid-container-text`) is true, since it can mean nothing else.
+ *
+ * A size that is already full width on a phone is kept. Nothing else rule 12
+ * names is touched: a Grid that is not a container may be meant as a row or as
+ * a stack (`grid-not-container`, `grid-as-stack`), and a sized item inside a
+ * Box (`grid-item-outside-container`) is moved only by changing the Box.
+ *
+ * `written` is the node as the model wrote it, by an id of `tree`, as
+ * `detectUnresponsiveGrids` reads it, for a tree the palette validator has
+ * read; a tree as the model wrote it is read as it stands, which is how the
+ * tree check settles a layout, a template or a component (`aiSettleWrittenGridItems`).
+ * A tree with nothing to settle comes back
+ * as the same object, so settling is idempotent. A node that is changed is
+ * copied, never edited in place.
+ */ export function aiSettleGridItems(tree, options = {}) {
+    var _options_written, _options_mintId;
+    const written = (_options_written = options.written) != null ? _options_written : ()=>undefined;
+    const mintId = (_options_mintId = options.mintId) != null ? _options_mintId : createIdUrlSafe;
+    const nodes = _extends({}, tree.nodes);
+    const copied = new Set();
+    const edit = (id)=>{
+        if (!copied.has(id)) {
+            const node = nodes[id];
+            nodes[id] = _extends({}, node, {
+                props: _extends({}, node.props)
+            }, node.nodes ? {
+                nodes: [
+                    ...node.nodes
+                ]
+            } : {});
+            copied.add(id);
+        }
+        return nodes[id];
+    };
+    const setSize = (id, size)=>{
+        var _nodes_id_props;
+        if (((_nodes_id_props = nodes[id].props) == null ? void 0 : _nodes_id_props['size']) === size) return;
+        edit(id).props['size'] = size;
+    };
+    const writtenProp = (id, name)=>{
+        const node = written(id);
+        return isRecord(node) && isRecord(node['props']) ? node['props'][name] : undefined;
+    };
+    const childrenOf = (id)=>{
+        var _ref;
+        var _nodes_id;
+        return ((_ref = (_nodes_id = nodes[id]) == null ? void 0 : _nodes_id.nodes) != null ? _ref : []).filter((child)=>nodes[child]);
+    };
+    const isSized = (id)=>{
+        var _nodes_id, _nodes_id_props;
+        return ((_nodes_id = nodes[id]) == null ? void 0 : _nodes_id.componentId) === GRID && ((_nodes_id_props = nodes[id].props) == null ? void 0 : _nodes_id_props['size']) !== undefined;
+    };
+    const wrapsItems = (id)=>{
+        const children = childrenOf(id);
+        return GRID_ITEM_WRAPPERS.has(nodes[id].componentId) && children.length > 0 && children.every(isSized);
+    };
+    for (const { id } of walkTree(tree)){
+        var _nodes_id_props;
+        if (nodes[id].componentId !== GRID) continue;
+        if (((_nodes_id_props = nodes[id].props) == null ? void 0 : _nodes_id_props['container']) !== true) {
+            var _nodes_id_props1;
+            // Text the palette validator dropped, or, in a tree as the model wrote it, the prop itself.
+            const own = (_nodes_id_props1 = nodes[id].props) == null ? void 0 : _nodes_id_props1['container'];
+            const text = own === undefined ? writtenProp(id, 'container') : own;
+            if (typeof text !== 'string' || text.trim().toLowerCase() !== 'true') continue;
+            edit(id).props['container'] = true;
+        }
+        const container = nodes[id];
+        const columns = gridColumns(container);
+        const children = childrenOf(id);
+        const items = children.flatMap((child)=>wrapsItems(child) ? childrenOf(child) : [
+                child
+            ]);
+        if (!items.length) continue;
+        const size = gridItemSizeFor(items.length, columns);
+        const settledItems = [];
+        for (const item of items){
+            var _nodes_item_props;
+            if (nodes[item].componentId !== GRID) {
+                var _host_nodes;
+                // Only a direct child can be no Grid: a wrapper lends only sized Grid items.
+                const wrapperId = mintId();
+                const host = edit(id);
+                host.nodes = ((_host_nodes = host.nodes) != null ? _host_nodes : []).map((child)=>child === item ? wrapperId : child);
+                const shape = container;
+                nodes[wrapperId] = _extends({}, '$id' in shape ? {
+                    $id: wrapperId
+                } : {}, 'type' in shape ? {
+                    type: shape['type']
+                } : {}, {
+                    componentId: GRID
+                }, 'pluginId' in shape ? {
+                    pluginId: shape['pluginId']
+                } : {}, 'parentId' in shape ? {
+                    parentId: id
+                } : {}, {
+                    nodes: [
+                        item
+                    ],
+                    props: {
+                        size
+                    }
+                });
+                copied.add(wrapperId);
+                if ('parentId' in nodes[item]) edit(item)['parentId'] = wrapperId;
+                settledItems.push(wrapperId);
+                continue;
+            }
+            if (!gridItemSpan((_nodes_item_props = nodes[item].props) == null ? void 0 : _nodes_item_props['size'], columns).phoneFull) {
+                var _writtenProp;
+                var _nodes_item_props1;
+                const own = writtenGridSizeText((_writtenProp = writtenProp(item, 'size')) != null ? _writtenProp : (_nodes_item_props1 = nodes[item].props) == null ? void 0 : _nodes_item_props1['size']);
+                setSize(item, own !== null && gridItemSpan(own, columns).phoneFull ? own : size);
+            }
+            settledItems.push(item);
+        }
+        const steps = settledItems.some((item)=>{
+            var _nodes_item_props;
+            return gridItemSpan((_nodes_item_props = nodes[item].props) == null ? void 0 : _nodes_item_props['size'], columns).steps;
+        });
+        if (settledItems.length >= 2 && !steps) for (const item of settledItems)setSize(item, size);
+    }
+    return copied.size ? _extends({}, tree, {
+        nodes
+    }) : tree;
+}
+/**
+ * `aiSettleGridItems` on a tree as the model wrote it, before the palette
+ * validator reads it (AGL-3596): the tree check every kind but a page section
+ * goes through stores what the validator makes of its answer, so the answer
+ * is settled first. Anything that is no flat node map comes back as it was.
+ */ export function aiSettleWrittenGridItems(input) {
+    if (!isRecord(input) || typeof input['rootId'] !== 'string' || !isRecord(input['nodes'])) return input;
+    const nodes = Object.fromEntries(Object.entries(input['nodes']).filter(([, node])=>isRecord(node)));
+    const tree = {
+        rootId: input['rootId'],
+        nodes: nodes
+    };
+    const settled = aiSettleGridItems(tree);
+    return settled === tree ? input : _extends({}, input, {
+        nodes: _extends({}, input['nodes'], settled.nodes)
+    });
+}
 /** The palette colors a link or a button can take, and a band can be painted in. */ const LINK_COLOR_FAMILIES = new Set([
     'primary',
     'secondary',
@@ -2305,6 +2568,175 @@ const BUDGET_METRICS = [
     }
     return violations;
 }
+/** The key a repeated item is written under (`AI_REPEAT_KEY` in `ai-repeated-items.ts`, which imports this file). */ const REPEAT_KEY = 'repeat';
+/**
+ * A node map that does not agree with itself, settled where it has one
+ * reading (AGL-3596), before `detectDisagreeingNodes` reads it. A guided
+ * start's Home page stopped on each of these after its re-ask, and each is
+ * one line the model left out, not a choice it made.
+ *
+ * - A name listed under `nodes` that the map never holds is taken out of the
+ *   list: there is nothing written to place there.
+ * - An element written and listed by nobody goes where the model said it
+ *   goes, when its own `parentId` names an element the tree reaches that can
+ *   hold it. Failing that, a single such element goes in the single element
+ *   the tree reaches that can hold elements and holds none, which is the shape
+ *   of a row whose item was written beside it. Failing both, it is dropped,
+ *   with everything under it: nothing on the page holds it, and none of it
+ *   would ever be shown.
+ * - A repeated item (`repeat`) is the exception: dropping it would lose every
+ *   card it draws, so one that cannot be placed is left for the re-ask.
+ *
+ * Reads and returns the tree as the model wrote it; an input with nothing to
+ * settle comes back as the same object.
+ */ export function aiSettleDisagreeingNodes(input) {
+    if (!isRecord(input) || typeof input['rootId'] !== 'string' || !isRecord(input['nodes'])) return input;
+    const rootId = input['rootId'];
+    const source = input['nodes'];
+    if (!isRecord(source[rootId])) return input;
+    const nodes = _extends({}, source);
+    let changed = false;
+    const listed = (id)=>{
+        const node = nodes[id];
+        return isRecord(node) && Array.isArray(node['nodes']) ? node['nodes'] : [];
+    };
+    const setListed = (id, children)=>{
+        nodes[id] = _extends({}, nodes[id], {
+            nodes: children
+        });
+        changed = true;
+    };
+    const holds = (id)=>{
+        var _AI_PALETTE_node_componentId;
+        const node = nodes[id];
+        return isRecord(node) && typeof node['componentId'] === 'string' && ((_AI_PALETTE_node_componentId = AI_PALETTE[node['componentId']]) == null ? void 0 : _AI_PALETTE_node_componentId.acceptsChildren) === true;
+    };
+    const reach = ()=>{
+        const reached = new Set([
+            rootId
+        ]);
+        const queue = [
+            rootId
+        ];
+        while(queue.length){
+            for (const child of listed(queue.shift())){
+                if (typeof child !== 'string' || reached.has(child) || !isRecord(nodes[child])) continue;
+                reached.add(child);
+                queue.push(child);
+            }
+        }
+        return reached;
+    };
+    // Names that were never written come out of the lists that name them.
+    for (const id of Object.keys(nodes)){
+        const children = listed(id);
+        const written = children.filter((child)=>typeof child !== 'string' || isRecord(nodes[child]));
+        if (written.length !== children.length) setListed(id, written);
+    }
+    let reached = reach();
+    const orphans = Object.keys(nodes).filter((id)=>!reached.has(id) && isRecord(nodes[id]));
+    if (orphans.length) {
+        const inOrphan = new Set(orphans.flatMap((id)=>listed(id)));
+        const roots = orphans.filter((id)=>!inOrphan.has(id));
+        const empty = [
+            ...reached
+        ].filter((id)=>id !== rootId && holds(id) && listed(id).length === 0);
+        for (const id of roots){
+            const named = nodes[id]['parentId'];
+            const parent = typeof named === 'string' && reached.has(named) && holds(named) ? named : roots.length === 1 && empty.length === 1 ? empty[0] : null;
+            if (parent) setListed(parent, [
+                ...listed(parent),
+                id
+            ]);
+        }
+        reached = reach();
+        const unplaced = Object.keys(nodes).filter((id)=>!reached.has(id) && isRecord(nodes[id]));
+        // A repeated item, and what it holds, is kept for the re-ask to place.
+        const kept = new Set();
+        const queue = unplaced.filter((id)=>nodes[id][REPEAT_KEY] !== undefined);
+        while(queue.length){
+            const id = queue.shift();
+            if (kept.has(id) || !isRecord(nodes[id])) continue;
+            kept.add(id);
+            for (const child of listed(id))if (typeof child === 'string') queue.push(child);
+        }
+        for (const id of unplaced){
+            if (kept.has(id)) continue;
+            delete nodes[id];
+            changed = true;
+        }
+    }
+    return changed ? _extends({}, input, {
+        nodes
+    }) : input;
+}
+/** The fewest words a heading cut at a boundary keeps, so a cut never leaves a stub. */ const HEADING_CUT_MIN_WORDS = 3;
+/** The least share of the ceiling a heading cut at a boundary keeps. */ const HEADING_CUT_MIN_SHARE = 0.3;
+/** Where a sentence ends: its stop is kept. */ const SENTENCE_END = /[.!?](?=\s)/g;
+/** Where a clause ends: the mark is dropped. */ const CLAUSE_END = /\s*(?:[,;:]|\s[—–-])\s/g;
+/**
+ * The longest whole part of a heading that fits `limit`: up to the last
+ * sentence that ends within it, else the last clause, or `null` where neither
+ * does, or where what is left is a stub.
+ */ function headingWithin(line, limit) {
+    const keeps = (head)=>head.split(/\s+/).length >= HEADING_CUT_MIN_WORDS && head.length >= limit * HEADING_CUT_MIN_SHARE;
+    for (const [pattern, keepMark] of [
+        [
+            SENTENCE_END,
+            true
+        ],
+        [
+            CLAUSE_END,
+            false
+        ]
+    ]){
+        let best = null;
+        for (const match of line.matchAll(pattern)){
+            var _match_index;
+            const head = line.slice(0, ((_match_index = match.index) != null ? _match_index : 0) + (keepMark ? match[0].length : 0)).trim();
+            if (head.length > limit) break;
+            best = head;
+        }
+        if (best !== null && keeps(best)) return best;
+    }
+    return null;
+}
+/**
+ * A heading written past the headline ceiling, settled where it has one
+ * reading (AGL-3596). The palette validator cuts such a line where the
+ * ceiling falls, mid-word, and the check refuses the cut (rule 14,
+ * `copy-cut-at-ceiling`); live guided starts' heroes stopped on it after
+ * their re-ask. A heading whose first sentence or clause ends within the
+ * ceiling is a whole line already, so it is kept to that, its later words
+ * dropped: "Free inspections after a storm, with photos of every shingle we
+ * replace and a written…" becomes "Free inspections after a storm". A heading
+ * with no such boundary, or whose part within is a stub, is left for the
+ * re-ask. Reads and returns the tree as the model wrote it.
+ */ export function aiSettleCutHeadings(input) {
+    var _ref;
+    var _AI_PALETTE_muiTypography_textLimits, _AI_PALETTE_muiTypography;
+    if (!isRecord(input) || !isRecord(input['nodes'])) return input;
+    const limit = Math.min((_ref = (_AI_PALETTE_muiTypography = AI_PALETTE['muiTypography']) == null ? void 0 : (_AI_PALETTE_muiTypography_textLimits = _AI_PALETTE_muiTypography.textLimits) == null ? void 0 : _AI_PALETTE_muiTypography_textLimits['children']) != null ? _ref : Infinity, AI_TEXT_LIMITS.headline);
+    let nodes = null;
+    for (const [id, node] of Object.entries(input['nodes'])){
+        if (!isRecord(node) || node['componentId'] !== 'muiTypography' || !isRecord(node['props'])) continue;
+        const line = node['props']['children'];
+        if (!isHeadlineVariant(node['props']['variant']) || typeof line !== 'string') continue;
+        const trimmed = line.trim();
+        if (trimmed.length <= limit || trimmed.includes('{{')) continue;
+        const head = headingWithin(trimmed, limit);
+        if (head === null) continue;
+        nodes != null ? nodes : nodes = _extends({}, input['nodes']);
+        nodes[id] = _extends({}, node, {
+            props: _extends({}, node['props'], {
+                children: head
+            })
+        });
+    }
+    return nodes ? _extends({}, input, {
+        nodes
+    }) : input;
+}
 /**
  * The whole check on one emitted tree: the palette validator first, then
  * every tree rule, then the budget. `otherPages` are the trees generated