@pie-players/pie-default-tool-loaders 0.3.73 → 0.3.75

package/README.md

@@ -3,7 +3,8 @@
 Composition layer for the packaged PIE assessment tools: which capabilities exist
 in a deployment, and how a program tiers them.
 
-It owns the concrete `pie-tool-*` dependencies so toolkit core can stay
+It owns the concrete `pie-tool-*` dependencies and the calculator engines
+(`pie-calculator-cortex`, `-desmos` and `-geogebra`) so toolkit core can stay
 dependency-light and cycle-safe, and it is the layer above core — core knows
 `featureId`, placement levels, activation kinds and precedence rules, and knows
 no capability ids.
@@ -13,30 +14,29 @@ and how does the program tier them":
 
 | Export | What it decides |
 | --- | --- |
-| `PACKAGED_TOOL_REGISTRATIONS`, `createPackagedToolRegistry`, `registerPackagedTools` | Which capabilities exist, and their toolbar and surface contracts |
+| `PACKAGED_TOOL_REGISTRATIONS`, `createPackagedToolRegistry` | Which capabilities exist, and their toolbar and surface contracts |
 | `PACKAGED_TOOL_TAG_MAP` | Which custom element each one renders as |
-| `PACKAGED_TOOL_PLACEMENT`, `SECTION_PLAYER_PREFERRED_TOOL_PLACEMENT`, `PACKAGED_TOOL_ORDER` | Where they appear and in what order |
-| `UNIVERSAL_SUPPORTS_PRESET`, `createUniversalPersonalNeedsProfile` | Which of their support ids the program grants to everyone |
-| `DEFAULT_TOOL_MODULE_LOADERS`, `createDefaultToolModuleLoaders`, `registerSectionToolModuleLoaders` | When each one's bundle loads |
+| `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 |
+| `DEFAULT_TOOL_MODULE_LOADERS` | When each one's bundle loads |
 
 The individual registrations are exported too, so a host can compose its own set
 rather than take the packaged one whole.
 
 These exports are projections of one internal **Packaged Capability
 Composition**. Each packaged capability is authored once with its registration,
-element delivery, loader bootstrap sets, placement/order membership and explicit
+element delivery, module loader, preferred placement and explicit
 universal-support policy. The package build rejects contradictory PIE-owned data
-— for example, a region capability with a toolbar tag, or a universal support
-id its registration does not declare — so release tests find a missing facet
+— for example, a region capability with a toolbar tag, or a content-dependent
+capability marked universal — so release tests find a missing facet
 instead of a learner finding a dead affordance. The browser does not repeat that
 strict gate at import time: a PIE authoring defect must block publication, not an
 otherwise usable assessment.
 
-That invariant boundary does not make host input stricter. The existing public
-factory and constants are unchanged: lazy module loading remains opt-in,
-registration/tag/factory overrides retain precedence, an empty `toolIds` array
-still selects the full packaged set, and unknown selected ids are ignored while
-known ids continue to register.
+That invariant boundary does not make host input stricter: lazy module loading
+is opt-in, registration/tag/factory overrides take precedence, an empty
+`toolIds` array selects the full packaged set, and unknown selected ids are
+ignored while known ids register.
 
 ## Usage
 
@@ -52,35 +52,27 @@ const registry = createPackagedToolRegistry({
 });
 ```
 
-Desmos remains the calculator delivery when no provider is configured. To use
-GeoGebra or the fully bundled open-source Cortex implementation, pass the same
-calculator configuration to both the toolkit and the
-packaged composition. The composition then owns the matching element tag and
-module loader; hosts do not hand-maintain a second vendor map.
+One loader set serves every host shape. `DEFAULT_TOOL_MODULE_LOADERS` holds a
+loader per packaged capability, and a registry loads a module only when a tool
+first renders, so an item player, a section player and an assessment player
+pass the same set and load only the tools they place.
 
