@dolphy-app/extension-sdk 0.3.0 → 0.4.0

package/README.md

@@ -2,7 +2,7 @@
 
 SDK for extension authors: defineExtension, defineAnswerView, test helpers
 
-The package version equals the version of the Dolphy app release it was published from (0.3.0).
+The package version equals the version of the Dolphy app release it was published from (0.4.0).
 
 `@dolphy-app/extension-sdk` — extension code (`defineExtension`,
 `defineExerciseType`), answer views (`defineAnswerView`), panels,
@@ -16,6 +16,20 @@ import { defineExtension } from '@dolphy-app/extension-sdk';
 import { loadExerciseType } from '@dolphy-app/extension-sdk/testing';
 ```
 
+The package ships a guide in `docs/` (`node_modules/@dolphy-app/extension-sdk/docs/`
+after the install): a
+[quick start](https://github.com/dolphy-app/dolphy/blob/main/packages/extension-sdk/docs/quick-start.md), recipes for
+[an exercise type](https://github.com/dolphy-app/dolphy/blob/main/packages/extension-sdk/docs/recipe-exercise-type.md),
+[a theme](https://github.com/dolphy-app/dolphy/blob/main/packages/extension-sdk/docs/recipe-theme.md),
+[a command and a panel](https://github.com/dolphy-app/dolphy/blob/main/packages/extension-sdk/docs/recipe-command-panel.md),
+[events and storage](https://github.com/dolphy-app/dolphy/blob/main/packages/extension-sdk/docs/recipe-event-storage.md),
+[settings](https://github.com/dolphy-app/dolphy/blob/main/packages/extension-sdk/docs/recipe-settings.md),
+[an importer and an exporter](https://github.com/dolphy-app/dolphy/blob/main/packages/extension-sdk/docs/recipe-import-export.md),
+[visibility conditions and dependencies](https://github.com/dolphy-app/dolphy/blob/main/packages/extension-sdk/docs/recipe-when-dependencies.md) and
+[a panel on the UI kit](https://github.com/dolphy-app/dolphy/blob/main/packages/extension-sdk/docs/recipe-ui-kit.md), a path
+[without a build](https://github.com/dolphy-app/dolphy/blob/main/packages/extension-sdk/docs/no-build.md) and notes on
+[debugging](https://github.com/dolphy-app/dolphy/blob/main/packages/extension-sdk/docs/debugging.md).
+
 ## Installation
 
 ```sh

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { a as defineAnswerView, i as MountAnswerView, n as AnswerViewApi, r as AnswerViewInstance, t as AnswerView } from "./answer-view-D6wnyThb.js";
-import { CommandHandler, ExerciseTypeHandler, ExtensionContext as ExtensionContext$1, ExtensionIdSet, ExtensionModule, GradePolicyHandler, JsonValue, LearningEventHandler, MarkdownRenderContext, MarkdownRendererModule, NotifyEffect, OpenPanelEffect, PanelContext as PanelContext$1, PanelModule } from "@dolphy-app/extension-api";
+import { CommandHandler, ExerciseTypeHandler, ExporterHandler, ExtensionContext as ExtensionContext$1, ExtensionIdSet, ExtensionModule, GradePolicyHandler, ImporterHandler, JsonValue, LearningEventHandler, MarkdownRenderContext, MarkdownRendererModule, NotifyEffect, OpenPanelEffect, PanelContext as PanelContext$1, PanelModule, ScheduleHandler, WidgetContext as WidgetContext$1, WidgetModule } from "@dolphy-app/extension-api";
 export * from "@dolphy-app/extension-api";
 //#region packages/extension-sdk/src/ids.d.ts
 /**
@@ -34,6 +34,8 @@ type HasGeneratedIds = [keyof ExtensionIds] extends [never] ? false : true;
 type ExtensionContext = ExtensionContext$1<ResolvedIds>;
 /** Context of a panel module; `call` accepts the declared command ids only. */
 type PanelContext = PanelContext$1<ResolvedIds['commands']>;
