@forgeax/interface 0.4.1

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

@@ -0,0 +1,325 @@
+import { type ComponentType, type ReactNode } from 'react';
+import type { SerializedDockview } from 'dockview';
+import type { DockRegion } from './regions';
+import type { PanelActionContribution, PanelContentDefinition, PanelHeaderDefinition, StatusItemContribution, DrawerPanelContribution } from '../../core/panels';
+import type { DetachedWindowCapability } from '@forgeax/app-shell/window';
+export interface ExtensionTransport {
+    post(envelope: unknown): void;
+    onMessage(handler: (envelope: unknown) => void): () => void;
+    close(): void;
+}
+export interface ExtensionToolCall {
+    toolId: string;
+    args?: unknown;
+    caller: {
+        kind: 'user' | 'ai' | 'skill' | 'cli';
+        sessionId?: string;
+        threadId?: string;
+        agentId?: string;
+    } | {
+        kind: 'extension';
+        extensionId: string;
+        instanceId: string;
+        sessionId?: string;
+        threadId?: string;
+    };
+}
+export type ExtensionToolResult = {
+    ok: true;
+    result?: unknown;
+} | {
+    ok: false;
+    error: string;
+    code?: string;
+};
+export interface ExtensionPort {
+    onChat(handler: (event: {
+        text: string;
+        attachments?: string[];
+    }) => void): () => void;
+    onToolCall(handler: (call: ExtensionToolCall) => Promise<ExtensionToolResult> | ExtensionToolResult): () => void;
+    surface: {
+        subscribe(handler: (event: {
+            surfaceId: string;
+            actions: Array<{
+                id: string;
+                label?: string;
+                args?: unknown;
+                enabled: boolean;
+                hotkey?: string;
+            }>;
+            snapshot: unknown;
+        }) => void): () => void;
+    };
+    setTheme(event: {
+        locale?: 'zh' | 'en' | 'ja';
+        theme?: 'light' | 'dark';
+    }): void;
+    setVisibility(visible: boolean): void;
+    onNavigate(handler: (event: {
+        targetPluginId: string;
+        payload?: Record<string, unknown>;
+    }) => void): () => void;
+    close(): void;
+}
+export interface EditorContextMenuItem {
+    label?: string;
+    title?: string;
+    icon?: string;
+    shortcut?: string;
+    forge?: boolean;
+    onClick?: () => void;
+    disabled?: boolean;
+    danger?: boolean;
+    sep?: boolean;
+    children?: EditorContextMenuItem[];
+}
+/**
+ * Host-owned source import request for page-generated assets.
+ *
+ * This is deliberately an Editor host seam, not a plugin tool contract. The
+ * host decides how the bytes enter the Editor product; page runtimes only
+ * provide the project-relative destination and source bytes.
+ */
+export interface EditorAssetImportSourceRequest {
+    readonly base64: string;
+    readonly destPath: string;
+    readonly sourceName: string;
+    readonly requestId: string;
+}
+export type EditorAssetImportSourceHandler = (request: EditorAssetImportSourceRequest) => unknown | Promise<unknown>;
+export interface CreateExtensionPortOptions {
+    extensionId: string;
+    transport: ExtensionTransport;
+    initial?: {
+        locale?: 'zh' | 'en' | 'ja';
+        theme?: 'light' | 'dark';
+        sessionId?: string;
+        threadId?: string;
+        pane?: 'left' | 'center';
+    };
+    defaultTimeoutMs?: number;
+    onInvalid?: (raw: unknown, reason: string) => void;
+}
+type HostFactory<Options, Result> = {
+    call(options: Options): Result;
+}['call'];
+export type CreateExtensionPort = HostFactory<CreateExtensionPortOptions, ExtensionPort>;
+export interface WindowTransportOptions {
+    target: Window;
+    targetOrigin: string;
+    expectedOrigin?: string;
+    expectedSource?: () => Window | null;
+    listenOn?: Window;
+}
+export type CreateWindowTransport = (options: WindowTransportOptions) => ExtensionTransport;
+/**
+ * A dock panel descriptor. Carries everything the DockRegion needs to know
+ * to render a panel: title (tab label), optional visual/behavior hints
+ * (order/icon/when/defaultRegion), and the body renderer.
+ *
+ * Phase 1 uses `defaultRegion` as the initial home; user overrides live in
+ * the active page's `panelLocations` (see useActivePage). Phase 2
+ * wires the override via UI.
+ */
+export interface PanelDescriptor {
+    /** Stable panel id. Optional during migration; DockPanelHost still passes the id. */
+    id?: string;
+    /** Tab label shown on the dock tab. */
+    title: string;
+    /** Sort order within the region. Lower = earlier. Default 0. */
+    order?: number;
+    /** Reserved for Phase 2 activity-bar icon. Ignored today. */
+    icon?: string;
+    /** Predicate for conditional visibility. Missing = always visible. */
+    when?: () => boolean;
+    /** Where this panel lives absent a user override. Default 'DockShell'. */
+    defaultRegion?: DockRegion;
+    /** Optional shell-owned header metadata. */
+    header?: PanelHeaderDefinition;
+    /** Optional shell-owned content policy. */
+    content?: PanelContentDefinition;
+    /** Optional panel-scoped actions; normalized together with contributed actions. */
+    actions?: readonly PanelActionContribution[];
+    /** Dockview chrome behavior hints. DockRegion owns interpretation. */
+    dockChrome?: {
+        /** How to render this panel's dock tab when it is the only tab in its group. */
+        singleTab?: 'default' | 'full' | 'hideTitle';
+    };
+    /** Complete detached-window target factory. Missing means dock-only. */
+    windowing?: DetachedWindowCapability;
+    /** Panel body renderer. */
+    render: () => ReactNode;
+}
+/**
+ * Structural slot registry for the interface shell.
+ *
+ * Categories reflect where in the shell each slot lives — this is the SSOT
+ * for the compositional design so future maintainers can find "where should
+ * I put this new injection" by role, not by naming coincidence.
+ *
+ *   panels    — draggable dockview panel bodies (user-arrangeable)
+ *   overlays  — full-screen modal-style layers
+ *   surfaces  — heavy engine viewports (kept alive above dockview)
+ *   chrome    — fixed shell regions outside dockview
+ *   detached  — bodies of DETACHED OS windows (Tauri or `window.open`)
+ *   slots     — well-defined sub-slots inside interface-owned components
+ *   extensionTransport — cross-realm transport factories (not rendering)
+ *
+ * All render targets are React Components (capitalized nouns) — consumers
+ * use JSX `<X.Y />` directly, no render-function-call syntax.
+ *
+ * (v9 · 2026-07-08) The former `page` category — a feature-name grouping
+ * mixing MainArea body / sidebar sub-nav / detached windows — was eliminated.
+ * Its five slots are now reclassified by structural role into `detached.*`
+ * and `slots.*`. Structural categories no longer contain feature names.
+ */
+export interface PanelRenderers {
+    /** Draggable dock panels (dockview body injection).
+     *  Consumers mount via `<DockPanelHost id={id}/>` which looks each id up here. */
+    panels?: Record<string, PanelDescriptor>;
+    /** Full-screen overlays (modals, dashboards). Positioned above dockview + chrome. */
+    overlays?: {
+        Dashboard?: ComponentType;
+        Settings?: ComponentType;
+    };
+    /** Heavy engine surfaces. Positioned by SurfaceKeepAliveLayer above the
+     *  dockview 'viewport' panel anchor, so they survive dockview rebuilds.
+     *
+     *  2026-06-30: preview/edit merged into a single 'viewport' panel; the old
+     *  `Preview` slot was retired. `SceneEditor` is now the only engine surface
+     *  — a WYSIWYG viewport that switches between edit-time gizmos and play-time
+     *  simulation on the same in-process engine. Future play/debug modes would
+     *  add sibling slots here. */
+    surfaces?: {
+        /** Pure renderer surface. Product controls belong to the hosting panel's
+         *  PanelShell header in both docked and detached windows. */
+        SceneEditor?: ComponentType;
+    };
+    /** Single-realm editor coordination callbacks. Interface declares only the
+     * structural contract; studio/standalone inject the editor-core implementation
+     * so the interface foundation never imports editor-core. */
+    editor?: {
+        /** Import bytes through the mounted Editor product's Gateway. */
+        importAssetSource?: EditorAssetImportSourceHandler;
+        setContextMenuRenderer?: (renderer: (menu: {
+            x: number;
+            y: number;
+            items: EditorContextMenuItem[];
+        } | null) => void) => () => void;
+        installBridge?: (handlers: {
+            onEditorHealth(entry: {
+                level: 'info' | 'warn' | 'error';
+                code: string;
+                message: string;
+                ts: number;
+            }): void;
+            onEditorConsole(entry: {
+                level: 'log' | 'warn' | 'error' | 'info' | 'debug';
+                text: string;
+                ts: number;
+            }): void;
+            onEditorNetwork(entry: {
+                kind: 'fetch' | 'xhr' | 'ws';
+                method: string;
+                url: string;
+                status: number;
+                ms: number;
+                ok: boolean;
+                ts: number;
+            }): void;
+            onEditorRef(payload: {
+                kind: 'entity';
+                id: number;
+                name: string;
+                components: string[];
+                source?: {
+                    plugin?: string;
+                    docId?: string;
+                };
+            } | {
+                kind: 'component';
+                entityId: number;
+                entityName: string;
+                comp: string;
+                value: unknown;
+            } | {
+                kind: 'asset';
+                guid: string;
+                assetKind: string;
+                name: string;
+                packPath?: string;
+            }): void;
+            onAddAssetToChat(refs: Array<{
+                type: 'asset' | 'folder';
+                guid?: string;
+                kind?: string;
+                name: string;
+                path: string;
+                payload?: Record<string, unknown>;
+                summary?: {
+                    totalAssets: number;
+                    kinds: Record<string, number>;
+                    guids: string[];
+                };
+            }>): void;
+        }) => () => void;
+    };
+    /** ADR-0030 §2.3 — bottom-drawer panel contributions (kind:'drawer'). Keyed
+     *  by id so the derive fold sub-merges per key. Each entry registers a
+     *  launcher tab at the bottom that expands upward into a resizable,
+     *  single-active panel (DrawerHostView). */
+    drawerPanels?: Record<string, DrawerPanelContribution>;
+    /** ADR-0030 §2.2 — status-bar (strip) item contributions. Keyed by id so the
+     *  derive fold sub-merges per key (later contributor wins per id, siblings
+     *  preserved). This is the footer's `kind:'strip'` registration surface: the
+     *  StripHostView renders these text/button/custom chips. Replaces the legacy
+     *  module-level statusBarStore (a parallel registration truth). */
+    stripItems?: Record<string, StatusItemContribution>;
+    /** Bodies of DETACHED OS-windows (Tauri or `window.open`) keyed by surface id.
+     *  Rendered inside <DetachedSurface> when a panel/surface is popped out.
+     *  Same host bundle loads with `?surface=...` in the URL; DetachedSurface
+     *  reads these slots to mount the correct body. */
+    detached?: {
+        AgentsBrowser?: ComponentType;
+        FilesBrowser?: ComponentType;
+    };
+    /** Sub-slot injection points — each is a well-defined callsite inside an
+     *  interface-owned component where studio fills in feature-specific content.
+     *  Each slot has ONE render callsite.
+     *
+     *  Leaf names are globally unique on purpose — DOM slot markers use the
+     *  bare leaf name (data-fx-slot="MainAreaBody") without a "slots:" prefix. */
+    slots?: {
+        /** MainArea body when app mode is not the SceneEditor mode (i.e., 'ai'). */
+        MainAreaBody?: ComponentType;
+        /** Sidebar's Agents sub-nav body. */
+        SidebarAgents?: ComponentType;
+        /** Extension-host top-right widget shown when an extension Page is expanded. */
+        CornerAgentPicker?: ComponentType<{
+            preferredAgentExtensionId?: string;
+        }>;
+    };
+    /** Extension-transport factories for extension Page iframe RPC (studio-only). The contract
+     *  is structural so Interface stays runnable without Extension Platform installed. */
+    extensionTransport?: {
+        createExtensionPort?: CreateExtensionPort;
+        createWindowTransport?: CreateWindowTransport;
+    };
+    /** Live editor sub-panel ids (ep:*). The host derives this from its editor
+     *  manifest; DockShell uses it to register panel renderers and menu entries.
+     *  Empty means no editor is wired. */
+    editorPanelIds: readonly string[];
+    /** Optional host-owned layouts for built-in product pages. Interface owns the
+     *  docking mechanics but must not encode an editor application's panel
+     *  arrangement, so editor hosts inject their Scene layout here. */
+    builtinPageLayouts?: Readonly<Record<string, SerializedDockview>>;
+    /** Inline (non-iframe) extension panels, keyed by extension id. Not a
+     *  fixed slot — plugins register themselves here. Stays at top level. */
+    extensionPanels?: Record<string, () => ReactNode>;
+}
+export declare const DEFAULT_EDITOR_PANEL_IDS: readonly string[];
+export declare const DEFAULT_PANEL_RENDERERS: PanelRenderers;
+export declare const PanelRenderersProvider: import("react").Provider<PanelRenderers>;
+export declare function usePanelRenderers(): PanelRenderers;
+export {};

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