-```ts
-import {
-	createDefaultToolModuleLoaders,
-	createPackagedToolRegistry,
-} from "@pie-players/pie-default-tool-loaders";
-
-const calculatorProviderConfig = {
-	provider: {
-		id: "calculator-geogebra",
-		init: { appletTimeoutMs: 20_000 },
-	},
-	settings: { showResetIcon: true },
-};
-
-const registry = createPackagedToolRegistry({
-	calculatorProviderConfig,
-	toolModuleLoaders: createDefaultToolModuleLoaders({
-		calculatorProviderConfig,
-	}),
-});
+The calculator is one element, `<pie-tool-calculator>`, for every provider.
+Desmos is the provider when none is configured; the toolkit picks another from
+`tools.providers.calculator` when the element mounts, and an open calculator
+remounts on the new provider when a tool-config update replaces it.
 
+```ts
 const tools = {
-	providers: { calculator: calculatorProviderConfig },
+	providers: {
+		calculator: {
+			provider: {
+				id: "calculator-geogebra",
+				init: { appletTimeoutMs: 20_000 },
+			},
+			settings: { showResetIcon: true },
+		},
+	},
 };
 ```
 
@@ -89,32 +81,38 @@ For an offline-capable calculator with no API key or runtime CDN, use
 history, evaluation limit, allowed functions, clipboard policy, and graph
 viewport options documented by `@pie-players/pie-calculator-cortex`.
 
-`createDefaultToolRegistry()` in the toolkit is the other end of that choice: it
-builds an empty registry, and a host composing its own set registers into it.
+A host composing its own set starts from the toolkit's empty `ToolRegistry`,
+registers into it, and installs the tag map its registrations create elements
+from.
 
 ```ts
-import { createDefaultToolRegistry } from "@pie-players/pie-assessment-toolkit";
+import { ToolRegistry } from "@pie-players/pie-assessment-toolkit";
 import {
 	calculatorToolRegistration,
-	registerSectionToolModuleLoaders,
+	DEFAULT_TOOL_MODULE_LOADERS,
+	PACKAGED_TOOL_TAG_MAP,
 	ttsToolRegistration,
 } from "@pie-players/pie-default-tool-loaders";
 
-const registry = createDefaultToolRegistry({
-	registrations: [calculatorToolRegistration, ttsToolRegistration],
-});
-// Section-only loaders, for section toolbar bootstrap points.
-registerSectionToolModuleLoaders(registry);
+const registry = new ToolRegistry();
+registry.register(calculatorToolRegistration);
+registry.register(ttsToolRegistration);
+registry.setComponentOverrides({ toolTagMap: PACKAGED_TOOL_TAG_MAP });
+registry.setToolModuleLoaders(DEFAULT_TOOL_MODULE_LOADERS);
 ```
 
+A later `setToolModuleLoaders` call adds or replaces entries. A replacement
+registered after a tool's module has loaded is ignored with a warning, since the
+elements it defines are already in place.
+
 ## Content-dependent capabilities require an explicit packaging decision
 
-A content-dependent capability is never inferred into
-`UNIVERSAL_SUPPORTS_PRESET`. It may ship in `PACKAGED_TOOL_REGISTRATIONS` only
+A content-dependent capability is never granted by
+`createUniversalPersonalNeedsProfile()`. It may ship in `PACKAGED_TOOL_REGISTRATIONS` only
 when it has a useful presentation path without a grant and declares
 `resolvesWithoutGrant`. Audio transcript is the shipped example: an authored
 `visibility: "always"` transcript reaches every player, while its accommodation
-path remains policy-gated and `transcript` stays out of the universal preset.
+path remains policy-gated and `transcript` stays out of the universal profile.
 
 A content-dependent capability with no presentation path remains an explicit
 deployment choice. Signing is the shipped example: install
@@ -127,11 +125,11 @@ import { signLanguageRegistration } from "@pie-players/pie-tool-sign-language";
 registry.register(signLanguageRegistration);
 ```
 
-## Universal supports preset
+## Universal and empty profiles
 
-`createUniversalPersonalNeedsProfile()` builds a `PersonalNeedsProfile` granting
-`UNIVERSAL_SUPPORTS_PRESET` — the support ids the packaged tool set treats as
-universal features.
+`createUniversalPersonalNeedsProfile()` builds a fresh `PersonalNeedsProfile`
+granting the tool ids of the capabilities the packaged set treats as universal
+features. A support id is the tool id it grants.
 
 ```ts
 import { createUniversalPersonalNeedsProfile } from "@pie-players/pie-default-tool-loaders";
@@ -142,11 +140,11 @@ const section = {
 };
 ```
 
-The core ships no populated default — `createEmptyPersonalNeedsProfile()` in
-`@pie-players/pie-assessment-toolkit` grants nothing. Which capabilities a
+The toolkit ships no populated default, and `createEmptyPersonalNeedsProfile()`
+builds a profile granting nothing. Which capabilities a
 deployment grants by default is a property of the program, not of a capability:
 TTS is a universal feature in one program and a documented accommodation in
