@morscherlab/mint-sdk 1.2.0-beta.2 → 1.2.0-beta.20

package/dist/composables/useDropdownState.d.ts

@@ -2,18 +2,34 @@ import { Ref } from 'vue';
 export interface UseDropdownStateOptions {
     closeOnOutsideClick?: boolean;
     closeOnEscape?: boolean;
+    /** Close the panel when the page scrolls or the viewport resizes. Default `false`. */
+    closeOnScroll?: boolean;
     insideRefs?: Array<Ref<HTMLElement | null>>;
+    /**
+     * Element focus returns to when the panel closes with `close(true)` (Escape).
+     * Pass one when the trigger lives outside `rootRef`; otherwise bind the
+     * returned `triggerRef` to the trigger element.
+     */
+    triggerRef?: Ref<HTMLElement | null>;
     onOpen?: () => void;
     onClose?: () => void;
 }
 export interface UseDropdownStateReturn {
     isOpen: Ref<boolean>;
     rootRef: Ref<HTMLElement | null>;
+    /** Bind to the trigger element so Escape can return focus to it. */
+    triggerRef: Ref<HTMLElement | null>;
     open: () => void;
-    close: () => void;
+    /** Closes the panel; `returnFocus` moves focus back to `triggerRef`. */
+    close: (returnFocus?: boolean) => void;
     toggle: () => void;
     handleClickOutside: (event: MouseEvent) => void;
     handleKeydown: (event: KeyboardEvent) => void;
 }
-/** Shared disclosure state for dropdown-style SDK components. */
+/**
+ * Shared disclosure state for dropdown-style SDK components: open/close state,
+ * outside-click and Escape closing, optional scroll/resize closing, and focus
+ * return to the trigger. `close(returnFocus)` mirrors `useMenuKeyboard`'s
+ * contract, so the two compose directly.
+ */
 export declare function useDropdownState(options?: UseDropdownStateOptions): UseDropdownStateReturn;

package/dist/composables/useEventStream.d.ts

