@pie-players/pie-default-tool-loaders 0.3.74 → 1.0.0-beta.0

package/dist/packaged-capability-composition.js

@@ -2,49 +2,26 @@
  * The one authored description of PIE's packaged capability composition.
  *
  * Registrations describe what a capability can do. This module owns the
- * deployment decisions around them: element tags, lazy module bootstrap sets,
- * placement presets, toolbar order and the explicit universal-support policy.
+ * deployment decisions around them: element tags, lazy module loaders, the
+ * section-player placement preset and the explicit universal-support policy.
  * Public constants are projections of this composition so adding a capability
  * cannot leave a second hand-maintained catalogue silently behind.
  */
-import { ToolRegistry, } from "@pie-players/pie-assessment-toolkit/tools/internal";
+import { ToolRegistry, } from "@pie-players/pie-assessment-toolkit/tools/registration";
 import { annotationToolbarRegistration, lineReaderToolRegistration, themeToolRegistration, } from "./registrations/accessibility-tools.js";
 import { audioTranscriptRegistration } from "./registrations/audio-transcript.js";
-import { calculatorToolRegistration, resolveCalculatorProviderId, } from "./registrations/calculator.js";
+import { calculatorToolRegistration } from "./registrations/calculator.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";
 const loadSideEffectModule = (load) => load().then(() => undefined);
-function loadCalculatorElement(tagName, load) {
-    if (typeof globalThis !== "undefined" &&
-        "customElements" in globalThis &&
-        globalThis.customElements?.get(tagName)) {
-        return Promise.resolve();
-    }
-    return loadSideEffectModule(load);
-}
-const loadDesmosCalculatorModule = () => loadCalculatorElement("pie-tool-calculator", () => import("@pie-players/pie-tool-calculator-shared/calculator-element"));
-const loadGeoGebraCalculatorModule = () => loadCalculatorElement("pie-tool-calculator-geogebra", () => import("@pie-players/pie-tool-calculator-geogebra"));
-const loadCortexCalculatorModule = () => loadCalculatorElement("pie-tool-calculator-cortex", () => import("@pie-players/pie-tool-calculator-cortex"));
-const CALCULATOR_DELIVERY = {
-    "calculator-desmos": {
-        tagName: "pie-tool-calculator",
-        loadModule: loadDesmosCalculatorModule,
-    },
-    "calculator-geogebra": {
-        tagName: "pie-tool-calculator-geogebra",
-        loadModule: loadGeoGebraCalculatorModule,
-    },
-    "calculator-cortex": {
-        tagName: "pie-tool-calculator-cortex",
-        loadModule: loadCortexCalculatorModule,
-    },
-};
-function resolveCalculatorDelivery(config) {
-    return CALCULATOR_DELIVERY[resolveCalculatorProviderId(config)];
-}
+// One element serves every calculator provider; the toolkit picks the provider
+// from `tools.providers.calculator` when the element mounts.
+const loadCalculatorModule = () => globalThis.customElements?.get("pie-tool-calculator")
+    ? Promise.resolve()
+    : loadSideEffectModule(() => import("@pie-players/pie-tool-calculator-shared/calculator-element"));
 const loadTtsModule = () => loadSideEffectModule(() => import("@pie-players/pie-tool-tts-inline"));
 const loadRulerModule = () => loadSideEffectModule(() => import("@pie-players/pie-tool-ruler"));
 const loadProtractorModule = () => loadSideEffectModule(() => import("@pie-players/pie-tool-protractor"));
