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

package/dist/registrations/audio-transcript.d.ts

@@ -5,13 +5,13 @@
  * Two kinds of content wear the same shape, and the card says which:
  *
  *   - `visibility: "always"` is authored presentation. The item family was
- *     designed to be delivered with its transcript on screen — Star Early
- *     Literacy sentence items, for instance — so no profile grants it and none
- *     revokes it.
+ *     designed to be delivered with its transcript on screen — sentence items in
+ *     an early-literacy assessment, for instance — so no profile grants it and
+ *     none revokes it.
  *   - anything else, `"onGrant"` included, is the accommodation. Policy decides
- *     against the `transcript` support id, and silence means no. For the three
- *     Star families where a visible transcript turns the item into a reading
- *     task, that gate is the whole point.
+ *     against the `transcript` support id, and silence means no. For item
+ *     families where a visible transcript turns the item into a reading task,
+ *     that gate is the whole point.
  *
  * The toolkit renders the text, not the element. Before this, the transcript rode
  * on `model.audioTranscript` and `mc-populated-blank` revealed its own copy when
@@ -35,7 +35,7 @@
  * absent from the universal preset — a content-dependent support never belongs in
  * a wholesale grant.
  */
-import type { ToolContentDependencyContext, ToolRegistration } from "@pie-players/pie-assessment-toolkit/tools/internal";
+import type { ToolContentDependencyContext, ToolRegistration } from "@pie-players/pie-assessment-toolkit/tools/registration";
 /** QTI 3.0 / AfA support id gating an audio transcript. */
 export declare const AUDIO_TRANSCRIPT_FEATURE_ID = "transcript";
 /** Catalog type carrying the transcript text. */
