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

package/README.md

@@ -1,105 +1,98 @@
 # PIE Default Tool Loaders
 
-Composition layer for the packaged PIE assessment tools: which capabilities exist
-in a deployment, and how a program tiers them.
+The packaged PIE assessment tools: which capabilities exist in a deployment, how
+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.
 
-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.
-
-It owns five things, all answers to "which capabilities does this deployment have
-and how does the program tier them":
+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,
+placement levels, activation kinds and precedence rules — and no concrete
+capability id. A support id is the tool id a profile grants.
 
 | 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 |
-
-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
-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
-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.
+| `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 |
+| `CONTENT_ALTERNATE_REGISTRATIONS` | Which of them carry an authored alternate that renders as a region; the print player mounts these |
+
+The individual registrations are exported too, so a host can compose its own
+set ([Custom sets](#custom-sets)).
 
 ## Usage
 
 ```ts
-import {
-	createPackagedToolRegistry,
-	DEFAULT_TOOL_MODULE_LOADERS,
-} from "@pie-players/pie-default-tool-loaders";
+import { createPackagedToolRegistry } from "@pie-players/pie-default-tool-loaders";
 
 // The packaged capability set, lazily loaded.
-const registry = createPackagedToolRegistry({
-	toolModuleLoaders: DEFAULT_TOOL_MODULE_LOADERS,
-});
+const registry = createPackagedToolRegistry();
+
+// The same registrations for a host that defines the tool elements itself.
+const preloaded = createPackagedToolRegistry({ toolModuleLoaders: {} });
 ```
 
-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 is what `createPackagedToolRegistry`
+installs unless `toolModuleLoaders` replaces it. A registry loads a module only
+when a tool first renders, so an item player, a section player and an
+assessment player share the set and load only the tools they place.
+
+`createPackagedToolRegistry` is lenient with host input. Registration, tag-map
+and component-factory overrides take precedence over the packaged data. An
+empty `toolIds` array selects the full packaged set, and unknown ids in it are
+ignored while the known ones register.
+
+## Calculator providers
+
+The calculator is one element, `<pie-tool-calculator>`, for every provider. The
+toolkit picks the provider from `tools.providers.calculator` when the element
+mounts, and an open calculator remounts on the new provider when a tool-config
+update replaces it.
+
+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.
 
 ```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,
-	}),
-});
-
 const tools = {
-	providers: { calculator: calculatorProviderConfig },
+	providers: {
+		calculator: {
+			provider: {
+				id: "calculator-geogebra",
+				init: { appletTimeoutMs: 20_000 },
+			},
+			settings: { showResetIcon: true },
+		},
+	},
 };
 ```
 
-For an offline-capable calculator with no API key or runtime CDN, use
-`provider.id: "calculator-cortex"`. Its `settings` accept angle mode, precision,
-history, evaluation limit, allowed functions, clipboard policy, and graph
-viewport options documented by `@pie-players/pie-calculator-cortex`.
+## Custom sets
 
-The toolkit's `ToolRegistry` is the other end of that choice: it starts empty,
-and a host composing its own set registers into it and installs the tag map its
-registrations create elements from.
+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 { ToolRegistry } from "@pie-players/pie-assessment-toolkit";
 import {
 	calculatorToolRegistration,
+	DEFAULT_TOOL_MODULE_LOADERS,
 	PACKAGED_TOOL_TAG_MAP,
-	registerDefaultToolModuleLoaders,
 	ttsToolRegistration,
 } from "@pie-players/pie-default-tool-loaders";
 
@@ -107,27 +100,28 @@ const registry = new ToolRegistry();
 registry.register(calculatorToolRegistration);
 registry.register(ttsToolRegistration);
 registry.setComponentOverrides({ toolTagMap: PACKAGED_TOOL_TAG_MAP });
-registerDefaultToolModuleLoaders(registry);
+registry.setToolModuleLoaders(DEFAULT_TOOL_MODULE_LOADERS);
 ```
 
-`registerDefaultToolModuleLoaders` installs a loader for every packaged tool.
-`registerSectionToolModuleLoaders` installs only the section-bootstrap subset,
-which has no text-to-speech loader, so a registry that places item-level text to
-speech needs the full set.
+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
+## Content-dependent capabilities
 
