@adecore/intelligent-ui 0.0.0 → 0.21.0

package/dist/stream.d.ts

@@ -0,0 +1,28 @@
+import { type UiBlock, type UiCompilerOptions } from './compiler.ts';
+export declare const UI_STREAM_INTERVAL_MS = 250;
+export interface UiStreamClock {
+    now(): number;
+    setTimeout(run: () => void, ms: number): unknown;
+    clearTimeout(handle: unknown): void;
+}
+export interface UiStreamPreview {
+    textLength: number;
+    blocks: UiBlock[];
+}
+export interface UiStreamOptions extends UiCompilerOptions {
+    clock: UiStreamClock;
+    emit(preview: UiStreamPreview): void;
+}
+export declare class UiStream {
+    private readonly compiler;
+    private readonly options;
+    private pending;
+    private timer;
+    private lastCompiledAt;
+    private closed;
+    constructor(options: UiStreamOptions);
+    update(text: string, latestAttachment?: string): void;
+    finish(text: string, latestAttachment?: string): UiBlock[];
+    dispose(): void;
+    private flush;
+}

package/dist/stream.js

@@ -0,0 +1,56 @@
+import { UiCompiler } from './compiler.js';
+export const UI_STREAM_INTERVAL_MS = 250;
+export class UiStream {
+    compiler;
+    options;
+    pending = null;
+    timer = null;
+    lastCompiledAt = -Infinity;
+    closed = false;
+    constructor(options) {
+        this.options = options;
+        this.compiler = new UiCompiler(options);
+    }
+    update(text, latestAttachment) {
+        if (this.closed) {
+            return;
+        }
+        this.pending = { text, latestAttachment };
+        if (this.timer !== null) {
+            return;
+        }
+        const delay = Math.max(0, UI_STREAM_INTERVAL_MS - (this.options.clock.now() - this.lastCompiledAt));
+        if (delay === 0) {
+            this.flush();
+        }
+        else {
+            this.timer = { handle: this.options.clock.setTimeout(() => this.flush(), delay) };
+        }
+    }
+    finish(text, latestAttachment) {
+        this.dispose();
+        const blocks = this.compiler.compile(text, { final: true, latestAttachment });
+        this.compiler.clear();
+        return blocks;
+    }
+    dispose() {
+        this.closed = true;
+        if (this.timer !== null) {
+            this.options.clock.clearTimeout(this.timer.handle);
+            this.timer = null;
+        }
+        this.pending = null;
+        this.compiler.clear();
+    }
+    flush() {
+        this.timer = null;
+        const pending = this.pending;
+        if (pending === null || this.closed) {
+            return;
+        }
+        this.pending = null;
+        this.lastCompiledAt = this.options.clock.now();
+        const blocks = this.compiler.compile(pending.text, { latestAttachment: pending.latestAttachment });
+        this.options.emit({ textLength: pending.text.length, blocks });
+    }
+}

package/dist/text.js

@@ -6,15 +6,25 @@ export function uiCompactCatalog() {
         const props = Object.entries(entry.schema.shape)
             .map(([key, schema]) => `${key}${schema.isOptional() ? '?' : ''}`)
             .join(',');
-        return `${name}(${props})`;
+        return `${name}${props ? `: ${props}` : ''}`;
     })
         .join(' · ');
 }
