@moxxy/core 0.3.0

package/dist/usage-stats.d.ts

@@ -0,0 +1,42 @@
+import { type ModelUsageTotals } from '@moxxy/sdk';
+/**
+ * Cross-session token usage, persisted at ~/.moxxy/usage.json. A forward-going
+ * aggregate keyed by `"<provider>/<model>"`: each session folds its own
+ * `provider_response` usage and merges the delta in on shutdown (see
+ * `@moxxy/plugin-usage-stats`). Purely additive counters — no derived/cost
+ * fields — so a session's contribution is added once and the file stays a sum.
+ *
+ * Like preferences, this is best-effort: a missing or malformed file reads as
+ * empty, and a write failure never blocks shutdown.
+ */
+export interface StoredModelUsage extends ModelUsageTotals {
+    /** ISO timestamp of the first session that recorded usage for this model. */
+    readonly firstSeen: string;
+    /** ISO timestamp of the most recent session that recorded usage. */
+    readonly lastSeen: string;
+}
+export interface UsageStatsFile {
+    readonly version: 1;
+    /** ISO timestamp of the last merge/clear. */
+    readonly updatedAt: string;
+    /** Per-`provider/model` lifetime totals. */
+    readonly models: Record<string, StoredModelUsage>;
+}
+export declare function usageStatsPath(): string;
+/**
+ * Read the usage aggregate. Returns an empty file when missing or unparseable —
+ * usage stats are an optional, non-load-blocking layer.
+ */
+export declare function loadUsageStats(filePath?: string): Promise<UsageStatsFile>;
+/**
+ * Merge a session's per-model delta into the persisted aggregate and write it
+ * back. Reads the current file, adds each delta field-wise, refreshes
+ * first/lastSeen, and writes atomically. Returns the updated file.
+ *
+ * Best-effort: a write failure logs to stderr but does not throw — losing one
+ * session's stats must never block shutdown.
+ */
+export declare function mergeUsageStats(delta: Record<string, ModelUsageTotals>, filePath?: string): Promise<UsageStatsFile>;
+/** Reset the aggregate to empty (the user-facing `/usage clear`). */
+export declare function clearUsageStats(filePath?: string): Promise<void>;
+//# sourceMappingURL=usage-stats.d.ts.map

package/dist/usage-stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage-stats.d.ts","sourceRoot":"","sources":["../src/usage-stats.ts"],"names":[],"mappings":"AAGA,OAAO,EAA+B,KAAK,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAGhF;;;;;;;;;GASG;AACH,MAAM,WAAW,gBAAiB,SAAQ,gBAAgB;IACxD,6EAA6E;IAC7E,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;IACpB,6CAA6C;IAC7C,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,4CAA4C;IAC5C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;CACnD;AAED,wBAAgB,cAAc,IAAI,MAAM,CAEvC;AAMD;;;GAGG;AACH,wBAAsB,cAAc,CAAC,QAAQ,GAAE,MAAyB,GAAG,OAAO,CAAC,cAAc,CAAC,CAgBjG;AAWD;;;;;;;GAOG;AACH,wBAAsB,eAAe,CACnC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,EACvC,QAAQ,GAAE,MAAyB,GAClC,OAAO,CAAC,cAAc,CAAC,CAgCzB;AAED,qEAAqE;AACrE,wBAAsB,eAAe,CAAC,QAAQ,GAAE,MAAyB,GAAG,OAAO,CAAC,IAAI,CAAC,CAExF"}

package/dist/usage-stats.js

