@forgeax/interface 0.4.1

package/dist/package/browser/components/DockShell/DockTab.d.ts

@@ -0,0 +1,3 @@
+import { type ReactElement } from 'react';
+import type { IDockviewDefaultTabProps } from 'dockview';
+export declare function DockTab({ api, containerApi: _containerApi, params: _params, hideClose, closeActionOverride, onPointerDown, onPointerUp, onPointerLeave, tabLocation: _tabLocation, ...rest }: IDockviewDefaultTabProps): ReactElement;

package/dist/package/browser/components/DockShell/DockTab.js

@@ -0,0 +1,139 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// Custom dockview tab — the default tab with a leading Lucide panel icon.
+//
+// Wired as `<DockviewReact defaultTabComponent={DockTab} />`, so every dock tab
+// (static, ep:*, page-mode) gets an icon without touching per-panel registration.
+//
+// This is a faithful re-implementation of dockview's `DockviewDefaultTab`
+// (node_modules/dockview .../dockview/defaultTab.js): it forwards the pointer
+// handlers dockview injects for drag/activate and preserves the exact
+// `.dv-default-tab` / `.dv-default-tab-content` / `.dv-default-tab-action` DOM
+// hooks the stylesheets and `edgeDrawer.ts`'s click routing key off. The
+// additions are a leading `.fx-dock-tab-icon` (inside `.dv-default-tab`, so the
+// whole tab stays draggable/clickable), a Lucide `X` close glyph (design-system
+// on-brand, avoids a deep `dockview/.../svg` import), and a Lucide `Pin` that
+// takes the X's place on edge-strip tabs (see `useEdgePin` below).
+//
+// CLOSE BUTTON: React synthetic events and native mousedown/click are
+// unreliable here because calling preventDefault() on pointerdown (needed to
+// prevent tab activation) suppresses subsequent mousedown/click per the W3C
+// Pointer Events spec. The public App Shell interaction hook owns that native
+// pointerdown and the matching middle-button session; this file only injects
+// Dockview close policy and forwards Dockview's tab handlers.
+import { useCallback, useMemo, } from 'react';
+import { DockTabAction, DockTabFrame, DockTabIcon, DockTabStatusSummary, DockTabTitle, useLiveTabPlacement, useLiveTabTitle, useTabPinnedState, useTabCloseInteractions, } from '@forgeax/app-shell/react';
+import { Pin, X } from 'lucide-react';
+import { barePanelId, iconForDockPanel } from '../../lib/panel-tab-icons';
+import { EDGE_PIN_CLASS, edgePinStateSource } from './edgePinStore';
+import { useTranslation } from '../../i18n';
+import { useHealthStore } from '../StatusBar/healthStore';
+const EMPTY_HEALTH_ENTRIES = Object.freeze([]);
+/** Track the live tab title (dockview mutates it via `api.setTitle`). */
+function useTitle(api) {
+    const source = useMemo(() => ({
+        getTitle: () => api.title,
+        subscribe: (listener) => {
+            const disposable = api.onDidTitleChange(listener);
+            return () => disposable.dispose();
+        },
+    }), [api]);
+    return useLiveTabTitle(source);
+}
+/**
+ * The displayed tab name is DERIVED at render — never read from the persisted
+ * layout. Same shape as the icon (`iconForDockPanel(api.id)`): the panel id is
+ * the key, i18n is the lookup. `dockShell.panelTitles.<bareId>` wins and is
+ * locale-reactive (useTranslation re-renders on language change), so a stored
+ * `api.title` baked into the dockview layout JSON is ignored for keyed panels.
+ * Panels without a catalog key (host-injected editor/extension panels) fall
+ * back to the live `api.title` the host set at mount — their own name, as-is.
+ */
+function useDockTabName(api) {
+    const stored = useTitle(api);
+    const { t } = useTranslation();
+    const key = `dockShell.panelTitles.${barePanelId(api.id)}`;
+    const localized = t(key);
+    return localized !== key ? localized : stored;
+}
+function useInfoIssueCounts(panelId) {
+    const entries = useHealthStore((s) => (barePanelId(panelId) === 'info' ? s.entries : EMPTY_HEALTH_ENTRIES));
+    return useMemo(() => {
+        if (barePanelId(panelId) !== 'info')
+            return null;
+        let error = 0;
+        let warn = 0;
+        for (const entry of entries) {
+            if (entry.level === 'error')
+                error++;
+            else if (entry.level === 'warn')
+                warn++;
+        }
+        return { error, warn };
+    }, [entries, panelId]);
+}
+/**
+ * Edge-strip tabs show a per-tab Pin toggle where a grid tab shows close (X) —
+ * see edgeDrawer.ts for the rules. Both bits are DERIVED from live dockview
+ * state, so the first paint after a refresh is already correct:
+ * `onDidLocationChange` fires on any group change (dockviewPanelApi sets it from
+ * the `group` setter), which covers dragging a panel into or out of a strip.
+ */
+function useEdgePin(api) {
+    const source = useMemo(() => ({
+        getPlacement: () => ({
+            isEdge: api.location.type === 'edge',
+            groupId: api.group.id,
+        }),
+        subscribe: (listener) => {
+            const disposable = api.onDidLocationChange(listener);
+            return () => disposable.dispose();
+        },
+    }), [api]);
+    const home = useLiveTabPlacement(source) ?? {
+        isEdge: false,
+        groupId: api.group.id,
+    };
+    const pinned = useTabPinnedState(edgePinStateSource, home.groupId, api.id);
+    return { isEdge: home.isEdge, pinned };
+}
+export function DockTab({ api, containerApi: _containerApi, params: _params, hideClose, closeActionOverride, onPointerDown, onPointerUp, onPointerLeave, tabLocation: _tabLocation, ...rest }) {
+    const title = useDockTabName(api);
+    const infoIssueCounts = useInfoIssueCounts(api.id);
+    const Icon = iconForDockPanel(api.id);
+    const { isEdge, pinned } = useEdgePin(api);
+    const close = useCallback(() => {
+        if (closeActionOverride)
+            closeActionOverride();
+        else
+            api.close();
+    }, [api, closeActionOverride]);
+    const closeInteractions = useTabCloseInteractions({
+        close,
+        disabled: hideClose,
+        onPointerDown,
+        onPointerUp,
+        onPointerLeave,
+    });
+    const onBtnPointerDown = useCallback((event) => event.preventDefault(), []);
+    const infoStatusItems = infoIssueCounts === null
+        ? []
+        : [
+            ...(infoIssueCounts.error > 0
+                ? [{ id: 'errors', tone: 'error', icon: '✖', value: infoIssueCounts.error }]
+                : []),
+            ...(infoIssueCounts.warn > 0
+                ? [{ id: 'warnings', tone: 'warning', icon: '⚠', value: infoIssueCounts.warn }]
+                : []),
+        ];
+    const action = hideClose
+        ? undefined
+        : isEdge
+            ? (
+            // The toggle itself is driven by edgeDrawer's capture-phase click
+            // handler (it must preventDefault dockview's native expand before the
+            // event ever reaches React), so this renders state and carries the
+            // panel id that handler reads back — no onClick of its own.
+            _jsx(DockTabAction, { className: `${EDGE_PIN_CLASS}${pinned ? ` ${EDGE_PIN_CLASS}--on` : ''}`, "data-fx-edge-pin-panel": api.id, role: "button", "aria-pressed": pinned, "aria-label": pinned ? 'Unpin tab' : 'Pin tab', title: pinned ? 'Unpin' : 'Pin', onPointerDown: onBtnPointerDown, children: _jsx(Pin, { className: "fx-edge-pin-icon", size: 12, "aria-hidden": true }) }))
+            : (_jsx(DockTabAction, { ref: closeInteractions.closeRef, children: _jsx(X, { size: 14, "aria-hidden": true }) }));
+    return (_jsxs(DockTabFrame, { "data-testid": "dockview-dv-default-tab", ...rest, onPointerDown: closeInteractions.onPointerDown, onPointerUp: closeInteractions.onPointerUp, onPointerLeave: closeInteractions.onPointerLeave, leading: (_jsx(DockTabIcon, { children: _jsx(Icon, { size: 14, "aria-hidden": true }) })), action: action, children: [_jsx(DockTabTitle, { children: title }), infoIssueCounts !== null && infoStatusItems.length > 0 && (_jsx(DockTabStatusSummary, { "aria-label": `${infoIssueCounts.error} errors, ${infoIssueCounts.warn} warnings`, items: infoStatusItems }))] }));
+}

