@pie-players/pie-assessment-toolkit 0.3.64 → 0.3.66

package/dist/services/ToolkitCoordinator.d.ts

@@ -29,7 +29,8 @@ import type { SREMathSpeechOptions } from "./tts/math-speech.js";
 import { ToolProviderRegistry } from "./tool-providers/index.js";
 import type { ToolProviderApi } from "./tool-providers/ToolProviderApi.js";
 import type { TTSToolProviderConfig } from "./tool-providers/index.js";
-import type { ResolvedToolContext, ToolContextResolver, ToolContextResolverContext, ToolContextResolverMap, ToolRegistry } from "./ToolRegistry.js";
+import { ToolRegistry } from "./ToolRegistry.js";
+import type { ResolvedToolContext, ToolContextResolver, ToolContextResolverContext, ToolContextResolverMap } from "./ToolRegistry.js";
 import { type FeaturePolicyDecision, type PnpEnforcementMode, type PolicySource, type ResolvedEngineInputs, type ToolPolicyChangeListener, type ToolPolicyDecision, type ToolPolicyDecisionRequest } from "../policy/engine.js";
 import type { SectionControllerContext, SectionControllerEvent, SectionControllerEventType, SectionControllerFactoryDefaults, SectionControllerHandle, SectionControllerKey, SectionSessionPersistenceStrategy, SectionPersistenceFactoryDefaults } from "./section-controller-types.js";
 export type { SectionControllerContext, SectionControllerEvent, SectionControllerEventType, SectionControllerFactoryDefaults, SectionControllerHandle, SectionControllerKey, SectionControllerLoadedRenderable, SectionSessionPersistenceConfig, SectionSessionPersistenceStrategy, SectionControllerRuntimeState, SectionControllerSessionState, SectionPersistenceFactoryDefaults, } from "./section-controller-types.js";
