@jini-ai/ui 0.5.4 → 0.5.6

package/dist/features/lexical-rich-text-editor/react/hooks/useKeyboardCommands.js

@@ -20,44 +20,9 @@ export function useKeyboardCommands(popoverOpen, onSubmit, onPopoverKey) {
     const onPopoverKeyRef = useRef(onPopoverKey);
     onPopoverKeyRef.current = onPopoverKey;
     useEffect(() => {
-        return mergeRegister(editor.registerCommand(KEY_ENTER_COMMAND, (e) => {
-            // IME confirm Enter — let Lexical commit the composition.
-            if (editor.isComposing())
-                return false;
-            if (e?.shiftKey) {
-                editor.dispatchCommand(INSERT_LINE_BREAK_COMMAND, false);
-                e.preventDefault();
-                return true;
-            }
-            // Cmd/Ctrl+Enter force-submits even with a popover open.
-            if (e?.metaKey || e?.ctrlKey) {
-                e.preventDefault();
-                onSubmitRef.current();
-                return true;
-            }
-            if (popoverOpenRef.current) {
-                e?.preventDefault();
-                return onPopoverKeyRef.current('Enter');
-            }
-            e?.preventDefault();
-            onSubmitRef.current();
-            return true;
-        }, COMMAND_PRIORITY_HIGH), editor.registerCommand(KEY_ARROW_DOWN_COMMAND, (e) => {
-            if (!popoverOpenRef.current || editor.isComposing())
-                return false;
-            e?.preventDefault();
-            return onPopoverKeyRef.current('ArrowDown');
-        }, COMMAND_PRIORITY_HIGH), editor.registerCommand(KEY_ARROW_UP_COMMAND, (e) => {
-            if (!popoverOpenRef.current || editor.isComposing())
-                return false;
-            e?.preventDefault();
-            return onPopoverKeyRef.current('ArrowUp');
-        }, COMMAND_PRIORITY_HIGH), editor.registerCommand(KEY_TAB_COMMAND, (e) => {
-            if (!popoverOpenRef.current || editor.isComposing())
-                return false;
-            e?.preventDefault();
-            return onPopoverKeyRef.current('Tab');
-        }, COMMAND_PRIORITY_HIGH), editor.registerCommand(KEY_ESCAPE_COMMAND, () => {
+        const routing = { editor, popoverOpenRef, onSubmitRef, onPopoverKeyRef };
+        const navKey = (key) => (event) => routeNavKeyToPopover({ ...routing, event, key });
+        return mergeRegister(editor.registerCommand(KEY_ENTER_COMMAND, (event) => handleEnter({ ...routing, event }), COMMAND_PRIORITY_HIGH), editor.registerCommand(KEY_ARROW_DOWN_COMMAND, navKey('ArrowDown'), COMMAND_PRIORITY_HIGH), editor.registerCommand(KEY_ARROW_UP_COMMAND, navKey('ArrowUp'), COMMAND_PRIORITY_HIGH), editor.registerCommand(KEY_TAB_COMMAND, navKey('Tab'), COMMAND_PRIORITY_HIGH), editor.registerCommand(KEY_ESCAPE_COMMAND, () => {
             if (!popoverOpenRef.current)
                 return false;
             return onPopoverKeyRef.current('Escape');
@@ -67,4 +32,34 @@ export function useKeyboardCommands(popoverOpen, onSubmit, onPopoverKey) {
         }, COMMAND_PRIORITY_HIGH));
     }, [editor]);
 }
+function handleEnter(at) {
+    const { editor, event: e } = at;
+    // IME confirm Enter — let Lexical commit the composition.
+    if (editor.isComposing())
+        return false;
+    if (e?.shiftKey) {
+        editor.dispatchCommand(INSERT_LINE_BREAK_COMMAND, false);
+        e.preventDefault();
+        return true;
+    }
+    // Cmd/Ctrl+Enter force-submits even with a popover open.
+    if (e?.metaKey || e?.ctrlKey) {
+        e.preventDefault();
+        at.onSubmitRef.current();
+        return true;
+    }
+    e?.preventDefault();
+    if (at.popoverOpenRef.current)
+        return at.onPopoverKeyRef.current('Enter');
+    at.onSubmitRef.current();
+    return true;
+}
+/** Arrow-down/up/Tab go to the popover only while it's open and no IME
+ *  composition is in progress; otherwise Lexical handles them. */
+function routeNavKeyToPopover(at) {
+    if (!at.popoverOpenRef.current || at.editor.isComposing())
+        return false;
+    at.event?.preventDefault();
+    return at.onPopoverKeyRef.current(at.key);
+}
 //# sourceMappingURL=useKeyboardCommands.js.map

package/dist/features/lexical-rich-text-editor/rules.js

@@ -205,6 +205,10 @@ function isUsableRect(r) {
 function toCaretRect(r) {
     return { top: r.top, bottom: r.bottom, left: r.left, right: r.right };
 }
+/** A caret rect pinned to a box's left edge (zero width). */
+function leftEdgeRect(r) {
+    return { top: r.top, bottom: r.bottom, left: r.left, right: r.left };
+}
 /** Reads the caret's viewport rect via the native selection, with ordered
  *  fallbacks for the collapsed-caret 0×0 case: (1) range bounding rect,
  *  (2) range client-rects list, (3) a zero-width probe range cloned at the
@@ -213,99 +217,108 @@ export function readCaretRect(rootEl) {
     if (typeof window === 'undefined')
         return null;
     const winSel = window.getSelection();
-    if (winSel && winSel.rangeCount > 0) {
-        const range = winSel.getRangeAt(0);
-        // jsdom does not implement Range geometry — guard every native call so a
-        // missing method falls through to the element/root box instead of
-        // throwing.
-        if (typeof range.getBoundingClientRect === 'function') {
-            const r = range.getBoundingClientRect();
-            if (isUsableRect(r))
-                return toCaretRect(r);
-        }
-        if (typeof range.getClientRects === 'function') {
-            const rects = range.getClientRects();
-            if (rects.length > 0 && isUsableRect(rects[0]))
-                return toCaretRect(rects[0]);
-        }
-        const anchorNode = range.startContainer;
-        if (anchorNode.nodeType === Node.TEXT_NODE) {
-            try {
-                const probe = document.createRange();
-                const len = anchorNode.length;
-                const off = Math.min(range.startOffset, len);
-                probe.setStart(anchorNode, off);
-                probe.setEnd(anchorNode, off);
-                if (typeof probe.getBoundingClientRect === 'function') {
-                    const pr = probe.getBoundingClientRect();
-                    if (isUsableRect(pr))
-                        return toCaretRect(pr);
-                }
-                if (typeof probe.getClientRects === 'function') {
-                    const prList = probe.getClientRects();
-                    if (prList.length > 0 && isUsableRect(prList[0]))
-                        return toCaretRect(prList[0]);
-                }
-            }
-            catch {
-                /* fall through */
-            }
-        }
-        const el = anchorNode.nodeType === Node.ELEMENT_NODE
-            ? anchorNode
-            : anchorNode.parentElement;
-        if (el) {
-            const er = el.getBoundingClientRect();
-            if (isUsableRect(er)) {
-                return { top: er.top, bottom: er.bottom, left: er.left, right: er.left };
-            }
-        }
+    const fromSelection = winSel && winSel.rangeCount > 0 ? caretRectFromRange(winSel.getRangeAt(0)) : null;
+    if (fromSelection)
+        return fromSelection;
+    return rootEl ? leftEdgeRect(rootEl.getBoundingClientRect()) : null;
+}
+/** Fallbacks (1)–(4) of `readCaretRect` for one live selection range. */
+function caretRectFromRange(range) {
+    const fromRange = rangeGeometryRect(range);
+    if (fromRange)
+        return fromRange;
+    const anchorNode = range.startContainer;
+    if (anchorNode.nodeType === Node.TEXT_NODE) {
+        const probed = probeTextCaretRect({ text: anchorNode, offset: range.startOffset });
+        if (probed)
+            return probed;
+    }
+    return anchorElementRect(anchorNode);
+}
+/** Fallbacks (1) and (2): a range's bounding rect, then its first client rect. */
+function rangeGeometryRect(range) {
+    // jsdom does not implement Range geometry — guard every native call so a
+    // missing method falls through to the element/root box instead of
+    // throwing.
+    if (typeof range.getBoundingClientRect === 'function') {
+        const r = range.getBoundingClientRect();
+        if (isUsableRect(r))
+            return toCaretRect(r);
     }
-    if (rootEl) {
-        const rr = rootEl.getBoundingClientRect();
-        return { top: rr.top, bottom: rr.bottom, left: rr.left, right: rr.left };
+    if (typeof range.getClientRects === 'function') {
+        const rects = range.getClientRects();
+        if (rects.length > 0 && isUsableRect(rects[0]))
+            return toCaretRect(rects[0]);
     }
     return null;
 }
+/** Fallback (3): geometry of a zero-width probe range at the anchor text offset. */
+function probeTextCaretRect(at) {
+    try {
+        const probe = document.createRange();
+        const off = Math.min(at.offset, at.text.length);
+        probe.setStart(at.text, off);
+        probe.setEnd(at.text, off);
+        return rangeGeometryRect(probe);
+    }
+    catch {
+        /* fall through */
+        return null;
+    }
+}
+/** Fallback (4): the anchor element's box (or the text anchor's parent's). */
+function anchorElementRect(anchorNode) {
+    const el = anchorNode.nodeType === Node.ELEMENT_NODE ? anchorNode : anchorNode.parentElement;
+    if (!el)
+        return null;
+    const er = el.getBoundingClientRect();
+    return isUsableRect(er) ? leftEdgeRect(er) : null;
+}
 /** Default ABOVE the caret (a composer typically sits at a panel's bottom,
  *  so above never occludes the input line); flip BELOW only when above lacks
  *  room. Clamp horizontally into the viewport (or `boundary`, when given).
  *  Caps height; the caller's popover scrolls internally. */
 export function computeCaretFloatingLayerPosition(caret, size, boundary, config) {
-    const { gap, margin, hardMaxHeight, preferredWidth } = config;
+    const { margin } = config;
     const vw = window.innerWidth;
-    const vh = window.innerHeight;
-    const viewportAvailableWidth = vw - margin * 2;
-    const boundaryAvailableWidth = boundary ? boundary.width - margin * 2 : viewportAvailableWidth;
+    const width = layerWidth({ vw, boundary, margin, preferredWidth: config.preferredWidth });
+    const vertical = verticalPlacement({
+        caret,
+        vh: window.innerHeight,
+        wantedH: size?.height ?? config.hardMaxHeight,
+        ...config,
+    });
+    const left = clampLeft({ caretLeft: caret.left, vw, boundary, margin, width });
+    return { left, top: vertical.top, width, maxHeight: vertical.maxHeight, placement: vertical.placement };
+}
+function layerWidth(at) {
+    const viewportAvailableWidth = at.vw - at.margin * 2;
+    const boundaryAvailableWidth = at.boundary
+        ? at.boundary.width - at.margin * 2
+        : viewportAvailableWidth;
     const availableWidth = Math.max(240, Math.min(viewportAvailableWidth, boundaryAvailableWidth));
-    const width = Math.min(preferredWidth, availableWidth);
+    return Math.min(at.preferredWidth, availableWidth);
+}
+function verticalPlacement(at) {
+    const { caret, gap, margin, wantedH } = at;
     const spaceAbove = caret.top - gap - margin;
-    const spaceBelow = vh - caret.bottom - gap - margin;
-    const wantedH = size?.height ?? hardMaxHeight;
+    const spaceBelow = at.vh - caret.bottom - gap - margin;
     const aboveFits = spaceAbove >= Math.min(wantedH, 160);
     const placement = aboveFits || spaceAbove >= spaceBelow ? 'above' : 'below';
     const space = placement === 'above' ? spaceAbove : spaceBelow;
-    const maxHeight = Math.max(120, Math.min(hardMaxHeight, space));
-    let top;
-    if (placement === 'above') {
-        const h = Math.min(wantedH, maxHeight);
-        top = caret.top - gap - h;
-        if (top < margin)
-            top = margin;
-    }
-    else {
-        top = caret.bottom + gap;
-    }
+    const maxHeight = Math.max(120, Math.min(at.hardMaxHeight, space));
+    if (placement === 'below')
+        return { top: caret.bottom + gap, maxHeight, placement };
+    const h = Math.min(wantedH, maxHeight);
+    return { top: Math.max(margin, caret.top - gap - h), maxHeight, placement };
+}
+function clampLeft(at) {
+    const { vw, boundary, margin, width } = at;
     const minLeft = boundary ? Math.max(margin, boundary.left + margin) : margin;
     const maxLeft = boundary
         ? Math.max(minLeft, Math.min(vw - margin - width, boundary.right - margin - width))
         : vw - margin - width;
-    let left = caret.left;
-    if (left > maxLeft)
-        left = maxLeft;
-    if (left < minLeft)
-        left = minLeft;
-    return { left, top, width, maxHeight, placement };
+    return Math.max(minLeft, Math.min(at.caretLeft, maxLeft));
 }
 /** Combines detection + caret-rect reading into the shape `RichTextInput`
  *  reports upward on every editor update. */

package/dist/features/lexical-rich-text-editor/serialize.js

@@ -9,32 +9,34 @@ import { $isMentionNode } from './mention-node.js';
 export function serializeRichText(state) {
     return state.read(() => {
         const mentions = [];
-        const blocks = [];
-        for (const block of $getRoot().getChildren()) {
-            if (!$isParagraphNode(block)) {
-                // Stray non-paragraph block (shouldn't happen): fall back to its text.
-                blocks.push(block.getTextContent());
-                continue;
-            }
-            let line = '';
-            for (const child of block.getChildren()) {
-                if ($isMentionNode(child)) {
-                    line += child.getToken();
-                    mentions.push(child.getEntity());
-                }
-                else if ($isLineBreakNode(child)) {
-                    line += '\n';
-                }
-                else if ($isTextNode(child)) {
-                    line += child.getTextContent();
-                }
-                else if ($isElementNode(child)) {
-                    line += child.getTextContent();
-                }
-            }
-            blocks.push(line);
-        }
+        const blocks = $getRoot()
+            .getChildren()
+            .map((block) => $isParagraphNode(block)
+            ? serializeParagraph({ paragraph: block, mentions })
+            : // Stray non-paragraph block (shouldn't happen): fall back to its text.
+                block.getTextContent());
         return { text: blocks.join('\n'), mentions };
     });
 }
+/**
+ * One paragraph's wire text; appends each atomic mention's entity to
+ * `mentions` in document order. A non-mention decorator child contributes
+ * nothing.
+ */
+function serializeParagraph(at) {
+    let line = '';
+    for (const child of at.paragraph.getChildren()) {
+        if ($isMentionNode(child)) {
+            line += child.getToken();
+            at.mentions.push(child.getEntity());
+        }
+        else if ($isLineBreakNode(child)) {
+            line += '\n';
+        }
+        else if ($isTextNode(child) || $isElementNode(child)) {
+            line += child.getTextContent();
+        }
+    }
+    return line;
+}
 //# sourceMappingURL=serialize.js.map

package/dist/features/mcp-ui/secret-card.js

@@ -27,51 +27,131 @@ function checkedFields(form) {
     return form.fields.map(field => ({ ...field }));
 }
 /** Classify before persistence; an abort wins over an already-buffered answer.
- * Trimming tests blankness only: rewriting a provider secret can corrupt intentional newlines.
- * @complexity O(n + b) before save in fields and submitted secret bytes; failure text delegates
- * to core's exact-secret redaction scan. Host persistence cost is external. */
-async function saveAnswer(required) {
-    const { answer, fields, prep, ctx, spec, options, exchangeId } = required;
-    if (ctx.signal.aborted)
-        return { status: 'abandoned' };
+ * @complexity O(1). */
+function answerStep(required) {
+    const { answer, signal } = required;
+    if (signal.aborted)
+        return { run: { status: 'abandoned' } };
     if (answer.status !== 'received')
-        return { status: answer.status };
+        return { run: { status: answer.status } };
     if (answer.params[SURFACE_DISMISSED_PARAM] === true)
-        return { status: 'cancelled' };
-    const values = Object.fromEntries(fields.map(field => [field.name, answer.params[field.name]]));
+        return { run: { status: 'cancelled' } };
+    return { params: answer.params };
+}
+/** The exact submitted secret, or undefined when it is blank or malformed.
+ * Trimming tests blankness only: rewriting a provider secret can corrupt intentional newlines.
+ * @complexity O(b) in the submitted secret bytes. */
+function secretValue(required) {
+    const { field, value } = required;
+    if (value !== undefined && typeof value !== 'string')
+        return undefined;
+    const secret = typeof value === 'string' ? value : '';
+    if (secret.trim() === '' && (secret !== '' || field.allowBlank !== true))
+        return undefined;
+    return secret;
+}
+/** Project only declared names; undefined means a required secret was blank or malformed.
+ * @complexity O(n + b) in fields and submitted secret bytes. */
+function collectValues(required) {
+    const { fields, params } = required;
+    const values = Object.fromEntries(fields.map(field => [field.name, params[field.name]]));
     const secrets = [];
     for (const field of fields) {
         if (field.secret !== true)
             continue;
-        const value = values[field.name];
-        if (value !== undefined && typeof value !== 'string')
-            return { status: 'blank' };
-        const secret = typeof value === 'string' ? value : '';
-        if (secret.trim() === '' && (secret !== '' || field.allowBlank !== true))
-            return { status: 'blank' };
+        const secret = secretValue({ field, value: values[field.name] });
+        if (secret === undefined)
+            return undefined;
         values[field.name] = secret;
         secrets.push(secret);
     }
+    return { values, secrets };
+}
+/** Map a save exception to fixed, redacted text and log fixed metadata only.
+ * @complexity O(m + b): delegates to core's exact-secret redaction scan. */
+function failedRun(required) {
+    const { error, secrets, signal, toolId, options, exchangeId } = required;
+    if (signal.aborted)
+        return { status: 'abandoned' };
+    let safeMessage = options.text?.saveFailure ?? 'Saving failed. Nothing was saved.';
+    try {
+        safeMessage = options.safeError?.(error) ?? safeMessage;
+    }
+    catch { /* An error mapper must not disclose a second exception containing the submitted value. */ }
+    // Even an accidentally permissive allowlist must not echo the submitted secret.
+    safeMessage = redactSecrets({ input: safeMessage }, { exactSecrets: secrets });
+    try {
+        options.logFailure?.({ toolId, exchangeId, saved: false });
+    }
+    catch { /* Logging must not replace the safe model result with an opaque logger exception. */ }
+    return { status: 'failed', safeMessage };
+}
+/** Classify, then persist; an abort wins over an already-buffered answer.
+ * @complexity O(n + b) before save in fields and submitted secret bytes; failure text delegates
+ * to core's exact-secret redaction scan. Host persistence cost is external. */
+async function saveAnswer(required) {
+    const { answer, fields, prep, ctx, spec, options, exchangeId } = required;
+    const step = answerStep({ answer, signal: ctx.signal });
+    if ('run' in step)
+        return step.run;
+    const collected = collectValues({ fields, params: step.params });
+    if (collected === undefined)
+        return { status: 'blank' };
     if (ctx.signal.aborted)
         return { status: 'abandoned' };
+    const { values, secrets } = collected;
     try {
         return { status: 'saved', saved: await spec.save({ values, prep, signal: ctx.signal }) };
     }
     catch (error) {
+        return failedRun({ error, secrets, signal: ctx.signal, toolId: spec.toolId, options, exchangeId });
+    }
+}
+/** Fail closed without an emitter. @complexity O(1). @throws ToolInputError with fixed text. */
+function requireEmitter(required, optional) {
+    if (optional.emitSurface)
+        return optional.emitSurface;
+    throw new ToolInputError({ message: required.options.text?.noEmitter ?? `${required.toolId}: this execution context has no interactive form channel (no emitSurface), so this form cannot be shown here. Nothing was changed.` });
+}
+/** The form resource: engine-owned routing params and dismissal around the host's copy.
+ * @complexity O(n + h) in fields and rendered HTML. */
+function buildCardForm(required) {
+    const { form, fields, uri, framing, toolId, exchangeId, options } = required;
+    return buildFormSurface({ ...form, fields, uri, ...framing, toolName: toolId,
+        baseParams: { [SURFACE_EXCHANGE_ID_PARAM]: exchangeId },
+        cancel: { label: form.cancelLabel ?? options.text?.cancelLabel ?? 'Cancel', toolName: toolId,
+            params: { [SURFACE_EXCHANGE_ID_PARAM]: exchangeId, [SURFACE_DISMISSED_PARAM]: true } },
+    });
+}
+/** Open the exchange, emit the card and hold the call until the real save is reported.
+ * @complexity O(n + h + b) locally, plus host I/O. */
+async function runCard(required) {
+    const { spec, options, deps, ctx, emit, prep, form, fields } = required;
+    const exchange = deps.surfaceExchanges.open({ binding: { toolId: spec.toolId, principalId: ctx.principal.id, channel: 'mcp-ui' }, emit });
+    const closeOnAbort = () => exchange.close({});
+    ctx.signal.addEventListener('abort', closeOnAbort, { once: true });
+    try {
+        // Close the open/register race as well as the prepare/abort race.
         if (ctx.signal.aborted)
-            return { status: 'abandoned' };
-        let safeMessage = options.text?.saveFailure ?? 'Saving failed. Nothing was saved.';
-        try {
-            safeMessage = options.safeError?.(error) ?? safeMessage;
-        }
-        catch { /* An error mapper must not disclose a second exception containing the submitted value. */ }
-        // Even an accidentally permissive allowlist must not echo the submitted secret.
-        safeMessage = redactSecrets({ input: safeMessage }, { exactSecrets: secrets });
-        try {
-            options.logFailure?.({ toolId: spec.toolId, exchangeId, saved: false });
-        }
-        catch { /* Logging must not replace the safe model result with an opaque logger exception. */ }
-        return { status: 'failed', safeMessage };
+            return spec.result({ prep, run: { status: 'abandoned' } });
+        const uri = `ui://${options.uriHost ?? 'jini'}/secret-card/${encodeURIComponent(spec.toolId)}/${encodeURIComponent(exchange.id)}`;
+        const framing = options.frameSize === undefined ? {} : { preferredFrameSize: options.frameSize };
+        const resource = buildCardForm({ form, fields, uri, framing, toolId: spec.toolId, exchangeId: exchange.id, options });
+        return await deps.askThenReport({ exchange, confirmationEmission: { channel: 'mcp-ui', payload: { resource } },
+            handle: async (answer) => {
+                const run = await saveAnswer({ answer, fields, prep, ctx, spec, options, exchangeId: exchange.id });
+                const result = spec.result({ prep, run });
+                const outcome = spec.outcome({ prep, run });
+                if (outcome === undefined)
+                    return { result };
+                return { result, outcome: { channel: 'mcp-ui', payload: { resource: buildOutcomeSurface({ ...outcome, uri, ...framing }) } } };
+            },
+        });
+    }
+    finally {
+        ctx.signal.removeEventListener('abort', closeOnAbort);
+        // Also covers rendering/projection failures before or inside askThenReport; close is idempotent.
+        exchange.close({});
     }
 }
 /**
@@ -92,8 +172,7 @@ export function defineSecretCardTool(required, options = {}) {
         toolId: spec.toolId,
         secretFieldNames: prep => checkedFields(spec.form({ prep })).filter(field => field.secret === true).map(field => field.name),
         handler: deps => async (ctx, optional = {}) => {
-            if (!optional.emitSurface)
-                throw new ToolInputError({ message: options.text?.noEmitter ?? `${spec.toolId}: this execution context has no interactive form channel (no emitSurface), so this form cannot be shown here. Nothing was changed.` });
+            const emit = requireEmitter({ toolId: spec.toolId, options }, optional);
             const prep = await spec.prepare({ ctx });
             if (ctx.signal.aborted)
                 return spec.result({ prep, run: { status: 'abandoned' } });
@@ -101,36 +180,7 @@ export function defineSecretCardTool(required, options = {}) {
             const fields = checkedFields(form);
             if (ctx.signal.aborted)
                 return spec.result({ prep, run: { status: 'abandoned' } });
-            const exchange = deps.surfaceExchanges.open({ binding: { toolId: spec.toolId, principalId: ctx.principal.id, channel: 'mcp-ui' }, emit: optional.emitSurface });
-            const closeOnAbort = () => exchange.close({});
-            ctx.signal.addEventListener('abort', closeOnAbort, { once: true });
-            try {
-                // Close the open/register race as well as the prepare/abort race.
-                if (ctx.signal.aborted)
-                    return spec.result({ prep, run: { status: 'abandoned' } });
-                const uri = `ui://${options.uriHost ?? 'jini'}/secret-card/${encodeURIComponent(spec.toolId)}/${encodeURIComponent(exchange.id)}`;
-                const framing = options.frameSize === undefined ? {} : { preferredFrameSize: options.frameSize };
-                const resource = buildFormSurface({ ...form, fields, uri, ...framing, toolName: spec.toolId,
-                    baseParams: { [SURFACE_EXCHANGE_ID_PARAM]: exchange.id },
-                    cancel: { label: form.cancelLabel ?? options.text?.cancelLabel ?? 'Cancel', toolName: spec.toolId,
-                        params: { [SURFACE_EXCHANGE_ID_PARAM]: exchange.id, [SURFACE_DISMISSED_PARAM]: true } },
-                });
-                return await deps.askThenReport({ exchange, confirmationEmission: { channel: 'mcp-ui', payload: { resource } },
-                    handle: async (answer) => {
-                        const run = await saveAnswer({ answer, fields, prep, ctx, spec, options, exchangeId: exchange.id });
-                        const result = spec.result({ prep, run });
-                        const outcome = spec.outcome({ prep, run });
-                        if (outcome === undefined)
-                            return { result };
-                        return { result, outcome: { channel: 'mcp-ui', payload: { resource: buildOutcomeSurface({ ...outcome, uri, ...framing }) } } };
-                    },
-                });
-            }
-            finally {
-                ctx.signal.removeEventListener('abort', closeOnAbort);
-                // Also covers rendering/projection failures before or inside askThenReport; close is idempotent.
-                exchange.close({});
-            }
+            return runCard({ spec, options, deps, ctx, emit, prep, form, fields });
         },
     };
 }