package/dist/package/browser/components/DockShell/ExtensionHostPanel.d.ts

@@ -0,0 +1,9 @@
+import type { SurfacePane } from '@forgeax/app-shell/window';
+interface Props {
+    extensionId: string;
+    pane?: SurfacePane;
+}
+/** Render one Page placement for a Extension extension. The Page owns panel
+ * availability and position; `pane` only selects the extension's content mode. */
+export declare function ExtensionHostPanel({ extensionId, pane }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/package/browser/components/DockShell/ExtensionHostPanel.js

@@ -0,0 +1,68 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { lazy, Suspense } from 'react';
+import { useTranslation } from '../../i18n';
+import { pickLang } from '../../lib/extension-api';
+import { useExtensionManifest } from '../../lib/use-extension-manifest';
+import { useShellStore } from '../../store';
+import { usePanelRenderers } from './panelRenderers';
+import { ExtensionRuntimeFrame } from './ExtensionRuntimeFrame';
+import { isExtensionHostExtension, useExtensionCatalogEntry } from './extensionRuntime';
+import { usesExternalIframeRuntime } from './extension-runtime-selection';
+import { NativeExtensionHost } from '../ExtensionHost/NativeExtensionHost';
+// Keep Extension Platform transport out of standalone DockShell's static import graph. Catalog
+// Pages load this runtime only when an iframe-backed placement is mounted.
+const StandaloneExtensionIframe = lazy(() => import('../MainArea/StandaloneExtensionIframe').then((module) => ({
+    default: module.StandaloneExtensionIframe,
+})));
+function LegacyStandalonePanel({ manifest, pane, }) {
+    const { t } = useTranslation();
+    return (_jsx("div", { className: "page-dock-panel page-dock-standalone", children: _jsx(Suspense, { fallback: _jsx("div", { className: "page-dock-loading", children: t('extensionDock.loadingExtensionGeneric') }), children: _jsx(StandaloneExtensionIframe, { plugin: manifest, pane: pane, active: true }) }) }));
+}
+function HostedExtensionRuntimePanel({ extensionId, pane, onEditorAssetImport, }) {
+    const { t } = useTranslation();
+    const activeGameSlug = useShellStore((state) => state.activeGameSlug);
+    const activeGameResolved = useShellStore((state) => state.activeGameResolved);
+    const runtime = useExtensionCatalogEntry(extensionId, activeGameSlug, activeGameResolved);
+    if (runtime.loading) {
+        return _jsx("div", { className: "page-dock-loading", children: t('extensionDock.loadingExtensionHost') });
+    }
+    if (runtime.error) {
+        return (_jsxs("div", { className: "page-dock-loading page-dock-error", role: "alert", children: [_jsx("div", { children: t('extensionDock.extensionHostFailed', { error: runtime.error.message }) }), _jsx("button", { type: "button", onClick: runtime.retry, children: t('extensionDock.retry') })] }));
+    }
+    if (runtime.descriptor && activeGameSlug) {
+        return (_jsx("div", { className: "page-dock-panel page-dock-standalone", children: _jsx(ExtensionRuntimeFrame, { descriptor: runtime.descriptor, gameId: activeGameSlug, pane: pane, onEditorAssetImport: onEditorAssetImport }) }));
+    }
+    return (_jsxs("div", { className: "page-dock-loading page-dock-error", role: "alert", children: [_jsx("div", { children: activeGameSlug
+                    ? t('extensionDock.extensionExtensionMissing', { extensionId })
+                    : t('extensionDock.extensionGameRequired') }), _jsx("button", { type: "button", onClick: runtime.retry, children: t('extensionDock.retry') })] }));
+}
+/** Render one Page placement for a Extension extension. The Page owns panel
+ * availability and position; `pane` only selects the extension's content mode. */
+export function ExtensionHostPanel({ extensionId, pane }) {
+    const { t, i18n } = useTranslation();
+    const manifest = useExtensionManifest(extensionId);
+    const { extensionPanels, editor } = usePanelRenderers();
+    const InlinePanel = extensionPanels?.[extensionId];
+    if (InlinePanel) {
+        return (_jsx("div", { className: "page-dock-panel page-dock-inline", children: _jsx(InlinePanel, {}) }));
+    }
+    if (!manifest || manifest === 'loading') {
+        return (_jsx("div", { className: "page-dock-panel", children: _jsx("div", { className: "page-dock-loading", children: t('extensionDock.loadingExtension', { extensionId }) }) }));
+    }
+    const label = pickLang(manifest.displayName, i18n.language, manifest.id);
+    if (manifest.runtimeMode === 'native-module'
+        && manifest.moduleUrl) {
+        return (_jsx("div", { className: "page-dock-panel page-dock-standalone", children: _jsx(NativeExtensionHost, { extensionId: manifest.id, moduleUrl: manifest.moduleUrl, allowedOrigin: manifest.allowedOrigin, generation: manifest.registryGeneration ?? 0, active: true }) }));
+    }
+    // Explicit legacy runtimes are iframe-backed even though their persisted Studio
+    // manifest intentionally contains no standalone process command/port. The
+    // Host-projected frontendUrl is the authority for this externally-owned mode.
+    if (usesExternalIframeRuntime(manifest)) {
+        if (!isExtensionHostExtension(manifest.id)) {
+            return _jsx(LegacyStandalonePanel, { manifest: manifest, pane: pane });
+        }
+        return (_jsx(HostedExtensionRuntimePanel, { extensionId: extensionId, pane: pane, onEditorAssetImport: editor?.importAssetSource }));
+    }
+    const description = pickLang(manifest.description ?? '', i18n.language, '');
+    return (_jsxs("div", { className: "page-dock-panel page-dock-placeholder", children: [_jsx("div", { className: "page-dock-name", children: label }), description && _jsx("div", { className: "page-dock-desc", children: description }), _jsx("div", { className: "page-dock-id", children: manifest.id })] }));
+}

package/dist/package/browser/components/DockShell/ExtensionRuntimeFrame.d.ts

@@ -0,0 +1,14 @@
+import { type ReactElement } from 'react';
+import type { ExtensionCatalogEntry } from '@forgeax/extension-host/browser';
+import type { ExtensionSessionContext } from '@forgeax/extension-host/contracts';
+import type { SurfacePane } from '@forgeax/app-shell/window';
+import type { EditorAssetImportSourceHandler } from './panelRenderers';
+export declare const TRUSTED_EXTENSION_SANDBOX = "allow-scripts allow-same-origin";
+export declare function extensionRuntimeUrl(runtimeUrl: string, pane?: SurfacePane): string;
+export declare function extensionFrameContext(descriptor: ExtensionCatalogEntry, gameId: string): ExtensionSessionContext;
+export declare function ExtensionRuntimeFrame({ descriptor, gameId, pane, onEditorAssetImport, }: {
+    descriptor: ExtensionCatalogEntry;
+    gameId: string;
+    pane?: SurfacePane;
+    onEditorAssetImport?: EditorAssetImportSourceHandler;
+}): ReactElement;

package/dist/package/browser/components/DockShell/ExtensionRuntimeFrame.js

@@ -0,0 +1,56 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useRef } from 'react';
+import { ExtensionFrame } from '@forgeax/extension-host/react';
+import { getLocale } from '../../i18n';
+import { attachExtensionEditorAssetImportBridge } from './extension-editor-bridge';
+import { EXTENSION_API_BASE } from './extensionRuntime';
+export const TRUSTED_EXTENSION_SANDBOX = 'allow-scripts allow-same-origin';
+export function extensionRuntimeUrl(runtimeUrl, pane) {
+    if (!pane)
+        return runtimeUrl;
+    const url = new URL(runtimeUrl, window.location.href);
+    url.searchParams.set('pane', pane);
+    return url.origin === window.location.origin
+        ? `${url.pathname}${url.search}${url.hash}`
+        : url.toString();
+}
+export function extensionFrameContext(descriptor, gameId) {
+    const runtimeId = encodeURIComponent(descriptor.runtimeId);
+    const encodedGameId = encodeURIComponent(gameId);
+    return {
+        extensionId: descriptor.extensionId,
+        runtimeId: descriptor.runtimeId,
+        gameId,
+        locale: getLocale(),
+        theme: 'dark',
+        endpoints: {
+            toolCall: `${EXTENSION_API_BASE}tools/call`,
+            gamePackage: `${EXTENSION_API_BASE}games/${encodedGameId}/package?runtimeId=${runtimeId}`,
+            extensionApi: `${EXTENSION_API_BASE}extension/${runtimeId}?gameId=${encodedGameId}`,
+            gameVersions: `${EXTENSION_API_BASE}games/${encodedGameId}/versions`,
+            gameComponents: `${EXTENSION_API_BASE}games/${encodedGameId}/components`,
+        },
+        capabilities: ['tools.call', 'project.files', 'game.package', 'media', 'versioning', 'extension.http'],
+    };
+}
+export function ExtensionRuntimeFrame({ descriptor, gameId, pane, onEditorAssetImport, }) {
+    const frameRef = useRef(null);
+    const importHandlerRef = useRef(onEditorAssetImport);
+    importHandlerRef.current = onEditorAssetImport;
+    const onFrameLoad = useCallback((event) => {
+        frameRef.current = event.currentTarget;
+    }, []);
+    useEffect(() => {
+        return attachExtensionEditorAssetImportBridge({
+            ownerWindow: window,
+            frameWindow: () => frameRef.current?.contentWindow ?? null,
+            importAssetSource: (request) => {
+                const handler = importHandlerRef.current;
+                return handler
+                    ? handler(request)
+                    : { ok: false, error: '当前 Studio 没有可用的 Editor Gateway' };
+            },
+        });
+    }, []);
+    return (_jsx(ExtensionFrame, { runtimeUrl: extensionRuntimeUrl(descriptor.runtimeUrl, pane), context: extensionFrameContext(descriptor, gameId), sandbox: TRUSTED_EXTENSION_SANDBOX, title: pane ? `${descriptor.title} — ${pane}` : descriptor.title, "data-extension-runtime": descriptor.extensionId, "data-extension-pane": pane, style: { display: 'block', width: '100%', height: '100%', border: 0 }, onLoad: onFrameLoad }));
+}