-another. So the preset is data to adopt, extend or replace alongside the district
+another. So the universal profile is data to adopt, extend or replace alongside the district
 and test-administration configuration, and it deliberately excludes any
 capability that declares a content dependency.
 

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

@@ -0,0 +1,12 @@
+/** Fully bundled open-source calculator adapter for the tool-provider registry. */
+import type { CalculatorToolProviderInitConfig, LazyCalculatorProviderDefinition } from "./LazyCalculatorToolProvider.js";
+import { LazyCalculatorToolProvider } from "./LazyCalculatorToolProvider.js";
+import type { ToolProviderCapabilities } from "@pie-players/pie-assessment-toolkit/tools/registration";
+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>;
+    getCapabilities(): ToolProviderCapabilities;
+}

package/dist/calculator-providers/CortexToolProvider.js

@@ -0,0 +1,31 @@
+/** 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.",
+        };
+    }
+    getCapabilities() {
+        return {
+            supportsOffline: true,
+            requiresAuth: false,
+            maxInstances: null,
+            features: {
+                basic: true,
+                scientific: true,
+                graphing: true,
+                fourFunction: true,
+            },
+        };
+    }
+}

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

@@ -0,0 +1,13 @@
+/** Desmos calculator adapter for the generic tool-provider registry. */
+import type { CalculatorProviderInit } from "@pie-players/pie-calculator";
+import { LazyCalculatorToolProvider, type LazyCalculatorProviderDefinition } from "./LazyCalculatorToolProvider.js";
+import type { ToolProviderCapabilities } from "@pie-players/pie-assessment-toolkit/tools/registration";
+/** 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>;
+    getCapabilities(): ToolProviderCapabilities;
+}

package/dist/calculator-providers/DesmosToolProvider.js

@@ -0,0 +1,31 @@
+/** 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.",
+        };
+    }
+    getCapabilities() {
+        return {
+            supportsOffline: false,
+            requiresAuth: true,
+            maxInstances: null,
+            features: {
+                basic: true,
+                scientific: true,
+                graphing: true,
+                fourFunction: true,
+            },
+        };
+    }
+}

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

@@ -0,0 +1,15 @@
+/** GeoGebra calculator adapter for the generic tool-provider registry. */
+import type { CalculatorToolProviderInitConfig, LazyCalculatorProviderDefinition } from "./LazyCalculatorToolProvider.js";
+import { LazyCalculatorToolProvider } from "./LazyCalculatorToolProvider.js";
+import type { ToolProviderCapabilities } from "@pie-players/pie-assessment-toolkit/tools/registration";
+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>;
+    getCapabilities(): ToolProviderCapabilities;
+}

package/dist/calculator-providers/GeoGebraToolProvider.js

@@ -0,0 +1,31 @@
+/** 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.",
+        };
+    }
+    getCapabilities() {
+        return {
+            supportsOffline: false,
+            requiresAuth: false,
+            maxInstances: null,
+            features: {
+                basic: true,
+                scientific: true,
+                graphing: true,
+                fourFunction: false,
+            },
+        };
+    }
+}

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

@@ -0,0 +1,34 @@
+import type { CalculatorProvider, CalculatorProviderInit } from "@pie-players/pie-calculator";
+import type { ToolProviderApi, ToolProviderCapabilities } 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;
+}
+/**
+ * Shared lazy-module and lifecycle implementation for calculator tool adapters.
+ * Concrete adapters own only their metadata, capabilities and provider import.
+ */
+export declare abstract class LazyCalculatorToolProvider<TConfig extends CalculatorToolProviderInitConfig> implements ToolProviderApi<CalculatorProvider> {
+    abstract readonly providerName: string;
+    readonly category: "calculator";
+    abstract readonly version: string;
+    abstract readonly requiresAuth: boolean;
+    protected abstract getDefinition(): LazyCalculatorProviderDefinition<TConfig>;
+    abstract getCapabilities(): ToolProviderCapabilities;
+    private calculatorProvider;
+    private initializationPromise;
+    private lifecycleGeneration;
+    private emitTelemetry;
+    initialize(config?: TConfig): Promise<void>;
+    private initializeProvider;
+    createInstance(): Promise<CalculatorProvider>;
+    isReady(): boolean;
+    destroy(): void;
+}
+export {};

