@pie-players/pie-default-tool-loaders 0.3.64 → 0.3.65

package/dist/registrations/subject-specific-tools.js

@@ -0,0 +1,158 @@
+/**
+ * Subject-Specific Tools Registrations
+ *
+ * Registers tools for specific subject areas:
+ * - Graph (graphing calculator/coordinate plane)
+ * - Periodic Table (chemistry reference)
+ *
+ * Maps to QTI 3.0 standard access features:
+ * - graphingCalculator (assessment tool)
+ * - graph (assessment tool)
+ * - periodicTable (assessment tool)
+ */
+import { hasMathContent, hasScienceContent, } from "@pie-players/pie-assessment-toolkit/tools/internal";
+import { createToolElement, } from "@pie-players/pie-assessment-toolkit/tools/internal";
+import { createScopedVisibilityBinding, syncButtonAndOverlayVisibility, } from "@pie-players/pie-assessment-toolkit/tools/internal";
+/**
+ * Graph tool registration
+ *
+ * Provides graphing calculator and coordinate plane functionality.
+ * Context-smart: appears automatically for math content or when explicitly enabled.
+ */
+export const graphToolRegistration = {
+    toolId: "graph",
+    name: "Graph",
+    description: "Graphing calculator and coordinate plane",
+    icon: "chart-bar",
+    // Graph is a section-level floating tool.
+    supportedLevels: ["section"],
+    // PNP support IDs
+    // Maps to QTI 3.0 standard features: graph, graphingCalculator
+    pnpSupportIds: [
+        "graph", // QTI 3.0 standard (assessment.graph)
+        "graphingCalculator", // QTI 3.0 standard (assessment.graphingCalculator)
+        "coordinatePlane", // Common variant
+        "graphingTool", // Common variant
+    ],
+    /**
+     * Pass 2: Graph is relevant when math content is present
+     */
+    isVisibleInContext(context) {
+        return hasMathContent(context);
+    },
+    renderToolbar(context, toolbarContext) {
+        const visibility = createScopedVisibilityBinding(this.toolId, toolbarContext);
+        const button = {
+            toolId: this.toolId,
+            label: this.name,
+            icon: typeof this.icon === "function" ? this.icon(context) : this.icon,
+            disabled: false,
+            ariaLabel: "Graph - Graphing calculator",
+            tooltip: "Graph",
+            onClick: () => toolbarContext.toggleTool(this.toolId),
+            active: visibility.isActive(),
+        };
+        const componentOverrides = toolbarContext.componentOverrides ?? {};
+        const overlay = createToolElement(this.toolId, context, toolbarContext, componentOverrides);
+        overlay.setAttribute("tool-id", visibility.fullToolId);
+        return {
+            toolId: this.toolId,
+            button,
+            elements: [
+                {
+                    element: overlay,
+                    mount: "after-buttons",
+                    shell: {
+                        title: this.name,
+                        draggable: true,
+                        resizable: true,
+                        closeable: true,
+                        initialWidth: 920,
+                        initialHeight: 680,
+                        minWidth: 640,
+                        minHeight: 500,
+                    },
+                },
+            ],
+            sync: () => {
+                syncButtonAndOverlayVisibility({
+                    button,
+                    overlay,
+                    isActive: visibility.isActive,
+                });
+            },
+            subscribeActive: visibility.subscribeActive,
+        };
+    },
+};
+/**
+ * Periodic Table tool registration
+ *
+ * Provides chemistry periodic table reference.
+ * Context-smart: appears automatically for science content or when explicitly enabled.
+ */
+export const periodicTableToolRegistration = {
+    toolId: "periodicTable",
+    name: "Periodic Table",
+    description: "Chemistry periodic table reference",
+    icon: "beaker",
+    // Periodic table is a section-level floating tool.
+    supportedLevels: ["section"],
+    // PNP support IDs
+    // Maps to QTI 3.0 standard feature: periodicTable
+    pnpSupportIds: [
+        "periodicTable", // QTI 3.0 standard (assessment.periodicTable)
+        "chemistryReference", // Common variant
+        "elementReference", // Common variant
+    ],
+    /**
+     * Pass 2: Periodic table is relevant when science content is present
+     */
+    isVisibleInContext(context) {
+        return hasScienceContent(context);
+    },
+    renderToolbar(context, toolbarContext) {
+        const visibility = createScopedVisibilityBinding(this.toolId, toolbarContext);
+        const button = {
+            toolId: this.toolId,
+            label: this.name,
+            icon: typeof this.icon === "function" ? this.icon(context) : this.icon,
+            disabled: false,
+            ariaLabel: "Periodic table - Chemistry reference",
+            tooltip: "Periodic Table",
+            onClick: () => toolbarContext.toggleTool(this.toolId),
+            active: visibility.isActive(),
+        };
+        const componentOverrides = toolbarContext.componentOverrides ?? {};
+        const overlay = createToolElement(this.toolId, context, toolbarContext, componentOverrides);
+        overlay.setAttribute("tool-id", visibility.fullToolId);
+        return {
+            toolId: this.toolId,
+            button,
+            elements: [
+                {
+                    element: overlay,
+                    mount: "after-buttons",
+                    shell: {
+                        title: this.name,
+                        draggable: true,
+                        resizable: true,
+                        closeable: true,
+                        initialWidth: 1160,
+                        initialHeight: 760,
+                        minWidth: 920,
+                        minHeight: 620,
+                    },
+                },
+            ],
+            sync: () => {
+                syncButtonAndOverlayVisibility({
+                    button,
+                    overlay,
+                    isActive: visibility.isActive,
+                });
+            },
+            subscribeActive: visibility.subscribeActive,
+        };
+    },
+};

