@pie-players/pie-default-tool-loaders 1.0.0-beta.3 → 1.0.0-beta.4

package/README.md

@@ -5,9 +5,9 @@ they load, and which of them a program grants to everyone. This README is for
 host integrators choosing a tool set and a calculator, and for contributors
 adding a packaged capability.
 
-The package owns the concrete `pie-tool-*` dependencies and the calculator
-engines (`pie-calculator-cortex`, `-desmos` and `-geogebra`), so toolkit core
-stays dependency-light and cycle-safe. Core knows the concepts — support ids,
+The package owns the concrete `pie-tool-*` dependencies and the Desmos and
+GeoGebra calculator adapters (`pie-calculator-desmos` and `-geogebra`), so
+toolkit core stays dependency-light and cycle-safe. Core knows the concepts — support ids,
 placement levels, activation kinds and precedence rules — and no concrete
 capability id. A support id is the tool id a profile grants.
 
@@ -15,6 +15,7 @@ capability id. A support id is the tool id a profile grants.
 | --- | --- |
 | `PACKAGED_TOOL_REGISTRATIONS`, `createPackagedToolRegistry` | Which capabilities exist, and their toolbar and surface contracts |
 | `PACKAGED_TOOL_TAG_MAP` | Which custom element each one renders as |
+| `createCalculatorToolRegistration` | Which calculator backends `provider.id` selects among |
 | `SECTION_PLAYER_PREFERRED_TOOL_PLACEMENT` | Where they appear and in what order |
 | `createUniversalPersonalNeedsProfile`, `createEmptyPersonalNeedsProfile` | Which of them the program grants to everyone, or to no one |
 | `createPersonalNeedsProfileFromAfa` | Which of them a student's AfA PNP 3.0 record grants, prohibits and turns on at start, and with which settings |