+const UI_SYNTAX = `Write XML-like component tags inside a fenced ${UI_FENCE_LANGUAGE} block. Put text between opening and closing tags; empty components end with />. Quote string props; put numbers, booleans and expressions in braces.`;
+const UI_EXAMPLE = [
+    '```' + UI_FENCE_LANGUAGE,
+    '$enabled = false',
+    '<Summary badge="Draft">Release overview</Summary>',
+    '<Stats><Stat label="Tests" value={42}/></Stats>',
+    '<Switch value={$enabled}>Notify me</Switch>',
+    '<Choices><Choice context="Review the release overview">Continue</Choice></Choices>',
+    '```'
+].join('\n');
 export function uiSessionNote() {
-    return `For a result, comparison or choice that benefits from an interface, put a fenced ${UI_FENCE_LANGUAGE} block in your final reply, with explanation outside it. Use catalog tags with named props; no layout, style or color props. State: $name = literal JSON on a line above the tags. Bind local inputs with value={$name}; use braced expressions and @Count, @Filter(list,row,predicate), @Sum, @Join, @Round. Show(when) and Each(items,as) control children. End decisions with Choices; each Choice has a short label and precise context shown to the person. Image takes a chat attachment or generated="latest", never a URL or path. No executable code. Local state resets on reload. ${uiCompactCatalog()}`;
+    return `${UI_SYNTAX} Prose outside. Only named catalog props, no styling. $name = literal JSON; input value={$name}; braced expressions: @Count, @Filter(list,row,predicate), @Sum, @Join, @Round. Show/Each control children. Choice labels and precise context stay visible and send once. Image: attachment or generated="latest", never URL/path. No code execution. State resets on reload. Catalog (? means optional props): ${uiCompactCatalog()}\nExample:\n${UI_EXAMPLE}\n`;
 }
 export function uiReferenceText() {
-    return Object.entries(UI_GROUPS)
+    const groups = Object.entries(UI_GROUPS)
         .map(([group, definition]) => {
         const components = Object.entries(UI_CATALOG)
             .filter(([, entry]) => entry.group === group)
@@ -22,11 +32,12 @@ export function uiReferenceText() {
             const props = Object.entries(entry.schema.shape)
                 .map(([key, schema]) => `${key}${schema.isOptional() ? '?' : ''}`)
                 .join(', ');
-            return `${name}(${props}): ${entry.description}`;
+            return `${name}: ${entry.description}${props ? ` Props: ${props}.` : ''}`;
         });
         return [definition.description, definition.rules, ...components].join('\n');
     })
         .join('\n\n');
