@manifest-editor/shell 2.0.3-next.0.2f3498a → 2.0.3-next.0.3782be7

package/dist/index.d.cts

@@ -1,6 +1,6 @@
-import * as react12 from "react";
-import { Dispatch, HTMLAttributes, ReactNode, SetStateAction } from "react";
-import * as react_jsx_runtime9 from "react/jsx-runtime";
+import * as react4 from "react";
+import { CSSProperties, Dispatch, HTMLAttributes, ReactElement, ReactNode, SVGProps, SetStateAction } from "react";
+import * as react_jsx_runtime4 from "react/jsx-runtime";
 import * as _manifest_editor_creator_api0 from "@manifest-editor/creator-api";
 import { CreatableResource, Creator, CreatorDefinition } from "@manifest-editor/creator-api";
 import * as _iiif_presentation_30 from "@iiif/presentation-3";
@@ -16,10 +16,34 @@ import { Vault as Vault$1 } from "@iiif/helpers";
 import { EditorInstance } from "@manifest-editor/editor-api";
 import { ManifestNormalized } from "@iiif/presentation-3-normalized";
 import { Emitter } from "mitt";
-import { useLocalStorage, useOptionalLocalStorage } from "@manifest-editor/components";
+import { ToastContent as ToastContent$1, ToastVariant as ToastVariant$1, useLocalStorage, useOptionalLocalStorage } from "@manifest-editor/components";
 import * as styled_components_dist_types0 from "styled-components/dist/types";
 import * as styled_components0 from "styled-components";
+import { ToastOptions } from "@react-stately/toast";
+import { MessagePortClientVault, RemoteVaultAction, RemoteVaultClientMessage } from "@manifest-editor/client-vault";
 
+//#region src/AppResourceProvider/AppResourceProvider.d.ts
+interface Resource {
+  id: string;
+  type: string;
+}
+declare function useAppResourceInstance(): string;
+declare function useAppResource(): Resource;
+declare function AppResourceInstanceProvider({
+  id,
+  children
+}: {
+  id?: string;
+  children: React.ReactNode;
+}): string | number | bigint | boolean | Iterable<react4.ReactNode> | Promise<string | number | bigint | boolean | react4.ReactPortal | react4.ReactElement<unknown, string | react4.JSXElementConstructor<any>> | Iterable<react4.ReactNode> | null | undefined> | react_jsx_runtime4.JSX.Element | null | undefined;
+declare function AppResourceProvider({
+  resource,
+  children
+}: {
+  resource?: Resource;
+  children: React.ReactNode;
+}): react_jsx_runtime4.JSX.Element;
+//#endregion
 //#region src/PreviewContext/PreviewContext.types.d.ts
 interface Preview {
   id: string;
@@ -110,6 +134,13 @@ interface Config {
     version: 3 | 2;
   };
   uploadBackends: Array<UploadBackendConfig>;
+  plugins?: {
+    apps?: Record<string, {
+      enabled?: string[];
+      disabled?: string[];
+      settings?: Record<string, Record<string, unknown>> & Record<string, unknown>;
+    }>;
+  };
 }
 interface EditorConfig {
   singleTab?: string;
@@ -127,8 +158,10 @@ interface UploadBackendConfig {
     type: string;
   }> | null;
 }