package/dist/registrations/tts.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Text-to-Speech (TTS) Tool Registration
+ *
+ * Registers the TTS tool for reading content aloud.
+ *
+ * Maps to QTI 3.0 standard access features:
+ * - textToSpeech (auditory support)
+ * - readAloud (auditory support)
+ */
+import type { ToolRegistration } from "@pie-players/pie-assessment-toolkit/tools/internal";
+export declare const TOOL_ELEMENT_UNMOUNT_CALLBACK_PROP = "__pieToolElementUnmount";
+export declare const TOOL_ACTIVE_CHANGE_EVENT = "pie-tool-active-change";
+/**
+ * Text-to-Speech tool registration
+ *
+ * Supports:
+ * - Reading content aloud using browser TTS or external providers
+ * - Context-aware visibility (shows when readable text is available)
+ * - All levels except assessment and element
+ */
+export declare const ttsToolRegistration: ToolRegistration;

package/dist/registrations/tts.js

@@ -0,0 +1,184 @@
+/**
+ * Text-to-Speech (TTS) Tool Registration
+ *
+ * Registers the TTS tool for reading content aloud.
+ *
+ * Maps to QTI 3.0 standard access features:
+ * - textToSpeech (auditory support)
+ * - readAloud (auditory support)
+ */
+import { hasReadableText } from "@pie-players/pie-assessment-toolkit/tools/internal";
+import { createScopedToolId } from "@pie-players/pie-assessment-toolkit/tools/internal";
+import { buildRuntimeTTSConfig, normalizeTTSLayoutMode, normalizeTTSSpeedControlOptions, resolveTTSHostToolbarLayout, resolveTTSLayoutMode, resolveTTSBackend, resolveTTSRuntimeSettings, resolveRuntimeProvider, resolveTransportMode, } from "@pie-players/pie-assessment-toolkit/tools/internal";
+import { TTSToolProvider } from "@pie-players/pie-assessment-toolkit/tools/internal";
+const inlineTTSControls = new Map();
+export const TOOL_ELEMENT_UNMOUNT_CALLBACK_PROP = "__pieToolElementUnmount";
+export const TOOL_ACTIVE_CHANGE_EVENT = "pie-tool-active-change";
+/**
+ * Text-to-Speech tool registration
+ *
+ * Supports:
+ * - Reading content aloud using browser TTS or external providers
+ * - Context-aware visibility (shows when readable text is available)
+ * - All levels except assessment and element
+ */
+export const ttsToolRegistration = {
+    toolId: "textToSpeech",
+    name: "Text to Speech",
+    description: "Read content aloud",
+    icon: "volume-up",
+    provider: {
+        getProviderId: () => "tts",
+        createProvider: (config) => {
+            const settings = resolveTTSRuntimeSettings(config);
+            return new TTSToolProvider(resolveTTSBackend(settings));
+        },
+        getInitConfig: (config) => {
+            const settings = resolveTTSRuntimeSettings(config);
+            const backend = resolveTTSBackend(settings);
+            const serverProvider = resolveRuntimeProvider(settings, backend);
+            const transportMode = resolveTransportMode(settings, serverProvider);
+            return {
+                backend,
+                serverProvider,
+                transportMode,
+                ...buildRuntimeTTSConfig(settings),
+            };
+        },
+        getAuthFetcher: (config) => {
+            const runtimeAuthFetcher = config?.provider?.runtime?.authFetcher;
+            return typeof runtimeAuthFetcher === "function"
+                ? runtimeAuthFetcher
+                : undefined;
+        },
+        sanitizeConfig: (config) => {
+            const settings = config.settings && typeof config.settings === "object"
+                ? { ...config.settings }
+                : undefined;
+            if (settings && "layoutMode" in settings) {
+                settings.layoutMode = normalizeTTSLayoutMode(settings.layoutMode);
+            }
+            if (settings && "speedOptions" in settings) {
+                settings.speedOptions = normalizeTTSSpeedControlOptions(settings.speedOptions);
+            }
+            const normalizedConfig = {
+                ...config,
+            };
+            if ("layoutMode" in normalizedConfig) {
+                normalizedConfig.layoutMode = normalizeTTSLayoutMode(normalizedConfig.layoutMode);
+            }
+            if ("speedOptions" in normalizedConfig) {
+                normalizedConfig.speedOptions = normalizeTTSSpeedControlOptions(normalizedConfig.speedOptions);
+            }
+            if (settings) {
+                normalizedConfig.settings = settings;
+            }
+            return normalizedConfig;
+        },
+        lazy: true,
+    },
+    // TTS is inline-only and scoped to item/passage contexts.
+    supportedLevels: ["item", "passage"],
+    // PNP support IDs that enable this tool
+    // Maps to QTI 3.0 standard features: textToSpeech, readAloud
+    pnpSupportIds: [
+        "textToSpeech", // QTI 3.0 standard (auditory.textToSpeech)
+        "readAloud", // QTI 3.0 standard (auditory.readAloud)
+        "tts", // Common abbreviation
+        "speechOutput", // Common variant
+    ],
+    /**
+     * Pass 2: Determine if TTS is relevant in this context
+     *
+     * TTS is relevant when:
+     * - Context contains readable text (at least 10 characters)
+     */
+    isVisibleInContext(context) {
+        return hasReadableText(context);
+    },
+    renderToolbar(_context, toolbarContext) {
+        const resolveRuntimeSettings = () => resolveTTSRuntimeSettings(toolbarContext.toolkitCoordinator?.getToolConfig(this.toolId) ||
+            undefined);
+        const resolveElementSpeedOptions = () => {
+            const runtimeSettings = resolveRuntimeSettings();
+            return normalizeTTSSpeedControlOptions(runtimeSettings.speedOptions);
+        };
+        const resolveLayoutMode = () => resolveTTSLayoutMode(resolveRuntimeSettings());
+        const resolveHostLayout = () => resolveTTSHostToolbarLayout(resolveRuntimeSettings());
+        const fullToolId = createScopedToolId(this.toolId, toolbarContext.scope.level, toolbarContext.scope.scopeId);
+        const resolveControlSize = () => {
+            const raw = toolbarContext.ui?.size;
+            return raw === "sm" || raw === "lg" ? raw : "md";
+        };
+        const ensureElement = () => {
+            let element = inlineTTSControls.get(fullToolId);
+            if (element &&
+                typeof element.isConnected ===
+                    "boolean" &&
+                !element.isConnected) {
+                inlineTTSControls.delete(fullToolId);
+                element = undefined;
+            }
+            if (!element) {
+                element = document.createElement("pie-tool-tts-inline");
+                element[TOOL_ELEMENT_UNMOUNT_CALLBACK_PROP] = () => {
+                    if (inlineTTSControls.get(fullToolId) === element) {
+                        inlineTTSControls.delete(fullToolId);
+                    }
+                };
+                inlineTTSControls.set(fullToolId, element);
+            }
+            element.setAttribute("tool-id", fullToolId);
+            element.setAttribute("catalog-id", toolbarContext.catalogId || toolbarContext.itemId);
+            element.setAttribute("language", toolbarContext.language || "en-US");
+            element.setAttribute("size", resolveControlSize());
+            element.setAttribute("layout-mode", resolveLayoutMode());
+            element.speedOptions = resolveElementSpeedOptions();
+            element.showSingleSpeedOption =
+                resolveRuntimeSettings().showSingleSpeedOption === true;
+            return element;
+        };
+        const hostLayout = resolveHostLayout();
+        return {
+            toolId: this.toolId,
+            button: null,
+            elements: [
+                {
+                    element: ensureElement(),
+                    mount: hostLayout.mount,
+                    layoutHints: {
+                        controlsRow: {
+                            reserveSpace: hostLayout.controlsRow.reserveSpace,
+                            showWhenToolActive: hostLayout.controlsRow.expandWhenToolActive,
+                        },
+                        headerOverlay: {
+                            showWhenToolActive: hostLayout.headerOverlay.expandWhenToolActive,
+                        },
+                    },
+                },
+            ],
+            subscribeActive: (callback) => {
+                const element = ensureElement();
+                const handler = (event) => {
+                    const detail = event.detail;
+                    callback(detail?.active === true);
+                };
+                element.addEventListener(TOOL_ACTIVE_CHANGE_EVENT, handler);
+                return () => {
+                    element.removeEventListener(TOOL_ACTIVE_CHANGE_EVENT, handler);
+                };
+            },
+            sync: () => {
+                const element = ensureElement();
+                element.setAttribute("tool-id", fullToolId);
+                element.setAttribute("catalog-id", toolbarContext.catalogId || toolbarContext.itemId);
+                element.setAttribute("language", toolbarContext.language || "en-US");
+                element.setAttribute("size", resolveControlSize());
+                element.setAttribute("layout-mode", resolveLayoutMode());
+                element.speedOptions = resolveElementSpeedOptions();
+                element.showSingleSpeedOption =
+                    resolveRuntimeSettings().showSingleSpeedOption === true;
+            },
+        };
+    },
+};