@@ -59,133 +36,89 @@ const loadPictureDictionaryModule = () => loadSideEffectModule(() => import("@pi
 const PACKAGED_CAPABILITY_DEFINITIONS = [
     {
         registration: calculatorToolRegistration,
-        tagName: CALCULATOR_DELIVERY["calculator-desmos"].tagName,
-        loadModule: CALCULATOR_DELIVERY["calculator-desmos"].loadModule,
-        loaderTargets: ["item", "section"],
-        placementOrder: { element: 10 },
+        tagName: "pie-tool-calculator",
+        loadModule: loadCalculatorModule,
         preferredPlacementOrder: { item: 10 },
-        toolbarOrder: 20,
-        universalSupportIds: ["calculator", "graphingCalculator"],
+        universal: true,
     },
     {
         registration: ttsToolRegistration,
         tagName: "pie-tool-tts-inline",
         loadModule: loadTtsModule,
-        loaderTargets: ["item"],
-        placementOrder: { item: 10, passage: 10, rubric: 10, element: 30 },
         preferredPlacementOrder: { item: 20, passage: 10 },
-        toolbarOrder: 30,
-        universalSupportIds: ["textToSpeech", "readAloud"],
+        universal: true,
     },
     {
         registration: rulerToolRegistration,
         tagName: "pie-tool-ruler",
         loadModule: loadRulerModule,
-        loaderTargets: ["section"],
-        placementOrder: { element: 40 },
         preferredPlacementOrder: { section: 50 },
-        toolbarOrder: 80,
-        universalSupportIds: ["ruler"],
+        universal: true,
     },
     {
         registration: protractorToolRegistration,
         tagName: "pie-tool-protractor",
         loadModule: loadProtractorModule,
-        loaderTargets: ["section"],
-        placementOrder: { element: 50 },
         preferredPlacementOrder: { section: 60 },
-        toolbarOrder: 90,
-        universalSupportIds: ["protractor"],
+        universal: true,
     },
     {
         registration: answerEliminatorToolRegistration,
         tagName: "pie-tool-answer-eliminator",
         loadModule: loadAnswerEliminatorModule,
-        loaderTargets: ["item"],
-        placementOrder: { element: 20 },
         preferredPlacementOrder: { item: 30 },
-        toolbarOrder: 70,
-        universalSupportIds: ["answerMasking", "answerEliminator", "strikethrough"],
+        universal: true,
     },
     {
         registration: lineReaderToolRegistration,
         tagName: "pie-tool-line-reader",
         loadModule: loadLineReaderModule,
-        loaderTargets: ["section"],
-        placementOrder: { passage: 40, rubric: 40 },
         preferredPlacementOrder: { section: 40 },
-        toolbarOrder: 40,
-        universalSupportIds: ["readingMask", "readingGuide", "readingRuler"],
+        universal: true,
     },
     {
         registration: themeToolRegistration,
         tagName: "pie-tool-theme",
         loadModule: loadThemeModule,
-        loaderTargets: ["item"],
-        placementOrder: { assessment: 10, section: 10 },
         preferredPlacementOrder: { section: 10 },
-        toolbarOrder: 10,
-        universalSupportIds: [
-            "highContrastDisplay",
-            "colorContrast",
-            "invertColors",
-            "theme",
-        ],
+        universal: true,
     },
     {
         registration: annotationToolbarRegistration,
         tagName: "pie-tool-annotation-toolbar",
         loadModule: loadAnnotationToolbarModule,
-        loaderTargets: ["item"],
-        placementOrder: { item: 30, passage: 30, rubric: 30, element: 70 },
         preferredPlacementOrder: { item: 40, passage: 20 },
-        toolbarOrder: 50,
-        // 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"],
+        universal: true,
     },
     {
         registration: graphToolRegistration,
         tagName: "pie-tool-graph",
         loadModule: loadGraphModule,
-        loaderTargets: ["section"],
-        placementOrder: { item: 40, element: 80 },
         preferredPlacementOrder: { section: 20 },
-        toolbarOrder: 100,
-        universalSupportIds: ["graph"],
+        universal: true,
     },
     {
         registration: periodicTableToolRegistration,
         tagName: "pie-tool-periodic-table",
         loadModule: loadPeriodicTableModule,
-        loaderTargets: ["section"],
-        placementOrder: { item: 50, element: 90 },
         preferredPlacementOrder: { section: 30 },
-        toolbarOrder: 110,
-        universalSupportIds: ["periodicTable"],
+        universal: true,
     },
     {
         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: [],
+        // A dictionary is a granted accommodation, and on a vocabulary item it is
+        // construct-relevant, so it is never universal.
+        universal: false,
     },
     {
         registration: pictureDictionaryToolRegistration,
         tagName: "pie-tool-picture-dictionary",
         loadModule: loadPictureDictionaryModule,
-        loaderTargets: ["section"],
-        placementOrder: { item: 70, element: 110 },
         preferredPlacementOrder: { section: 80 },
-        toolbarOrder: 130,
-        universalSupportIds: [],
+        universal: false,
     },
     // 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
@@ -194,35 +127,21 @@ const PACKAGED_CAPABILITY_DEFINITIONS = [
         registration: spanishDictionaryToolRegistration,
         tagName: "pie-tool-dictionary",
         loadModule: loadDictionaryModule,
-        loaderTargets: ["section"],
-        placementOrder: { item: 80, element: 120 },
         preferredPlacementOrder: { section: 90 },
-        toolbarOrder: 140,
-        universalSupportIds: [],
+        universal: false,
     },
     {
         registration: spanishPictureDictionaryToolRegistration,
         tagName: "pie-tool-picture-dictionary",
         loadModule: loadPictureDictionaryModule,
-        loaderTargets: ["section"],
-        placementOrder: { item: 90, element: 130 },
         preferredPlacementOrder: { section: 100 },
-        toolbarOrder: 150,
-        universalSupportIds: [],
+        universal: false,
     },
     {
         registration: audioTranscriptRegistration,
-        universalSupportIds: [],
+        universal: false,
     },
 ];
-const PACKAGED_PLACEMENT_LEVELS = [
-    "assessment",
-    "section",
-    "item",
-    "passage",
-    "rubric",
-    "element",
-];
 const PREFERRED_PLACEMENT_LEVELS = ["section", "item", "passage"];
 function assertUniqueWeights(definitions, levels, read, field) {
     for (const level of levels) {
@@ -243,8 +162,6 @@ function assertUniqueWeights(definitions, levels, read, field) {
 }
 function assertComposition(definitions) {
     const toolIds = new Set();
-    const universalSupportIds = new Set();
-    const toolbarOrders = new Set();
     for (const definition of definitions) {
         const { registration } = definition;
         if (!registration.toolId.trim()) {
@@ -258,9 +175,6 @@ function assertComposition(definitions) {
         if (isRegion) {
             if (definition.tagName !== undefined ||
                 definition.loadModule !== undefined ||
-                definition.loaderTargets !== undefined ||
-                definition.toolbarOrder !== undefined ||
-                Object.keys(definition.placementOrder ?? {}).length > 0 ||
                 Object.keys(definition.preferredPlacementOrder ?? {}).length > 0) {
                 throw new Error(`Invalid packaged capability "${registration.toolId}": a region capability is surface-hosted and cannot declare element delivery or toolbar placement.`);
             }
@@ -269,44 +183,12 @@ function assertComposition(definitions) {
             if (!definition.tagName?.includes("-")) {
                 throw new Error(`Invalid packaged capability "${registration.toolId}": element-backed capabilities need a custom-element tag.`);
             }
-            if (typeof definition.loadModule !== "function" ||
-                !definition.loaderTargets?.length) {
-                throw new Error(`Invalid packaged capability "${registration.toolId}": element-backed capabilities need a lazy loader and at least one bootstrap target.`);
-            }
-            if (new Set(definition.loaderTargets).size !==
-                definition.loaderTargets.length) {
-                throw new Error(`Invalid packaged capability "${registration.toolId}": loader bootstrap targets must be unique.`);
+            if (typeof definition.loadModule !== "function") {
+                throw new Error(`Invalid packaged capability "${registration.toolId}": element-backed capabilities need a lazy loader.`);
             }
-            if (definition.toolbarOrder === undefined) {
-                throw new Error(`Invalid packaged capability "${registration.toolId}": toolbar capabilities need an order.`);
-            }
-        }
-        if (definition.toolbarOrder !== undefined) {
-            if (!Number.isSafeInteger(definition.toolbarOrder) ||
-                definition.toolbarOrder < 0) {
-                throw new Error(`Invalid packaged capability "${registration.toolId}": toolbar order must be a non-negative integer.`);
-            }
-            if (toolbarOrders.has(definition.toolbarOrder)) {
-                throw new Error(`Invalid packaged capability composition: duplicate toolbar order ${definition.toolbarOrder}.`);
-            }
-            toolbarOrders.add(definition.toolbarOrder);
         }
-        const registrationSupportIds = new Set(registration.pnpSupportIds ?? [registration.toolId]);
-        if (registration.requiresAuthoredContent &&
-            definition.universalSupportIds.length > 0) {
-            throw new Error(`Invalid packaged capability "${registration.toolId}": content-dependent support ids cannot be universally granted.`);
-        }
-        for (const supportId of definition.universalSupportIds) {
-            if (!supportId.trim()) {
-                throw new Error(`Invalid packaged capability "${registration.toolId}": universal support ids must be non-empty.`);
-            }
-            if (!registrationSupportIds.has(supportId)) {
-                throw new Error(`Invalid packaged capability "${registration.toolId}": universal support id "${supportId}" is not declared by its registration.`);
-            }
-            if (universalSupportIds.has(supportId)) {
-                throw new Error(`Invalid packaged capability composition: universal support id "${supportId}" has more than one owner.`);
-            }
-            universalSupportIds.add(supportId);
+        if (registration.requiresAuthoredContent && definition.universal) {
+            throw new Error(`Invalid packaged capability "${registration.toolId}": a content-dependent capability cannot be universally granted.`);
         }
         for (const level of PREFERRED_PLACEMENT_LEVELS) {
             if (definition.preferredPlacementOrder?.[level] !== undefined &&
@@ -315,7 +197,6 @@ function assertComposition(definitions) {
             }
         }
     }
-    assertUniqueWeights(definitions, PACKAGED_PLACEMENT_LEVELS, (definition) => definition.placementOrder, "placementOrder");
     assertUniqueWeights(definitions, PREFERRED_PLACEMENT_LEVELS, (definition) => definition.preferredPlacementOrder, "preferredPlacementOrder");
 }
 function orderedToolIds(definitions, level, read) {
@@ -331,12 +212,8 @@ class PackagedCapabilityComposition {
     definitions;
     registrations;
     toolTagMap;
-    itemModuleLoaders;
-    sectionModuleLoaders;
-    defaultModuleLoaders;
-    placement;
+    moduleLoaders;
     preferredPlacement;
-    toolbarOrder;
     universalSupportIds;
     constructor(definitions) {
         this.definitions = definitions;
@@ -344,34 +221,20 @@ class PackagedCapabilityComposition {
         this.toolTagMap = Object.freeze(Object.fromEntries(definitions.flatMap((definition) => definition.tagName
             ? [[definition.registration.toolId, definition.tagName]]
             : [])));
-        this.itemModuleLoaders = this.projectModuleLoaders("item");
-        this.sectionModuleLoaders = this.projectModuleLoaders("section");
-        this.defaultModuleLoaders = Object.freeze({
-            ...this.itemModuleLoaders,
-            ...this.sectionModuleLoaders,
+        this.moduleLoaders = Object.freeze(Object.fromEntries(definitions.flatMap((definition) => definition.loadModule
+            ? [[definition.registration.toolId, definition.loadModule]]
+            : [])));
+        const preferredIds = (level) => Object.freeze(orderedToolIds(definitions, level, ({ preferredPlacementOrder }) => preferredPlacementOrder));
+        this.preferredPlacement = Object.freeze({
+            section: preferredIds("section"),
+            item: preferredIds("item"),
+            passage: preferredIds("passage"),
         });
-        this.placement = Object.freeze(Object.fromEntries(PACKAGED_PLACEMENT_LEVELS.map((level) => [
-            level,
-            Object.freeze(orderedToolIds(definitions, level, (definition) => definition.placementOrder)),
-        ])));
-        this.preferredPlacement = Object.freeze(Object.fromEntries(PREFERRED_PLACEMENT_LEVELS.map((level) => [
-            level,
-            Object.freeze(orderedToolIds(definitions, level, (definition) => definition.preferredPlacementOrder)),
-        ])));
-        this.toolbarOrder = Object.freeze(definitions
-            .filter((definition) => definition.toolbarOrder !== undefined)
-            .slice()
-            .sort((left, right) => left.toolbarOrder - right.toolbarOrder)
-            .map(({ registration }) => registration.toolId));
         this.universalSupportIds = Object.freeze(definitions
-            .flatMap(({ universalSupportIds }) => [...universalSupportIds])
+            .filter((definition) => definition.universal)
+            .map(({ registration }) => registration.toolId)
             .sort());
     }
-    projectModuleLoaders(target) {
-        return Object.freeze(Object.fromEntries(this.definitions.flatMap((definition) => definition.loadModule && definition.loaderTargets?.includes(target)
-            ? [[definition.registration.toolId, definition.loadModule]]
-            : [])));
-    }
     selectRegistrations(toolIds) {
         // Preserve the established fail-soft host behavior: no selection means all,
         // and unknown ids are ignored rather than preventing known tools from loading.
@@ -380,46 +243,19 @@ class PackagedCapabilityComposition {
         const selected = new Set(toolIds);
         return this.registrations.filter(({ toolId }) => selected.has(toolId));
     }
-    registerTools(registry, options = {}) {
-        const applyOverrides = options.applyOverrides ??
-            ((registration) => registration);
-        for (const registration of this.selectRegistrations(options.toolIds)) {
-            registry.register(applyOverrides(registration));
-        }
-    }
     createRegistry(options = {}) {
         const registry = new ToolRegistry();
-        this.registerTools(registry, {
-            toolIds: options.toolIds,
-            applyOverrides: (registration) => options.overrides?.[registration.toolId] ?? registration,
-        });
-        // Loader installation remains opt-in. Some hosts preload tool elements or
-        // provide their own tags; silently adding package loads here would change
-        // their bundle/runtime behavior.
-        if (options.toolModuleLoaders &&
-            Object.keys(options.toolModuleLoaders).length > 0) {
-            const toolModuleLoaders = { ...options.toolModuleLoaders };
-            const calculatorDelivery = resolveCalculatorDelivery(options.calculatorProviderConfig);
-            // A host using the packaged default map gets a coherent provider-specific
-            // loader. A genuinely custom calculator loader remains the host's override.
-            if (options.calculatorProviderConfig &&
-                toolModuleLoaders.calculator === this.defaultModuleLoaders.calculator) {
-                toolModuleLoaders.calculator = calculatorDelivery.loadModule;
-            }
-            registry.setToolModuleLoaders(toolModuleLoaders);
+        for (const registration of this.selectRegistrations(options.toolIds)) {
+            registry.register(options.overrides?.[registration.toolId] ?? registration);
         }
-        const calculatorTagMap = options.calculatorProviderConfig
-            ? {
-                calculator: resolveCalculatorDelivery(options.calculatorProviderConfig).tagName,
-            }
-            : {};
+        registry.setToolModuleLoaders({
+            ...(options.toolModuleLoaders ?? this.moduleLoaders),
+        });
         registry.setComponentOverrides({
             toolTagMap: {
                 ...this.toolTagMap,
-                ...calculatorTagMap,
                 ...(options.toolTagMap ?? {}),
             },
-            toolComponentFactory: options.toolComponentFactory,
             toolComponentFactories: options.toolComponentFactories,
         });
         return registry;
@@ -428,7 +264,6 @@ class PackagedCapabilityComposition {
         return {
             supports: [...this.universalSupportIds],
             prohibitedSupports: [],
-            activateAtInit: [],
         };
     }
 }
@@ -450,71 +285,31 @@ export const PACKAGED_TOOL_REGISTRATIONS = [
 export const PACKAGED_TOOL_TAG_MAP = {
     ...packagedCapabilityComposition.toolTagMap,
 };
-export const ITEM_TOOL_MODULE_LOADERS = {
-    ...packagedCapabilityComposition.itemModuleLoaders,
-};
-export const SECTION_TOOL_MODULE_LOADERS = {
-    ...packagedCapabilityComposition.sectionModuleLoaders,
-};
 export const DEFAULT_TOOL_MODULE_LOADERS = {
-    ...packagedCapabilityComposition.defaultModuleLoaders,
-};
-/** Build the packaged loader map for a selected calculator provider. */
-export function createDefaultToolModuleLoaders(options = {}) {
-    return {
-        ...DEFAULT_TOOL_MODULE_LOADERS,
-        calculator: resolveCalculatorDelivery(options.calculatorProviderConfig)
-            .loadModule,
-    };
-}
-/** Build the section-bootstrap loader subset for a selected calculator provider. */
-export function createSectionToolModuleLoaders(options = {}) {
-    return {
-        ...SECTION_TOOL_MODULE_LOADERS,
-        calculator: resolveCalculatorDelivery(options.calculatorProviderConfig)
-            .loadModule,
-    };
-}
-export const PACKAGED_TOOL_PLACEMENT = {
-    assessment: [...packagedCapabilityComposition.placement.assessment],
-    section: [...packagedCapabilityComposition.placement.section],
-    item: [...packagedCapabilityComposition.placement.item],
-    passage: [...packagedCapabilityComposition.placement.passage],
-    rubric: [...packagedCapabilityComposition.placement.rubric],
-    element: [...packagedCapabilityComposition.placement.element],
+    ...packagedCapabilityComposition.moduleLoaders,
 };
 export const SECTION_PLAYER_PREFERRED_TOOL_PLACEMENT = {
     section: [...packagedCapabilityComposition.preferredPlacement.section],
     item: [...packagedCapabilityComposition.preferredPlacement.item],
     passage: [...packagedCapabilityComposition.preferredPlacement.passage],
 };
-export const PACKAGED_TOOL_ORDER = [
-    ...packagedCapabilityComposition.toolbarOrder,
-];
-export const UNIVERSAL_SUPPORTS_PRESET = packagedCapabilityComposition.universalSupportIds;
-/** Register packaged PIE capabilities onto an existing registry. */
-export function registerPackagedTools(registry, options = {}) {
-    packagedCapabilityComposition.registerTools(registry, options);
-}
 /** Create a registry holding the packaged PIE capabilities. */
 export function createPackagedToolRegistry(options = {}) {
     return packagedCapabilityComposition.createRegistry(options);
 }
-/** Build a fresh profile granting the explicit universal-support preset. */
+/**
+ * A fresh profile granting the packaged set's universal capabilities, sorted by
+ * tool id. Which capabilities are universal is program policy declared on each
+ * definition; registry membership never implies it.
+ */
 export function createUniversalPersonalNeedsProfile() {
     return packagedCapabilityComposition.createUniversalPersonalNeedsProfile();
 }
-/** Register packaged lazy module loaders, followed by host overrides. */
-export function registerDefaultToolModuleLoaders(registry, options = {}) {
-    registry.setToolModuleLoaders({
-        ...createDefaultToolModuleLoaders(options),
-        ...(options.loaders ?? {}),
-    });
-}
-/** Register only the section-bootstrap loader subset, then host overrides. */
-export function registerSectionToolModuleLoaders(registry, options = {}) {
-    registry.setToolModuleLoaders({
-        ...createSectionToolModuleLoaders(options),
-        ...(options.loaders ?? {}),
-    });
+/**
+ * A fresh profile granting and prohibiting nothing. The toolkit ships no
+ * populated default: a deployment's universal set is program policy, which
+ * `createUniversalPersonalNeedsProfile` carries as data for hosts that adopt it.
+ */
+export function createEmptyPersonalNeedsProfile() {
+    return { supports: [], prohibitedSupports: [] };
 }

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

@@ -5,12 +5,8 @@
  * - Line Reader (reading guide)
  * - Color Scheme (theme/contrast)
  * - Annotation Toolbar (text highlighting)
- *
- * Maps to QTI 3.0 standard access features from:
- * - visual category: highContrastDisplay, colorContrast
- * - reading category: readingMask, readingGuide, highlighting
  */
-import type { ToolRegistration } from "@pie-players/pie-assessment-toolkit/tools/internal";
+import type { ToolRegistration } from "@pie-players/pie-assessment-toolkit/tools/registration";
 /**
  * Line Reader tool registration
  *

package/dist/registrations/accessibility-tools.js

@@ -5,13 +5,9 @@
  * - Line Reader (reading guide)
  * - Color Scheme (theme/contrast)
  * - Annotation Toolbar (text highlighting)
- *
- * Maps to QTI 3.0 standard access features from:
- * - visual category: highContrastDisplay, colorContrast
- * - reading category: readingMask, readingGuide, highlighting
  */
-import { hasReadableText } from "@pie-players/pie-assessment-toolkit/tools/internal";
-import { resolveToolTag, } from "@pie-players/pie-assessment-toolkit/tools/internal";
+import { hasReadableText } from "@pie-players/pie-assessment-toolkit/tools/registration";
+import { resolveToolTag, } from "@pie-players/pie-assessment-toolkit/tools/registration";
 import { buildSelectionActions } from "./selection-actions.js";
 import { renderOverlayToolbar } from "./overlay-toolbar-render.js";
 /**
@@ -27,15 +23,7 @@ export const lineReaderToolRegistration = {
     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"],
-    // PNP support IDs
-    // Maps to QTI 3.0 standard features: readingMask, readingGuide, readingRuler
-    pnpSupportIds: [
-        "readingMask", // QTI 3.0 standard (reading.readingMask)
-        "readingGuide", // QTI 3.0 standard (reading.readingGuide)
-        "readingRuler", // QTI 3.0 standard (reading.readingRuler)
-    ],
     /**
      * Pass 2: Line reader is relevant when readable text is present
      */
@@ -45,7 +33,6 @@ export const lineReaderToolRegistration = {
     renderToolbar(context, toolbarContext) {
         return renderOverlayToolbar(this, context, toolbarContext, {
             surface: "frameless",
-            handsOverCoordinator: true,
         });
     },
 };
@@ -64,19 +51,11 @@ export const themeToolRegistration = {
     icon: "swatch",
     // Color scheme is assessment-wide
     supportedLevels: ["assessment", "section"],
-    // PNP support IDs
-    // Maps to QTI 3.0 standard features: highContrastDisplay, colorContrast, invertColors
-    pnpSupportIds: [
-        "highContrastDisplay", // QTI 3.0 standard (visual.highContrastDisplay)
-        "colorContrast", // QTI 3.0 standard (visual.colorContrast)
-        "invertColors", // QTI 3.0 standard (visual.invertColors)
-        "theme", // Canonical id, and this registration's toolId
-    ],
     /**
      * Pass 2: Color scheme is always relevant when allowed
      */
     isVisibleInContext(context) {
-        return true; // Always show if allowed by orchestrator
+        return true;
     },
     renderToolbar(context, toolbarContext) {
         return renderOverlayToolbar(this, context, toolbarContext, {
@@ -87,7 +66,6 @@ export const themeToolRegistration = {
                 minWidth: 420,
                 minHeight: 300,
             },
-            handsOverCoordinator: true,
         });
     },
 };
@@ -107,22 +85,13 @@ export const annotationToolbarRegistration = {
     activation: "selection-gateway",
     singletonScope: "section",
     /**
-     * Section-scoped singleton surface. The gateway used to be mounted by
-     * `PieSectionPlayerBaseElement.svelte`, which named this tool id in three
-     * places — the policy check, the module load and the element — so no host
-     * could contribute a second section-scoped capability. Declaring the surface
-     * moves that wiring into this registration, and the renderer discovers it
-     * through `ToolRegistry.getToolsBySurface("section-overlay")`.
+     * Section-scoped singleton surface. The renderer discovers it through
+     * `ToolRegistry.getToolsBySurface("section-overlay")`, so the section player
+     * names no tool id and a host can contribute another section-scoped
+     * capability.
      */
     surfaces: ["section-overlay"],
-    // Annotation appears where there's text content
     supportedLevels: ["passage", "rubric", "item", "element"],
-    // PNP support IDs
-    // Maps to QTI 3.0 standard features: highlighting, annotations
-    pnpSupportIds: [
-        "highlighting", // QTI 3.0 standard (cognitive.highlighting / reading.wordHighlighting)
-        "annotations", // QTI 3.0 standard (cognitive.annotations)
-    ],
     /**
      * Pass 2: Annotation is relevant when readable text is present
      */
@@ -145,16 +114,11 @@ export const annotationToolbarRegistration = {
             return null;
         }
         const element = document.createElement(tagName);
-        // Reads the context it is handed. These were reactive props before the
-        // gateway moved behind `renderSurface`, and a host calling
-        // `updateAssessment(...)` mid-session swaps the coordinator without
-        // remounting — closing over the render-time services would leave the gateway
-        // highlighting into the previous session's coordinator.
+        // The gateway reads its services from the toolkit runtime context. What it
+        // takes from here is the action list, rebuilt from the current services on
+        // every sync so a mid-session `updateAssessment(...)` reaches it.
         const applyServices = (current) => {
             element.enabled = true;
-            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.
@@ -164,8 +128,6 @@ export const annotationToolbarRegistration = {
         return { element, sync: applyServices };
     },
     renderToolbar(context, toolbarContext) {
-        return renderOverlayToolbar(this, context, toolbarContext, {
-            handsOverCoordinator: true,
-        });
+        return renderOverlayToolbar(this, context, toolbarContext);
     },
 };