@@ -47,6 +47,7 @@ export declare const AUDIO_TRANSCRIPT_REGION_CLASS = "pie-tool-audio-transcript"
 export interface ResolvedAudioTranscript {
     catalogId: string;
     text: string;
+    /** BCP 47, as the region's `lang` takes it, whatever syntax the card used. */
     language?: string;
     /** True when the card declares itself authored presentation. */
     always: boolean;

package/dist/registrations/audio-transcript.js

@@ -5,13 +5,13 @@
  * Two kinds of content wear the same shape, and the card says which:
  *
  *   - `visibility: "always"` is authored presentation. The item family was
- *     designed to be delivered with its transcript on screen — Star Early
- *     Literacy sentence items, for instance — so no profile grants it and none
- *     revokes it.
+ *     designed to be delivered with its transcript on screen — sentence items in
+ *     an early-literacy assessment, for instance — so no profile grants it and
+ *     none revokes it.
  *   - anything else, `"onGrant"` included, is the accommodation. Policy decides
- *     against the `transcript` support id, and silence means no. For the three
- *     Star families where a visible transcript turns the item into a reading
- *     task, that gate is the whole point.
+ *     against the `transcript` support id, and silence means no. For item
+ *     families where a visible transcript turns the item into a reading task,
+ *     that gate is the whole point.
  *
  * The toolkit renders the text, not the element. Before this, the transcript rode
  * on `model.audioTranscript` and `mc-populated-blank` revealed its own copy when
@@ -35,6 +35,7 @@
  * absent from the universal preset — a content-dependent support never belongs in
  * a wholesale grant.
  */
+import { toLanguageTag } from "@pie-players/pie-players-shared/i18n/language-tags";
 /** QTI 3.0 / AfA support id gating an audio transcript. */
 export const AUDIO_TRANSCRIPT_FEATURE_ID = "transcript";
 /** Catalog type carrying the transcript text. */
@@ -55,6 +56,10 @@ const isTranscriptCard = (card) => !!card && card.catalog === AUDIO_TRANSCRIPT_C
 const isAlwaysVisible = (card) => typeof card.visibility === "string" &&
     card.visibility.trim().toLowerCase() === ALWAYS_VISIBLE;
 const cardText = (card) => typeof card.content === "string" ? card.content.trim() : "";
+// The Learnosity transform emits POSIX `es_ES`, which `lang` does not accept.
+const cardLanguage = (card) => typeof card.language === "string"
+    ? toLanguageTag(card.language) || undefined
+    : undefined;
 /**
  * The transcript an entity carries, or `null`.
  *
@@ -83,7 +88,7 @@ export function resolveAudioTranscript(context) {
         const resolved = {
             catalogId,
             text,
-            language: typeof card.language === "string" ? card.language : undefined,
+            language: cardLanguage(card),
             always: isAlwaysVisible(card),
         };
         // An `always` card answers whether or not policy granted anything, so it
@@ -147,7 +152,6 @@ export const audioTranscriptRegistration = {
     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
     // present, or absent. `region` is the activation for a capability with no
     // toolbar presence, and tools-config validation reports a `tools.placement`

package/dist/registrations/calculator.d.ts

@@ -3,13 +3,9 @@
  *
  * Registers the calculator tool with support for multiple calculator types
  * (basic, scientific, graphing) through a host-selected provider.
- *
- * Maps to QTI 3.0 standard access features:
- * - calculator (cognitive support)
- * - graphingCalculator (assessment tool)
  */
-import type { ToolRegistration } from "@pie-players/pie-assessment-toolkit/tools/internal";
-import type { ToolProviderConfig } from "@pie-players/pie-assessment-toolkit/tools/internal";
+import type { ToolRegistration } from "@pie-players/pie-assessment-toolkit/tools/registration";
+import type { ToolProviderConfig } from "@pie-players/pie-assessment-toolkit/tools/registration";
 export type CalculatorProviderId = "calculator-desmos" | "calculator-geogebra" | "calculator-cortex";
 export declare const DEFAULT_CALCULATOR_PROVIDER_ID: CalculatorProviderId;
 export declare function resolveCalculatorProviderId(config: ToolProviderConfig | undefined): CalculatorProviderId;

package/dist/registrations/calculator.js

@@ -3,14 +3,10 @@
  *
  * Registers the calculator tool with support for multiple calculator types
  * (basic, scientific, graphing) through a host-selected provider.
- *
- * Maps to QTI 3.0 standard access features:
- * - calculator (cognitive support)
- * - graphingCalculator (assessment tool)
  */
-import { hasMathContent } from "@pie-players/pie-assessment-toolkit/tools/internal";
-import { createScopedToolId } from "@pie-players/pie-assessment-toolkit/tools/internal";
-import { createToolElement } from "@pie-players/pie-assessment-toolkit/tools/internal";
+import { hasMathContent } from "@pie-players/pie-assessment-toolkit/tools/registration";
+import { createScopedToolId } from "@pie-players/pie-assessment-toolkit/tools/registration";
+import { createToolElement } from "@pie-players/pie-assessment-toolkit/tools/registration";
 import { CortexToolProvider } from "../calculator-providers/CortexToolProvider.js";
 import { DesmosToolProvider } from "../calculator-providers/DesmosToolProvider.js";
 import { GeoGebraToolProvider } from "../calculator-providers/GeoGebraToolProvider.js";
@@ -58,7 +54,10 @@ function normalizeCalculatorType(value) {
 }
 function getCalculatorRenderParams(toolbarContext) {
     const params = toolbarContext.getToolRenderParams?.("calculator") ?? {};
-    const calculatorType = normalizeCalculatorType(params.calculatorType);
+    // A host resolver or a request names the type; the policy parameters'
+    // `type` is the default beneath both.
+    const calculatorType = normalizeCalculatorType(params.calculatorType) ??
+        normalizeCalculatorType(toolbarContext.getToolParameters?.("calculator")?.type);
     const availableTypesRaw = params.availableTypes;
     const availableTypes = Array.isArray(availableTypesRaw)
         ? availableTypesRaw
@@ -86,11 +85,9 @@ const CALCULATOR_NAME_KEYS = {
     graphing: "tools.calculator.nameGraphing",
     untyped: "tools.calculator.name",
 };
-function applyCalculatorParamsToElement(element, calculatorType, availableTypes, providerId, calculatorConfig) {
+function applyCalculatorParamsToElement(element, calculatorType, availableTypes, calculatorConfig) {
     const calculatorElement = element;
-    calculatorElement.providerId = providerId;
     calculatorElement.calculatorConfig = calculatorConfig;
-    element.setAttribute("provider-id", providerId);
     if (calculatorType) {
         calculatorElement.calculatorType = calculatorType;
         element.setAttribute("calculator-type", calculatorType);
@@ -122,7 +119,6 @@ export const calculatorToolRegistration = {
     descriptionKey: "tools.calculator.description",
     icon: "calculator",
     provider: {
-        getProviderId: resolveCalculatorProviderId,
         createProvider: createCalculatorToolProvider,
         getInitConfig: (config) => config?.provider?.init ?? {},
         getAuthFetcher: (config) => {
@@ -135,16 +131,6 @@ export const calculatorToolRegistration = {
     },
     // Calculator is item-level in this player architecture.
     supportedLevels: ["item"],
-    // PNP support IDs that enable this tool
-    // Maps to QTI 3.0 standard features: calculator, graphingCalculator
-    // A type is not a feature id: `calculatorType` arrives through the host's
-    // render params, so `basicCalculator` / `scientificCalculator` granted the
-    // same untyped calculator these two do and only looked like they selected a
-    // variant.
-    pnpSupportIds: [
-        "calculator", // QTI 3.0 standard (cognitive.calculator)
-        "graphingCalculator", // QTI 3.0 standard (assessment.graphingCalculator)
-    ],
     /**
      * Pass 2: Determine if calculator is relevant in this context
      *
@@ -152,14 +138,12 @@ export const calculatorToolRegistration = {
      * (MathML, LaTeX, arithmetic markers).
      */
     isVisibleInContext(context) {
-        // Show only when math is present in item content.
         return hasMathContent(context);
     },
     renderToolbar(context, toolbarContext) {
         const { calculatorType, availableTypes, displayName } = getCalculatorRenderParams(toolbarContext);
         const calculatorToolConfig = toolbarContext.toolkitCoordinator?.getToolConfig(this.toolId) ||
             undefined;
-        const providerId = resolveCalculatorProviderId(calculatorToolConfig);
         const calculatorConfig = getCalculatorInstanceConfig(calculatorToolConfig);
         const fullToolId = createScopedToolId(this.toolId, toolbarContext.scope.level, toolbarContext.scope.scopeId);
         const componentOverrides = toolbarContext.componentOverrides;
@@ -167,16 +151,14 @@ export const calculatorToolRegistration = {
         // and container mount on every re-render.
         const overlay = resolveOverlayElement(toolbarContext, fullToolId, () => createToolElement(this.toolId, context, toolbarContext, componentOverrides));
         overlay.setAttribute("tool-id", fullToolId);
-        overlay.toolkitCoordinator = toolbarContext.toolkitCoordinator;
-        applyCalculatorParamsToElement(overlay, calculatorType, availableTypes, providerId, calculatorConfig);
+        applyCalculatorParamsToElement(overlay, calculatorType, availableTypes, calculatorConfig);
         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.
+            // design system is a composition decision.
             faIconName: "calculator",
             disabled: false,
             // The name stays put across open and closed. The toolbar mirrors
@@ -185,7 +167,7 @@ export const calculatorToolRegistration = {
             ariaLabel: displayName,
             tooltip: displayName,
             onClick: () => toolbarContext.toggleTool(this.toolId),
-            active: toolbarContext.isToolVisible(fullToolId),
+            active: toolbarContext.isToolVisible(this.toolId),
         };
         let lastVisibleState = button.active;
         if (overlay.visible !== button.active) {
@@ -264,29 +246,25 @@ export const calculatorToolRegistration = {
             ],
             button,
             sync: () => {
-                const active = toolbarContext.isToolVisible(fullToolId);
+                const active = toolbarContext.isToolVisible(this.toolId);
                 button.active = active;
                 button.label = 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.
+                // Static across the toggle: `aria-pressed` carries the state, and a
+                // "Close …" template built from a localized noun mixes languages
+                // ("Close rekenmachine" under nl-NL).
                 button.ariaLabel = displayName;
                 button.tooltip = displayName;
                 if (lastVisibleState !== active) {
                     overlay.visible = active;
                     lastVisibleState = active;
                 }
-                if (overlay.toolkitCoordinator !== toolbarContext.toolkitCoordinator) {
-                    overlay.toolkitCoordinator = toolbarContext.toolkitCoordinator;
-                }
-                applyCalculatorParamsToElement(overlay, calculatorType, availableTypes, providerId, calculatorConfig);
+                applyCalculatorParamsToElement(overlay, calculatorType, availableTypes, calculatorConfig);
             },
             subscribeActive: (callback) => {
                 if (!toolbarContext.subscribeVisibility)
                     return () => { };
                 return toolbarContext.subscribeVisibility(() => {
-                    callback(toolbarContext.isToolVisible(fullToolId));
+                    callback(toolbarContext.isToolVisible(this.toolId));
                 });
             },
         };

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

@@ -15,7 +15,7 @@
  * 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";
+import type { ToolRegistration } from "@pie-players/pie-assessment-toolkit/tools/registration";
 /**
  * What distinguishes one dictionary capability from another.
  *
@@ -32,14 +32,15 @@ import type { ToolRegistration } from "@pie-players/pie-assessment-toolkit/tools
  * 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. */
+    /**
+     * Capability id, unique per language, and the PNP support id that grants it.
+     * 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.
      *
@@ -53,7 +54,7 @@ export interface DictionaryVariantOptions {
  * 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.
+ * `toolId` and `lookupLanguage` to offer a second language beside it.
  */
 export declare function createDictionaryToolRegistration(options?: DictionaryVariantOptions): ToolRegistration;
 /** The content-following dictionary every deployment gets. */

package/dist/registrations/dictionary-tools.js

@@ -15,8 +15,14 @@
  * 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 { createScopedVisibilityBinding, createToolElement, hasReadableText, syncButtonAndOverlayVisibility, } from "@pie-players/pie-assessment-toolkit/tools/internal";
+import { createScopedVisibilityBinding, createToolElement, hasReadableText, syncButtonAndOverlayVisibility, } from "@pie-players/pie-assessment-toolkit/tools/registration";
 import { resolveOverlayElement } from "./overlay-element-cache.js";
+/**
+ * The lookup fields each panel last took from render params. The panel outlives
+ * renders, so a field the host stops supplying is cleared here; a field it never
+ * supplied, such as one a component factory set, is left alone.
+ */
+const appliedLookupFields = new WeakMap();
 /**
  * Apply the host's per-tool render params to the panel.
  *
@@ -34,14 +40,23 @@ function applyLookupParams(element, toolId, toolbarContext,
 /** A language variant's own corpus language; see {@link DictionaryVariantOptions}. */
 lookupLanguage) {
     const params = toolbarContext.getToolRenderParams?.(toolId) ?? {};
+    const supplied = {};
     if (typeof params.endpoint === "string")
-        element.endpoint = params.endpoint;
+        supplied.endpoint = params.endpoint;
     if (typeof params.lookup === "function")
-        element.lookup = params.lookup;
+        supplied.lookup = params.lookup;
     if (typeof params.headers === "function")
-        element.headers = params.headers;
+        supplied.headers = params.headers;
     if (typeof params.credentials === "string")
-        element.credentials = params.credentials;
+        supplied.credentials = params.credentials;
+    // A dropped `lookup` left in place would keep outranking the endpoint that
+    // replaced it.
+    for (const field of appliedLookupFields.get(element) ?? []) {
+        if (!(field in supplied))
+            element[field] = undefined;
+    }
+    Object.assign(element, supplied);
+    appliedLookupFields.set(element, new Set(Object.keys(supplied)));
     // The selection door: a gateway acting on the learner's selection requests this
     // tool with the words in `term`, and the toolbar layers that over the host's own
     // params. The toolbar stamps every request with a neutral `toolRequestId` — core
@@ -122,7 +137,7 @@ function renderDictionaryPanel(args) {
  * 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.
+ * `toolId` and `lookupLanguage` to offer a second language beside it.
  */
 export function createDictionaryToolRegistration(options = {}) {
     const toolId = options.toolId ?? "dictionary";
@@ -136,15 +151,6 @@ export function createDictionaryToolRegistration(options = {}) {
         icon: "book-open",
         // Text can appear at any of these; the panel itself floats at section scope.
         supportedLevels: ["section", "item", "passage", "rubric"],
-        // PNP support IDs
-        // Maps to AfA PNP 3.0 / QTI 3.0 dictionary support, plus the common variants a
-        // host profile is likely to carry.
-        pnpSupportIds: options.pnpSupportIds ?? [
-            "dictionary", // Canonical id
-            "englishDictionary", // Common variant
-            "glossary", // Common variant
-            "definitions", // Common variant
-        ],
         /** Pass 2: a dictionary is relevant wherever there is text to look words up from. */
         isVisibleInContext(context) {
             return hasReadableText(context);
@@ -185,15 +191,6 @@ export function createPictureDictionaryToolRegistration(options = {}) {
         descriptionKey: `${prefix}.description`,
         icon: "photo",
         supportedLevels: ["section", "item", "passage", "rubric"],
-        // PNP support IDs
-        // AfA PNP 3.0 names an illustrated equivalent of a glossary; the variants cover
-        // what host profiles call it in practice.
-        pnpSupportIds: options.pnpSupportIds ?? [
-            "pictureDictionary", // Canonical id
-            "illustratedGlossary", // Common variant
-            "symbolDictionary", // Common variant
-            "pictureSupport", // Common variant
-        ],
         isVisibleInContext(context) {
             return hasReadableText(context);
         },
@@ -224,13 +221,11 @@ export const spanishDictionaryToolRegistration = createDictionaryToolRegistratio
     toolId: "dictionarySpanish",
     name: "Spanish Dictionary",
     description: "Look up word definitions in Spanish",
-    pnpSupportIds: ["spanishDictionary"],
     lookupLanguage: "es",
 });
 export const spanishPictureDictionaryToolRegistration = createPictureDictionaryToolRegistration({
     toolId: "pictureDictionarySpanish",
     name: "Spanish Picture Dictionary",
     description: "Look up pictures for words in Spanish",
-    pnpSupportIds: ["spanishPictureDictionary"],
     lookupLanguage: "es",
 });

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

@@ -3,14 +3,8 @@
  *
  * Registers tools for interacting with question content:
  * - Answer Eliminator (strike through answer choices)
- * - Highlighter (highlight text passages)
- *
- * Maps to QTI 3.0 standard access features:
- * - answerMasking (assessment tool)
- * - strikethrough (visual transformation)
- * - highlighting (cognitive/reading support)
  */
-import type { ToolRegistration } from "@pie-players/pie-assessment-toolkit/tools/internal";
+import type { ToolRegistration } from "@pie-players/pie-assessment-toolkit/tools/registration";
 /**
  * Answer Eliminator tool registration
  *

package/dist/registrations/interaction-tools.js

@@ -3,17 +3,28 @@
  *
  * Registers tools for interacting with question content:
  * - Answer Eliminator (strike through answer choices)
- * - Highlighter (highlight text passages)
- *
- * Maps to QTI 3.0 standard access features:
- * - answerMasking (assessment tool)
- * - strikethrough (visual transformation)
- * - highlighting (cognitive/reading support)
  */
-import { hasChoiceInteraction } 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";
+import { hasChoiceInteraction } from "@pie-players/pie-assessment-toolkit/tools/registration";
+import { createToolElement, } from "@pie-players/pie-assessment-toolkit/tools/registration";
+import { createScopedVisibilityBinding, syncButtonAndOverlayVisibility, } from "@pie-players/pie-assessment-toolkit/tools/registration";
 import { resolveOverlayElement } from "./overlay-element-cache.js";
+/** The policy parameters' `strategy`, defaulting to strikethrough. */
+const normalizeEliminationStrategy = (value) => value === "mask" ? "mask" : "strikethrough";
+/** The state-store key of each PIE element in the item, by model id. */
+function resolveElementStateKeys(context, toolbarContext) {
+    const keys = {};
+    if (!("item" in context) || !toolbarContext.getGlobalElementId)
+        return keys;
+    for (const model of context.item?.config?.models ?? []) {
+        const elementId = model?.id;
+        if (typeof elementId !== "string" || !elementId)
+            continue;
+        const key = toolbarContext.getGlobalElementId(elementId);
+        if (key)
+            keys[elementId] = key;
+    }
+    return keys;
+}
 /**
  * Answer Eliminator tool registration
  *
@@ -27,15 +38,7 @@ export const answerEliminatorToolRegistration = {
     nameKey: "tools.answerEliminator.name",
     descriptionKey: "tools.answerEliminator.description",
     icon: "strikethrough",
-    // Answer eliminator appears at item level only
     supportedLevels: ["item"],
-    // PNP support IDs
-    // Maps to QTI 3.0 standard feature: answerMasking
-    pnpSupportIds: [
-        "answerMasking", // QTI 3.0 standard (assessment.answerMasking)
-        "answerEliminator", // QTI 3.0 standard (assessment.answerEliminator)
-        "strikethrough", // QTI 3.0 standard (assessment.strikethrough)
-    ],
     /**
      * Pass 2: Answer eliminator is relevant only for choice-based questions
      */
@@ -57,9 +60,8 @@ export const answerEliminatorToolRegistration = {
         const visibility = createScopedVisibilityBinding(this.toolId, toolbarContext);
         const componentOverrides = toolbarContext.componentOverrides ?? {};
         const overlay = resolveOverlayElement(toolbarContext, visibility.fullToolId, () => createToolElement(this.toolId, context, toolbarContext, componentOverrides));
-        overlay.setAttribute("tool-id", visibility.fullToolId);
-        overlay.setAttribute("strategy", "strikethrough");
         overlay.setAttribute("button-alignment", "inline");
+        overlay.setAttribute("strategy", normalizeEliminationStrategy(toolbarContext.getToolParameters?.("answerEliminator")?.strategy));
         const button = {
             toolId: this.toolId,
             label: this.name,
@@ -80,17 +82,7 @@ export const answerEliminatorToolRegistration = {
                     overlay,
                     isActive: visibility.isActive,
                 });
-                if (toolbarContext.toolCoordinator) {
-                    overlay.coordinator = toolbarContext.toolCoordinator;
-                }
-                overlay.scopeElement = toolbarContext.getScopeElement?.() || null;
-                if (toolbarContext.elementToolStateStore) {
-                    overlay.elementToolStateStore = toolbarContext.elementToolStateStore;
-                }
-                const globalElementId = toolbarContext.getGlobalElementId?.();
-                if (globalElementId) {
-                    overlay.globalElementId = globalElementId;
-                }
+                overlay.elementStateKeys = resolveElementStateKeys(context, toolbarContext);
             },
             subscribeActive: visibility.subscribeActive,
         };

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

@@ -2,12 +2,8 @@
  * Measurement Tools Registrations
  *
  * Registers ruler and protractor tools for on-screen measurements.
- *
- * Maps to QTI 3.0 standard access features:
- * - ruler (assessment tool)
- * - protractor (assessment tool)
  */
-import type { ToolRegistration } from "@pie-players/pie-assessment-toolkit/tools/internal";
+import type { ToolRegistration } from "@pie-players/pie-assessment-toolkit/tools/registration";
 /**
  * Ruler tool registration
  *

package/dist/registrations/measurement-tools.js

@@ -2,12 +2,8 @@
  * Measurement Tools Registrations
  *
  * Registers ruler and protractor tools for on-screen measurements.
- *
- * Maps to QTI 3.0 standard access features:
- * - ruler (assessment tool)
- * - protractor (assessment tool)
  */
-import { hasMathContent } from "@pie-players/pie-assessment-toolkit/tools/internal";
+import { hasMathContent } from "@pie-players/pie-assessment-toolkit/tools/registration";
 import { renderOverlayToolbar } from "./overlay-toolbar-render.js";
 /**
  * Ruler tool registration
@@ -24,11 +20,6 @@ export const rulerToolRegistration = {
     icon: "ruler",
     // Ruler typically appears at section/item/element level
     supportedLevels: ["section", "item", "element"],
-    // PNP support IDs
-    // Maps to QTI 3.0 standard feature: ruler
-    pnpSupportIds: [
-        "ruler", // QTI 3.0 standard (assessment.ruler)
-    ],
     /**
      * Pass 2: Ruler is relevant when math content is present
      */
@@ -38,7 +29,6 @@ export const rulerToolRegistration = {
     renderToolbar(context, toolbarContext) {
         return renderOverlayToolbar(this, context, toolbarContext, {
             surface: "frameless",
-            handsOverCoordinator: true,
         });
     },
 };
@@ -57,11 +47,6 @@ export const protractorToolRegistration = {
     icon: "protractor",
     // Protractor typically appears at section/item/element level
     supportedLevels: ["section", "item", "element"],
-    // PNP support IDs
-    // Maps to QTI 3.0 standard feature: protractor
-    pnpSupportIds: [
-        "protractor", // QTI 3.0 standard (assessment.protractor)
-    ],
     /**
      * Pass 2: Protractor is relevant when math content is present
      */
@@ -71,7 +56,6 @@ export const protractorToolRegistration = {
     renderToolbar(context, toolbarContext) {
         return renderOverlayToolbar(this, context, toolbarContext, {
             surface: "frameless",
-            handsOverCoordinator: true,
         });
     },
 };

package/dist/registrations/overlay-element-cache.d.ts

@@ -12,7 +12,9 @@
  * A Svelte custom element tears its component down once it leaves the document,
  * so a cached element found disconnected is dropped and recreated.
  */
-import type { ToolbarContext } from "@pie-players/pie-assessment-toolkit/tools/internal";
+import type { ToolbarContext } from "@pie-players/pie-assessment-toolkit/tools/registration";
+/** The property the toolbar calls as it unmounts a tool element. */
+export declare const TOOL_ELEMENT_UNMOUNT_CALLBACK_PROP = "__pieToolElementUnmount";
 /**
  * The element cached for `fullToolId` under this toolbar's coordinator, or the
  * one `create` returns, which is then cached. Without a coordinator there is no

package/dist/registrations/overlay-element-cache.js

@@ -12,7 +12,8 @@
  * A Svelte custom element tears its component down once it leaves the document,
  * so a cached element found disconnected is dropped and recreated.
  */
-import { TOOL_ELEMENT_UNMOUNT_CALLBACK_PROP } from "./tts.js";
+/** The property the toolbar calls as it unmounts a tool element. */
+export const TOOL_ELEMENT_UNMOUNT_CALLBACK_PROP = "__pieToolElementUnmount";
 const overlayElements = new WeakMap();
 /**
  * The element cached for `fullToolId` under this toolbar's coordinator, or the

package/dist/registrations/overlay-toolbar-render.d.ts

@@ -2,21 +2,17 @@
  * The `renderToolbar` shape shared by every packaged capability that puts one
  * overlay behind one toolbar button.
  *
- * Seven registrations had this inline. What actually varies between them is the
- * three options below and nothing else: whether the overlay paints its own chrome
- * or takes a draggable window, that window's size, and whether the overlay needs
- * the coordinator re-handed on each sync. Everything else — the visibility
- * binding, the button, the component-override lookup, the `tool-id` attribute, the
- * sync — was identical, which is why one rule landing in three spellings was
- * possible: the shell title was `resolveToolRegistrationName` in two files,
- * `displayName` in a third and a raw `t(key)` in a fourth.
+ * What varies between capabilities is the two options below: whether the overlay
+ * paints its own chrome or takes a draggable window, and that window's size. The
+ * visibility binding, the button, the component-override lookup, the `tool-id`
+ * attribute and the sync are shared, so the shell title has one spelling.
  *
- * Catalog keys are derived from `toolId`, which held at all seven sites:
- * `tools.<toolId>.buttonA11y` and `tools.<toolId>.tooltip`. A capability needing a
- * different prefix — the dictionary variants, which compose several capabilities
- * off one element — keeps its own renderer.
+ * Catalog keys are derived from `toolId`: `tools.<toolId>.buttonA11y` and
+ * `tools.<toolId>.tooltip`. A capability needing a different prefix — the
+ * dictionary variants, which compose several capabilities off one element —
+ * keeps its own renderer.
  */
-import { type ToolContext, type ToolRegistration, type ToolToolbarRenderResult, type ToolbarContext } from "@pie-players/pie-assessment-toolkit/tools/internal";
+import { type ToolContext, type ToolRegistration, type ToolToolbarRenderResult, type ToolbarContext } from "@pie-players/pie-assessment-toolkit/tools/registration";
 /** A window's geometry. Absent for overlays that paint their own chrome. */
 export interface OverlayToolShell {
     resizable: boolean;
@@ -33,11 +29,5 @@ export interface RenderOverlayToolbarOptions {
     surface?: "frameless";
     /** Present when the capability opens in a draggable, closeable window. */
     shell?: OverlayToolShell;
-    /**
-     * Re-hand the toolkit coordinator on every sync. Overlays that take part in
-     * stacking or visibility restore need it; the two that only render their own
-     * model do not, and giving them a property they ignore is not free to assume.
-     */
-    handsOverCoordinator?: boolean;
 }
 export declare function renderOverlayToolbar(registration: ToolRegistration, context: ToolContext, toolbarContext: ToolbarContext, options?: RenderOverlayToolbarOptions): ToolToolbarRenderResult;