package/dist/tool-placement.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Placement presets for the packaged capability set.
+ *
+ * Composition data for the same reason the tag map and the registrations are:
+ * they name capabilities. The toolkit keeps `DEFAULT_TOOL_PLACEMENT`, which is
+ * empty at every level and names none.
+ */
+/**
+ * Every packaged capability at every level it supports. Prefer explicit host
+ * configuration over adopting this wholesale.
+ */
+export declare const PACKAGED_TOOL_PLACEMENT: {
+    readonly assessment: readonly ["theme"];
+    readonly section: readonly ["theme"];
+    readonly item: readonly ["textToSpeech", "highlighter", "annotationToolbar", "graph", "periodicTable"];
+    readonly passage: readonly ["textToSpeech", "highlighter", "annotationToolbar", "lineReader"];
+    readonly rubric: readonly ["textToSpeech", "highlighter", "annotationToolbar", "lineReader"];
+    readonly element: readonly ["calculator", "answerEliminator", "textToSpeech", "ruler", "protractor", "highlighter", "annotationToolbar", "graph", "periodicTable"];
+};
+/**
+ * Each packaged capability once, at its usual assessment surface. Not
+ * exhaustive: `supportedLevels` still bounds where a capability can run, and a
+ * host can place them differently for its own UX.
+ */
+export declare const SECTION_PLAYER_PREFERRED_TOOL_PLACEMENT: {
+    section: string[];
+    item: string[];
+    passage: string[];
+};