-declare const ConfigReactContext: react12.Context<Config>;
-declare const SaveConfigReactContext: react12.Context<(config: Partial<Config>) => void>;
+declare function mergePartialConfig(...configs: Array<Partial<Config> | null | undefined>): Partial<Config>;
+declare function mergeConfig(...configs: Array<Partial<Config> | null | undefined>): Config;
+declare const ConfigReactContext: react4.Context<Config>;
+declare const SaveConfigReactContext: react4.Context<(config: Partial<Config>) => void>;
 declare function useConfig(): Config;
 declare function useSaveConfig(): (config: Partial<Config>) => void;
 declare function ConfigProvider({
@@ -139,7 +172,7 @@ declare function ConfigProvider({
   children: ReactNode;
   config?: Partial<Config>;
   saveConfig?: (config: Partial<Config>) => void;
-}): react_jsx_runtime9.JSX.Element;
+}): react_jsx_runtime4.JSX.Element;
 //#endregion
 //#region src/EditingStack/EditingStack.types.d.ts
 interface EditableResource {
@@ -208,6 +241,7 @@ interface LayoutProviderProps {
   modals?: Array<LayoutPanel>;
   annotations?: Array<AnnotationPanel>;
   background?: Array<BackgroundPanel>;
+  backgroundActions?: Array<BackgroundActionDefinition>;
 }
 interface LayoutContext extends LayoutProviderProps {
   state: LayoutState;
@@ -345,7 +379,14 @@ interface LayoutPanel {
   id: string;
   label: string;
   divide?: boolean;
+  separator?: boolean;
   icon?: null | string | ReactNode;
+  supports?: (ctx: LayoutPanelSupportContext) => boolean;
+  focusedMode?: {
+    hide?: boolean;
+    closeOnMainPanelClick?: boolean;
+    onSelect?: (ctx: LayoutPanelFocusedModeContext) => void;
+  };
   render: LayoutFunction;
   onMount?: (state: any, ctx: {
     current: PanelActions;
@@ -373,6 +414,21 @@ interface LayoutPanel {
     tabs?: boolean;
   };
 }
+interface LayoutPanelSupportContext {
+  rootResource?: Resource;
+  vault?: Vault;
+  app: MappedApp;
+  layoutState: LayoutState;
+  appState: AppState;
+}
+interface LayoutPanelFocusedModeContext {
+  rootResource?: Resource;
+  vault?: Vault;
+  app: MappedApp;
+  layoutState: LayoutState;
+  appState: AppState;
+  actions: LayoutActions;
+}
 type MenuPositions = "left" | "right" | "bottom" | "top";
 interface PinnedLayoutPanel<T$1 = any> extends LayoutPanel {
   pinned: true;
@@ -427,6 +483,7 @@ interface LayoutProps {
   modals?: Array<LayoutPanel>;
   annotations?: Array<AnnotationPanel>;
   background?: Array<BackgroundPanel>;
+  backgroundActions?: Array<BackgroundActionDefinition>;
   footer?: ReactNode;
   menu?: ReactNode;
   header?: ReactNode;
@@ -437,12 +494,442 @@ interface LayoutProps {
   leftPanelMenuPosition?: MenuPositions;
   centerPanelMenuPosition?: MenuPositions;
   rightPanelMenuPosition?: MenuPositions;
+  layoutMode?: "default" | "focused";
   editors?: EditorDefinition[];
   resources?: (string | ResourceDefinition)[];
   creators?: CreatorDefinition$1[];
   canvasEditors?: CanvasEditorDefinition[];
 }
 //#endregion
+//#region src/CanvasProgress.d.ts
+declare const CANVAS_PROGRESS_META_NAMESPACE = "@manifest-editor/canvas-progress";
+declare const CANVAS_PROGRESS_STATUS_META_KEY = "status";
+type CanvasProgressActiveStatus = "queued" | "pending" | "done";
+type CanvasProgressStatus = CanvasProgressActiveStatus | "none";
+type CanvasProgressStatusInput = CanvasProgressStatus | null | undefined;
+type CanvasProgressResource = string | {
+  id: string;
+  type?: string;
+} | null | undefined;
+declare function getCanvasProgressStatus(vault: Vault, resource: CanvasProgressResource): CanvasProgressStatus;
+declare function getCanvasProgressStatusFromState(state: any, resource: CanvasProgressResource): CanvasProgressStatus;
+declare function setCanvasProgressStatus(vault: Vault, resource: CanvasProgressResource, status: CanvasProgressStatusInput): CanvasProgressStatus;
+declare function clearCanvasProgressStatus(vault: Vault, resource: CanvasProgressResource): CanvasProgressStatus;
+declare function setCanvasProgressStatuses(vault: Vault, resources: CanvasProgressResource[], status: CanvasProgressStatusInput): Record<string, CanvasProgressStatus>;
+declare function clearCanvasProgressStatuses(vault: Vault, resources: CanvasProgressResource[]): Record<string, CanvasProgressStatus>;
+interface ManifestEditorCanvasProgressApi {
+  getStatus(resource: CanvasProgressResource): CanvasProgressStatus;
+  setStatus(resource: CanvasProgressResource, status: CanvasProgressStatusInput): CanvasProgressStatus;
+  clearStatus(resource: CanvasProgressResource): CanvasProgressStatus;
+  setStatuses(resources: CanvasProgressResource[], status: CanvasProgressStatusInput): Record<string, CanvasProgressStatus>;
+  clearStatuses(resources: CanvasProgressResource[]): Record<string, CanvasProgressStatus>;
+}
+declare function createManifestEditorCanvasProgressApi(vault: Vault): ManifestEditorCanvasProgressApi;
+declare function createTrackingCanvasProgressApi(baseApi: ManifestEditorCanvasProgressApi, trackedResourceIds?: Set<string>): ManifestEditorCanvasProgressApi & {
+  clearTrackedStatuses(): void;
+  trackedResourceIds: Set<string>;
+};
+declare function useCanvasProgressStatus(resource: CanvasProgressResource): CanvasProgressStatus;
+declare function useCanvasProgressActions(resource: CanvasProgressResource): {
+  setStatus(status: CanvasProgressStatusInput): CanvasProgressStatus;
+  clearStatus(): CanvasProgressStatus;
+  getStatus(): CanvasProgressStatus;
+};
+declare function ManifestEditorCanvasProgressOverlay({
+  resource,
+  status,
+  className
+}: {
+  resource?: CanvasProgressResource;
+  status?: CanvasProgressStatus;
+  className?: string;
+}): react_jsx_runtime4.JSX.Element;
+//#endregion
+//#region src/PluginContext/PluginContext.types.d.ts
+type PluginMetadata = {
+  id: string;
+  label: string;
+  description?: string;
+  author?: string | {
+    name: string;
+    url?: string;
+  };
+  official?: boolean;
+  image?: string | {
+    src: string;
+    alt?: string;
+  };
+  screenshots?: Array<{
+    src: string;
+    label?: string;
+    alt?: string;
+  }>;
+  version?: string;
+  tags?: string[];
+  supports?: {
+    apps?: string[];
+    projectTypes?: Array<"Manifest" | "Collection">;
+  };
+  defaultEnabled?: boolean;
+  dependencies?: string[];
+};
+type PluginModule = {
+  default: PluginMetadata;
+  config?: Partial<Config>;
+  settings?: PluginSettingsDefinition;
+} & AppExtension;
+type LazyPluginModule = {
+  default: PluginMetadata;
+  settings?: PluginSettingsDefinition;
+  load: () => Promise<PluginModule | MappedPlugin>;
+};
+type MappedPlugin = {
+  metadata: PluginMetadata;
+  extension: AppExtension;
+  settings?: PluginSettingsDefinition;
+  load?: () => Promise<PluginModule | MappedPlugin>;
+  loadStatus?: "idle" | "loading" | "loaded" | "error";
+  loadError?: string;
+};
+type PluginInput = PluginModule | MappedPlugin | LazyPluginModule;
+type PluginSettingsValue = Record<string, unknown>;
+type PluginSettingsRecord = Record<string, PluginSettingsValue>;
+type PluginSettingsFieldOption = {
+  label: string;
+  value: string | number | boolean;
+};
+type PluginSettingsField = {
+  id: string;
+  label: string;
+  description?: string;
+  type?: "text" | "textarea" | "number" | "boolean" | "select";
+  placeholder?: string;
+  options?: PluginSettingsFieldOption[];
+};
+type PluginSettingsRenderContext<T$1 extends PluginSettingsValue = PluginSettingsValue> = {
+  plugin: MappedPlugin;
+  appId: string;
+  scope: PluginConfigScope;
+  value: T$1;
+  defaults: T$1;
+  effective: T$1;
+  onChange: (value: T$1) => void;
+};
+type PluginSettingsDefinition<T$1 extends PluginSettingsValue = PluginSettingsValue> = {
+  defaults?: T$1;
+  fields?: PluginSettingsField[];
+  validate?: (settings: T$1) => string | null | undefined | void;
+  render?: (context: PluginSettingsRenderContext<T$1>) => ReactNode;
+};
+type PluginConfigScope = "workspace" | "global";
+type PluginAppConfig = {
+  enabled?: string[];
+  disabled?: string[];
+  settings?: PluginSettingsRecord & Record<string, unknown>;
+};
+type PluginStoreSnapshot = {
+  plugins: MappedPlugin[];
+  enabled: string[];
+  disabled: string[];
+  globalApps: Record<string, PluginAppConfig>;
+  apps: Record<string, PluginAppConfig>;
+};
+type PluginStore = PluginStoreSnapshot & {
+  setProviderState(state: {
+    plugins?: MappedPlugin[];
+    enabled?: string[];
+    disabled?: string[];
+    globalPluginConfig?: Config["plugins"];
+  }): void;
+  setPluginLoading(id: string): void;
+  setPluginLoaded(id: string, plugin: MappedPlugin): void;
+  setPluginLoadError(id: string, error: string): void;
+  setAppConfig(appId: string, config: PluginAppConfig): void;
+  setGlobalConfig(config?: Config["plugins"]): void;
+  setGlobalAppConfig(appId: string, config: PluginAppConfig): void;
+  enable(appId: string, id: string): void;
+  enable(appId: string, id: string, scope: PluginConfigScope): void;
+  disable(appId: string, id: string): void;
+  disable(appId: string, id: string, scope: PluginConfigScope): void;
+};
+type PluginHostApp = Pick<MappedApp, "metadata" | "layout">;
+type PluginRuntimeApi = {
+  getSettings<T$1 extends PluginSettingsValue = PluginSettingsValue>(pluginId: string): T$1;
+};
+//#endregion
+//#region src/Tags.d.ts
+declare const TAGS_META_NAMESPACE = "@manifest-editor/tags";
+declare const TAGS_META_KEY = "tags";
+interface ManifestEditorTag {
+  type: string;
+  id: string;
+  label: string;
+  backgroundColor: string;
+  textColor: string;
+  icon?: string;
+}
+type ManifestEditorTagResource = string | {
+  id: string;
+  type?: string;
+} | null | undefined;
+interface ManifestEditorTagGroupRow {
+  key: string;
+  type: string;
+  id: string;
+  tag: ManifestEditorTag;
+  canvasIds: string[];
+  canvasCount: number;
+}
+interface ManifestEditorTagGroup {
+  key: string;
+  type: string;
+  rows: ManifestEditorTagGroupRow[];
+  canvasIds: string[];
+  canvasCount: number;
+  tagCount: number;
+}
+declare const FLAG_TAG: ManifestEditorTag;
+declare function getResourceTags(vault: Vault, resource: ManifestEditorTagResource): ManifestEditorTag[];
+declare function getResourceTagsFromState(state: any, resource: ManifestEditorTagResource): ManifestEditorTag[];
+declare function setResourceTags(vault: Vault, resource: ManifestEditorTagResource, tags: ManifestEditorTag[]): ManifestEditorTag[];
+declare function addResourceTag(vault: Vault, resource: ManifestEditorTagResource, tag: ManifestEditorTag): ManifestEditorTag[];
+declare function getResourceTag(vault: Vault, resource: ManifestEditorTagResource, tagType: string): ManifestEditorTag | undefined;
+declare function removeResourceTag(vault: Vault, resource: ManifestEditorTagResource, tagType: string, tagId?: string): ManifestEditorTag[];
+declare function getResourceTagGroups(vault: Vault, resources: ManifestEditorTagResource[]): ManifestEditorTagGroup[];
+declare function hasResourceTag(vault: Vault, resource: ManifestEditorTagResource, tagType: string, tagId?: string): boolean;
+declare function toggleResourceTag(vault: Vault, resource: ManifestEditorTagResource, tag: ManifestEditorTag): ManifestEditorTag[];
+interface ManifestEditorTagsApi {
+  getTags(resource: ManifestEditorTagResource): ManifestEditorTag[];
+  setTags(resource: ManifestEditorTagResource, tags: ManifestEditorTag[]): ManifestEditorTag[];
+  addTag(resource: ManifestEditorTagResource, tag: ManifestEditorTag): ManifestEditorTag[];
+  upsertTag(resource: ManifestEditorTagResource, tag: ManifestEditorTag): ManifestEditorTag[];
+  getTag(resource: ManifestEditorTagResource, tagType: string): ManifestEditorTag | undefined;
+  removeTag(resource: ManifestEditorTagResource, tagType: string, tagId?: string): ManifestEditorTag[];
+  hasTag(resource: ManifestEditorTagResource, tagType: string, tagId?: string): boolean;
+  toggleTag(resource: ManifestEditorTagResource, tag: ManifestEditorTag): ManifestEditorTag[];
+}
+declare function createManifestEditorTagsApi(vault: Vault): ManifestEditorTagsApi;
+declare function useResourceTags(resource: ManifestEditorTagResource): ManifestEditorTag[];
+declare function useResourceTagActions(resource: ManifestEditorTagResource): {
+  setTags(tags: ManifestEditorTag[]): ManifestEditorTag[];
+  addTag(tag: ManifestEditorTag): ManifestEditorTag[];
+  getTag(tagType: string): ManifestEditorTag | undefined;
+  removeTag(tagType: string, tagId?: string): ManifestEditorTag[];
+  toggleTag(tag: ManifestEditorTag): ManifestEditorTag[];
+  hasTag(tagType: string, tagId?: string): boolean;
+};
+declare function ManifestEditorTagIcon({
+  icon,
+  title,
+  ...props
+}: SVGProps<SVGSVGElement> & {
+  icon?: string;
+  title?: string;
+}): react_jsx_runtime4.JSX.Element | null;
+declare function ManifestEditorTagBadge({
+  tag,
+  showIcon,
+  className,
+  style
+}: {
+  tag: ManifestEditorTag;
+  showIcon?: boolean;
+  className?: string;
+  style?: CSSProperties;
+}): react_jsx_runtime4.JSX.Element;
+declare function ManifestEditorTagOverlay({
+  resource,
+  tags,
+  className
+}: {
+  resource?: ManifestEditorTagResource;
+  tags?: ManifestEditorTag[];
+  className?: string;
+}): react_jsx_runtime4.JSX.Element;
+//#endregion
+//#region src/BackgroundTasks/BackgroundTasks.types.d.ts
+type BackgroundActionStatus = "idle" | "preparing" | "running" | "complete" | "error" | "cancelled";
+type BackgroundActionLogLevel = "debug" | "info" | "warn" | "error";
+type BackgroundActionTaskStatus = "queued" | "running" | "complete" | "skipped" | "error" | "cancelled";
+type BackgroundActionEventType = "started" | "label" | "status" | "log" | "result" | "results-available" | "error" | "cancel-requested";
+interface BackgroundActionTarget extends Reference {
+  label: string;
+  scope: "root" | "canvas";
+}
+interface BackgroundActionError {
+  message: string;
+  stack?: string;
+  detail?: unknown;
+}
+interface BackgroundActionLogEntry {
+  id: string;
+  createdAt: number;
+  level: BackgroundActionLogLevel;
+  message: string;
+  data?: unknown;
+}
+interface BackgroundActionEvent {
+  id: string;
+  createdAt: number;
+  type: BackgroundActionEventType;
+  message?: string;
+  data?: unknown;
+}
+interface BackgroundActionProgress {
+  percent: number;
+  current?: number;
+  total?: number;
+  label?: string;
+}
+type BackgroundActionProgressInput = {
+  percent: number;
+  current?: number;
+  total?: number;
+  label?: string;
+} | {
+  current: number;
+  total: number;
+  percent?: number;
+  label?: string;
+};
+interface BackgroundActionTask {
+  id: string;
+  label: string;
+  target?: BackgroundActionTarget;
+  input?: unknown;
+  status?: BackgroundActionTaskStatus;
+  statusText?: string;
+  result?: unknown;
+  error?: BackgroundActionError | null;
+  createdAt?: number;
+  startedAt?: number;
+  completedAt?: number;
+}
+interface BackgroundActionPlan {
+  version: 1;
+  data?: unknown;
+  tasks: BackgroundActionTask[];
+}
+interface BackgroundActionPersistedState {
+  version: 1;
+  savedAt: number;
+  instances: Record<string, BackgroundActionInstance>;
+  histories: Record<string, BackgroundActionInstance[]>;
+  plans: Record<string, BackgroundActionPlan>;
+}
+interface BackgroundActionPersistenceKey {
+  appId: string;
+  instanceId: string;
+  rootResource: Reference;
+}
+interface BackgroundActionPersistence {
+  load(key: BackgroundActionPersistenceKey): Promise<BackgroundActionPersistedState | null | undefined>;
+  save(key: BackgroundActionPersistenceKey, state: BackgroundActionPersistedState): Promise<void>;
+  clear(key: BackgroundActionPersistenceKey): Promise<void>;
+}
+type BackgroundActionTaskRunResult = {
+  taskStatus?: "complete" | "skipped";
+  result?: unknown;
+  statusText?: string;
+} | unknown;
+interface BackgroundActionTaskRunOptions {
+  statuses?: BackgroundActionTaskStatus[];
+  progressLabel?: (task: BackgroundActionTask, index: number, total: number) => string;
+  yieldEveryMs?: number | false;
+}
+interface BackgroundActionTasksApi {
+  getAll(): BackgroundActionTask[];
+  getPending(): BackgroundActionTask[];
+  update(id: string, patch: Partial<BackgroundActionTask>, persistImmediately?: boolean): void;
+  runEach(handler: (task: BackgroundActionTask, context: {
+    index: number;
+    total: number;
+    pendingIndex: number;
+    pendingTotal: number;
+  }) => BackgroundActionTaskRunResult | Promise<BackgroundActionTaskRunResult>, options?: BackgroundActionTaskRunOptions): Promise<BackgroundActionTask[]>;
+}
+interface BackgroundActionInstance {
+  id: string;
+  runId: string;
+  actionId: string;
+  target: BackgroundActionTarget;
+  label: string;
+  status: BackgroundActionStatus;
+  statusText?: string;
+  error?: BackgroundActionError | null;
+  result?: unknown;
+  resultsAvailable: boolean;
+  logs: BackgroundActionLogEntry[];
+  events: BackgroundActionEvent[];
+  progress?: BackgroundActionProgress;
+  startedAt?: number;
+  completedAt?: number;
+  cancelRequestedAt?: number;
+  cancelledAt?: number;
+}
+interface BackgroundActionSystemContext {
+  rootResource: Resource;
+  currentCanvas?: BackgroundActionTarget;
+  vault: Vault;
+  tags: ManifestEditorTagsApi;
+  canvasProgress: ManifestEditorCanvasProgressApi;
+  plugins: PluginRuntimeApi;
+  config: Config;
+  layoutState: LayoutState;
+  layoutActions: LayoutActions;
+}
+interface BackgroundActionContext extends BackgroundActionSystemContext {
+  definition: BackgroundActionDefinition;
+  target: BackgroundActionTarget;
+  instanceKey: string;
+  instance?: BackgroundActionInstance;
+}
+interface BackgroundActionLifecycle {
+  setActionLabel(label: string): void;
+  setActionStatus(status: BackgroundActionStatus, statusText?: string): void;
+  setActionError(error: unknown, statusText?: string): void;
+  appendActionLog(message: string, level?: BackgroundActionLogLevel, data?: unknown): void;
+  setActionProgress(progress: BackgroundActionProgressInput | null): void;
+  setResult(result: unknown): void;
+  setResultsAvailable(available: boolean): void;
+}
+interface BackgroundActionRunContext extends BackgroundActionContext, BackgroundActionLifecycle {
+  signal: AbortSignal;
+  prepareData?: unknown;
+  plan?: BackgroundActionPlan;
+  tasks: BackgroundActionTasksApi;
+}
+interface BackgroundActionRenderContext extends BackgroundActionSystemContext {
+  definition: BackgroundActionDefinition;
+}
+interface BackgroundActionDefinition {
+  id: string;
+  label: string;
+  summary?: string;
+  section?: string;
+  order?: number;
+  resourceTypes?: string[];
+  resumable?: boolean;
+  supports?: (ctx: BackgroundActionContext) => boolean;
+  prepare?: (ctx: BackgroundActionRunContext) => BackgroundActionPlan | boolean | void | Promise<BackgroundActionPlan | boolean | void>;
+  run: (ctx: BackgroundActionRunContext) => unknown | Promise<unknown>;
+  render?: (ctx: BackgroundActionRenderContext) => ReactNode | null;
+  onResults?: (ctx: BackgroundActionContext) => unknown | Promise<unknown>;
+}
+interface AvailableBackgroundAction {
+  definition: BackgroundActionDefinition;
+  target: BackgroundActionTarget;
+  instanceKey: string;
+  instance?: BackgroundActionInstance;
+  context: BackgroundActionContext;
+}
+interface BackgroundActionGroup {
+  id: string;
+  label: string;
+  target: BackgroundActionTarget;
+  actions: AvailableBackgroundAction[];
+}
+//#endregion
 //#region src/AppContext/AppContext.d.ts
 type AppContext = {
   instanceId: string;
@@ -479,6 +966,7 @@ interface AppExtension {
   canvasEditors?: CanvasEditorDefinition[];
   annotations?: AnnotationPanel[];
   background?: BackgroundPanel[];
+  backgroundActions?: BackgroundActionDefinition[];
   leftPanelIds?: string[];
   disableSideEffects?: string[];
 }
@@ -486,9 +974,9 @@ type AppState = {
   state: null | any;
   setState: SetStateAction<any>;
 };
-declare const PrimeAppReactContext: react12.Context<MappedApp | null>;
-declare const AppReactContext: react12.Context<AppContext | null>;
-declare const AppStateReactContext: react12.Context<{
+declare const PrimeAppReactContext: react4.Context<MappedApp | null>;
+declare const AppReactContext: react4.Context<AppContext | null>;
+declare const AppStateReactContext: react4.Context<{
   state: null | any;
   setState: SetStateAction<any>;
 }>;
@@ -512,7 +1000,7 @@ declare function AppProvider({
   args?: any;
   definition: MappedApp;
   children: ReactNode;
-}): react_jsx_runtime9.JSX.Element;
+}): react_jsx_runtime4.JSX.Element;
 //#endregion
 //#region src/AppContext/MultiAppContext.d.ts
 type MappedApp$1 = any;
@@ -551,13 +1039,13 @@ declare function MultiAppProvider({
     manifestApp?: string;
     collectionApp?: string;
   };
-}): react_jsx_runtime9.JSX.Element | null;
+}): react_jsx_runtime4.JSX.Element | null;
 //#endregion
 //#region src/AppHeader/AppHeader.d.ts
 interface AppHeaderProps {
   onClickLogo?: () => void;
 }
-declare const AppHeader: react12.NamedExoticComponent<AppHeaderProps>;
+declare const AppHeader: react4.NamedExoticComponent<AppHeaderProps>;
 //#endregion
 //#region src/AppMenu/AppMenuContext.d.ts
 type MenuItem = {
@@ -582,29 +1070,7 @@ declare function AppMenuProvider({
 }: {
   children: React.ReactNode;
   menu: AppMenuContext;
-}): react_jsx_runtime9.JSX.Element;
-//#endregion
-//#region src/AppResourceProvider/AppResourceProvider.d.ts
-interface Resource {
-  id: string;
-  type: string;
-}
-declare function useAppResourceInstance(): string;
-declare function useAppResource(): Resource;
-declare function AppResourceInstanceProvider({
-  id,
-  children
-}: {
-  id?: string;
-  children: React.ReactNode;
-}): string | number | bigint | boolean | Iterable<react12.ReactNode> | Promise<string | number | bigint | boolean | react12.ReactPortal | react12.ReactElement<unknown, string | react12.JSXElementConstructor<any>> | Iterable<react12.ReactNode> | null | undefined> | react_jsx_runtime9.JSX.Element | null | undefined;
-declare function AppResourceProvider({
-  resource,
-  children
-}: {
-  resource?: Resource;
-  children: React.ReactNode;
-}): react_jsx_runtime9.JSX.Element;
+}): react_jsx_runtime4.JSX.Element;
 //#endregion
 //#region src/AtlasStore/AtlasStoreProvider.d.ts
 declare function useAtlasStore(): StoreApi<AtlasStore>;
@@ -627,6 +1093,84 @@ declare function getImageDimensions(url: string): Promise<{
   height: number;
 } | null>;
 //#endregion
+//#region src/BackgroundTasks/BackgroundActions.d.ts
+declare function useAvailableBackgroundActions(): BackgroundActionGroup[];
+declare function BackgroundActionsMount(): react_jsx_runtime4.JSX.Element;
+declare function BackgroundActionToasts(): null;
+declare function BackgroundActionsMenu(): react_jsx_runtime4.JSX.Element | null;
+//#endregion
+//#region src/BackgroundTasks/BackgroundTasksStore.d.ts
+interface BackgroundActionsStore {
+  definitions: BackgroundActionDefinition[];
+  instances: Record<string, BackgroundActionInstance>;
+  histories: Record<string, BackgroundActionInstance[]>;
+  plans: Record<string, BackgroundActionPlan>;
+  controllers: Record<string, AbortController>;
+  hasHydrated: boolean;
+  setDefinitions(definitions: BackgroundActionDefinition[]): void;
+  setPersistence(persistence: BackgroundActionPersistence | null, key: BackgroundActionPersistenceKey | null): void;
+  hydrate(snapshot?: BackgroundActionPersistedState | null): void;
+  persist(immediate?: boolean): void;
+  flushPersistence(): Promise<void>;
+  registerAction(definition: BackgroundActionDefinition): () => void;
+  unregisterAction(id: string): void;
+  resetAction(instanceKey: string): void;
+  startAction(instanceKey: string, definition: BackgroundActionDefinition, target: BackgroundActionTarget, controller?: AbortController): void;
+  resumeAction(instanceKey: string, controller: AbortController): void;
+  cancelAction(instanceKey: string): void;
+  setActionLabel(instanceKey: string, label: string): void;
+  setActionStatus(instanceKey: string, status: BackgroundActionStatus, statusText?: string): void;
+  setActionError(instanceKey: string, error: unknown, statusText?: string): void;
+  appendActionLog(instanceKey: string, message: string, level?: BackgroundActionLogLevel, data?: unknown): void;
+  setActionProgress(instanceKey: string, progress: BackgroundActionProgressInput | null): void;
+  setResult(instanceKey: string, result: unknown): void;
+  setResultsAvailable(instanceKey: string, available: boolean): void;
+  setActionPlan(instanceKey: string, plan: BackgroundActionPlan): void;
+  updateActionTask(instanceKey: string, taskId: string, patch: Partial<BackgroundActionTask>, persistImmediately?: boolean): void;
+}
+interface RunBackgroundActionOptions {
+  store: StoreApi<BackgroundActionsStore>;
+  context: BackgroundActionContext;
+  signal?: AbortSignal;
+  resume?: boolean;
+  prepareData?: unknown;
+}
+interface GetAvailableBackgroundActionGroupsOptions {
+  definitions: BackgroundActionDefinition[];
+  instances: Record<string, BackgroundActionInstance>;
+  systemContext: BackgroundActionSystemContext;
+  targets: BackgroundActionTarget[];
+  onSupportsError?: (definition: BackgroundActionDefinition, error: unknown) => void;
+}
+declare function getBackgroundActionInstanceKey(actionId: string, target: BackgroundActionTarget): string;
+declare function mergeBackgroundActionDefinitions(base?: BackgroundActionDefinition[], extensions?: BackgroundActionDefinition[]): BackgroundActionDefinition[];
+declare function sortBackgroundActionDefinitions(definitions: BackgroundActionDefinition[]): BackgroundActionDefinition[];
+declare function normaliseBackgroundActionError(error: unknown): BackgroundActionError;
+declare function getAvailableBackgroundActionGroups({
+  definitions,
+  instances,
+  systemContext,
+  targets,
+  onSupportsError
+}: GetAvailableBackgroundActionGroupsOptions): BackgroundActionGroup[];
+declare function createBackgroundActionsStore(initialDefinitions?: BackgroundActionDefinition[]): StoreApi<BackgroundActionsStore>;
+declare function runBackgroundAction(options: RunBackgroundActionOptions): Promise<BackgroundActionInstance | undefined>;
+declare function createLocalForageBackgroundActionPersistence(): BackgroundActionPersistence | null;
+declare const BackgroundActionsReactContext: react4.Context<StoreApi<BackgroundActionsStore> | null>;
+declare function BackgroundActionsProvider({
+  children,
+  persistence,
+  persistenceKey
+}: {
+  children: ReactNode;
+  persistence?: BackgroundActionPersistence | false | null;
+  persistenceKey?: BackgroundActionPersistenceKey;
+}): react4.FunctionComponentElement<react4.ProviderProps<StoreApi<BackgroundActionsStore> | null>>;
+declare function useBackgroundActionsStoreApi(): StoreApi<BackgroundActionsStore>;
+declare function useBackgroundActionsStore<T$1 = BackgroundActionsStore>(selector?: (state: BackgroundActionsStore) => T$1): T$1;
+declare function useBackgroundActionInstance(instanceKey: string): BackgroundActionInstance | undefined;
+declare function useBackgroundActionHistory(instanceKey: string): BackgroundActionInstance[];
+//#endregion
 //#region src/BaseCreator/index.d.ts
 declare const baseCreator: LayoutPanel;
 //#endregion
@@ -635,7 +1179,7 @@ interface BaseAnnotationCreatorProps {
   resource: CreatableResource;
   onCreate: () => void;
 }
-declare function BaseAnnotationCreator(props: BaseAnnotationCreatorProps): react_jsx_runtime9.JSX.Element;
+declare function BaseAnnotationCreator(props: BaseAnnotationCreatorProps): react_jsx_runtime4.JSX.Element;
 //#endregion
 //#region src/BaseCreator/BaseCreator.hooks.d.ts
 declare function useCreator(parent: any, property: string, type: string, target?: Reference, options?: {
@@ -658,7 +1202,7 @@ declare function CreatorInitialData<T$1 extends Record<string, unknown>>(props:
   id: string;
   children: React.ReactNode;
   data: T$1;
-}): react_jsx_runtime9.JSX.Element;
+}): react_jsx_runtime4.JSX.Element;
 //#endregion
 //#region src/BaseEditor/index.d.ts
 declare const baseEditor: LayoutPanel;
@@ -680,10 +1224,10 @@ declare function BaseEditor({
   currentTab
 }: {
   currentTab?: string;
-}): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react12.ReactPortal | react12.ReactElement<unknown, string | react12.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | react_jsx_runtime9.JSX.Element | null | undefined;
+}): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react4.ReactPortal | react4.ReactElement<unknown, string | react4.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | react_jsx_runtime4.JSX.Element | null | undefined;
 //#endregion
 //#region src/ConfigContext/ConfigEditor.d.ts
