@dolphy-app/extension-sdk 0.3.0 → 0.4.0

package/dist/testing.js

@@ -1,5 +1,5 @@
 import { t as createAnswerElementClass } from "./answer-element-BOQcuxYh.js";
-import { ANSWER_EVENT, EXTENSION_COMMAND_LIMITS, EXTENSION_STORAGE_LIMITS, InvalidCommandResultError, PermissionError, StorageQuotaError, normalizeCommandResult } from "@dolphy-app/extension-api";
+import { ANSWER_EVENT, COLOR_SETTING_PATTERN, EXTENSION_COMMAND_LIMITS, EXTENSION_NOTIFICATION_LIMITS, EXTENSION_SECRET_LIMITS, EXTENSION_STATS_LIMITS, EXTENSION_STORAGE_LIMITS, EXTENSION_TRANSFER_LIMITS, InvalidCommandResultError, InvalidTransferResultError, NotificationRateLimitError, PermissionError, SETTING_LIMITS, SecretsUnavailableError, StorageQuotaError, normalizeCommandResult, normalizeExportResult, normalizeImportResult } from "@dolphy-app/extension-api";
 import { Ajv2020 } from "ajv/dist/2020.js";
 
 //#region packages/extension-sdk/src/testing.ts
@@ -69,10 +69,59 @@ const createMemoryStorage = () => {
 		keys: async () => [...entries.keys()].sort(compareKeys)
 	};
 };