package/dist/tool-placement.js

@@ -0,0 +1,52 @@
+/**
+ * Placement presets for the packaged capability set.
+ *
+ * Composition data for the same reason the tag map and the registrations are:
+ * they name capabilities. The toolkit keeps `DEFAULT_TOOL_PLACEMENT`, which is
+ * empty at every level and names none.
+ */
+/**
+ * Every packaged capability at every level it supports. Prefer explicit host
+ * configuration over adopting this wholesale.
+ */
+export const PACKAGED_TOOL_PLACEMENT = {
+    assessment: ["theme"],
+    section: ["theme"],
+    item: [
+        "textToSpeech",
+        "highlighter",
+        "annotationToolbar",
+        "graph",
+        "periodicTable",
+    ],
+    passage: ["textToSpeech", "highlighter", "annotationToolbar", "lineReader"],
+    rubric: ["textToSpeech", "highlighter", "annotationToolbar", "lineReader"],
+    element: [
+        "calculator",
+        "answerEliminator",
+        "textToSpeech",
+        "ruler",
+        "protractor",
+        "highlighter",
+        "annotationToolbar",
+        "graph",
+        "periodicTable",
+    ],
+};
+/**
+ * Each packaged capability once, at its usual assessment surface. Not
+ * exhaustive: `supportedLevels` still bounds where a capability can run, and a
+ * host can place them differently for its own UX.
+ */
+export const SECTION_PLAYER_PREFERRED_TOOL_PLACEMENT = {
+    section: [
+        "theme",
+        "graph",
+        "periodicTable",
+        "lineReader",
+        "ruler",
+        "protractor",
+    ],
+    item: ["calculator", "textToSpeech", "answerEliminator", "annotationToolbar"],
+    passage: ["textToSpeech", "annotationToolbar"],
+};