@@ -0,0 +1,83 @@
+import { promises as fs } from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { addModelTotals, createMutex } from '@moxxy/sdk';
+import { writeFileAtomic } from '@moxxy/sdk/server';
+export function usageStatsPath() {
+    return path.join(os.homedir(), '.moxxy', 'usage.json');
+}
+function emptyStats() {
+    return { version: 1, updatedAt: new Date().toISOString(), models: {} };
+}
+/**
+ * Read the usage aggregate. Returns an empty file when missing or unparseable —
+ * usage stats are an optional, non-load-blocking layer.
+ */
+export async function loadUsageStats(filePath = usageStatsPath()) {
+    try {
+        const raw = await fs.readFile(filePath, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed &&
+            typeof parsed === 'object' &&
+            typeof parsed.models === 'object' &&
+            parsed.models !== null) {
+            return parsed;
+        }
+    }
+    catch {
+        // missing or malformed — start fresh
+    }
+    return emptyStats();
+}
+async function writeAtomic(file, filePath) {
+    await writeFileAtomic(filePath, JSON.stringify(file, null, 2) + '\n');
+}
+// Serializes the read-modify-write in `mergeUsageStats` so two concurrent
+// merges (e.g. overlapping shutdowns) can't both read the same snapshot and
+// have the second write clobber the first's delta.
+const mergeMutex = createMutex();
+/**
+ * Merge a session's per-model delta into the persisted aggregate and write it
+ * back. Reads the current file, adds each delta field-wise, refreshes
+ * first/lastSeen, and writes atomically. Returns the updated file.
+ *
+ * Best-effort: a write failure logs to stderr but does not throw — losing one
+ * session's stats must never block shutdown.
+ */
+export async function mergeUsageStats(delta, filePath = usageStatsPath()) {
+    // An empty delta writes nothing, so there's no read-modify-write to
+    // serialize: skip the mutex entirely and read the current file directly. A
+    // session with no recorded usage produces an empty delta on every shutdown,
+    // so this avoids needless I/O + contention on the common no-op path.
+    const keys = Object.keys(delta);
+    if (keys.length === 0)
+        return loadUsageStats(filePath);
+    return mergeMutex.run(async () => {
+        const current = await loadUsageStats(filePath);
+        const now = new Date().toISOString();
+        const models = { ...current.models };
+        for (const key of keys) {
+            const d = delta[key];
+            if (d.calls === 0)
+                continue;
+            const existing = models[key];
+            models[key] = existing
+                ? { ...addModelTotals(existing, d), firstSeen: existing.firstSeen, lastSeen: now }
+                : { ...d, firstSeen: now, lastSeen: now };
+        }
+        const next = { version: 1, updatedAt: now, models };
+        try {
+            await writeAtomic(next, filePath);
+        }
+        catch (err) {
+            process.stderr.write(`moxxy: failed to persist usage stats to ${filePath}: ` +
+                `${err instanceof Error ? err.message : String(err)}\n`);
+        }
+        return next;
+    });
+}
+/** Reset the aggregate to empty (the user-facing `/usage clear`). */
+export async function clearUsageStats(filePath = usageStatsPath()) {
+    await writeAtomic(emptyStats(), filePath);
+}
+//# sourceMappingURL=usage-stats.js.map

package/dist/usage-stats.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage-stats.js","sourceRoot":"","sources":["../src/usage-stats.ts"],"names":[],"mappings":"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"}

package/dist/view/default-renderer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The built-in view-spec renderer, seeded into every session's
+ * {@link ViewRendererRegistry}. Plugins may register/replace and `setActive`
+ * an alternative renderer with a different vocabulary.
+ */
+export declare const defaultViewRenderer: import("@moxxy/sdk").ViewRendererDef;
+//# sourceMappingURL=default-renderer.d.ts.map

package/dist/view/default-renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-renderer.d.ts","sourceRoot":"","sources":["../../src/view/default-renderer.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,sCAK9B,CAAC"}

package/dist/view/default-renderer.js

@@ -0,0 +1,14 @@
+import { DEFAULT_VIEW_TAGS, defineViewRenderer } from '@moxxy/sdk';
+import { parseView, validateDoc } from './parse.js';
+/**
+ * The built-in view-spec renderer, seeded into every session's
+ * {@link ViewRendererRegistry}. Plugins may register/replace and `setActive`
+ * an alternative renderer with a different vocabulary.
+ */
+export const defaultViewRenderer = defineViewRenderer({
+    name: 'moxxy/default',
+    allowList: DEFAULT_VIEW_TAGS,
+    parse: (source) => parseView(source, DEFAULT_VIEW_TAGS),
+    validate: (doc) => validateDoc(doc, DEFAULT_VIEW_TAGS),
+});
+//# sourceMappingURL=default-renderer.js.map

