@pie-players/pie-default-tool-loaders 0.3.66 → 0.3.68

package/dist/content-alternates.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The packaged capabilities that carry an authored alternate and render it as a
+ * region.
+ *
+ * A projection of the composition set below, kept in its own module for one
+ * reason: it must be importable without reaching the packaged composition table,
+ * whose lazy loaders name concrete `pie-tool-*` packages. A renderer that only
+ * ever shows text alternates — print — would otherwise carry a calculator and a
+ * TTS bundle it can never activate.
+ *
+ * Which slot an alternate fills is still the renderer's decision, not this list's:
+ * every entry declares its own `surfaces`, and a host resolves the slots it
+ * actually opens. Print opens the in-flow one and not the docked-media one,
+ * because a signed alternate on paper is a blank rectangle.
+ *
+ * `tests/content-alternates.test.ts` pins this against the composition set in both
+ * directions, so a capability added there cannot quietly fail to reach print.
+ */
+import type { ToolRegistration } from "@pie-players/pie-assessment-toolkit/tools/internal";
+export declare const CONTENT_ALTERNATE_REGISTRATIONS: readonly ToolRegistration[];

package/dist/content-alternates.js

@@ -0,0 +1,22 @@
+/**
+ * The packaged capabilities that carry an authored alternate and render it as a
+ * region.
+ *
+ * A projection of the composition set below, kept in its own module for one
+ * reason: it must be importable without reaching the packaged composition table,
+ * whose lazy loaders name concrete `pie-tool-*` packages. A renderer that only
+ * ever shows text alternates — print — would otherwise carry a calculator and a
+ * TTS bundle it can never activate.
+ *
+ * Which slot an alternate fills is still the renderer's decision, not this list's:
+ * every entry declares its own `surfaces`, and a host resolves the slots it
+ * actually opens. Print opens the in-flow one and not the docked-media one,
+ * because a signed alternate on paper is a blank rectangle.
+ *
+ * `tests/content-alternates.test.ts` pins this against the composition set in both
+ * directions, so a capability added there cannot quietly fail to reach print.
+ */
+import { audioTranscriptRegistration } from "./registrations/audio-transcript.js";
+export const CONTENT_ALTERNATE_REGISTRATIONS = [
+    audioTranscriptRegistration,
+];

package/dist/index.d.ts

@@ -1,9 +1,11 @@
 export type { PackagedToolRegistryOptions, RegisterDefaultToolModuleLoadersOptions, RegisterPackagedToolsOptions, ToolModuleLoader, ToolRegistryLike, } from "./packaged-capability-composition.js";
 export { createPackagedToolRegistry, createUniversalPersonalNeedsProfile, DEFAULT_TOOL_MODULE_LOADERS, ITEM_TOOL_MODULE_LOADERS, PACKAGED_TOOL_ORDER, PACKAGED_TOOL_PLACEMENT, PACKAGED_TOOL_REGISTRATIONS, PACKAGED_TOOL_TAG_MAP, registerDefaultToolModuleLoaders, registerPackagedTools, registerSectionToolModuleLoaders, SECTION_PLAYER_PREFERRED_TOOL_PLACEMENT, SECTION_TOOL_MODULE_LOADERS, UNIVERSAL_SUPPORTS_PRESET, } from "./packaged-capability-composition.js";
+export { CONTENT_ALTERNATE_REGISTRATIONS } from "./content-alternates.js";
 export { annotationToolbarRegistration, lineReaderToolRegistration, themeToolRegistration, } from "./registrations/accessibility-tools.js";
 export { AUDIO_TRANSCRIPT_FEATURE_ID, AUDIO_TRANSCRIPT_REGION_CLASS, AUDIO_TRANSCRIPT_REGION_LABEL, audioTranscriptRegistration, resolveAudioTranscript, type ResolvedAudioTranscript, } from "./registrations/audio-transcript.js";
 export { calculatorToolRegistration } from "./registrations/calculator.js";