@@ -0,0 +1,25 @@
+// Panel renderer injection — keeps the interface shell business-agnostic.
+//
+// The DockShell renders generic chrome (page / preview / edit / chat /
+// ep:* editor panels), but the actual edit & preview SURFACES belong to an
+// app (today: the editor). To avoid interface importing `@forgeax/editor*`
+// (which created the studio → interface → editor → interface cycle), the
+// host injects the editor-specific render slots through this context.
+//
+// - interface ALONE renders neutral placeholders (no editor present).
+// - studio injects real renderers built from `@forgeax/editor/{edit,play}`.
+//
+// This is the same shape as the existing extension panel merge: DockShell owns
+// the docking mechanics, the host supplies the panel bodies.
+import { createContext, useContext } from 'react';
+// Interface-alone hosts do not expose editor panels. Editor hosts inject their
+// own manifest through PanelRenderers.editorPanelIds.
+export const DEFAULT_EDITOR_PANEL_IDS = [];
+export const DEFAULT_PANEL_RENDERERS = {
+    editorPanelIds: DEFAULT_EDITOR_PANEL_IDS,
+};
+const PanelRenderersContext = createContext(DEFAULT_PANEL_RENDERERS);
+export const PanelRenderersProvider = PanelRenderersContext.Provider;
+export function usePanelRenderers() {
+    return useContext(PanelRenderersContext);
+}

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

