@beeuni/sdk 0.2.0 → 0.3.0

package/dist/genui/catalog.js

@@ -0,0 +1,396 @@
+import { createLibrary, defineComponent } from '@openuidev/lang-core';
+import { z } from 'zod/v4';
+const isSlot = (field) => 'accepts' in field;
+const defined = {};
+const specs = {};
+function refsOf(names) {
+    const refs = names.map((name) => {
+        const component = defined[name];
+        if (!component)
+            throw new Error(`genui catalog: ${name} is used before it is defined`);
+        return component.ref;
+    });
+    return refs.length === 1 ? refs[0] : z.union(refs);
+}
+function component(input) {
+    const openui = {};
+    const strict = {};
+    const streaming = {};
+    const slots = {};
+    for (const [key, field] of Object.entries(input.fields)) {
+        if (!isSlot(field)) {
+            openui[key] = field;
+            strict[key] = field;
+            streaming[key] = field;
+            continue;
+        }
+        slots[key] = field;
+        const item = field.lazy ? z.lazy(() => refsOf(field.accepts)) : refsOf(field.accepts);
+        const strictArray = z.array(z.unknown()).min(field.min).max(field.max);
+        const streamingArray = z.array(z.unknown()).max(field.max);
+        openui[key] = field.optional ? z.array(item).optional() : z.array(item);
+        strict[key] = field.optional ? strictArray.optional() : strictArray;
+        streaming[key] = streamingArray.optional();
+    }
+    defined[input.name] = defineComponent({
+        name: input.name,
+        description: input.description,
+        props: z.object(openui),
+        component: input.name,
+    });
+    specs[input.name] = {
+        name: input.name,
+        block: input.block ?? true,
+        container: input.container ?? false,
+        slots,
+        urls: input.urls ?? {},
+        strict: z.object(strict),
+        streaming: z.object(streaming),
+        toMarkdown: input.toMarkdown,
+        a11y: input.a11y,
+    };
+}
+const escapeLine = (value) => value.replace(/[\\`*_[\]()<|]/g, '\\$&');
+const inline = (value) => escapeLine(String(value ?? '').replace(/\s*[\r\n]+\s*/g, ' '));
+const target = (value) => String(value ?? '').replace(/\(/g, '%28').replace(/\)/g, '%29');
+const cell = (value) => (typeof value === 'number' ? String(value) : inline(value));
+const mdTable = (head, rows) => [
+    `| ${head.join(' | ')} |`,
+    `| ${head.map(() => '---').join(' | ')} |`,
+    ...rows.map((row) => `| ${head.map((_, i) => cell(row[i] ?? '')).join(' | ')} |`),
+].join('\n');
+const nodes = (value) => (Array.isArray(value) ? value : []);
+const joinChildren = (value, child, separator = '\n\n') => nodes(value)
+    .map(child)
+    .filter((text) => text.length > 0)
+    .join(separator);
+const formatNumber = (value) => typeof value === 'number' && Number.isFinite(value) ? value.toLocaleString('en-US') : '';
+const withUnit = (value, unit) => (unit ? `${value} ${inline(unit)}` : value);
+const sourceLine = (source) => `Source: ${inline(source)}`;
+function seriesTable(labels, series, unit) {
+    const head = ['', ...series.map((s) => `${inline(s.props.name)}${unit ? ` \\(${inline(unit)}\\)` : ''}`)];
+    const rows = labels.map((label, i) => [
+        label,
+        ...series.map((s) => formatNumber(s.props.values?.[i])),
+    ]);
+    return mdTable(head, rows);
+}
+const osmLink = (lat, lng) => `https://www.openstreetmap.org/?mlat=${lat}&mlon=${lng}#map=15/${lat}/${lng}`;
+const text = (max) => z.string().min(1).max(max);
+const optText = (max) => z.string().max(max).optional();
+const url = () => z.string().max(2048);
+component({
+    name: 'Badge',
+    description: 'Short status tag. tone: neutral, good, warn, bad',
+    fields: { label: text(24), tone: z.enum(['neutral', 'good', 'warn', 'bad']).optional() },
+    toMarkdown: (p) => `[${inline(p.label)}]`,
+});
+component({
+    name: 'Link',
+    description: 'A link to a source, booking page, or document',
+    fields: { label: text(80), href: url() },
+    urls: { href: 'required' },
+    toMarkdown: (p) => `[${inline(p.label)}](${target(p.href)})`,
+});
+component({
+    name: 'Image',
+    description: 'A picture. Use only URLs from tool results or files. With text, the picture sits beside 1 to 3 sentences',
+    fields: { src: url(), alt: text(200), caption: optText(200), text: optText(400) },
+    urls: { src: 'required' },
+    toMarkdown: (p) => [`![${inline(p.alt)}](${target(p.src)})`, p.caption ? `*${inline(p.caption)}*` : '', p.text ? inline(p.text) : '']
+        .filter(Boolean)
+        .join('\n\n'),
+});
+component({
+    name: 'Callout',
+    description: 'A key takeaway or warning. tone: info, warn, success',
+    fields: { tone: z.enum(['info', 'warn', 'success']), body: text(400), title: optText(80) },
+    toMarkdown: (p) => String(p.body ?? '')
+        .split(/\r?\n/)
+        .map((line, i) => `> ${i === 0 && p.title ? `**${inline(p.title)}** ` : ''}${escapeLine(line.trim())}`.trimEnd())
+        .join('\n'),
+});
+component({
+    name: 'Stat',
+    description: 'One key number. trend: up, down, flat',
+    fields: {
+        label: text(40),
+        value: text(24),
+        delta: optText(24),
+        trend: z.enum(['up', 'down', 'flat']).optional(),
+        unit: optText(12),
+    },
+    toMarkdown: (p) => `**${inline(p.label)}:** ${withUnit(inline(p.value), p.unit)}${p.delta ? ` (${inline(p.delta)})` : ''}`,
+});
+component({
+    name: 'StatRow',
+    description: '2 to 4 Stats in a row, for the key numbers of an answer',
+    fields: { stats: { accepts: ['Stat'], min: 2, max: 4 } },
+    toMarkdown: (p, child) => nodes(p.stats).map((stat) => `- ${child(stat)}`).join('\n'),
+});
+component({
+    name: 'Table',
+    description: 'Rows a user scans or sorts. Up to 8 columns and 50 rows',
+    fields: {
+        columns: z.array(text(40)).min(1).max(8),
+        rows: z.array(z.array(z.union([z.string().max(200), z.number()])).max(8)).max(50),
+        caption: optText(120),
+    },
+    toMarkdown: (p) => [p.caption ? `*${inline(p.caption)}*` : '', mdTable(p.columns.map(inline), p.rows)]
+        .filter(Boolean)
+        .join('\n\n'),
+});
+component({
+    name: 'CompareItem',
+    description: 'One option inside Compare. values line up with Compare specs',
+    block: false,
+    fields: {
+        name: text(60),
+        values: z.array(z.string().max(120)).max(12),
+        pros: z.array(z.string().max(120)).max(5).optional(),
+        cons: z.array(z.string().max(120)).max(5).optional(),
+    },
+    toMarkdown: (p) => [
+        `**${inline(p.name)}**`,
+        ...(p.pros ?? []).map((pro) => `- + ${inline(pro)}`),
+        ...(p.cons ?? []).map((con) => `- − ${inline(con)}`),
+    ].join('\n'),
+});
+component({
+    name: 'Compare',
+    description: 'Side-by-side comparison of 2 to 4 options. specs are the row labels; winner names the pick',
+    fields: {
+        items: { accepts: ['CompareItem'], min: 2, max: 4 },
+        specs: z.array(text(40)).max(12).optional(),
+        winner: optText(60),
+    },
+    toMarkdown: (p, child) => {
+        const items = nodes(p.items);
+        const specsList = p.specs ?? [];
+        const parts = [];
+        if (specsList.length > 0) {
+            parts.push(mdTable(['', ...items.map((item) => inline(item.props.name))], specsList.map((spec, i) => [spec, ...items.map((item) => item.props.values[i] ?? '—')])));
+        }
+        parts.push(...items.map(child));
+        if (p.winner)
+            parts.push(`**Pick:** ${inline(p.winner)}`);
+        return parts.join('\n\n');
+    },
+});
+component({
+    name: 'RankedItem',
+    description: 'One entry inside RankedList. Leave image empty: options with photos are Cards',
+    block: false,
+    fields: { title: text(80), reason: text(240), meta: optText(80), image: url().optional(), href: url().optional() },
+    urls: { image: 'optional', href: 'optional' },
+    toMarkdown: (p) => `**${inline(p.title)}** — ${inline(p.reason)}${p.meta ? ` (${inline(p.meta)})` : ''}${p.href ? ` [Open](${target(p.href)})` : ''}`,
+});
+component({
+    name: 'RankedList',
+    description: 'A ranked recommendation, best first. Up to 10 items',
+    fields: { items: { accepts: ['RankedItem'], min: 1, max: 10 } },
+    toMarkdown: (p, child) => nodes(p.items).map((item, i) => `${i + 1}. ${child(item)}`).join('\n'),
+});
+component({
+    name: 'Series',
+    description: 'One named series of numbers inside a chart',
+    block: false,
+    fields: { name: text(40), values: z.array(z.number()).max(365) },
+    toMarkdown: (p) => `${inline(p.name)}: ${p.values.map(formatNumber).join(', ')}`,
+});
+const chartA11y = (kind) => (p) => `${kind}: ${nodes(p.series)
+    .map((s) => s.props.name)
+    .join(', ')}. Source: ${p.source}`;
+component({
+    name: 'BarChart',
+    description: 'Amounts across up to 24 categories, up to 4 series. source names where the data came from',
+    fields: {
+        categories: z.array(text(40)).min(1).max(24),
+        series: { accepts: ['Series'], min: 1, max: 4 },
+        source: text(200),
+        unit: optText(12),
+    },
+    toMarkdown: (p) => `${seriesTable(p.categories, nodes(p.series), p.unit)}\n\n${sourceLine(p.source)}`,
+    a11y: chartA11y('Bar chart'),
+});
+component({
+    name: 'LineChart',
+    description: 'A trend over time: x labels, up to 4 series. source names where the data came from',
+    fields: {
+        x: z.array(text(40)).min(2).max(365),
+        series: { accepts: ['Series'], min: 1, max: 4 },
+        source: text(200),
+        unit: optText(12),
+    },
+    toMarkdown: (p) => `${seriesTable(p.x, nodes(p.series), p.unit)}\n\n${sourceLine(p.source)}`,
+    a11y: chartA11y('Line chart'),
+});
+component({
+    name: 'Slice',
+    description: 'One part of a PieChart',
+    block: false,
+    fields: { label: text(40), value: z.number().nonnegative() },
+    toMarkdown: (p) => `${inline(p.label)}: ${formatNumber(p.value)}`,
+});
+component({
+    name: 'PieChart',
+    description: 'Shares of a whole, 2 to 6 slices. source names where the data came from. variant picks the layout: ' +
+        'donut: the total and every share (default). focus: the answer is about the first slice. ' +
+        'ring: one share dominates and is the headline. treemap: 4 to 6 slices, sizes matter more than the total. ' +
+        'gauge: 2 or 3 slices, like used against left. stack: a receipt, exact values to read',
+    fields: {
+        slices: { accepts: ['Slice'], min: 2, max: 6 },
+        source: text(200),
+        unit: optText(12),
+        variant: z.enum(['donut', 'focus', 'ring', 'treemap', 'gauge', 'stack']).optional(),
+    },
+    toMarkdown: (p) => {
+        const slices = nodes(p.slices);
+        const total = slices.reduce((sum, s) => sum + (Number(s.props.value) || 0), 0);
+        const lines = slices.map((s) => {
+            const value = Number(s.props.value) || 0;
+            const percent = total > 0 ? Math.round((value / total) * 100) : 0;
+            return `- ${inline(s.props.label)}: ${withUnit(formatNumber(value), p.unit)} (${percent}%)`;
+        });
+        return `${lines.join('\n')}\n\n${sourceLine(p.source)}`;
+    },
+    a11y: (p) => `Pie chart: ${nodes(p.slices)
+        .map((s) => `${s.props.label} ${formatNumber(s.props.value)}`)
+        .join(', ')}. Source: ${p.source}`,
+});
+component({
+    name: 'Marker',
+    description: 'One place on a Map. Coordinates only from tool results or files. description is its address or a short note. ' +
+        'value is the short figure in its map pin: a rating, a price, a population. href is its own page, image its photo, ' +
+        'phone its phone number, kind what it is (Hotel, Cafe, Museum)',
+    block: false,
+    fields: {
+        lat: z.number().min(-90).max(90),
+        lng: z.number().min(-180).max(180),
+        label: text(60),
+        description: optText(200),
+        value: optText(24),
+        href: url().optional(),
+        image: url().optional(),
+        phone: optText(30),
+        kind: optText(30),
+    },
+    urls: { href: 'optional', image: 'optional' },
+    toMarkdown: (p) => `**${inline(p.label)}**${p.value ? ` (${inline(p.value)})` : ''}${p.description ? ` — ${inline(p.description)}` : ''} ([map](${osmLink(p.lat, p.lng)}))`,
+});
+component({
+    name: 'Map',
+    description: 'Up to 25 places, zoom 1-18, then an optional route as [lat, lng] pairs. source names where the coordinates came from',
+    fields: {
+        markers: { accepts: ['Marker'], min: 1, max: 25 },
+        source: text(200),
+        zoom: z.number().int().min(1).max(18).optional(),
+        route: z.array(z.array(z.number()).length(2)).max(500).optional(),
+    },
+    toMarkdown: (p, child) => `${nodes(p.markers).map((m) => `- ${child(m)}`).join('\n')}\n\n${sourceLine(p.source)}`,
+    a11y: (p) => `Map with ${nodes(p.markers).length} places: ${nodes(p.markers)
+        .map((m) => m.props.label)
+        .join(', ')}. Source: ${p.source}`,
+});
+component({
+    name: 'Card',
+    description: 'One item: a hotel, product, place, or person. subtitle is a short location or kind line. ' +
+        'rating is 0 to 5, reviews is how many, price is a short text. 2 or more Cards in a Stack show as a grid or a list',
+    fields: {
+        title: text(80),
+        body: optText(600),
+        subtitle: optText(120),
+        image: url().optional(),
+        href: url().optional(),
+        badges: { accepts: ['Badge'], min: 0, max: 4, optional: true },
+        rating: z.number().min(0).max(5).optional(),
+        reviews: z.number().int().nonnegative().optional(),
+        price: optText(40),
+    },
+    urls: { image: 'optional', href: 'optional' },
+    toMarkdown: (p, child) => [
+        `### ${inline(p.title)}`,
+        p.rating != null ? `★ ${p.rating}${p.reviews != null ? ` (${formatNumber(p.reviews)})` : ''}` : '',
+        p.subtitle ? `*${inline(p.subtitle)}*` : '',
+        p.price ? inline(p.price) : '',
+        p.body ? inline(p.body) : '',
+        joinChildren(p.badges, child, ' '),
+        p.image ? `![${inline(p.title)}](${target(p.image)})` : '',
+        p.href ? `[Open](${target(p.href)})` : '',
+    ]
+        .filter(Boolean)
+        .join('\n\n'),
+});
+component({
+    name: 'Step',
+    description: 'One row inside Steps: a leg or action, what to do, its photo, and a time or cost',
+    block: false,
+    fields: { title: text(80), text: optText(500), image: url().optional(), meta: optText(40) },
+    urls: { image: 'optional' },
+    toMarkdown: (p) => `**${inline(p.title)}**${p.text ? ` — ${inline(p.text)}` : ''}${p.meta ? ` (${inline(p.meta)})` : ''}`,
+});
+component({
+    name: 'Steps',
+    description: 'A journey or a process in order: up to 12 rows, each with its photo, joined by a line',
+    fields: { steps: { accepts: ['Step'], min: 1, max: 12 } },
+    toMarkdown: (p, child) => nodes(p.steps).map((step, i) => `${i + 1}. ${child(step)}`).join('\n'),
+});
+component({
+    name: 'Checklist',
+    description: 'Things to pack or gather: a title and up to 20 items, each under 120 characters, the reader ticks off',
+    fields: { title: text(80), items: z.array(text(120)).min(1).max(20) },
+    toMarkdown: (p) => `**${inline(p.title)}**\n\n${p.items.map((item) => `- [ ] ${inline(item)}`).join('\n')}`,
+});
+export const GENUI_BLOCKS = [
+    'Stack', 'Card', 'Stat', 'StatRow', 'Table', 'Compare', 'RankedList', 'BarChart', 'LineChart',
+    'PieChart', 'Map', 'Steps', 'Checklist', 'Tabs', 'Accordion', 'Badge', 'Callout', 'Image', 'Link',
+];
+const INNER_BLOCKS = GENUI_BLOCKS.filter((name) => name !== 'Tabs' && name !== 'Accordion');
+component({
+    name: 'Tab',
+    description: 'One tab inside Tabs: a label and its blocks',
+    block: false,
+    fields: { label: text(30), children: { accepts: INNER_BLOCKS, min: 1, max: 8, lazy: true } },
+    toMarkdown: (p, child) => `#### ${inline(p.label)}\n\n${joinChildren(p.children, child)}`,
+});
+component({
+    name: 'Tabs',
+    description: '2 to 5 tabs. Use when content splits into views the user switches between',
+    container: true,
+    fields: { tabs: { accepts: ['Tab'], min: 2, max: 5 } },
+    toMarkdown: (p, child) => joinChildren(p.tabs, child),
+});
+component({
+    name: 'AccordionItem',
+    description: 'One collapsible section inside Accordion',
+    block: false,
+    fields: { title: text(80), children: { accepts: INNER_BLOCKS, min: 1, max: 8, lazy: true } },
+    toMarkdown: (p, child) => `#### ${inline(p.title)}\n\n${joinChildren(p.children, child)}`,
+});
+component({
+    name: 'Accordion',
+    description: 'Up to 10 collapsible sections, for details a reader may skip',
+    container: true,
+    fields: { items: { accepts: ['AccordionItem'], min: 1, max: 10 } },
+    toMarkdown: (p, child) => joinChildren(p.items, child),
+});
+component({
+    name: 'Stack',
+    description: 'Layout: 2 or more blocks in one block. children: 2 to 12 blocks. direction: col (default) or row. ' +
+        'layout, for 2 or more Cards: grid (big images) or list (small thumbnails); empty lets the app choose from the images',
+    container: true,
+    fields: {
+        children: { accepts: GENUI_BLOCKS, min: 1, max: 12, lazy: true },
+        direction: z.enum(['col', 'row']).optional(),
+        layout: z.enum(['list', 'grid']).optional(),
+    },
+    toMarkdown: (p, child) => joinChildren(p.children, child),
+});
+export const GENUI_SPECS = specs;
+export const GENUI_LIBRARY = createLibrary({
+    components: Object.values(defined),
+    root: 'Stack',
+});
+export const GENUI_MAX_DEPTH = 4;
+export const GENUI_MAX_NODES = 500;
+export const GENUI_MAX_SOURCE_CHARS = 64 * 1024;

package/dist/genui/expansion.d.ts

@@ -0,0 +1,3 @@
+import type { GenuiIssue } from './types.js';
+export declare function pendingStatementId(code: string): string | null;
+export declare function expansionIssue(code: string): GenuiIssue | null;

package/dist/genui/expansion.js

@@ -0,0 +1,295 @@
+import { autoClose, parseExpression, split, tokenize, walkAST } from '@openuidev/lang-core';
+import { GENUI_MAX_NODES, GENUI_MAX_SOURCE_CHARS } from './catalog.js';
+const MAX_NESTING = 64;
+const MAX_EXPANDED_VALUES = 50_000;
+function skipString(input, start) {
+    if (input[start] !== '"')
+        return start;
+    let i = start + 1;
+    while (i < input.length) {
+        const c = input[i];
+        if (c === '\\')
+            i += 2;
+        else if (c === '"')
+            return i + 1;
+        else
+            i++;
+    }
+    return i;
+}
+const isFence = (input, i) => input[i] === '`' && input[i + 1] === '`' && input[i + 2] === '`';
+function stripFences(input) {
+    const blocks = [];
+    let i = 0;
+    while (i < input.length) {
+        let fenceStart = -1;
+        while (i < input.length) {
+            const next = skipString(input, i);
+            if (next > i) {
+                i = next;
+                continue;
+            }
+            if (isFence(input, i)) {
+                fenceStart = i;
+                break;
+            }
+            i++;
+        }
+        if (fenceStart === -1)
+            break;
+        let j = fenceStart + 3;
+        while (j < input.length && input[j] !== '\n')
+            j++;
+        if (j >= input.length) {
+            blocks.push(input.slice(fenceStart + 3).replace(/^[^\n]*\n?/, ''));
+            break;
+        }
+        j++;
+        let closePos = -1;
+        let k = j;
+        while (k < input.length) {
+            const next = skipString(input, k);
+            if (next > k) {
+                k = next;
+                continue;
+            }
+            if (isFence(input, k)) {
+                closePos = k;
+                break;
+            }
+            k++;
+        }
+        if (closePos === -1) {
+            blocks.push(input.slice(j));
+            break;
+        }
+        blocks.push(input.slice(j, closePos));
+        i = closePos + 3;
+    }
+    if (blocks.length > 0)
+        return blocks.join('\n');
+    if (input.startsWith('```')) {
+        let j = 3;
+        while (j < input.length && input[j] !== '\n')
+            j++;
+        const body = input.slice(j < input.length ? j + 1 : 3);
+        const trailing = body.lastIndexOf('```');
+        return trailing === -1 ? body : body.slice(0, trailing);
+    }
+    return input;
+}
+function stripComments(input) {
+    let inStr = false;
+    return input
+        .split('\n')
+        .map((line) => {
+        for (let i = 0; i < line.length; i++) {
+            const c = line[i];
+            if (inStr) {
+                if (c === '\\' && i + 1 < line.length) {
+                    i++;
+                    continue;
+                }
+                if (c === inStr)
+                    inStr = false;
+                continue;
+            }
+            if (c === '"' || c === "'") {
+                inStr = c;
+                continue;
+            }
+            if (c === '/' && line[i + 1] === '/')
+                return line.substring(0, i).trimEnd();
+            if (c === '#')
+                return line.substring(0, i).trimEnd();
+        }
+        return line;
+    })
+        .join('\n');
+}
+const preprocess = (input) => stripComments(stripFences(input.trim())).trim();
+function bracketDepth(text) {
+    let depth = 0;
+    let max = 0;
+    let quote = '';
+    let escaped = false;
+    for (const c of text) {
+        if (quote) {
+            if (escaped)
+                escaped = false;
+            else if (c === '\\')
+                escaped = true;
+            else if (c === quote)
+                quote = '';
+        }
+        else if (c === '"' || c === "'")
+            quote = c;
+        else if (c === '(' || c === '[' || c === '{') {
+            max = Math.max(max, ++depth);
+            if (max > MAX_NESTING)
+                return max;
+        }
+        else if (c === ')' || c === ']' || c === '}')
+            depth = Math.max(0, depth - 1);
+    }
+    return max;
+}
+function splitStatements(cleaned) {
+    const completed = [];
+    let depth = 0;
+    let ternary = 0;
+    let quote = '';
+    let escaped = false;
+    let start = 0;
+    for (let i = 0; i < cleaned.length; i++) {
+        const c = cleaned[i];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (c === '\\' && quote) {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            if (c === quote)
+                quote = '';
+            continue;
+        }
+        if (c === '"' || c === "'")
+            quote = c;
+        else if (c === '(' || c === '[' || c === '{')
+            depth++;
+        else if (c === ')' || c === ']' || c === '}')
+            depth = Math.max(0, depth - 1);
+        else if (c === '?' && depth === 0)
+            ternary++;
+        else if (c === ':' && depth === 0 && ternary > 0)
+            ternary--;
+        else if (c === '\n' && depth <= 0 && ternary <= 0) {
+            let peek = i + 1;
+            while (peek < cleaned.length && ' \t\r\n'.includes(cleaned[peek]))
+                peek++;
+            if (peek < cleaned.length && (cleaned[peek] === '?' || (cleaned[peek] === ':' && ternary > 0)))
+                continue;
+            const text = cleaned.slice(start, i).trim();
+            if (text)
+                completed.push(text);
+            start = i + 1;
+        }
+    }
+    return { completed, pending: cleaned.slice(start).trim() };
+}
+function statementsOf(cleaned) {
+    const statements = new Map();
+    const add = (text, skipCompleted) => {
+        const completed = skipCompleted ? new Set(statements.keys()) : null;
+        for (const raw of split(tokenize(text))) {
+            if (completed?.has(raw.id))
+                continue;
+            statements.set(raw.id, { ast: parseExpression(raw.tokens), tokens: raw.tokens });
+        }
+    };
+    const { completed, pending } = splitStatements(cleaned);
+    for (const text of completed)
+        add(text, false);
+    if (pending) {
+        const { text, wasIncomplete } = autoClose(pending);
+        add(text, wasIncomplete);
+    }
+    return statements;
+}
+export function pendingStatementId(code) {
+    const { pending } = splitStatements(preprocess(code));
+    if (!pending)
+        return null;
+    return split(tokenize(autoClose(pending).text)).at(-1)?.id ?? null;
+}
+const OPEN = new Set([1, 3, 5]);
+const CLOSE = new Set([2, 4, 6]);
+export function expansionIssue(code) {
+    if (code.length > GENUI_MAX_SOURCE_CHARS) {
+        return { code: 'too-large', message: `Block source is longer than ${GENUI_MAX_SOURCE_CHARS} characters` };
+    }
+    const tooDeep = { code: 'depth', message: `Brackets or references nest deeper than ${MAX_NESTING}` };
+    const tooMany = (what) => ({ code: 'too-many-nodes', message: `${what}; the block is not rendered` });
+    const cleaned = preprocess(code);
+    if (bracketDepth(cleaned) > MAX_NESTING)
+        return tooDeep;
+    const own = new Map();
+    for (const [id, { ast, tokens }] of statementsOf(cleaned)) {
+        let elements = 0;
+        let values = 0;
+        const refs = [];
+        walkAST(ast, (node) => {
+            values++;
+            if (node.k === 'Comp')
+                elements++;
+            else if (node.k === 'Ref' || node.k === 'RuntimeRef')
+                refs.push(node.n);
+        });
+        let depth = 0;
+        let max = 0;
+        for (const token of tokens) {
+            if (OPEN.has(token.t))
+                max = Math.max(max, ++depth);
+            else if (CLOSE.has(token.t))
+                depth--;
+        }
+        own.set(id, { elements, values, depth: max, refs });
+    }
+    const nodeCap = GENUI_MAX_NODES + 1;
+    const valueCap = MAX_EXPANDED_VALUES + 1;
+    const sizes = new Map();
+    const path = new Set();
+    let cycle = false;
+    const measure = (id) => {
+        const known = sizes.get(id);
+        if (known)
+            return known;
+        if (path.size > MAX_NESTING)
+            return { elements: 0, values: 0, depth: MAX_NESTING + 1 };
+        path.add(id);
+        const statement = own.get(id);
+        let { elements, values } = statement;
+        let below = 0;
+        for (const ref of statement.refs) {
+            if (!own.has(ref))
+                continue;
+            if (path.has(ref)) {
+                cycle = true;
+                continue;
+            }
+            const child = measure(ref);
+            elements = Math.min(nodeCap, elements + child.elements);
+            values = Math.min(valueCap, values + child.values);
+            below = Math.max(below, child.depth);
+        }
+        path.delete(id);
+        const size = { elements, values, depth: statement.depth + 1 + below };
+        sizes.set(id, size);
+        return size;
+    };
+    let stateElements = 0;
+    let stateValues = 0;
+    for (const id of own.keys()) {
+        const size = measure(id);
+        if (id.startsWith('$')) {
+            stateElements = Math.min(nodeCap, stateElements + size.elements);
+            stateValues = Math.min(valueCap, stateValues + size.values);
+        }
+        if (cycle)
+            return tooMany('Block references form a cycle');
+        if (stateElements >= nodeCap)
+            return tooMany(`$state statements expand to more than ${GENUI_MAX_NODES} components`);
+        if (stateValues >= valueCap)
+            return tooMany(`$state statements expand to more than ${MAX_EXPANDED_VALUES} values`);
+        if (size.depth > MAX_NESTING)
+            return tooDeep;
+        if (size.elements >= nodeCap)
+            return tooMany(`Block expands to more than ${GENUI_MAX_NODES} components`);
+        if (size.values >= valueCap)
+            return tooMany(`Block expands to more than ${MAX_EXPANDED_VALUES} values`);
+    }
+    return null;
+}