package/dist/tool-tag-map.d.ts

@@ -0,0 +1,16 @@
+import type { ToolTagMap } from "@pie-players/pie-assessment-toolkit/tools/internal";
+/**
+ * Element tag for each packaged tool.
+ *
+ * Composition data, not core data: it is a catalogue of which capabilities exist
+ * in a deployment and which element renders each. It lived in the toolkit, where
+ * a core module naming eleven capabilities meant a host could not add a twelfth
+ * without editing our package — the map was overridable, but its default was
+ * core-resident, so the core still had to know the names.
+ *
+ * `resolveToolTag` in the toolkit reads only the overrides it is handed, and
+ * `createPackagedToolRegistry` installs this map through
+ * `ToolRegistry.setComponentOverrides`. A host composing its own registry
+ * supplies its own map the same way.
+ */
+export declare const PACKAGED_TOOL_TAG_MAP: ToolTagMap;

package/dist/tool-tag-map.js

@@ -0,0 +1,27 @@
+/**
+ * Element tag for each packaged tool.
+ *
+ * Composition data, not core data: it is a catalogue of which capabilities exist
+ * in a deployment and which element renders each. It lived in the toolkit, where
+ * a core module naming eleven capabilities meant a host could not add a twelfth
+ * without editing our package — the map was overridable, but its default was
+ * core-resident, so the core still had to know the names.
+ *
+ * `resolveToolTag` in the toolkit reads only the overrides it is handed, and
+ * `createPackagedToolRegistry` installs this map through
+ * `ToolRegistry.setComponentOverrides`. A host composing its own registry
+ * supplies its own map the same way.
+ */
+export const PACKAGED_TOOL_TAG_MAP = {
+    calculator: "pie-tool-calculator",
+    textToSpeech: "pie-tool-text-to-speech",
+    ruler: "pie-tool-ruler",
+    protractor: "pie-tool-protractor",
+    answerEliminator: "pie-tool-answer-eliminator",
+    highlighter: "pie-tool-annotation-toolbar",
+    lineReader: "pie-tool-line-reader",
+    theme: "pie-tool-theme",
+    annotationToolbar: "pie-tool-annotation-toolbar",
+    graph: "pie-tool-graph",
+    periodicTable: "pie-tool-periodic-table",
+};