@@ -0,0 +1,18 @@
+import type { DockviewApi, DockviewGroupPanel, IDockviewPanel } from 'dockview';
+import type { DetachedWindowCapability } from '@forgeax/app-shell/window';
+import type { DockRegion } from './regions';
+import type { SideEdge } from './sideEdgeMove';
+export interface PanelTabCommandsDeps {
+    getApi: () => DockviewApi | null;
+    titleFor: (id: string) => string;
+}
+export interface PanelTabCommands {
+    close(panel: IDockviewPanel): void;
+    closeOthers(active: IDockviewPanel, group: DockviewGroupPanel): void;
+    moveToEdge(panel: IDockviewPanel, side: SideEdge): void;
+    moveOffEdge(panel: IDockviewPanel): void;
+    setTitleBarHidden(groupEl: HTMLElement, hidden: boolean): void;
+    transferToRegion(panelId: string, targetRegion: DockRegion): void;
+    detach(panel: IDockviewPanel, capability: DetachedWindowCapability | undefined): void;
+}
+export declare function createPanelTabCommands(deps: PanelTabCommandsDeps): PanelTabCommands;

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

@@ -0,0 +1,133 @@
+import { getSurfaceWindowingController } from '../../lib/platform/surface-windowing';
+import { getDockRegions } from './dockviewRegistry';
+import { setDockTitleHidden } from './dockTitle';
+import { openPanelWindow } from './panelWindowing';
+import { setFooterPanelUserVisible, isFooterPanelId } from './footer-panel-visibility';
+function dockRegionTransferApi(api) {
+    return api;
+}
+export function createPanelTabCommands(deps) {
+    const { getApi, titleFor } = deps;
+    return {
+        close(panel) {
+            if (isFooterPanelId(panel.id))
+                setFooterPanelUserVisible(panel.id, false);
+            try {
+                panel.api.close();
+            }
+            catch { /* noop */ }
+        },
+        closeOthers(active, group) {
+            for (const panel of group.panels) {
+                if (panel.id === active.id)
+                    continue;
+                try {
+                    panel.api.close();
+                }
+                catch { /* noop */ }
+            }
+        },
+        moveToEdge(panel, side) {
+            const api = getApi();
+            if (!api)
+                return;
+            const edgeApi = api.getEdgeGroup(side);
+            if (!edgeApi)
+                return;
+            const edgeGroup = api.groups.find((group) => group.api.id === edgeApi.id);
+            if (!edgeGroup)
+                return;
+            try {
+                api.setEdgeGroupVisible(side, true);
+            }
+            catch { /* noop */ }
+            edgeGroup.element.classList.remove('fx-edge-empty');
+            try {
+                panel.api.moveTo({ group: edgeGroup, position: 'center' });
+            }
+            catch { /* noop */ }
+            try {
+                edgeGroup.api.collapse();
+            }
+            catch { /* noop */ }
+            try {
+                panel.api.setActive();
+            }
+            catch { /* noop */ }
+        },
+        moveOffEdge(panel) {
+            const api = getApi();
+            if (!api)
+                return;
+            const gridGroup = api.groups.find((group) => group.api.location.type === 'grid');
+            if (!gridGroup)
+                return;
+            const loc = panel.api.location;
+            const fromSide = loc.type === 'edge' && (loc.position === 'left' || loc.position === 'right')
+                ? loc.position
+                : 'left';
+            try {
+                panel.api.moveTo({ group: gridGroup, position: fromSide });
+            }
+            catch { /* noop */ }
+            try {
+                panel.api.setActive();
+            }
+            catch { /* noop */ }
+        },
+        setTitleBarHidden(groupEl, hidden) {
+            setDockTitleHidden(groupEl, hidden);
+        },
+        transferToRegion(panelId, targetRegion) {
+            const regions = getDockRegions();
+            const target = regions.find((entry) => entry.region === targetRegion);
+            if (!target)
+                return;
+            const targetApi = dockRegionTransferApi(target.api);
+            const source = regions.find((entry) => dockRegionTransferApi(entry.api).getPanel(panelId));
+            if (source?.region === targetRegion)
+                return;
+            const sourcePanel = source ? dockRegionTransferApi(source.api).getPanel(panelId) : undefined;
+            if (sourcePanel) {
+                const component = panelId;
+                const title = sourcePanel.api.title || titleFor(panelId);
+                const params = sourcePanel.params;
+                try {
+                    sourcePanel.api.close();
+                }
+                catch { /* noop */ }
+                try {
+                    targetApi.addPanel({
+                        id: panelId,
+                        component,
+                        title,
+                        params,
+                    });
+                }
+                catch { /* noop */ }
+                return;
+            }
+            if (targetApi.getPanel(panelId))
+                return;
+            try {
+                targetApi.addPanel({
+                    id: panelId,
+                    component: panelId,
+                    title: titleFor(panelId),
+                });
+            }
+            catch { /* noop */ }
+        },
+        detach(panel, capability) {
+            void openPanelWindow(panel.id, capability, {
+                detachSurface: getSurfaceWindowingController().detachSurface,
+                closeDockPanel: () => {
+                    try {
+                        panel.api.close();
+                    }
+                    catch { /* noop */ }
+                },
+            });
+        },
+    };
+}

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