+/** Context of a widget module; `call` accepts the declared command ids only. */
+type WidgetContext = WidgetContext$1<ResolvedIds['commands']>;
 /**
  * A record that holds exactly the declared ids: a missing and an extra key are
  * both compile errors. With no generated declarations any keys are accepted;
@@ -48,6 +50,8 @@ type Exact<Id extends string, Value> = [HasGeneratedIds] extends [false] ? {
 type ExtensionViews = Exact<ResolvedIds['exerciseTypes'], AnswerView>;
 /** `export const panels = { … } satisfies ExtensionPanels`: one `defineExtensionPanel` per declared panel. */
 type ExtensionPanels = Exact<ResolvedIds['panels'], PanelModule<HTMLElement, ResolvedIds['commands']>>;
+/** `export const widgets = { … } satisfies ExtensionWidgets`: one `defineExtensionWidget` per declared widget. */
+type ExtensionWidgets = Exact<ResolvedIds['widgets'], WidgetModule<HTMLElement, ResolvedIds['commands']>>;
 /** `export const markdown = { … } satisfies ExtensionMarkdown`: one `defineMarkdownRenderer` per declared language. */
 type ExtensionMarkdown = Exact<ResolvedIds['markdownLanguages'], MarkdownRendererModule<HTMLElement>>;
 //#endregion