package/dist/calculator-providers/LazyCalculatorToolProvider.js

@@ -0,0 +1,95 @@
+/**
+ * Shared lazy-module and lifecycle implementation for calculator tool adapters.
+ * Concrete adapters own only their metadata, capabilities and provider import.
+ */
+export class LazyCalculatorToolProvider {
+    category = "calculator";
+    calculatorProvider = null;
+    initializationPromise = null;
+    lifecycleGeneration = 0;
+    async emitTelemetry(config, eventName, payload) {
+        try {
+            await config.onTelemetry?.(eventName, payload);
+        }
+        catch (error) {
+            console.warn(`[${this.providerName}] telemetry callback failed:`, error);
+        }
+    }
+    async initialize(config = {}) {
+        if (this.calculatorProvider)
+            return;
+        if (this.initializationPromise)
+            return this.initializationPromise;
+        const generation = ++this.lifecycleGeneration;
+        const initializationPromise = this.initializeProvider(config, generation);
+        this.initializationPromise = initializationPromise;
+        try {
+            await initializationPromise;
+        }
+        finally {
+            if (this.initializationPromise === initializationPromise) {
+                this.initializationPromise = null;
+            }
+        }
+    }
+    async initializeProvider(config, generation) {
+        const definition = this.getDefinition();
+        const moduleLoadStartedAt = Date.now();
+        await this.emitTelemetry(config, "pie-tool-library-load-start", {
+            toolId: "calculator",
+            operation: definition.moduleImportOperation,
+            backend: definition.backend,
+        });
+        let ProviderConstructor;
+        try {
+            ProviderConstructor = await definition.loadProvider();
+            await this.emitTelemetry(config, "pie-tool-library-load-success", {
+                toolId: "calculator",
+                operation: definition.moduleImportOperation,
+                backend: definition.backend,
+                duration: Date.now() - moduleLoadStartedAt,
+            });
+        }
+        catch (error) {
+            await this.emitTelemetry(config, "pie-tool-library-load-error", {
+                toolId: "calculator",
+                operation: definition.moduleImportOperation,
+                backend: definition.backend,
+                duration: Date.now() - moduleLoadStartedAt,
+                errorType: "ToolLibraryLoadError",
+                message: error instanceof Error ? error.message : String(error),
+            });
+            throw new Error(definition.initializationErrorMessage, { cause: error });
+        }
+        if (generation !== this.lifecycleGeneration) {
+            throw new Error(`${this.providerName} initialization was cancelled`);
+        }
+        const candidate = new ProviderConstructor();
+        try {
+            await candidate.initialize(config);
+            if (generation !== this.lifecycleGeneration) {
+                throw new Error(`${this.providerName} initialization was cancelled`);
+            }
+            this.calculatorProvider = candidate;
+        }
+        catch (error) {
+            candidate.destroy();
+            throw new Error(definition.initializationErrorMessage, { cause: error });
+        }
+    }
+    async createInstance() {
+        if (!this.calculatorProvider) {
+            throw new Error(`[${this.providerName}] Provider not initialized. Call initialize() first.`);
+        }
+        return this.calculatorProvider;
+    }
+    isReady() {
+        return this.calculatorProvider !== null;
+    }
+    destroy() {
+        this.lifecycleGeneration += 1;
+        this.initializationPromise = null;
+        this.calculatorProvider?.destroy();
+        this.calculatorProvider = null;
+    }
+}

package/dist/content-alternates.d.ts

@@ -16,5 +16,5 @@
  * `tests/content-alternates.test.ts` pins this against the composition set in both
  * directions, so a capability added there cannot quietly fail to reach print.
  */