package/dist/package/browser/components/DockShell/PanelWindowingBoundary.d.ts

@@ -0,0 +1,6 @@
+import type { ReactNode } from 'react';
+import type { DetachedWindowCapability } from '@forgeax/app-shell/window';
+export declare function PanelWindowingBoundary({ capability, children, }: {
+    capability?: DetachedWindowCapability;
+    children: ReactNode;
+}): ReactNode;

package/dist/package/browser/components/DockShell/PanelWindowingBoundary.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useTranslation } from '../../i18n';
+import { useFloatingSurfaces } from '../../lib/platform';
+import { DetachedPanelBoundary, SurfacePlaceholder } from '@forgeax/app-shell/react';
+export function PanelWindowingBoundary({ capability, children, }) {
+    const { t } = useTranslation();
+    const floatingSurfaces = useFloatingSurfaces();
+    return (_jsx(DetachedPanelBoundary, { capability: capability, floatingSurfaces: floatingSurfaces, placeholder: (_jsx(SurfacePlaceholder, { title: t('dockShell.detachedWindowPlaceholder') })), children: children }));
+}

package/dist/package/browser/components/DockShell/chatDockAnimation.d.ts

@@ -0,0 +1,45 @@
+export type ChatDockAnimationPhase = 'idle' | 'collapsing' | 'preparing-expand' | 'expanding';
+export declare const CHAT_DOCK_ANIMATION_FALLBACK_MS = 300;
+interface ClosedChatOpenState {
+    atHome: boolean;
+    collapsed: boolean;
+}
+interface ClosedChatOpenActions {
+    moveHome(): void;
+    markForReopen(): void;
+    prepareExpand(): void;
+    uncollapse(): void;
+}
+/**
+ * F1's closed → open path must commit the prepared zero-width phase before it
+ * clears the collapsed store flag. Otherwise ChatDock renders one frame at its
+ * full persisted width while the dockview panel is still absent.
+ */
+export declare function prepareClosedChatOpen(state: ClosedChatOpenState, actions: ClosedChatOpenActions): void;
+interface TimerScheduler {
+    setTimeout(callback: () => void, delayMs: number): unknown;
+    clearTimeout(handle: unknown): void;
+}
+interface ChatDockAnimationCallbacks {
+    onPhaseChange(phase: ChatDockAnimationPhase): void;
+    shouldFinishCollapse(): boolean;
+    onCollapse(): void;
+}
+export interface ChatDockAnimationController {
+    getPhase(): ChatDockAnimationPhase;
+    activate(): void;
+    collapse(): void;
+    prepareExpand(): void;
+    startExpand(): void;
+    transitionEnd(): void;
+    cancel(): void;
+    dispose(): void;
+}
+/**
+ * Owns the cancellable part of the ChatDock width transition. DOM preparation
+ * stays in DockRegion (it must run after React commits), while this controller
+ * guarantees that a stale transitionend/fallback can never close a panel that
+ * has already been expanded again.
+ */
+export declare function createChatDockAnimationController(callbacks: ChatDockAnimationCallbacks, scheduler?: TimerScheduler, fallbackMs?: number): ChatDockAnimationController;
+export {};

