@forgeax/interface 0.4.1

package/dist/package/browser/core/page-platform/session.js

@@ -0,0 +1,327 @@
+import { decodePageKey, encodePageKey, } from '@forgeax/types';
+import { PagePlatformError } from './types';
+import { getCurrentProject, subscribeCurrentProject } from '../../lib/project-context';
+const inertController = {
+    prepareClose: () => ({ status: 'ready' }),
+    dispose: () => undefined,
+};
+function normalizeKey(key) {
+    return typeof key === 'string' ? decodePageKey(key) : key;
+}
+export function createPageSession(registry, options = {}) {
+    const createInstanceId = options.createInstanceId ?? (() => crypto.randomUUID());
+    const now = options.now ?? (() => Date.now());
+    const entries = new Map();
+    // Controller-reflected live titles, keyed by encoded key — merged into the
+    // snapshot so the instance record stays immutable while the tab label can
+    // change. `titleSubs` holds the matching `subscribeTitle` unsubscribe fns.
+    const titles = new Map();
+    const titleSubs = new Map();
+    const listeners = new Set();
+    let generation = 0;
+    let activeKey;
+    let snapshot = { generation, instances: [] };
+    let registryUnsubscribe = () => undefined;
+    let projectUnsubscribe = () => undefined;
+    let restoring = false;
+    const recentKey = (policy) => policy === 'project'
+        ? `forgeax:project:${getCurrentProject()}:recent-page`
+        : 'forgeax:session:recent-page';
+    const persistRecent = () => {
+        if (typeof localStorage === 'undefined')
+            return;
+        if (!activeKey)
+            return;
+        const entry = entries.get(activeKey);
+        if (!entry)
+            return;
+        const resolved = registry.get(entry.instance.typeId);
+        if (!resolved || resolved.status !== 'available')
+            return;
+        const policy = resolved.definition.restorePolicy ?? 'never';
+        if (policy === 'never')
+            return;
+        const request = {
+            typeId: entry.instance.typeId,
+            ...(entry.instance.resource ? { resource: entry.instance.resource } : {}),
+            ...(Object.keys(entry.instance.context).length > 0 ? { context: entry.instance.context } : {}),
+        };
+        try {
+            localStorage.setItem(recentKey(policy), JSON.stringify(request));
+        }
+        catch { /* quota/private mode */ }
+    };
+    const publish = () => {
+        generation++;
+        snapshot = {
+            generation,
+            ...(activeKey ? { activeKey } : {}),
+            instances: [...entries.entries()].map(([encoded, entry]) => titles.has(encoded) ? { ...entry.instance, title: titles.get(encoded) } : entry.instance),
+        };
+        for (const listener of [...listeners])
+            listener();
+    };
+    // Reflect a controller's reactive title (getTitle + subscribeTitle) into the
+    // `titles` overlay. Reads the initial value synchronously (so the first
+    // snapshot already carries it) and republishes on every change event.
+    const bindTitle = (encoded, controller) => {
+        const read = () => {
+            const next = controller.getTitle?.();
+            const current = titles.get(encoded);
+            if (next === current)
+                return;
+            if (next === undefined)
+                titles.delete(encoded);
+            else
+                titles.set(encoded, next);
+            if (entries.has(encoded))
+                publish();
+        };
+        const initial = controller.getTitle?.();
+        if (initial !== undefined)
+            titles.set(encoded, initial);
+        if (controller.subscribeTitle) {
+            titleSubs.set(encoded, controller.subscribeTitle(() => read()));
+        }
+    };
+    const unbindTitle = (encoded) => {
+        titleSubs.get(encoded)?.();
+        titleSubs.delete(encoded);
+        titles.delete(encoded);
+    };
+    const requireEntry = (key) => {
+        const normalized = normalizeKey(key);
+        const encoded = encodePageKey(normalized);
+        const entry = entries.get(encoded);
+        if (!entry) {
+            throw new PagePlatformError('PAGE_INSTANCE_NOT_FOUND', `page instance "${encoded}" is not open`, { key: encoded });
+        }
+        return { encoded, entry };
+    };
+    const resolvePreparation = async (entry, reason, decision) => {
+        const preparation = await entry.controller.prepareClose(reason);
+        if (preparation.status === 'ready')
+            return;
+        if (preparation.status === 'vetoed') {
+            throw new PagePlatformError('PAGE_CLOSE_VETOED', preparation.message ?? 'page refused to close', {
+                key: entry.instance.encodedKey,
+                reason,
+            });
+        }
+        if (!decision || decision === 'cancel') {
+            throw new PagePlatformError('PAGE_CLOSE_REQUIRES_DECISION', preparation.message ?? 'page has unsaved changes', { key: entry.instance.encodedKey, reason });
+        }
+        if (decision === 'save') {
+            if (!entry.controller.save) {
+                throw new PagePlatformError('PAGE_CLOSE_VETOED', 'page cannot save its dirty state', {
+                    key: entry.instance.encodedKey,
+                    reason,
+                });
+            }
+            await entry.controller.save();
+        }
+        else {
+            if (!entry.controller.discard) {
+                throw new PagePlatformError('PAGE_CLOSE_VETOED', 'page cannot discard its dirty state', {
+                    key: entry.instance.encodedKey,
+                    reason,
+                });
+            }
+            await entry.controller.discard();
+        }
+    };
+    const session = {
+        async open(request) {
+            const resolved = registry.get(request.typeId);
+            if (!resolved) {
+                throw new PagePlatformError('PAGE_TYPE_NOT_FOUND', `page type "${request.typeId}" is not registered`, {
+                    typeId: request.typeId,
+                });
+            }
+            if (resolved.status === 'unavailable') {
+                throw new PagePlatformError('PAGE_TYPE_UNAVAILABLE', `page type "${request.typeId}" is unavailable`, {
+                    typeId: request.typeId,
+                    reason: resolved.reason,
+                    missingPanelTypeIds: resolved.missingPanelTypeIds,
+                });
+            }
+            let key;
+            if (resolved.definition.cardinality === 'singleton') {
+                if (request.resource || request.instanceId) {
+                    throw new PagePlatformError('PAGE_CARDINALITY_MISMATCH', 'singleton page does not accept resource or instance identity');
+                }
+                key = { cardinality: 'singleton', typeId: request.typeId };
+            }
+            else if (resolved.definition.cardinality === 'resource') {
+                if (!request.resource || request.instanceId) {
+                    throw new PagePlatformError('PAGE_CARDINALITY_MISMATCH', 'resource page requires exactly one resource identity');
+                }
+                key = { cardinality: 'resource', typeId: request.typeId, resourceId: request.resource.canonicalId };
+            }
+            else {
+                if (request.resource) {
+                    throw new PagePlatformError('PAGE_CARDINALITY_MISMATCH', 'multi-instance page does not accept a resource identity');
+                }
+                key = {
+                    cardinality: 'multi-instance',
+                    typeId: request.typeId,
+                    instanceId: request.instanceId ?? createInstanceId(),
+                };
+            }
+            const encoded = encodePageKey(key);
+            if (entries.has(encoded)) {
+                if (activeKey !== encoded) {
+                    activeKey = encoded;
+                    publish();
+                }
+                return key;
+            }
+            const context = request.context ?? {};
+            const controller = await resolved.definition.createController?.({
+                key,
+                context,
+                ...(request.resource ? { resource: request.resource } : {}),
+            }) ?? inertController;
+            const instance = {
+                key,
+                encodedKey: encoded,
+                typeId: request.typeId,
+                context,
+                ...(request.resource ? { resource: request.resource } : {}),
+                openedAt: now(),
+                closable: resolved.definition.closable !== false,
+            };
+            entries.set(encoded, { instance, controller });
+            bindTitle(encoded, controller);
+            activeKey = encoded;
+            publish();
+            persistRecent();
+            return key;
+        },
+        async focus(key) {
+            const { encoded } = requireEntry(key);
+            if (activeKey === encoded)
+                return;
+            activeKey = encoded;
+            publish();
+            persistRecent();
+        },
+        getContextMenuItems(key) {
+            const { entry } = requireEntry(key);
+            return entry.controller.getContextMenuItems?.() ?? [];
+        },
+        reorder(key, toIndex) {
+            const { encoded } = requireEntry(key);
+            const order = [...entries.keys()];
+            const from = order.indexOf(encoded);
+            const to = Math.max(0, Math.min(toIndex, order.length - 1));
+            if (from === to)
+                return;
+            order.splice(to, 0, order.splice(from, 1)[0]);
+            // Rebuild the Map in the new order so the derived snapshot (which reads
+            // insertion order) reflects the move without a parallel ordering field.
+            const moved = order.map((k) => [k, entries.get(k)]);
+            entries.clear();
+            for (const [k, entry] of moved)
+                entries.set(k, entry);
+            publish();
+        },
+        async close(key, request = {}) {
+            const { encoded, entry } = requireEntry(key);
+            const reason = request.reason ?? 'user';
+            if (!entry.instance.closable && reason === 'user') {
+                throw new PagePlatformError('PAGE_CLOSE_VETOED', 'page is permanent and cannot be closed', { key: encoded });
+            }
+            await resolvePreparation(entry, reason, request.decision);
+            await entry.controller.dispose();
+            entries.delete(encoded);
+            unbindTitle(encoded);
+            if (activeKey === encoded)
+                activeKey = [...entries.keys()].at(-1);
+            publish();
+            if (activeKey)
+                persistRecent();
+        },
+        getSnapshot() {
+            return snapshot;
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        async closeOwnedBy(owner, reason = 'extension-disabled', decision) {
+            const owned = [...entries.values()].filter((entry) => registry.ownerOf(entry.instance.typeId) === owner);
+            for (const entry of owned)
+                await resolvePreparation(entry, reason, decision);
+            for (const entry of owned)
+                await entry.controller.dispose();
+            if (owned.length === 0)
+                return;
+            const ownedKeys = new Set(owned.map((entry) => entry.instance.encodedKey));
+            for (const key of ownedKeys) {
+                entries.delete(key);
+                unbindTitle(key);
+            }
+            if (activeKey && ownedKeys.has(activeKey))
+                activeKey = [...entries.keys()].at(-1);
+            publish();
+        },
+        async dispose() {
+            const all = [...entries.values()];
+            for (const entry of all)
+                await resolvePreparation(entry, 'host-dispose', 'discard');
+            for (const entry of all)
+                await entry.controller.dispose();
+            for (const encoded of [...titleSubs.keys()])
+                unbindTitle(encoded);
+            entries.clear();
+            titles.clear();
+            activeKey = undefined;
+            if (all.length > 0)
+                publish();
+            listeners.clear();
+            registryUnsubscribe();
+            projectUnsubscribe();
+        },
+    };
+    const tryRestoreRecent = async () => {
+        if (restoring || entries.size > 0 || typeof localStorage === 'undefined')
+            return;
+        for (const policy of ['project', 'session']) {
+            const key = recentKey(policy);
+            const raw = localStorage.getItem(key);
+            if (!raw)
+                continue;
+            let request;
+            try {
+                request = JSON.parse(raw);
+            }
+            catch {
+                localStorage.removeItem(key);
+                continue;
+            }
+            const resolved = registry.get(request.typeId);
+            if (!resolved)
+                continue;
+            if (resolved.status !== 'available' || (resolved.definition.restorePolicy ?? 'never') !== policy) {
+                localStorage.removeItem(key);
+                continue;
+            }
+            restoring = true;
+            try {
+                await session.open(request);
+            }
+            catch {
+                localStorage.removeItem(key);
+            }
+            finally {
+                restoring = false;
+            }
+            return;
+        }
+    };
+    registryUnsubscribe = registry.subscribe(() => { void tryRestoreRecent(); });
+    projectUnsubscribe = subscribeCurrentProject(() => { void tryRestoreRecent(); });
+    void tryRestoreRecent();
+    return session;
+}

package/dist/package/browser/core/page-platform/types.d.ts

@@ -0,0 +1,242 @@
+import type { PageCardinality, PageErrorCode, PageKey, PageLayoutEnvelope, QualifiedPageTypeId, QualifiedPanelTypeId, QualifiedActivityId, QualifiedResourceEditorId, ResourceDescriptor, ResourceSelector } from '@forgeax/types';
+import type { SerializedDockview } from 'dockview';
+import type { ReactNode } from 'react';
+import type { DetachedWindowCapability } from '@forgeax/app-shell/window';
+export interface PanelRenderContext {
+    readonly pageKey: PageKey;
+    readonly placementId: string;
+    readonly pageContext: Readonly<Record<string, unknown>>;
+    readonly initialProps?: Readonly<Record<string, unknown>>;
+}
+export type PanelRuntime = {
+    readonly kind: 'inline';
+    readonly render: (context: PanelRenderContext) => ReactNode;
+} | {
+    readonly kind: 'iframe';
+    readonly src: string;
+};
+export interface PanelTypeRegistration {
+    readonly id: QualifiedPanelTypeId;
+    readonly runtime: PanelRuntime;
+    /** Complete detached-window target factory. Missing means dock-only. */
+    readonly windowing?: DetachedWindowCapability<PanelRenderContext>;
+}
+export interface PagePanelPlacement {
+    readonly id: string;
+    readonly panelTypeId: QualifiedPanelTypeId;
+    readonly title?: string;
+    readonly optional?: boolean;
+    readonly initialProps?: Readonly<Record<string, unknown>>;
+}
+export type PageCloseReason = 'user' | 'extension-disabled' | 'workspace-change' | 'host-dispose';
+export type PageCloseDecision = 'save' | 'discard' | 'cancel';
+export type PageClosePreparation = {
+    readonly status: 'ready';
+} | {
+    readonly status: 'dirty';
+    readonly message?: string;
+} | {
+    readonly status: 'vetoed';
+    readonly message?: string;
+};
+/**
+ * One right-click menu entry contributed by a page's controller. VSCode-style:
+ * the controller AUTHORS the item (id/label/icon) and OWNS its behaviour
+ * (`run`) and live state (`disabled`), re-evaluated each time the menu opens —
+ * so e.g. a "Save" item can enable only while the page is dirty.
+ */
+export interface PageMenuItem {
+    readonly id: string;
+    readonly label: string;
+    /** Lucide glyph name (kebab, e.g. "copy" / "folder-search"); the tab strip
+     *  resolves it to a lucide-react icon — same glyph set as the design demo. */
+    readonly icon?: string;
+    /** Items sharing a group render contiguously; a divider separates groups (and
+     *  the platform's base close group). */
+    readonly group?: string;
+    readonly disabled?: boolean;
+    run(): void | Promise<void>;
+}
+export interface PageController {
+    prepareClose(reason: PageCloseReason): PageClosePreparation | Promise<PageClosePreparation>;
+    save?(): void | Promise<void>;
+    discard?(): void | Promise<void>;
+    dispose(): void | Promise<void>;
+    /**
+     * Contribute this page's right-click menu items (beyond the platform's base
+     * close group), evaluated freshly on each open so `disabled`/`label` reflect
+     * live state. VSCode `menus`-contribution analogue, owned per instance.
+     */
+    getContextMenuItems?(): readonly PageMenuItem[];
+    /**
+     * Live tab title, VSCode `EditorInput.getName()`-style. When present it
+     * overrides the static page-type title in the tab strip — a resource-less
+     * singleton (e.g. the level editor) has no other per-instance name. Return
+     * `undefined` to fall back to the static title.
+     */
+    getTitle?(): string | undefined;
+    /**
+     * Subscribe to title changes, VSCode `onDidChangeLabel`-style. The session
+     * re-reads `getTitle()` on each notification and republishes the snapshot, so
+     * the tab updates event-driven with zero polling. Returns an unsubscribe fn.
+     */
+    subscribeTitle?(listener: () => void): () => void;
+}
+export interface PageControllerContext {
+    readonly key: PageKey;
+    readonly context: Readonly<Record<string, unknown>>;
+    readonly resource?: ResourceDescriptor;
+}
+export interface PageTypeRegistration {
+    readonly id: QualifiedPageTypeId;
+    readonly title: string;
+    readonly cardinality: PageCardinality;
+    readonly restorePolicy?: 'never' | 'session' | 'project';
+    readonly closable?: boolean;
+    readonly layoutVersion?: number;
+    readonly layout: PageLayoutEnvelope | SerializedDockview;
+    readonly panels: readonly PagePanelPlacement[];
+    readonly createController?: (context: PageControllerContext) => PageController | Promise<PageController>;
+}
+export interface PagePlatformContribution {
+    readonly pageTypes?: readonly PageTypeRegistration[];
+    readonly panelTypes?: readonly PanelTypeRegistration[];
+    readonly activities?: readonly ActivityRegistration[];
+    readonly resourceEditors?: readonly ResourceEditorRegistration[];
+}
+export interface ActivityLocalizedText {
+    readonly zh?: string;
+    readonly en?: string;
+    readonly ja?: string;
+}
+export interface ActivityRegistration {
+    readonly id: QualifiedActivityId;
+    readonly title: string;
+    /** Unresolved manifest text retained so shell chrome reacts to locale changes. */
+    readonly titleI18n?: ActivityLocalizedText;
+    /** Runtime-only localized extension description; not part of manifest contracts. */
+    readonly description?: string;
+    readonly descriptionI18n?: ActivityLocalizedText;
+    readonly icon?: string;
+    readonly category?: string;
+    readonly order?: number;
+    /**
+     * Registration source, injected by the host at the assembly seam — NEVER
+     * self-declared by an extension. It is the primary rail sort key: builtin
+     * activities always precede installed/project ones, so an unranked plugin
+     * can never jump ahead of the core nav. `order` only breaks ties WITHIN a
+     * layer (VSCode `group@order` philosophy — the layer caps the reach of any
+     * plugin's number). Absent ⇒ treated as `installed`.
+     */
+    readonly sourceLayer?: 'builtin' | 'installed' | 'project' | 'user';
+    readonly pageTypeId?: QualifiedPageTypeId;
+    readonly commandId?: string;
+}
+export interface ResourceEditorRegistration {
+    readonly id: QualifiedResourceEditorId;
+    readonly selector: ResourceSelector;
+    readonly pageTypeId: QualifiedPageTypeId;
+    readonly priority?: 'default' | 'optional';
+    readonly sourceLayer?: 'builtin' | 'installed' | 'project' | 'user';
+}
+export interface ActivityRegistrySnapshot {
+    readonly generation: number;
+    readonly activities: readonly (ActivityRegistration & {
+        readonly owner: string;
+    })[];
+}
+export interface ActivityRegistry {
+    getSnapshot(): ActivityRegistrySnapshot;
+    subscribe(listener: () => void): () => void;
+    launch(id: QualifiedActivityId): Promise<void>;
+}
+export interface ResourceEditorResolver {
+    list(resource: ResourceDescriptor): readonly ResourceEditorRegistration[];
+    resolve(resource: ResourceDescriptor): ResourceEditorRegistration | undefined;
+    open(resource: ResourceDescriptor): Promise<PageKey>;
+    setUserAssociation(resource: ResourceDescriptor, editorId: QualifiedResourceEditorId | null): void;
+}
+export interface ResolvedPanelPlacement extends PagePanelPlacement {
+    readonly panelType: PanelTypeRegistration;
+}
+export type ResolvedPageType = {
+    readonly status: 'available';
+    readonly owner: string;
+    readonly definition: PageTypeRegistration;
+    readonly layout: PageLayoutEnvelope | SerializedDockview;
+    readonly panels: readonly ResolvedPanelPlacement[];
+} | {
+    readonly status: 'unavailable';
+    readonly owner: string;
+    readonly definition: PageTypeRegistration;
+    readonly reason: 'missing-required-panel' | 'duplicate-page-type';
+    readonly missingPanelTypeIds: readonly QualifiedPanelTypeId[];
+};
+export interface PageRegistrySnapshot {
+    readonly generation: number;
+    readonly pageTypes: ReadonlyMap<QualifiedPageTypeId, ResolvedPageType>;
+    readonly panelTypes: ReadonlyMap<QualifiedPanelTypeId, PanelTypeRegistration>;
+}
+export interface PageRegistry {
+    get(typeId: QualifiedPageTypeId): ResolvedPageType | undefined;
+    ownerOf(typeId: QualifiedPageTypeId): string | undefined;
+    getSnapshot(): PageRegistrySnapshot;
+    subscribe(listener: () => void): () => void;
+    validateContribution(owner: string, contribution: PagePlatformContribution): void;
+}
+export interface PageOpenRequest {
+    readonly typeId: QualifiedPageTypeId;
+    readonly resource?: ResourceDescriptor;
+    readonly instanceId?: string;
+    readonly context?: Readonly<Record<string, unknown>>;
+}
+export interface PageCloseRequest {
+    readonly reason?: PageCloseReason;
+    readonly decision?: PageCloseDecision;
+}
+export interface PageInstance {
+    readonly key: PageKey;
+    readonly encodedKey: string;
+    readonly typeId: QualifiedPageTypeId;
+    readonly context: Readonly<Record<string, unknown>>;
+    readonly resource?: ResourceDescriptor;
+    readonly openedAt: number;
+    readonly closable: boolean;
+    /**
+     * Live tab title reflected from the page's controller (`getTitle()` +
+     * `subscribeTitle()`), e.g. the level editor tracking the current scene name.
+     * Overrides the static page-type title in the tab strip.
+     */
+    readonly title?: string;
+}
+export interface PageSessionSnapshot {
+    readonly generation: number;
+    readonly activeKey?: string;
+    readonly instances: readonly PageInstance[];
+}
+export interface PagePort {
+    open(request: PageOpenRequest): Promise<PageKey>;
+    focus(key: PageKey | string): Promise<void>;
+    close(key: PageKey | string, request?: PageCloseRequest): Promise<void>;
+    /**
+     * Move an open page to a new position in the tab order. Tab order is session
+     * state (the insertion order of live instances), so reordering lives here —
+     * the SSOT — rather than as UI-local state that would drift from the snapshot.
+     * `toIndex` is clamped to the valid range; a no-op move publishes nothing.
+     */
+    reorder(key: PageKey | string, toIndex: number): void;
+    /**
+     * The right-click menu items contributed by an open page's controller,
+     * evaluated now (fresh live state). Empty when the page has no controller
+     * items — the tab strip always prepends its own base close group.
+     */
+    getContextMenuItems(key: PageKey | string): readonly PageMenuItem[];
+    getSnapshot(): PageSessionSnapshot;
+    subscribe(listener: () => void): () => void;
+}
+export type PagePlatformErrorCode = PageErrorCode;
+export declare class PagePlatformError extends Error {
+    readonly code: PagePlatformErrorCode;
+    readonly details?: Readonly<Record<string, unknown>>;
+    constructor(code: PagePlatformErrorCode, message: string, details?: Readonly<Record<string, unknown>>);
+}

package/dist/package/browser/core/page-platform/types.js

@@ -0,0 +1,10 @@
+export class PagePlatformError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.name = 'PagePlatformError';
+        this.code = code;
+        this.details = details;
+    }
+}