-import type { ToolRegistration } from "@pie-players/pie-assessment-toolkit/tools/internal";
+import type { ToolRegistration } from "@pie-players/pie-assessment-toolkit/tools/registration";
 export declare const CONTENT_ALTERNATE_REGISTRATIONS: readonly ToolRegistration[];

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export type { PackagedCalculatorCompositionOptions, PackagedToolRegistryOptions, RegisterDefaultToolModuleLoadersOptions, RegisterPackagedToolsOptions, ToolModuleLoader, ToolRegistryLike, } from "./packaged-capability-composition.js";
-export { createPackagedToolRegistry, createDefaultToolModuleLoaders, createSectionToolModuleLoaders, createUniversalPersonalNeedsProfile, DEFAULT_TOOL_MODULE_LOADERS, ITEM_TOOL_MODULE_LOADERS, PACKAGED_TOOL_ORDER, PACKAGED_TOOL_PLACEMENT, PACKAGED_TOOL_REGISTRATIONS, PACKAGED_TOOL_TAG_MAP, registerDefaultToolModuleLoaders, registerPackagedTools, registerSectionToolModuleLoaders, SECTION_PLAYER_PREFERRED_TOOL_PLACEMENT, SECTION_TOOL_MODULE_LOADERS, UNIVERSAL_SUPPORTS_PRESET, } from "./packaged-capability-composition.js";
+export 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 { CONTENT_ALTERNATE_REGISTRATIONS } from "./content-alternates.js";
 export { annotationToolbarRegistration, lineReaderToolRegistration, themeToolRegistration, } from "./registrations/accessibility-tools.js";
 export { AUDIO_TRANSCRIPT_FEATURE_ID, AUDIO_TRANSCRIPT_REGION_CLASS, AUDIO_TRANSCRIPT_REGION_LABEL, audioTranscriptRegistration, resolveAudioTranscript, type ResolvedAudioTranscript, } from "./registrations/audio-transcript.js";

package/dist/index.js

@@ -1,4 +1,4 @@
-export { createPackagedToolRegistry, createDefaultToolModuleLoaders, createSectionToolModuleLoaders, createUniversalPersonalNeedsProfile, DEFAULT_TOOL_MODULE_LOADERS, ITEM_TOOL_MODULE_LOADERS, PACKAGED_TOOL_ORDER, PACKAGED_TOOL_PLACEMENT, PACKAGED_TOOL_REGISTRATIONS, PACKAGED_TOOL_TAG_MAP, registerDefaultToolModuleLoaders, registerPackagedTools, registerSectionToolModuleLoaders, SECTION_PLAYER_PREFERRED_TOOL_PLACEMENT, SECTION_TOOL_MODULE_LOADERS, UNIVERSAL_SUPPORTS_PRESET, } from "./packaged-capability-composition.js";
+export { createEmptyPersonalNeedsProfile, createPackagedToolRegistry, createUniversalPersonalNeedsProfile, DEFAULT_TOOL_MODULE_LOADERS, PACKAGED_TOOL_REGISTRATIONS, PACKAGED_TOOL_TAG_MAP, SECTION_PLAYER_PREFERRED_TOOL_PLACEMENT, } from "./packaged-capability-composition.js";
 // The authored-alternate subset, for a renderer that shows alternates and no
 // toolbar — importable without the packaged composition's tool loaders.
 export { CONTENT_ALTERNATE_REGISTRATIONS } from "./content-alternates.js";

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

@@ -2,45 +2,25 @@
  * 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, type ToolComponentFactory, type ToolComponentFactoryMap, type ToolRegistration, type ToolTagMap, type ToolProviderConfig } from "@pie-players/pie-assessment-toolkit/tools/internal";
+import { ToolRegistry, type ToolComponentFactoryMap, type ToolModuleLoader, type ToolRegistration, type ToolTagMap } from "@pie-players/pie-assessment-toolkit/tools/registration";
 import type { PersonalNeedsProfile } from "@pie-players/pie-players-shared/types";