package/dist/view/default-renderer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-renderer.js","sourceRoot":"","sources":["../../src/view/default-renderer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AACnE,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEpD;;;;GAIG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,kBAAkB,CAAC;IACpD,IAAI,EAAE,eAAe;IACrB,SAAS,EAAE,iBAAiB;IAC5B,KAAK,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,SAAS,CAAC,MAAM,EAAE,iBAAiB,CAAC;IACvD,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,WAAW,CAAC,GAAG,EAAE,iBAAiB,CAAC;CACvD,CAAC,CAAC"}

package/dist/view/parse.d.ts

@@ -0,0 +1,7 @@
+import { countNodes } from '@moxxy/sdk';
+import type { ViewDoc, ViewParseError, ViewParseResult, ViewTagSpec } from '@moxxy/sdk';
+export declare function parseView(source: string, allowList: ReadonlyArray<ViewTagSpec>): ViewParseResult;
+/** Validate an already-built (expanded) AST against the allow-list. */
+export declare function validateDoc(doc: ViewDoc, allowList: ReadonlyArray<ViewTagSpec>): ViewParseError[];
+export { countNodes };
+//# sourceMappingURL=parse.d.ts.map

package/dist/view/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/view/parse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAiB,MAAM,YAAY,CAAC;AACvD,OAAO,KAAK,EAEV,OAAO,EAEP,cAAc,EACd,eAAe,EACf,WAAW,EACZ,MAAM,YAAY,CAAC;AA8bpB,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,eAAe,CAehG;AAED,uEAAuE;AACvE,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,EAAE,SAAS,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,cAAc,EAAE,CA0CjG;AAKD,OAAO,EAAE,UAAU,EAAE,CAAC"}

package/dist/view/parse.js