@@ -0,0 +1,32 @@
+import { canOpenPanelWindow, shouldShowDetachedPlaceholder, type DetachedWindowCapability, type OpenPanelWindowOptions, type SurfaceDescriptor } from '@forgeax/app-shell/window';
+export { canOpenPanelWindow, shouldShowDetachedPlaceholder };
+export type { OpenPanelWindowOptions } from '@forgeax/app-shell/window';
+export interface PanelWindowingSources {
+    basePanelIds: ReadonlySet<string>;
+    baseWindowing: Readonly<Record<string, DetachedWindowCapability>>;
+    pageWindowing: Readonly<Record<string, DetachedWindowCapability>>;
+    injectedWindowing?: DetachedWindowCapability;
+}
+/** Dockview prefixes editor placements with ep:, while injected descriptors use bare ids. */
+export declare function injectedPanelDescriptorId(panelId: string): string;
+/** Whether the Page runtime survives the later BASE/editor component spreads. */
+export declare function pageRuntimeOwnsPanel(panelId: string, basePanelIds: ReadonlySet<string>, editorPanelIds: readonly string[]): boolean;
+/**
+ * Resolve capability with the same ownership precedence as DockRegion's final
+ * component map: editor ep:* uses its injected descriptor; BASE wins even when
+ * it deliberately has no capability; only unclaimed ids may fall through
+ * Page → injected.
+ */
+export declare function resolvePanelWindowing(panelId: string, sources: PanelWindowingSources): DetachedWindowCapability | undefined;
+/**
+ * The one high-level panel pop-out action used by every shell affordance.
+ * It constructs the target, opens the physical carrier, and only then removes
+ * an ordinary dock tab only when the target explicitly requests that behavior.
+ */
+export declare function openPanelWindow(panelId: string, capability: DetachedWindowCapability | undefined, options: OpenPanelWindowOptions): Promise<boolean>;
+/**
+ * Resolve the dock placement restored by a window-close event. This is a lookup,
+ * not a consume: every DockRegion receives the same close notification and the
+ * region that owns the placement must be allowed to handle it.
+ */
+export declare function detachedDockPanelForSurface(surface: SurfaceDescriptor): string | undefined;

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