package/dist/package/browser/core/panels/context-expression.d.ts

@@ -0,0 +1 @@
+export { evaluateContextExpression, getContextExpressionKeys } from '@forgeax/extension-platform/platform';

package/dist/package/browser/core/panels/context-expression.js

@@ -0,0 +1 @@
+export { evaluateContextExpression, getContextExpressionKeys } from '@forgeax/extension-platform/platform';

package/dist/package/browser/core/panels/drawer.d.ts

@@ -0,0 +1,23 @@
+import type { ReactNode } from 'react';
+/** The only built-in drawer location today. Adding a side drawer later is a new
+ *  location id + geometry, not a new code path (ADR-0030 §1). */
+export type DrawerLocationId = 'drawer.bottom';
+export interface DrawerPanelContribution {
+    readonly kind?: 'panel';
+    readonly id: string;
+    /** Display title fallback (used verbatim when `titleKey` is absent or its key
+     *  is missing). Keep it a human-readable literal, not an id. */
+    readonly title: string;
+    /** i18n key resolved through `t()` at render time; when set it wins over
+     *  `title`. Built-ins set this; plugins may pass only a literal `title`. */
+    readonly titleKey?: string;
+    /** lucide icon name for the launcher tab (resolved by DrawerHostView). */
+    readonly icon?: string;
+    readonly location?: DrawerLocationId;
+    /** Launcher tab order within the drawer. Lower = earlier. Default 0. */
+    readonly order?: number;
+    /** Conditional visibility of the launcher tab. Missing = always visible. */
+    readonly when?: () => boolean;
+    /** Panel body renderer (in-process). */
+    readonly render: () => ReactNode;
+}

package/dist/package/browser/core/panels/drawer.js

@@ -0,0 +1 @@
+export {};

package/dist/package/browser/core/panels/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types';
+export * from './strip';
+export * from './drawer';
+export * from './context-expression';
+export * from './panel-action-registry';
+export * from './panel-control-registry';
+export * from './resolve-panel-action-state';

package/dist/package/browser/core/panels/index.js

@@ -0,0 +1,7 @@
+export * from './types';
+export * from './strip';
+export * from './drawer';
+export * from './context-expression';
+export * from './panel-action-registry';
+export * from './panel-control-registry';
+export * from './resolve-panel-action-state';

package/dist/package/browser/core/panels/panel-action-registry.d.ts

@@ -0,0 +1,6 @@
+import type { Cleanup } from '../extension-foundation/types';
+import type { PanelActionContribution, PanelActionsApi } from './types';
+export interface PanelActionRegistry extends PanelActionsApi {
+    contribute(owner: string, actions: readonly PanelActionContribution[]): Cleanup;
+}
+export declare function createPanelActionRegistry(): PanelActionRegistry;