package/dist/universal-supports.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Named preset of the PNP support ids the packaged tool set treats as universal
+ * features — data, not a derivation.
+ *
+ * This list was previously computed at import time by unioning every registered
+ * tool's `pnpSupportIds`, which made registry membership decide eligibility tier
+ * and had to be corrected by a compile-time exclusion list no host could extend.
+ * The ids below are that computation's output, frozen: adopt it, extend it, or
+ * replace it alongside the district and test-administration configuration, the
+ * same way any other policy input is chosen.
+ *
+ * Two properties this list must keep:
+ *
+ *   1. **Universal features only.** An accommodation belongs here only if the
+ *      program has decided it is universal — which is a decision about the
+ *      program, not about the capability. TTS sits here because the packaged set
+ *      treats it as a universal feature; it is a documented accommodation in
+ *      other programs.
+ *   2. **No content-dependent capability.** A capability declaring
+ *      `requiresAuthoredContent` needs an authored resource to have anything to
+ *      show, so granting it wholesale grants an accommodation to learners who
+ *      have no documented need for it. `tests/universal-supports.test.ts`
+ *      enforces this against the registrations rather than against a name list.
+ */
+import type { PersonalNeedsProfile } from "@pie-players/pie-players-shared/types";
+export declare const UNIVERSAL_SUPPORTS_PRESET: readonly string[];
+/**
+ * Build a profile granting {@link UNIVERSAL_SUPPORTS_PRESET}.
+ *
+ * A fresh array per call: a profile flows into policy inputs that hosts mutate,
+ * and handing out a shared reference would let one host's edit reach another's.
+ */
+export declare function createUniversalPersonalNeedsProfile(): PersonalNeedsProfile;

package/dist/universal-supports.js