+    return `${UI_SYNTAX}\nExample:\n${UI_EXAMPLE}\n\n${groups}`;
 }
 export function uiFallbackText(text, blocks) {
     let result = '';

package/package.json

@@ -1,84 +1,99 @@
 {
-    "name": "@adecore/intelligent-ui",
-    "version": "0.0.0",
-    "description": "A streaming UI catalog, compiler and bounded expression interpreter without a framework or DOM.",
-    "license": "FSL-1.1-MIT",
-    "author": "Bas Milius",
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/basmilius/adecore.git",
-        "directory": "packages/intelligent-ui"
+  "name": "@adecore/intelligent-ui",
+  "version": "0.21.0",
+  "description": "A streaming UI catalog, compiler and bounded expression interpreter without a framework or DOM.",
+  "license": "FSL-1.1-MIT",
+  "author": "Bas Milius",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/basmilius/adecore.git",
+    "directory": "packages/intelligent-ui"
+  },
+  "bugs": {
+    "url": "https://github.com/basmilius/adecore/issues"
+  },
+  "homepage": "https://adecore.dev/intelligent-ui/",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/fixtures"
+  ],
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
-    "bugs": {
-        "url": "https://github.com/basmilius/adecore/issues"
+    "./links": {
+      "source": "./src/links.ts",
+      "types": "./dist/links.d.ts",
+      "default": "./dist/links.js"
     },
-    "homepage": "https://adecore.dev/intelligent-ui/",
-    "type": "module",
-    "sideEffects": false,
-    "files": [
-        "dist",
-        "src",
-        "!src/**/*.test.ts",
-        "!src/fixtures"
-    ],
-    "exports": {
-        ".": {
-            "source": "./src/index.ts",
-            "types": "./dist/index.d.ts",
-            "default": "./dist/index.js"
-        },
-        "./catalog": {
-            "source": "./src/catalog.ts",
-            "types": "./dist/catalog.d.ts",
-            "default": "./dist/catalog.js"
-        },
-        "./budget": {
-            "source": "./src/budget.ts",
-            "types": "./dist/budget.d.ts",
-            "default": "./dist/budget.js"
-        },
-        "./expression": {
-            "source": "./src/expression.ts",
-            "types": "./dist/expression.d.ts",
-            "default": "./dist/expression.js"
-        },
-        "./syntax": {
-            "source": "./src/syntax.ts",
-            "types": "./dist/syntax.d.ts",
-            "default": "./dist/syntax.js"
-        },
-        "./compiler": {
-            "source": "./src/compiler.ts",
-            "types": "./dist/compiler.d.ts",
-            "default": "./dist/compiler.js"
-        },
-        "./runtime": {
-            "source": "./src/runtime.ts",
-            "types": "./dist/runtime.d.ts",
-            "default": "./dist/runtime.js"
-        },
-        "./protocol": {
-            "source": "./src/protocol.ts",
-            "types": "./dist/protocol.d.ts",
-            "default": "./dist/protocol.js"
-        },
-        "./text": {
-            "source": "./src/text.ts",
-            "types": "./dist/text.d.ts",
-            "default": "./dist/text.js"
-        }
+    "./query": {
+      "source": "./src/query.ts",
+      "types": "./dist/query.d.ts",
+      "default": "./dist/query.js"
     },
-    "scripts": {
-        "build": "bun scripts/build.ts",
-        "typecheck": "tsc --noEmit",
-        "test": "bun test --conditions=source"
+    "./catalog": {
+      "source": "./src/catalog.ts",
+      "types": "./dist/catalog.d.ts",
+      "default": "./dist/catalog.js"
     },
-    "devDependencies": {
-        "@types/bun": "^1.4.2",
-        "@types/node": "^24.13.6",
-        "typescript": "^7.0.2"
+    "./budget": {
+      "source": "./src/budget.ts",
+      "types": "./dist/budget.d.ts",
+      "default": "./dist/budget.js"
     },
-    "dependencies": {
-        "zod": "^4.6.5"
+    "./expression": {
+      "source": "./src/expression.ts",
+      "types": "./dist/expression.d.ts",
+      "default": "./dist/expression.js"
+    },
+    "./syntax": {
+      "source": "./src/syntax.ts",
+      "types": "./dist/syntax.d.ts",
+      "default": "./dist/syntax.js"
+    },
+    "./compiler": {
+      "source": "./src/compiler.ts",
+      "types": "./dist/compiler.d.ts",
+      "default": "./dist/compiler.js"
+    },
+    "./runtime": {
+      "source": "./src/runtime.ts",
+      "types": "./dist/runtime.d.ts",
+      "default": "./dist/runtime.js"
+    },
+    "./protocol": {
+      "source": "./src/protocol.ts",
+      "types": "./dist/protocol.d.ts",
+      "default": "./dist/protocol.js"
+    },
+    "./text": {
+      "source": "./src/text.ts",
+      "types": "./dist/text.d.ts",
+      "default": "./dist/text.js"
+    },
+    "./stream": {
+      "source": "./src/stream.ts",
+      "types": "./dist/stream.d.ts",
+      "default": "./dist/stream.js"
     }
+  },
+  "scripts": {
+    "build": "bun scripts/build.ts",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test --conditions=source"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.4.2",
+    "@types/node": "^24.13.6",
+    "typescript": "^7.0.2"
+  },
+  "dependencies": {
+    "zod": "^4.6.5"
+  }
 }

package/src/compiler.ts

@@ -6,6 +6,8 @@ import { type z } from 'zod';
 
 export const UI_FENCE_LANGUAGE = 'ruimte-ui';
 
+export const UI_REPLY_LIMITS = { blocks: 16, characters: 262144, nodes: 2048, milliseconds: 60 } as const;
+
 export interface UiNode {
     id: string;
     type: string;
@@ -23,11 +25,13 @@ export interface UiNode {
 export interface UiQuery {
     source: string;
     args: Record<string, UiValue>;
+    expression?: UiExpression;
 }
 
 export interface UiBlock {
     id: string;
     catalogVersion: number;
+    revision?: string;
     start: number;
     end: number;
     complete: boolean;
@@ -217,14 +221,29 @@ export function compileUiBlock(source: string, options: UiCompileOptions): UiBlo
     try {
         const syntax = parseUiSyntax(source, options.id, options.final, budget);
         block.diagnostics = syntax.diagnostics;
-        for (const [name, expression] of Object.entries(syntax.declarations)) {
+        for (const [name, expression] of Object.entries(syntax.declarations).sort(
+            ([, a], [, b]) => Number(a.kind === 'call' && a.name === 'Query') - Number(b.kind === 'call' && b.name === 'Query')
+        )) {
             try {
                 if (expression.kind === 'call' && expression.name === 'Query') {
-                    if (expression.args.length !== 2 || !expression.args.every(isConstant)) {
-                        throw new UiFailure('invalid_query', '@Query needs a literal source and literal argument record.');
+                    if (expression.args.length !== 2 || !isConstant(expression.args[0]) || expression.args[1].kind !== 'object') {
+                        throw new UiFailure('invalid_query', '@Query needs a literal source and an argument record.');
                     }
                     const querySource = evaluateUiExpression(expression.args[0], {}, budget);
-                    const args = evaluateUiExpression(expression.args[1], {}, budget);
+                    const argument = expression.args[1];
+                    const references = (part: unknown): void => {
+                        if (!part || typeof part !== 'object') {
+                            return;
+                        }
+                        if ('kind' in part && part.kind === 'reference' && 'name' in part && !Object.hasOwn(block.defaults, String(part.name))) {
+                            throw new UiFailure('invalid_query', 'Query arguments may reference only declared local state.');
+                        }
+                        for (const value of Object.values(part)) {
+                            references(value);
+                        }
+                    };
+                    references(argument);
+                    const args = evaluateUiExpression(argument, block.defaults, budget);
                     if (typeof querySource !== 'string' || !args || Array.isArray(args) || typeof args !== 'object') {
                         throw new UiFailure('invalid_query', 'Invalid query source or argument record.');
                     }
@@ -235,7 +254,10 @@ export function compileUiBlock(source: string, options: UiCompileOptions): UiBlo
                     if (!checked.success) {
                         throw new UiFailure('invalid_query', 'Query arguments do not match the host schema.');
                     }
-                    block.queries[name] = { source: querySource, args };
+                    if (Object.keys(block.queries).length >= 8) {
+                        throw new UiFailure('budget_exceeded', 'A block may declare at most eight queries.');
+                    }
+                    block.queries[name] = { source: querySource, args, ...(!isConstant(argument) ? { expression: argument } : {}) };
                 } else {
                     if (!isConstant(expression)) {
                         throw new UiFailure('invalid_default', 'State defaults must be literal JSON values.');
@@ -267,36 +289,129 @@ export function compileUiBlock(source: string, options: UiCompileOptions): UiBlo
     return block;
 }
 
-export function compileUi(text: string, options: UiCompileOptions): UiBlock[] {
-    const blocks: UiBlock[] = [];
-    let fence: { marker: string; length: number; start: number; codeStart: number; ui: boolean } | null = null;
-    let position = 0;
-    for (const line of text.split(/(?<=\n)/)) {
-        const opening = /^ {0,3}(`{3,}|~{3,})([^\r\n]*)/.exec(line);
-        if (!fence && opening) {
-            fence = {
-                marker: opening[1][0],
-                length: opening[1].length,
-                start: position,
-                codeStart: position + line.length,
-                ui: opening[2].trim() === UI_FENCE_LANGUAGE
-            };
-        } else if (fence && opening && opening[1][0] === fence.marker && opening[1].length >= fence.length && !opening[2].trim()) {
-            if (fence.ui) {
-                const block = compileUiBlock(text.slice(fence.codeStart, position), { ...options, id: `${options.id}:ui:${fence.start}`, final: true });
-                block.start = fence.start;
-                block.end = position + line.length;
-                blocks.push(block);
+export type UiCompilerOptions = Omit<UiCompileOptions, 'final' | 'latestAttachment'>;
+export type UiCompileUpdate = Pick<UiCompileOptions, 'final' | 'latestAttachment'>;
+
+interface CachedUiBlock {
+    source: string;
+    block: UiBlock;
+    latestAttachment?: string;
+}
+
+export class UiCompiler {
+    private readonly options: UiCompilerOptions;
+    private cache = new Map<number, CachedUiBlock>();
+
+    constructor(options: UiCompilerOptions) {
+        this.options = options;
+    }
+
+    compile(text: string, update: UiCompileUpdate = {}): UiBlock[] {
+        const blocks: UiBlock[] = [];
+        const next = new Map<number, CachedUiBlock>();
+        let fence: { marker: string; length: number; start: number; codeStart: number; ui: boolean } | null = null;
+        let position = 0;
+        let characters = 0;
+        let nodes = 0;
+        let exhausted = false;
+        const now = this.options.now ?? Date.now;
+        const started = now();
+        const nodeCount = (items: readonly UiNode[]): number => items.reduce((count, node) => count + 1 + nodeCount(node.children), 0);
+        const rejected = (start: number, codeStart: number, codeEnd: number, end: number, complete: boolean): UiBlock => ({
+            id: `${this.options.id}:ui:${start}`,
+            catalogVersion: UI_CATALOG_VERSION,
+            start,
+            end,
+            complete,
+            defaults: {},
+            queries: {},
+            nodes: [],
+            fallback: text.slice(codeStart, Math.min(codeEnd, codeStart + 4096)),
+            diagnostics: [uiDiagnostic(new UiFailure('budget_exceeded', 'This reply exceeded its UI budget; remaining fences stay text.'), start, end)]
+        });
+        const append = (start: number, codeStart: number, codeEnd: number, end: number, closed: boolean) => {
+            if (exhausted) {
+                return;
+            }
+            if (blocks.length >= UI_REPLY_LIMITS.blocks) {
+                const last = blocks.at(-1)!;
+                blocks[blocks.length - 1] = {
+                    ...last,
+                    diagnostics: [
+                        ...last.diagnostics.slice(0, 19),
+                        uiDiagnostic(new UiFailure('budget_exceeded', 'Further UI fences stay text because this reply has too many blocks.'), start, end)
+                    ]
+                };
+                exhausted = true;
+                return;
+            }
+            const complete = closed || update.final === true;
+            characters += codeEnd - codeStart;
+            if (characters > UI_REPLY_LIMITS.characters || now() - started > UI_REPLY_LIMITS.milliseconds) {
+                blocks.push(rejected(start, codeStart, codeEnd, end, complete));
+                exhausted = true;
+                return;
+            }
+            const source = text.slice(codeStart, codeEnd);
+            const cached = this.cache.get(start);
+            const unchanged =
+                !update.final &&
+                cached?.source === source &&
+                cached.block.end === end &&
+                cached.block.complete === complete &&
+                cached.latestAttachment === update.latestAttachment;
+            const block = unchanged
+                ? cached.block
+                : compileUiBlock(source, {
+                      ...this.options,
+                      ...update,
+                      id: `${this.options.id}:ui:${start}`,
+                      final: complete
+                  });
+            nodes += nodeCount(block.nodes);
+            if (nodes > UI_REPLY_LIMITS.nodes) {
+                blocks.push(rejected(start, codeStart, codeEnd, end, complete));
+                exhausted = true;
+                return;
+            }
+            block.start = start;
+            block.end = end;
+            blocks.push(block);
+            next.set(start, { source, block, latestAttachment: update.latestAttachment });
+        };
+        while (position < text.length && !exhausted) {
+            const newline = text.indexOf('\n', position);
+            const end = newline === -1 ? text.length : newline + 1;
+            const line = text.slice(position, end);
+            const opening = /^ {0,3}(`{3,}|~{3,})([^\r\n]*)/.exec(line);
+            if (!fence && opening) {
+                fence = {
+                    marker: opening[1][0],
+                    length: opening[1].length,
+                    start: position,
+                    codeStart: position + line.length,
+                    ui: opening[2].trim() === UI_FENCE_LANGUAGE
+                };
+            } else if (fence && opening && opening[1][0] === fence.marker && opening[1].length >= fence.length && !opening[2].trim()) {
+                if (fence.ui) {
+                    append(fence.start, fence.codeStart, position, position + line.length, true);
+                }
+                fence = null;
             }
-            fence = null;
+            position = end;
+        }
+        if (fence?.ui) {
+            append(fence.start, fence.codeStart, text.length, text.length, false);
         }
-        position += line.length;
+        this.cache = next;
+        return blocks;
     }
-    if (fence?.ui) {
-        const block = compileUiBlock(text.slice(fence.codeStart), { ...options, id: `${options.id}:ui:${fence.start}` });
-        block.start = fence.start;
-        block.end = text.length;
-        blocks.push(block);
+
+    clear(): void {
+        this.cache.clear();
     }
-    return blocks;
+}
+
+export function compileUi(text: string, options: UiCompileOptions): UiBlock[] {
+    return new UiCompiler(options).compile(text, options);
 }

package/src/index.ts

@@ -12,7 +12,32 @@ export {
 export { UI_LIMITS, UiBudget, UiFailure, safeKey, type UiLimits } from './budget.ts';
 export { copyUiValue, evaluateUiExpression, parseUiExpression, type UiExpression, type UiValue } from './expression.ts';
 export { parseUiSyntax, uiDiagnostic, type UiDiagnostic, type UiSyntax, type UiSyntaxNode } from './syntax.ts';
-export { UI_FENCE_LANGUAGE, compileUi, compileUiBlock, type UiBlock, type UiCompileOptions, type UiNode, type UiQuery } from './compiler.ts';
-export { evaluateUiBlock, UiState, type UiBinding, type UiEvaluation, type UiViewNode } from './runtime.ts';
+export {
+    UI_FENCE_LANGUAGE,
+    UI_REPLY_LIMITS,
+    UiCompiler,
+    compileUi,
+    compileUiBlock,
+    type UiCompilerOptions,
+    type UiCompileUpdate,
+    type UiBlock,
+    type UiCompileOptions,
+    type UiNode,
+    type UiQuery
+} from './compiler.ts';
+export {
+    evaluateUiBlock,
+    UiState,
+    uiInputValues,
+    resolveUiChoice,
+    type UiChoiceSelection,
+    type UiBinding,
+    type UiEvaluation,
+    type UiViewNode
+} from './runtime.ts';
+export { uiValidatedState, uiQueryArguments, uiQueryFallback } from './query.ts';
 export { UiNodeSchema, UiDiagnosticSchema, UiBlockSchema, UiBlocksSchema } from './protocol.ts';
 export { uiCompactCatalog, uiSessionNote, uiReferenceText, uiFallbackText } from './text.ts';
+export { UI_STREAM_INTERVAL_MS, UiStream, type UiStreamClock, type UiStreamOptions, type UiStreamPreview } from './stream.ts';
+
+export { UiLinkTargetSchema, UiLinkResolutionSchema, uiLinkTargets, type UiLinkTarget, type UiLinkResolution } from './links.ts';

package/src/links.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import type { UiBlock } from './compiler.ts';
+import { evaluateUiBlock, type UiViewNode } from './runtime.ts';
+import { uiValidatedState } from './query.ts';
+
+export const UiLinkTargetSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('File'), path: z.string().min(1).max(4096), line: z.number().int().positive().optional() }).strict(),
+    z.object({ type: z.literal('Diff'), path: z.string().min(1).max(4096) }).strict(),
+    z.object({ type: z.literal('Commit'), sha: z.string().regex(/^[a-f\d]{7,64}$/i) }).strict(),
+    z.object({ type: z.literal('Node'), id: z.string().min(1).max(256) }).strict()
+]);
+export type UiLinkTarget = z.infer<typeof UiLinkTargetSchema>;
+
+export const UiLinkResolutionSchema = z.object({
+    state: z.enum(['chip', 'plain']),
+    target: UiLinkTargetSchema.optional(),
+    cwd: z.string().optional(),
+    viewId: z.string().optional(),
+    projectId: z.string().optional(),
+    staged: z.boolean().optional(),
+    conflicted: z.boolean().optional(),
+    relativePath: z.string().optional(),
+    label: z.string().optional(),
+    reason: z.string().optional()
+});
+export type UiLinkResolution = z.infer<typeof UiLinkResolutionSchema>;
+
+export function uiLinkTargets(
+    block: UiBlock,
+    input: Readonly<Record<string, unknown>> = {},
+    queries: Readonly<Record<string, unknown>> = {}
+): Record<string, UiLinkTarget> {
+    const state = uiValidatedState(block, input, queries);
+    const targets: Record<string, UiLinkTarget> = Object.create(null);
+    const visit = (nodes: readonly UiViewNode[]) => {
+        for (const node of nodes) {
+            if (node.error || !node.complete) {
+                continue;
+            }
+            const checked = UiLinkTargetSchema.safeParse({ type: node.type, ...node.props });
+            if (checked.success) {
+                targets[node.id] = checked.data;
+            }
+            visit(node.children);
+        }
+    };
+    visit(evaluateUiBlock(block, state).nodes);
+    return targets;
+}

package/src/protocol.ts

@@ -32,11 +32,12 @@ export const UiDiagnosticSchema = z.object({
 export const UiBlockSchema: z.ZodType<UiBlock> = z.object({
     id: z.string(),
     catalogVersion: position,
+    revision: z.string().min(1).optional(),
     start: position,
     end: position,
     complete: z.boolean(),
     defaults: values,
-    queries: z.record(z.string(), z.object({ source: z.string(), args: values })),
+    queries: z.record(z.string(), z.object({ source: z.string(), args: values, expression: z.unknown().optional() })),
     nodes: z.array(UiNodeSchema),
     diagnostics: z.array(UiDiagnosticSchema),
     fallback: z.string()