@dolphy-app/extension-sdk 0.2.0 → 0.4.0

package/dist/testing.js

@@ -1,3 +1,5 @@
+import { t as createAnswerElementClass } from "./answer-element-BOQcuxYh.js";
+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
@@ -31,6 +33,451 @@ const createMemoryLibrary = (files) => {
 		}
 	};
 };
+/** UTF-8 byte order matches code point order — this is how the engine sorts keys. */
+const compareKeys = (a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b));
+/**
+* In-memory storage with the same limits and errors as the engine
+* (`EXTENSION_STORAGE_LIMITS`, `StorageQuotaError`): values are stored as
+* JSON text and returned as copies; on rejection nothing changes.
+*/
+const createMemoryStorage = () => {
+	const limits = EXTENSION_STORAGE_LIMITS;
+	const entries = /* @__PURE__ */ new Map();
+	const totalBytes = () => {
+		let total = 0;
+		for (const text of entries.values()) total += Buffer.byteLength(text);
+		return total;
+	};
+	return {
+		get: async (key) => {
+			const text = entries.get(key);
+			return text === void 0 ? void 0 : JSON.parse(text);
+		},
+		set: async (key, value) => {
+			if (typeof key !== "string" || key.length === 0) throw new Error("storage key must be a non-empty string");
+			const text = JSON.stringify(value);
+			if (text === void 0) throw new Error("storage value must be JSON");
+			const bytes = Buffer.byteLength(text);
+			if (key.length > limits.keyLength) throw new StorageQuotaError("key-length", limits.keyLength);
+			if (bytes > limits.valueBytes) throw new StorageQuotaError("value-size", limits.valueBytes);
+			const existing = entries.get(key);
+			if (existing === void 0 && entries.size >= limits.keys) throw new StorageQuotaError("key-count", limits.keys);
+			if (totalBytes() - (existing === void 0 ? 0 : Buffer.byteLength(existing)) + bytes > limits.totalBytes) throw new StorageQuotaError("total-size", limits.totalBytes);
+			entries.set(key, text);
+		},
+		delete: async (key) => entries.delete(key),
+		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;
+		case "number":
+			if (typeof value !== "number" || !Number.isFinite(value)) return "must be a finite number";
+			if (definition.integer === true && !Number.isInteger(value)) return "must be an integer";
+			if (definition.min !== void 0 && value < definition.min) return `is less than ${definition.min}`;
+			return definition.max !== void 0 && value > definition.max ? `is greater than ${definition.max}` : null;
+		default: return typeof value === "string" && definition.options.some((option) => option.value === value) ? null : "must be one of the options";
+	}
+};
+/** 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, storedForm(definition, definition.default)]));
+	const handlers = /* @__PURE__ */ new Set();
+	const known = (id) => {
+		const definition = byId.get(id);
+		if (definition === void 0) throw new Error(`setting '${id}' is not declared in the manifest`);
+		return definition;
+	};
+	const checked = (id, value) => {
+		const problem = findSettingProblem(known(id), value);
+		if (problem !== null) throw new Error(`setting '${id}' ${problem}`);
+		return storedForm(known(id), value);
+	};
+	for (const [id, value] of Object.entries(initial)) values.set(id, checked(id, value));
+	return {
+		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 (sameSettingValue(values.get(id), next)) return;
+			values.set(id, next);
+			for (const handler of [...handlers]) await handler({
+				id,
+				value: next
+			});
+		}
+	};
+};
+/** In-memory learning event subscriptions: one handler per event, as in the host. */
+const createMemoryEvents = (options = {}) => {
+	const handlers = /* @__PURE__ */ new Map();
+	return {
+		on(name, handler) {
+			if (options.permitted === false) throw new PermissionError("learning.events");
+			if (options.declared !== void 0 && !options.declared.includes(name)) throw new Error(`event '${name}' is not declared in the manifest`);
+			if (handlers.has(name)) throw new Error(`event '${name}' is already subscribed`);
+			handlers.set(name, handler);
+			return { dispose: () => {
+				if (handlers.get(name) === handler) handlers.delete(name);
+			} };
+		},
+		async emit(name, payload) {
+			await handlers.get(name)?.(payload);
+		}
+	};
+};
+/** In-memory commands: the same registration rules and result parsing as the host. */
+const createMemoryCommands = (options = {}) => {
+	const handlers = /* @__PURE__ */ new Map();
+	return {
+		register(id, handler) {
+			if (options.declaredCommands !== void 0 && !options.declaredCommands.includes(id)) throw new Error(`command '${id}' is not declared in the manifest`);
+			if (handlers.has(id)) throw new Error(`command '${id}' is already registered`);
+			handlers.set(id, handler);
+			return { dispose: () => {
+				if (handlers.get(id) === handler) handlers.delete(id);
+			} };
+		},
+		async run(id, args) {
+			const handler = handlers.get(id);
+			if (handler === void 0) throw new Error(`command '${id}' was not registered`);
+			if ((JSON.stringify(args)?.length ?? 0) > EXTENSION_COMMAND_LIMITS.argsChars) throw new Error(`args are longer than ${EXTENSION_COMMAND_LIMITS.argsChars} characters`);
+			const result = await handler(args);
+			try {
+				return normalizeCommandResult(result, options.declaredPanels);
+			} catch (error) {
+				if (error instanceof InvalidCommandResultError) throw new Error(`invalid command result: ${error.message}`);
+				throw error;
+			}
+		},
+		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) => {
 	const validate = new Ajv2020({
 		allErrors: true,
@@ -86,16 +533,13 @@ const findGradeResultProblem = (result) => {
 };
 const loadExerciseType = async (module, type, options = {}) => {
 	const handlers = /* @__PURE__ */ new Map();
-	const context = {
-		extensionId: "test",
-		logger: options.logger ?? silentLogger,
-		library: options.library ?? createMemoryLibrary({}),
+	const context = contextOf(options, {
 		registerExerciseType: (registeredType, handler) => {
 			handlers.set(registeredType, handler);
 			return { dispose: () => void handlers.delete(registeredType) };
 		},
 		registerGradePolicy: () => ({ dispose: () => void 0 })
-	};
+	});
 	await module.activate(context);
 	const handler = handlers.get(type);
 	if (handler === void 0) throw new Error(`exercise type '${type}' was not registered`);
@@ -134,16 +578,13 @@ const loadExerciseType = async (module, type, options = {}) => {
 const isGradeValue = (value) => Number.isInteger(value) && value >= 1 && value <= 5;
 const loadGradePolicy = async (module, id, options = {}) => {
 	const handlers = /* @__PURE__ */ new Map();
-	const context = {
-		extensionId: "test",
-		logger: options.logger ?? silentLogger,
-		library: options.library ?? createMemoryLibrary({}),
+	const context = contextOf(options, {
 		registerExerciseType: () => ({ dispose: () => void 0 }),
 		registerGradePolicy: (registeredId, handler) => {
 			handlers.set(registeredId, handler);
 			return { dispose: () => void handlers.delete(registeredId) };
 		}
-	};
+	});
 	await module.activate(context);
 	const handler = handlers.get(id);
 	if (handler === void 0) throw new Error(`grade policy '${id}' was not registered`);
@@ -158,6 +599,276 @@ const loadGradePolicy = async (module, id, options = {}) => {
 		}
 	};
 };
+/**
+* Activates the module with in-memory storage, settings, and events, and lets the test
+* send events and change settings.
+*/
+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
+	}, {
+		registerExerciseType: () => ({ dispose: () => void 0 }),
+		registerGradePolicy: () => ({ dispose: () => void 0 })
+	});
+	await module.activate(context);
+	return {
+		emit: events.emit,
+		storage,
+		secrets,
+		settings,
+		dispose: async () => {
+			await module.deactivate?.();
+		}
+	};
+};
+/** Activates the module with in-memory commands and lets the test invoke them like the host. */
+const loadCommands = async (module, options = {}) => {
+	const commands = createMemoryCommands(options);
+	const context = contextOf({
+		...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 }),
+		registerGradePolicy: () => ({ dispose: () => void 0 })
+	});
+	await module.activate(context);
+	return {
+		run: commands.run,
+		ids: commands.ids,
+		dispose: async () => {
+			await module.deactivate?.();
+		}
+	};
+};
+/** 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;
+};
+const microtask = () => Promise.resolve();
+let viewCounter = 0;
+/**
+* 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).
+*/
+const loadView = async (views, id, options = {}) => {
+	const doc = requireDocument("loadView");
+	const view = views[id];
+	if (view === void 0) throw new Error(`view '${id}' was not exported`);
+	const tag = `dolphy-test-view-${++viewCounter}`;
+	customElements.define(tag, createAnswerElementClass(tag, view));
+	const element = doc.createElement(tag);
+	if (options.label !== void 0) element.setAttribute("aria-label", options.label);
+	for (const key of [
+		"view",
+		"value",
+		"disabled",
+		"verdict"
+	]) if (options[key] !== void 0) Object.assign(element, { [key]: options[key] });
+	const changes = [];
+	let submissions = 0;
+	element.addEventListener(ANSWER_EVENT.change, (event) => {
+		changes.push(event.detail);
+	});
+	element.addEventListener(ANSWER_EVENT.submit, () => void (submissions += 1));
+	const container = options.container ?? doc.body.appendChild(doc.createElement("div"));
+	container.append(element);
+	await microtask();
+	const root = element.shadowRoot;
+	return {
+		element,
+		root,
+		changes,
+		get submissions() {
+			return submissions;
+		},
+		update: async (props) => {
+			Object.assign(element, props);
+			await microtask();
+		},
+		query: (selector) => root.querySelector(selector),
+		queryAll: (selector) => [...root.querySelectorAll(selector)],
+		dispose: () => {
+			element.remove();
+			if (options.container === void 0) container.remove();
+		}
+	};
+};
+/** 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 { context, frame, container } = createFrameContext(options, doc);
+	const listeners = /* @__PURE__ */ new Set();
+	await panel.mount(container, {
+		get context() {
+			return context.context;
+		},
+		signal: context.signal,
+		call: context.call,
+		onContextChange: context.onContextChange,
+		panelId: id,
+		props: options.props,
+		onProps: (listener) => {
+			listeners.add(listener);
+			return () => void listeners.delete(listener);
+		}
+	});
+	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;
+		},
+		signal: context.signal,
+		call: context.call,
+		onContextChange: context.onContextChange,
+		widgetId: id
+	});
+	return frame;
+};
 
 //#endregion
-export { createMemoryLibrary, createSchemaValidator, loadExerciseType, loadGradePolicy };
+export { createMemoryCommands, createMemoryEvents, createMemoryExporters, createMemoryImporters, createMemoryLibrary, createMemoryNotifications, createMemorySchedule, createMemorySecrets, createMemorySettings, createMemoryStats, createMemoryStorage, createSchemaValidator, loadCommands, loadEvents, loadExerciseType, loadExporters, loadGradePolicy, loadImporters, loadPanel, loadSchedules, loadView, loadWidget };