package/dist/package/browser/components/DockShell/chatDockAnimation.js

@@ -0,0 +1,101 @@
+export const CHAT_DOCK_ANIMATION_FALLBACK_MS = 300;
+/**
+ * F1's closed → open path must commit the prepared zero-width phase before it
+ * clears the collapsed store flag. Otherwise ChatDock renders one frame at its
+ * full persisted width while the dockview panel is still absent.
+ */
+export function prepareClosedChatOpen(state, actions) {
+    if (!state.atHome)
+        actions.moveHome();
+    actions.markForReopen();
+    actions.prepareExpand();
+    if (state.collapsed)
+        actions.uncollapse();
+}
+const browserScheduler = {
+    setTimeout: (callback, delayMs) => window.setTimeout(callback, delayMs),
+    clearTimeout: (handle) => window.clearTimeout(handle),
+};
+/**
+ * Owns the cancellable part of the ChatDock width transition. DOM preparation
+ * stays in DockRegion (it must run after React commits), while this controller
+ * guarantees that a stale transitionend/fallback can never close a panel that
+ * has already been expanded again.
+ */
+export function createChatDockAnimationController(callbacks, scheduler = browserScheduler, fallbackMs = CHAT_DOCK_ANIMATION_FALLBACK_MS) {
+    let phase = 'idle';
+    let fallback = null;
+    let disposed = false;
+    const clearFallback = () => {
+        if (fallback === null)
+            return;
+        scheduler.clearTimeout(fallback);
+        fallback = null;
+    };
+    const publish = (next) => {
+        phase = next;
+        if (!disposed)
+            callbacks.onPhaseChange(next);
+    };
+    const settleCollapse = () => {
+        if (disposed || phase !== 'collapsing')
+            return;
+        clearFallback();
+        if (callbacks.shouldFinishCollapse())
+            callbacks.onCollapse();
+        publish('idle');
+    };
+    const settleExpand = () => {
+        if (disposed || phase !== 'expanding')
+            return;
+        clearFallback();
+        publish('idle');
+    };
+    const schedule = (settle) => {
+        clearFallback();
+        fallback = scheduler.setTimeout(settle, fallbackMs);
+    };
+    return {
+        getPhase: () => phase,
+        activate: () => {
+            disposed = false;
+        },
+        collapse: () => {
+            if (disposed)
+                return;
+            clearFallback();
+            publish('collapsing');
+            schedule(settleCollapse);
+        },
+        prepareExpand: () => {
+            if (disposed)
+                return;
+            clearFallback();
+            publish('preparing-expand');
+        },
+        startExpand: () => {
+            if (disposed)
+                return;
+            clearFallback();
+            publish('expanding');
+            schedule(settleExpand);
+        },
+        transitionEnd: () => {
+            if (phase === 'collapsing')
+                settleCollapse();
+            else if (phase === 'expanding')
+                settleExpand();
+        },
+        cancel: () => {
+            if (disposed)
+                return;
+            clearFallback();
+            publish('idle');
+        },
+        dispose: () => {
+            clearFallback();
+            disposed = true;
+            phase = 'idle';
+        },
+    };
+}