-declare function ConfigEditor(): react_jsx_runtime9.JSX.Element;
+declare function ConfigEditor(): react_jsx_runtime4.JSX.Element;
 //#endregion
 //#region src/ContextMenu/ContextMenuContext.d.ts
 type ContextMenuItem = {
@@ -732,12 +1276,12 @@ type ContextMenuStore = {
   }>;
   hookMenuItem(req: ContextMenuRequest): () => void;
 };
-declare const ContextMenuReactContext: react12.Context<StoreApi<ContextMenuStore> | null>;
+declare const ContextMenuReactContext: react4.Context<StoreApi<ContextMenuStore> | null>;
 declare function ContextMenuProvider({
   children
 }: {
   children: React.ReactNode;
-}): react_jsx_runtime9.JSX.Element;
+}): react_jsx_runtime4.JSX.Element;
 declare function useResourceContextMenuItems(req: {
   id?: string;
   type: string;
@@ -748,7 +1292,7 @@ declare function useResourceContextMenuItems(req: {
 declare function useCustomContextMenu(req: ContextMenuRequest, deps?: any[]): void;
 //#endregion
 //#region src/EditingStack/EditingStack.d.ts
-declare const EditingStackContext: react12.Context<EditingStackState>;
+declare const EditingStackContext: react4.Context<EditingStackState>;
 declare function useEditingStack(): EditingStackActions;
 declare function useEditingResource(): EditableResource | null;
 declare function useEditingResourceStack(): EditableResource[];
@@ -773,7 +1317,7 @@ declare function EditingStack(props: {
     id: string;
     type: string;
   };
-}): react_jsx_runtime9.JSX.Element;
+}): react_jsx_runtime4.JSX.Element;
 declare function InlineEditingStack({
   resource,
   children
@@ -783,14 +1327,14 @@ declare function InlineEditingStack({
     type: string;
   };
   children?: React.ReactNode;
-}): react_jsx_runtime9.JSX.Element;
+}): react_jsx_runtime4.JSX.Element;
 //#endregion
 //#region src/ExportPanel/ExportPanel.d.ts
 interface ExportPanelProps {
   initialVersion?: 2 | 3;
   versions?: Array<2 | 3>;
 }