-export { answerEliminatorToolRegistration, highlighterToolRegistration, } from "./registrations/interaction-tools.js";
+export { createDictionaryToolRegistration, createPictureDictionaryToolRegistration, dictionaryToolRegistration, type DictionaryVariantOptions, pictureDictionaryToolRegistration, spanishDictionaryToolRegistration, spanishPictureDictionaryToolRegistration, } from "./registrations/dictionary-tools.js";
+export { answerEliminatorToolRegistration } from "./registrations/interaction-tools.js";
 export { protractorToolRegistration, rulerToolRegistration, } from "./registrations/measurement-tools.js";
 export { graphToolRegistration, periodicTableToolRegistration, } from "./registrations/subject-specific-tools.js";
 export { ttsToolRegistration } from "./registrations/tts.js";

package/dist/index.js

@@ -1,10 +1,14 @@
 export { createPackagedToolRegistry, createUniversalPersonalNeedsProfile, DEFAULT_TOOL_MODULE_LOADERS, ITEM_TOOL_MODULE_LOADERS, PACKAGED_TOOL_ORDER, PACKAGED_TOOL_PLACEMENT, PACKAGED_TOOL_REGISTRATIONS, PACKAGED_TOOL_TAG_MAP, registerDefaultToolModuleLoaders, registerPackagedTools, registerSectionToolModuleLoaders, SECTION_PLAYER_PREFERRED_TOOL_PLACEMENT, SECTION_TOOL_MODULE_LOADERS, UNIVERSAL_SUPPORTS_PRESET, } from "./packaged-capability-composition.js";
+// The authored-alternate subset, for a renderer that shows alternates and no
+// toolbar — importable without the packaged composition's tool loaders.
+export { CONTENT_ALTERNATE_REGISTRATIONS } from "./content-alternates.js";
 // Individual registrations, for a host composing a subset rather than the whole
 // packaged set.
 export { annotationToolbarRegistration, lineReaderToolRegistration, themeToolRegistration, } from "./registrations/accessibility-tools.js";
 export { AUDIO_TRANSCRIPT_FEATURE_ID, AUDIO_TRANSCRIPT_REGION_CLASS, AUDIO_TRANSCRIPT_REGION_LABEL, audioTranscriptRegistration, resolveAudioTranscript, } from "./registrations/audio-transcript.js";
 export { calculatorToolRegistration } from "./registrations/calculator.js";
-export { answerEliminatorToolRegistration, highlighterToolRegistration, } from "./registrations/interaction-tools.js";
+export { createDictionaryToolRegistration, createPictureDictionaryToolRegistration, dictionaryToolRegistration, pictureDictionaryToolRegistration, spanishDictionaryToolRegistration, spanishPictureDictionaryToolRegistration, } from "./registrations/dictionary-tools.js";
+export { answerEliminatorToolRegistration } from "./registrations/interaction-tools.js";
 export { protractorToolRegistration, rulerToolRegistration, } from "./registrations/measurement-tools.js";
 export { graphToolRegistration, periodicTableToolRegistration, } from "./registrations/subject-specific-tools.js";
 export { ttsToolRegistration } from "./registrations/tts.js";

package/dist/packaged-capability-composition.d.ts

@@ -41,7 +41,7 @@ export type RegisterDefaultToolModuleLoadersOptions = {
  * that prevents an otherwise usable assessment from rendering.
  */
 export declare function assertPackagedCapabilityComposition(): void;
-export declare const PACKAGED_TOOL_REGISTRATIONS: readonly [ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration];
+export declare const PACKAGED_TOOL_REGISTRATIONS: readonly [ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration];
 export declare const PACKAGED_TOOL_TAG_MAP: ToolTagMap;
 export declare const ITEM_TOOL_MODULE_LOADERS: Record<string, ToolModuleLoader>;
 export declare const SECTION_TOOL_MODULE_LOADERS: Record<string, ToolModuleLoader>;
@@ -49,17 +49,17 @@ export declare const DEFAULT_TOOL_MODULE_LOADERS: Record<string, ToolModuleLoade
 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"];
+    readonly item: readonly ["textToSpeech", "annotationToolbar", "graph", "periodicTable", "dictionary", "pictureDictionary", "dictionarySpanish", "pictureDictionarySpanish"];
+    readonly passage: readonly ["textToSpeech", "annotationToolbar", "lineReader"];
+    readonly rubric: readonly ["textToSpeech", "annotationToolbar", "lineReader"];
+    readonly element: readonly ["calculator", "answerEliminator", "textToSpeech", "ruler", "protractor", "annotationToolbar", "graph", "periodicTable", "dictionary", "pictureDictionary", "dictionarySpanish", "pictureDictionarySpanish"];
 };
 export declare const SECTION_PLAYER_PREFERRED_TOOL_PLACEMENT: {
     section: string[];
     item: string[];
     passage: string[];
 };