package/dist/package/browser/components/DockShell/chatDockFullscreen.d.ts

@@ -0,0 +1,17 @@
+export declare function handleFullscreenChatToggle(fullscreen: boolean, toggleChatpanel: () => void): boolean;
+export declare function isFullscreenChatRestoreOwner({ chatWasOpen, chatHome, region, }: {
+    chatWasOpen: boolean;
+    chatHome: string;
+    region: string;
+}): boolean;
+export declare function resolveFullscreenChatRestoreIntent({ ownsChat, chatpanelCollapsed, }: {
+    ownsChat: boolean;
+    chatpanelCollapsed: boolean;
+}): {
+    chatWasOpen: boolean;
+    hiddenByToggle: boolean;
+} | null;
+export declare function shouldRestoreFullscreenChat({ chatWasOpen, chatpanelCollapsed, }: {
+    chatWasOpen: boolean;
+    chatpanelCollapsed: boolean;
+}): boolean;

package/dist/package/browser/components/DockShell/chatDockFullscreen.js

@@ -0,0 +1,22 @@
+export function handleFullscreenChatToggle(fullscreen, toggleChatpanel) {
+    if (!fullscreen)
+        return false;
+    toggleChatpanel();
+    return true;
+}
+export function isFullscreenChatRestoreOwner({ chatWasOpen, chatHome, region, }) {
+    // The physical panel identifies its owner while open. When it was already
+    // closed, the configured home region owns any explicit fullscreen toggle.
+    return chatWasOpen || chatHome === region;
+}
+export function resolveFullscreenChatRestoreIntent({ ownsChat, chatpanelCollapsed, }) {
+    if (!ownsChat)
+        return null;
+    return {
+        chatWasOpen: !chatpanelCollapsed,
+        hiddenByToggle: chatpanelCollapsed,
+    };
+}
+export function shouldRestoreFullscreenChat({ chatWasOpen, chatpanelCollapsed, }) {
+    return chatWasOpen && !chatpanelCollapsed;
+}