@@ -0,0 +1,42 @@
+import { canOpenPanelWindow, createPanelWindowingController, shouldShowDetachedPlaceholder, } from '@forgeax/app-shell/window';
+export { canOpenPanelWindow, shouldShowDetachedPlaceholder };
+const panelWindowing = createPanelWindowingController();
+/** Dockview prefixes editor placements with ep:, while injected descriptors use bare ids. */
+export function injectedPanelDescriptorId(panelId) {
+    return panelId.startsWith('ep:') ? panelId.slice(3) : panelId;
+}
+/** Whether the Page runtime survives the later BASE/editor component spreads. */
+export function pageRuntimeOwnsPanel(panelId, basePanelIds, editorPanelIds) {
+    if (basePanelIds.has(panelId))
+        return false;
+    return !(panelId.startsWith('ep:') && editorPanelIds.includes(panelId.slice(3)));
+}
+/**
+ * Resolve capability with the same ownership precedence as DockRegion's final
+ * component map: editor ep:* uses its injected descriptor; BASE wins even when
+ * it deliberately has no capability; only unclaimed ids may fall through
+ * Page → injected.
+ */
+export function resolvePanelWindowing(panelId, sources) {
+    if (panelId.startsWith('ep:'))
+        return sources.injectedWindowing;
+    if (sources.basePanelIds.has(panelId))
+        return sources.baseWindowing[panelId];
+    return sources.pageWindowing[panelId] ?? sources.injectedWindowing;
+}
+/**
+ * The one high-level panel pop-out action used by every shell affordance.
+ * It constructs the target, opens the physical carrier, and only then removes
+ * an ordinary dock tab only when the target explicitly requests that behavior.
+ */
+export async function openPanelWindow(panelId, capability, options) {
+    return panelWindowing.openPanelWindow(panelId, capability, options);
+}
+/**
+ * Resolve the dock placement restored by a window-close event. This is a lookup,
+ * not a consume: every DockRegion receives the same close notification and the
+ * region that owns the placement must be allowed to handle it.
+ */
+export function detachedDockPanelForSurface(surface) {
+    return panelWindowing.panelForClosedSurface(surface);
+}

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