@@ -0,0 +1,77 @@
+/**
+ * Named preset of the PNP support ids the packaged tool set treats as universal
+ * features — data, not a derivation.
+ *
+ * This list was previously computed at import time by unioning every registered
+ * tool's `pnpSupportIds`, which made registry membership decide eligibility tier
+ * and had to be corrected by a compile-time exclusion list no host could extend.
+ * The ids below are that computation's output, frozen: adopt it, extend it, or
+ * replace it alongside the district and test-administration configuration, the
+ * same way any other policy input is chosen.
+ *
+ * Two properties this list must keep:
+ *
+ *   1. **Universal features only.** An accommodation belongs here only if the
+ *      program has decided it is universal — which is a decision about the
+ *      program, not about the capability. TTS sits here because the packaged set
+ *      treats it as a universal feature; it is a documented accommodation in
+ *      other programs.
+ *   2. **No content-dependent capability.** A capability declaring
+ *      `requiresAuthoredContent` needs an authored resource to have anything to
+ *      show, so granting it wholesale grants an accommodation to learners who
+ *      have no documented need for it. `tests/universal-supports.test.ts`
+ *      enforces this against the registrations rather than against a name list.
+ */
+export const UNIVERSAL_SUPPORTS_PRESET = Object.freeze([
+    "angleMeasurement",
+    "annotation",
+    "annotations",
+    "answerEliminator",
+    "answerMasking",
+    "basicCalculator",
+    "calculator",
+    "chemistryReference",
+    "choiceMasking",
+    "colorContrast",
+    "coordinatePlane",
+    "customColors",
+    "elementReference",
+    "graph",
+    "graphingCalculator",
+    "graphingTool",
+    "highContrast",
+    "highContrastDisplay",
+    "highlighter",
+    "highlighting",
+    "invertColors",
+    "lineReader",
+    "measurement",
+    "periodicTable",
+    "protractor",
+    "readAloud",
+    "readingGuide",
+    "readingMask",
+    "readingRuler",
+    "ruler",
+    "scientificCalculator",
+    "speechOutput",
+    "strikethrough",
+    "textHighlight",
+    "textToSpeech",
+    "theme",
+    "trackingGuide",
+    "tts",
+]);
+/**
+ * Build a profile granting {@link UNIVERSAL_SUPPORTS_PRESET}.
+ *
+ * A fresh array per call: a profile flows into policy inputs that hosts mutate,
+ * and handing out a shared reference would let one host's edit reach another's.
+ */
+export function createUniversalPersonalNeedsProfile() {
+    return {
+        supports: [...UNIVERSAL_SUPPORTS_PRESET],
+        prohibitedSupports: [],
+        activateAtInit: [],
+    };
+}

package/package.json

@@ -1,8 +1,8 @@
 {
 	"name": "@pie-players/pie-default-tool-loaders",
-	"version": "0.3.64",
+	"version": "0.3.65",
 	"type": "module",
-	"description": "Default lazy module loaders for PIE assessment tools",
+	"description": "Composition layer for the packaged PIE assessment tools: registrations, tag map, placement presets, universal supports and lazy module loaders",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/pie-framework/pie-players.git",
@@ -32,19 +32,21 @@
 		"test": "bun test"
 	},
 	"dependencies": {
-		"@pie-players/pie-tool-annotation-toolbar": "0.3.64",
-		"@pie-players/pie-tool-answer-eliminator": "0.3.64",
-		"@pie-players/pie-tool-calculator-desmos": "0.3.64",
-		"@pie-players/pie-tool-theme": "0.3.64",
-		"@pie-players/pie-tool-graph": "0.3.64",
-		"@pie-players/pie-tool-line-reader": "0.3.64",
-		"@pie-players/pie-tool-periodic-table": "0.3.64",
-		"@pie-players/pie-tool-protractor": "0.3.64",
-		"@pie-players/pie-tool-ruler": "0.3.64",
-		"@pie-players/pie-tool-tts-inline": "0.3.64"
+		"@pie-players/pie-assessment-toolkit": "0.3.65",
+		"@pie-players/pie-players-shared": "0.3.65",
+		"@pie-players/pie-tool-annotation-toolbar": "0.3.65",
+		"@pie-players/pie-tool-answer-eliminator": "0.3.65",
+		"@pie-players/pie-tool-calculator-desmos": "0.3.65",
+		"@pie-players/pie-tool-graph": "0.3.65",
+		"@pie-players/pie-tool-line-reader": "0.3.65",
+		"@pie-players/pie-tool-periodic-table": "0.3.65",
+		"@pie-players/pie-tool-protractor": "0.3.65",
+		"@pie-players/pie-tool-ruler": "0.3.65",
+		"@pie-players/pie-tool-theme": "0.3.65",
+		"@pie-players/pie-tool-tts-inline": "0.3.65"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "^2.5.6",
+		"@biomejs/biome": "^2.5.7",
 		"typescript": "^5.9.3"
 	},
 	"homepage": "https://github.com/pie-framework/pie-players/tree/master/packages/default-tool-loaders#readme",