-A content-dependent capability is never inferred into
-`UNIVERSAL_SUPPORTS_PRESET`. 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.
+A content-dependent capability declares `requiresAuthoredContent`: it renders
+only where the content carries what it needs, and
+`createUniversalPersonalNeedsProfile()` never grants one. It ships 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 stays 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
-`@pie-players/pie-tool-sign-language` and register it, which is the same two
-lines a host writes for a capability of its own.
+A content-dependent capability with no such path is an explicit deployment
+choice. Signing is the shipped example: install
+`@pie-players/pie-tool-sign-language` and register it, the same two lines a
+host writes for a capability of its own.
 
 ```ts
 import { signLanguageRegistration } from "@pie-players/pie-tool-sign-language";
@@ -135,29 +129,44 @@ 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. Tool policy reads the profile from the assessment entity, so set it
+there: on the player's `assessment` property, or through
+`coordinator.updateAssessment(...)` on a coordinator you pass. A
+`section.personalNeedsProfile` is ignored with a console warning.
 
 ```ts
 import { createUniversalPersonalNeedsProfile } from "@pie-players/pie-default-tool-loaders";
 
-const section = {
-	...authoredSection,
+sectionPlayer.assessment = {
+	...authoredAssessment,
 	personalNeedsProfile: createUniversalPersonalNeedsProfile(),
 };
 ```
 
-The core ships no populated default — `createEmptyPersonalNeedsProfile()` in
-`@pie-players/pie-assessment-toolkit` grants 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
-and test-administration configuration, and it deliberately excludes any
-capability that declares a content dependency.
-
-A section carrying no profile is left alone. `pnpEnforcement` auto-detection
-engages on real host policy material, so supplying no profile means placement
-alone decides which tools appear.
+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: TTS is a universal feature in one program
+and a documented accommodation in another. The universal profile is data to
+adopt, extend or replace alongside the district and test-administration
+configuration, and it excludes every capability that declares a content
+dependency.
+
+An assessment carrying no profile is left alone. `pnpEnforcement`
+auto-detection engages only on host policy material, so with no profile,
+placement alone decides which tools appear.
+
+## Packaged capability composition
+
+The exports are projections of one internal composition. Each packaged
+capability is authored once with its registration, element delivery, module
+loader, preferred placement and explicit universal-support flag.
+
+The package build rejects contradictory PIE-owned data, such as a region
+capability with a toolbar tag or a content-dependent capability marked
+universal, so release tests catch a missing facet before it ships. The browser
+skips that strict check at import time: a PIE authoring defect blocks
+publication and never an otherwise usable assessment.

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

@@ -1,13 +1,10 @@
 /** 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/internal";
 export type CortexToolProviderConfig = CalculatorToolProviderInitConfig;
 export declare class CortexToolProvider extends LazyCalculatorToolProvider<CortexToolProviderConfig> {
-    readonly providerId = "cortex-calculator";
     readonly providerName = "PIE Open-Source Calculator";
     readonly version = "1";
     readonly requiresAuth = false;
     protected getDefinition(): LazyCalculatorProviderDefinition<CortexToolProviderConfig>;
-    getCapabilities(): ToolProviderCapabilities;
 }

package/dist/calculator-providers/CortexToolProvider.js

@@ -1,7 +1,6 @@
 /** Fully bundled open-source calculator adapter for the tool-provider registry. */
 import { LazyCalculatorToolProvider } from "./LazyCalculatorToolProvider.js";
 export class CortexToolProvider extends LazyCalculatorToolProvider {
-    providerId = "cortex-calculator";
     providerName = "PIE Open-Source Calculator";
     version = "1";
     requiresAuth = false;
@@ -16,17 +15,4 @@ export class CortexToolProvider extends LazyCalculatorToolProvider {
             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

@@ -1,14 +1,11 @@
 /** 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/internal";
 /** Provider initialization is the provider-neutral calculator contract. */
 export type DesmosToolProviderConfig = CalculatorProviderInit;
 export declare class DesmosToolProvider extends LazyCalculatorToolProvider<DesmosToolProviderConfig> {
-    readonly providerId = "desmos-calculator";
     readonly providerName = "Desmos Calculator";
     readonly version = "1.12";
     readonly requiresAuth = true;
     protected getDefinition(): LazyCalculatorProviderDefinition<DesmosToolProviderConfig>;
-    getCapabilities(): ToolProviderCapabilities;
 }

package/dist/calculator-providers/DesmosToolProvider.js

@@ -1,7 +1,6 @@
 /** Desmos calculator adapter for the generic tool-provider registry. */
 import { LazyCalculatorToolProvider, } from "./LazyCalculatorToolProvider.js";
 export class DesmosToolProvider extends LazyCalculatorToolProvider {
-    providerId = "desmos-calculator";
     providerName = "Desmos Calculator";
     version = "1.12";
     requiresAuth = true;
@@ -16,17 +15,4 @@ export class DesmosToolProvider extends LazyCalculatorToolProvider {
             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

@@ -1,16 +1,13 @@
 /** 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/internal";
 export interface GeoGebraToolProviderConfig extends CalculatorToolProviderInitConfig {
     scriptUrl?: string;
     appletTimeoutMs?: number;
 }
 export declare class GeoGebraToolProvider extends LazyCalculatorToolProvider<GeoGebraToolProviderConfig> {
-    readonly providerId = "geogebra-calculator";
     readonly providerName = "GeoGebra Calculator";
     readonly version = "6";
     readonly requiresAuth = false;
     protected getDefinition(): LazyCalculatorProviderDefinition<GeoGebraToolProviderConfig>;
-    getCapabilities(): ToolProviderCapabilities;
 }

package/dist/calculator-providers/GeoGebraToolProvider.js

@@ -1,7 +1,6 @@
 /** GeoGebra calculator adapter for the generic tool-provider registry. */
 import { LazyCalculatorToolProvider } from "./LazyCalculatorToolProvider.js";
 export class GeoGebraToolProvider extends LazyCalculatorToolProvider {
-    providerId = "geogebra-calculator";
     providerName = "GeoGebra Calculator";
     version = "6";
     requiresAuth = false;
@@ -16,17 +15,4 @@ export class GeoGebraToolProvider extends LazyCalculatorToolProvider {
             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

@@ -1,5 +1,5 @@
 import type { CalculatorProvider, CalculatorProviderInit } from "@pie-players/pie-calculator";
-import type { ToolProviderApi, ToolProviderCapabilities } from "@pie-players/pie-assessment-toolkit/tools/internal";
+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>;
@@ -12,16 +12,14 @@ export interface LazyCalculatorProviderDefinition<TConfig> {
 }
 /**
  * Shared lazy-module and lifecycle implementation for calculator tool adapters.
- * Concrete adapters own only their metadata, capabilities and provider import.
+ * Concrete adapters own only their metadata and provider import.
  */
-export declare abstract class LazyCalculatorToolProvider<TConfig extends CalculatorToolProviderInitConfig> implements ToolProviderApi<TConfig, CalculatorProvider> {
-    abstract readonly providerId: string;
+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;

package/dist/calculator-providers/LazyCalculatorToolProvider.js

@@ -1,6 +1,6 @@
 /**
  * Shared lazy-module and lifecycle implementation for calculator tool adapters.
- * Concrete adapters own only their metadata, capabilities and provider import.
+ * Concrete adapters own only their metadata and provider import.
  */
 export class LazyCalculatorToolProvider {
     category = "calculator";

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,8 +1,8 @@
-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";
+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 { createDictionaryToolRegistration, createPictureDictionaryToolRegistration, dictionaryToolRegistration, type DictionaryVariantOptions, pictureDictionaryToolRegistration, spanishDictionaryToolRegistration, spanishPictureDictionaryToolRegistration, } from "./registrations/dictionary-tools.js";
 export { answerEliminatorToolRegistration } from "./registrations/interaction-tools.js";

package/dist/index.js

@@ -1,11 +1,11 @@
-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";
 // Individual registrations, for a host composing a subset rather than the whole
 // packaged set.
 export { annotationToolbarRegistration, lineReaderToolRegistration, themeToolRegistration, } from "./registrations/accessibility-tools.js";
-export { AUDIO_TRANSCRIPT_FEATURE_ID, AUDIO_TRANSCRIPT_REGION_CLASS, AUDIO_TRANSCRIPT_REGION_LABEL, audioTranscriptRegistration, resolveAudioTranscript, } from "./registrations/audio-transcript.js";
+export { 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 { createDictionaryToolRegistration, createPictureDictionaryToolRegistration, dictionaryToolRegistration, pictureDictionaryToolRegistration, spanishDictionaryToolRegistration, spanishPictureDictionaryToolRegistration, } from "./registrations/dictionary-tools.js";
 export { answerEliminatorToolRegistration } from "./registrations/interaction-tools.js";

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

@@ -2,45 +2,29 @@
  * 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 CalculatorToolProviderConfig, type ToolComponentFactory, type ToolComponentFactoryMap, type ToolRegistration, type ToolTagMap } 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?: CalculatorToolProviderConfig;
-}
-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. */
+    /**
+     * Module loaders keyed by toolId, each loading its tool's element on first
+     * render. Defaults to `DEFAULT_TOOL_MODULE_LOADERS`; a map replaces it, so a
+     * host that defines its tool elements itself passes `{}`.
+     */
     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 +33,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;