package/dist/package/browser/components/DockShell/chatDockLayout.d.ts

@@ -0,0 +1,10 @@
+export interface ChatDockviewLayoutSize {
+    width: number;
+    height: number;
+}
+/**
+ * Dockview must be laid out against its own flex item. The ChatDock inner shell
+ * also contains SessionTabStrip, so measuring either the outer column or the
+ * inner shell overstates Dockview's height by the tab-strip height.
+ */
+export declare function readChatDockviewLayoutSize(inner: HTMLElement | null): ChatDockviewLayoutSize | null;

package/dist/package/browser/components/DockShell/chatDockLayout.js

@@ -0,0 +1,11 @@
+/**
+ * Dockview must be laid out against its own flex item. The ChatDock inner shell
+ * also contains SessionTabStrip, so measuring either the outer column or the
+ * inner shell overstates Dockview's height by the tab-strip height.
+ */
+export function readChatDockviewLayoutSize(inner) {
+    const dockview = inner?.querySelector('.fx-dockshell');
+    if (!dockview || dockview.clientWidth <= 0 || dockview.clientHeight <= 0)
+        return null;
+    return { width: dockview.clientWidth, height: dockview.clientHeight };
+}

package/dist/package/browser/components/DockShell/compact-empty-dock-groups.d.ts