-declare function ExportPanel(props: ExportPanelProps): react_jsx_runtime9.JSX.Element;
+declare function ExportPanel(props: ExportPanelProps): react_jsx_runtime4.JSX.Element;
 //#endregion
 //#region src/helpers.d.ts
 declare function getManifestNomalized(id: string): Promise<ManifestNormalized | undefined>;
@@ -843,14 +1387,14 @@ declare function useDecayState(time: number): readonly [boolean, {
 }];
 //#endregion
 //#region src/hooks/use-event.d.ts
-declare const ReactEmitterContext: react12.Context<Emitter<any>>;
+declare const ReactEmitterContext: react4.Context<Emitter<any>>;
 declare function EventEmitterProvider({
   children,
   emitter
 }: {
   children: React.ReactNode;
   emitter: Emitter<any>;
-}): react_jsx_runtime9.JSX.Element;
+}): react_jsx_runtime4.JSX.Element;
 declare function useEmitter<Event extends Record<string | symbol, unknown>>(): Emitter<Event>;
 declare function useEvent<Event extends Record<string | symbol, unknown>, Key extends keyof Event>(key: Key, listener: (data: Event[Key]) => void, deps?: any[]): void;
 //#endregion
@@ -905,14 +1449,14 @@ declare function useSvgTools(): {
 };
 //#endregion
 //#region src/Layout/components/HandleControls.d.ts