+/**
+* 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.
+*/
+const createMemorySecrets = (options = {}) => {
+	const limits = EXTENSION_SECRET_LIMITS;
+	const entries = /* @__PURE__ */ new Map();
+	let available = options.available ?? true;
+	const requireStore = () => {
+		if (!available) throw new SecretsUnavailableError();
+	};
+	return {
+		setAvailable: (value) => {
+			available = value;
+		},
+		get: async (key) => {
+			const value = entries.get(key);
+			if (value !== void 0) requireStore();
+			return value;
+		},
+		set: async (key, value) => {
+			if (typeof key !== "string" || key.length === 0) throw new Error("secret key must be a non-empty string");
+			if (typeof value !== "string") throw new Error("secret value must be a string");
+			if (key.length > limits.keyLength) throw new StorageQuotaError("key-length", limits.keyLength);
+			if (Buffer.byteLength(value) > limits.valueBytes) throw new StorageQuotaError("value-size", limits.valueBytes);
+			requireStore();
+			if (!entries.has(key) && entries.size >= limits.keys) throw new StorageQuotaError("key-count", limits.keys);
+			entries.set(key, value);
+		},
+		delete: async (key) => entries.delete(key)
+	};
+};
+/** The value as the host stores it: a color in lower case, a list copied. */
+const storedForm = (definition, value) => {
+	if (definition.type === "color" && typeof value === "string") return value.toLowerCase();
+	return Array.isArray(value) ? [...value] : value;
+};
+const sameSettingValue = (a, b) => Array.isArray(a) && Array.isArray(b) ? a.length === b.length && a.every((item, index) => item === b[index]) : Object.is(a, b);
 /** Why a value does not fit the setting definition; `null` if it fits. */
 const findSettingProblem = (definition, value) => {
 	switch (definition.type) {
 		case "boolean": return typeof value === "boolean" ? null : "must be a boolean";
+		case "color": return typeof value === "string" && COLOR_SETTING_PATTERN.test(value) ? null : "must be a color #rrggbb";
+		case "list": {
+			if (!Array.isArray(value) || !value.every((item) => typeof item === "string")) return "must be an array of strings";
+			const maxItems = definition.maxItems ?? SETTING_LIMITS.listItems;
+			if (value.length > maxItems) return `has more than ${maxItems} items`;
+			const itemMax = definition.itemMaxLength ?? SETTING_LIMITS.listItemLength;
+			return value.some((item) => item.length > itemMax) ? `has an item longer than ${itemMax} characters` : null;
+		}
+		case "text":
 		case "string":
 			if (typeof value !== "string") return "must be a string";
 			return definition.maxLength !== void 0 && value.length > definition.maxLength ? `is longer than ${definition.maxLength} characters` : null;
@@ -87,7 +136,7 @@ const findSettingProblem = (definition, value) => {
 /** In-memory settings from manifest definitions; `initial` provides user values in place of `default`. */
 const createMemorySettings = (definitions, initial = {}) => {
 	const byId = new Map(definitions.map((definition) => [definition.id, definition]));
-	const values = new Map(definitions.map((definition) => [definition.id, definition.default]));
+	const values = new Map(definitions.map((definition) => [definition.id, storedForm(definition, definition.default)]));
 	const handlers = /* @__PURE__ */ new Set();
 	const known = (id) => {
 		const definition = byId.get(id);
@@ -97,21 +146,18 @@ const createMemorySettings = (definitions, initial = {}) => {
 	const checked = (id, value) => {
 		const problem = findSettingProblem(known(id), value);
 		if (problem !== null) throw new Error(`setting '${id}' ${problem}`);
-		return value;
+		return storedForm(known(id), value);
 	};
 	for (const [id, value] of Object.entries(initial)) values.set(id, checked(id, value));
 	return {
-		get: (id) => {
-			known(id);
-			return values.get(id);
-		},
+		get: (id) => storedForm(known(id), values.get(id)),
 		onDidChange(handler) {
 			handlers.add(handler);
 			return { dispose: () => void handlers.delete(handler) };
 		},
 		async set(id, value) {
 			const next = checked(id, value);
-			if (Object.is(values.get(id), next)) return;
+			if (sameSettingValue(values.get(id), next)) return;
 			values.set(id, next);
 			for (const handler of [...handlers]) await handler({
 				id,
@@ -165,14 +211,271 @@ const createMemoryCommands = (options = {}) => {
 		ids: () => [...handlers.keys()]
 	};
 };
+/** In-memory schedule subscriptions: one handler per schedule and no overlapping firings, as in the host. */
+const createMemorySchedule = (options = {}) => {
+	const handlers = /* @__PURE__ */ new Map();
+	const running = /* @__PURE__ */ new Set();
+	return {
+		on(id, handler) {
+			if (options.declared !== void 0 && !options.declared.includes(id)) throw new Error(`schedule '${id}' is not declared in the manifest`);
+			if (handlers.has(id)) throw new Error(`schedule '${id}' is already subscribed`);
+			handlers.set(id, handler);
+			return { dispose: () => {
+				if (handlers.get(id) === handler) handlers.delete(id);
+			} };
+		},
+		async fire(id) {
+			const handler = handlers.get(id);
+			if (handler === void 0 || running.has(id)) return false;
+			running.add(id);
+			try {
+				await handler();
+				return true;
+			} finally {
+				running.delete(id);
+			}
+		},
+		ids: () => [...handlers.keys()]
+	};
+};
+/** In-memory importers: the same registration rules and result checks as the host. */
+const createMemoryImporters = (options = {}) => {
+	const handlers = /* @__PURE__ */ new Map();
+	const declaredOf = (id) => options.declaredImporters?.find((entry) => entry.id === id);
+	return {
+		register(id, handler) {
+			if (options.declaredImporters !== void 0 && declaredOf(id) === void 0) throw new Error(`importer '${id}' is not declared in the manifest`);
+			if (handlers.has(id)) throw new Error(`importer '${id}' is already registered`);
+			handlers.set(id, handler);
+			return { dispose: () => {
+				if (handlers.get(id) === handler) handlers.delete(id);
+			} };
+		},
+		async run(id, input) {
+			const handler = handlers.get(id);
+			if (handler === void 0) throw new Error(`importer '${id}' was not registered`);
+			const expected = declaredOf(id)?.input ?? "text";
+			if (options.declaredImporters !== void 0 && ("text" in input ? "text" : "bytes") !== expected) throw new Error(`importer '${id}' takes ${expected} input`);
+			if (("text" in input ? new TextEncoder().encode(input.text).length : input.bytes.byteLength) > EXTENSION_TRANSFER_LIMITS.inputBytes) throw new Error(`the file is longer than ${EXTENSION_TRANSFER_LIMITS.inputBytes} bytes`);
+			const result = await handler(input);
+			try {
+				return normalizeImportResult(result);
+			} catch (error) {
+				if (error instanceof InvalidTransferResultError) throw new Error(`invalid import result: ${error.message}`);
+				throw error;
+			}
+		},
+		ids: () => [...handlers.keys()]
+	};
+};
+/** In-memory exporters: the same registration rules and result checks as the host. */
+const createMemoryExporters = (options = {}) => {
+	const handlers = /* @__PURE__ */ new Map();
+	const declaredOf = (id) => options.declaredExporters?.find((entry) => entry.id === id);
+	return {
+		register(id, handler) {
+			if (options.declaredExporters !== void 0 && declaredOf(id) === void 0) throw new Error(`exporter '${id}' is not declared in the manifest`);
+			if (handlers.has(id)) throw new Error(`exporter '${id}' is already registered`);
+			handlers.set(id, handler);
+			return { dispose: () => {
+				if (handlers.get(id) === handler) handlers.delete(id);
+			} };
+		},
+		async run(id, input) {
+			const handler = handlers.get(id);
+			if (handler === void 0) throw new Error(`exporter '${id}' was not registered`);
+			const declared = declaredOf(id);
+			if (declared !== void 0 && declared.scope !== input.scope) throw new Error(`exporter '${id}' takes the ${declared.scope} scope`);
+			if (input.scope === "course") {
+				const encoder = new TextEncoder();
+				if (Object.values(input.files).reduce((sum, text) => sum + encoder.encode(text).length, 0) > EXTENSION_TRANSFER_LIMITS.totalBytes) throw new Error(`the course files are longer than ${EXTENSION_TRANSFER_LIMITS.totalBytes} bytes`);
+			}
+			const result = await handler(input);
+			try {
+				return normalizeExportResult(result);
+			} catch (error) {
+				if (error instanceof InvalidTransferResultError) throw new Error(`invalid export result: ${error.message}`);
+				throw error;
+			}
+		},
+		ids: () => [...handlers.keys()]
+	};
+};
+const DAY_MS = 864e5;
+const STATS_CORRECT_GRADE_MIN = 3;
+const dayNumberOf = (year, month, day) => {
+	const date = /* @__PURE__ */ new Date(0);
+	date.setUTCFullYear(year, month - 1, day);
+	return Math.floor(date.getTime() / DAY_MS);
+};
+const dayLabelOf = (dayNumber) => (/* @__PURE__ */ new Date(dayNumber * DAY_MS)).toISOString().slice(0, 10);
+const parseDay = (field, value) => {
+	const match = typeof value === "string" ? /^(\d{4})-(\d{2})-(\d{2})$/.exec(value) : null;
+	const day = match === null ? null : dayNumberOf(Number(match[1]), Number(match[2]), Number(match[3]));
+	if (day === null || dayLabelOf(day) !== value) throw new Error(`'${field}' must be a date as YYYY-MM-DD`);
+	return day;
+};
+/**
+* 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`).
+*/
+const createMemoryStats = (options = {}) => {
+	const timeZone = options.timeZone ?? new Intl.DateTimeFormat().resolvedOptions().timeZone;
+	const formatter = new Intl.DateTimeFormat("en-US", {
+		timeZone,
+		calendar: "gregory",
+		numberingSystem: "latn",
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit"
+	});
+	const localDay = (at) => {
+		const parts = Object.fromEntries(formatter.formatToParts(at).map(({ type, value }) => [type, value]));
+		return dayNumberOf(Number(parts.year), Number(parts.month), Number(parts.day));
+	};
+	const attempts = [];
+	const record = (attempt) => {
+		const at = new Date(attempt.at).getTime();
+		if (Number.isNaN(at)) throw new Error("attempt.at is not a valid time");
+		attempts.push({
+			day: localDay(at),
+			correct: attempt.grade >= STATS_CORRECT_GRADE_MIN,
+			...attempt.courseId !== void 0 && { courseId: attempt.courseId }
+		});
+	};
+	for (const attempt of options.attempts ?? []) record(attempt);
+	const guard = () => {
+		if (options.permitted === false) throw new PermissionError("learning.stats");
+	};
+	const countsOf = (courseId) => {
+		const days = /* @__PURE__ */ new Map();
+		for (const item of attempts) {
+			if (courseId !== void 0 && item.courseId !== courseId) continue;
+			const counts = days.get(item.day) ?? {
+				attempts: 0,
+				correct: 0
+			};
+			counts.attempts += 1;
+			if (item.correct) counts.correct += 1;
+			days.set(item.day, counts);
+		}
+		return days;
+	};
+	return {
+		record,
+		async streak(streakOptions) {
+			guard();
+			const days = countsOf(streakOptions?.courseId);
+			const today = localDay((options.now ?? Date.now)());
+			let longest = 0;
+			let run = 0;
+			let previous = NaN;
+			for (const day of [...days.keys()].sort((a, b) => a - b)) {
+				run = day === previous + 1 ? run + 1 : 1;
+				longest = Math.max(longest, run);
+				previous = day;
+			}
+			let cursor = days.has(today) ? today : today - 1;
+			let current = 0;
+			while (days.has(cursor)) {
+				current += 1;
+				cursor -= 1;
+			}
+			return {
+				current,
+				longest
+			};
+		},
+		async daily({ from, to, courseId }) {
+			guard();
+			const first = parseDay("from", from);
+			const last = parseDay("to", to);
+			if (last < first || last - first + 1 > EXTENSION_STATS_LIMITS.dailyDays) throw new Error(`the range must be ascending and cover at most ${EXTENSION_STATS_LIMITS.dailyDays} dates`);
+			const days = countsOf(courseId);
+			const result = [];
+			for (let day = first; day <= last; day += 1) {
+				const { attempts: made, correct } = days.get(day) ?? {
+					attempts: 0,
+					correct: 0
+				};
+				result.push({
+					date: dayLabelOf(day),
+					attempts: made,
+					correct,
+					accuracy: made === 0 ? null : correct / made
+				});
+			}
+			return result;
+		}
+	};
+};
+/** Control characters (except the line feed), line and paragraph separators and text direction marks. */
+const NOTIFICATION_CONTROL = /[\u0000-\u0009\u000B-\u001F\u007F-\u009F\u2028\u2029\u200E\u200F\u202A-\u202E\u2066-\u2069]/gu;
+const notificationText = (field, value, max) => {
+	if (typeof value !== "string") throw new Error(`notification ${field} must be a string`);
+	const unified = value.replace(/\r\n?/gu, "\n").replace(/\t/gu, " ");
+	const text = (field === "body" ? unified : unified.replace(/\n/gu, " ")).replace(NOTIFICATION_CONTROL, "").trim();
+	if (field === "title" && text === "" || [...text].length > max) throw new Error(`notification ${field} must be ${field === "title" ? "1 to " : "up to "}${max} characters`);
+	return text;
+};
+/**
+* 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.
+*/
+const createMemoryNotifications = (options = {}) => {
+	const now = options.now ?? Date.now;
+	let enabled = options.enabled !== false;
+	let supported = options.supported !== false;
+	const shown = [];
+	const times = [];
+	const limits = EXTENSION_NOTIFICATION_LIMITS;
+	return {
+		shown,
+		setEnabled: (value) => {
+			enabled = value;
+		},
+		setSupported: (value) => {
+			supported = value;
+		},
+		async show(notification) {
+			if (options.permitted === false) throw new PermissionError("notifications");
+			const title = notificationText("title", notification?.title, limits.titleLength);
+			const body = notificationText("body", notification?.body, limits.bodyLength);
+			if (!enabled) return false;
+			const at = now();
+			const recent = times.filter((time) => at - time < 36e5);
+			times.length = 0;
+			times.push(...recent);
+			if (recent.filter((time) => at - time < 6e4).length >= limits.perMinute) throw new NotificationRateLimitError("minute", limits.perMinute);
+			if (recent.length >= limits.perHour) throw new NotificationRateLimitError("hour", limits.perHour);
+			times.push(at);
+			if (!supported) return false;
+			shown.push({
+				title,
+				body
+			});
+			return true;
+		}
+	};
+};
 const contextOf = (options, registrars) => ({
 	extensionId: "test",
 	logger: options.logger ?? silentLogger,
 	library: options.library ?? createMemoryLibrary({}),
 	storage: options.storage ?? createMemoryStorage(),
+	secrets: options.secrets ?? createMemorySecrets(),
 	settings: options.settings ?? createMemorySettings([]),
 	events: options.events ?? createMemoryEvents(),
+	stats: options.stats ?? createMemoryStats(),
+	notifications: options.notifications ?? createMemoryNotifications(),
+	schedule: options.schedule ?? createMemorySchedule(),
 	commands: options.commands ?? createMemoryCommands(),
+	importers: options.importers ?? createMemoryImporters(),
+	exporters: options.exporters ?? createMemoryExporters(),
 	...registrars
 });
 const createSchemaValidator = (schema) => {
@@ -303,11 +606,16 @@ const loadGradePolicy = async (module, id, options = {}) => {
 const loadEvents = async (module, options = {}) => {
 	const events = createMemoryEvents(options);
 	const storage = options.storage ?? createMemoryStorage();
+	const secrets = options.secrets ?? createMemorySecrets();
 	const settings = createMemorySettings(options.settings ?? [], options.settingValues);
 	const context = contextOf({
 		...options.library !== void 0 && { library: options.library },
 		...options.logger !== void 0 && { logger: options.logger },
+		...options.stats !== void 0 && { stats: options.stats },
+		...options.notifications !== void 0 && { notifications: options.notifications },
+		...options.schedule !== void 0 && { schedule: options.schedule },
 		storage,
+		secrets,
 		settings,
 		events
 	}, {
@@ -318,6 +626,7 @@ const loadEvents = async (module, options = {}) => {
 	return {
 		emit: events.emit,
 		storage,
+		secrets,
 		settings,
 		dispose: async () => {
 			await module.deactivate?.();
@@ -331,8 +640,12 @@ const loadCommands = async (module, options = {}) => {
 		...options.library !== void 0 && { library: options.library },
 		...options.logger !== void 0 && { logger: options.logger },
 		...options.storage !== void 0 && { storage: options.storage },
+		...options.secrets !== void 0 && { secrets: options.secrets },
 		...options.settings !== void 0 && { settings: options.settings },
 		...options.events !== void 0 && { events: options.events },
+		...options.stats !== void 0 && { stats: options.stats },
+		...options.notifications !== void 0 && { notifications: options.notifications },
+		...options.schedule !== void 0 && { schedule: options.schedule },
 		commands
 	}, {
 		registerExerciseType: () => ({ dispose: () => void 0 }),
@@ -347,6 +660,76 @@ const loadCommands = async (module, options = {}) => {
 		}
 	};
 };
+/** The context parts a test replaced, without the keys it left unset. */
+const loadOptionsOf = (options) => ({
+	...options.library !== void 0 && { library: options.library },
+	...options.logger !== void 0 && { logger: options.logger },
+	...options.storage !== void 0 && { storage: options.storage },
+	...options.secrets !== void 0 && { secrets: options.secrets },
+	...options.settings !== void 0 && { settings: options.settings },
+	...options.events !== void 0 && { events: options.events },
+	...options.commands !== void 0 && { commands: options.commands },
+	...options.stats !== void 0 && { stats: options.stats },
+	...options.notifications !== void 0 && { notifications: options.notifications },
+	...options.schedule !== void 0 && { schedule: options.schedule }
+});
+/** Activates the module with in-memory importers and lets the test run them like the host. */
+const loadImporters = async (module, options = {}) => {
+	const importers = createMemoryImporters(options);
+	const context = contextOf({
+		...loadOptionsOf(options),
+		importers
+	}, {
+		registerExerciseType: () => ({ dispose: () => void 0 }),
+		registerGradePolicy: () => ({ dispose: () => void 0 })
+	});
+	await module.activate(context);
+	return {
+		run: importers.run,
+		ids: importers.ids,
+		dispose: async () => {
+			await module.deactivate?.();
+		}
+	};
+};
+/** Activates the module with in-memory exporters and lets the test run them like the host; `stats` feeds `ctx.stats` of a progress exporter. */
+const loadExporters = async (module, options = {}) => {
+	const exporters = createMemoryExporters(options);
+	const context = contextOf({
+		...loadOptionsOf(options),
+		exporters
+	}, {
+		registerExerciseType: () => ({ dispose: () => void 0 }),
+		registerGradePolicy: () => ({ dispose: () => void 0 })
+	});
+	await module.activate(context);
+	return {
+		run: exporters.run,
+		ids: exporters.ids,
+		dispose: async () => {
+			await module.deactivate?.();
+		}
+	};
+};
+/** Activates the module with in-memory schedules and lets the test fire them like the host. */
+const loadSchedules = async (module, options = {}) => {
+	const schedule = createMemorySchedule(options);
+	const context = contextOf({
+		...loadOptionsOf(options),
+		schedule
+	}, {
+		registerExerciseType: () => ({ dispose: () => void 0 }),
+		registerGradePolicy: () => ({ dispose: () => void 0 })
+	});
+	await module.activate(context);
+	return {
+		fire: schedule.fire,
+		ids: schedule.ids,
+		dispose: async () => {
+			await module.deactivate?.();
+		}
+	};
+};
 const requireDocument = (helper) => {
 	if (typeof document === "undefined") throw new Error(`${helper} needs a DOM: run the test in a DOM environment (happy-dom or jsdom)`);
 	return document;
@@ -400,47 +783,92 @@ const loadView = async (views, id, options = {}) => {
 		}
 	};
 };
+/** The part of the context a panel and a widget share, with the controls a test needs. */
+const createFrameContext = (options, doc) => {
+	const calls = [];
+	const listeners = /* @__PURE__ */ new Set();
+	const controller = new AbortController();
+	const container = options.container ?? doc.body.appendChild(doc.createElement("div"));
+	let current = { courseId: options.context?.courseId ?? null };
+	return {
+		context: {
+			get context() {
+				return current;
+			},
+			signal: controller.signal,
+			call: async (commandId, args) => {
+				calls.push({
+					commandId,
+					args
+				});
+				if (options.call === void 0) throw new Error(`command '${commandId}' is not available in this test`);
+				return options.call(commandId, args);
+			},
+			onContextChange: (listener) => {
+				listeners.add(listener);
+				return () => void listeners.delete(listener);
+			}
+		},
+		frame: {
+			container,
+			calls,
+			get aborted() {
+				return controller.signal.aborted;
+			},
+			setContext: (next) => {
+				current = { courseId: next.courseId };
+				for (const listener of [...listeners]) listener(current);
+			},
+			dispose: () => {
+				controller.abort();
+				if (options.container === void 0) container.remove();
+			}
+		},
+		container
+	};
+};
 /** Mounts a panel from `panels[id]` in the test DOM environment with the same context the frame provides. */
 const loadPanel = async (panels, id, options = {}) => {
 	const doc = requireDocument("loadPanel");
 	const panel = panels[id];
 	if (panel === void 0) throw new Error(`panel '${id}' was not exported`);
-	const calls = [];
+	const { context, frame, container } = createFrameContext(options, doc);
 	const listeners = /* @__PURE__ */ new Set();
-	const controller = new AbortController();
-	const container = options.container ?? doc.body.appendChild(doc.createElement("div"));
 	await panel.mount(container, {
+		get context() {
+			return context.context;
+		},
+		signal: context.signal,
+		call: context.call,
+		onContextChange: context.onContextChange,
 		panelId: id,
 		props: options.props,
-		signal: controller.signal,
-		call: async (commandId, args) => {
-			calls.push({
-				commandId,
-				args
-			});
-			if (options.call === void 0) throw new Error(`command '${commandId}' is not available in this test`);
-			return options.call(commandId, args);
-		},
 		onProps: (listener) => {
 			listeners.add(listener);
 			return () => void listeners.delete(listener);
 		}
 	});
-	return {
-		container,
-		calls,
-		get aborted() {
-			return controller.signal.aborted;
-		},
-		setProps: (props) => {
-			for (const listener of [...listeners]) listener(props);
+	return Object.assign(frame, { setProps: (props) => {
+		for (const listener of [...listeners]) listener(props);
+	} });
+};
+/** Mounts a widget from `widgets[id]` in the test DOM environment with the same context the frame provides. */
+const loadWidget = async (widgets, id, options = {}) => {
+	const doc = requireDocument("loadWidget");
+	const widget = widgets[id];
+	if (widget === void 0) throw new Error(`widget '${id}' was not exported`);
+	const { context, frame, container } = createFrameContext(options, doc);
+	await widget.mount(container, {
+		get context() {
+			return context.context;
 		},
-		dispose: () => {
-			controller.abort();
-			if (options.container === void 0) container.remove();
-		}
-	};
+		signal: context.signal,
+		call: context.call,
+		onContextChange: context.onContextChange,
+		widgetId: id
+	});
+	return frame;
 };
 
 //#endregion
-export { createMemoryCommands, createMemoryEvents, createMemoryLibrary, createMemorySettings, createMemoryStorage, createSchemaValidator, loadCommands, loadEvents, loadExerciseType, loadGradePolicy, loadPanel, loadView };
+export { createMemoryCommands, createMemoryEvents, createMemoryExporters, createMemoryImporters, createMemoryLibrary, createMemoryNotifications, createMemorySchedule, createMemorySecrets, createMemorySettings, createMemoryStats, createMemoryStorage, createSchemaValidator, loadCommands, loadEvents, loadExerciseType, loadExporters, loadGradePolicy, loadImporters, loadPanel, loadSchedules, loadView, loadWidget };