@dolphy-app/extension-sdk 0.4.0 → 0.6.0

package/dist/testing.d.ts

@@ -1,5 +1,7 @@
-import { t as AnswerView } from "./answer-view-D6wnyThb.js";
-import { AnswerChangeDetail, AnswerElementProps, CommandOutcome, ExportInput, ExportResult, ExtensionCommands, ExtensionEvents, ExtensionExporters, ExtensionImporters, ExtensionLogger, ExtensionModule, ExtensionNotification, ExtensionNotifications, ExtensionSchedule, ExtensionSecrets, ExtensionSettings, ExtensionStats, ExtensionStorage, GradePolicyInput, GradeResult, GradeValue, ImportInput, ImportResult, ImporterInputKind, JsonSchema, JsonValue, LearningEventName, LearningEventPayloads, LibraryReader, PanelContextInfo, PanelModule, SettingContribution, SettingValue, WidgetModule } from "@dolphy-app/extension-api";
+import { t as ExtensionEngine } from "./index-I_CXC6Lj.js";
+import { a as MountContext$1, i as InjectionRegistration$1, l as ServerEntry$1, o as Mountable, r as ClientEntry, s as PanelRegistration$1, t as AppApi$1 } from "./define-entry-lsuxzKdD.js";
+import { AnswerViewProps, AppLocale, AppTheme, ClientCommandRegistration, CommandOutcome, Disposable, ExportInput, ExportResult, ExtensionHookName, ExtensionLogger, ExtensionNotification, ExtensionNotifications, ExtensionSecrets, ExtensionSettings, ExtensionStats, ExtensionStorage, GradePolicyInput, GradeResult, GradeValue, HookRequest, HookResponse, ImportInput, ImportResult, JsonSchema, JsonValue, LearningEventName, LearningEventPayloads, LibraryReader, MarkdownBlockProps, RpcContract, ServerRegistration, SettingDefinition, SettingValue, ThemeRegistration } from "@dolphy-app/extension-api";
+import { Component } from "vue";
 //#region packages/extension-sdk/src/testing.d.ts
 export declare const createMemoryLibrary: (files: Readonly<Record<string, string>>) => LibraryReader;
 /**
@@ -31,105 +33,15 @@ export interface MemorySettings extends ExtensionSettings {
    * Unlike the host, a handler failure is not swallowed but rejects the promise.
    */
   set(id: string, value: SettingValue): Promise<void>;
+  /** Adds definitions, as `server.registerSettings` does; an id registered twice throws. The returned `Disposable` removes them. */
+  register(definitions: readonly SettingDefinition[]): Disposable;
 }