-declare const HandleContainer: styled_components0.IStyledComponent<"web", styled_components_dist_types0.FastOmit<react12.DetailedHTMLProps<react12.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>;
-declare const HandleControls: react12.ForwardRefExoticComponent<{
+declare const HandleContainer: styled_components0.IStyledComponent<"web", styled_components_dist_types0.FastOmit<react4.DetailedHTMLProps<react4.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>;
+declare const HandleControls: react4.ForwardRefExoticComponent<{
   dir: "left" | "right";
   open: boolean;
   actions: PanelActions;
   transition?: TransitionStatus;
   reset?: () => void;
-} & react12.RefAttributes<HTMLDivElement>>;
+} & react4.RefAttributes<HTMLDivElement>>;
 //#endregion
 //#region src/Layout/components/ModularPanel.d.ts
 interface ModularPanelProps {
@@ -928,11 +1472,11 @@ interface ModularPanelProps {
   style?: any;
 }
 declare function useSetCustomTitle(): (title: string) => void;
-declare const ModularPanelHeader: styled_components0.IStyledComponent<"web", styled_components_dist_types0.Substitute<react12.DetailedHTMLProps<react12.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
+declare const ModularPanelHeader: styled_components0.IStyledComponent<"web", styled_components_dist_types0.Substitute<react4.DetailedHTMLProps<react4.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {
   $tabs?: boolean;
   $error?: boolean;
 }>>;
-declare const ModulePanelButton: styled_components0.IStyledComponent<"web", styled_components_dist_types0.FastOmit<react12.DetailedHTMLProps<react12.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never>>;
+declare const ModulePanelButton: styled_components0.IStyledComponent<"web", styled_components_dist_types0.FastOmit<react4.DetailedHTMLProps<react4.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, never>>;
 declare function ModularPanel({
   panel,
   state,
@@ -944,16 +1488,16 @@ declare function ModularPanel({
   available,
   style,
   noHeader
-}: ModularPanelProps): react_jsx_runtime9.JSX.Element | null;
+}: ModularPanelProps): react_jsx_runtime4.JSX.Element | null;
 //#endregion
 //#region src/Layout/components/PanelError.d.ts
 declare function PanelError(props: {
   error: Error;
   resetErrorBoundary: () => void;
-}): react_jsx_runtime9.JSX.Element;
+}): react_jsx_runtime4.JSX.Element;
 //#endregion
 //#region src/Layout/Layout.d.ts