@@ -12,7 +12,16 @@ export interface EventStreamOptions<TData = string> {
     headers?: HeadersInit;
     credentials?: RequestCredentials;
     immediate?: boolean;
+    /**
+     * Reconnect after a dropped stream. Left unset, it follows the platform's
+     * `wsAutoReconnect` setting, defaulting to `true` without a settings store.
+     */
     reconnect?: boolean;
+    /**
+     * Delay before the first reconnect attempt. Left unset, it follows the
+     * platform's `wsReconnectInterval` setting, defaulting to 2000 ms without a
+     * settings store. A server-sent `retry:` field still overrides it.
+     */
     reconnectDelayMs?: number;
     parseJson?: boolean;
     shouldReconnect?: (cause?: unknown) => boolean;

package/dist/composables/useFileBrowser.d.ts

@@ -0,0 +1,55 @@
+import { ComputedRef, MaybeRefOrGetter, Ref } from 'vue';
+import { FileBrowserSortKey, FileEntry, FilePathCrumb, FileSelection, ServerMount } from '../types/fileBrowserTypes';
+export interface UseFileBrowserOptions {
+    /** Extensions the caller cares about; entries are flagged, never removed. */
+    typeRules?: MaybeRefOrGetter<string[] | undefined>;
+    /** Mount to open first; defaults to the first available one. */
+    initialMountId?: MaybeRefOrGetter<string | undefined>;
+    /** Override the platform API base URL (standalone plugin dev). */
+    apiBaseUrl?: string;
+}
+export interface UseFileBrowserReturn {
+    /** Every configured mount, offline ones included. */
+    mounts: Ref<ServerMount[]>;
+    /** Mount the current listing belongs to. */
+    mountId: Ref<string>;
+    /** Mount-relative path of the current listing. */
+    path: Ref<string>;
+    /** Parent path, or null at a mount root. */
+    parent: Ref<string | null>;
+    entries: Ref<FileEntry[]>;
+    breadcrumbs: Ref<FilePathCrumb[]>;
+    /** Directory size before any search filter. */
+    totalCount: Ref<number | null>;
+    /** How many entries satisfy the type rules. */
+    matchCount: Ref<number | null>;
+    /** How many rows this listing carries, after search and any cap. */
+    shownCount: Ref<number | null>;
+    /** True when the server capped the listing. */
+    truncated: Ref<boolean>;
+    search: Ref<string>;
+    sort: Ref<FileBrowserSortKey>;
+    /** Controlled selection, ready to bind to FileBrowserModal. */
+    selected: Ref<FileSelection[]>;
+    isLoading: ComputedRef<boolean>;
+    error: Ref<string | null>;
+    /** Load the mount list and open the first available mount. */
+    init: () => Promise<void>;
+    /** Open a directory, or a mount root when path is empty. */
+    navigate: (location: {
+        mount_id: string;
+        path: string;
+    }) => Promise<void>;
+    /** Re-read the current directory. */
+    refresh: () => Promise<void>;
+    /** Take the directory currently being viewed as the input. */
+    selectCurrentFolder: () => void;
+    clear: () => void;
+}
+/**
+ * Drives FileBrowserModal against the platform's `/api/filesystem` routes.
+ *
+ * Requires the `filesystem.browse` permission and a deployment that declares
+ * mounts; with none configured the routes are absent and `mounts` stays empty.
+ */
+export declare function useFileBrowser(options?: UseFileBrowserOptions): UseFileBrowserReturn;

package/dist/composables/useFilePicker.d.ts

@@ -0,0 +1,189 @@
+import { PickerAdapter, PickerCapabilities, PickerNode, PickerSelection, PickerSelectionMode, PickerSource } from '../types/filePicker';
+interface PickerStateProps {
+    open: boolean;
+    adapter: PickerAdapter;
+    selectionMode: PickerSelectionMode;
+    sources: PickerSource[];
+    capabilities: PickerCapabilities;
+    initialPath: string;
+    initialSelection: PickerSelection | null;
+    systemFilter?: (node: PickerNode, source: PickerSource) => boolean;
+}
+type PickerEmit = {
+    (event: 'update:open', value: boolean): void;
+    (event: 'select', value: PickerSelection): void;
+    (event: 'cancel'): void;
+};
+/** Internal orchestration; public consumers use FilePicker's props and events. */
+export declare function useFilePicker(props: PickerStateProps, emit: PickerEmit): {
+    previewNode: import('vue').ComputedRef<PickerNode>;
+    sourceNames: Record<PickerSource, string>;
+    sourceIcons: Record<PickerSource, string>;
+    allowedSources: import('vue').ComputedRef<PickerSource[]>;
+    source: import('vue').ShallowRef<PickerSource, PickerSource>;
+    query: import('vue').ShallowRef<string, string>;
+    recursive: import('vue').ShallowRef<boolean, boolean>;
+    skipBlanks: import('vue').ShallowRef<boolean, boolean>;
+    reviewing: import('vue').ShallowRef<boolean, boolean>;
+    nav: {
+        path: import('vue').ShallowRef<string, string>;
+        trail: import('vue').Ref<{
+            path: string;
+            label: string;
+        }[], {
+            path: string;
+            label: string;
+        }[] | {
+            path: string;
+            label: string;
+        }[]>;
+        entries: import('vue').ShallowRef<PickerNode[], PickerNode[]>;
+        nodes: import('vue').Ref<Map<string, {
+            kind: "folder";
+            fileCount?: number | null | undefined;
+            formats?: Record<string, number> | undefined;
+            hasChildren?: boolean | undefined;
+            path: string;
+            name: string;
+            parentPath?: string | null | undefined;
+            parentName?: string | undefined;
+            bytes?: number | null | undefined;
+            unavailableReason?: string | undefined;
+        } | {
+            kind: "file";
+            format: string;
+            file?: {
+                readonly lastModified: number;
+                readonly name: string;
+                readonly webkitRelativePath: string;
+                readonly size: number;
+                readonly type: string;
+                arrayBuffer: () => Promise<ArrayBuffer>;
+                bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+                slice: (start?: number, end?: number, contentType?: string) => Blob;
+                stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+                text: () => Promise<string>;
+            } | undefined;
+            path: string;
+            name: string;
+            parentPath?: string | null | undefined;
+            parentName?: string | undefined;
+            bytes?: number | null | undefined;
+            unavailableReason?: string | undefined;
+        }> & Omit<Map<string, PickerNode>, keyof Map<any, any>>, Map<string, PickerNode> | (Map<string, {
+            kind: "folder";
+            fileCount?: number | null | undefined;
+            formats?: Record<string, number> | undefined;
+            hasChildren?: boolean | undefined;
+            path: string;
+            name: string;
+            parentPath?: string | null | undefined;
+            parentName?: string | undefined;
+            bytes?: number | null | undefined;
+            unavailableReason?: string | undefined;
+        } | {
+            kind: "file";
+            format: string;
+            file?: {
+                readonly lastModified: number;
+                readonly name: string;
+                readonly webkitRelativePath: string;
+                readonly size: number;
+                readonly type: string;
+                arrayBuffer: () => Promise<ArrayBuffer>;
+                bytes: () => Promise<Uint8Array<ArrayBuffer>>;
+                slice: (start?: number, end?: number, contentType?: string) => Blob;
+                stream: () => ReadableStream<Uint8Array<ArrayBuffer>>;
+                text: () => Promise<string>;
+            } | undefined;
+            path: string;
+            name: string;
+            parentPath?: string | null | undefined;
+            parentName?: string | undefined;
+            bytes?: number | null | undefined;
+            unavailableReason?: string | undefined;
+        }> & Omit<Map<string, PickerNode>, keyof Map<any, any>>)>;
+        children: import('vue').ShallowRef<Map<string, PickerNode[]>, Map<string, PickerNode[]>>;
+        expanded: import('vue').Ref<Set<string> & Omit<Set<string>, keyof Set<any>>, Set<string> | (Set<string> & Omit<Set<string>, keyof Set<any>>)>;
+        expanding: import('vue').Ref<Set<string> & Omit<Set<string>, keyof Set<any>>, Set<string> | (Set<string> & Omit<Set<string>, keyof Set<any>>)>;
+        expansionErrors: import('vue').Ref<Map<string, string> & Omit<Map<string, string>, keyof Map<any, any>>, Map<string, string> | (Map<string, string> & Omit<Map<string, string>, keyof Map<any, any>>)>;
+        loading: import('vue').ShallowRef<boolean, boolean>;
+        error: import('vue').ShallowRef<string, string>;
+        rows: import('vue').ComputedRef<import('..').PickerTreeRow[]>;
+        isAllowed: (node: PickerNode) => boolean;
+        clear: () => void;
+        invalidate: () => void;
+        register: (items: PickerNode[], parent?: string) => void;
+        loadChildren: (folder: string, ancestors?: string[], refresh?: boolean) => Promise<PickerNode[]>;
+        load: (query?: string, recursive?: boolean, refresh?: boolean) => Promise<void>;
+        expand: (node: PickerNode) => Promise<void>;
+        enter: (node: PickerNode) => void;
+        up: (target?: string) => void;
+    };
+    selection: {
+        keys: import('vue').Ref<Set<string> & Omit<Set<string>, keyof Set<any>>, Set<string> | (Set<string> & Omit<Set<string>, keyof Set<any>>)>;
+        dropped: import('vue').Ref<Set<string> & Omit<Set<string>, keyof Set<any>>, Set<string> | (Set<string> & Omit<Set<string>, keyof Set<any>>)>;
+        focusPath: import('vue').ShallowRef<string, string>;
+        resolving: import('vue').ShallowRef<boolean, boolean>;
+        resolutionError: import('vue').ShallowRef<string, string>;
+        roots: import('vue').ComputedRef<PickerNode[]>;
+        chosen: import('vue').ComputedRef<{
+            files: import('..').PickerFile[];
+            excluded: import('..').PickerExcluded[];
+            bytes: number;
+        }>;
+        focused: import('vue').ComputedRef<PickerNode>;
+        select: (node: PickerNode, modifiers?: {
+            metaKey?: boolean;
+            ctrlKey?: boolean;
+            shiftKey?: boolean;
+            toggle?: boolean;
+        }) => void;
+        selected: (node: PickerNode) => boolean;
+        selectable: (node: PickerNode) => boolean;
+        exclusion: (node: PickerNode) => import('..').PickerExcluded | null;
+        reset: (selection?: PickerSelection | null) => void;
+        resolve: () => Promise<void>;
+        folderProgress: (node: PickerNode) => string;
+        ancestorSelected: (node: PickerNode, candidates?: Set<string> & Omit<Set<string>, keyof Set<any>>) => boolean;
+    };
+    capability: import('vue').ComputedRef<import('..').PickerCapability | undefined>;
+    path: import('vue').ShallowRef<string, string>;
+    trail: import('vue').Ref<{
+        path: string;
+        label: string;
+    }[], {
+        path: string;
+        label: string;
+    }[] | {
+        path: string;
+        label: string;
+    }[]>;
+    loading: import('vue').ShallowRef<boolean, boolean>;
+    error: import('vue').ShallowRef<string, string>;
+    rows: import('vue').ComputedRef<import('..').PickerTreeRow[]>;
+    roots: import('vue').ComputedRef<PickerNode[]>;
+    chosen: import('vue').ComputedRef<{
+        files: import('..').PickerFile[];
+        excluded: import('..').PickerExcluded[];
+        bytes: number;
+    }>;
+    focused: import('vue').ComputedRef<PickerNode>;
+    resolving: import('vue').ShallowRef<boolean, boolean>;
+    resolutionError: import('vue').ShallowRef<string, string>;
+    searchArea: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    confirmLabel: import('vue').ComputedRef<string>;
+    folderCount: import('vue').ComputedRef<number>;
+    canConfirm: import('vue').ComputedRef<boolean>;
+    switchSource: (next: PickerSource) => Promise<void>;
+    selectNode: (node: PickerNode, event: MouseEvent | KeyboardEvent) => void;
+    enter: (node: PickerNode) => Promise<void>;
+    up: (target?: string) => Promise<void>;
+    refresh: () => Promise<void>;
+    selectParent: (node: PickerNode) => void;
+    chooseLocal: (files: File[], _rootName?: string, relativePaths?: string[]) => Promise<void>;
+    cancel: () => void;
+    confirm: () => void;
+    keyboard: (event: KeyboardEvent) => void;
+};
+export {};

package/dist/composables/useFocusTrap.d.ts

@@ -0,0 +1,21 @@
+import { Ref } from 'vue';
+export interface UseFocusTrapOptions {
+    /** Ref to the trap's container element. Focusable elements are queried within it. */
+    containerRef: Ref<HTMLElement | null>;
+    /** Reactive flag — the trap activates when this becomes `true` and releases when it becomes `false`. */
+    active: Ref<boolean>;
+    /** Restore focus to the element that was focused before activation, when the trap releases. Default `true`. */
+    restoreFocus?: boolean;
+}
+export interface UseFocusTrapReturn {
+    /** Focusable descendants of the container, in DOM order, excluding roving-tabindex (`tabindex="-1"`) elements. */
+    getFocusableElements: () => HTMLElement[];
+}
+/**
+ * Traps Tab focus within a container while `active` is true: Tab wraps from the last
+ * focusable element back to the first (and Shift+Tab from the first to the last), the
+ * first focusable element (or the container itself, if none) receives focus when the
+ * trap activates, and focus returns to whatever was focused beforehand when it releases.
+ * Used by BaseModal and WellEditPopupInternal.
+ */
+export declare function useFocusTrap(options: UseFocusTrapOptions): UseFocusTrapReturn;

package/dist/composables/useGeneratedAnalysis.d.ts

@@ -1,5 +1,5 @@
 import { ComputedRef, Ref, ShallowRef } from 'vue';
-import { PluginJobCenterSource } from './useJobsStatusTray';
+import { JobsStatusTrayAdapter, PluginJobCenterSource } from './useJobsStatusTray';
 import { GeneratedAnalysisJob, GeneratedAnalysisResult, GeneratedSession, GeneratedAnalysisManifest, PluginJobPathInput, PluginJobPathUpload, PluginJobStagedPartInput, PluginJobStagedPartUploadResult, PluginJobStaging, PluginJobStagingPagination } from '../types/generated-ui';
 export type GeneratedAnalysisTransport = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
 export interface GeneratedAnalysisTransportOptions {
@@ -53,6 +53,8 @@ export interface UsePluginJobsReturn extends PluginJobCenterSource {
     pause: () => void;
     resume: () => void;
     dispose: () => void;
+    /** @deprecated Pass the runtime itself to SDK job UI as its source. */
+    jobsAdapter: JobsStatusTrayAdapter;
 }
 export type UseGeneratedAnalysisReturn = UsePluginJobsReturn;
 export declare function createGeneratedAnalysisTransport(options?: GeneratedAnalysisTransportOptions): GeneratedAnalysisTransport;

package/dist/composables/useJobsStatusTray.d.ts

@@ -1,5 +1,6 @@
 import { ComputedRef, MaybeRefOrGetter, Ref, ShallowRef } from 'vue';
-import { JobListPayload, JobState, JobStateInput } from '../types/jobs';
+import { JobListPayload, JobState, JobStateInput, JobStreamData } from '../types/jobs';
+import { UsePluginEventStreamReturn } from './usePluginClient';
 export type JobsStatusTrayTab = 'active' | 'history';
 /**
  * The canonical owner of a collection of plugin jobs.
@@ -26,10 +27,29 @@ export interface CombinedPluginJobCenterSource extends PluginJobCenterSource {
  * dispatching a mutation to the wrong owner.
  */
 export declare function combinePluginJobSources(sources: readonly PluginJobCenterSource[]): CombinedPluginJobCenterSource;
+/** @deprecated Prefer a {@link PluginJobCenterSource}. */
+export interface JobsStatusTrayAdapter {
+    listJobs?: () => Promise<JobListPayload | readonly JobStateInput[]>;
+    cancelJob?: (job: JobState) => Promise<JobStateInput | void>;
+    deleteJob?: (job: JobState) => Promise<boolean | void>;
+    clearFinishedJobs?: (jobs: readonly JobState[]) => Promise<number | void>;
+}
 export interface UsePluginJobCenterOptions {
     source?: MaybeRefOrGetter<PluginJobCenterSource | undefined>;
+    /** @deprecated Pass a source with its canonical jobs ref. */
+    jobs?: MaybeRefOrGetter<readonly JobStateInput[] | undefined>;
+    /** @deprecated Pass source actions instead. */
+    adapter?: MaybeRefOrGetter<JobsStatusTrayAdapter | undefined>;
+    /** @deprecated Event handling belongs to the source runtime. */
+    eventStream?: MaybeRefOrGetter<UsePluginEventStreamReturn<JobStreamData> | undefined>;
     loadOnMount?: boolean;
 }
+export interface UseJobsStatusTrayOptions extends UsePluginJobCenterOptions {
+}
+export interface JobStreamMessage {
+    event: string;
+    data: JobStreamData;
+}
 export interface UsePluginJobCenterReturn {
     jobs: ComputedRef<JobState[]>;
     activeJobs: ComputedRef<JobState[]>;
@@ -49,11 +69,13 @@ export interface UsePluginJobCenterReturn {
     close: () => void;
     toggle: () => void;
     refresh: () => Promise<boolean>;
+    applyStreamMessage: (message: JobStreamMessage) => void;
     cancelJob: (job: JobState) => Promise<boolean>;
     deleteJob: (job: JobState) => Promise<boolean>;
     clearFinished: () => Promise<boolean>;
     isPending: (job: JobState) => boolean;
 }
+export type UseJobsStatusTrayReturn = UsePluginJobCenterReturn;
 /**
  * Headless controller for plugin job presentation and actions.
  *
@@ -61,3 +83,5 @@ export interface UsePluginJobCenterReturn {
  * source. The controller never mirrors source jobs into another ref.
  */
 export declare function usePluginJobCenter(options?: UsePluginJobCenterOptions): UsePluginJobCenterReturn;
+/** @deprecated Use `usePluginJobCenter()` for the plugin job-center controller. */
+export declare function useJobsStatusTray(options?: UseJobsStatusTrayOptions): UseJobsStatusTrayReturn;

package/dist/composables/useListReorder.d.ts

@@ -0,0 +1,90 @@
+import { Ref } from 'vue';
+/** Inline style for a visually hidden `aria-live` region (no global utility class in the SDK). */
+export declare const REORDER_ANNOUNCER_STYLE: Readonly<{
+    position: "absolute";
+    width: "1px";
+    height: "1px";
+    padding: "0";
+    margin: "-1px";
+    overflow: "hidden";
+    clip: "rect(0, 0, 0, 0)";
+    whiteSpace: "nowrap";
+    border: "0";
+}>;
+export interface UseReorderAnnouncerReturn {
+    /** Bind to a polite live region's text content. */
+    announcement: Ref<string>;
+    /** Publishes a message to the live region. */
+    announce: (message: string) => void;
+    /** Bind to the live region's `style` so it stays visually hidden. */
+    announcerStyle: typeof REORDER_ANNOUNCER_STYLE;
+}
+/**
+ * Screen-reader announcements for drag/keyboard move interactions. Bind
+ * `announcement` to a `role="status" aria-live="polite"` element styled with
+ * `announcerStyle`.
+ */
+export declare function useReorderAnnouncer(): UseReorderAnnouncerReturn;
+export interface ListReorderMove<T> {
+    /** Index the item moved from, within `items()`. */
+    fromIndex: number;
+    /** Index the item moved to, within `items()`. */
+    toIndex: number;
+    /** The reordered array (a copy — `items()` is never mutated). */
+    items: T[];
+    /** Whether the move came from the keyboard or a pointer drag. */
+    source: 'keyboard' | 'drag';
+}
+export interface UseListReorderOptions<T> {
+    /** The list being reordered, in its canonical (not merely rendered) order. */
+    items: () => T[];
+    /** Stable id for an item; falls back to the render index when ids repeat. */
+    getId: (item: T, index: number) => string;
+    /** Applies the move. The composable never mutates the source array. */
+    onReorder: (move: ListReorderMove<T>) => void;
+    /** Human-readable name used in announcements. Defaults to the item's id. */
+    getLabel?: (item: T, index: number) => string;
+    /** Blocks every reorder while it returns `true` (readonly / non-sortable lists). */
+    disabled?: () => boolean;
+    /** Resolves the focusable element for an id so keyboard moves keep focus on the item. */
+    getElement?: (id: string) => HTMLElement | null | undefined;
+    /** Noun used in announcements, e.g. `'Reagent'`. Default `'Item'`. */
+    itemNoun?: string;
+}
+export interface UseListReorderReturn<T> {
+    /** Id of the item currently being dragged, or `null`. */
+    draggingId: Ref<string | null>;
+    /** Id of the item the pointer is hovering as a drop target, or `null`. */
+    dragOverId: Ref<string | null>;
+    isDragging: (id: string) => boolean;
+    isDragOver: (id: string) => boolean;
+    announcement: Ref<string>;
+    announcerStyle: typeof REORDER_ANNOUNCER_STYLE;
+    announce: (message: string) => void;
+    /** Bind to the draggable element's `@dragstart`. */
+    onDragStart: (event: DragEvent, item: T, index: number) => void;
+    /** Bind to `@dragover` — calls `preventDefault()` so the drop is accepted. */
+    onDragOver: (event: DragEvent, item: T, index: number) => void;
+    /** Bind to `@dragleave`. */
+    onDragLeave: () => void;
+    /** Bind to `@drop`. */
+    onDrop: (event: DragEvent, item: T, index: number) => void;
+    /** Bind to `@dragend`. */
+    onDragEnd: () => void;
+    /**
+     * Bind to the item's (or its drag handle's) `@keydown`: Alt+ArrowUp / Alt+ArrowLeft
+     * moves the item one position earlier, Alt+ArrowDown / Alt+ArrowRight one later.
+     */
+    onKeydown: (event: KeyboardEvent, item: T, index: number) => void;
+    /** Moves an item between two indices of `items()` programmatically. */
+    move: (fromIndex: number, toIndex: number, source?: 'keyboard' | 'drag') => void;
+}
+/** Pure helper: a copy of `items` with the entry at `from` moved to `to`. */
+export declare function reorderList<T>(items: T[], from: number, to: number): T[];
+/**
+ * Keyboard-accessible list reordering shared by the SDK's drag-to-reorder lists.
+ * It owns the HTML5 drag state, the drop-index maths, and an Alt+Arrow keyboard
+ * alternative that announces every move through a polite live region — so a
+ * reorder never depends on a pointer.
+ */
+export declare function useListReorder<T>(options: UseListReorderOptions<T>): UseListReorderReturn<T>;

package/dist/composables/useMenuKeyboard.d.ts

@@ -0,0 +1,29 @@
+export interface UseMenuKeyboardOptions {
+    /** Returns the currently navigable items inside the open panel, in DOM order. */
+    items: () => HTMLElement[];
+    /** True while the panel is open. */
+    isOpen: () => boolean;
+    /** Opens the panel. */
+    open: () => void;
+    /** Closes the panel. When `returnFocus` is true, focus should return to the trigger. */
+    close: (returnFocus?: boolean) => void;
+}
+export interface UseMenuKeyboardReturn {
+    /**
+     * Bind to the trigger's `@keydown`. ArrowDown/Enter/Space open the panel (when
+     * closed) and focus its first item; ArrowUp opens it focused on the last item.
+     */
+    handleTriggerKeydown: (event: KeyboardEvent) => void;
+    /**
+     * Bind to the open panel's `@keydown`. ArrowUp/ArrowDown cycle focus with
+     * wraparound, Home/End jump to the first/last item, Escape closes and returns
+     * focus to the trigger, and Tab closes without moving focus.
+     */
+    handlePanelKeydown: (event: KeyboardEvent) => void;
+}
+/**
+ * Shared keyboard contract for menu- and listbox-style disclosure panels (the
+ * WAI-ARIA menu button pattern). Used by ActionMenu, AppAvatarMenu and DropdownButton,
+ * each pairing it with `useDropdownState` for the disclosure state itself.
+ */
+export declare function useMenuKeyboard(options: UseMenuKeyboardOptions): UseMenuKeyboardReturn;

package/dist/composables/useOptimisticMutation.d.ts

@@ -24,5 +24,9 @@ export interface UseOptimisticMutationReturn<TVariables, TData, TSnapshot = unkn
     clearError: () => void;
     reset: () => void;
 }
-/** Run async mutations with optional optimistic local updates and rollback. */
+/**
+ * Run async mutations with optional optimistic local updates and rollback.
+ *
+ * @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `useRequestSyncState()` instead.
+ */
 export declare function useOptimisticMutation<TVariables, TData, TSnapshot = unknown>(options: UseOptimisticMutationOptions<TVariables, TData, TSnapshot>): UseOptimisticMutationReturn<TVariables, TData, TSnapshot>;

package/dist/composables/usePlatformFilePickerAdapter.d.ts

@@ -0,0 +1,11 @@
+import { PickerAdapter } from '../types/filePicker';
+/** Opaque picker identity; decode before passing a selection to a mount-scoped API. */
+export declare function encodePlatformPickerPath(mountId: string, path?: string): string;
+export declare function decodePlatformPickerPath(path: string): {
+    mountId: string;
+    path: string;
+};
+/** Adapt the authenticated MINT mount API without exposing absolute host paths. */
+export declare function usePlatformFilePickerAdapter(options?: {
+    apiBaseUrl?: string;
+}): PickerAdapter;

package/dist/composables/usePluginClient.d.ts

@@ -209,6 +209,8 @@ export declare function createPluginClient<TClient extends object = GeneratedPlu
 export declare function uploadPluginEndpoint<TResponse = unknown>(contract: PluginContract, endpoint: PluginEndpointDefinition, payload?: unknown, options?: PluginEndpointRequestOptions): Promise<TResponse>;
 /** Fetch a generated plugin endpoint as a Blob and optionally trigger a browser download. */
 export declare function downloadPluginEndpoint(contract: PluginContract, endpoint: PluginEndpointDefinition, payload?: unknown, options?: DownloadPluginEndpointOptions): Promise<Blob>;
+/** @deprecated Use `useGeneratedPluginClient()` for generated clients. */
+export declare function usePluginClient<TClient>(client: TClient): TClient;
 /** Load, edit, and persist plugin settings from platform config or the plugin-local settings router. */
 export declare function usePluginSettings<TSettings = Record<string, unknown>>(options?: UsePluginSettingsOptions | string): UsePluginSettingsReturn<TSettings>;
 /** Consume a generated plugin SSE endpoint with auth headers, reconnect, and teardown. */

package/dist/composables/usePluginConfig.d.ts

@@ -0,0 +1,27 @@
+import { Ref, ComputedRef } from 'vue';
+export interface UsePluginConfigReturn {
+    /** Editable plugin configuration values. */
+    config: Ref<Record<string, unknown>>;
+    /** Whether the config is currently loading. */
+    isLoading: Ref<boolean>;
+    /** Whether the config is currently saving. */
+    isSaving: Ref<boolean>;
+    /** Error message from the last failed operation, or null. */
+    error: Ref<string | null>;
+    /** Timestamp of the last successful load, or null. */
+    lastLoadedAt: Ref<Date | null>;
+    /** Timestamp of the last successful save, or null. */
+    lastSavedAt: Ref<Date | null>;
+    /** Whether local config differs from the last loaded or saved snapshot. */
+    isDirty: ComputedRef<boolean>;
+    /** Load plugin configuration from the platform. */
+    load: () => Promise<void>;
+    /** Save plugin configuration to the platform. */
+    save: () => Promise<boolean>;
+    /** Restore the last loaded or saved configuration snapshot. */
+    reset: () => void;
+}
+/**
+ * @deprecated Unused by the MINT platform and scheduled for removal in MINT 1.3; use `usePluginSettings()` for typed plugin settings.
+ */
+export declare function usePluginConfig(pluginName?: string): UsePluginConfigReturn;

package/dist/composables/usePluginWorkspace.d.ts

@@ -0,0 +1,51 @@
+import { ComputedRef } from 'vue';
+import { PageSelectorItem, PillNavItem } from '../types';
+import { PluginWorkspaceViewEmit, PluginWorkspaceViewProps } from '../components/PluginWorkspaceView.props';
+import { PluginWorkspaceControlsModel, PluginWorkspaceShellModel, PluginWorkspaceSidebarModel } from './pluginWorkspaceModel';
+/**
+ * Loosely-typed view of a component's `useSlots()` result: only slot presence and names are
+ * read here, so this accepts any `defineSlots()` shape without fighting Vue's `Slot` render
+ * function type. Mirrors the `SlotKeyMap` helper type in PluginWorkspaceView.shell.ts.
+ */
+export type PluginWorkspaceSlotsLike = Readonly<Record<string, unknown>>;
+export interface UsePluginWorkspaceOptions {
+    /** PluginWorkspaceView's own reactive props object (from `defineProps`). */
+    props: PluginWorkspaceViewProps;
+    /** PluginWorkspaceView's own slots (from `useSlots()`), used to detect provided passthrough slots. */
+    slots: PluginWorkspaceSlotsLike;
+    /** PluginWorkspaceView's own typed `emit` function (from `defineEmits<PluginWorkspaceViewEmits>()`). */
+    emit: PluginWorkspaceViewEmit;
+}
+export interface UsePluginWorkspaceReturn {
+    /** Model consumed by WorkspaceShellInternal's `shell` prop. */
+    shell: ComputedRef<PluginWorkspaceShellModel>;
+    /** Model consumed by WorkspaceSidebarInternal's `sidebar` prop. */
+    sidebar: ComputedRef<PluginWorkspaceSidebarModel>;
+    /** Model consumed by WorkspaceControlsInternal's `controls` prop, and by the raw `default` slot. */
+    controls: ComputedRef<PluginWorkspaceControlsModel>;
+    /** Whether AppLayout should render a sidebar surface at all. */
+    hasSidebarSurface: ComputedRef<boolean>;
+    /** Applies an AppSidebar `update:model-value` payload to the shared control values and emits `update:modelValue`/`update:values`. */
+    handleControlValuesUpdate: (values: Record<string, unknown>) => void;
+    /** Resolves an AppTopBar `page-selector-select` payload into the active view and emits `page-selector-select`. */
+    handlePageSelectorSelect: (page: PageSelectorItem) => void;
+    /** Resolves an AppTopBar `pill-select` payload into the active view and emits `pill-select`. */
+    handlePillSelect: (item: PillNavItem) => void;
+}
+/**
+ * Maps PluginWorkspaceView's flat 72-prop surface into the three typed model objects
+ * (`shell`, `sidebar`, `controls`) rendered by its internal pieces
+ * (WorkspaceShellInternal, WorkspaceSidebarInternal, WorkspaceControlsInternal). Reuses the
+ * existing `usePluginWorkspaceControls` / `usePluginWorkspaceNavigation` composables and the
+ * PluginWorkspaceView.shell slot-detection helpers, so it changes only how that state is
+ * assembled and exposed, not the underlying behavior.
+ *
+ * @example Recommended
+ * ```ts
+ * const props = withDefaults(defineProps<PluginWorkspaceViewProps>(), { ... })
+ * const emit = defineEmits<PluginWorkspaceViewEmits>()
+ * const slots = useSlots()
+ * const { shell, sidebar, controls } = usePluginWorkspace({ props, slots, emit })
+ * ```
+ */
+export declare function usePluginWorkspace(options: UsePluginWorkspaceOptions): UsePluginWorkspaceReturn;