-/** In-memory settings from manifest definitions; `initial` provides user values in place of `default`. */
-export declare const createMemorySettings: (definitions: readonly SettingContribution[], initial?: Readonly<Record<string, SettingValue>>) => MemorySettings;
-export interface MemoryEvents extends ExtensionEvents {
-  /**
-   * Sends the event to the subscribed handler and awaits it. With no subscription,
-   * the event is skipped, as in the host. Unlike the host, a handler failure
-   * is not swallowed but rejects the promise, and the 2 s handler timeout is not applied.
-   */
-  emit<N extends LearningEventName>(name: N, payload: LearningEventPayloads[N]): Promise<void>;
-}
-export interface MemoryEventsOptions {
-  /** Events from `contributes.events`: subscribing to another throws, as in the host. Unset — any are allowed. */
-  declared?: readonly LearningEventName[];
-  /** false — subscribing throws `PermissionError`, as for an extension without `learning.events`. Defaults to true. */
-  permitted?: boolean;
-}
-/** In-memory learning event subscriptions: one handler per event, as in the host. */
-export declare const createMemoryEvents: (options?: MemoryEventsOptions) => MemoryEvents;
-export interface MemoryCommands extends ExtensionCommands {
-  /**
-   * Runs a registered command the way the host does: the same
-   * argument and result bounds, the same result normalization. An unregistered
-   * command and an invalid result reject the promise. The 10 s handler timeout is not applied.
-   */
-  run(id: string, args?: JsonValue): Promise<CommandOutcome>;
-  /** Registered commands in registration order. */
-  ids(): string[];
-}
-export interface MemoryCommandsOptions {
-  /** Commands from `contributes.commands`: registering another throws, as in the host. Unset — any are allowed. */
-  declaredCommands?: readonly string[];
-  /** Panels from `contributes.panels`: `openPanel` on another is invalid, as in the host. Unset — any. */
-  declaredPanels?: readonly string[];
-}
-/** In-memory commands: the same registration rules and result parsing as the host. */
-export declare const createMemoryCommands: (options?: MemoryCommandsOptions) => MemoryCommands;
-export interface MemorySchedule extends ExtensionSchedule {
-  /**
-   * Fires a schedule the way the host does and awaits the handler: resolves
-   * `true` once the handler returned. With no subscription, or while the
-   * handler of the previous firing is still running, the firing is skipped and
-   * resolves `false`. Unlike the host, a handler failure is not swallowed but
-   * rejects the promise, and the 10 s handler timeout is not applied.
-   */
-  fire(id: string): Promise<boolean>;
-  /** Subscribed schedules in subscription order. */
-  ids(): string[];
-}
-export interface MemoryScheduleOptions {
-  /** Schedules from `contributes.schedules`: subscribing to another throws, as in the host. Unset — any are allowed. */
-  declared?: readonly string[];
-}
-/** In-memory schedule subscriptions: one handler per schedule and no overlapping firings, as in the host. */
-export declare const createMemorySchedule: (options?: MemoryScheduleOptions) => MemorySchedule;
-export interface MemoryImporters extends ExtensionImporters {
-  /**
-   * Runs a registered importer the way the host does: the input must have the
-   * form the importer declares (`text` unless `input: 'bytes'`) and at most
-   * `EXTENSION_TRANSFER_LIMITS.inputBytes`; the result goes through the host's
-   * rules (`normalizeImportResult`: paths, sizes, number of files). An
-   * unregistered importer and an invalid result reject the promise. The 30 s
-   * handler timeout is not applied.
-   */
-  run(id: string, input: ImportInput): Promise<ImportResult>;
-  /** Registered importers in registration order. */
-  ids(): string[];
-}
-export interface MemoryImportersOptions {
-  /** Importers from `contributes.importers`: registering another throws and `input` is checked, as in the host. Unset — any are allowed. */
-  declaredImporters?: readonly {
-    id: string;
-    input?: ImporterInputKind;
-  }[];
-}
-/** In-memory importers: the same registration rules and result checks as the host. */
-export declare const createMemoryImporters: (options?: MemoryImportersOptions) => MemoryImporters;
-export interface MemoryExporters extends ExtensionExporters {
-  /**
-   * Runs a registered exporter the way the host does: the input must match the
-   * exporter's declared `scope` and a course snapshot is at most
-   * `EXTENSION_TRANSFER_LIMITS.totalBytes`; the result goes through the host's
-   * rules (`normalizeExportResult`: file name, size, `text` xor `bytes`). An
-   * unregistered exporter and an invalid result reject the promise. The 30 s
-   * handler timeout is not applied.
-   */
-  run(id: string, input: ExportInput): Promise<ExportResult>;
-  /** Registered exporters in registration order. */
-  ids(): string[];
-}
-export interface MemoryExportersOptions {
-  /** Exporters from `contributes.exporters`: registering another throws and `scope` is checked, as in the host. Unset — any are allowed. */
-  declaredExporters?: readonly {
-    id: string;
-    scope: ExportInput['scope'];
-  }[];
-}
-/** In-memory exporters: the same registration rules and result checks as the host. */
-export declare const createMemoryExporters: (options?: MemoryExportersOptions) => MemoryExporters;
+/**
+ * In-memory settings. `definitions` are registered at once, more come through
+ * `register`; `initial` provides user values in place of `default`, applied
+ * when the setting with that id is registered.
+ */
+export declare const createMemorySettings: (definitions?: readonly SettingDefinition[], initial?: Readonly<Record<string, SettingValue>>) => MemorySettings;
 export interface MemoryStatsAttempt {
   /** When the attempt happened: epoch milliseconds, a `Date`, or an ISO-8601 string. */
   at: number | Date | string;
@@ -145,8 +57,6 @@ export interface MemoryStatsOptions {
   timeZone?: string;
   /** The current time, for the `current` streak. Defaults to `Date.now`. */
   now?: () => number;
-  /** false — every call rejects with `PermissionError('learning.stats')`, as for an extension without the permission. Defaults to true. */
-  permitted?: boolean;
 }
 export interface MemoryStats extends ExtensionStats {
   /** Adds an attempt to the history. */
@@ -159,8 +69,6 @@ export interface MemoryStats extends ExtensionStats {
  */
 export declare const createMemoryStats: (options?: MemoryStatsOptions) => MemoryStats;
 export interface MemoryNotificationsOptions {
-  /** false — every call rejects with `PermissionError('notifications')`, as for an extension without the permission. Defaults to true. */
-  permitted?: boolean;
   /** false — the operating system does not support notifications: `show` resolves `false`. Defaults to true. */
   supported?: boolean;
   /** false — the user switched notifications off for the extension: `show` resolves `false`. Defaults to true. */
@@ -184,23 +92,23 @@ export interface MemoryNotifications extends ExtensionNotifications {
  * would keep.
  */
 export declare const createMemoryNotifications: (options?: MemoryNotificationsOptions) => MemoryNotifications;
-/** What a test replaces in the extension context; by default everything is in memory and silent. */
-export interface LoadOptions {
+export declare const createSchemaValidator: (schema: JsonSchema) => (value: unknown) => string[];
+/** What a test replaces in the context of the server part; by default everything is in memory and silent. */
+export interface TestServerOptions {
+  /** Default `test`. When set, every registered id must be equal to it or start with `<extensionId>.`, as the host checks. */
+  extensionId?: string;
   library?: LibraryReader;
   logger?: ExtensionLogger;
   storage?: ExtensionStorage;
-  secrets?: ExtensionSecrets;
-  settings?: ExtensionSettings;
-  events?: ExtensionEvents;
-  commands?: ExtensionCommands;
-  importers?: ExtensionImporters;
-  exporters?: ExtensionExporters;
-  stats?: ExtensionStats;
-  notifications?: ExtensionNotifications;
-  schedule?: ExtensionSchedule;
+  secrets?: MemorySecrets;
+  stats?: MemoryStats;
+  notifications?: MemoryNotifications;
+  /** User values of settings in place of `default`, by setting id; every id must be registered by the entry. */
+  settingValues?: Readonly<Record<string, SettingValue>>;
+  /** The engine `ctx.engine` gives to the entry; by default every use of it throws, as the test server has no engine. */
+  engine?: ExtensionEngine;
 }
-export declare const createSchemaValidator: (schema: JsonSchema) => (value: unknown) => string[];
-export interface LoadedExerciseType {
+export interface TestExerciseType {
   project(spec: unknown, options?: {
     exerciseId?: string;
   }): Promise<unknown>;
@@ -219,141 +127,176 @@ export interface LoadedExerciseType {
   } | {
     found: false;
   }>;
-  /** Deactivates the extension module. */
-  dispose(): Promise<void>;
 }
-export declare const loadExerciseType: (module: ExtensionModule, type: string, options?: LoadOptions) => Promise<LoadedExerciseType>;
-export interface LoadedGradePolicy {
+export interface TestGradePolicy {
   evaluate(input: GradePolicyInput): Promise<GradeValue | null>;
-  /** Deactivates the extension module. */
-  dispose(): Promise<void>;
 }
-export declare const loadGradePolicy: (module: ExtensionModule, id: string, options?: LoadOptions) => Promise<LoadedGradePolicy>;
-export interface LoadedEvents {
-  /** Events are delivered as in the host: to the subscribed handler, one at a time. See `MemoryEvents.emit`. */
-  emit: MemoryEvents['emit'];
-  storage: ExtensionStorage;
-  secrets: ExtensionSecrets;
-  settings: MemorySettings;
-  /** Deactivates the extension module. */
-  dispose(): Promise<void>;
+export interface TestImporter {
+  /**
+   * Runs the importer the way the host does: the input must have the form the
+   * importer declares and at most `EXTENSION_TRANSFER_LIMITS.inputBytes`; the
+   * result goes through `normalizeImportResult`. An invalid result rejects the
+   * promise. The handler timeout is not applied.
+   */
+  run(input: ImportInput): Promise<ImportResult>;
 }
-export interface LoadEventsOptions extends Omit<LoadOptions, 'storage' | 'secrets' | 'settings' | 'events'>, MemoryEventsOptions {
-  storage?: ExtensionStorage;
-  secrets?: ExtensionSecrets;
-  /** Definitions from the manifest's `contributes.settings`; values are read and changed through `settings`. */
-  settings?: readonly SettingContribution[];
-  /** User values in place of `default`. */
-  settingValues?: Readonly<Record<string, SettingValue>>;
+export interface TestExporter {
+  /**
+   * Runs the exporter the way the host does: the input must match the
+   * exporter's `scope` and a course snapshot is at most
+   * `EXTENSION_TRANSFER_LIMITS.totalBytes`; the result goes through
+   * `normalizeExportResult`. An invalid result rejects the promise. The handler
+   * timeout is not applied.
+   */
+  run(input: ExportInput): Promise<ExportResult>;
+}
+/** The server part of an extension, started on in-memory fakes. */
+export interface TestServer {
+  readonly extensionId: string;
+  /** What the entry registered, as the host's registrar hands it to the engine (checked for types and unique ids only: the host checks the rest). */
+  readonly registration: ServerRegistration;
+  readonly library: LibraryReader;
+  readonly storage: ExtensionStorage;
+  readonly secrets: MemorySecrets;
+  readonly settings: MemorySettings;
+  readonly stats: MemoryStats;
+  readonly notifications: MemoryNotifications;
+  /** The engine of the context: `options.engine`. */
+  readonly engine: ExtensionEngine;
+  readonly commands: {
+    /**
+     * Runs a registered command the way the host does: the same argument and
+     * result bounds, the same result normalization. An unregistered command
+     * and an invalid result reject the promise. The handler timeout is not applied.
+     */
+    run(id: string, args?: JsonValue): Promise<CommandOutcome>;
+  };
+  readonly events: {
+    /**
+     * Sends the event to the subscribed handler and awaits it. With no
+     * subscription the event is skipped, as in the host. Unlike the host, a
+     * handler failure is not swallowed but rejects the promise, and the
+     * handler timeout is not applied.
+     */
+    emit<N extends LearningEventName>(name: N, payload: LearningEventPayloads[N]): Promise<void>;
+  };
+  /**
+   * Calls the handler registered with `server.before` the way the host does:
+   * the request must pass `EXTENSION_HOOKS[name].request` and the response
+   * `EXTENSION_HOOKS[name].response`. An unregistered hook, a schema
+   * violation and an error of the handler reject the promise. The handler
+   * timeout is not applied, and no other extension's handlers run.
+   */
+  hook<N extends ExtensionHookName>(name: N, request: HookRequest<N>): Promise<HookResponse<N>>;
+  readonly schedule: {
+    /**
+     * Fires a registered schedule the way the host does and awaits the
+     * handler: resolves `true` once the handler returned, `false` while the
+     * handler of the previous firing is still running. An unregistered
+     * schedule rejects the promise. Unlike the host, a handler failure is not
+     * swallowed but rejects the promise.
+     */
+    fire(id: string): Promise<boolean>;
+  };
+  exerciseType(id: string): TestExerciseType;
+  gradePolicy(id: string): TestGradePolicy;
+  importer(id: string): TestImporter;
+  exporter(id: string): TestExporter;
+  /**
+   * Calls the handler registered with `server.handle` under `contract.name`
+   * the way the host does: the input must serialize to at most
+   * `EXTENSION_RPC_LIMITS.inputChars` characters and pass the input schema
+   * the handler registered; the result must pass the output schema. An
+   * unregistered contract, a schema violation and an error of the handler
+   * reject the promise. The handler timeout is not applied.
+   */
+  rpc<Input, Output>(contract: RpcContract<Input, Output>, input: Input): Promise<Output>;
+  /** Runs the cleanup the entry returned and removes the registrations. */
+  dispose(): Promise<void>;
 }
 /**
- * Activates the module with in-memory storage, settings, and events, and lets the test
- * send events and change settings.
+ * Starts `entry` (the `server` export of an extension) with in-memory
+ * storage, secrets, settings, statistics, notifications and library, and
+ * returns a harness to call what it registered. Registration is all or
+ * nothing, as in the host: when `entry` throws, so does `createTestServer`.
  */
-export declare const loadEvents: (module: ExtensionModule, options?: LoadEventsOptions) => Promise<LoadedEvents>;
-export interface LoadedCommands {
-  run: MemoryCommands['run'];
-  ids: MemoryCommands['ids'];
-  /** Deactivates the extension module. */
+export declare const createTestServer: (entry: ServerEntry$1, options?: TestServerOptions) => Promise<TestServer>;
+/** An answer view as registered: a Vue component or a `Mountable`. */
+export type AnswerViewComponent = Component | Mountable<AnswerViewProps>;
+/** A markdown renderer as registered: a Vue component or a `Mountable`. */
+export type MarkdownRendererComponent = Component | Mountable<MarkdownBlockProps>;
+/** The client part of an extension, started on a recording context. */
+export interface TestClient {
+  readonly extensionId: string;
+  readonly panels: readonly PanelRegistration$1[];
+  /** Injections as registered, with `position` defaulted to `append`. */
+  readonly injections: readonly Required<InjectionRegistration$1>[];
+  /** Answer views by exercise type id, as registered (a Vue component or a `Mountable`). */
+  readonly answerViews: ReadonlyMap<string, AnswerViewComponent>;
+  /** Markdown renderers by block language, as registered (a Vue component or a `Mountable`). */
+  readonly markdownRenderers: ReadonlyMap<string, MarkdownRendererComponent>;
+  readonly themes: readonly ThemeRegistration[];
+  readonly commands: readonly ClientCommandRegistration[];
+  /** Runs the cleanup the entry returned and removes the registrations. */
   dispose(): Promise<void>;
 }
-export interface LoadCommandsOptions extends Omit<LoadOptions, 'commands'>, MemoryCommandsOptions {}
-/** Activates the module with in-memory commands and lets the test invoke them like the host. */
-export declare const loadCommands: (module: ExtensionModule, options?: LoadCommandsOptions) => Promise<LoadedCommands>;
-export interface LoadedImporters {
-  run: MemoryImporters['run'];
-  ids: MemoryImporters['ids'];
-  /** Deactivates the extension module. */
-  dispose(): Promise<void>;
-}
-export interface LoadImportersOptions extends Omit<LoadOptions, 'importers'>, MemoryImportersOptions {}
-/** Activates the module with in-memory importers and lets the test run them like the host. */
-export declare const loadImporters: (module: ExtensionModule, options?: LoadImportersOptions) => Promise<LoadedImporters>;
-export interface LoadedExporters {
-  run: MemoryExporters['run'];
-  ids: MemoryExporters['ids'];
-  /** Deactivates the extension module. */
-  dispose(): Promise<void>;
-}
-export interface LoadExportersOptions extends Omit<LoadOptions, 'exporters'>, MemoryExportersOptions {}
-/** Activates the module with in-memory exporters and lets the test run them like the host; `stats` feeds `ctx.stats` of a progress exporter. */
-export declare const loadExporters: (module: ExtensionModule, options?: LoadExportersOptions) => Promise<LoadedExporters>;
-export interface LoadedSchedules {
-  fire: MemorySchedule['fire'];
-  ids: MemorySchedule['ids'];
-  /** Deactivates the extension module. */
-  dispose(): Promise<void>;
-}
-export interface LoadSchedulesOptions extends Omit<LoadOptions, 'schedule'>, MemoryScheduleOptions {}
-/** Activates the module with in-memory schedules and lets the test fire them like the host. */
-export declare const loadSchedules: (module: ExtensionModule, options?: LoadSchedulesOptions) => Promise<LoadedSchedules>;
-export interface LoadViewOptions extends Partial<AnswerElementProps> {
-  /** `aria-label` of the host element, as the app sets it. */
-  label?: string;
-  /** Where to mount; defaults to a new `div` in `document.body`. */
-  container?: HTMLElement;
-}
-export interface LoadedView {
-  /** The kind's custom element, as the app creates it. */
-  readonly element: HTMLElement;
-  /** The element's shadow root: the view renders its UI here. */
-  readonly root: ShadowRoot;
-  /** `dolphy-answer-change` events in order. */
-  readonly changes: readonly AnswerChangeDetail[];
-  /** How many times the view asked to submit the answer (`dolphy-answer-submit`). */
-  readonly submissions: number;
-  /** Sets element properties and waits for the view to apply the update. */
-  update(props: Partial<AnswerElementProps>): Promise<void>;
-  query<E extends Element = Element>(selector: string): E | null;
-  queryAll<E extends Element = Element>(selector: string): E[];
-  /** Removes the element from the document; the view receives `destroy()`. */
-  dispose(): void;
+export interface TestClientOptions {
+  /** Default `test`. When set, every registered id must be equal to it or start with `<extensionId>.`, as the window checks. */
+  extensionId?: string;
+  /** The window API `client.app` gives to the entry; by default every use of it throws, as the test client has no window. */
+  app?: AppApi$1;
+  /** The engine `client.engine` gives to the entry; by default every use of it throws. */
+  engine?: ExtensionEngine;
 }
 /**
- * Mounts a view from `views[id]` in the test DOM environment with the same element
- * the app creates (test tags are issued; the manifest `element` is not needed).
+ * Starts `entry` (the `client` export of an extension) on a context that
+ * records what it adds, so a test can mount the components and read the
+ * themes and commands. An id added twice and an injection with a bad target
+ * or position fail like in the window.
  */
-export declare const loadView: (views: Readonly<Record<string, AnswerView>>, id: string, options?: LoadViewOptions) => Promise<LoadedView>;
-export interface LoadPanelOptions {
-  /** Properties the panel was opened with (`openPanel(id, props)`). */
-  props?: JsonValue;
-  /** Reply to `ctx.call`; by default the call is rejected. */
-  call?: (commandId: string, args: JsonValue | undefined) => JsonValue | undefined | Promise<JsonValue | undefined>;
-  /** The surroundings the frame starts with (`ctx.context`); defaults to all courses (`courseId: null`). */
-  context?: PanelContextInfo;
-  /** Where to mount; defaults to a new `div` in `document.body`. */
-  container?: HTMLElement;
-}
-export interface LoadWidgetOptions {
-  /** Reply to `ctx.call`; by default the call is rejected. */
-  call?: LoadPanelOptions['call'];
-  /** The surroundings the frame starts with (`ctx.context`); defaults to all courses (`courseId: null`). */
-  context?: PanelContextInfo;
-  /** Where to mount; defaults to a new `div` in `document.body`. */
-  container?: HTMLElement;
-}
-export interface LoadedFrame {
-  /** Container the module received in `mount`. */
-  readonly container: HTMLElement;
-  /** `ctx.call` invocations in order. */
-  readonly calls: readonly {
-    commandId: string;
-    args: JsonValue | undefined;
-  }[];
-  /** Whether `ctx.signal` was aborted (after `dispose()`). */
-  readonly aborted: boolean;
-  /** The app focused another course: updates `ctx.context` and notifies `ctx.onContextChange` subscribers. */
-  setContext(context: PanelContextInfo): void;
-  /** Closes the frame: aborts `ctx.signal` and removes the container. */
-  dispose(): void;
+export declare const createTestClient: (entry: ClientEntry, options?: TestClientOptions) => Promise<TestClient>;
+/** What `mountForTest` gives `ctx`; everything is optional except `props`. */
+export interface MountForTestOptions<Props, Handle = undefined> {
+  /** The first `ctx.props`. */
+  props: Props;
+  /** The element to draw into; by default a new `<div>` of the global `document`. Required without a DOM. */
+  el?: HTMLElement;
+  /** `ctx.handle`: a panel or injection handle; `undefined` by default. */
+  handle?: Handle;
+  /** `ctx.app`; by default every use of it throws, as the test has no window. */
+  app?: AppApi$1;
+  /** `ctx.engine`, the engine of `ctx.callRpc`; by default every use of it throws. */
+  engine?: ExtensionEngine;
+  /** Default `{ id: 'light', dark: false }`. */
+  theme?: AppTheme;
+  /** Default `en`. */
+  locale?: AppLocale;
+  /** Default `test`. */
+  extensionId?: string;
+}
+/** A `Mountable` mounted by `mountForTest`. */
+export interface MountedForTest<Props, Handle = undefined> {
+  readonly el: HTMLElement;
+  /** The context the `Mountable` got. */
+  readonly ctx: MountContext$1<Props, Handle>;
+  /** Replaces `ctx.props` and calls the `onProps` listeners. */
+  setProps(next: Props): void;
+  /** Replaces `ctx.theme` and calls the `onTheme` listeners. */
+  setTheme(next: AppTheme): void;
+  /** Replaces `ctx.locale` and calls the `onLocale` listeners. */
+  setLocale(next: AppLocale): void;
+  /** Every `ctx.emit` call, in order: `[event, payload]`. */
+  readonly emitted: readonly (readonly [string, unknown])[];
+  /** Every `ctx.reportError` call, in order. */
+  readonly errors: readonly unknown[];
+  /** Aborts `ctx.signal` and runs the cleanup `mount` returned, once. */
+  unmount(): Promise<void>;
 }
-export interface LoadedPanel extends LoadedFrame {
-  /** Sends new properties to the panel (`ctx.onProps`). */
-  setProps(props: JsonValue | undefined): void;
-}
-export type LoadedWidget = LoadedFrame;
-/** Mounts a panel from `panels[id]` in the test DOM environment with the same context the frame provides. */
-export declare const loadPanel: (panels: Readonly<Record<string, PanelModule<HTMLElement>>>, id: string, options?: LoadPanelOptions) => Promise<LoadedPanel>;
-/** Mounts a widget from `widgets[id]` in the test DOM environment with the same context the frame provides. */
-export declare const loadWidget: (widgets: Readonly<Record<string, WidgetModule<HTMLElement>>>, id: string, options?: LoadWidgetOptions) => Promise<LoadedWidget>;
+/**
+ * Mounts a `Mountable` into an element on a recording context, so a test can
+ * change the props, the theme and the language, read what the component
+ * emitted and reported, and unmount it. Rejects with what `mount` throws. Needs
+ * a DOM (`document`) or `options.el`.
+ */
+export declare const mountForTest: <Props, Handle = undefined>(mountable: Mountable<Props, Handle>, options: MountForTestOptions<Props, Handle>) => Promise<MountedForTest<Props, Handle>>;
 //#endregion