@@ -295,7 +296,7 @@ export interface ToolkitServiceBundle {
  *   assessmentId: 'demo-three-questions',
  *   tools: {
  *     providers: {
- *       textToSpeech: { enabled: true, defaultVoice: 'en-US' },
+ *       textToSpeech: { enabled: true, backend: 'browser' },
  *       answerEliminator: { enabled: true, strategy: 'strikethrough' }
  *     },
  *     placement: {
@@ -413,6 +414,17 @@ export declare class ToolkitCoordinator {
      * frozen snapshot.
      */
     private boundCurrentItemRef;
+    /**
+     * Whether {@link decideFeaturePolicy} has already reported serving a decision
+     * with no assessment bound.
+     *
+     * One report per coordinator, not per decision: a feature policy is consulted
+     * once per capability per card, so a per-decision warning would bury itself.
+     * Never reset — {@link updateAssessment} arriving later fixes the deployment,
+     * and re-arming would report the same gap again on the next unbound coordinator
+     * lifetime for no new information.
+     */
+    private reportedUnboundFeaturePolicy;
     private static resolveConfig;
     constructor(config: ToolkitCoordinatorConfig);
     /**
@@ -667,6 +679,12 @@ export declare class ToolkitCoordinator {
      * Thin shim over the owned tool-policy engine; see
      * {@link ToolPolicyEngine.decideFeature} for the contract, including why
      * `pnpEnforcement` is not consulted.
+     *
+     * Reports once per coordinator when it is asked about a feature with no
+     * assessment bound. A host in that state gets a correct denial for every
+     * capability it asks about, which is indistinguishable from a student who was
+     * properly declined — so without this, forgetting {@link updateAssessment}
+     * presents as an accommodation that silently never appears.
      */
     decideFeaturePolicy(featureId: string): FeaturePolicyDecision;
     /**

package/dist/services/ToolkitCoordinator.js

@@ -25,7 +25,7 @@ import { TTSService } from "./TTSService.js";
 import { BrowserTTSProvider } from "./tts/browser-provider.js";
 import { buildRuntimeTTSConfig, resolveTTSBackend, resolveTTSRuntimeSettings, } from "./tts-runtime-config.js";
 import { ToolProviderRegistry } from "./tool-providers/index.js";
-import { createPackagedToolRegistry } from "./createDefaultToolRegistry.js";
+import { ToolRegistry } from "./ToolRegistry.js";
 import { ToolPolicyEngine, } from "../policy/engine.js";
 import { resolveDefaultPnpEnforcement } from "../policy/internal.js";
 const isPlainRecord = (value) => !!value && typeof value === "object" && !Array.isArray(value);
@@ -70,7 +70,7 @@ const SECTION_SCOPED_EVENT_TYPES = [
  *   assessmentId: 'demo-three-questions',
  *   tools: {
  *     providers: {
- *       textToSpeech: { enabled: true, defaultVoice: 'en-US' },
+ *       textToSpeech: { enabled: true, backend: 'browser' },
  *       answerEliminator: { enabled: true, strategy: 'strikethrough' }
  *     },
  *     placement: {
@@ -188,9 +188,26 @@ export class ToolkitCoordinator {
      * frozen snapshot.
      */
     boundCurrentItemRef = null;
+    /**
+     * Whether {@link decideFeaturePolicy} has already reported serving a decision
+     * with no assessment bound.
+     *
+     * One report per coordinator, not per decision: a feature policy is consulted
+     * once per capability per card, so a per-decision warning would bury itself.
+     * Never reset — {@link updateAssessment} arriving later fixes the deployment,
+     * and re-arming would report the same gap again on the next unbound coordinator
+     * lifetime for no new information.
+     */
+    reportedUnboundFeaturePolicy = false;
     static resolveConfig(config) {
         const strictness = normalizeToolConfigStrictness(config.toolConfigStrictness);
-        const toolRegistry = config.toolRegistry ?? createPackagedToolRegistry();
+        // An empty registry when the host supplies none. This package no longer
+        // holds the packaged capability set, so there is nothing to fall back to —
+        // a host that wants stock tools passes a registry from
+        // `@pie-players/pie-default-tool-loaders`. Tool-id validation is skipped
+        // against an empty registry (with a diagnostic saying so) rather than
+        // rejecting every configured id.
+        const toolRegistry = config.toolRegistry ?? new ToolRegistry();
         const normalized = config.deferToolConfigValidation === true
             ? normalizeToolsConfig(config.tools)
             : normalizeAndValidateToolsConfig(config.tools, {
@@ -232,8 +249,7 @@ export class ToolkitCoordinator {
         const resolvedConfig = ToolkitCoordinator.resolveConfig(config);
         this.assessmentId = resolvedConfig.assessmentId;
         this.config = resolvedConfig;
-        this.toolRegistry =
-            resolvedConfig.toolRegistry ?? createPackagedToolRegistry();
+        this.toolRegistry = resolvedConfig.toolRegistry ?? new ToolRegistry();
         this.installToolContextResolvers(resolvedConfig.toolContextResolvers);
         this.hooks = resolvedConfig.hooks ?? {};
         this.lazyInit = config.lazyInit === true;
@@ -1268,13 +1284,16 @@ export class ToolkitCoordinator {
                 if (canUseEventTarget) {
                     synth.removeEventListener("voiceschanged", onVoicesChanged);
                 }
-                else if (assignedHandler && synth.onvoiceschanged === onVoicesChanged) {
+                else if (assignedHandler &&
+                    synth.onvoiceschanged === onVoicesChanged) {
                     synth.onvoiceschanged = previousHandler;
                 }
                 resolve();
             };
             const onVoicesChanged = (event) => {
-                if (!canUseEventTarget && typeof previousHandler === "function" && event) {
+                if (!canUseEventTarget &&
+                    typeof previousHandler === "function" &&
+                    event) {
                     previousHandler.call(synth, event);
                 }
                 finish();
@@ -1371,6 +1390,15 @@ export class ToolkitCoordinator {
         if (toolId === "tts") {
             throw new Error(`Tool id "tts" is no longer supported. Use "textToSpeech".`);
         }
+        // An empty registry means the host supplied none, not that every id is
+        // wrong. There is nothing to check an id against, and throwing turns a
+        // host's every tool-config call into an exception — including the calls
+        // this coordinator's own default-provider block provokes, which is how a
+        // host that passes no registry ended up unable to read its own config.
+        // `normalizeAndValidateToolsConfig` already reports the missing registry
+        // once, as `tools.registryUnavailable`; a second report per call is noise.
+        if (this.toolRegistry.getAllToolIds().length === 0)
+            return;
         if (!this.toolRegistry.get(toolId)) {
             throw new Error(`Unknown tool id "${toolId}".`);
         }
@@ -1525,9 +1553,20 @@ export class ToolkitCoordinator {
      * Thin shim over the owned tool-policy engine; see
      * {@link ToolPolicyEngine.decideFeature} for the contract, including why
      * `pnpEnforcement` is not consulted.
+     *
+     * Reports once per coordinator when it is asked about a feature with no
+     * assessment bound. A host in that state gets a correct denial for every
+     * capability it asks about, which is indistinguishable from a student who was
+     * properly declined — so without this, forgetting {@link updateAssessment}
+     * presents as an accommodation that silently never appears.
      */
     decideFeaturePolicy(featureId) {
-        return this.policyEngine.decideFeature(featureId);
+        const decision = this.policyEngine.decideFeature(featureId);
+        if (!decision.assessmentBound && !this.reportedUnboundFeaturePolicy) {
+            this.reportedUnboundFeaturePolicy = true;
+            console.warn(`[ToolkitCoordinator] Feature policy was asked about "${featureId}" with no assessment bound, so every capability will be declined for want of a profile to read. Call updateAssessment(...) with the assessment (its personalNeedsProfile, settings.districtPolicy and settings.testAdministration are what policy reads) before relying on any accommodation. Reported once per coordinator.`);
+        }
+        return decision;
     }
     /**
      * Subscribe to policy-engine change events. Fires whenever the

package/dist/services/catalog-owner.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Identity and traversal rules for one mounted accessibility-catalog owner.
+ *
+ * The resolver is the public lifecycle boundary. This supporting module keeps
+ * its owner identity and direct-lookup helper separate from the runtime event
+ * adapter, while keeping the entity walk private to the resolver package.
+ */
+import type { AccessibilityCatalog } from "@pie-players/pie-players-shared/types";
+export type CatalogOwnerKind = "global" | "passage" | "itemModel";
+interface CatalogOwnerScopeContext {
+    assessmentId?: string;
+    sectionId?: string;
+}
+/** A valid resolver scope for a global, passage, or item/model owner. */
+export type CatalogOwnerContext = (CatalogOwnerScopeContext & {
+    ownerKind: "global";
+    canonicalItemId?: never;
+    itemId?: never;
+    passageId?: never;
+    modelId?: never;
+}) | (CatalogOwnerScopeContext & {
+    ownerKind: "passage";
+    passageId: string;
+    canonicalItemId?: never;
+    itemId?: never;
+    modelId?: never;
+}) | (CatalogOwnerScopeContext & {
+    ownerKind: "itemModel";
+    itemId: string;
+    canonicalItemId?: string;
+    modelId?: string;
+    passageId?: never;
+});
+export interface CatalogOwnerRegistrationEntry {
+    context: CatalogOwnerContext;
+    catalogs: AccessibilityCatalog[];
+}
+/** The entity shape catalogs hang off: an item, or a passage. */
+export interface CatalogSourceEntity {
+    accessibilityCatalogs?: AccessibilityCatalog[];
+    config?: {
+        extractedCatalogs?: AccessibilityCatalog[];
+        models?: Array<{
+            id?: string;
+            accessibilityCatalogs?: AccessibilityCatalog[];
+        }>;
+    };
+}
+/** Who is rendering the entity — everything owner scoping is derived from. */
+export interface CatalogOwnerIdentity {
+    kind: "item" | "passage";
+    /** The rendered instance id. */
+    itemId: string;
+    canonicalItemId?: string;
+    assessmentId?: string;
+    sectionId?: string;
+}
+/**
+ * Build the lookup context for a direct resolver client such as inline TTS.
+ *
+ * Owner registration uses the same function, so direct readers cannot drift
+ * from the context the resolver files the entity under.
+ */
+export declare function catalogOwnerContextFor(owner: CatalogOwnerIdentity): CatalogOwnerContext;
+/**
+ * Collect every catalog group carried by one owner in registration-precedence
+ * order. This is deliberately not exported from the package root: callers
+ * register the owner once through `AccessibilityCatalogResolver.registerOwner`.
+ */
+export declare function collectOwnerCatalogRegistrations(entity: CatalogSourceEntity | null | undefined, owner: CatalogOwnerIdentity): CatalogOwnerRegistrationEntry[];
+export {};

package/dist/services/catalog-owner.js

@@ -0,0 +1,64 @@
+/**
+ * Identity and traversal rules for one mounted accessibility-catalog owner.
+ *
+ * The resolver is the public lifecycle boundary. This supporting module keeps
+ * its owner identity and direct-lookup helper separate from the runtime event
+ * adapter, while keeping the entity walk private to the resolver package.
+ */
+const hasCatalogs = (catalogs) => Array.isArray(catalogs) && catalogs.length > 0;
+/**
+ * Build the lookup context for a direct resolver client such as inline TTS.
+ *
+ * Owner registration uses the same function, so direct readers cannot drift
+ * from the context the resolver files the entity under.
+ */
+export function catalogOwnerContextFor(owner) {
+    if (owner.kind === "passage") {
+        return {
+            ownerKind: "passage",
+            assessmentId: owner.assessmentId,
+            sectionId: owner.sectionId,
+            passageId: owner.canonicalItemId || owner.itemId,
+        };
+    }
+    return {
+        ownerKind: "itemModel",
+        assessmentId: owner.assessmentId,
+        sectionId: owner.sectionId,
+        itemId: owner.itemId,
+        canonicalItemId: owner.canonicalItemId || owner.itemId,
+    };
+}
+/**
+ * Collect every catalog group carried by one owner in registration-precedence
+ * order. This is deliberately not exported from the package root: callers
+ * register the owner once through `AccessibilityCatalogResolver.registerOwner`.
+ */
+export function collectOwnerCatalogRegistrations(entity, owner) {
+    if (!entity)
+        return [];
+    const context = catalogOwnerContextFor(owner);
+    const registrations = [];
+    if (hasCatalogs(entity.accessibilityCatalogs)) {
+        registrations.push({ context, catalogs: entity.accessibilityCatalogs });
+    }
+    if (hasCatalogs(entity.config?.extractedCatalogs)) {
+        registrations.push({
+            context,
+            catalogs: entity.config.extractedCatalogs,
+        });
+    }
+    if (owner.kind === "passage")
+        return registrations;
+    if (context.ownerKind !== "itemModel")
+        return registrations;
+    for (const model of entity.config?.models ?? []) {
+        if (!hasCatalogs(model.accessibilityCatalogs))
+            continue;
+        registrations.push({
+            context: { ...context, modelId: model.id },
+            catalogs: model.accessibilityCatalogs,
+        });
+    }
+    return registrations;
+}

package/dist/services/createDefaultToolRegistry.d.ts

@@ -1,86 +1,53 @@
 /**
- * Default Tool Registry Factory
+ * Tool Registry Factory
  *
- * Creates a ToolRegistry pre-populated with all PIE framework tools.
- * Integrators can use this as a starting point and customize as needed.
+ * Creates an empty `ToolRegistry` and installs whatever component overrides and
+ * lazy module loaders the caller supplies.
+ *
+ * It registers nothing by itself, deliberately. Eleven concrete registrations
+ * used to live in this package, which made the policy and registry core know
+ * every capability by name and left a host unable to contribute one without a PR
+ * against this package. The packaged set now lives in the composition layer:
+ * `createPackagedToolRegistry` from `@pie-players/pie-default-tool-loaders`.
  */
+import type { ToolRegistration, ToolModuleLoader } from "./ToolRegistry.js";
 import { ToolRegistry } from "./ToolRegistry.js";
-import type { ToolRegistration } from "./ToolRegistry.js";
-import type { ToolModuleLoader } from "./ToolRegistry.js";
-import { type ToolComponentFactory, type ToolComponentFactoryMap, type ToolTagMap } from "../tools/tool-tag-map.js";
-import { DEFAULT_TOOL_PLACEMENT, PACKAGED_TOOL_PLACEMENT, SECTION_PLAYER_PREFERRED_TOOL_PLACEMENT } from "./tool-config-defaults.js";
+import type { ToolComponentFactory, ToolComponentFactoryMap, ToolTagMap } from "../tools/tool-tag-map.js";
+import { DEFAULT_TOOL_PLACEMENT } from "./tool-config-defaults.js";
 export interface DefaultToolRegistryOptions {
     /**
-     * Override default tool registrations by toolId.
-     * This is the highest-precedence extension point.
+     * Registrations to register, keyed by toolId. Nothing is registered when this
+     * is absent.
      */
-    overrides?: Partial<Record<string, ToolRegistration>>;
+    registrations?: Partial<Record<string, ToolRegistration>>;
     /**
-     * Override default component tag mapping used by built-in registrations.
+     * Element tag mapping for the registrations being installed. There is no
+     * built-in default: a tag map names capabilities, so it belongs to whoever
+     * decides which capabilities exist.
      */
     toolTagMap?: Partial<ToolTagMap>;
     /**
-     * Override component factory globally (all tools) or per tool.
+     * Override component creation globally (all tools) or per tool.
      */
     toolComponentFactory?: ToolComponentFactory;
     toolComponentFactories?: Partial<ToolComponentFactoryMap>;
     /**
      * Optional lazy module loaders keyed by toolId.
-     * Hosts can inject default loaders from an external package.
      */
     toolModuleLoaders?: Partial<Record<string, ToolModuleLoader>>;
-    /**
-     * Register packaged PIE tools by default.
-     *
-     * @default false
-     */
-    includePackagedTools?: boolean;
-    /**
-     * Restrict registration to specific packaged tool IDs.
-     * Ignored when includePackagedTools is false.
-     */
-    toolIds?: string[];
 }
 /**
  * Create a tool registry.
  *
- * By default, this creates an empty registry so hosts can explicitly opt in.
- * For convenience, pass { includePackagedTools: true } to register all packaged tools,
- * or use createPackagedToolRegistry().
- *
- * @returns ToolRegistry with all default tools
+ * @returns an empty `ToolRegistry` unless `registrations` is supplied
  */
 export declare function createDefaultToolRegistry(options?: DefaultToolRegistryOptions): ToolRegistry;
-export interface RegisterPackagedToolsOptions {
-    toolIds?: string[];
-    applyOverrides?: (registration: ToolRegistration) => ToolRegistration;
-}
 /**
- * Register packaged PIE tools onto an existing registry.
- */
-export declare function registerPackagedTools(registry: ToolRegistry, options?: RegisterPackagedToolsOptions): void;
-/**
- * Convenience factory that registers all packaged PIE tools.
- */
-export declare function createPackagedToolRegistry(options?: Omit<DefaultToolRegistryOptions, "includePackagedTools">): ToolRegistry;
-/**
- * Default tool placement configuration
+ * Placement configuration with every level empty.
  *
- * Defines which tools appear at which levels by default.
- * Integrators can override this configuration.
- *
- * Categories:
- * - Global tools: theme (assessment/section level)
- * - Context-smart: calculator, graph, periodicTable (item/element, auto-detect)
- * - Reading aids: textToSpeech, lineReader, annotationToolbar (where text exists)
- * - Interaction-specific: answerEliminator (choice questions), highlighter (text)
- * - Measurement: ruler, protractor (element level, diagram/geometry)
+ * The only placement default this package can hold: a populated one would name
+ * capabilities. `PACKAGED_TOOL_PLACEMENT` and
+ * `SECTION_PLAYER_PREFERRED_TOOL_PLACEMENT` are in
+ * `@pie-players/pie-default-tool-loaders`.
  */
 export { DEFAULT_TOOL_PLACEMENT };
-export { PACKAGED_TOOL_PLACEMENT };
-export { SECTION_PLAYER_PREFERRED_TOOL_PLACEMENT };
-/**
- * Tool priority order for rendering
- * Tools will be rendered in this order when multiple tools are visible
- */
-export declare const DEFAULT_TOOL_ORDER: readonly ["theme", "calculator", "textToSpeech", "lineReader", "annotationToolbar", "highlighter", "answerEliminator", "ruler", "protractor", "graph", "periodicTable"];

package/dist/services/createDefaultToolRegistry.js

@@ -1,125 +1,45 @@
 /**
- * Default Tool Registry Factory
+ * Tool Registry Factory
  *
- * Creates a ToolRegistry pre-populated with all PIE framework tools.
- * Integrators can use this as a starting point and customize as needed.
+ * Creates an empty `ToolRegistry` and installs whatever component overrides and
+ * lazy module loaders the caller supplies.
+ *
+ * It registers nothing by itself, deliberately. Eleven concrete registrations
+ * used to live in this package, which made the policy and registry core know
+ * every capability by name and left a host unable to contribute one without a PR
+ * against this package. The packaged set now lives in the composition layer:
+ * `createPackagedToolRegistry` from `@pie-players/pie-default-tool-loaders`.
  */
 import { ToolRegistry } from "./ToolRegistry.js";
-import { calculatorToolRegistration } from "../tools/registrations/calculator.js";
-import { ttsToolRegistration } from "../tools/registrations/tts.js";
-import { rulerToolRegistration, protractorToolRegistration, } from "../tools/registrations/measurement-tools.js";
-import { answerEliminatorToolRegistration, highlighterToolRegistration, } from "../tools/registrations/interaction-tools.js";
-import { lineReaderToolRegistration, themeToolRegistration, annotationToolbarRegistration, } from "../tools/registrations/accessibility-tools.js";
-import { graphToolRegistration, periodicTableToolRegistration, } from "../tools/registrations/subject-specific-tools.js";
-import { DEFAULT_TOOL_TAG_MAP, } from "../tools/tool-tag-map.js";
-import { DEFAULT_TOOL_PLACEMENT, PACKAGED_TOOL_PLACEMENT, SECTION_PLAYER_PREFERRED_TOOL_PLACEMENT, } from "./tool-config-defaults.js";
-const PACKAGED_TOOL_REGISTRATIONS = [
-    calculatorToolRegistration,
-    ttsToolRegistration,
-    rulerToolRegistration,
-    protractorToolRegistration,
-    answerEliminatorToolRegistration,
-    highlighterToolRegistration,
-    lineReaderToolRegistration,
-    themeToolRegistration,
-    annotationToolbarRegistration,
-    graphToolRegistration,
-    periodicTableToolRegistration,
-];
+import { DEFAULT_TOOL_PLACEMENT } from "./tool-config-defaults.js";
 /**
  * Create a tool registry.
  *
- * By default, this creates an empty registry so hosts can explicitly opt in.
- * For convenience, pass { includePackagedTools: true } to register all packaged tools,
- * or use createPackagedToolRegistry().
- *
- * @returns ToolRegistry with all default tools
+ * @returns an empty `ToolRegistry` unless `registrations` is supplied
  */
 export function createDefaultToolRegistry(options = {}) {
     const registry = new ToolRegistry();
-    const componentConfig = {
-        toolTagMap: {
-            ...DEFAULT_TOOL_TAG_MAP,
-            ...(options.toolTagMap || {}),
-        },
-        toolComponentFactory: options.toolComponentFactory,
-        toolComponentFactories: options.toolComponentFactories,
-    };
-    const applyOverrides = (registration) => options.overrides?.[registration.toolId] || registration;
-    if (options.includePackagedTools) {
-        registerPackagedTools(registry, {
-            toolIds: options.toolIds,
-            applyOverrides,
-        });
+    for (const registration of Object.values(options.registrations ?? {})) {
+        if (registration)
+            registry.register(registration);
     }
     if (options.toolModuleLoaders &&
         Object.keys(options.toolModuleLoaders).length > 0) {
         registry.setToolModuleLoaders(options.toolModuleLoaders);
     }
-    registry.setComponentOverrides(componentConfig);
-    return registry;
-}
-/**
- * Register packaged PIE tools onto an existing registry.
- */
-export function registerPackagedTools(registry, options = {}) {
-    const selectedToolIds = options.toolIds && options.toolIds.length > 0
-        ? new Set(options.toolIds)
-        : null;
-    const applyOverrides = options.applyOverrides ||
-        ((registration) => registration);
-    for (const registration of PACKAGED_TOOL_REGISTRATIONS) {
-        if (selectedToolIds && !selectedToolIds.has(registration.toolId)) {
-            continue;
-        }
-        registry.register(applyOverrides(registration));
-    }
-}
-/**
- * Convenience factory that registers all packaged PIE tools.
- */
-export function createPackagedToolRegistry(options = {}) {
-    return createDefaultToolRegistry({
-        ...options,
-        includePackagedTools: true,
+    registry.setComponentOverrides({
+        toolTagMap: options.toolTagMap,
+        toolComponentFactory: options.toolComponentFactory,
+        toolComponentFactories: options.toolComponentFactories,
     });
+    return registry;
 }
 /**
- * Default tool placement configuration
- *
- * Defines which tools appear at which levels by default.
- * Integrators can override this configuration.
+ * Placement configuration with every level empty.
  *
- * Categories:
- * - Global tools: theme (assessment/section level)
- * - Context-smart: calculator, graph, periodicTable (item/element, auto-detect)
- * - Reading aids: textToSpeech, lineReader, annotationToolbar (where text exists)
- * - Interaction-specific: answerEliminator (choice questions), highlighter (text)
- * - Measurement: ruler, protractor (element level, diagram/geometry)
+ * The only placement default this package can hold: a populated one would name
+ * capabilities. `PACKAGED_TOOL_PLACEMENT` and
+ * `SECTION_PLAYER_PREFERRED_TOOL_PLACEMENT` are in
+ * `@pie-players/pie-default-tool-loaders`.
  */
 export { DEFAULT_TOOL_PLACEMENT };
-export { PACKAGED_TOOL_PLACEMENT };
-export { SECTION_PLAYER_PREFERRED_TOOL_PLACEMENT };
-/**
- * Tool priority order for rendering
- * Tools will be rendered in this order when multiple tools are visible
- */
-export const DEFAULT_TOOL_ORDER = [
-    // Global accessibility first
-    "theme",
-    // Common tools
-    "calculator",
-    "textToSpeech",
-    // Reading aids
-    "lineReader",
-    "annotationToolbar",
-    "highlighter",
-    // Interaction tools
-    "answerEliminator",
-    // Measurement tools
-    "ruler",
-    "protractor",
-    // Subject-specific
-    "graph",
-    "periodicTable",
-];

package/dist/services/defaultPersonalNeedsProfile.d.ts

@@ -1,19 +1,21 @@
 import type { PersonalNeedsProfile } from "@pie-players/pie-players-shared/types";
 /**
- * PNP support ids that must never enter the computed default profile, however
- * they reach the registry.
+ * An empty personal-needs profile: nothing granted, nothing prohibited, nothing
+ * activated at init.
  *
- * `computeDefaultSupports()` derives the fallback profile from every registered
- * tool's `pnpSupportIds`, which is right for universal features — a highlighter
- * or a zoom control should be there for every student by default. It is wrong
- * for an **accommodation**: signing requires a documented need (IEP / 504), so
- * granting it to every host that does not supply its own profile would invert
- * the eligibility tier. Registry membership is about being policy-addressable,
- * not about who may enable it.
+ * The core ships no populated default on purpose. It once derived one from every
+ * registered tool's `pnpSupportIds`, which read *registry membership* as
+ * *eligibility tier* — registration means "policy-addressable", not "universal,
+ * on by default" — so an accommodation-tier capability was granted to every
+ * student of every host that supplied no profile. The remedy at the time was a
+ * compile-time list of ids to exclude, which a host could not extend for its own
+ * accommodation.
  *
- * Excluded here rather than by declining to register, so the guarantee holds
- * even if a signing tool is later registered for some other reason.
+ * Which capabilities a deployment grants by default is a property of the
+ * program, not of this package: TTS is a universal feature in one program and a
+ * documented accommodation in another. That belongs in policy configuration
+ * alongside the district and test-administration levels. A named preset of
+ * today's universal set ships as data from
+ * `@pie-players/pie-default-tool-loaders`, for hosts that want it.
  */
-export declare const ACCOMMODATION_ONLY_SUPPORT_IDS: readonly string[];
-export declare const DEFAULT_PERSONAL_NEEDS_PROFILE: PersonalNeedsProfile;
-export declare function createDefaultPersonalNeedsProfile(): PersonalNeedsProfile;
+export declare function createEmptyPersonalNeedsProfile(): PersonalNeedsProfile;