@morscherlab/mint-sdk 1.3.11 → 1.4.0-beta.10

package/dist/composables/pluginWorkspaceModel.d.ts

@@ -1,16 +1,15 @@
-import { AccountMenuItem, PageSelectorItemInput, PillNavItemInput, SidebarToolSection, TopBarSettingsConfig, TopBarVariant } from '../types';
-import { FormEnhancements, FormSchema } from '../types/form-builder';
-import { ControlComponentBinding, ControlComponentBindingsById, ControlModel, ControlModelBinding, ControlSchema, ControlWorkspaceOptions } from './useControlSchema';
+import { PluginWorkspaceSidebarSpec, PluginWorkspaceTopBarSpec } from '../types';
+import { ControlComponentBinding, ControlComponentBindingsById } from './useControlSchema';
 /**
  * Scoped-slot payload shared by PluginWorkspaceView's `default`, `topbar`, and `sidebar`
  * slots: the resolved active view plus the values and component bindings/props derived
- * from the compact control schema. WorkspaceControlsInternal renders a component's default
+ * from the sidebar control model. WorkspaceControlsInternal renders a component's default
  * slot bound to exactly this shape.
  */
 export interface PluginWorkspaceControlsModel {
     /** Currently resolved workspace view id. */
     activeView: string;
-    /** Sets the active view, updating any uncontrolled state and emitting `update:activeView`. */
+    /** Sets the active view, updating any uncontrolled state and emitting `update:view`. */
     setActiveView: (viewId: string) => void;
     /** Current control values, shared between the auto-rendered sidebar form and the default slot. */
     values: Record<string, unknown>;
@@ -25,8 +24,8 @@ export interface PluginWorkspaceControlsModel {
 }
 /**
  * Resolved AppLayout + AppTopBar configuration consumed by WorkspaceShellInternal: top bar
- * chrome and navigation, plus the AppLayout layout/collapse props that own the responsive
- * mobile sidebar toggle.
+ * spec and active pill, plus the AppLayout layout props that own the responsive mobile
+ * sidebar toggle.
  */
 export interface PluginWorkspaceShellModel {
     /** AppLayout sidebar position. */
@@ -43,117 +42,35 @@ export interface PluginWorkspaceShellModel {
     sidebarCloseLabel: string;
     /** Whether AppLayout should render a `#sidebar` template at all. */
     hasSidebarSurface: boolean;
-    /** App or plugin title shown in the top bar. */
-    title: string;
+    /** Top bar title. Unset, the top bar shows the plugin identity (`providePluginIdentity` or the platform). */
+    title?: string;
     /** Secondary copy shown under the title. */
     subtitle?: string;
-    /** Top bar visual treatment. */
-    topBarVariant: TopBarVariant;
-    /** Home link used by the top bar brand icon. */
-    homePath: string;
-    /** Show the default MINT logo when no icon/logo slot is provided. */
-    showLogo: boolean;
-    /** Preferred route-level page selector entries. */
-    pageSelector?: PageSelectorItemInput[];
-    /** Resolved active page selector id. */
-    currentPageSelectorId: string;
-    /** Resolved centered pill navigation, generated from the control schema when omitted. */
-    pillNav?: PillNavItemInput[];
+    /** AppTopBar spec with the workspace defaults applied and the generated pills filled in; `false` removes the top bar. */
+    topBar: false | PluginWorkspaceTopBarSpec;
     /** Resolved active centered pill id. */
-    currentPillId: string;
-    /** Show the theme toggle button. */
-    showThemeToggle: boolean;
-    /** Show the settings button and modal. */
-    showSettings: boolean;
-    /** Built-in settings modal configuration. */
-    settingsConfig?: TopBarSettingsConfig;
-    /** Show the standalone badge when not integrated into the platform. */
-    showStandaloneLabel: boolean;
-    /** Custom standalone badge label. */
-    standaloneLabel: string;
-    /** Account dropdown entries. */
-    accountMenu?: AccountMenuItem[];
-    /** Show the notifications icon button. */
-    showNotifications: boolean;
-    /** Draw a notification dot on the notifications icon. */
-    hasNotificationDot: boolean;
-    /** Show the admin shortcut. */
-    showAdmin: boolean;
-    /** Route used by the admin shortcut. */
-    adminPath: string;
-    /** Account display name. */
-    userName?: string;
-    /** Explicit account avatar initial. */
-    userInitial?: string;
-    /** Account email shown in the avatar menu. */
-    userEmail?: string;
+    pill: string;
     /** Names of AppTopBar passthrough slots the caller actually provided. */
     topBarSlotNames: string[];
     /** Scoped-slot payload exposed to the `topbar` override slot. */
     controls: PluginWorkspaceControlsModel;
 }
-/**
- * Resolved AppSidebar configuration consumed by WorkspaceSidebarInternal: sidebar chrome,
- * panels/forms, collapse behavior, and the compact control-schema props that drive
- * AppSidebar's auto-generated form.
- */
+/** Resolved AppSidebar configuration consumed by WorkspaceSidebarInternal. */
 export interface PluginWorkspaceSidebarModel {
-    /** Sidebar chrome title. */
-    title?: string;
-    /** Sidebar chrome subtitle. */
-    subtitle?: string;
-    /** Optional compact badge/count rendered in the sidebar header. */
-    badge?: string | number;
-    /** Map of view IDs to sidebar tool sections. */
-    panels: Record<string, SidebarToolSection[]>;
+    /** AppSidebar spec with the workspace defaults applied. */
+    spec: PluginWorkspaceSidebarSpec;
     /** Resolved active view, used to pick which panels/forms render. */
     activeView: string;
-    /** AppSidebar floating style (always false: PluginWorkspaceView docks the sidebar inside AppLayout). */
-    floating: boolean;
-    /** Compact AppSidebar density. */
-    dense: boolean;
-    /** Sidebar CSS width. */
-    width?: string;
-    /** Sidebar position, mirrors the shell's `sidebarPosition`. */
-    side: 'left' | 'right';
-    /** Optional FormBuilder schemas keyed by section ID. */
-    forms: Record<string, FormSchema>;
-    /** DOM id for the AppSidebar scrollable content area. */
-    contentId?: string;
-    /** Render the sidebar shell even when no panel matches the active view. */
-    showWhenEmpty: boolean;
-    /** Optional compact control model for the generated sidebar form. */
-    model?: ControlModel | ControlModelBinding;
-    /** Compact control schema for the generated sidebar form. */
-    controlSchema?: ControlSchema;
-    /** Options passed to compact control schema generation. */
-    controlOptions: ControlWorkspaceOptions;
     /** Shared values for the auto-rendered sidebar form. */
     values: Record<string, unknown>;
-    /** Runtime FormBuilder enhancements for the auto-rendered sidebar form. */
-    formEnhancements?: FormEnhancements<Record<string, unknown>>;
-    /** Show submit/cancel actions inside the auto-rendered sidebar form. */
-    showFormActions: boolean;
+    /** Controlled sidebar collapsed state. */
+    collapsed?: boolean;
     /** Loading/saving state for the auto-rendered sidebar form. */
     formLoading: boolean;
     /** Disabled state for the auto-rendered sidebar form. */
     formDisabled: boolean;
     /** Readonly state for the auto-rendered sidebar form. */
     formReadonly: boolean;
-    /** Size passed to the auto-rendered sidebar form. */
-    formSize: 'sm' | 'md' | 'lg';
-    /** Show a built-in collapse/expand button in the sidebar chrome. */
-    collapsible?: boolean;
-    /** Controlled sidebar collapsed state. */
-    collapsed?: boolean;
-    /** Initial sidebar collapsed state when uncontrolled. */
-    defaultCollapsed: boolean;
-    /** Sidebar width when collapsed. */
-    collapsedWidth: string;
-    /** Accessible label for the sidebar collapse action. */
-    collapseButtonLabel: string;
-    /** Accessible label for the sidebar expand action. */
-    expandButtonLabel: string;
     /** Names of AppSidebar passthrough slots the caller actually provided. */
     slotNames: string[];
 }

package/dist/composables/useApi.d.ts

@@ -17,8 +17,6 @@ export interface ApiClientOptions {
     baseUrl?: string;
     timeout?: number;
     withAuth?: boolean;
-    /** Normalize failed responses into MintApiError. Generated clients enable this by default. */
-    typedErrors?: boolean;
 }
 export interface UseApiReturn {
     client: AxiosInstance;
@@ -32,5 +30,5 @@ export interface UseApiReturn {
     buildUrl: (path: string) => string;
     buildWsUrl: (path: string) => string;
 }
-/** Axios-based API client that injects the plugin base URL and JWT auth header on every request. */
+/** Axios-based API client that injects the plugin base URL and JWT auth header on every request. A failed response rejects with a `MintApiError`. */
 export declare function useApi(options?: ApiClientOptions): UseApiReturn;

package/dist/composables/useAppExperiment.d.ts

@@ -10,11 +10,18 @@ export interface UseAppExperimentOptions {
     onDetach?: () => void;
     saveDisabled?: Ref<boolean> | ComputedRef<boolean>;
     saveDisabledMessage?: string | Ref<string | undefined> | ComputedRef<string | undefined>;
+    /** Unsaved changes; marks the Save button with a dot. */
+    dirty?: Ref<boolean> | ComputedRef<boolean>;
 }
 export interface AppExperimentPopoverBinding {
     experimentName?: string;
     experimentCode?: string;
     experimentStatus?: ExperimentStatus;
+    experimentId?: number | null;
+    experimentProject?: string;
+    experimentOwner?: string;
+    /** ISO timestamp of the experiment's last update. */
+    experimentUpdatedAt?: string;
     /** An experiment is bound but its record has not arrived yet. */
     isResolving: boolean;
     /** Resolution failed; the binding is kept so the user can retry or detach. */
@@ -25,9 +32,10 @@ export interface AppExperimentPopoverBinding {
     saveDisabledMessage?: string;
     saveLoading: boolean;
     saveSuccessMessage?: string;
+    dirty?: boolean;
 }
 export interface AppExperimentSelectorModalBinding {
-    modelValue: boolean;
+    open: boolean;
     currentExperimentId: number | null;
 }
 export interface UseAppExperimentReturn {

package/dist/composables/{useAnalysisArtifacts.d.ts → useArtifacts.d.ts}

@@ -1,8 +1,8 @@
 import { ComputedRef, MaybeRefOrGetter, Ref } from 'vue';
 import { AnalysisArtifactDetail, AnalysisArtifactMetadataUpdate, AnalysisArtifactStatusFilter, AnalysisArtifactSummary, AnalysisArtifactTarget } from '../types/analysisArtifactTypes';
 export { ANALYSIS_FILE_ARTIFACT_SCHEMA } from '../types/analysisArtifactTypes';
-export interface UseAnalysisArtifactsOptions {
-    /** Experiment id; defaults to platform injection or URL. Refetches when it changes. */
+export interface UseArtifactsOptions {
+    /** Experiment id; defaults to the current experiment (`useExperimentStore`). Refetches when it changes. */
     experimentId?: MaybeRefOrGetter<number | undefined>;
     /** Override API base URL. */
     apiBaseUrl?: string;
@@ -13,14 +13,14 @@ export interface UseAnalysisArtifactsOptions {
     /** Fetch as soon as an experiment id is available. */
     immediate?: boolean;
 }
-export interface UseAnalysisArtifactsReturn {
+export interface UseArtifactsReturn {
     /** Fetched artifacts, scoped to pluginId when set. */
     artifacts: ComputedRef<AnalysisArtifactSummary[]>;
     /** Artifacts after applying statusFilter, pluginFilter, and search. */
     visibleArtifacts: ComputedRef<AnalysisArtifactSummary[]>;
     /** Detail loaded by the last successful getDetail call, or null. */
     selectedDetail: Ref<AnalysisArtifactDetail | null>;
-    /** Resolved experiment id from options, platform injection, or URL. */
+    /** Resolved experiment id from options or the current experiment. */
     currentExperimentId: ComputedRef<number | undefined>;
     /** Whether an experiment id is available. */
     hasCurrentExperiment: ComputedRef<boolean>;
@@ -62,8 +62,8 @@ export interface UseAnalysisArtifactsReturn {
  *
  * @example Recommended
  * ```ts
- * const artifacts = useAnalysisArtifacts({ pluginId: 'LEAF' })
+ * const artifacts = useArtifacts({ pluginId: 'LEAF' })
  * await artifacts.list()
  * ```
  */
-export declare function useAnalysisArtifacts(options?: UseAnalysisArtifactsOptions): UseAnalysisArtifactsReturn;
+export declare function useArtifacts(options?: UseArtifactsOptions): UseArtifactsReturn;

package/dist/composables/useCalendarGrid.d.ts

@@ -22,5 +22,5 @@ export interface UseCalendarGridReturn {
     prevMonth: () => void;
     nextMonth: () => void;
 }
-/** Shared calendar grid state for date and datetime pickers. */
+/** Shared Monday-first calendar grid state for date and datetime pickers. */
 export declare function useCalendarGrid(options?: UseCalendarGridOptions): UseCalendarGridReturn;

package/dist/composables/useExperiment.d.ts

@@ -0,0 +1,30 @@
+import { ComputedRef } from 'vue';
+import { ExperimentSummary } from '../types';
+/** Load state of the current experiment record. */
+export type ExperimentLoadStatus = 'idle' | 'loading' | 'ready' | 'error';
+export interface UseExperimentReturn {
+    /** Id of the current experiment; `null` when none is selected. */
+    id: ComputedRef<number | null>;
+    /** Record of the current experiment, once the platform returned it. */
+    current: ComputedRef<ExperimentSummary | null>;
+    /** `idle` with no selection, then `loading`, `ready` or `error`. */
+    status: ComputedRef<ExperimentLoadStatus>;
+    /** Message of the last failed load, or `null`. */
+    error: ComputedRef<string | null>;
+    /** Read the current experiment again. The selection does not change. */
+    refresh: () => Promise<void>;
+}
+/**
+ * Read the experiment the plugin page works on.
+ *
+ * The platform selects the experiment and keeps it in step with the URL; this
+ * composable only reads it. Watch `id` to respond to a change. In standalone
+ * mode no experiment is selected and `id` stays `null`.
+ *
+ * @example
+ * ```typescript
+ * const experiment = useExperiment()
+ * watch(experiment.id, (id) => { if (id !== null) void load(id) }, { immediate: true })
+ * ```
+ */
+export declare function useExperiment(): UseExperimentReturn;

package/dist/composables/useExperimentSelector.d.ts

@@ -6,6 +6,8 @@ export interface UseExperimentSelectorOptions {
     apiBaseUrl?: string;
     limit?: number;
     immediate?: boolean;
+    /** Keep `statusCounts` in step with the non-status filters (one stats request per change). */
+    withStatusCounts?: boolean;
 }
 export interface UseExperimentSelectorReturn {
     /** Current page of fetched experiment rows. */
@@ -32,8 +34,8 @@ export interface UseExperimentSelectorReturn {
     experimentTypes: Ref<ExperimentTypeOption[]>;
     /** Available project options for filter UI. */
     projects: Ref<SelectOption<string>[]>;
-    /** Fetched experiments grouped by project name. */
-    groupedByProject: ComputedRef<[string, ExperimentSummary[]][]>;
+    /** Experiment count per status under every filter except status itself. */
+    statusCounts: Ref<Record<string, number>>;
     /** Fetch the current page with the current filters. */
     fetch: () => Promise<void>;
     /** Fetch and append the next page when available. */
@@ -46,6 +48,8 @@ export interface UseExperimentSelectorReturn {
     clear: () => void;
     /** Fetch experiment type and project filter options. */
     fetchFilterOptions: () => Promise<void>;
+    /** Fetch `statusCounts` from `GET /experiments/stats`. */
+    fetchStatusCounts: () => Promise<void>;
 }
 /** Fetches a paginated, filtered experiment list from the platform API for picker and selector UIs. */
 export declare function useExperimentSelector(options?: UseExperimentSelectorOptions): UseExperimentSelectorReturn;

package/dist/composables/useFilePicker.d.ts

@@ -1,6 +1,6 @@
 import { Ref } from 'vue';
 import { PickerAdapter, PickerCapabilities, PickerNode, PickerSelection, PickerSelectionMode, PickerSort, PickerSource } from '../types/filePicker';
-import { SegmentedOption } from '../types';
+import { OptionPrimitive, SelectOption } from '../types';
 interface PickerStateProps {
     open: boolean;
     adapter: PickerAdapter;
@@ -21,7 +21,7 @@ type PickerEmit = {
 export declare function useFilePicker(props: PickerStateProps, emit: PickerEmit, searchArea: Ref<HTMLElement | null>): {
     previewNode: import('vue').ComputedRef<PickerNode>;
     sourceNames: Record<PickerSource, string>;
-    segments: import('vue').ComputedRef<SegmentedOption[]>;
+    segments: import('vue').ComputedRef<SelectOption<OptionPrimitive>[]>;
     activeSegment: import('vue').ComputedRef<string>;
     mounts: import('vue').ShallowRef<PickerNode[], PickerNode[]>;
     mountView: import('vue').ComputedRef<boolean>;

package/dist/composables/useJobCenter.d.ts

@@ -0,0 +1,63 @@
+import { ComputedRef, MaybeRefOrGetter, Ref, ShallowRef } from 'vue';
+import { JobListPayload, JobState, JobStateInput } from '../types/jobs';
+export type JobsStatusTrayTab = 'active' | 'history';
+/**
+ * The canonical owner of a collection of plugin jobs.
+ *
+ * Sources, rather than job-center UI, own polling, event streams, and all job
+ * mutations. This keeps components and consumers on one reactive job graph.
+ */
+export interface PluginJobCenterSource {
+    jobs: MaybeRefOrGetter<readonly JobStateInput[]>;
+    refresh?: () => Promise<JobListPayload | readonly JobStateInput[] | void>;
+    cancel?: (jobId: string) => Promise<JobStateInput | void>;
+    delete?: (jobId: string) => Promise<boolean | void>;
+    clear?: () => Promise<number | void>;
+    dispose?: () => void;
+}
+export interface CombinedPluginJobCenterSource extends PluginJobCenterSource {
+    jobs: ComputedRef<readonly JobStateInput[]>;
+}
+/**
+ * Combines independent job runtimes without copying their reactive state.
+ *
+ * Job ids must be globally unique across the sources. A duplicate id throws
+ * when jobs are read or an id-routed action is requested, rather than silently
+ * dispatching a mutation to the wrong owner.
+ */
+export declare function combinePluginJobSources(sources: readonly PluginJobCenterSource[]): CombinedPluginJobCenterSource;
+export interface UseJobCenterOptions {
+    source?: MaybeRefOrGetter<PluginJobCenterSource | undefined>;
+    loadOnMount?: boolean;
+}
+export interface UseJobCenterReturn {
+    jobs: ComputedRef<JobState[]>;
+    activeJobs: ComputedRef<JobState[]>;
+    historyJobs: ComputedRef<JobState[]>;
+    deletableJobs: ComputedRef<JobState[]>;
+    featuredJob: ComputedRef<JobState | null>;
+    canRefresh: ComputedRef<boolean>;
+    canCancel: ComputedRef<boolean>;
+    canDelete: ComputedRef<boolean>;
+    canClearFinished: ComputedRef<boolean>;
+    isOpen: Ref<boolean>;
+    activeTab: Ref<JobsStatusTrayTab>;
+    isLoading: Ref<boolean>;
+    error: ShallowRef<string | null>;
+    pendingJobIds: Ref<Set<string>>;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    refresh: () => Promise<boolean>;
+    cancelJob: (job: JobState) => Promise<boolean>;
+    deleteJob: (job: JobState) => Promise<boolean>;
+    clearFinished: () => Promise<boolean>;
+    isPending: (job: JobState) => boolean;
+}
+/**
+ * Headless controller for plugin job presentation and actions.
+ *
+ * Every job list is derived directly from the source. The controller never
+ * mirrors source jobs into another ref.
+ */
+export declare function useJobCenter(options?: UseJobCenterOptions): UseJobCenterReturn;

package/dist/composables/{useGeneratedAnalysis.d.ts → useJobsEndpoint.d.ts}

@@ -1,22 +1,25 @@
 import { ComputedRef, Ref, ShallowRef } from 'vue';
-import { JobsStatusTrayAdapter, PluginJobCenterSource } from './useJobsStatusTray';
+import { PluginJobCenterSource } from './useJobCenter';
 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 {
     fetcher?: typeof fetch;
     getAccessToken?: () => string | null | undefined;
 }
-export interface UsePluginJobsOptions {
+export interface UseJobsEndpointOptions {
     baseUrl: string;
     transport?: GeneratedAnalysisTransport;
     storage?: Storage;
     createId?: () => string;
-    pollInterval?: number;
+    /** Milliseconds between job list polls while no event stream is open. Default 750. */
+    poll?: number;
     stream?: boolean;
     streamReconnectDelay?: number;
+    /** List the existing jobs at once instead of on the first `submit()` or `refresh()`. */
     immediate?: boolean;
+    /** Load the generated UI manifest (`/generated/manifest`) before the jobs. */
+    manifest?: boolean;
 }
-export type GeneratedAnalysisOptions = UsePluginJobsOptions;
 export interface PluginJobWaitOptions {
     signal?: AbortSignal;
     rejectOnFailure?: boolean;
@@ -24,7 +27,7 @@ export interface PluginJobWaitOptions {
 export interface PluginJobRequestOptions {
     signal?: AbortSignal;
 }
-export interface UsePluginJobsReturn extends PluginJobCenterSource {
+export interface UseJobsEndpointReturn extends PluginJobCenterSource {
     manifest: ShallowRef<GeneratedAnalysisManifest | null>;
     session: ShallowRef<GeneratedSession | null>;
     jobs: ShallowRef<GeneratedAnalysisJob[]>;
@@ -33,39 +36,35 @@ export interface UsePluginJobsReturn extends PluginJobCenterSource {
     isSubmitting: Ref<boolean>;
     error: ShallowRef<string | null>;
     status: ShallowRef<'idle' | 'initializing' | 'ready' | 'paused' | 'error' | 'disposed'>;
-    initialize: () => Promise<void>;
-    ready: () => Promise<void>;
     uploadPath: (input: PluginJobPathInput, definitionId?: string) => Promise<PluginJobPathUpload>;
     uploadStagedPart: <Metadata>(input: PluginJobStagedPartInput<Metadata>) => Promise<PluginJobStagedPartUploadResult<Metadata>>;
     getJobStaging: <Metadata = unknown>(job: GeneratedAnalysisJob | string, pagination?: PluginJobStagingPagination) => Promise<PluginJobStaging<Metadata>>;
     sealJob: (job: GeneratedAnalysisJob | string) => Promise<GeneratedAnalysisJob>;
+    /** Submit a job. The first call opens the job session. */
     submit: (definitionId: string, inputs: Record<string, unknown>) => Promise<GeneratedAnalysisJob>;
-    loadResult: (job: GeneratedAnalysisJob) => Promise<GeneratedAnalysisResult | null>;
+    result: (job: GeneratedAnalysisJob) => Promise<GeneratedAnalysisResult | null>;
     resultForJob: (jobId: string) => GeneratedAnalysisResult | null;
-    refreshJobs: () => Promise<GeneratedAnalysisJob[]>;
+    /** List the jobs again. The first call opens the job session. */
     refresh: () => Promise<GeneratedAnalysisJob[]>;
-    getJob: (jobId: string, options?: PluginJobRequestOptions) => Promise<GeneratedAnalysisJob>;
-    waitForJob: (job: GeneratedAnalysisJob | string, options?: PluginJobWaitOptions) => Promise<GeneratedAnalysisJob>;
+    get: (jobId: string, options?: PluginJobRequestOptions) => Promise<GeneratedAnalysisJob>;
+    wait: (job: GeneratedAnalysisJob | string, options?: PluginJobWaitOptions) => Promise<GeneratedAnalysisJob>;
     jobsFor: (definitionId: string) => GeneratedAnalysisJob[];
-    cancelJob: (job: GeneratedAnalysisJob | string) => Promise<GeneratedAnalysisJob>;
-    deleteJob: (job: GeneratedAnalysisJob | string) => Promise<boolean>;
-    clearFinishedJobs: (definitionId?: string) => Promise<number>;
+    cancel: (job: GeneratedAnalysisJob | string) => Promise<GeneratedAnalysisJob>;
+    delete: (job: GeneratedAnalysisJob | string) => Promise<boolean>;
+    clear: (definitionId?: string) => Promise<number>;
     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;
-export declare function useGeneratedAnalysis(options: GeneratedAnalysisOptions): UseGeneratedAnalysisReturn;
 /**
- * Connect a custom plugin frontend to the SDK-owned job lifecycle.
+ * Connect a frontend to the SDK-owned job lifecycle of one plugin API prefix.
+ * Generated clients use it through `useJobs()`.
  *
- * @example Recommended
+ * @example
  * ```ts
- * const jobs = usePluginJobs({ baseUrl: '/api/leaf/jobs' })
- * await jobs.initialize()
+ * const jobs = useJobsEndpoint({ baseUrl: '/api/leaf', immediate: true })
+ * const job = await jobs.submit('fit-plate', inputs)
  * ```
  */
-export declare function usePluginJobs(options: UsePluginJobsOptions): UsePluginJobsReturn;
+export declare function useJobsEndpoint(options: UseJobsEndpointOptions): UseJobsEndpointReturn;

package/dist/composables/useMenuKeyboard.d.ts

@@ -23,7 +23,7 @@ export interface UseMenuKeyboardReturn {
 }
 /**
  * Shared keyboard contract for menu- and listbox-style disclosure panels (the
- * WAI-ARIA menu button pattern). Used by ActionMenu and AppAvatarMenu,
+ * WAI-ARIA menu button pattern). Used by ActionMenu and the platform account menu,
  * each pairing it with `useDropdownState` for the disclosure state itself.
  */
 export declare function useMenuKeyboard(options: UseMenuKeyboardOptions): UseMenuKeyboardReturn;

package/dist/composables/usePlatform.d.ts

@@ -0,0 +1,64 @@
+import { Access, ThemeMode } from '../types';
+/**
+ * Read the platform context the MINT platform injects into a plugin page.
+ *
+ * `can(access)` answers with the same three levels as the Python `access`
+ * option. A page with no signed-in user passes every check when it runs
+ * standalone or the platform reports `authRequired: false`; the platform
+ * still checks every request.
+ *
+ * @example
+ * ```typescript
+ * const platform = usePlatform()
+ * const canConfigure = computed(() => platform.can('configure'))
+ * ```
+ */
+export declare function usePlatform(): {
+    integrated: import('vue').ComputedRef<boolean>;
+    plugin: import('vue').ComputedRef<{
+        id: string;
+        name: string;
+        display_name: string;
+        version: string;
+        plugin_type: string;
+        route_prefix: string;
+        api_prefix: string;
+        settings_api: "plugin" | "platform";
+        subtitle?: string | undefined;
+        description?: string | undefined;
+        icon?: string | undefined;
+        color?: string | undefined;
+        frontend_revision?: string | undefined;
+        nav_items?: {
+            path: string;
+            label: string;
+            id?: string | undefined;
+            icon?: string | undefined;
+            description?: string | undefined;
+            requiresAuth?: boolean | undefined;
+            access?: "use" | "configure" | "admin" | undefined;
+            requiresFeature?: string | undefined;
+            children?: /*elided*/ any[] | undefined;
+        }[] | undefined;
+        settings?: import('..').PluginSettings | undefined;
+    } | undefined>;
+    user: import('vue').ComputedRef<{
+        id: number;
+        username: string;
+        role: string;
+        shortname?: string | undefined;
+        role_obj?: {
+            id: number;
+            slug: string;
+            name: string;
+            color: string;
+            permissions: string[];
+            project_scope: string;
+            plugin_access: string[] | "all" | null;
+        } | undefined;
+    } | undefined>;
+    theme: import('vue').ComputedRef<ThemeMode>;
+    features: import('vue').ComputedRef<Record<string, boolean> | undefined>;
+    isAdmin: import('vue').ComputedRef<boolean>;
+    can: (access: Access) => boolean;
+};

package/dist/composables/usePluginWorkspace.d.ts

@@ -1,5 +1,5 @@
 import { ComputedRef } from 'vue';
-import { PageSelectorItem, PillNavItem } from '../types';
+import { PillNavItem } from '../types';
 import { PluginWorkspaceViewEmit, PluginWorkspaceViewProps } from '../components/PluginWorkspaceView.props';
 import { PluginWorkspaceControlsModel, PluginWorkspaceShellModel, PluginWorkspaceSidebarModel } from './pluginWorkspaceModel';
 /**
@@ -25,24 +25,19 @@ export interface UsePluginWorkspaceReturn {
     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`. */
+    /** Applies an AppSidebar `update:values` payload to the shared control values and emits `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`. */
+    /** Resolves an AppTopBar `pill-select` payload into the active view and emits `update:pill` and `pill-select`. */
     handlePillSelect: (item: PillNavItem) => void;
 }
 /**
- * Maps PluginWorkspaceView's flat 72-prop surface into the three typed model objects
+ * Maps PluginWorkspaceView's `spec` and `v-model`s 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.
+ * (WorkspaceShellInternal, WorkspaceSidebarInternal, WorkspaceControlsInternal).
  *
  * @example Recommended
  * ```ts
- * const props = withDefaults(defineProps<PluginWorkspaceViewProps>(), { ... })
+ * const props = defineProps<PluginWorkspaceViewProps>()
  * const emit = defineEmits<PluginWorkspaceViewEmits>()
  * const slots = useSlots()
  * const { shell, sidebar, controls } = usePluginWorkspace({ props, slots, emit })

package/dist/composables/usePresence.d.ts

@@ -0,0 +1,41 @@
+import { MaybeRefOrGetter, Ref } from 'vue';
+/**
+ * What a viewer does on a topic. The platform accepts a fixed set per topic
+ * kind: `experiment:{id}` takes all four labels, `project:{id}` only
+ * `viewing` and `editing`. `editing` means a form with unsaved edits is open;
+ * it is a hint, not a lock.
+ */
+export type PresenceActivity = 'viewing' | 'viewing_design' | 'viewing_results' | 'editing';
+/** One user with an open realtime stream on the topic. */
+export interface PresenceViewer {
+    user_id: string;
+    activity: PresenceActivity;
+}
+export interface UsePresenceReturn {
+    /** The viewers, `editing` first, at most 20; the current user is included. Empty while the stream is closed. */
+    viewers: Readonly<Ref<readonly PresenceViewer[]>>;
+    /** Every viewer, also those beyond the 20 in `viewers`. */
+    count: Readonly<Ref<number>>;
+    /** True while the shared realtime stream is open. */
+    connected: Readonly<Ref<boolean>>;
+    /** Unsubscribe; also runs when the calling component or effect scope is disposed. */
+    stop: () => void;
+}
+/**
+ * Who else views an `experiment:{id}` or `project:{id}` topic (RFC #439).
+ *
+ * Built on `useRealtime`: the tab's open stream on the topic is its presence,
+ * and `presence.changed` events update `viewers`. When `activity` is given,
+ * the label is sent to `POST /api/presence/activity` when the call starts on
+ * an open stream, each time the stream opens and each time the label changes;
+ * `stop` (also the end of the calling scope) sets it back to `viewing`.
+ * Without it, the platform shows the tab as `viewing`. Like `useRealtime`, it needs the platform's `realtime`
+ * feature flag; check that flag first.
+ *
+ * @example
+ * const { viewers } = usePresence(
+ *   () => `experiment:${id.value}`,
+ *   () => (dirty.value ? 'editing' : 'viewing'),
+ * )
+ */
+export declare function usePresence(topic: MaybeRefOrGetter<string>, activity?: MaybeRefOrGetter<PresenceActivity>): UsePresenceReturn;