@@ -0,0 +1,479 @@
+import { countNodes, isSafeViewUrl } from '@moxxy/sdk';
+class ParseFail extends Error {
+    info;
+    constructor(info) {
+        super(info.message);
+        this.info = info;
+    }
+}
+function lineColAt(src, pos) {
+    let line = 1;
+    let col = 1;
+    for (let i = 0; i < pos && i < src.length; i++) {
+        if (src[i] === '\n') {
+            line++;
+            col = 1;
+        }
+        else {
+            col++;
+        }
+    }
+    return { line, col };
+}
+function fail(src, pos, message) {
+    throw new ParseFail({ message, ...lineColAt(src, pos) });
+}
+function tokenize(src) {
+    const tokens = [];
+    let i = 0;
+    const n = src.length;
+    while (i < n) {
+        const lt = src.indexOf('<', i);
+        if (lt === -1) {
+            if (src.slice(i).trim())
+                tokens.push({ t: 'text', value: src.slice(i), pos: i });
+            break;
+        }
+        if (lt > i && src.slice(i, lt).trim()) {
+            tokens.push({ t: 'text', value: src.slice(i, lt), pos: i });
+        }
+        // Comment: <!-- ... -->
+        if (src.startsWith('<!--', lt)) {
+            const end = src.indexOf('-->', lt + 4);
+            i = end === -1 ? n : end + 3;
+            continue;
+        }
+        // Closing tag
+        if (src[lt + 1] === '/') {
+            const gt = src.indexOf('>', lt);
+            if (gt === -1)
+                fail(src, lt, 'unterminated closing tag');
+            tokens.push({ t: 'close', tag: src.slice(lt + 2, gt).trim(), pos: lt });
+            i = gt + 1;
+            continue;
+        }
+        // Opening tag — read to the matching top-level '>' (quotes/braces aware)
+        const { end, inner } = readRawTag(src, lt);
+        let body = inner.trim();
+        const selfClose = body.endsWith('/');
+        if (selfClose)
+            body = body.slice(0, -1).trim();
+        const sp = body.search(/\s/);
+        const tag = (sp === -1 ? body : body.slice(0, sp)).trim();
+        if (!tag || !/^[A-Za-z][A-Za-z0-9-]*$/.test(tag))
+            fail(src, lt, `invalid tag name "${tag}"`);
+        const attrs = sp === -1 ? [] : parseAttrs(body.slice(sp));
+        tokens.push({ t: 'open', tag, attrs, selfClose, pos: lt });
+        i = end + 1;
+    }
+    return tokens;
+}
+function readRawTag(src, lt) {
+    let i = lt + 1;
+    const n = src.length;
+    let quote = null;
+    let brace = 0;
+    while (i < n) {
+        const c = src[i];
+        if (quote) {
+            if (c === quote)
+                quote = null;
+        }
+        else if (c === '"' || c === "'") {
+            quote = c;
+        }
+        else if (c === '{') {
+            brace++;
+        }
+        else if (c === '}') {
+            if (brace > 0)
+                brace--;
+        }
+        else if (c === '>' && brace === 0) {
+            return { end: i, inner: src.slice(lt + 1, i) };
+        }
+        i++;
+    }
+    fail(src, lt, 'unterminated tag');
+}
+function parseAttrs(s) {
+    const attrs = [];
+    let i = 0;
+    const n = s.length;
+    while (i < n) {
+        while (i < n && /\s/.test(s[i]))
+            i++;
+        if (i >= n)
+            break;
+        let name = '';
+        while (i < n && /[A-Za-z0-9\-_:]/.test(s[i])) {
+            name += s[i];
+            i++;
+        }
+        if (!name) {
+            i++; // skip a stray separator char
+            continue;
+        }
+        let j = i;
+        while (j < n && /\s/.test(s[j]))
+            j++;
+        if (s[j] === '=') {
+            i = j + 1;
+            while (i < n && /\s/.test(s[i]))
+                i++;
+            const q = s[i];
+            let value = '';
+            if (q === '"' || q === "'") {
+                i++;
+                while (i < n && s[i] !== q) {
+                    value += s[i];
+                    i++;
+                }
+                i++; // closing quote
+            }
+            else if (q === '{') {
+                const start = i;
+                let depth = 0;
+                while (i < n) {
+                    if (s[i] === '{')
+                        depth++;
+                    else if (s[i] === '}') {
+                        depth--;
+                        if (depth === 0) {
+                            i++;
+                            break;
+                        }
+                    }
+                    i++;
+                }
+                value = s.slice(start, i); // keep braces; raw
+            }
+            else {
+                while (i < n && !/\s/.test(s[i])) {
+                    value += s[i];
+                    i++;
+                }
+            }
+            attrs.push({ name, value });
+        }
+        else {
+            attrs.push({ name, value: true });
+            i = j;
+        }
+    }
+    return attrs;
+}
+function isBNode(c) {
+    return 'tag' in c;
+}
+function build(tokens, src) {
+    const top = [];
+    const stack = [];
+    for (const tok of tokens) {
+        const target = stack.length ? stack[stack.length - 1].children : top;
+        if (tok.t === 'text') {
+            target.push({ text: decodeEntities(tok.value) });
+        }
+        else if (tok.t === 'open') {
+            const node = { tag: tok.tag, attrs: tok.attrs, children: [], pos: tok.pos };
+            target.push(node);
+            if (!tok.selfClose)
+                stack.push(node);
+        }
+        else {
+            const open = stack.pop();
+            if (!open)
+                fail(src, tok.pos, `unexpected closing tag </${tok.tag}>`);
+            if (open.tag !== tok.tag) {
+                fail(src, tok.pos, `mismatched closing tag: expected </${open.tag}>, got </${tok.tag}>`);
+            }
+        }
+    }
+    if (stack.length)
+        fail(src, stack[stack.length - 1].pos, `unclosed tag <${stack[stack.length - 1].tag}>`);
+    const elements = top.filter(isBNode);
+    if (elements.length !== 1) {
+        throw new ParseFail({ message: `expected exactly one root element, found ${elements.length}` });
+    }
+    return elements[0];
+}
+function decodeEntities(s) {
+    return s
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .replace(/&apos;/g, "'")
+        .replace(/&amp;/g, '&');
+}
+// ---------------------------------------------------------------------------
+// Validation + coercion (BNode → ViewNode), collecting all errors
+// ---------------------------------------------------------------------------
+// URL safety: the canonical scheme allow-list is `isSafeViewUrl` in
+// @moxxy/sdk (view-renderer.ts) — shared with `validateDoc` below and
+// mirrored by the web frontend's render-time re-check.
+function coerceValue(tag, name, value, spec, errors) {
+    if (spec.type === 'boolean') {
+        if (value === true)
+            return true;
+        return value !== 'false';
+    }
+    if (value === true) {
+        errors.push({ message: `<${tag}> attribute "${name}" expects a value` });
+        return '';
+    }
+    if (spec.type === 'number') {
+        const num = Number(value);
+        if (!Number.isFinite(num)) {
+            errors.push({ message: `<${tag}> attribute "${name}" must be a number` });
+            return 0;
+        }
+        if (spec.min !== undefined && num < spec.min) {
+            errors.push({ message: `<${tag}> attribute "${name}" must be ≥ ${spec.min}` });
+        }
+        if (spec.max !== undefined && num > spec.max) {
+            errors.push({ message: `<${tag}> attribute "${name}" must be ≤ ${spec.max}` });
+        }
+        return num;
+    }
+    // Decode HTML entities in attribute string values so they match the
+    // contract of text nodes (which build() decodes), e.g. a label of
+    // `a &amp; b` renders `a & b` instead of the literal `a &amp; b`. Decoding
+    // happens BEFORE the URL-safety check below, so an entity-encoded scheme
+    // (e.g. `href="javascript&#58;…"`) is normalized to `javascript:` and still
+    // rejected — decoding can never smuggle a disallowed scheme past the check.
+    const decoded = decodeEntities(value);
+    if (spec.type === 'enum') {
+        if (!spec.values?.includes(decoded)) {
+            errors.push({ message: `<${tag}> attribute "${name}" must be one of: ${spec.values?.join(', ')}` });
+        }
+        return decoded;
+    }
+    // string
+    if ((name === 'href' || name === 'src') && !isSafeViewUrl(decoded, name)) {
+        errors.push({ message: `<${tag}> attribute "${name}" has a disallowed URL scheme` });
+    }
+    return decoded;
+}
+function coerceAttrs(b, spec, errors) {
+    const out = {};
+    const seen = new Set();
+    for (const a of b.attrs) {
+        if (/^on/i.test(a.name)) {
+            errors.push({ message: `<${b.tag}> forbidden attribute "${a.name}"` });
+            continue;
+        }
+        const aspec = spec?.attrs[a.name];
+        if (!aspec) {
+            // When the TAG itself is unknown (spec === undefined) convert() already
+            // pushed one `unknown tag` error — flagging every attribute as `unknown
+            // attribute` on top of it is redundant noise the agent reads back. The
+            // on* security check above still fires either way. Only emit the
+            // per-attribute error when the tag is known and the attribute isn't.
+            if (spec)
+                errors.push({ message: `<${b.tag}> unknown attribute "${a.name}"` });
+            continue;
+        }
+        seen.add(a.name);
+        out[a.name] = coerceValue(b.tag, a.name, a.value, aspec, errors);
+    }
+    if (spec) {
+        for (const [name, aspec] of Object.entries(spec.attrs)) {
+            if (aspec.required && !seen.has(name)) {
+                errors.push({ message: `<${b.tag}> missing required attribute "${name}"` });
+            }
+        }
+    }
+    return out;
+}
+function convert(b, specByTag, errors) {
+    const spec = specByTag.get(b.tag);
+    if (!spec)
+        errors.push({ message: `unknown tag <${b.tag}>` });
+    const props = coerceAttrs(b, spec, errors);
+    const children = [];
+    for (const c of b.children) {
+        if (!isBNode(c)) {
+            const v = c.text.replace(/\s+/g, ' ').trim();
+            if (!v)
+                continue; // drop whitespace-only text
+            if (spec && spec.allowedChildren !== 'any') {
+                errors.push({ message: `<${b.tag}> may not contain text` });
+            }
+            children.push({ kind: 'text', value: v });
+        }
+        else {
+            if (spec) {
+                if (spec.allowedChildren === 'none') {
+                    errors.push({ message: `<${b.tag}> may not have children` });
+                }
+                else if (Array.isArray(spec.allowedChildren) && !spec.allowedChildren.includes(c.tag)) {
+                    errors.push({ message: `<${b.tag}> may not contain <${c.tag}>` });
+                }
+            }
+            children.push(convert(c, specByTag, errors));
+        }
+    }
+    return finalizeNode({ kind: 'element', tag: b.tag, props, children }, spec);
+}
+// ---------------------------------------------------------------------------
+// Action + navigation extraction
+// ---------------------------------------------------------------------------
+function collectFieldNames(node) {
+    const names = [];
+    const walk = (n) => {
+        if (n.kind !== 'element')
+            return;
+        if ((n.tag === 'input' || n.tag === 'select' || n.tag === 'checkbox') && typeof n.props.name === 'string') {
+            names.push(n.props.name);
+        }
+        n.children.forEach(walk);
+    };
+    walk(node);
+    return names;
+}
+function finalizeNode(node, spec) {
+    if (node.kind !== 'element')
+        return node;
+    let out = node;
+    // Client-side navigation: any element carrying a `to` (link/button).
+    if (typeof node.props.to === 'string' && node.props.to) {
+        out = { ...out, nav: node.props.to };
+    }
+    if (spec?.interactive) {
+        if (node.tag === 'form') {
+            const name = typeof node.props.action === 'string' ? node.props.action : '';
+            out = { ...out, action: { name, fields: collectFieldNames(node) } };
+        }
+        else if (node.tag === 'button' && typeof node.props.action === 'string' && node.props.action) {
+            const fields = typeof node.props.fields === 'string' && node.props.fields
+                ? node.props.fields.split(',').map((f) => f.trim()).filter(Boolean)
+                : [];
+            out = { ...out, action: { name: node.props.action, fields } };
+        }
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+// Rich-component expansion (results → primitive card stack)
+// ---------------------------------------------------------------------------
+function el(tag, props, children, action, nav) {
+    return { kind: 'element', tag, props, children, ...(action ? { action } : {}), ...(nav ? { nav } : {}) };
+}
+function txt(value) {
+    return { kind: 'text', value };
+}
+/**
+ * `results` → a stack of selectable cards (one per `result`). Each card shows
+ * title/subtitle/badge and an "Open" affordance: `to` navigates client-side to a
+ * named view; else `action` (or `open:<id>` when only `id` is given) drives a turn.
+ */
+function expandResults(node) {
+    const cards = node.children
+        .filter((c) => c.kind === 'element' && c.tag === 'result')
+        .map((r) => {
+        const p = r.props;
+        const id = p.id != null ? String(p.id) : '';
+        const title = String(p.title ?? '');
+        const subtitle = p.subtitle != null ? String(p.subtitle) : '';
+        const badge = p.badge != null ? String(p.badge) : '';
+        const to = typeof p.to === 'string' && p.to ? p.to : undefined;
+        const action = typeof p.action === 'string' && p.action ? p.action : id ? `open:${id}` : undefined;
+        const left = el('stack', { gap: 'none' }, [
+            el('text', { weight: 'bold' }, [txt(title)]),
+            ...(subtitle ? [el('text', { tone: 'muted' }, [txt(subtitle)])] : []),
+        ]);
+        const right = [];
+        if (badge)
+            right.push(el('badge', {}, [txt(badge)]));
+        if (to)
+            right.push(el('button', { to, label: 'Open', variant: 'secondary' }, [], undefined, to));
+        else if (action)
+            right.push(el('button', { action, label: 'Open', variant: 'primary' }, [], { name: action, fields: [] }));
+        return el('card', {}, [
+            el('row', { justify: 'between', align: 'center' }, [left, el('row', { gap: 'md', align: 'center' }, right)]),
+        ]);
+    });
+    return el('stack', { gap: 'md' }, cards);
+}
+function expand(node) {
+    if (node.kind !== 'element')
+        return node;
+    if (node.tag === 'results')
+        return expandResults(node);
+    return { ...node, children: node.children.map(expand) };
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+export function parseView(source, allowList) {
+    try {
+        const tokens = tokenize(source);
+        const rootB = build(tokens, source);
+        const specByTag = new Map(allowList.map((s) => [s.tag, s]));
+        const errors = [];
+        let root = convert(rootB, specByTag, errors);
+        if (errors.length)
+            return { ok: false, errors };
+        root = expand(root);
+        const title = root.kind === 'element' && root.tag === 'view' && typeof root.props.title === 'string' ? root.props.title : undefined;
+        return { ok: true, doc: { root, ...(title ? { title } : {}) } };
+    }
+    catch (e) {
+        if (e instanceof ParseFail)
+            return { ok: false, errors: [e.info] };
+        return { ok: false, errors: [{ message: e instanceof Error ? e.message : String(e) }] };
+    }
+}
+/** Validate an already-built (expanded) AST against the allow-list. */
+export function validateDoc(doc, allowList) {
+    const specByTag = new Map(allowList.map((s) => [s.tag, s]));
+    const errors = [];
+    const walk = (node) => {
+        if (node.kind !== 'element')
+            return;
+        const spec = specByTag.get(node.tag);
+        if (!spec) {
+            errors.push({ message: `unknown tag <${node.tag}>` });
+            return;
+        }
+        for (const [key, value] of Object.entries(node.props)) {
+            if (!spec.attrs[key]) {
+                errors.push({ message: `<${node.tag}> unknown attribute "${key}"` });
+                continue;
+            }
+            // URL-scheme allow-list — an AST handed straight to validateDoc (i.e.
+            // one that never went through parseView's coerceValue) must not smuggle
+            // a javascript:/data:text href past the renderer.
+            if ((key === 'href' || key === 'src') && typeof value === 'string' && !isSafeViewUrl(value, key)) {
+                errors.push({ message: `<${node.tag}> attribute "${key}" has a disallowed URL scheme` });
+            }
+        }
+        for (const [name, aspec] of Object.entries(spec.attrs)) {
+            if (aspec.required && !(name in node.props)) {
+                errors.push({ message: `<${node.tag}> missing required attribute "${name}"` });
+            }
+        }
+        for (const c of node.children) {
+            if (c.kind === 'element') {
+                if (spec.allowedChildren === 'none') {
+                    errors.push({ message: `<${node.tag}> may not have children` });
+                }
+                else if (Array.isArray(spec.allowedChildren) && !spec.allowedChildren.includes(c.tag)) {
+                    errors.push({ message: `<${node.tag}> may not contain <${c.tag}>` });
+                }
+            }
+            else if (spec.allowedChildren !== 'any' && c.value.trim()) {
+                errors.push({ message: `<${node.tag}> may not contain text` });
+            }
+            walk(c);
+        }
+    };
+    walk(doc.root);
+    return errors;
+}
+// Count element + text nodes (for tool result `nodeCount`). The recursion now
+// lives in @moxxy/sdk so core's parser and the plugin-view tool share one
+// implementation; re-exported here to keep core's public export shape.
+export { countNodes };
+//# sourceMappingURL=parse.js.map