@@ -0,0 +1 @@
+export { DOCK_REGIONS, REGIONS, isDockRegion, type DockRegion, type Region, } from '@forgeax/app-shell/dock';

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

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

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

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

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

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

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

@@ -0,0 +1,3 @@
+import type { SerializedDockview } from 'dockview';
+/** Rewrite legacy `edit`/`preview` dock keys to `viewport` before `api.fromJSON`. */
+export declare function sanitizeRetiredDockLayout(layout: SerializedDockview): SerializedDockview;

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

@@ -0,0 +1,46 @@
+/** Retired viewport panel keys from the pre-2026-06-30 edit/preview split. */
+const RETIRED_VIEWPORT_KEYS = new Set(['edit', 'preview']);
+function remapGridViews(node) {
+    if (!node || typeof node !== 'object')
+        return;
+    const n = node;
+    if (n.type === 'leaf' && n.data && typeof n.data === 'object') {
+        const leaf = n.data;
+        if (Array.isArray(leaf.views)) {
+            leaf.views = leaf.views.map((v) => (RETIRED_VIEWPORT_KEYS.has(v) ? 'viewport' : v));
+        }
+        if (leaf.activeView && RETIRED_VIEWPORT_KEYS.has(leaf.activeView)) {
+            leaf.activeView = 'viewport';
+        }
+        return;
+    }
+    if (n.type === 'branch' && Array.isArray(n.data)) {
+        for (const child of n.data)
+            remapGridViews(child);
+    }
+}
+/** Rewrite legacy `edit`/`preview` dock keys to `viewport` before `api.fromJSON`. */
+export function sanitizeRetiredDockLayout(layout) {
+    const out = structuredClone(layout);
+    if (out.grid?.root)
+        remapGridViews(out.grid.root);
+    if (out.panels) {
+        for (const key of Object.keys(out.panels)) {
+            const panel = out.panels[key];
+            if (!panel)
+                continue;
+            if (RETIRED_VIEWPORT_KEYS.has(panel.contentComponent ?? '')) {
+                panel.contentComponent = 'viewport';
+            }
+            if (RETIRED_VIEWPORT_KEYS.has(key)) {
+                const migrated = { ...panel, id: 'viewport', contentComponent: 'viewport' };
+                out.panels.viewport = migrated;
+                delete out.panels[key];
+            }
+            else if (panel.id && RETIRED_VIEWPORT_KEYS.has(panel.id)) {
+                panel.id = 'viewport';
+            }
+        }
+    }
+    return out;
+}

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

@@ -0,0 +1 @@
+export { isOnSideEdge, nearerSideEdge, type RectLike, type SideEdge, } from '@forgeax/app-shell/dock';

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

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

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

@@ -0,0 +1,13 @@
+import type { DockviewApi, GetTabContextMenuItemsParams } from 'dockview';
+import type { PanelTabCommands } from './panelTabCommands';
+import { type PanelWindowingSources } from './panelWindowing';
+import { buildTabContextMenuItems } from './tabContextMenu';
+import type { DockRegion } from './regions';
+export interface StudioTabMenuProviderDeps {
+    region: DockRegion;
+    getWrapEl: () => HTMLElement | null;
+    getApi: () => DockviewApi | null;
+    commands: PanelTabCommands;
+    windowingSources: PanelWindowingSources;
+}
+export declare function createStudioTabContextMenuHandler(deps: StudioTabMenuProviderDeps): (params: GetTabContextMenuItemsParams) => ReturnType<typeof buildTabContextMenuItems>;