@@ -0,0 +1,16 @@
+/** Remove grid/floating groups that lost all panels (e.g. after UE lift/drop). */
+export interface CompactEmptyDockGroupsApi {
+    readonly groups: ReadonlyArray<{
+        readonly panels: readonly unknown[];
+        readonly api: {
+            readonly location: {
+                readonly type: string;
+            };
+        };
+    }>;
+    removeGroup(group: CompactEmptyDockGroupsApi['groups'][number]): void;
+}
+export declare function compactEmptyDockGroups(api: CompactEmptyDockGroupsApi): number;
+export declare function relayoutDockContainer(api: {
+    layout?(width: number, height: number, force?: boolean): void;
+}, container: HTMLElement | null | undefined): void;

package/dist/package/browser/components/DockShell/compact-empty-dock-groups.js

@@ -0,0 +1,28 @@
+/** Remove grid/floating groups that lost all panels (e.g. after UE lift/drop). */
+export function compactEmptyDockGroups(api) {
+    const empty = api.groups.filter((group) => group.panels.length === 0
+        && (group.api.location.type === 'grid' || group.api.location.type === 'floating'));
+    for (const group of empty) {
+        try {
+            api.removeGroup(group);
+        }
+        catch {
+            // Group may already be mid-disposal from dockview's own move path.
+        }
+    }
+    return empty.length;
+}
+export function relayoutDockContainer(api, container) {
+    if (!container)
+        return;
+    const width = container.clientWidth;
+    const height = container.clientHeight;
+    if (width <= 0 || height <= 0)
+        return;
+    try {
+        api.layout?.(width, height, true);
+    }
+    catch {
+        // noop — region may be unmounting.
+    }
+}