-export declare const PACKAGED_TOOL_ORDER: readonly ["theme", "calculator", "textToSpeech", "lineReader", "annotationToolbar", "highlighter", "answerEliminator", "ruler", "protractor", "graph", "periodicTable"];
+export declare const PACKAGED_TOOL_ORDER: readonly ["theme", "calculator", "textToSpeech", "lineReader", "annotationToolbar", "answerEliminator", "ruler", "protractor", "graph", "periodicTable", "dictionary", "pictureDictionary", "dictionarySpanish", "pictureDictionarySpanish"];
 export declare const UNIVERSAL_SUPPORTS_PRESET: readonly string[];
 /** Register packaged PIE capabilities onto an existing registry. */
 export declare function registerPackagedTools(registry: ToolRegistry, options?: RegisterPackagedToolsOptions): void;

package/dist/packaged-capability-composition.js

@@ -11,7 +11,8 @@ import { ToolRegistry, } from "@pie-players/pie-assessment-toolkit/tools/interna
 import { annotationToolbarRegistration, lineReaderToolRegistration, themeToolRegistration, } from "./registrations/accessibility-tools.js";
 import { audioTranscriptRegistration } from "./registrations/audio-transcript.js";
 import { calculatorToolRegistration } from "./registrations/calculator.js";
-import { answerEliminatorToolRegistration, highlighterToolRegistration, } from "./registrations/interaction-tools.js";
+import { dictionaryToolRegistration, pictureDictionaryToolRegistration, spanishDictionaryToolRegistration, spanishPictureDictionaryToolRegistration, } from "./registrations/dictionary-tools.js";
+import { answerEliminatorToolRegistration } from "./registrations/interaction-tools.js";
 import { protractorToolRegistration, rulerToolRegistration, } from "./registrations/measurement-tools.js";
 import { graphToolRegistration, periodicTableToolRegistration, } from "./registrations/subject-specific-tools.js";
 import { ttsToolRegistration } from "./registrations/tts.js";
