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

package/README.md

@@ -14,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
 
@@ -53,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 },
+		},
+	},
 };
 ```
 
@@ -90,16 +81,16 @@ 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`.
 
-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,22 +98,21 @@ 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
 
-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
@@ -135,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";
@@ -150,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

@@ -1,10 +1,9 @@
 /** 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";
+import type { ToolProviderCapabilities } from "@pie-players/pie-assessment-toolkit/tools/registration";
 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;

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;

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

@@ -1,11 +1,10 @@
 /** 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";
+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 providerId = "desmos-calculator";
     readonly providerName = "Desmos Calculator";
     readonly version = "1.12";
     readonly requiresAuth = true;

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;

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

@@ -1,13 +1,12 @@
 /** 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";
+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 providerId = "geogebra-calculator";
     readonly providerName = "GeoGebra Calculator";
     readonly version = "6";
     readonly requiresAuth = false;

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;

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, ToolProviderCapabilities } from "@pie-players/pie-assessment-toolkit/tools/registration";
 export type CalculatorToolProviderInitConfig = Pick<CalculatorProviderInit, "onTelemetry">;
 type InitializableCalculatorProvider<TConfig> = CalculatorProvider & {
     initialize(config: TConfig): Promise<void>;
@@ -14,8 +14,7 @@ export interface LazyCalculatorProviderDefinition<TConfig> {
  * 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<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;

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 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. */
     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;