-interface LayoutProps$1 {
+interface LayoutRenderProps {
   header?: React.ReactNode;
   footer?: React.ReactNode;
   menu?: React.ReactNode;
@@ -968,14 +1512,17 @@ interface LayoutProps$1 {
   htmlId?: string;
   centerPanelMenuPosition?: "top" | "bottom";
   disableSideEffects?: string[];
+  layoutMode?: "default" | "focused";
 }
-declare const Layout: react12.NamedExoticComponent<LayoutProps$1>;
+declare const Layout: react4.NamedExoticComponent<LayoutRenderProps>;
 //#endregion
 //#region src/Layout/Layout.context.d.ts
-declare const LayoutActionsReactContext: react12.Context<LayoutActions>;
-declare const LayoutStateReactContext: react12.Context<LayoutState>;
+declare const LayoutActionsReactContext: react4.Context<LayoutActions>;
+declare const LayoutStateReactContext: react4.Context<LayoutState>;
+declare const LayoutModeReactContext: react4.Context<"default" | "focused">;
 declare function useLayoutState(): LayoutState;
 declare function useLayoutActions(): LayoutActions;
+declare function useLayoutMode(): "default" | "focused";
 declare function useAvailableLayouts(): LayoutProps;
 declare function useLayoutProvider(): LayoutProviderProps & {
   loading?: true;
@@ -1007,6 +1554,125 @@ declare const layoutReducer: (state: LayoutState, args_0: PanelActionType) => La
 declare function getDefaultPanelState(): PanelState;
 declare function getDefaultLayoutState(): LayoutState;
 //#endregion
+//#region src/Layout/Layout.supports.d.ts
+declare function filterSupportedPanels(panels: LayoutPanel[], ctx: LayoutPanelSupportContext, onSupportsError?: (panel: LayoutPanel, error: unknown) => void): LayoutPanel[];
+declare function getSupportedPanelFallback(panels: LayoutPanel[], currentId: string | null): string | null;
+declare function panelIds(panels: LayoutPanel[]): string;
+//#endregion
+//#region src/ManifestPaginationNavigation.d.ts
+interface ManifestPaginationNavigationProps {
+  className?: string;
+  variant?: "light" | "dark";
+}
+declare function ManifestPaginationNavigation({
+  className,
+  variant
+}: ManifestPaginationNavigationProps): react_jsx_runtime4.JSX.Element;
+//#endregion
+//#region src/PluginContext/PluginContext.d.ts
+declare const PluginReactContext: react4.Context<StoreApi<PluginStore> | null>;
+declare const PluginGlobalConfigReactContext: react4.Context<{
+  globalPluginConfig?: Config["plugins"];
+  saveGlobalPluginConfig?: (config: Config["plugins"]) => void | Promise<void>;
+}>;
+declare function PluginProvider({
+  plugins,
+  enabled,
+  disabled,
+  globalPluginConfig,
+  saveGlobalPluginConfig,
+  children
+}: {
+  plugins: PluginInput[];
+  enabled?: string[];
+  disabled?: string[];
+  globalPluginConfig?: Config["plugins"];
+  saveGlobalPluginConfig?: (config: Config["plugins"]) => void | Promise<void>;
+  children: ReactNode;
+}): ReactElement;
+declare function useOptionalPluginStoreApi(): StoreApi<PluginStore> | null;
+declare function usePluginStoreApi(): StoreApi<PluginStore>;
+declare function usePlugins(): PluginStoreSnapshot;
+declare function useEnabledPlugins(appId?: string): MappedPlugin[];
+declare function usePluginActions(): {
+  enable(appId: string, id: string, scope?: PluginConfigScope): void;
+  disable(appId: string, id: string, scope?: PluginConfigScope): void;
+  setAppConfig(appId: string, config: PluginAppConfig): void;
+  setGlobalAppConfig(appId: string, config: PluginAppConfig): void;
+};
+declare function usePluginRuntimeApi(appId?: string): PluginRuntimeApi;
+declare function usePluginSettings<T$1 extends PluginSettingsValue = PluginSettingsValue>(pluginId: string, appId?: string): T$1;
+declare function usePluginConfigApi<T$1 extends PluginSettingsValue = PluginSettingsValue>(pluginId: string, appId?: string): {
+  plugin: MappedPlugin | null;
+  appId: string;
+  defaults: T$1;
+  global: T$1;
+  workspace: T$1;
+  effective: T$1;
+  canSaveGlobal: boolean;
+  setWorkspaceSettings: (settings: T$1) => void;
+  resetWorkspaceSettings: () => void;
+  setGlobalSettings: (settings: T$1) => Promise<void>;
+  resetGlobalSettings: () => Promise<void>;
+};
+declare function useResolvedPluginApp(definition: MappedApp, appId: string): MappedApp;
+declare function PluginConfigBridge({
+  config
+}: {
+  config?: Partial<Config>;
+}): null;
+//#endregion
+//#region src/PluginContext/PluginContext.helpers.d.ts
+declare function getEmptyPluginState(): PluginStoreSnapshot;
+declare function normalisePluginAppConfig(config?: PluginAppConfig): PluginAppConfig;
+declare function normalisePluginAppsConfig(config?: {
+  apps?: Record<string, PluginAppConfig>;
+}): Record<string, PluginAppConfig>;
+declare function enablePluginInConfig(config: PluginAppConfig | undefined, id: string): PluginAppConfig;
+declare function disablePluginInConfig(config: PluginAppConfig | undefined, id: string): PluginAppConfig;
+declare function resetPluginInConfig(config: PluginAppConfig | undefined, id: string): PluginAppConfig;
+declare function pluginAppConfigEquals(a?: PluginAppConfig, b?: PluginAppConfig): boolean;
+declare function mapPlugin(input: PluginModule, map?: (plugin: MappedPlugin) => MappedPlugin): MappedPlugin;
+declare function mapLazyPlugin(input: LazyPluginModule): MappedPlugin;
+declare function isMappedPlugin(input: PluginInput): input is MappedPlugin;
+declare function isLazyPlugin(input: PluginInput): input is LazyPluginModule;
+declare function normalisePlugin(input: PluginInput): MappedPlugin;
+declare function normalisePlugins(plugins?: PluginInput[]): MappedPlugin[];
+declare function mergeProviderPlugins(previous: MappedPlugin[], next: MappedPlugin[]): MappedPlugin[];
+declare function isPluginCompatible(plugin: MappedPlugin, app?: PluginHostApp | null, appId?: string | null): boolean;
+declare function getPluginCompatibilityReason(plugin: MappedPlugin, app?: PluginHostApp | null, appId?: string | null): "This plugin does not support the current app." | "This plugin does not support the current project type." | null;
+declare function isPluginSelected(plugin: MappedPlugin, state: PluginStoreSnapshot, appId?: string | null): boolean;
+declare function getPluginSelectionSource(plugin: MappedPlugin, state: PluginStoreSnapshot, appId?: string | null): PluginConfigScope | "provider" | "default";
+declare function getEnabledPluginsForApp(state: PluginStoreSnapshot, app?: PluginHostApp | null, appId?: string | null): MappedPlugin[];
+declare function getPluginSettingsFromConfig<T$1 extends PluginSettingsValue = PluginSettingsValue>(config: PluginAppConfig | undefined, pluginId: string): Partial<T$1>;
+declare function setPluginSettingsInConfig<T$1 extends PluginSettingsValue = PluginSettingsValue>(config: PluginAppConfig | undefined, pluginId: string, settings: T$1): PluginAppConfig;
+declare function resetPluginSettingsInConfig(config: PluginAppConfig | undefined, pluginId: string): PluginAppConfig;
+declare function getPluginDefaultSettings<T$1 extends PluginSettingsValue = PluginSettingsValue>(plugin?: MappedPlugin): T$1;
+declare function getEffectivePluginSettings<T$1 extends PluginSettingsValue = PluginSettingsValue>(state: PluginStoreSnapshot, pluginId: string, appId?: string | null): T$1;
+declare function createPluginRuntimeApi(state: PluginStoreSnapshot, appId?: string | null): PluginRuntimeApi;
+declare function enablePluginAndDependenciesInConfig(config: PluginAppConfig, state: PluginStoreSnapshot, plugin: MappedPlugin, app?: PluginHostApp | null, appId?: string | null): {
+  config: PluginAppConfig;
+  enabledIds: string[];
+  blocked: string[];
+};
+declare function applyPlugins(app: MappedApp, plugins: MappedPlugin[], appId?: string): MappedApp;
+//#endregion
+//#region src/PluginContext/PluginContext.store.d.ts
+declare function createPluginStore({
+  plugins,
+  enabled,
+  disabled,
+  globalPluginConfig
+}?: {
+  plugins?: MappedPlugin[];
+  enabled?: string[];
+  disabled?: string[];
+  globalPluginConfig?: Config["plugins"];
+}): zustand0.StoreApi<PluginStore>;
+//#endregion
+//#region src/PluginContext/PluginManager.d.ts
+declare function PluginManager(): react_jsx_runtime4.JSX.Element | null;
+//#endregion
 //#region src/PreviewButton/PreviewButton.d.ts
 declare function PreviewButton({
   downloadEnabled,
@@ -1014,10 +1680,10 @@ declare function PreviewButton({
 }: {
   downloadEnabled?: boolean;
   fileName?: string;
-}): react_jsx_runtime9.JSX.Element;
+}): react_jsx_runtime4.JSX.Element;
 //#endregion
 //#region src/PreviewContext/PreviewContext.d.ts
-declare const PreviewProvider: react12.NamedExoticComponent<{
+declare const PreviewProvider: react4.NamedExoticComponent<{
   previews: Preview[];
   children: ReactNode;
   configs: PreviewConfiguration[];
@@ -1033,6 +1699,18 @@ declare function createPreviewVault(homepageCollectionId?: string): {
   readonly clearHistory: () => void;
 };
 //#endregion
+//#region src/PreviewVault/vault-message-bridge.d.ts
+type BridgeTarget = {
+  port: MessagePort;
+  lastActionId: string;
+};
+type VaultBridgeRegistry = {
+  originalDispatch: Vault["dispatch"];
+  patchedDispatch: Vault["dispatch"];
+  targets: Set<BridgeTarget>;
+};
+declare function createIframeVaultBridge(vault: Vault, port: MessagePort): () => void;
+//#endregion
 //#region src/PreviewVault/PreviewVault.d.ts
 declare function usePreviewVault(): Vault;
 declare const HOMEPAGE_COLLECTION = "manifest-editor://homepage-collection.json";
@@ -1042,18 +1720,18 @@ declare function usePreviewHistory(): {
 };
 declare function PreviewVaultContext(props: {
   children: any;
-}): react_jsx_runtime9.JSX.Element;
+}): react_jsx_runtime4.JSX.Element;
 declare function PreviewVaultBoundary({
   children
 }: {
   children: any;
-}): react_jsx_runtime9.JSX.Element;
+}): react_jsx_runtime4.JSX.Element;
 //#endregion
 //#region src/ResourceEditingContext/ResourceEditingContext.d.ts
 interface ResourceEditingContext {
   resource: Reference<any> | null;
 }
-declare const ResourceEditingReactContext: react12.Context<ResourceEditingContext>;
+declare const ResourceEditingReactContext: react4.Context<ResourceEditingContext>;
 declare function useEditingContext(): ResourceEditingContext;
 /**
  * useResource
@@ -1079,7 +1757,7 @@ declare function ResourceEditingProvider({
     type: string;
   } | null | undefined;
   children: ReactNode;
-}): react_jsx_runtime9.JSX.Element;
+}): react_jsx_runtime4.JSX.Element;
 //#endregion
 //#region src/ShellContext/ShellContext.d.ts
 declare function ShellProvider({
@@ -1089,7 +1767,8 @@ declare function ShellProvider({
   theme,
   previews,
   resource,
-  editing
+  editing,
+  backgroundActionPersistence
 }: {
   resource: Resource;
   config?: Partial<Config>;
@@ -1101,7 +1780,156 @@ declare function ShellProvider({
     id: string;
     type: string;
   };
-}): react_jsx_runtime9.JSX.Element;
+  backgroundActionPersistence?: BackgroundActionPersistence | false | null;
+}): react_jsx_runtime4.JSX.Element;
+//#endregion
+//#region src/SpecificationContext/SpecificationContext.types.d.ts
+type SpecificationEntityType = "Collection" | "Manifest" | "Canvas" | "Range" | "AnnotationPage" | "Annotation" | "ContentResource" | "Agent";
+type SpecificationPropertyPath = string[];
+type SpecificationJsonValue = null | string | number | boolean | SpecificationJsonValue[] | {
+  [key: string]: SpecificationJsonValue;
+};
+type SpecificationTextValue = string | {
+  [language: string]: string[];
+};
+type SpecificationRuleBase = {
+  id?: string;
+  label?: string;
+  description?: string;
+  message?: string;
+};
+type SpecificationPropertyRuleBase = SpecificationRuleBase & {
+  entityType: SpecificationEntityType;
+  path: SpecificationPropertyPath;
+};
+type DisallowPropertySpecificationRule = SpecificationPropertyRuleBase & {
+  type: "disallow-property";
+};
+type RequireNonEmptySpecificationRule = SpecificationPropertyRuleBase & {
+  type: "require-non-empty";
+};
+type FixedValueSpecificationRule = SpecificationPropertyRuleBase & {
+  type: "fixed-value";
+  value: SpecificationJsonValue;
+};
+type CanvasWithImageServiceSpecificationRule = SpecificationRuleBase & {
+  type: "iiif:canvas-with-image-service";
+  serviceId?: string;
+  serviceIds?: string[];
+};
+type ThumbnailFromBodyServiceSpecificationRule = SpecificationRuleBase & {
+  type: "iiif:thumbnail-from-body-service";
+  entityType?: "Manifest" | "Canvas";
+  requireThumbnail?: boolean;
+};
+type ValidRightsSpecificationRule = SpecificationRuleBase & {
+  type: "iiif:valid-rights";
+  entityType?: SpecificationEntityType;
+  allowed: string[];
+  required?: boolean;
+};
+type RequiredStatementSpecificationRule = SpecificationRuleBase & {
+  type: "iiif:required-statement";
+  entityType?: SpecificationEntityType;
+  label?: SpecificationTextValue;
+  value?: SpecificationTextValue;
+  valueRequired?: boolean;
+};
+type MetadataTemplateSpecificationRule = SpecificationRuleBase & {
+  type: "iiif:metadata-template";
+  entityType?: SpecificationEntityType;
+  items: Array<{
+    label: SpecificationTextValue;
+    value?: SpecificationTextValue;
+    valueRequired?: boolean;
+  }>;
+};
+type SpecificationRule = DisallowPropertySpecificationRule | RequireNonEmptySpecificationRule | FixedValueSpecificationRule | CanvasWithImageServiceSpecificationRule | ThumbnailFromBodyServiceSpecificationRule | ValidRightsSpecificationRule | RequiredStatementSpecificationRule | MetadataTemplateSpecificationRule;
+type ManifestEditorSpecification = {
+  id: string;
+  label: string;
+  description?: string;
+  version?: string;
+  terminology?: {
+    entities?: Partial<Record<SpecificationEntityType, string>>;
+    properties?: Array<{
+      entityType?: SpecificationEntityType;
+      path: SpecificationPropertyPath;
+      label: string;
+    }>;
+  };
+  rules: SpecificationRule[];
+};
+type SpecificationReportStatus = "satisfied" | "missing" | "invalid" | "disallowed" | "not-applicable";
+type SpecificationEditorTarget = {
+  resource: Reference;
+  propertyPath?: SpecificationPropertyPath;
+  selectedTab?: string;
+};
+type SpecificationReportItem = {
+  id: string;
+  specificationId: string;
+  specificationLabel: string;
+  ruleId: string;
+  ruleType: SpecificationRule["type"];
+  ruleLabel: string;
+  ruleIndex: number;
+  target?: Reference;
+  path?: SpecificationPropertyPath;
+  status: SpecificationReportStatus;
+  displayLabel: string;
+  message: string;
+  expected?: SpecificationJsonValue | SpecificationTextValue | string[];
+  actual?: unknown;
+  editorTarget?: SpecificationEditorTarget;
+};
+type SpecificationReport = {
+  specifications: ManifestEditorSpecification[];
+  results: SpecificationReportItem[];
+  counts: Record<SpecificationReportStatus, number>;
+};
+type SpecificationPropertyPolicy = {
+  entityType?: SpecificationEntityType;
+  path: SpecificationPropertyPath;
+  label?: string;
+  disallowed: boolean;
+  required: boolean;
+  fixedValue?: SpecificationJsonValue;
+  fixedValueRule?: FixedValueSpecificationRule;
+  rules: SpecificationRule[];
+};
+//#endregion
+//#region src/SpecificationContext/SpecificationContext.d.ts
+declare function SpecificationProvider({
+  children,
+  specifications
+}: {
+  children: ReactNode;
+  specifications?: ManifestEditorSpecification[];
+}): react_jsx_runtime4.JSX.Element;
+declare function useSpecifications(): ManifestEditorSpecification[];
+declare function useSpecificationReport(rootRef?: Reference): SpecificationReport;
+declare function useSpecificationTerminology(): {
+  getLabel(entityType: string | undefined, path: SpecificationPropertyPath | string | undefined, fallback?: string): string;
+};
+declare function useSpecificationPropertyPolicy(resourceRef: Reference | null | undefined, propertyPath: SpecificationPropertyPath | string): SpecificationPropertyPolicy;
+//#endregion
+//#region src/SpecificationContext/SpecificationContext.helpers.d.ts
+type CollectedResource = {
+  ref: Reference;
+  resource: any;
+};
+declare function normaliseSpecificationPath(path: SpecificationPropertyPath | string | undefined): SpecificationPropertyPath;
+declare function specificationPathEquals(a: SpecificationPropertyPath | string | undefined, b: SpecificationPropertyPath | string | undefined): boolean;
+declare function getValueAtPath(resource: any, path: SpecificationPropertyPath | string | undefined): unknown;
+declare function setValueAtPath(resource: any, path: SpecificationPropertyPath | string, value: unknown): any;
+declare function hasMeaningfulValue(value: unknown): boolean;
+declare function normaliseJsonValue(value: unknown): unknown;
+declare function specificationJsonEquals(a: unknown, b: unknown): boolean;
+declare function getTerminologyLabel(specifications: ManifestEditorSpecification[] | undefined, entityType: SpecificationEntityType | string | undefined, path: SpecificationPropertyPath | string | undefined, fallback?: string): string;
+declare function getPropertyPolicy(specifications: ManifestEditorSpecification[] | undefined, resource: Reference | null | undefined, path: SpecificationPropertyPath | string): SpecificationPropertyPolicy;
+declare function evaluateSpecifications(specifications: ManifestEditorSpecification[] | undefined, vault: Vault, rootRef: Reference): SpecificationReport;
+declare function collectSpecificationResources(vault: Vault, rootRef: Reference): CollectedResource[];
 //#endregion
 //#region src/TaskBridge/TaskBridge.d.ts
 interface Task<Req = any, Res = any> {
@@ -1124,11 +1952,32 @@ declare function TaskBridge({
   children
 }: {
   children?: ReactNode;
-}): react_jsx_runtime9.JSX.Element;
+}): react_jsx_runtime4.JSX.Element;
+//#endregion
+//#region src/Toast/ToastContext.d.ts
+type ToastVariant = ToastVariant$1;
+type ToastContent = ToastContent$1;
+interface ToastApi {
+  add(content: ToastContent, options?: ToastOptions): string;
+  info(content: ToastContent, options?: ToastOptions): string;
+  success(content: ToastContent, options?: ToastOptions): string;
+  warning(content: ToastContent, options?: ToastOptions): string;
+  error(content: ToastContent, options?: ToastOptions): string;
+  close(key: string): void;
+}
+interface ToastProviderProps {
+  children: ReactNode;
+  maxVisibleToasts?: number;
+}
+declare function ToastProvider({
+  children,
+  maxVisibleToasts
+}: ToastProviderProps): react_jsx_runtime4.JSX.Element;
+declare function useToasts(): ToastApi;
 //#endregion
 //#region src/Universal/UniversalCopyPaste.types.d.ts
 interface UniversalCopyPasteProps<T$1> {
-  as?: keyof JSX.IntrinsicElements | react12.ComponentType<T$1>;
+  as?: keyof JSX.IntrinsicElements | react4.ComponentType<T$1>;
   children?: ReactNode;
   reference?: Reference;
   onReference?: (reference: Reference) => void;
@@ -1158,7 +2007,7 @@ declare function UniversalCopyTarget<T$1>({
   onPasteLink: _onPasteLink,
   onPasteAnalysis: _onPasteAnalysis,
   ...props
-}: Partial<HTMLAttributes<HTMLElement>> & UniversalCopyPasteProps<T$1> & T$1): react_jsx_runtime9.JSX.Element;
+}: Partial<HTMLAttributes<HTMLElement>> & UniversalCopyPasteProps<T$1> & T$1): react_jsx_runtime4.JSX.Element;
 //#endregion
-export { AnnotationPanel, AppContext, AppExtension, AppHeader, AppMenuProvider, AppProvider, AppReactContext, AppResourceInstanceProvider, AppResourceProvider, AppState, AppStateReactContext, AtlasStoreProvider, AtlasStoreReactContext, BackgroundPanel, BaseAnnotationCreator, BaseEditor, BaseEditorBackButton, BaseEditorCloseButton, CanvasEditorDefinition, Config, ConfigEditor, ConfigProvider, ConfigReactContext, ContextMenuItem, ContextMenuProvider, ContextMenuReactContext, ContextMenuRequest, CreatorInitialData, EditableResource, EditingStack, EditingStackActionCreators, EditingStackActions, EditingStackContext, EditingStackState, EditorConfig, EditorDefinition, EventEmitterProvider, ExportPanel, ExportPanelProps, HOMEPAGE_COLLECTION, HandleContainer, HandleControls, InlineEditingStack, Layout, LayoutActions, LayoutActionsReactContext, LayoutContext, LayoutFunction, LayoutPanel, LayoutPanelContext, LayoutProps, LayoutProviderProps, LayoutState, LayoutStateReactContext, LoadedApp, MappedApp, MenuPositions, ModularPanel, ModularPanelHeader, ModulePanelButton, MultiAppContext, MultiAppProvider, PanelActionType, PanelActions, PanelError, PanelState, PinnablePanelActions, PinnablePanelState, PinnedLayoutPanel, Preview, PreviewActions, PreviewActionsType, PreviewButton, PreviewConfiguration, PreviewContext, PreviewHandler, PreviewProvider, PreviewState, PreviewVaultBoundary, PreviewVaultContext, PrimeAppReactContext, ReactEmitterContext, Resource, ResourceDefinition, ResourceEditingProvider, ResourceEditingReactContext, SaveConfigReactContext, ShellProvider, TaskBridge, UniversalCopyPasteProps, UniversalCopyTarget, UploadBackendConfig, analyse, analyseJson, baseCreator, baseEditor, copyToClipboard, createActionIdentity, createDownload, createPreviewVault, detectMedia, editBasedOnResource, extendApp, getDefaultLayoutState, getDefaultPanelState, getFormat, getImageDimensions, getManifestNomalized, isPinnableState, layoutReducer, mapApp, panelSizing, polygonToBoundingBox, randomId, renderHelper, useAnnotationCreatorState, useAnnotationPageEditor, useApp, useAppInstance, useAppMenu, useAppMenuItem, useAppResource, useAppResourceInstance, useAppState, useApps, useAtlasStore, useAvailableLayouts, useCollectionEditor, useConfig, useCreatingResource, useCreator, useCustomContextMenu, useDecayState, useEditingContext, useEditingResource, useEditingResourceStack, useEditingStack, useEditor, useEmitter, useEvent, useGenericEditor, useHighlightedImageResource, useHoverHighlightImageResource, useInitialData, useInlineCreator, useLayoutActions, useLayoutProvider, useLayoutState, useLocalStorage, useManifestEditor, useMatchMedia, useOptionalLocalStorage, useOptionalResource, usePanelActions, usePreviewContext, usePreviewHistory, usePreviewVault, usePreviews, useResource, useResourceContextMenuItems, useSaveConfig, useSaveVault, useSetCustomTitle, useSvgTools, useTask, useTaskDispatch, useTaskEvent, useTaskRunner, useTemporaryHighlight };
+export { AnnotationPanel, AppContext, AppExtension, AppHeader, AppMenuProvider, AppProvider, AppReactContext, AppResourceInstanceProvider, AppResourceProvider, AppState, AppStateReactContext, AtlasStoreProvider, AtlasStoreReactContext, AvailableBackgroundAction, BackgroundActionContext, BackgroundActionDefinition, BackgroundActionError, BackgroundActionEvent, BackgroundActionEventType, BackgroundActionGroup, BackgroundActionInstance, BackgroundActionLifecycle, BackgroundActionLogEntry, BackgroundActionLogLevel, BackgroundActionPersistedState, BackgroundActionPersistence, BackgroundActionPersistenceKey, BackgroundActionPlan, BackgroundActionProgress, BackgroundActionProgressInput, BackgroundActionRenderContext, BackgroundActionRunContext, BackgroundActionStatus, BackgroundActionSystemContext, BackgroundActionTarget, BackgroundActionTask, BackgroundActionTaskRunOptions, BackgroundActionTaskRunResult, BackgroundActionTaskStatus, BackgroundActionTasksApi, BackgroundActionToasts, BackgroundActionsMenu, BackgroundActionsMount, BackgroundActionsProvider, BackgroundActionsReactContext, BackgroundActionsStore, BackgroundPanel, BaseAnnotationCreator, BaseEditor, BaseEditorBackButton, BaseEditorCloseButton, CANVAS_PROGRESS_META_NAMESPACE, CANVAS_PROGRESS_STATUS_META_KEY, CanvasEditorDefinition, CanvasProgressActiveStatus, CanvasProgressResource, CanvasProgressStatus, CanvasProgressStatusInput, CanvasWithImageServiceSpecificationRule, Config, ConfigEditor, ConfigProvider, ConfigReactContext, ContextMenuItem, ContextMenuProvider, ContextMenuReactContext, ContextMenuRequest, CreatorInitialData, DisallowPropertySpecificationRule, EditableResource, EditingStack, EditingStackActionCreators, EditingStackActions, EditingStackContext, EditingStackState, EditorConfig, EditorDefinition, EventEmitterProvider, ExportPanel, ExportPanelProps, FLAG_TAG, FixedValueSpecificationRule, GetAvailableBackgroundActionGroupsOptions, HOMEPAGE_COLLECTION, HandleContainer, HandleControls, InlineEditingStack, Layout, LayoutActions, LayoutActionsReactContext, LayoutContext, LayoutFunction, LayoutModeReactContext, LayoutPanel, LayoutPanelContext, LayoutPanelFocusedModeContext, LayoutPanelSupportContext, LayoutProps, LayoutProviderProps, LayoutRenderProps, LayoutState, LayoutStateReactContext, LazyPluginModule, LoadedApp, ManifestEditorCanvasProgressApi, ManifestEditorCanvasProgressOverlay, ManifestEditorSpecification, ManifestEditorTag, ManifestEditorTagBadge, ManifestEditorTagGroup, ManifestEditorTagGroupRow, ManifestEditorTagIcon, ManifestEditorTagOverlay, ManifestEditorTagResource, ManifestEditorTagsApi, ManifestPaginationNavigation, ManifestPaginationNavigationProps, MappedApp, MappedPlugin, MenuPositions, MessagePortClientVault, MetadataTemplateSpecificationRule, ModularPanel, ModularPanelHeader, ModulePanelButton, MultiAppContext, MultiAppProvider, PanelActionType, PanelActions, PanelError, PanelState, PinnablePanelActions, PinnablePanelState, PinnedLayoutPanel, PluginAppConfig, PluginConfigBridge, PluginConfigScope, PluginGlobalConfigReactContext, PluginHostApp, PluginInput, PluginManager, PluginMetadata, PluginModule, PluginProvider, PluginReactContext, PluginRuntimeApi, PluginSettingsDefinition, PluginSettingsField, PluginSettingsFieldOption, PluginSettingsRecord, PluginSettingsRenderContext, PluginSettingsValue, PluginStore, PluginStoreSnapshot, Preview, PreviewActions, PreviewActionsType, PreviewButton, PreviewConfiguration, PreviewContext, PreviewHandler, PreviewProvider, PreviewState, PreviewVaultBoundary, PreviewVaultContext, PrimeAppReactContext, ReactEmitterContext, type RemoteVaultAction, type RemoteVaultClientMessage, RequireNonEmptySpecificationRule, RequiredStatementSpecificationRule, Resource, ResourceDefinition, ResourceEditingProvider, ResourceEditingReactContext, RunBackgroundActionOptions, SaveConfigReactContext, ShellProvider, SpecificationEditorTarget, SpecificationEntityType, SpecificationJsonValue, SpecificationPropertyPath, SpecificationPropertyPolicy, SpecificationPropertyRuleBase, SpecificationProvider, SpecificationReport, SpecificationReportItem, SpecificationReportStatus, SpecificationRule, SpecificationRuleBase, SpecificationTextValue, TAGS_META_KEY, TAGS_META_NAMESPACE, TaskBridge, ThumbnailFromBodyServiceSpecificationRule, ToastApi, ToastContent, ToastProvider, ToastVariant, UniversalCopyPasteProps, UniversalCopyTarget, UploadBackendConfig, ValidRightsSpecificationRule, VaultBridgeRegistry, addResourceTag, analyse, analyseJson, applyPlugins, baseCreator, baseEditor, clearCanvasProgressStatus, clearCanvasProgressStatuses, collectSpecificationResources, copyToClipboard, createActionIdentity, createBackgroundActionsStore, createDownload, createIframeVaultBridge, createLocalForageBackgroundActionPersistence, createManifestEditorCanvasProgressApi, createManifestEditorTagsApi, createPluginRuntimeApi, createPluginStore, createPreviewVault, createTrackingCanvasProgressApi, detectMedia, disablePluginInConfig, editBasedOnResource, enablePluginAndDependenciesInConfig, enablePluginInConfig, evaluateSpecifications, extendApp, filterSupportedPanels, getAvailableBackgroundActionGroups, getBackgroundActionInstanceKey, getCanvasProgressStatus, getCanvasProgressStatusFromState, getDefaultLayoutState, getDefaultPanelState, getEffectivePluginSettings, getEmptyPluginState, getEnabledPluginsForApp, getFormat, getImageDimensions, getManifestNomalized, getPluginCompatibilityReason, getPluginDefaultSettings, getPluginSelectionSource, getPluginSettingsFromConfig, getPropertyPolicy, getResourceTag, getResourceTagGroups, getResourceTags, getResourceTagsFromState, getSupportedPanelFallback, getTerminologyLabel, getValueAtPath, hasMeaningfulValue, hasResourceTag, isLazyPlugin, isMappedPlugin, isPinnableState, isPluginCompatible, isPluginSelected, layoutReducer, mapApp, mapLazyPlugin, mapPlugin, mergeBackgroundActionDefinitions, mergeConfig, mergePartialConfig, mergeProviderPlugins, normaliseBackgroundActionError, normaliseJsonValue, normalisePlugin, normalisePluginAppConfig, normalisePluginAppsConfig, normalisePlugins, normaliseSpecificationPath, panelIds, panelSizing, pluginAppConfigEquals, polygonToBoundingBox, randomId, removeResourceTag, renderHelper, resetPluginInConfig, resetPluginSettingsInConfig, runBackgroundAction, setCanvasProgressStatus, setCanvasProgressStatuses, setPluginSettingsInConfig, setResourceTags, setValueAtPath, sortBackgroundActionDefinitions, specificationJsonEquals, specificationPathEquals, toggleResourceTag, useAnnotationCreatorState, useAnnotationPageEditor, useApp, useAppInstance, useAppMenu, useAppMenuItem, useAppResource, useAppResourceInstance, useAppState, useApps, useAtlasStore, useAvailableBackgroundActions, useAvailableLayouts, useBackgroundActionHistory, useBackgroundActionInstance, useBackgroundActionsStore, useBackgroundActionsStoreApi, useCanvasProgressActions, useCanvasProgressStatus, useCollectionEditor, useConfig, useCreatingResource, useCreator, useCustomContextMenu, useDecayState, useEditingContext, useEditingResource, useEditingResourceStack, useEditingStack, useEditor, useEmitter, useEnabledPlugins, useEvent, useGenericEditor, useHighlightedImageResource, useHoverHighlightImageResource, useInitialData, useInlineCreator, useLayoutActions, useLayoutMode, useLayoutProvider, useLayoutState, useLocalStorage, useManifestEditor, useMatchMedia, useOptionalLocalStorage, useOptionalPluginStoreApi, useOptionalResource, usePanelActions, usePluginActions, usePluginConfigApi, usePluginRuntimeApi, usePluginSettings, usePluginStoreApi, usePlugins, usePreviewContext, usePreviewHistory, usePreviewVault, usePreviews, useResolvedPluginApp, useResource, useResourceContextMenuItems, useResourceTagActions, useResourceTags, useSaveConfig, useSaveVault, useSetCustomTitle, useSpecificationPropertyPolicy, useSpecificationReport, useSpecificationTerminology, useSpecifications, useSvgTools, useTask, useTaskDispatch, useTaskEvent, useTaskRunner, useTemporaryHighlight, useToasts };
 //# sourceMappingURL=index.d.cts.map