@@ -33,6 +34,8 @@ const loadLineReaderModule = () => loadSideEffectModule(() => import("@pie-playe
 const loadThemeModule = () => loadSideEffectModule(() => import("@pie-players/pie-tool-theme"));
 const loadGraphModule = () => loadSideEffectModule(() => import("@pie-players/pie-tool-graph"));
 const loadPeriodicTableModule = () => loadSideEffectModule(() => import("@pie-players/pie-tool-periodic-table"));
+const loadDictionaryModule = () => loadSideEffectModule(() => import("@pie-players/pie-tool-dictionary"));
+const loadPictureDictionaryModule = () => loadSideEffectModule(() => import("@pie-players/pie-tool-picture-dictionary"));
 const PACKAGED_CAPABILITY_DEFINITIONS = [
     {
         registration: calculatorToolRegistration,
@@ -94,15 +97,6 @@ const PACKAGED_CAPABILITY_DEFINITIONS = [
             "choiceMasking",
         ],
     },
-    {
-        registration: highlighterToolRegistration,
-        tagName: "pie-tool-annotation-toolbar",
-        loadModule: loadAnnotationToolbarModule,
-        loaderTargets: ["item"],
-        placementOrder: { item: 20, passage: 20, rubric: 20, element: 60 },
-        toolbarOrder: 60,
-        universalSupportIds: ["highlighter", "textHighlight", "annotation"],
-    },
     {
         registration: lineReaderToolRegistration,
         tagName: "pie-tool-line-reader",
@@ -144,7 +138,16 @@ const PACKAGED_CAPABILITY_DEFINITIONS = [
         placementOrder: { item: 30, passage: 30, rubric: 30, element: 70 },
         preferredPlacementOrder: { item: 40, passage: 20 },
         toolbarOrder: 50,
-        universalSupportIds: ["highlighting", "annotations"],
+        // The last three came from the `highlighter` capability, which mounted this
+        // same element behind a second identically-labelled button. Kept here so a
+        // profile granted one of the older ids still gets highlighting.
+        universalSupportIds: [
+            "highlighting",
+            "annotations",
+            "highlighter",
+            "textHighlight",
+            "annotation",
+        ],
     },
     {
         registration: graphToolRegistration,
@@ -170,6 +173,51 @@ const PACKAGED_CAPABILITY_DEFINITIONS = [
             "elementReference",
         ],
     },
+    {
+        registration: dictionaryToolRegistration,
+        tagName: "pie-tool-dictionary",
+        loadModule: loadDictionaryModule,
+        loaderTargets: ["section"],
+        placementOrder: { item: 60, element: 100 },
+        preferredPlacementOrder: { section: 70 },
+        toolbarOrder: 120,
+        // Deliberately empty: a dictionary is a granted accommodation, and on a
+        // vocabulary item it is construct-relevant, so it is never universal.
+        universalSupportIds: [],
+    },
+    {
+        registration: pictureDictionaryToolRegistration,
+        tagName: "pie-tool-picture-dictionary",
+        loadModule: loadPictureDictionaryModule,
+        loaderTargets: ["section"],
+        placementOrder: { item: 70, element: 110 },
+        preferredPlacementOrder: { section: 80 },
+        toolbarOrder: 130,
+        universalSupportIds: [],
+    },
+    // The Spanish variants render the same elements under their own capability ids, so a
+    // programme can grant a Spanish gloss beside the content-following dictionary or
+    // instead of it. Ordered after both, since English-content delivery is the common case.
+    {
+        registration: spanishDictionaryToolRegistration,
+        tagName: "pie-tool-dictionary",
+        loadModule: loadDictionaryModule,
+        loaderTargets: ["section"],
+        placementOrder: { item: 80, element: 120 },
+        preferredPlacementOrder: { section: 90 },
+        toolbarOrder: 140,
+        universalSupportIds: [],
+    },
+    {
+        registration: spanishPictureDictionaryToolRegistration,
+        tagName: "pie-tool-picture-dictionary",
+        loadModule: loadPictureDictionaryModule,
+        loaderTargets: ["section"],
+        placementOrder: { item: 90, element: 130 },
+        preferredPlacementOrder: { section: 100 },
+        toolbarOrder: 150,
+        universalSupportIds: [],
+    },
     {
         registration: audioTranscriptRegistration,
         universalSupportIds: [],

package/dist/registrations/accessibility-tools.js

@@ -13,6 +13,8 @@
 import { hasReadableText } from "@pie-players/pie-assessment-toolkit/tools/internal";
 import { createToolElement, resolveToolTag, } from "@pie-players/pie-assessment-toolkit/tools/internal";
 import { applyOverlaySurface, createScopedVisibilityBinding, syncButtonAndOverlayVisibility, } from "@pie-players/pie-assessment-toolkit/tools/internal";
+import { buildSelectionActions } from "./selection-actions.js";
+import { renderOverlayToolbar } from "./overlay-toolbar-render.js";
 /**
  * Line Reader tool registration
  *
@@ -23,6 +25,8 @@ export const lineReaderToolRegistration = {
     toolId: "lineReader",
     name: "Line Reader",
     description: "Reading guide overlay",
+    nameKey: "tools.lineReader.name",
+    descriptionKey: "tools.lineReader.description",
     icon: "bars-3",
     // Line reader appears where there's text to read
     supportedLevels: ["section", "passage", "rubric", "item"],
@@ -42,37 +46,10 @@ export const lineReaderToolRegistration = {
         return hasReadableText(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: "Line reader - Reading guide",
-            tooltip: "Line Reader",
-            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);
-        applyOverlaySurface(overlay, "frameless");
-        return {
-            toolId: this.toolId,
-            button,
-            elements: [{ element: overlay, mount: "after-buttons" }],
-            sync: () => {
-                syncButtonAndOverlayVisibility({
-                    button,
-                    overlay,
-                    isActive: visibility.isActive,
-                });
-                if (toolbarContext.toolkitCoordinator) {
-                    overlay.toolkitCoordinator = toolbarContext.toolkitCoordinator;
-                }
-            },
-            subscribeActive: visibility.subscribeActive,
-        };
+        return renderOverlayToolbar(this, context, toolbarContext, {
+            surface: "frameless",
+            handsOverCoordinator: true,
+        });
     },
 };
 /**
@@ -85,6 +62,8 @@ export const themeToolRegistration = {
     toolId: "theme",
     name: "Theme",
     description: "Accessible themes and contrast",
+    nameKey: "tools.theme.name",
+    descriptionKey: "tools.theme.description",
     icon: "swatch",
     // Color scheme is assessment-wide
     supportedLevels: ["assessment", "section"],
@@ -105,51 +84,16 @@ export const themeToolRegistration = {
         return true; // Always show if allowed by orchestrator
     },
     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: "Theme - Change colors and contrast",
-            tooltip: "Theme",
-            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: false,
-                        closeable: true,
-                        initialWidth: 520,
-                        initialHeight: 380,
-                        minWidth: 420,
-                        minHeight: 300,
-                    },
-                },
-            ],
-            sync: () => {
-                syncButtonAndOverlayVisibility({
-                    button,
-                    overlay,
-                    isActive: visibility.isActive,
-                });
-                if (toolbarContext.toolkitCoordinator) {
-                    overlay.toolkitCoordinator = toolbarContext.toolkitCoordinator;
-                }
+        return renderOverlayToolbar(this, context, toolbarContext, {
+            shell: {
+                resizable: false,
+                initialWidth: 520,
+                initialHeight: 380,
+                minWidth: 420,
+                minHeight: 300,
             },
-            subscribeActive: visibility.subscribeActive,
-        };
+            handsOverCoordinator: true,
+        });
     },
 };
 /**
@@ -162,6 +106,8 @@ export const annotationToolbarRegistration = {
     toolId: "annotationToolbar",
     name: "Highlighter",
     description: "Highlight and annotate text",
+    nameKey: "tools.annotationToolbar.name",
+    descriptionKey: "tools.annotationToolbar.description",
     icon: "highlighter",
     activation: "selection-gateway",
     singletonScope: "section",
@@ -217,40 +163,17 @@ export const annotationToolbarRegistration = {
             element.ttsService = current.services.ttsService;
             element.highlightCoordinator =
                 current.services.toolkitCoordinator?.highlightCoordinator ?? null;
+            // The second door onto the dictionaries. The gateway renders these and
+            // knows nothing of what they open; the pairing is composition's, which is
+            // why the list is built in `selection-actions.ts` and not here.
+            element.selectionActions = buildSelectionActions(current.services);
         };
         applyServices(context);
         return { element, sync: applyServices };
     },
     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: "Annotation toolbar - Highlight text",
-            tooltip: "Highlight",
-            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" }],
-            sync: () => {
-                syncButtonAndOverlayVisibility({
-                    button,
-                    overlay,
-                    isActive: visibility.isActive,
-                });
-                if (toolbarContext.toolkitCoordinator) {
-                    overlay.toolkitCoordinator = toolbarContext.toolkitCoordinator;
-                }
-            },
-            subscribeActive: visibility.subscribeActive,
-        };
+        return renderOverlayToolbar(this, context, toolbarContext, {
+            handsOverCoordinator: true,
+        });
     },
 };

package/dist/registrations/audio-transcript.js

@@ -144,6 +144,8 @@ export const audioTranscriptRegistration = {
     toolId: AUDIO_TRANSCRIPT_FEATURE_ID,
     name: "Audio Transcript",
     description: "Text of an audio prompt, read before the content it transcribes",
+    nameKey: "tools.audioTranscript.name",
+    descriptionKey: "tools.audioTranscript.description",
     supportedLevels: ["item", "passage"],
     pnpSupportIds: [AUDIO_TRANSCRIPT_FEATURE_ID],
     // No button to press: a transcript is either authored-visible, or granted and
@@ -173,7 +175,11 @@ export const audioTranscriptRegistration = {
         applyTranscript(region, transcript);
         return {
             element: region,
-            ariaLabel: AUDIO_TRANSCRIPT_REGION_LABEL,
+            // `AUDIO_TRANSCRIPT_REGION_LABEL` stays the English source and the
+            // exported constant tests address; the catalog supplies the rendered
+            // label when a host published a provider.
+            ariaLabel: context.services.i18n?.t("tools.audioTranscript.regionA11y") ??
+                AUDIO_TRANSCRIPT_REGION_LABEL,
             // Reads the context it is handed, never the one captured above: on a
             // re-resolve the host's context carries the current card, and a learner must
             // not keep reading the previous item's transcript.

package/dist/registrations/calculator.js

@@ -61,13 +61,21 @@ function getCalculatorRenderParams(toolbarContext) {
     return {
         calculatorType,
         availableTypes,
-        displayName: calculatorType === "scientific"
-            ? "Scientific Calculator"
-            : calculatorType === "basic"
-                ? "Basic Calculator"
-                : "Calculator",
+        displayName: toolbarContext.i18n.t(CALCULATOR_NAME_KEYS[calculatorType ?? "untyped"]),
     };
 }
+/**
+ * The calculator's displayed name, per host-declared type.
+ *
+ * `untyped` keeps the pre-adoption behaviour of naming the scientific
+ * calculator, which is what the toolbar has always announced when the host
+ * declares no type.
+ */
+const CALCULATOR_NAME_KEYS = {
+    basic: "tools.calculator.nameBasic",
+    scientific: "tools.calculator.nameScientific",
+    untyped: "tools.calculator.name",
+};
 function applyCalculatorParamsToElement(element, calculatorType, availableTypes) {
     const calculatorElement = element;
     if (calculatorType) {
@@ -97,6 +105,8 @@ export const calculatorToolRegistration = {
     toolId: "calculator",
     name: "Calculator",
     description: "Multi-type calculator (basic, scientific, graphing)",
+    nameKey: "tools.calculator.name",
+    descriptionKey: "tools.calculator.description",
     icon: "calculator",
     provider: {
         getProviderId: (config) => typeof config?.provider?.id === "string" && config.provider.id.length > 0
@@ -154,18 +164,20 @@ export const calculatorToolRegistration = {
         overlay.setAttribute("tool-id", fullToolId);
         overlay.toolkitCoordinator = toolbarContext.toolkitCoordinator;
         applyCalculatorParamsToElement(overlay, calculatorType, availableTypes);
-        const openLabel = calculatorType === null
-            ? "Open scientific calculator"
-            : `Open ${displayName.toLowerCase()}`;
-        const closeLabel = calculatorType === null
-            ? "Close scientific calculator"
-            : `Close ${displayName.toLowerCase()}`;
         const button = {
             toolId: this.toolId,
             label: displayName,
             icon: typeof this.icon === "function" ? this.icon(context) : this.icon,
+            // Routes this button through <nds-icon-button> where the host enables NDS
+            // icons. Declared here because which capabilities render in the host's
+            // design system is a composition decision; the toolbar used to map it from
+            // the `calculator` toolId, which put a capability name in the generic core.
+            faIconName: "calculator",
             disabled: false,
-            ariaLabel: openLabel,
+            // The name stays put across open and closed. The toolbar mirrors
+            // `active` onto the button as `aria-pressed`, so the state is already
+            // exposed; a name that also swapped to "Close …" would contradict it.
+            ariaLabel: displayName,
             tooltip: displayName,
             onClick: () => toolbarContext.toggleTool(this.toolId),
             active: toolbarContext.isToolVisible(fullToolId),
@@ -181,7 +193,9 @@ export const calculatorToolRegistration = {
                     element: overlay,
                     mount: "after-buttons",
                     shell: {
-                        title: this.name,
+                        // The variant name the button already carries — "Basic Calculator",
+                        // not the registration's generic one.
+                        title: displayName,
                         draggable: true,
                         resizable: true,
                         closeable: true,
@@ -191,6 +205,13 @@ export const calculatorToolRegistration = {
                         minHeight: 420,
                         initialAlign: "bottom-right",
                         initialMargin: 16,
+                        // Header controls in the host's design system, and the layout that
+                        // goes with them.
+                        ndsHeaderControls: true,
+                        // A learner reads the question while using the calculator, so Tab and
+                        // Shift+Tab cross between the page and the shell instead of cycling
+                        // inside it.
+                        pageTabOrder: true,
                         content: {
                             overflowY: "auto",
                             preserveMinHeight: true,
@@ -203,10 +224,12 @@ export const calculatorToolRegistration = {
                 const active = toolbarContext.isToolVisible(fullToolId);
                 button.active = active;
                 button.label = displayName;
-                button.ariaLabel = active ? closeLabel : openLabel;
-                button.tooltip = active
-                    ? `Close ${displayName.toLowerCase()}`
-                    : displayName;
+                // Static across the toggle. The previous `Close ${name.toLowerCase()}`
+                // was a hardcoded English template built by lowercasing a localized
+                // noun — "Close rekenmachine" under nl-NL — and it is the state
+                // `aria-pressed` already carries.
+                button.ariaLabel = displayName;
+                button.tooltip = displayName;
                 if (lastVisibleState !== active) {
                     overlay.visible = active;
                     lastVisibleState = active;

package/dist/registrations/dictionary-tools.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Dictionary Tool Registrations
+ *
+ * Word lookup and picture (symbol) lookup, each a floating panel opened from the
+ * toolbar.
+ *
+ * Neither declares a universal support id. A dictionary is a granted accommodation,
+ * not a universal affordance: on a vocabulary item it is construct-relevant, so
+ * handing it to every learner by default would change what the item measures. A
+ * programme grants it through the PNP like any other accommodation.
+ *
+ * Both panels also accept a `term` from whatever selection affordance a host offers,
+ * but neither depends on one. A sighted keyboard-only learner cannot originate a text
+ * selection in non-editable content — Chromium does not extend one with Shift+Arrow
+ * there without caret browsing, an OS toggle absent on mobile — so a selection-only
+ * dictionary is unreachable for them. The panel's own field is the keyboard route.
+ */
+import type { ToolRegistration } from "@pie-players/pie-assessment-toolkit/tools/internal";
+/**
+ * What distinguishes one dictionary capability from another.
+ *
+ * A dictionary's language belongs to the learner, not to the content: the learner who
+ * needs a Spanish gloss is reading an English passage. So a deployment that offers two
+ * languages at once composes two capabilities, each granted on its own through the PNP,
+ * rather than one capability that follows whatever the section was authored in. That is
+ * also how the delivery systems PIE is measured against ship it — English Dictionary and
+ * Spanish Dictionary as two entries a programme grants separately.
+ *
+ * Catalog keys are derived from `toolId` (`tools.<toolId>.name` and so on), which holds for
+ * every packaged variant. A host composing a variant against its own catalog passes
+ * `messageKeyPrefix`; a key that does not resolve falls back to `name` and `description`,
+ * so a host catalog that lacks one is a plain label rather than a broken button.
+ */
+export interface DictionaryVariantOptions {
+    /** Capability id, unique per language. Defaults to the base tool's id. */
+    toolId?: string;
+    name?: string;
+    description?: string;
+    /** Catalog prefix for this variant's strings. Defaults to `tools.<toolId>`. */
+    messageKeyPrefix?: string;
+    /** PNP ids that grant this variant. A language variant needs its own. */
+    pnpSupportIds?: string[];
+    /**
+     * The corpus language this capability looks words up in, as a BCP-47 tag.
+     *
+     * Sent with every lookup, outranking the toolbar's content-alternate language and
+     * outranked by a language the host names in this tool's render params. Absent on the
+     * base capabilities, which follow the content.
+     */
+    lookupLanguage?: string;
+}
+/**
+ * Dictionary tool registration
+ *
+ * Word lookup from a host-supplied service, in one language. Call this again with another
+ * `toolId`, `pnpSupportIds` and `lookupLanguage` to offer a second language beside it.
+ */
+export declare function createDictionaryToolRegistration(options?: DictionaryVariantOptions): ToolRegistration;
+/** The content-following dictionary every deployment gets. */
+export declare const dictionaryToolRegistration: ToolRegistration;
+/**
+ * Picture Dictionary tool registration
+ *
+ * Symbol or picture lookup from a host-supplied service. Sized wider than the word
+ * dictionary because its results are a grid rather than a column of text.
+ */
+export declare function createPictureDictionaryToolRegistration(options?: DictionaryVariantOptions): ToolRegistration;
+/** The content-following picture dictionary every deployment gets. */
+export declare const pictureDictionaryToolRegistration: ToolRegistration;
+/**
+ * Spanish variants, packaged because a Spanish gloss for English content is a named
+ * accommodation rather than a hypothetical. Neither appears unless a PNP grants it.
+ */
+export declare const spanishDictionaryToolRegistration: ToolRegistration;
+export declare const spanishPictureDictionaryToolRegistration: ToolRegistration;