package/dist/package/browser/components/DockShell/crossInstanceDrop.d.ts

@@ -0,0 +1 @@
+export { handleCrossInstanceDrop, type CrossInstanceDropEvent, } from '@forgeax/app-shell/dock';

package/dist/package/browser/components/DockShell/crossInstanceDrop.js

@@ -0,0 +1 @@
+export { handleCrossInstanceDrop, } from '@forgeax/app-shell/dock';

package/dist/package/browser/components/DockShell/dockResetEpoch.d.ts

@@ -0,0 +1,2 @@
+export declare function bumpDockResetEpoch(): void;
+export declare function getDockResetEpoch(): number;

package/dist/package/browser/components/DockShell/dockResetEpoch.js

@@ -0,0 +1,13 @@
+// Monotonic epoch for `app.dock.reset`.
+//
+// Callers (layout menu, onboarding tour) may fire reset before a DockRegion has
+// subscribed to `dock:reset` or before dockview `onReady` has set `api`. Bumping
+// this epoch at request time lets each region apply the reset exactly once when
+// it becomes ready — no timers, no localStorage poking.
+let epoch = 0;
+export function bumpDockResetEpoch() {
+    epoch += 1;
+}
+export function getDockResetEpoch() {
+    return epoch;
+}

package/dist/package/browser/components/DockShell/dockTitle.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from 'react';
+export declare function setDockTitleHidden(group: HTMLElement, hidden: boolean): void;
+/**
+ * Resolve the effective title-bar state for a group. An explicit state wins;
+ * otherwise a panel's declarative single-tab preference is the default.
+ */
+export declare function isDockTitleHidden(group: HTMLElement): boolean;
+/** Restore affordance rendered in every dock panel body. CSS only reveals it
+ * for a single-panel group whose title bar is currently hidden. */
+export declare function DockTitleRestoreButton(): ReactNode;
+/** Keep the restore affordance outside the panel's layout flow. */
+export declare function withDockTitleRestore(render: () => ReactNode): () => ReactNode;

package/dist/package/browser/components/DockShell/dockTitle.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useTranslation } from '../../i18n';
+const DOCK_TITLE_STATE = 'data-fx-dock-title-state';
+export function setDockTitleHidden(group, hidden) {
+    const element = group;
+    element.dataset.fxDockTitleState = hidden ? 'hidden' : 'visible';
+}
+/**
+ * Resolve the effective title-bar state for a group. An explicit state wins;
+ * otherwise a panel's declarative single-tab preference is the default.
+ */
+export function isDockTitleHidden(group) {
+    const state = group.getAttribute(DOCK_TITLE_STATE);
+    if (state === 'hidden')
+        return true;
+    if (state === 'visible')
+        return false;
+    return group.querySelector('[data-dock-single-tab="hideTitle"]') !== null;
+}
+function closestDockGroup(target) {
+    return target.closest('.dv-groupview, .groupview');
+}
+/** Restore affordance rendered in every dock panel body. CSS only reveals it
+ * for a single-panel group whose title bar is currently hidden. */
+export function DockTitleRestoreButton() {
+    const { t } = useTranslation();
+    return (_jsx("button", { type: "button", className: "fx-dock-title-restore", "data-testid": "dock-title-restore", "aria-label": t('dockShell.showPanelTitle'), title: t('dockShell.showPanelTitle'), onClick: (event) => {
+            const group = closestDockGroup(event.currentTarget);
+            if (group)
+                setDockTitleHidden(group, false);
+        } }));
+}
+/** Keep the restore affordance outside the panel's layout flow. */
+export function withDockTitleRestore(render) {
+    return () => (_jsxs(_Fragment, { children: [render(), _jsx(DockTitleRestoreButton, {})] }));
+}