@@ -66,6 +70,7 @@ interface InActivate {
 /**
  * A record value in `defineExtension` that says "this id is registered in
  * `activate`" (`ctx.commands.register`, `ctx.events.on`,
+ * `ctx.importers.register`, `ctx.exporters.register`, `ctx.schedule.on`,
  * `ctx.registerExerciseType`, `ctx.registerGradePolicy`) rather than by a
  * handler in the record. Needed because the records must name every declared
  * id: a handler that needs `ctx` is written in `activate`, and its id gets this
@@ -85,11 +90,12 @@ type Ids = ResolvedIds;
 /** Learning-event handlers by event name; the events must be declared in `contributes.events`, the `learning.events` permission is needed. */
 type EventHandlers = { readonly [N in Ids['events']]: LearningEventHandler<N> | InActivate; };
 /**
- * What `defineExtension` takes. `exerciseTypes`, `gradePolicies`, `events` and
- * `commands` name every id `extension.json` declares for them, exactly: a
- * handler, or `inActivate` for an id that `activate` registers.
+ * What `defineExtension` takes. `exerciseTypes`, `gradePolicies`, `events`,
+ * `commands`, `schedules`, `importers` and `exporters` name every id
+ * `extension.json` declares for them, exactly: a handler, or `inActivate` for
+ * an id that `activate` registers.
  */
-type ExtensionDefinition = Section<'exerciseTypes', Ids['exerciseTypes'], { readonly [K in Ids['exerciseTypes']]: ExerciseTypeHandler | InActivate; }> & Section<'gradePolicies', Ids['gradePolicies'], { readonly [K in Ids['gradePolicies']]: GradePolicyHandler | InActivate; }> & Section<'events', Ids['events'], EventHandlers> & Section<'commands', Ids['commands'], { readonly [K in Ids['commands']]: CommandHandler | InActivate; }> & {
+type ExtensionDefinition = Section<'exerciseTypes', Ids['exerciseTypes'], { readonly [K in Ids['exerciseTypes']]: ExerciseTypeHandler | InActivate; }> & Section<'gradePolicies', Ids['gradePolicies'], { readonly [K in Ids['gradePolicies']]: GradePolicyHandler | InActivate; }> & Section<'events', Ids['events'], EventHandlers> & Section<'commands', Ids['commands'], { readonly [K in Ids['commands']]: CommandHandler | InActivate; }> & Section<'schedules', Ids['schedules'], { readonly [K in Ids['schedules']]: ScheduleHandler | InActivate; }> & Section<'importers', Ids['importers'], { readonly [K in Ids['importers']]: ImporterHandler | InActivate; }> & Section<'exporters', Ids['exporters'], { readonly [K in Ids['exporters']]: ExporterHandler | InActivate; }> & {
   /** Runs after the records are registered. */
   activate?(context: ExtensionContext): void | Promise<void>;
   deactivate?(): void | Promise<void>;
@@ -104,5 +110,7 @@ export declare const defineMarkdownRenderer: (render: (source: string, container
 //#region packages/extension-sdk/src/panel.d.ts
 /** An entry of `panels[<panel id>]` in `src/index.ts` (`contributes.panels`); `ctx.call` accepts the declared command ids. */
 export declare const defineExtensionPanel: (module: PanelModule<HTMLElement, ResolvedIds["commands"]>) => PanelModule<HTMLElement, ResolvedIds["commands"]>;
+/** An entry of `widgets[<widget id>]` in `src/index.ts` (`contributes.widgets`); `ctx.call` accepts the declared command ids. */
+export declare const defineExtensionWidget: (module: WidgetModule<HTMLElement, ResolvedIds["commands"]>) => WidgetModule<HTMLElement, ResolvedIds["commands"]>;
 //#endregion
-export { type AnswerView, type AnswerViewApi, type AnswerViewInstance, type EventHandlers, type ExtensionContext, type ExtensionDefinition, type ExtensionIds, type ExtensionMarkdown, type ExtensionPanels, type ExtensionViews, type InActivate, type MountAnswerView, type PanelContext, defineAnswerView };
+export { type AnswerView, type AnswerViewApi, type AnswerViewInstance, type EventHandlers, type ExtensionContext, type ExtensionDefinition, type ExtensionIds, type ExtensionMarkdown, type ExtensionPanels, type ExtensionViews, type ExtensionWidgets, type InActivate, type MountAnswerView, type PanelContext, type WidgetContext, defineAnswerView };

package/dist/index.js

@@ -14,6 +14,7 @@ const openPanel = (panelId, props) => props === void 0 ? { openPanel: panelId }
 /**
 * A record value in `defineExtension` that says "this id is registered in
 * `activate`" (`ctx.commands.register`, `ctx.events.on`,
+* `ctx.importers.register`, `ctx.exporters.register`, `ctx.schedule.on`,
 * `ctx.registerExerciseType`, `ctx.registerGradePolicy`) rather than by a
 * handler in the record. Needed because the records must name every declared
 * id: a handler that needs `ctx` is written in `activate`, and its id gets this
@@ -40,6 +41,9 @@ const defineExtension = /* @__NO_SIDE_EFFECTS__ */ (declared) => {
 		for (const [id, handler] of handlersOf(definition.gradePolicies)) registrations.push(context.registerGradePolicy(id, handler));
 		for (const [name, handler] of handlersOf(definition.events)) registrations.push(context.events.on(name, handler));
 		for (const [id, handler] of handlersOf(definition.commands)) registrations.push(context.commands.register(id, handler));
+		for (const [id, handler] of handlersOf(definition.schedules)) registrations.push(context.schedule.on(id, handler));
+		for (const [id, handler] of handlersOf(definition.importers)) registrations.push(context.importers.register(id, handler));
+		for (const [id, handler] of handlersOf(definition.exporters)) registrations.push(context.exporters.register(id, handler));
 	};
 	const activate = async (context) => {
 		try {
@@ -86,6 +90,8 @@ const defineMarkdownRenderer = /* @__NO_SIDE_EFFECTS__ */ (render) => ({ render
 //#region packages/extension-sdk/src/panel.ts
 /** An entry of `panels[<panel id>]` in `src/index.ts` (`contributes.panels`); `ctx.call` accepts the declared command ids. */
 const defineExtensionPanel = /* @__NO_SIDE_EFFECTS__ */ (module) => module;
+/** An entry of `widgets[<widget id>]` in `src/index.ts` (`contributes.widgets`); `ctx.call` accepts the declared command ids. */
+const defineExtensionWidget = /* @__NO_SIDE_EFFECTS__ */ (module) => module;
 
 //#endregion
-export { defineAnswerView, defineExerciseType, defineExtension, defineExtensionPanel, defineMarkdownRenderer, inActivate, notify, openPanel };
+export { defineAnswerView, defineExerciseType, defineExtension, defineExtensionPanel, defineExtensionWidget, defineMarkdownRenderer, inActivate, notify, openPanel };

package/dist/runtime.d.ts

@@ -1,14 +1,17 @@
 import { t as AnswerView } from "./answer-view-D6wnyThb.js";
-import { MarkdownRendererModule, PanelModule } from "@dolphy-app/extension-api";
+import { MarkdownRendererModule, PanelModule, WidgetModule } from "@dolphy-app/extension-api";
 //#region packages/extension-sdk/src/answer-element.d.ts
 /** Defines the kind's custom element; calling again with the same tag changes nothing. */
 export declare const registerAnswerView: (tag: string, view: AnswerView) => void;
 //#endregion
 //#region packages/extension-sdk/src/runtime.d.ts
 type PanelEntry = PanelModule<HTMLElement>;
+type WidgetEntry = WidgetModule<HTMLElement>;
 type MarkdownEntry = MarkdownRendererModule<HTMLElement>;
 /** Panel module that selects the `panels` entry by `ctx.panelId` (for a file shared by several panels). */
 export declare const dispatchPanels: (panels: Readonly<Record<string, PanelEntry>>) => PanelEntry;
+/** Widget module that selects the `widgets` entry by `ctx.widgetId` (for a file shared by several widgets). */
+export declare const dispatchWidgets: (widgets: Readonly<Record<string, WidgetEntry>>) => WidgetEntry;
 /** Renderer module that selects the `markdown` entry by block language. */
 export declare const dispatchMarkdown: (renderers: Readonly<Record<string, MarkdownEntry>>) => MarkdownEntry;
 //#endregion

package/dist/runtime.js

@@ -7,6 +7,12 @@ const dispatchPanels = (panels) => ({ mount(container, context) {
 	if (panel === void 0) throw new Error(`panel '${context.panelId}' is not exported`);
 	return panel.mount(container, context);
 } });
+/** Widget module that selects the `widgets` entry by `ctx.widgetId` (for a file shared by several widgets). */
+const dispatchWidgets = (widgets) => ({ mount(container, context) {
+	const widget = widgets[context.widgetId];
+	if (widget === void 0) throw new Error(`widget '${context.widgetId}' is not exported`);
+	return widget.mount(container, context);
+} });
 /** Renderer module that selects the `markdown` entry by block language. */
 const dispatchMarkdown = (renderers) => ({ render(source, container, context) {
 	const renderer = renderers[context.language];
@@ -15,4 +21,4 @@ const dispatchMarkdown = (renderers) => ({ render(source, container, context) {
 } });
 
 //#endregion
-export { dispatchMarkdown, dispatchPanels, registerAnswerView };
+export { dispatchMarkdown, dispatchPanels, dispatchWidgets, registerAnswerView };

package/dist/testing.d.ts

@@ -1,5 +1,5 @@
 import { t as AnswerView } from "./answer-view-D6wnyThb.js";
-import { AnswerChangeDetail, AnswerElementProps, CommandOutcome, ExtensionCommands, ExtensionEvents, ExtensionLogger, ExtensionModule, ExtensionSettings, ExtensionStorage, GradePolicyInput, GradeResult, GradeValue, JsonSchema, JsonValue, LearningEventName, LearningEventPayloads, LibraryReader, PanelModule, SettingContribution, SettingValue } from "@dolphy-app/extension-api";
+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";
 //#region packages/extension-sdk/src/testing.d.ts
 export declare const createMemoryLibrary: (files: Readonly<Record<string, string>>) => LibraryReader;
 /**
@@ -8,6 +8,22 @@ export declare const createMemoryLibrary: (files: Readonly<Record<string, string
  * JSON text and returned as copies; on rejection nothing changes.
  */
 export declare const createMemoryStorage: () => ExtensionStorage;
+/** In-memory secrets for tests: `ExtensionSecrets` plus a switch that imitates a missing system key store. */
+export interface MemorySecrets extends ExtensionSecrets {
+  /** Imitates the system key store becoming (un)available; stored values are kept. */
+  setAvailable(available: boolean): void;
+}
+export interface MemorySecretsOptions {
+  /** Default `true`; `false` imitates Linux `basic_text`, no key store, or an app that is not ready. */
+  available?: boolean;
+}
+/**
+ * In-memory secrets with the engine's limits and errors
+ * (`EXTENSION_SECRET_LIMITS`, `StorageQuotaError`, `SecretsUnavailableError`):
+ * without a key store `set` and `get` of an existing key throw, `get` of a
+ * missing key gives `undefined` and `delete` works.
+ */
+export declare const createMemorySecrets: (options?: MemorySecretsOptions) => MemorySecrets;
 export interface MemorySettings extends ExtensionSettings {
   /**
    * Changes the value as the user does in the dialog: the value is validated
@@ -52,14 +68,136 @@ export interface MemoryCommandsOptions {
 }
 /** 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;
+export interface MemoryStatsAttempt {
+  /** When the attempt happened: epoch milliseconds, a `Date`, or an ISO-8601 string. */
+  at: number | Date | string;
+  /** Grade 1-5; 3 and higher counts as correct, as in the app. */
+  grade: number;
+  /** Course of the attempt, for the `courseId` filter. Without it the attempt belongs to no course. */
+  courseId?: string;
+}
+export interface MemoryStatsOptions {
+  /** Attempts the statistics start with; more arrive through `record`. */
+  attempts?: readonly MemoryStatsAttempt[];
+  /** IANA time zone whose local days are counted. Defaults to the time zone of this process. */
+  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. */
+  record(attempt: MemoryStatsAttempt): void;
+}
+/**
+ * In-memory statistics with the semantics of the app: local days in a time zone,
+ * correct at grade 3 or higher, `current` streak not broken while today has no
+ * attempts yet, one `daily` entry per date (at most `EXTENSION_STATS_LIMITS.dailyDays`).
+ */
+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. */
+  enabled?: boolean;
+  /** The current time for the rate windows. Defaults to `Date.now`. */
+  now?: () => number;
+}
+export interface MemoryNotifications extends ExtensionNotifications {
+  /** Notifications handed to the (imitated) operating system, oldest first, as the app shows them: sanitized text. */
+  readonly shown: readonly ExtensionNotification[];
+  /** The user's switch "Notifications" of the extension. */
+  setEnabled(enabled: boolean): void;
+  /** Whether the imitated operating system supports notifications. */
+  setSupported(supported: boolean): void;
+}
+/**
+ * In-memory notifications with the engine's rules: the text is sanitized and
+ * limited, `perMinute`/`perHour` windows throw `NotificationRateLimitError`,
+ * a switched-off extension or an unsupporting system resolves `false` (and
+ * does not use the rate limit). `shown` is the log the app's fake notifier
+ * 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 {
   library?: LibraryReader;
   logger?: ExtensionLogger;
   storage?: ExtensionStorage;
+  secrets?: ExtensionSecrets;
   settings?: ExtensionSettings;
   events?: ExtensionEvents;
   commands?: ExtensionCommands;
+  importers?: ExtensionImporters;
+  exporters?: ExtensionExporters;
+  stats?: ExtensionStats;
+  notifications?: ExtensionNotifications;
+  schedule?: ExtensionSchedule;
 }
 export declare const createSchemaValidator: (schema: JsonSchema) => (value: unknown) => string[];
 export interface LoadedExerciseType {
@@ -95,12 +233,14 @@ 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 LoadEventsOptions extends Omit<LoadOptions, 'storage' | 'settings' | 'events'>, MemoryEventsOptions {
+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`. */
@@ -120,6 +260,33 @@ export interface LoadedCommands {
 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;
@@ -152,11 +319,21 @@ export interface LoadPanelOptions {
   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 LoadedPanel {
-  /** Container the panel received in `mount`. */
+export interface LoadedFrame {
+  /** Container the module received in `mount`. */
   readonly container: HTMLElement;
   /** `ctx.call` invocations in order. */
   readonly calls: readonly {
@@ -165,11 +342,18 @@ export interface LoadedPanel {
   }[];
   /** Whether `ctx.signal` was aborted (after `dispose()`). */
   readonly aborted: boolean;
-  /** Sends new properties to the panel (`ctx.onProps`). */
-  setProps(props: JsonValue | undefined): void;
+  /** 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 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>;
 //#endregion