-export type ToolModuleLoader = () => Promise<unknown>;
-export interface ToolRegistryLike {
-    setToolModuleLoaders(loaders: Partial<Record<string, ToolModuleLoader>>): void;
-}
-export interface PackagedCalculatorCompositionOptions {
-    /**
-     * The same calculator config supplied at `tools.providers.calculator`.
-     * Selects the matching packaged element and default loader. Omit it to retain
-     * the existing Desmos delivery.
-     */
-    calculatorProviderConfig?: ToolProviderConfig;
-}
-export interface PackagedToolRegistryOptions extends PackagedCalculatorCompositionOptions {
+export interface PackagedToolRegistryOptions {
     /** Override packaged registrations by toolId. */
     overrides?: Partial<Record<string, ToolRegistration>>;
     /** Override or extend the packaged element tag mapping. */
     toolTagMap?: Partial<ToolTagMap>;
-    /** Override the component factory globally or per tool. */
-    toolComponentFactory?: ToolComponentFactory;
+    /** Override the component factory per tool. */
     toolComponentFactories?: Partial<ToolComponentFactoryMap>;
     /** Lazy module loaders keyed by toolId. */
     toolModuleLoaders?: Partial<Record<string, ToolModuleLoader>>;
     /** Restrict registration to specific packaged tool ids. */
     toolIds?: string[];
 }
-export interface RegisterPackagedToolsOptions {
-    toolIds?: string[];
-    applyOverrides?: (registration: ToolRegistration) => ToolRegistration;
-}
-export interface RegisterDefaultToolModuleLoadersOptions extends PackagedCalculatorCompositionOptions {
-    loaders?: Partial<Record<string, ToolModuleLoader>>;
-}
 /**
  * Release/build gate for PIE-authored composition data.
  *
@@ -49,37 +29,25 @@ export interface RegisterDefaultToolModuleLoadersOptions extends PackagedCalcula
  * that prevents an otherwise usable assessment from rendering.
  */
 export declare function assertPackagedCapabilityComposition(): void;
-export declare const PACKAGED_TOOL_REGISTRATIONS: readonly [ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration, ToolRegistration];
+export declare const PACKAGED_TOOL_REGISTRATIONS: readonly ToolRegistration[];
 export declare const PACKAGED_TOOL_TAG_MAP: ToolTagMap;
-export declare const ITEM_TOOL_MODULE_LOADERS: Record<string, ToolModuleLoader>;
-export declare const SECTION_TOOL_MODULE_LOADERS: Record<string, ToolModuleLoader>;
 export declare const DEFAULT_TOOL_MODULE_LOADERS: Record<string, ToolModuleLoader>;
-/** Build the packaged loader map for a selected calculator provider. */
-export declare function createDefaultToolModuleLoaders(options?: PackagedCalculatorCompositionOptions): Record<string, ToolModuleLoader>;
-/** Build the section-bootstrap loader subset for a selected calculator provider. */
-export declare function createSectionToolModuleLoaders(options?: PackagedCalculatorCompositionOptions): Record<string, ToolModuleLoader>;
-export declare const PACKAGED_TOOL_PLACEMENT: {
-    readonly assessment: readonly ["theme"];
-    readonly section: readonly ["theme"];
-    readonly item: readonly ["textToSpeech", "annotationToolbar", "graph", "periodicTable", "dictionary", "pictureDictionary", "dictionarySpanish", "pictureDictionarySpanish"];
-    readonly passage: readonly ["textToSpeech", "annotationToolbar", "lineReader"];
-    readonly rubric: readonly ["textToSpeech", "annotationToolbar", "lineReader"];
-    readonly element: readonly ["calculator", "answerEliminator", "textToSpeech", "ruler", "protractor", "annotationToolbar", "graph", "periodicTable", "dictionary", "pictureDictionary", "dictionarySpanish", "pictureDictionarySpanish"];
-};
 export declare const SECTION_PLAYER_PREFERRED_TOOL_PLACEMENT: {
     section: string[];
     item: string[];
     passage: string[];
 };
-export declare const PACKAGED_TOOL_ORDER: readonly ["theme", "calculator", "textToSpeech", "lineReader", "annotationToolbar", "answerEliminator", "ruler", "protractor", "graph", "periodicTable", "dictionary", "pictureDictionary", "dictionarySpanish", "pictureDictionarySpanish"];
-export declare const UNIVERSAL_SUPPORTS_PRESET: readonly string[];
-/** Register packaged PIE capabilities onto an existing registry. */
-export declare function registerPackagedTools(registry: ToolRegistry, options?: RegisterPackagedToolsOptions): void;
 /** Create a registry holding the packaged PIE capabilities. */
 export declare function createPackagedToolRegistry(options?: PackagedToolRegistryOptions): ToolRegistry;
-/** 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 declare function createUniversalPersonalNeedsProfile(): PersonalNeedsProfile;
-/** Register packaged lazy module loaders, followed by host overrides. */
-export declare function registerDefaultToolModuleLoaders(registry: ToolRegistryLike, options?: RegisterDefaultToolModuleLoadersOptions): void;
-/** Register only the section-bootstrap loader subset, then host overrides. */
-export declare function registerSectionToolModuleLoaders(registry: ToolRegistryLike, options?: RegisterDefaultToolModuleLoadersOptions): void;
+/**
+ * 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 declare function createEmptyPersonalNeedsProfile(): PersonalNeedsProfile;