@forgeax/interface 0.4.1

package/dist/package/browser/components/Surfaces/SurfaceKeepAliveLayer.js

@@ -0,0 +1,218 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// SurfaceKeepAliveLayer — always-mounted owner of the Viewport surface.
+//
+// THE FIX for the Viewport↔AI freeze. Viewport / AI are separate dockview
+// *workspaces*; switching tabs rebuilds the dock tree, which previously destroyed +
+// cold-rebooted the heavy viewport on EVERY switch (full WebGPU init + the
+// editor's top-level-await boot → intermittent WKWebView wedge = the freeze).
+//
+// 2026-06-30: 'preview'/'edit' merged into single 'viewport'. Only the edit
+// surface is kept alive across workspace switches. The play-runtime (/preview)
+// is now a standalone fullscreen-only entry point (AC-14).
+//
+// React mounts this layer through a portal on `document.body` (see return) so
+// keep-alive surfaces escape the studio shell's fixed containing block. It still
+// conceptually tracks DockShell anchors from App.tsx and never unmounts. On a switch
+// we only:
+//   - position the ACTIVE surface over its dockview anchor's rect, visible;
+//   - park the others off-screen + visibility:hidden, which trips the in-process
+//     viewport's OWN IntersectionObserver (installVisibilityPause in edit-runtime)
+//     → editorApp.pause() in the background (context preserved).
+// Switching back is a one-frame composite: zero reload, zero boot, FPS resumes.
+//
+// Single realm: the edit surface is an in-process React component (ViewportComponent),
+// not an iframe. Stays editor-agnostic: the real surface comes from PanelRenderers
+// context (studio injects @forgeax/editor's SceneEditor); interface keeps ZERO
+// editor imports.
+import { useEffect, useReducer, useRef } from 'react';
+import { createPortal } from 'react-dom';
+import { createCoalescedFrameTaskLifecycle, createRestartableTimeoutTaskLifecycle, installElementResizeObservation, installViewportResizeObservation, installViewportScrollObservation, SurfacePlaceholder, SurfaceRegion, } from '@forgeax/app-shell/react';
+import { useHost } from '../../core/app-shell';
+import { usePanelRenderers } from '../DockShell/panelRenderers';
+import { FatalBanner } from '../StatusBar/FatalBanner';
+import { useFloatingSurfaces } from '../../lib/platform';
+import { mapViewportRectToOverlayRoot } from '../../lib/surfaceKeepAliveLayout';
+import { getAnchor, subscribeAnchors, subscribeRelayout, } from '../../lib/surfaceAnchors';
+import './SurfaceKeepAlive.css';
+// AppMode = shell workspace mode. The engine's edit-time surface kind is still
+// 'edit' (see SurfaceKind in ../../lib/surfaceAnchors); the page-id / mode-id
+// 'edit' was renamed to 'scene' by the v9 page-schema migration.
+const ALL_KINDS = ['edit'];
+// The keep-alive surface lives in a fixed overlay OUTSIDE dockview's DOM tree, so
+// clicking it never reaches dockview's group-focus machinery (doSetGroupActive via
+// tab pointerdown / content onDidFocus). Result: the previously-focused panel group
+// keeps its `dv-active-group` focus accent (the lime bar) even after you click into
+// the viewport. Map each surface kind back to its in-dock panel id so a pointerdown
+// on the surface can re-emit `panel:focus` and hand dock focus to the viewport.
+const PANEL_ID_FOR_KIND = {
+    edit: 'viewport',
+};
+export function SurfaceKeepAliveLayer() {
+    // Derived from the active workspace (SSOT); 'scene' workspace → edit surface,
+    // every other workspace → no kept-alive surface.
+    const host = useHost();
+    const { surfaces } = usePanelRenderers();
+    const SceneEditor = surfaces?.SceneEditor;
+    const floatingSurfaces = useFloatingSurfaces();
+    const viewportFloating = Boolean(floatingSurfaces['panel:viewport']);
+    const activeKind = viewportFloating ? null : 'edit';
+    // Visited set only grows — a surface, once mounted, is never torn down. Seeded
+    // with the boot mode's kind so the first surface mounts immediately; later kinds
+    // are added (and re-rendered) the first time their workspace becomes active.
+    const visitedRef = useRef(new Set(activeKind ? [activeKind] : []));
+    const [, bump] = useReducer((n) => n + 1, 0);
+    useEffect(() => {
+        if (activeKind && !visitedRef.current.has(activeKind)) {
+            visitedRef.current.add(activeKind);
+            bump();
+        }
+    }, [activeKind]);
+    // Portal overlay root + per-kind item DOM nodes — styled imperatively so dock
+    // resize/drag ticks don't churn React.
+    const rootRef = useRef(null);
+    const itemRefs = useRef(new Map());
+    // Imperative layout sync: overlay the active surface on its anchor's rect; hide
+    // the rest. Cheap enough to call on every resize/relayout tick.
+    const syncLayout = () => {
+        const overlayRoot = rootRef.current;
+        for (const kind of ALL_KINDS) {
+            const el = itemRefs.current.get(kind);
+            if (!el)
+                continue;
+            const anchor = kind === activeKind ? getAnchor(kind) : null;
+            if (!anchor) {
+                // Inactive, or active-but-no-anchor (page mode / panel closed / popped
+                // to an OS window). DO NOT use display:none — on WKWebView (the desktop
+                // Studio app) display:none on a WebGPU <canvas> DROPS the GPU device, so
+                // flipping back finds a dead context and the re-create wedges WKWebView's
+                // GPU process (the "switching back and forth freezes" Play↔Edit bug).
+                // Instead park the
+                // surface OFF-SCREEN + visibility:hidden: the GPU context stays alive, the
+                // surface is invisible + click-through, and being outside the viewport still
+                // trips the surface's IntersectionObserver so its render loop pauses (no
+                // double-render). Switch-back just moves it back onto the anchor — no
+                // context re-create, so no wedge. Keep a real (non-zero) size so the
+                // swap-chain stays valid while parked.
+                el.style.display = 'flex';
+                el.style.visibility = 'hidden';
+                el.style.pointerEvents = 'none';
+                el.style.top = '0px';
+                el.style.left = '-100000px';
+                if (!el.style.width || el.style.width === '0px')
+                    el.style.width = '1280px';
+                if (!el.style.height || el.style.height === '0px')
+                    el.style.height = '720px';
+                continue;
+            }
+            const mapped = mapViewportRectToOverlayRoot(anchor.getBoundingClientRect(), overlayRoot);
+            el.style.display = 'flex';
+            el.style.visibility = 'visible';
+            el.style.pointerEvents = '';
+            el.style.top = `${mapped.top}px`;
+            el.style.left = `${mapped.left}px`;
+            el.style.width = `${mapped.width}px`;
+            el.style.height = `${mapped.height}px`;
+        }
+    };
+    // Re-sync on: active-kind change (mode), anchor add/remove, dock relayout ping,
+    // window resize/scroll, and ResizeObserver of whichever anchors currently exist.
+    useEffect(() => {
+        syncLayout();
+        const layoutFrameTask = createCoalescedFrameTaskLifecycle({
+            task: syncLayout,
+        });
+        const scheduleSync = layoutFrameTask.schedule;
+        // macOS Chrome throttles rAF during live window drag, so a single rAF after
+        // `resize` often runs before dockview finishes its final reflow — the overlay
+        // gets sized to a stale (smaller) anchor rect and the dock's near-black
+        // --dv-background-color bleeds through on the right/bottom. Schedule a short
+        // settle burst after each resize so the final reflow is caught.
+        const SETTLE_TICKS = 4;
+        const SETTLE_STEP_MS = 60;
+        const settleTimers = Array.from({ length: SETTLE_TICKS }, (_, index) => createRestartableTimeoutTaskLifecycle({
+            task: scheduleSync,
+            delayMs: (index + 1) * SETTLE_STEP_MS,
+        }));
+        const cancelSettle = () => {
+            for (const timer of settleTimers)
+                timer.cancel();
+        };
+        const onWin = () => {
+            scheduleSync();
+            cancelSettle();
+            for (const timer of settleTimers)
+                timer.schedule();
+        };
+        const disposeWindowResizeObservation = installViewportResizeObservation({
+            target: window,
+            onResize: onWin,
+        });
+        const disposeViewportScrollObservation = installViewportScrollObservation({
+            target: window,
+            onScroll: onWin,
+        });
+        const visualViewport = window.visualViewport;
+        const disposeVisualViewportResizeObservation = visualViewport
+            ? installViewportResizeObservation({
+                target: visualViewport,
+                onResize: onWin,
+            })
+            : () => { };
+        const disposeAnchorResizeObservation = installElementResizeObservation({
+            getElements: () => ALL_KINDS.map(getAnchor).filter((anchor) => anchor !== null),
+            subscribeElements: subscribeAnchors,
+            onResize: scheduleSync,
+            onElementsChanged: syncLayout,
+        });
+        const offRelayout = subscribeRelayout(scheduleSync);
+        // A short rAF burst right after a switch catches the dockview rebuild settling
+        // (anchor mounts a frame or two after the workspace flips) without a permanent
+        // loop. Each tick is a single getBoundingClientRect — negligible.
+        let frames = 0;
+        const burstFrameTask = createCoalescedFrameTaskLifecycle({
+            task: () => {
+                syncLayout();
+                if (++frames < 30)
+                    burstFrameTask.schedule();
+            },
+        });
+        burstFrameTask.schedule();
+        return () => {
+            disposeWindowResizeObservation();
+            disposeViewportScrollObservation();
+            disposeVisualViewportResizeObservation();
+            for (const timer of settleTimers)
+                timer.dispose();
+            disposeAnchorResizeObservation();
+            offRelayout();
+            layoutFrameTask.dispose();
+            burstFrameTask.dispose();
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [activeKind]);
+    const renderSurface = (kind) => {
+        // Single-kind surface today ('edit'); the preview/edit merge (2026-06-30)
+        // collapsed both into one viewport. Kept the kind-switch so future modes
+        // (play, debug) can add sibling branches without restructuring.
+        if (kind !== 'edit')
+            return _jsx(NoEditor, { kind: kind });
+        return SceneEditor ? (_jsx("div", { "data-fx-slot": "SceneEditor", style: { display: 'contents' }, children: _jsx(SceneEditor, {}) })) : (_jsx(NoEditor, { kind: "edit" }));
+    };
+    const layer = (_jsx("div", { ref: rootRef, className: "fx-surface-keepalive-root", "aria-hidden": activeKind ? undefined : true, children: [...visitedRef.current].map((kind) => (
+        // Stable key + stable parent → the in-process surface is reconciled in
+        // place across every render: never remounted, never reloaded.
+        _jsx(SurfaceRegion, { ref: (el) => { itemRefs.current.set(kind, el); }, className: "fx-surface-keepalive-item", "data-surface-kind": kind, style: { display: 'none' }, overlay: _jsx(FatalBanner, { source: "edit" }), 
+            // Capture-phase so it fires before the surface's own handlers, and never
+            // preventDefault/stopPropagation — we only mirror the click as dock focus.
+            // Moves `dv-active-group` (the lime focus accent) onto the viewport group,
+            // clearing the stale highlight left on whatever tab was focused before.
+            onPointerDownCapture: () => {
+                const panelId = PANEL_ID_FOR_KIND[kind];
+                if (panelId)
+                    host.bus.emit('panel:focus', { id: panelId });
+            }, children: kind === 'edit' && viewportFloating ? null : renderSurface(kind) }, kind))) }));
+    return createPortal(layer, document.body);
+}
+function NoEditor({ kind }) {
+    return _jsx(SurfacePlaceholder, { title: "No editor configured", className: `surface-placeholder--${kind}` });
+}

package/dist/package/browser/components/Surfaces/SurfaceOverlay.css

@@ -0,0 +1,160 @@
+.fx-surf-overlay {
+  position: fixed;
+  right: 12px;
+  /* Sit above the 24px global status bar (the chip that toggles us lives there). */
+  bottom: 32px;
+  width: 320px;
+  max-height: 50vh;
+  display: flex;
+  flex-direction: column;
+  background: rgba(20, 20, 24, 0.96);
+  border: 1px solid #2a2a2c;
+  border-radius: 6px;
+  font-size: 11px;
+  color: #ccc;
+  z-index: var(--z-surface);
+  box-shadow: 0 4px 24px rgba(0, 0, 0, 0.5);
+  font-family: ui-monospace, SFMono-Regular, monospace;
+}
+.fx-surf-overlay-head {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 6px 10px;
+  border-bottom: 1px solid #2a2a2c;
+  background: #18181c;
+  border-top-left-radius: 6px;
+  border-top-right-radius: 6px;
+}
+.fx-surf-overlay-title {
+  color: #4a8cff;
+  font-weight: 600;
+}
+.fx-surf-overlay-hide {
+  background: transparent;
+  border: none;
+  color: #888;
+  cursor: pointer;
+  padding: 2px 4px;
+  display: flex;
+  align-items: center;
+}
+.fx-surf-overlay-hide:hover { color: #ccc; }
+/* Status-bar chip — entry point that toggles the panel. Inherits .sb-chip
+   typography from the global status bar; we only add the open-state accent. */
+.fx-surf-chip {
+  background: transparent;
+  border: none;
+  color: var(--color-text-secondary, #888);
+  cursor: pointer;
+  padding: 0 4px;
+  font: inherit;
+}
+.fx-surf-chip:hover { color: #4a8cff; }
+.fx-surf-chip-open { color: #4a8cff; }
+.fx-surf-overlay-body {
+  overflow: auto;
+  padding: 8px;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+.fx-surf-overlay-empty {
+  color: #666;
+  text-align: center;
+  padding: 12px 0;
+}
+.fx-surf-card {
+  border: 1px solid #2a2a2c;
+  border-radius: 4px;
+  padding: 6px 8px;
+  background: #1c1c20;
+}
+.fx-surf-card-head {
+  display: flex;
+  gap: 8px;
+  margin-bottom: 4px;
+  align-items: center;
+}
+.fx-surf-plugin {
+  color: #999;
+  font-size: 10px;
+}
+.fx-surf-id {
+  color: #4a8cff;
+}
+.fx-surf-actions {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+}
+.fx-surf-action {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 6px;
+  padding: 2px 4px;
+  border-radius: 3px;
+}
+.fx-surf-action:hover {
+  background: rgba(74, 140, 255, 0.08);
+}
+.fx-surf-action-disabled {
+  opacity: 0.5;
+}
+.fx-surf-action-id {
+  color: #d0a060;
+  font-size: 10.5px;
+}
+.fx-surf-action-label {
+  color: #ddd;
+}
+.fx-surf-hotkey {
+  background: #2a2a2c;
+  border: 1px solid #3a3a3c;
+  border-radius: 3px;
+  padding: 0 4px;
+  font-size: 10px;
+  color: #aaa;
+}
+.fx-surf-args {
+  flex-basis: 100%;
+  margin: 2px 0 0;
+  background: #0e0e10;
+  color: #888;
+  padding: 4px 6px;
+  border-radius: 3px;
+  font-size: 10px;
+  white-space: pre-wrap;
+  word-break: break-all;
+}
+.fx-surf-empty {
+  color: #666;
+  font-style: italic;
+}
+
+/* D2 — inline run button + form. Sits next to the action id in each row. */
+.fx-surf-action-run {
+  margin-left: auto;
+  display: inline-flex; align-items: center; gap: 3px;
+  padding: 2px 6px;
+  background: #1a4a78; color: #fff; border: 1px solid #2563eb;
+  border-radius: 3px; font-size: 10px; cursor: pointer;
+}
+.fx-surf-action-run:hover { background: #2563eb; }
+.fx-surf-action-form {
+  flex-basis: 100%;
+  margin-top: 4px;
+  padding: 6px;
+  background: #0e0e0e;
+  border: 1px solid #2a2a2a;
+  border-radius: 3px;
+}
+.fx-surf-action-result {
+  margin-top: 4px;
+  font-size: 10px;
+  color: #a8d4ff;
+}

package/dist/package/browser/components/Surfaces/SurfaceOverlay.d.ts

@@ -0,0 +1,9 @@
+import type { ReactElement } from 'react';
+import type { StatusItemContribution } from '../../core/panels';
+import './SurfaceOverlay.css';
+export declare function SurfaceOverlay(): ReactElement | null;
+/** ADR-0030 §2.2 — dev-only surface overlay entry as a `custom` status-item.
+ *  The chip toggles a fixed-position overlay; `when` gates it to DEV builds so
+ *  production omits the subtree. Low priority → joins the right-slot carousel
+ *  pool rather than anchoring. */
+export declare const surfaceOverlayStatusItem: StatusItemContribution;

package/dist/package/browser/components/Surfaces/SurfaceOverlay.js

@@ -0,0 +1,144 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * Phase D2 — dev-mode surface overlay.
+ *
+ * A panel listing every `surface.expose` snapshot received from plugin
+ * iframes (07-INTERFACE-EXPOSURE.md §1.2). Lets the user / author / AI
+ * see "this UI element is equivalent to tool X with args Y" without
+ * cracking open devtools.
+ *
+ * UX: entry point is a `surfaces · N` chip in the global status bar
+ * (right slot). Clicking the chip toggles the panel; default closed so
+ * the workspace isn't covered. Production builds omit the entire
+ * subtree via the DEV gate on the wrapper.
+ */
+import { useEffect, useMemo, useState } from 'react';
+import { EyeOff, Play } from 'lucide-react';
+import { installEventSourceObservation } from '@forgeax/app-shell/react';
+import { listSurfaces, subscribeSurfaces } from '../../lib/surface-store';
+import { SchemaForm } from '../SchemaForm/SchemaForm';
+import { useTranslation } from '../../i18n';
+import './SurfaceOverlay.css';
+async function fetchTools() {
+    try {
+        const r = await fetch('/api/tools');
+        if (!r.ok)
+            return [];
+        const j = (await r.json());
+        return j.tools ?? [];
+    }
+    catch {
+        return [];
+    }
+}
+export function SurfaceOverlay() {
+    if (!import.meta.env.DEV)
+        return null;
+    return _jsx(SurfaceOverlayDev, {});
+}
+/** ADR-0030 §2.2 — dev-only surface overlay entry as a `custom` status-item.
+ *  The chip toggles a fixed-position overlay; `when` gates it to DEV builds so
+ *  production omits the subtree. Low priority → joins the right-slot carousel
+ *  pool rather than anchoring. */
+export const surfaceOverlayStatusItem = {
+    kind: 'status-item',
+    id: 'surface-overlay',
+    location: 'statusbar.right',
+    priority: 10,
+    when: () => import.meta.env.DEV,
+    item: { type: 'custom', render: () => _jsx(SurfaceOverlay, {}) },
+};
+function SurfaceOverlayDev() {
+    const { t } = useTranslation();
+    const [surfaces, setSurfaces] = useState(() => listSurfaces());
+    const [open, setOpen] = useState(false);
+    const [tools, setTools] = useState([]);
+    useEffect(() => {
+        const off = subscribeSurfaces(() => setSurfaces(listSurfaces()));
+        return off;
+    }, []);
+    // Doc 07 §4 — load tool catalog so the dev overlay can render a SchemaForm
+    // for each surface action whose `id` matches a registered tool. Re-fetched
+    // on plugin reload via SSE; cheap, ~1KB payload.
+    useEffect(() => {
+        if (!open)
+            return undefined;
+        let cancelled = false;
+        const reload = () => fetchTools().then((next) => { if (!cancelled)
+            setTools(next); });
+        void reload();
+        const disposeObservation = installEventSourceObservation({
+            url: '/api/events/stream?topic=plugin.reloaded',
+            onEvent: () => { void reload(); },
+        });
+        return () => {
+            cancelled = true;
+            disposeObservation();
+        };
+    }, [open]);
+    const toolsById = useMemo(() => {
+        const m = new Map();
+        for (const tool of tools)
+            m.set(tool.id, tool);
+        return m;
+    }, [tools]);
+    // Chip lives inline in the strip slot; the overlay it toggles is a sibling
+    // fixed-position layer. Low priority so it joins the right-slot carousel
+    // pool rather than anchoring — a dev-only debugging surface shouldn't crowd
+    // out the always-visible state chips.
+    const chip = (_jsxs("button", { type: "button", className: `sb-chip fx-surf-chip${open ? ' fx-surf-chip-open' : ''}`, onClick: () => setOpen((v) => !v), title: open ? t('surfaces.chip.close') : t('surfaces.chip.open'), children: ["surfaces \u00B7 ", surfaces.length] }));
+    if (!open)
+        return chip;
+    return (_jsxs(_Fragment, { children: [chip, _jsxs("div", { className: "fx-surf-overlay", role: "complementary", "aria-label": "surface overlay", children: [_jsxs("div", { className: "fx-surf-overlay-head", children: [_jsxs("span", { className: "fx-surf-overlay-title", children: ["surfaces \u00B7 ", surfaces.length] }), _jsx("button", { type: "button", className: "fx-surf-overlay-hide", onClick: () => setOpen(false), title: t('common.close'), children: _jsx(EyeOff, { size: 12 }) })] }), _jsx("div", { className: "fx-surf-overlay-body", children: surfaces.length === 0 ? (_jsx("div", { className: "fx-surf-overlay-empty", children: t('surfaces.overlay.empty') })) : (surfaces.map((s) => (_jsx(SurfaceCard, { surface: s, toolsById: toolsById }, `${s.extensionId}:${s.surfaceId}`)))) })] })] }));
+}
+function SurfaceCard({ surface, toolsById, }) {
+    return (_jsxs("div", { className: "fx-surf-card", children: [_jsxs("div", { className: "fx-surf-card-head", children: [_jsx("span", { className: "fx-surf-plugin", children: surface.extensionId }), _jsx("span", { className: "fx-surf-id", children: surface.surfaceId })] }), _jsxs("ul", { className: "fx-surf-actions", children: [surface.actions.map((a) => (_jsx(SurfaceActionRow, { action: a, tool: toolsById.get(a.id), extensionId: surface.extensionId }, a.id))), surface.actions.length === 0 ? _jsx("li", { className: "fx-surf-empty", children: "(no actions)" }) : null] })] }));
+}
+/** D2 — single surface-action row. Has a "▶" toggle that opens an inline
+ *  SchemaForm seeded with the action's args snapshot + the tool's argsSchema
+ *  (when registered). Submitting POSTs `/api/tools/call` as caller=user
+ *  (page surface — the dev clicked the form). The legacy <pre>args view
+ *  is preserved for actions with no schema or no matching tool registration. */
+function SurfaceActionRow({ action, tool, extensionId, }) {
+    const { t } = useTranslation();
+    const [open, setOpen] = useState(false);
+    const [busy, setBusy] = useState(false);
+    const [result, setResult] = useState(null);
+    const argsSchema = (tool?.argsSchema ?? null);
+    const canRun = !!argsSchema && action.enabled !== false;
+    const submit = async (value) => {
+        setBusy(true);
+        setResult(null);
+        try {
+            const r = await fetch('/api/tools/call', {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({
+                    toolId: action.id,
+                    args: value,
+                    caller: { kind: 'user', agentId: extensionId },
+                }),
+            });
+            const j = (await r.json());
+            setResult(j.ok ? 'ok' : (j.error ?? 'failed'));
+            if (j.ok)
+                setOpen(false);
+        }
+        catch (e) {
+            setResult(e.message);
+        }
+        finally {
+            setBusy(false);
+        }
+    };
+    return (_jsxs("li", { className: `fx-surf-action${action.enabled ? '' : ' fx-surf-action-disabled'}`, children: [_jsx("code", { className: "fx-surf-action-id", children: action.id }), action.label ? _jsx("span", { className: "fx-surf-action-label", children: action.label }) : null, action.hotkey ? _jsx("kbd", { className: "fx-surf-hotkey", children: action.hotkey }) : null, canRun ? (_jsxs("button", { type: "button", className: "fx-surf-action-run", onClick: () => setOpen((v) => !v), title: open ? t('surfaces.action.formClose') : t('surfaces.action.formOpen'), children: [_jsx(Play, { size: 10 }), " ", open ? t('surfaces.action.collapse') : t('surfaces.action.run')] })) : null, !open && action.args ? _jsx("pre", { className: "fx-surf-args", children: summarizeArgs(action.args) }) : null, open && argsSchema ? (_jsxs("div", { className: "fx-surf-action-form", children: [_jsx(SchemaForm, { schema: argsSchema, initialValue: action.args, onSubmit: (v) => void submit(v), onCancel: () => setOpen(false), submitLabel: tool?.requireConfirm ? t('surfaces.action.runConfirm') : t('surfaces.action.run'), layout: "inline", busy: busy }), result ? _jsx("div", { className: "fx-surf-action-result", children: result }) : null] })) : null] }));
+}
+function summarizeArgs(args) {
+    try {
+        const s = JSON.stringify(args);
+        return s.length > 120 ? s.slice(0, 117) + '…' : s;
+    }
+    catch {
+        return String(args);
+    }
+}

package/dist/package/browser/components/TopBar/AndroidPackageDialog.d.ts

@@ -0,0 +1,23 @@
+import './TopBar.css';
+export type AndroidOrientation = 'portrait' | 'landscape';
+export interface AndroidPackageConfig {
+    androidAppId: string;
+    androidAppName: string;
+    androidProjectName: string;
+    androidIcon?: {
+        dataBase64: string;
+        filename: string;
+    };
+    androidOrientation: AndroidOrientation;
+}
+/** Derive a sane default applicationId from a slug (matches the backend). */
+export declare function defaultAndroidAppId(slug: string): string;
+type T = (k: string, opts?: Record<string, string | number>) => string;
+export declare function AndroidPackageDialog({ slug, defaultAppName, onCancel, onConfirm, t }: {
+    slug: string;
+    defaultAppName: string;
+    onCancel: () => void;
+    onConfirm: (cfg: AndroidPackageConfig) => void;
+    t: T;
+}): import("react/jsx-runtime").JSX.Element;
+export {};