@@ -58,15 +59,8 @@ Desmos is the provider when none is configured, and it needs an API key: pass
 it through `provider.runtime.authFetcher`, a `provider.init.proxyEndpoint` that
 returns it, or `provider.init.apiKey` in development
 ([Calculator with host auth](../../docs/tools-and-accomodations/tool_provider_system.md#calculator-with-host-auth)).
-Without one the calculator fails to load. For a keyless, offline-capable
-calculator with no runtime CDN, use `provider.id: "calculator-cortex"`. Its
-`settings` take the `CortexCalculatorSettings` type that
-`@pie-players/pie-calculator-cortex` exports: `angleMode`,
-`calculationPrecision`, `displayPrecision`, `historyLimit`,
-`evaluationTimeLimitMs`, `allowedFunctions`, `allowClipboard`, `messages`,
-`direction` and `graph`. Clipboard blocking follows `restrictedMode`;
-`allowClipboard` alone blocks nothing. The [Cortex README](../calculator-cortex/README.md)
-covers localization, message overrides and the keypad.
+Without one the calculator fails to load. `provider.id: "calculator-geogebra"`
+selects GeoGebra, which needs no key.
 
 ```ts
 const tools = {
@@ -82,6 +76,52 @@ const tools = {
 };
 ```
 
+### Adding a backend
+
+The packaged registration selects among Desmos and GeoGebra only, because a
+bundler that inlines dynamic imports inlines every backend the registration
+names, selected or not. `createCalculatorToolRegistration({ providers })` builds
+the registration with more backends, keyed by `provider.id`; an id the packaged
+set already holds is replaced. The keyless, offline-capable Cortex calculator,
+which needs no runtime CDN, is composed in this way from
+`@pie-players/pie-calculator-cortex`, which the host installs:
+
+```ts
+import {
+	createCalculatorToolRegistration,
+	createPackagedToolRegistry,
+} from "@pie-players/pie-default-tool-loaders";
+
+const registry = createPackagedToolRegistry({
+	overrides: {
+		calculator: createCalculatorToolRegistration({
+			providers: {
+				"calculator-cortex": {
+					providerName: "PIE Open-Source Calculator",
+					version: "1",
+					requiresAuth: false,
+					backend: "cortex",
+					load: async () =>
+						(await import("@pie-players/pie-calculator-cortex"))
+							.CortexCalculatorProvider,
+					initializationErrorMessage:
+						"Failed to initialize the Cortex calculator provider.",
+				},
+			},
+		}),
+	},
+});
+```
+
+`provider.id: "calculator-cortex"` then selects it. Its `settings` take the
+`CortexCalculatorSettings` type that `@pie-players/pie-calculator-cortex`
+exports: `angleMode`, `calculationPrecision`, `displayPrecision`,
+`historyLimit`, `evaluationTimeLimitMs`, `allowedFunctions`, `allowClipboard`,
+`messages`, `direction` and `graph`. Clipboard blocking follows
+`restrictedMode`; `allowClipboard` alone blocks nothing. The
+[Cortex README](../calculator-cortex/README.md) covers localization, message
+overrides and the keypad.
+
 ## Custom sets
 
 A host composing its own set starts from the toolkit's empty `ToolRegistry`,
@@ -167,8 +207,8 @@ student's AfA PNP 3.0 record, held as JSON keyed by the spec's terms. Features
 become support ids in the packaged set's names, the activation sets fill
 `activateAtInit` and `prohibitedSupports`, and the settings the packaged tools
 read become `toolParameters`: read-aloud speed, pitch and volume, the calculator
-type and the sign language. The toolkit's PNP configuration guide gives each AfA
-feature's disposition.
+type, the sign language and the magnifier's starting zoom. The toolkit's PNP
+configuration guide gives each AfA feature's disposition.
 
 ```ts
 import { createPersonalNeedsProfileFromAfa } from "@pie-players/pie-default-tool-loaders";

package/dist/afa-profile.d.ts

@@ -28,6 +28,10 @@ export interface AfaSpoken {
 }
 /** A set's features: empty elements keyed by feature, or the feature names. */
 export type AfaFeatureSet = Readonly<Record<string, unknown>> | readonly string[];
+/** AfA's `ZoomAmount`: a magnification multiplier. */
+export interface AfaZoomAmount {
+    "zoom-amount"?: number;
+}
 /** An AfA PNP 3.0 record in JSON. A feature is present unless absent, `null` or `false`. */
 export interface AfaPnpRecord {
     spoken?: AfaSpoken;
@@ -39,6 +43,15 @@ export interface AfaPnpRecord {
         language?: string;
         [setting: string]: unknown;
     };
+    /** One selection: the amount for all content, or for text and non-text apart. */
+    magnification?: {
+        "all-content"?: AfaZoomAmount;
+        selectMagnification?: {
+            text?: AfaZoomAmount;
+            "non-text"?: AfaZoomAmount;
+        };
+        [setting: string]: unknown;
+    };
     "activate-at-initialization-set"?: AfaFeatureSet;
     "activate-as-option-set"?: AfaFeatureSet;
     "prohibit-set"?: AfaFeatureSet;

package/dist/afa-profile.js

@@ -70,6 +70,16 @@ function spokenParameters(spoken) {
         ...(volume !== undefined ? { volume } : {}),
     };
 }
+/**
+ * The lens's starting zoom. The lens magnifies text and non-text alike, so a
+ * record that sets them apart gives the text amount, else the non-text one.
+ */
+function magnifierZoom(magnification) {
+    const select = magnification?.selectMagnification;
+    return (finiteNumber(magnification?.["all-content"]?.["zoom-amount"]) ??
+        finiteNumber(select?.text?.["zoom-amount"]) ??
+        finiteNumber(select?.["non-text"]?.["zoom-amount"]));
+}
 /** A fresh profile carrying `record`'s grants, prohibitions and settings, ids sorted. */
 export function createPersonalNeedsProfileFromAfa(record) {
     const spoken = typeof record.spoken === "object" && record.spoken !== null
@@ -108,6 +118,10 @@ export function createPersonalNeedsProfileFromAfa(record) {
     if (typeof signLang === "string" && signLang.length > 0) {
         toolParameters.signLanguage = { signLang };
     }
+    const zoom = magnifierZoom(record.magnification);
+    if (zoom !== undefined && zoom > 1) {
+        toolParameters.magnification = { zoom };
+    }
     return {
         supports,
         prohibitedSupports: [...prohibited].sort(),

package/dist/calculator-providers/LazyCalculatorToolProvider.d.ts

@@ -1,33 +1,47 @@
 import type { CalculatorProvider, CalculatorProviderInit } from "@pie-players/pie-calculator";
 import type { ToolProviderApi } from "@pie-players/pie-assessment-toolkit/tools/registration";
-export type CalculatorToolProviderInitConfig = Pick<CalculatorProviderInit, "onTelemetry">;
-type InitializableCalculatorProvider<TConfig> = CalculatorProvider & {
-    initialize(config: TConfig): Promise<void>;
-};
-export interface LazyCalculatorProviderDefinition<TConfig> {
-    backend: string;
-    moduleImportOperation: string;
-    loadProvider: () => Promise<new () => InitializableCalculatorProvider<TConfig>>;
-    initializationErrorMessage: string;
+/**
+ * One calculator backend, selected by the toolkit's `provider.id`. `load` runs
+ * on first use, but a bundler that inlines dynamic imports inlines what it
+ * names whether or not the host selects the backend. The packaged set therefore
+ * holds only the thin Desmos and GeoGebra adapters, and a host adds any other
+ * backend through `createCalculatorToolRegistration`.
+ */
+export interface CalculatorProviderDefinition {
+    /** Names the provider in toolkit logs, telemetry and error messages. */
+    readonly providerName: string;
+    readonly version: string;
+    /**
+     * Whether the registry merges the result of `provider.runtime.authFetcher`
+     * into the configuration `initialize()` receives.
+     */
+    readonly requiresAuth: boolean;
+    /** The `backend` of library-load telemetry. */
+    readonly backend: string;
+    /** Loads the adapter's provider class, usually through a dynamic import. */
+    readonly load: () => Promise<new () => CalculatorProvider>;
+    /** Thrown, with the failure as its cause, when loading or initializing fails. */
+    readonly initializationErrorMessage: string;
 }
 /**
- * Shared lazy-module and lifecycle implementation for calculator tool adapters.
- * Concrete adapters own only their metadata and provider import.
+ * Lazy-module and lifecycle implementation shared by every calculator backend:
+ * concurrent initialization is deduplicated, and `destroy()` cancels one in
+ * flight.
  */
-export declare abstract class LazyCalculatorToolProvider<TConfig extends CalculatorToolProviderInitConfig> implements ToolProviderApi<CalculatorProvider> {
-    abstract readonly providerName: string;
+export declare class LazyCalculatorToolProvider implements ToolProviderApi<CalculatorProvider> {
+    readonly providerName: string;
     readonly category: "calculator";
-    abstract readonly version: string;
-    abstract readonly requiresAuth: boolean;
-    protected abstract getDefinition(): LazyCalculatorProviderDefinition<TConfig>;
+    readonly version: string;
+    readonly requiresAuth: boolean;
+    private readonly definition;
     private calculatorProvider;
     private initializationPromise;
     private lifecycleGeneration;
+    constructor(definition: CalculatorProviderDefinition);
     private emitTelemetry;
-    initialize(config?: TConfig): Promise<void>;
+    initialize(config?: CalculatorProviderInit): Promise<void>;
     private initializeProvider;
     createInstance(): Promise<CalculatorProvider>;
     isReady(): boolean;
     destroy(): void;
 }
-export {};

package/dist/calculator-providers/LazyCalculatorToolProvider.js

@@ -1,12 +1,23 @@
 /**
- * Shared lazy-module and lifecycle implementation for calculator tool adapters.
- * Concrete adapters own only their metadata and provider import.
+ * Lazy-module and lifecycle implementation shared by every calculator backend:
+ * concurrent initialization is deduplicated, and `destroy()` cancels one in
+ * flight.
  */
 export class LazyCalculatorToolProvider {
+    providerName;
     category = "calculator";
+    version;
+    requiresAuth;
+    definition;
     calculatorProvider = null;
     initializationPromise = null;
     lifecycleGeneration = 0;
+    constructor(definition) {
+        this.definition = definition;
+        this.providerName = definition.providerName;
+        this.version = definition.version;
+        this.requiresAuth = definition.requiresAuth;
+    }
     async emitTelemetry(config, eventName, payload) {
         try {
             await config.onTelemetry?.(eventName, payload);
@@ -33,33 +44,34 @@ export class LazyCalculatorToolProvider {
         }
     }
     async initializeProvider(config, generation) {
-        const definition = this.getDefinition();
+        const { backend, initializationErrorMessage } = this.definition;
+        const operation = `${backend}-provider-module-import`;
         const moduleLoadStartedAt = Date.now();
         await this.emitTelemetry(config, "pie-tool-library-load-start", {
             toolId: "calculator",
-            operation: definition.moduleImportOperation,
-            backend: definition.backend,
+            operation,
+            backend,
         });
         let ProviderConstructor;
         try {
-            ProviderConstructor = await definition.loadProvider();
+            ProviderConstructor = await this.definition.load();
             await this.emitTelemetry(config, "pie-tool-library-load-success", {
                 toolId: "calculator",
-                operation: definition.moduleImportOperation,
-                backend: definition.backend,
+                operation,
+                backend,
                 duration: Date.now() - moduleLoadStartedAt,
             });
         }
         catch (error) {
             await this.emitTelemetry(config, "pie-tool-library-load-error", {
                 toolId: "calculator",
-                operation: definition.moduleImportOperation,
-                backend: definition.backend,
+                operation,
+                backend,
                 duration: Date.now() - moduleLoadStartedAt,
                 errorType: "ToolLibraryLoadError",
                 message: error instanceof Error ? error.message : String(error),
             });
-            throw new Error(definition.initializationErrorMessage, { cause: error });
+            throw new Error(initializationErrorMessage, { cause: error });
         }
         if (generation !== this.lifecycleGeneration) {
             throw new Error(`${this.providerName} initialization was cancelled`);
@@ -74,7 +86,7 @@ export class LazyCalculatorToolProvider {
         }
         catch (error) {
             candidate.destroy();
-            throw new Error(definition.initializationErrorMessage, { cause: error });
+            throw new Error(initializationErrorMessage, { cause: error });
         }
     }
     async createInstance() {

package/dist/calculator-providers/packaged-calculator-providers.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The calculator backends of the packaged set, by `provider.id`. Every import
+ * named here lands in a host bundle that inlines dynamic imports, so only thin
+ * adapters over a vendor-hosted engine belong in it.
+ */
+import type { CalculatorProviderDefinition } from "./LazyCalculatorToolProvider.js";
+export declare const DEFAULT_CALCULATOR_PROVIDER_ID = "calculator-desmos";
+export declare const PACKAGED_CALCULATOR_PROVIDERS: Readonly<Record<string, CalculatorProviderDefinition>>;

package/dist/calculator-providers/packaged-calculator-providers.js

@@ -0,0 +1,26 @@
+/**
+ * The calculator backends of the packaged set, by `provider.id`. Every import
+ * named here lands in a host bundle that inlines dynamic imports, so only thin
+ * adapters over a vendor-hosted engine belong in it.
+ */
+export const DEFAULT_CALCULATOR_PROVIDER_ID = "calculator-desmos";
+export const PACKAGED_CALCULATOR_PROVIDERS = {
+    "calculator-desmos": {
+        providerName: "Desmos Calculator",
+        version: "1.12",
+        requiresAuth: true,
+        backend: "desmos",
+        load: async () => (await import("@pie-players/pie-calculator-desmos"))
+            .DesmosCalculatorProvider,
+        initializationErrorMessage: "Failed to initialize Desmos calculator provider. Check the application key, preloaded API, runtime endpoint, or network access.",
+    },
+    "calculator-geogebra": {
+        providerName: "GeoGebra Calculator",
+        version: "6",
+        requiresAuth: false,
+        backend: "geogebra",
+        load: async () => (await import("@pie-players/pie-calculator-geogebra"))
+            .GeoGebraCalculatorProvider,
+        initializationErrorMessage: "Failed to initialize GeoGebra calculator provider. Confirm that the deployment may load GeoGebra and that its script URL is reachable.",
+    },
+};

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 export type { PackagedToolRegistryOptions } from "./packaged-capability-composition.js";
 export { createEmptyPersonalNeedsProfile, createPackagedToolRegistry, createUniversalPersonalNeedsProfile, DEFAULT_TOOL_MODULE_LOADERS, PACKAGED_TOOL_REGISTRATIONS, PACKAGED_TOOL_TAG_MAP, SECTION_PLAYER_PREFERRED_TOOL_PLACEMENT, } from "./packaged-capability-composition.js";
-export { type AfaFeatureSet, type AfaPnpRecord, type AfaSpoken, createPersonalNeedsProfileFromAfa, } from "./afa-profile.js";
+export { type AfaFeatureSet, type AfaPnpRecord, type AfaSpoken, type AfaZoomAmount, createPersonalNeedsProfileFromAfa, } from "./afa-profile.js";
 export { CONTENT_ALTERNATE_REGISTRATIONS } from "./content-alternates.js";
-export { annotationToolbarRegistration, lineReaderToolRegistration, themeToolRegistration, } from "./registrations/accessibility-tools.js";
+export { annotationToolbarRegistration, lineReaderToolRegistration, magnificationToolRegistration, themeToolRegistration, } from "./registrations/accessibility-tools.js";
 export { AUDIO_TRANSCRIPT_FEATURE_ID, AUDIO_TRANSCRIPT_REGION_CLASS, AUDIO_TRANSCRIPT_REGION_LABEL, audioTranscriptRegistration, CONTENT_LEAD_SURFACE, resolveAudioTranscript, type ResolvedAudioTranscript, } from "./registrations/audio-transcript.js";
-export { calculatorToolRegistration } from "./registrations/calculator.js";
+export { type CalculatorProviderDefinition, type CalculatorRegistrationOptions, calculatorToolRegistration, createCalculatorToolRegistration, } from "./registrations/calculator.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";

package/dist/index.js

@@ -6,9 +6,9 @@ export { createPersonalNeedsProfileFromAfa, } from "./afa-profile.js";
 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 { annotationToolbarRegistration, lineReaderToolRegistration, magnificationToolRegistration, themeToolRegistration, } from "./registrations/accessibility-tools.js";
 export { AUDIO_TRANSCRIPT_FEATURE_ID, AUDIO_TRANSCRIPT_REGION_CLASS, AUDIO_TRANSCRIPT_REGION_LABEL, audioTranscriptRegistration, CONTENT_LEAD_SURFACE, resolveAudioTranscript, } from "./registrations/audio-transcript.js";
-export { calculatorToolRegistration } from "./registrations/calculator.js";
+export { calculatorToolRegistration, createCalculatorToolRegistration, } from "./registrations/calculator.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";

package/dist/packaged-capability-composition.js

@@ -8,7 +8,7 @@
  * cannot leave a second hand-maintained catalogue silently behind.
  */
 import { ToolRegistry, } from "@pie-players/pie-assessment-toolkit/tools/registration";
-import { annotationToolbarRegistration, lineReaderToolRegistration, themeToolRegistration, } from "./registrations/accessibility-tools.js";
+import { annotationToolbarRegistration, lineReaderToolRegistration, magnificationToolRegistration, themeToolRegistration, } from "./registrations/accessibility-tools.js";
 import { audioTranscriptRegistration } from "./registrations/audio-transcript.js";
 import { calculatorToolRegistration } from "./registrations/calculator.js";
 import { dictionaryToolRegistration, pictureDictionaryToolRegistration, spanishDictionaryToolRegistration, spanishPictureDictionaryToolRegistration, } from "./registrations/dictionary-tools.js";
@@ -28,6 +28,7 @@ const loadProtractorModule = () => loadSideEffectModule(() => import("@pie-playe
 const loadAnswerEliminatorModule = () => loadSideEffectModule(() => import("@pie-players/pie-tool-answer-eliminator"));
 const loadAnnotationToolbarModule = () => loadSideEffectModule(() => import("@pie-players/pie-tool-annotation-toolbar"));
 const loadLineReaderModule = () => loadSideEffectModule(() => import("@pie-players/pie-tool-line-reader"));
+const loadMagnifierModule = () => loadSideEffectModule(() => import("@pie-players/pie-tool-magnifier"));
 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"));
@@ -76,6 +77,15 @@ const PACKAGED_CAPABILITY_DEFINITIONS = [
         preferredPlacementOrder: { section: 40 },
         universal: true,
     },
+    {
+        registration: magnificationToolRegistration,
+        tagName: "pie-tool-magnifier",
+        loadModule: loadMagnifierModule,
+        preferredPlacementOrder: { section: 45 },
+        // Magnification is a granted low-vision accommodation in AfA PNP, so it
+        // is never universal.
+        universal: false,
+    },
     {
         registration: themeToolRegistration,
         tagName: "pie-tool-theme",

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

@@ -3,6 +3,7 @@
  *
  * Registers tools for visual accessibility and reading support:
  * - Line Reader (reading guide)
+ * - Magnifier (movable magnifying lens)
  * - Color Scheme (theme/contrast)
  * - Annotation Toolbar (text highlighting)
  */
@@ -14,6 +15,13 @@ import type { ToolRegistration } from "@pie-players/pie-assessment-toolkit/tools
  * Useful for text-heavy passages and questions.
  */
 export declare const lineReaderToolRegistration: ToolRegistration;
+/**
+ * Magnifier tool registration
+ *
+ * A movable lens that shows the content under it enlarged. The AfA
+ * `magnification` tool parameter `zoom` sets the lens's starting level.
+ */
+export declare const magnificationToolRegistration: ToolRegistration;
 /**
  * Theme tool registration
  *

package/dist/registrations/accessibility-tools.js

@@ -3,6 +3,7 @@
  *
  * Registers tools for visual accessibility and reading support:
  * - Line Reader (reading guide)
+ * - Magnifier (movable magnifying lens)
  * - Color Scheme (theme/contrast)
  * - Annotation Toolbar (text highlighting)
  */
@@ -36,6 +37,43 @@ export const lineReaderToolRegistration = {
         });
     },
 };
+/** A `zoom` worth passing on: a finite magnification above 1. */
+const normalizeMagnifierZoom = (value) => typeof value === "number" && Number.isFinite(value) && value > 1
+    ? value
+    : undefined;
+/**
+ * Magnifier tool registration
+ *
+ * A movable lens that shows the content under it enlarged. The AfA
+ * `magnification` tool parameter `zoom` sets the lens's starting level.
+ */
+export const magnificationToolRegistration = {
+    toolId: "magnification",
+    name: "Magnifier",
+    description: "Magnify the content under a movable lens",
+    nameKey: "tools.magnification.name",
+    descriptionKey: "tools.magnification.description",
+    icon: "magnifying-glass",
+    supportedLevels: ["section", "passage", "rubric", "item"],
+    /**
+     * Pass 2: anything on screen can be magnified, text or not
+     */
+    isVisibleInContext() {
+        return true;
+    },
+    renderToolbar(context, toolbarContext) {
+        const result = renderOverlayToolbar(this, context, toolbarContext, {
+            surface: "frameless",
+        });
+        const overlay = result.elements?.[0]?.element;
+        const zoom = normalizeMagnifierZoom(toolbarContext.getToolParameters?.("magnification")?.zoom);
+        if (zoom === undefined)
+            overlay?.removeAttribute("zoom");
+        else
+            overlay?.setAttribute("zoom", String(zoom));
+        return result;
+    },
+};
 /**
  * Theme tool registration
  *

package/dist/registrations/calculator.d.ts

@@ -6,15 +6,26 @@
  */
 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;
+import { type CalculatorProviderDefinition } from "../calculator-providers/LazyCalculatorToolProvider.js";
+export type { CalculatorProviderDefinition };
+export interface CalculatorRegistrationOptions {
+    /**
+     * Backends by `provider.id`, merged over the packaged Desmos and GeoGebra
+     * definitions. An entry under a packaged id replaces that backend.
+     */
+    providers?: Readonly<Record<string, CalculatorProviderDefinition>>;
+}
+export declare function resolveCalculatorProviderId(config: ToolProviderConfig | undefined, providers?: Readonly<Record<string, CalculatorProviderDefinition>>): string;
 /**
- * Calculator tool registration
+ * Builds the calculator registration over the packaged backends plus any the
+ * host adds, so a host bundles a backend only by naming it.
  *
  * Supports:
- * - Basic, scientific, and graphing calculators through Desmos, GeoGebra, or Cortex
+ * - Basic, scientific, and graphing calculators through the backend that
+ *   `provider.id` selects, Desmos by default
  * - Context-aware visibility (shows only when math content is detected)
  * - Item level only
  */
+export declare function createCalculatorToolRegistration(options?: CalculatorRegistrationOptions): ToolRegistration;
+/** The calculator over the packaged Desmos and GeoGebra backends. */
 export declare const calculatorToolRegistration: ToolRegistration;

package/dist/registrations/calculator.js

@@ -7,32 +7,21 @@
 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";
+import { LazyCalculatorToolProvider, } from "../calculator-providers/LazyCalculatorToolProvider.js";
+import { DEFAULT_CALCULATOR_PROVIDER_ID, PACKAGED_CALCULATOR_PROVIDERS, } from "../calculator-providers/packaged-calculator-providers.js";
 import { resolveOverlayElement } from "./overlay-element-cache.js";
-export const DEFAULT_CALCULATOR_PROVIDER_ID = "calculator-desmos";
-export function resolveCalculatorProviderId(config) {
+export function resolveCalculatorProviderId(config, providers = PACKAGED_CALCULATOR_PROVIDERS) {
     const configured = config?.provider?.id;
     if (configured === undefined || configured === "") {
         return DEFAULT_CALCULATOR_PROVIDER_ID;
     }
-    if (configured === "calculator-desmos" ||
-        configured === "calculator-geogebra" ||
-        configured === "calculator-cortex") {
+    if (typeof configured === "string" && Object.hasOwn(providers, configured)) {
         return configured;
     }
-    throw new Error(`Unsupported calculator provider "${String(configured)}". Expected "calculator-desmos", "calculator-geogebra", or "calculator-cortex".`);
-}
-function createCalculatorToolProvider(config) {
-    switch (resolveCalculatorProviderId(config)) {
-        case "calculator-cortex":
-            return new CortexToolProvider();
-        case "calculator-geogebra":
-            return new GeoGebraToolProvider();
-        default:
-            return new DesmosToolProvider();
-    }
+    const expected = Object.keys(providers)
+        .map((id) => `"${id}"`)
+        .join(", ");
+    throw new Error(`Unsupported calculator provider "${String(configured)}". Expected one of ${expected}.`);
 }
 function getCalculatorInstanceConfig(config) {
     const theme = config?.theme;
@@ -104,169 +93,175 @@ function applyCalculatorParamsToElement(element, calculatorType, availableTypes,
     }
 }
 /**
- * Calculator tool registration
+ * Builds the calculator registration over the packaged backends plus any the
+ * host adds, so a host bundles a backend only by naming it.
  *
  * Supports:
- * - Basic, scientific, and graphing calculators through Desmos, GeoGebra, or Cortex
+ * - Basic, scientific, and graphing calculators through the backend that
+ *   `provider.id` selects, Desmos by default
  * - Context-aware visibility (shows only when math content is detected)
  * - Item level only
  */
-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: {
-        createProvider: createCalculatorToolProvider,
-        getInitConfig: (config) => config?.provider?.init ?? {},
-        getAuthFetcher: (config) => {
-            const runtimeAuthFetcher = config?.provider?.runtime?.authFetcher;
-            return typeof runtimeAuthFetcher === "function"
-                ? runtimeAuthFetcher
-                : undefined;
+export function createCalculatorToolRegistration(options = {}) {
+    const providers = { ...PACKAGED_CALCULATOR_PROVIDERS, ...options.providers };
+    return {
+        toolId: "calculator",
+        name: "Calculator",
+        description: "Multi-type calculator (basic, scientific, graphing)",
+        nameKey: "tools.calculator.name",
+        descriptionKey: "tools.calculator.description",
+        icon: "calculator",
+        provider: {
+            createProvider: (config) => new LazyCalculatorToolProvider(providers[resolveCalculatorProviderId(config, providers)]),
+            getInitConfig: (config) => config?.provider?.init ?? {},
+            getAuthFetcher: (config) => {
+                const runtimeAuthFetcher = config?.provider?.runtime?.authFetcher;
+                return typeof runtimeAuthFetcher === "function"
+                    ? runtimeAuthFetcher
+                    : undefined;
+            },
+            lazy: true,
+        },
+        // Calculator is item-level in this player architecture.
+        supportedLevels: ["item"],
+        /**
+         * Pass 2: Determine if calculator is relevant in this context
+         *
+         * Calculator is relevant when context contains mathematical content
+         * (MathML, LaTeX, arithmetic markers).
+         */
+        isVisibleInContext(context) {
+            return hasMathContent(context);
         },
-        lazy: true,
-    },
-    // Calculator is item-level in this player architecture.
-    supportedLevels: ["item"],
-    /**
-     * Pass 2: Determine if calculator is relevant in this context
-     *
-     * Calculator is relevant when context contains mathematical content
-     * (MathML, LaTeX, arithmetic markers).
-     */
-    isVisibleInContext(context) {
-        return hasMathContent(context);
-    },
-    renderToolbar(context, toolbarContext) {
-        const { calculatorType, availableTypes, displayName } = getCalculatorRenderParams(toolbarContext);
-        const calculatorToolConfig = toolbarContext.toolkitCoordinator?.getToolConfig(this.toolId) ||
-            undefined;
-        const calculatorConfig = getCalculatorInstanceConfig(calculatorToolConfig);
-        const fullToolId = createScopedToolId(this.toolId, toolbarContext.scope.level, toolbarContext.scope.scopeId);
-        const componentOverrides = toolbarContext.componentOverrides;
-        // Reused across renders: besides keeping state, this spares a Desmos boot
-        // and container mount on every re-render.
-        const overlay = resolveOverlayElement(toolbarContext, fullToolId, () => createToolElement(this.toolId, context, toolbarContext, componentOverrides));
-        overlay.setAttribute("tool-id", fullToolId);
-        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.
-            faIconName: "calculator",
-            disabled: false,
-            // 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(this.toolId),
-        };
-        let lastVisibleState = button.active;
-        if (overlay.visible !== button.active) {
-            overlay.visible = button.active;
-        }
-        return {
-            toolId: this.toolId,
-            elements: [
-                {
-                    element: overlay,
-                    mount: "after-buttons",
-                    shell: {
-                        // The variant name the button already carries — "Basic Calculator",
-                        // not the registration's generic one.
-                        title: displayName,
-                        draggable: true,
-                        resizable: true,
-                        closeable: true,
-                        /*
-                         * Sized per type from what each layout measures, rather than one
-                         * size for all three. A shell subtracts ~74px of header from the
-                         * height it is given, and the numbers below are the content each
-                         * type needs plus room for its history tape:
-                         *
-                         * - basic: strip, display, edit row and a four-row keypad measure
-                         *   398px. 560 left ~90px of blank above the entry line, which is
-                         *   the gap that made the panel look mis-sized.
-                         * - scientific: the same plus a keypad layer tab row.
-                         * - graphing: the expression rail beside the plot, whose column
-                         *   wants 486px on its own — viewport controls, a 14rem board floor
-                         *   and the readout that *is* the graph for assistive technology,
-                         *   since the board itself is `aria-hidden`. At 620 that column was
-                         *   12px short and the readout's last line was cut off.
-                         *
-                         * The minimums stay shared across types and providers. This
-                         * registration serves Desmos, GeoGebra and Cortex alike, so a
-                         * graphing-only floor would move the resize limit under two vendors
-                         * whose layouts were never measured for it. Cortex below 42rem
-                         * stacks the rail above the plot and needs 701px there, which no
-                         * spacing tier closes — it scrolls its own content instead of
-                         * clipping it, which is the contract every size below the opening
-                         * one already relies on.
-                         */
-                        initialWidth: calculatorType === "graphing" ? 720 : 380,
-                        initialHeight: calculatorType === "graphing"
-                            ? 660
-                            : calculatorType === "basic"
-                                ? 500
-                                : 560,
-                        minWidth: 380,
-                        minHeight: 480,
-                        /*
-                         * `bottom-right` put a 560-620px-tall shell over the items
-                         * column it shares the viewport with — tall enough, at
-                         * ordinary viewport heights, to sit on top of a sibling
-                         * item's own toolbar row and block its button from mouse
-                         * and touch input. `bottom-left` keeps the same footprint
-                         * over the passage column instead, which carries no
-                         * per-item controls to collide with.
-                         */
-                        initialAlign: "bottom-left",
-                        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,
+        renderToolbar(context, toolbarContext) {
+            const { calculatorType, availableTypes, displayName } = getCalculatorRenderParams(toolbarContext);
+            const calculatorToolConfig = toolbarContext.toolkitCoordinator?.getToolConfig(this.toolId) ||
+                undefined;
+            const calculatorConfig = getCalculatorInstanceConfig(calculatorToolConfig);
+            const fullToolId = createScopedToolId(this.toolId, toolbarContext.scope.level, toolbarContext.scope.scopeId);
+            const componentOverrides = toolbarContext.componentOverrides;
+            // Reused across renders: besides keeping state, this spares a Desmos boot
+            // and container mount on every re-render.
+            const overlay = resolveOverlayElement(toolbarContext, fullToolId, () => createToolElement(this.toolId, context, toolbarContext, componentOverrides));
+            overlay.setAttribute("tool-id", fullToolId);
+            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.
+                faIconName: "calculator",
+                disabled: false,
+                // 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(this.toolId),
+            };
+            let lastVisibleState = button.active;
+            if (overlay.visible !== button.active) {
+                overlay.visible = button.active;
+            }
+            return {
+                toolId: this.toolId,
+                elements: [
+                    {
+                        element: overlay,
+                        mount: "after-buttons",
+                        shell: {
+                            // The variant name the button already carries — "Basic Calculator",
+                            // not the registration's generic one.
+                            title: displayName,
+                            draggable: true,
+                            resizable: true,
+                            closeable: true,
+                            /*
+                             * Sized per type from what each layout measures, rather than one
+                             * size for all three. A shell subtracts ~74px of header from the
+                             * height it is given, and the numbers below are the content each
+                             * type needs plus room for its history tape:
+                             *
+                             * - basic: strip, display, edit row and a four-row keypad measure
+                             *   398px. 560 left ~90px of blank above the entry line, which is
+                             *   the gap that made the panel look mis-sized.
+                             * - scientific: the same plus a keypad layer tab row.
+                             * - graphing: the expression rail beside the plot, whose column
+                             *   wants 486px on its own — viewport controls, a 14rem board floor
+                             *   and the readout that *is* the graph for assistive technology,
+                             *   since the board itself is `aria-hidden`. At 620 that column was
+                             *   12px short and the readout's last line was cut off.
+                             *
+                             * The minimums stay shared across types and backends. One
+                             * registration serves every backend, so a graphing-only floor
+                             * would move the resize limit under vendors whose layouts were
+                             * never measured for it. Cortex below 42rem stacks the rail above
+                             * the plot and needs 701px there, which no spacing tier closes — it
+                             * scrolls its own content instead of clipping it, which is the
+                             * contract every size below the opening one already relies on.
+                             */
+                            initialWidth: calculatorType === "graphing" ? 720 : 380,
+                            initialHeight: calculatorType === "graphing"
+                                ? 660
+                                : calculatorType === "basic"
+                                    ? 500
+                                    : 560,
+                            minWidth: 380,
+                            minHeight: 480,
+                            /*
+                             * `bottom-right` put a 560-620px-tall shell over the items
+                             * column it shares the viewport with — tall enough, at
+                             * ordinary viewport heights, to sit on top of a sibling
+                             * item's own toolbar row and block its button from mouse
+                             * and touch input. `bottom-left` keeps the same footprint
+                             * over the passage column instead, which carries no
+                             * per-item controls to collide with.
+                             */
+                            initialAlign: "bottom-left",
+                            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,
+                            },
                         },
                     },
+                ],
+                button,
+                sync: () => {
+                    const active = toolbarContext.isToolVisible(this.toolId);
+                    button.active = active;
+                    button.label = displayName;
+                    // 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;
+                    }
+                    applyCalculatorParamsToElement(overlay, calculatorType, availableTypes, calculatorConfig);
                 },
-            ],
-            button,
-            sync: () => {
-                const active = toolbarContext.isToolVisible(this.toolId);
-                button.active = active;
-                button.label = displayName;
-                // 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;
-                }
-                applyCalculatorParamsToElement(overlay, calculatorType, availableTypes, calculatorConfig);
-            },
-            subscribeActive: (callback) => {
-                if (!toolbarContext.subscribeVisibility)
-                    return () => { };
-                return toolbarContext.subscribeVisibility(() => {
-                    callback(toolbarContext.isToolVisible(this.toolId));
-                });
-            },
-        };
-    },
-};
+                subscribeActive: (callback) => {
+                    if (!toolbarContext.subscribeVisibility)
+                        return () => { };
+                    return toolbarContext.subscribeVisibility(() => {
+                        callback(toolbarContext.isToolVisible(this.toolId));
+                    });
+                },
+            };
+        },
+    };
+}
+/** The calculator over the packaged Desmos and GeoGebra backends. */
+export const calculatorToolRegistration = createCalculatorToolRegistration();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@pie-players/pie-default-tool-loaders",
-	"version": "1.0.0-beta.3",
+	"version": "1.0.0-beta.4",
 	"type": "module",
 	"description": "Composition layer for the packaged PIE assessment tools: registrations, tag map, placement preset, universal and empty profiles, and lazy module loaders",
 	"repository": {
@@ -33,25 +33,25 @@
 		"test": "bun test"
 	},
 	"dependencies": {
-		"@pie-players/pie-assessment-toolkit": "1.0.0-beta.3",
-		"@pie-players/pie-calculator": "1.0.0-beta.3",
-		"@pie-players/pie-calculator-cortex": "1.0.0-beta.3",
-		"@pie-players/pie-calculator-desmos": "1.0.0-beta.3",
-		"@pie-players/pie-calculator-geogebra": "1.0.0-beta.3",
-		"@pie-players/pie-players-shared": "1.0.0-beta.3",
-		"@pie-players/pie-tool-annotation-toolbar": "1.0.0-beta.3",
-		"@pie-players/pie-tool-answer-eliminator": "1.0.0-beta.3",
-		"@pie-players/pie-tool-calculator-shared": "1.0.0-beta.3",
-		"@pie-players/pie-tool-dictionary": "1.0.0-beta.3",
-		"@pie-players/pie-tool-graph": "1.0.0-beta.3",
-		"@pie-players/pie-tool-line-reader": "1.0.0-beta.3",
-		"@pie-players/pie-tool-periodic-table": "1.0.0-beta.3",
-		"@pie-players/pie-tool-picture-dictionary": "1.0.0-beta.3",
-		"@pie-players/pie-tool-protractor": "1.0.0-beta.3",
-		"@pie-players/pie-tool-ruler": "1.0.0-beta.3",
-		"@pie-players/pie-tool-theme": "1.0.0-beta.3",
-		"@pie-players/pie-tool-tts-inline": "1.0.0-beta.3",
-		"@pie-players/tts-client-server": "1.0.0-beta.3"
+		"@pie-players/pie-assessment-toolkit": "1.0.0-beta.4",
+		"@pie-players/pie-calculator": "1.0.0-beta.4",
+		"@pie-players/pie-calculator-desmos": "1.0.0-beta.4",
+		"@pie-players/pie-calculator-geogebra": "1.0.0-beta.4",
+		"@pie-players/pie-players-shared": "1.0.0-beta.4",
+		"@pie-players/pie-tool-annotation-toolbar": "1.0.0-beta.4",
+		"@pie-players/pie-tool-answer-eliminator": "1.0.0-beta.4",
+		"@pie-players/pie-tool-calculator-shared": "1.0.0-beta.4",
+		"@pie-players/pie-tool-dictionary": "1.0.0-beta.4",
+		"@pie-players/pie-tool-graph": "1.0.0-beta.4",
+		"@pie-players/pie-tool-line-reader": "1.0.0-beta.4",
+		"@pie-players/pie-tool-magnifier": "1.0.0-beta.4",
+		"@pie-players/pie-tool-periodic-table": "1.0.0-beta.4",
+		"@pie-players/pie-tool-picture-dictionary": "1.0.0-beta.4",
+		"@pie-players/pie-tool-protractor": "1.0.0-beta.4",
+		"@pie-players/pie-tool-ruler": "1.0.0-beta.4",
+		"@pie-players/pie-tool-theme": "1.0.0-beta.4",
+		"@pie-players/pie-tool-tts-inline": "1.0.0-beta.4",
+		"@pie-players/tts-client-server": "1.0.0-beta.4"
 	},
 	"devDependencies": {
 		"@biomejs/biome": "^2.5.15",

package/dist/calculator-providers/CortexToolProvider.d.ts

@@ -1,10 +0,0 @@
-/** Fully bundled open-source calculator adapter for the tool-provider registry. */
-import type { CalculatorToolProviderInitConfig, LazyCalculatorProviderDefinition } from "./LazyCalculatorToolProvider.js";
-import { LazyCalculatorToolProvider } from "./LazyCalculatorToolProvider.js";
-export type CortexToolProviderConfig = CalculatorToolProviderInitConfig;
-export declare class CortexToolProvider extends LazyCalculatorToolProvider<CortexToolProviderConfig> {
-    readonly providerName = "PIE Open-Source Calculator";
-    readonly version = "1";
-    readonly requiresAuth = false;
-    protected getDefinition(): LazyCalculatorProviderDefinition<CortexToolProviderConfig>;
-}

package/dist/calculator-providers/CortexToolProvider.js

@@ -1,18 +0,0 @@
-/** Fully bundled open-source calculator adapter for the tool-provider registry. */
-import { LazyCalculatorToolProvider } from "./LazyCalculatorToolProvider.js";
-export class CortexToolProvider extends LazyCalculatorToolProvider {
-    providerName = "PIE Open-Source Calculator";
-    version = "1";
-    requiresAuth = false;
-    getDefinition() {
-        return {
-            backend: "cortex",
-            moduleImportOperation: "cortex-provider-module-import",
-            loadProvider: async () => {
-                const module = await import("@pie-players/pie-calculator-cortex");
-                return module.CortexCalculatorProvider;
-            },
-            initializationErrorMessage: "Failed to initialize the PIE open-source calculator provider. Confirm that this browser supports module workers and that the bundled worker assets are available.",
-        };
-    }
-}

package/dist/calculator-providers/DesmosToolProvider.d.ts

@@ -1,11 +0,0 @@
-/** Desmos calculator adapter for the generic tool-provider registry. */
-import type { CalculatorProviderInit } from "@pie-players/pie-calculator";
-import { LazyCalculatorToolProvider, type LazyCalculatorProviderDefinition } from "./LazyCalculatorToolProvider.js";
-/** Provider initialization is the provider-neutral calculator contract. */
-export type DesmosToolProviderConfig = CalculatorProviderInit;
-export declare class DesmosToolProvider extends LazyCalculatorToolProvider<DesmosToolProviderConfig> {
-    readonly providerName = "Desmos Calculator";
-    readonly version = "1.12";
-    readonly requiresAuth = true;
-    protected getDefinition(): LazyCalculatorProviderDefinition<DesmosToolProviderConfig>;
-}

package/dist/calculator-providers/DesmosToolProvider.js

@@ -1,18 +0,0 @@
-/** Desmos calculator adapter for the generic tool-provider registry. */
-import { LazyCalculatorToolProvider, } from "./LazyCalculatorToolProvider.js";
-export class DesmosToolProvider extends LazyCalculatorToolProvider {
-    providerName = "Desmos Calculator";
-    version = "1.12";
-    requiresAuth = true;
-    getDefinition() {
-        return {
-            backend: "desmos",
-            moduleImportOperation: "desmos-provider-module-import",
-            loadProvider: async () => {
-                const module = await import("@pie-players/pie-calculator-desmos");
-                return module.DesmosCalculatorProvider;
-            },
-            initializationErrorMessage: "Failed to initialize Desmos calculator provider. Check the application key, preloaded API, runtime endpoint, or network access.",
-        };
-    }
-}

package/dist/calculator-providers/GeoGebraToolProvider.d.ts

@@ -1,13 +0,0 @@
-/** GeoGebra calculator adapter for the generic tool-provider registry. */
-import type { CalculatorToolProviderInitConfig, LazyCalculatorProviderDefinition } from "./LazyCalculatorToolProvider.js";
-import { LazyCalculatorToolProvider } from "./LazyCalculatorToolProvider.js";
-export interface GeoGebraToolProviderConfig extends CalculatorToolProviderInitConfig {
-    scriptUrl?: string;
-    appletTimeoutMs?: number;
-}
-export declare class GeoGebraToolProvider extends LazyCalculatorToolProvider<GeoGebraToolProviderConfig> {
-    readonly providerName = "GeoGebra Calculator";
-    readonly version = "6";
-    readonly requiresAuth = false;
-    protected getDefinition(): LazyCalculatorProviderDefinition<GeoGebraToolProviderConfig>;
-}

package/dist/calculator-providers/GeoGebraToolProvider.js

@@ -1,18 +0,0 @@
-/** GeoGebra calculator adapter for the generic tool-provider registry. */
-import { LazyCalculatorToolProvider } from "./LazyCalculatorToolProvider.js";
-export class GeoGebraToolProvider extends LazyCalculatorToolProvider {
-    providerName = "GeoGebra Calculator";
-    version = "6";
-    requiresAuth = false;
-    getDefinition() {
-        return {
-            backend: "geogebra",
-            moduleImportOperation: "geogebra-provider-module-import",
-            loadProvider: async () => {
-                const module = await import("@pie-players/pie-calculator-geogebra");
-                return module.GeoGebraCalculatorProvider;
-            },
-            initializationErrorMessage: "Failed to initialize GeoGebra calculator provider. Confirm that the deployment may load GeoGebra and that its script URL is reachable.",
-        };
-    }
-}