@pie-players/pie-assessment-toolkit 0.3.72 → 0.3.74

package/dist/services/tts/math-alignment/speech-tokenizer.js

@@ -1,8 +1,8 @@
 import { extractSpokenText } from "../ssml/spoken-text.js";
 import { createSpeechAlignmentTokenPattern } from "../text-processing.js";
-// Shared Unicode-aware tokenizer, identical to the catalog span aligner's, so
-// spoken text tokenizes the same way on both paths (see
-// `createSpeechAlignmentTokenPattern`).
+// The one tokenizer and normalization table for TTS alignment. Spoken text,
+// visible catalog text and provider boundary words all tokenize here, so a word
+// normalizes the same way on the catalog, math and generated-speech paths.
 const TOKEN_PATTERN = createSpeechAlignmentTokenPattern();
 const NUMERIC_WORDS = new Map([
     ["zero", "0"],
@@ -21,24 +21,27 @@ const normalizedTokenValue = (value) => {
     const normalized = value.toLowerCase();
     return NUMERIC_WORDS.get(normalized) || normalized;
 };
-const tokenizeSpokenText = (spokenText) => {
+export const tokenizeAlignmentText = (text) => {
     const tokens = [];
-    for (const match of spokenText.matchAll(TOKEN_PATTERN)) {
-        const text = match[0];
+    for (const match of text.matchAll(TOKEN_PATTERN)) {
+        const value = match[0];
         const start = match.index ?? 0;
         tokens.push({
-            id: `speech-token-${tokens.length}`,
-            text,
-            normalized: normalizedTokenValue(text),
+            text: value,
+            normalized: normalizedTokenValue(value),
             start,
-            end: start + text.length,
-            sourceStart: start,
-            sourceEnd: start + text.length,
-            coordinateSystem: "normalized-speech",
+            end: start + value.length,
         });
     }
     return tokens;
 };
+const tokenizeSpokenText = (spokenText) => tokenizeAlignmentText(spokenText).map((token, index) => ({
+    ...token,
+    id: `speech-token-${index}`,
+    sourceStart: token.start,
+    sourceEnd: token.end,
+    coordinateSystem: "normalized-speech",
+}));
 export const tokenizeSpeechSource = (args) => {
     const extracted = extractSpokenText(args.speechText);
     return {
@@ -55,15 +58,17 @@ export const tokenizeSpeechSource = (args) => {
         hasMarkup: extracted.hasMarkup,
     };
 };
-const normalizeBoundaryWord = (word) => {
-    if (!word)
+const isControlTagWord = (word) => Boolean(word && /^<[^>]+>$/.test(word.trim()));
+/**
+ * A provider boundary word in the form spoken tokens compare in, or null when
+ * the word carries no token (empty, a control tag, punctuation). The word goes
+ * through the same SSML extraction as the chunk, so an entity-encoded word
+ * normalizes to the text it encodes.
+ */
+export const normalizeBoundaryWord = (word) => {
+    if (!word || isControlTagWord(word))
         return null;
-    if (/^<[^>]+>$/.test(word.trim()))
-        return null;
-    const match = word.match(TOKEN_PATTERN);
-    if (!match?.[0])
-        return null;
-    return normalizedTokenValue(match[0]);
+    return (tokenizeSpeechSource({ speechText: word }).tokens[0]?.normalized ?? null);
 };
 const findTokenAtOffset = (tokens, offset) => tokens.find((token) => token.start <= offset && offset < token.end) || null;
 const mapRawOffsetToSpokenOffset = (tokenization, position) => {
@@ -92,32 +97,29 @@ const candidateForOffset = (tokenization, offset, length) => {
         confidence: 0.75,
     };
 };
-const candidateMatchesWord = (candidate, boundaryWord) => {
-    const normalizedBoundary = normalizeBoundaryWord(boundaryWord);
-    return Boolean(candidate &&
-        normalizedBoundary &&
-        candidate.token.normalized === normalizedBoundary);
-};
+const candidateMatchesWord = (candidate, normalizedWord) => Boolean(candidate &&
+    normalizedWord &&
+    candidate.token.normalized === normalizedWord);
 export const resolveBoundaryToSpeechToken = (args) => {
     if (args.tokenization.boundaryOffsetSpace === "unsupported" ||
         !Number.isFinite(args.position) ||
-        (args.boundaryWord && /^<[^>]+>$/.test(args.boundaryWord.trim()))) {
+        isControlTagWord(args.boundaryWord)) {
         return null;
     }
     const safeLength = Math.max(1, Number.isFinite(args.length) ? args.length : 1);
+    const normalizedWord = normalizeBoundaryWord(args.boundaryWord);
     const rawCandidate = candidateForOffset(args.tokenization, mapRawOffsetToSpokenOffset(args.tokenization, args.position), safeLength);
     const plainCandidate = candidateForOffset(args.tokenization, args.position >= 0 && args.position < args.tokenization.spokenText.length
         ? args.position
         : null, safeLength);
-    if (candidateMatchesWord(rawCandidate, args.boundaryWord)) {
+    if (candidateMatchesWord(rawCandidate, normalizedWord)) {
         return { ...rawCandidate, confidence: 1 };
     }
-    if (candidateMatchesWord(plainCandidate, args.boundaryWord)) {
+    if (candidateMatchesWord(plainCandidate, normalizedWord)) {
         return { ...plainCandidate, confidence: 1 };
     }
-    if (args.boundaryWord && normalizeBoundaryWord(args.boundaryWord)) {
+    if (normalizedWord)
         return null;
-    }
     return args.tokenization.boundaryOffsetSpace === "raw-ssml"
         ? rawCandidate || plainCandidate
         : plainCandidate || rawCandidate;
@@ -125,18 +127,18 @@ export const resolveBoundaryToSpeechToken = (args) => {
 export const resolveSpokenOffsetToSpeechToken = (args) => {
     if (args.tokenization.boundaryOffsetSpace === "unsupported" ||
         !Number.isFinite(args.position) ||
-        (args.boundaryWord && /^<[^>]+>$/.test(args.boundaryWord.trim()))) {
+        isControlTagWord(args.boundaryWord)) {
         return null;
     }
     const safeLength = Math.max(1, Number.isFinite(args.length) ? args.length : 1);
+    const normalizedWord = normalizeBoundaryWord(args.boundaryWord);
     const spokenCandidate = candidateForOffset(args.tokenization, args.position >= 0 && args.position < args.tokenization.spokenText.length
         ? args.position
         : null, safeLength);
-    if (candidateMatchesWord(spokenCandidate, args.boundaryWord)) {
+    if (candidateMatchesWord(spokenCandidate, normalizedWord)) {
         return { ...spokenCandidate, confidence: 1 };
     }
-    if (args.boundaryWord && normalizeBoundaryWord(args.boundaryWord)) {
+    if (normalizedWord)
         return null;
-    }
     return spokenCandidate;
 };

package/dist/services/tts/math-alignment/types.d.ts

@@ -34,12 +34,14 @@ export interface MathMLTokenizationResult {
 }
 export type BoundaryCoordinateSystem = "normalized-speech" | "raw-ssml" | "provider-speech-marks";
 export type BoundaryOffsetSpace = "plain-spoken-text" | "raw-ssml" | "unsupported";
-export interface SpeechAlignmentToken {
-    id: string;
+export interface AlignmentTextToken {
     text: string;
     normalized: string;
     start: number;
     end: number;
+}
+export interface SpeechAlignmentToken extends AlignmentTextToken {
+    id: string;
     sourceStart: number;
     sourceEnd: number;
     coordinateSystem: BoundaryCoordinateSystem;

package/dist/services/tts/math-aware-text-processing.js

@@ -44,7 +44,6 @@ const findCanonicalMathML = (element) => {
     }
     return null;
 };
-const isMathContainer = (element) => Boolean(findCanonicalMathML(element));
 const TEXT_CHUNK_SOURCE_TAGS = new Set([
     "P",
     "H1",
@@ -223,6 +222,49 @@ const textFallbackFromMathML = (mathml) => {
     visit(parsed.documentElement);
     return normalizeTextForSpeech(parts.join(" "));
 };
+// MathJax CHTML paints its glyphs from CSS, so a typeset equation's only text
+// nodes are the source MathML it keeps, clipped, in mjx-assistive-mml. Mapping
+// the fallback text onto them places a catalog word inside its equation, where
+// the rendered-math resolver finds the glyph. Any divergence between the two
+// texts leaves the fallback unmapped.
+const mapFallbackToAssistiveMath = (element, fallbackText) => {
+    const map = new Map();
+    const sourceMath = isMathJaxElement(element)
+        ? element.querySelector("mjx-assistive-mml math")
+        : null;
+    if (!sourceMath)
+        return map;
+    const characters = [];
+    const visit = (node) => {
+        if (node.nodeType === 3) {
+            const text = node.textContent || "";
+            for (let offset = 0; offset < text.length; offset++) {
+                if (!/\s/.test(text[offset])) {
+                    characters.push({ node: node, offset });
+                }
+            }
+            return;
+        }
+        if (node.nodeType !== 1 || isAnnotationElement(node))
+            return;
+        for (const child of Array.from(node.childNodes)) {
+            visit(child);
+        }
+    };
+    visit(sourceMath);
+    let next = 0;
+    for (let index = 0; index < fallbackText.length; index++) {
+        if (/\s/.test(fallbackText[index]))
+            continue;
+        const mapping = characters[next];
+        if (mapping?.node.textContent?.[mapping.offset] !== fallbackText[index]) {
+            return new Map();
+        }
+        map.set(index, mapping);
+        next++;
+    }
+    return next === characters.length ? map : new Map();
+};
 const collectVisibleMathFallback = (element, canonicalMathML, options) => {
     const mathAcc = createAccumulator(options);
     const visit = (node) => {
@@ -255,7 +297,7 @@ const collectVisibleMathFallback = (element, canonicalMathML, options) => {
     }
     return {
         text: fallbackText,
-        map: new Map(),
+        map: mapFallbackToAssistiveMath(element, fallbackText),
     };
 };
 const trimTrailingWhitespace = (acc) => {

package/dist/services/tts/math-speech.d.ts

@@ -25,7 +25,11 @@ export interface SREMathSpeechOptions {
     domain?: string;
     /** Raw SRE style/preference string. ClearSpeak preferences are ":"-joined. */
     style?: string;
-    /** Extra SRE setupEngine options for hosts that need a newly exposed SRE knob. */
+    /**
+     * Extra SRE setupEngine options for hosts that need a newly exposed SRE knob.
+     * In a browser, SRE's locale tables load from the host's bundle unless `json`
+     * (a base URL or path) or `custom` (a loader) names another source.
+     */
     engineOptions?: Record<string, unknown>;
 }
 export interface ResolvedMathSpeech {

package/dist/services/tts/math-speech.js

@@ -1,12 +1,12 @@
+import { setSreStartupLocaleSource, sreLocaleSource } from "./sre-locales.js";
 import { normalizeTextForSpeech } from "./text-processing.js";
 let sreLoadPromise = null;
 let sreOperationQueue = Promise.resolve();
 const normalizeLocale = (language) => (language || "en").split("-")[0].toLowerCase() || "en";
-const defaultLoadSre = async () => {
+const defaultLoadSre = async (engineOptions) => {
     if (!sreLoadPromise) {
-        sreLoadPromise = import("speech-rule-engine").then((module) => {
-            const candidate = module.default ||
-                module;
+        setSreStartupLocaleSource(engineOptions);
+        sreLoadPromise = import("./sre-engine.js").then(({ default: candidate }) => {
             if (!candidate || typeof candidate.toSpeech !== "function") {
                 throw new Error("speech-rule-engine did not expose toSpeech");
             }
@@ -41,8 +41,10 @@ export const normalizeSREMathSpeechOptions = (options) => {
 const setupSre = async (sre, language, markup, mathSpeech) => {
     const locale = normalizeLocale(language);
     const normalizedMathSpeech = normalizeSREMathSpeechOptions(mathSpeech);
+    const engineOptions = normalizedMathSpeech?.engineOptions || {};
     await sre.setupEngine?.({
-        ...(normalizedMathSpeech?.engineOptions || {}),
+        ...sreLocaleSource(engineOptions),
+        ...engineOptions,
         locale,
         domain: normalizedMathSpeech?.domain || domainForLocale(locale),
         ...(normalizedMathSpeech?.style
@@ -97,7 +99,8 @@ export const resolveMathSpeechFromChunks = async (chunks, options = {}) => {
     let sre = null;
     let usedMathSpeech = false;
     let usedFallback = false;
-    const loadSre = options.loadSre || defaultLoadSre;
+    const loadSre = options.loadSre ||
+        (() => defaultLoadSre(normalizeSREMathSpeechOptions(options.mathSpeech)?.engineOptions));
     const speechParts = [];
     for (const chunk of chunks) {
         if (chunk.type === "text") {

package/dist/services/tts/sre-engine.d.ts

@@ -0,0 +1,7 @@
+import * as speechRuleEngine from "speech-rule-engine";
+declare const sre: {
+    setupEngine: typeof speechRuleEngine.setupEngine;
+    engineReady: typeof speechRuleEngine.engineReady;
+    toSpeech: typeof speechRuleEngine.toSpeech;
+};
+export default sre;

package/dist/services/tts/sre-engine.js

@@ -0,0 +1,11 @@
+import * as speechRuleEngine from "speech-rule-engine";
+import { sreStartupLocaleSource } from "./sre-locales.js";
+const sre = speechRuleEngine.default ?? speechRuleEngine;
+// SRE starts itself up while this module's import of it evaluates, then loads
+// `base` and `en` a few microtasks later from whatever locale source is set by
+// then. In a bundle this call runs synchronously after that evaluation, so it
+// lands first; configuring SRE after awaiting an `import()` of it lands after
+// those loads. Bun drains microtasks between evaluating a CommonJS module and
+// its importer, so there SRE reads `base` from its own package directory.
+void sre.setupEngine(sreStartupLocaleSource());
+export default sre;

package/dist/services/tts/sre-locales.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The `setupEngine` options naming where SRE reads locale tables from: the
+ * host's `json` (a base URL or path) or `custom` (a loader) when its
+ * `engineOptions` set either, otherwise the packaged tables wherever SRE would
+ * fetch them. SRE prefers `custom` over `json`, so the packaged loader is left
+ * out whenever the host names a source.
+ */
+export declare const sreLocaleSource: (engineOptions?: Record<string, unknown>) => Record<string, unknown>;
+/**
+ * Sets the source SRE loads its start-up locales from; see `./sre-engine.ts`.
+ * Only a call made before that module first loads has any effect.
+ */
+export declare const setSreStartupLocaleSource: (engineOptions?: Record<string, unknown>) => void;
+export declare const sreStartupLocaleSource: () => Record<string, unknown>;

package/dist/services/tts/sre-locales.js

@@ -0,0 +1,57 @@
+// SRE loads each locale's rule tables at runtime, from a public CDN unless it is
+// handed a source. An import per table lets the host's bundler emit each as a
+// lazy chunk served from the host's own origin, but a build that inlines every
+// `import()` into one file carries every table listed here, at 0.2 to 0.4 MB
+// each. So only `base`, which every locale builds on, and the `en` and `es`
+// locales are packaged; any other locale needs a source from the host's
+// `engineOptions`. No `with { type: "json" }`: bundlers infer JSON from the
+// extension, while Vite's dev server and Bun's bundler turn a table into
+// JavaScript and keep the attribute, which a browser then rejects.
+const SRE_LOCALE_TABLES = {
+    base: () => import("speech-rule-engine/lib/mathmaps/base.json"),
+    en: () => import("speech-rule-engine/lib/mathmaps/en.json"),
+    es: () => import("speech-rule-engine/lib/mathmaps/es.json"),
+};
+// SRE's `custom` loader contract: called with a locale name, resolving to that
+// locale's table as a JSON string or an already-parsed object. SRE falls back
+// to English when a table fails to load.
+const loadPackagedSreLocale = async (locale) => {
+    if (!Object.hasOwn(SRE_LOCALE_TABLES, locale)) {
+        throw new Error(`no speech-rule-engine locale table is packaged for "${locale}"; name a source with mathSpeech.engineOptions.json or .custom`);
+    }
+    return (await SRE_LOCALE_TABLES[locale]()).default;
+};
+// SRE's own test for fetching tables over HTTP (`common/system_external.js`).
+// Elsewhere it reads them from its package directory, which Node's ESM loader
+// could not replace with the imports above: it requires the attribute.
+const sreFetchesTables = () => (typeof window !== "undefined" && typeof window.document !== "undefined") ||
+    typeof globalThis
+        .DedicatedWorkerGlobalScope !== "undefined";
+/**
+ * The `setupEngine` options naming where SRE reads locale tables from: the
+ * host's `json` (a base URL or path) or `custom` (a loader) when its
+ * `engineOptions` set either, otherwise the packaged tables wherever SRE would
+ * fetch them. SRE prefers `custom` over `json`, so the packaged loader is left
+ * out whenever the host names a source.
+ */
+export const sreLocaleSource = (engineOptions = {}) => {
+    const { json, custom } = engineOptions;
+    if (json || custom) {
+        return { ...(json ? { json } : {}), ...(custom ? { custom } : {}) };
+    }
+    return sreFetchesTables() ? { custom: loadPackagedSreLocale } : {};
+};
+// Resolved on first read: a call at module scope would keep the table imports
+// in every bundle that includes this module, math speech used or not.
+let startupLocaleSource;
+/**
+ * Sets the source SRE loads its start-up locales from; see `./sre-engine.ts`.
+ * Only a call made before that module first loads has any effect.
+ */
+export const setSreStartupLocaleSource = (engineOptions) => {
+    startupLocaleSource = sreLocaleSource(engineOptions);
+};
+export const sreStartupLocaleSource = () => {
+    startupLocaleSource ??= sreLocaleSource();
+    return startupLocaleSource;
+};

package/dist/services/tts/text-processing.d.ts

@@ -67,4 +67,3 @@ export declare const collectVisibleTextAndMap: (element: Element, options?: Text
     text: string;
     map: NormalizedTextMap;
 };
-export declare const extractVisibleText: (element: Element, options?: TextProcessingOptions) => string;

package/dist/services/tts/text-processing.js

@@ -282,4 +282,3 @@ export const collectVisibleTextAndMap = (element, options) => {
     }
     return { text, map };
 };
-export const extractVisibleText = (element, options) => collectVisibleTextAndMap(element, options).text;

package/dist/services/tts-runtime-config.d.ts

@@ -1,5 +1,5 @@
 import type { TTSConfig } from "./TTSService.js";
-import type { ToolProviderConfig } from "./tools-config-normalizer.js";
+import type { TextToSpeechToolProviderConfig } from "./tools-config-normalizer.js";
 import { type SREMathSpeechOptions } from "./tts/math-speech.js";
 export type TTSLayoutMode = "reserved-row" | "expanding-row" | "floating-overlay" | "left-aligned";
 export interface TTSHostToolbarLayout {
@@ -42,6 +42,12 @@ export interface TTSRuntimeSettings {
     endpointMode?: "synthesizePath" | "rootPost";
     endpointValidationMode?: "voices" | "endpoint" | "none";
     includeAuthOnAssetFetch?: boolean;
+    /** Origins trusted with the `Authorization` header on asset fetches. */
+    assetOrigins?: string[];
+    /** Fetch `credentials` mode for requests to the TTS server. */
+    credentials?: "omit" | "same-origin" | "include";
+    /** Headers sent with every request to the TTS server. */
+    headers?: Record<string, string>;
     validateEndpoint?: boolean;
     cache?: boolean;
     speedRate?: "slow" | "medium" | "fast";
@@ -75,6 +81,11 @@ export interface TTSRuntimeSettings {
      * instead of relying on toolkit-specific speech rewrites.
      */
     mathSpeech?: SREMathSpeechOptions;
+    /**
+     * Options passed through to the provider. The fields derived from the
+     * settings above, such as `locale` and the Polly engine, win over these.
+     */
+    providerOptions?: Record<string, unknown>;
 }
 export declare const normalizeTTSLayoutMode: (value: unknown, fallback?: TTSLayoutMode) => TTSLayoutMode;
 /** Legacy numeric helper defaults. Rendered controls add visible Normal separately. */
@@ -96,10 +107,17 @@ export declare const formatTTSSpeedOptionsAsText: (values: number[]) => string;
  * - Non-empty text with no parseable finite numbers → same as invalid-only array config: defaults.
  */
 export declare const parseTTSSpeedOptionsFromText: (text: string) => number[];
-export declare const resolveTTSRuntimeSettings: (config: ToolProviderConfig | TTSRuntimeSettings | undefined) => TTSRuntimeSettings;
+export declare const resolveTTSRuntimeSettings: (config: TextToSpeechToolProviderConfig | TTSRuntimeSettings | undefined) => TTSRuntimeSettings;
 export declare const resolveTTSBackend: (config: TTSRuntimeSettings) => NonNullable<TTSRuntimeSettings["backend"]>;
 export declare const resolveRuntimeProvider: (config: TTSRuntimeSettings, backend: NonNullable<TTSRuntimeSettings["backend"]>) => TTSRuntimeSettings["serverProvider"];
 export declare const resolveTransportMode: (config: TTSRuntimeSettings, runtimeProvider: TTSRuntimeSettings["serverProvider"]) => NonNullable<TTSRuntimeSettings["transportMode"]>;
-export declare const buildRuntimeTTSConfig: (config: TTSRuntimeSettings) => Partial<TTSConfig>;
+/**
+ * The provider configuration built from host settings: the contract's portable
+ * fields plus the server adapter's, under the adapter's names.
+ */
+export type RuntimeTTSConfig = Pick<TTSConfig, "voice" | "rate" | "pitch" | "providerOptions" | "mathTokenHighlighting"> & Pick<TTSRuntimeSettings, "apiEndpoint" | "language" | "transportMode" | "endpointMode" | "endpointValidationMode" | "includeAuthOnAssetFetch" | "assetOrigins" | "credentials" | "headers" | "validateEndpoint"> & {
+    provider?: TTSRuntimeSettings["serverProvider"];
+};
+export declare const buildRuntimeTTSConfig: (config: TTSRuntimeSettings) => RuntimeTTSConfig;
 export declare const resolveTTSLayoutMode: (config: TTSRuntimeSettings) => TTSLayoutMode;
 export declare const resolveTTSHostToolbarLayout: (config: TTSRuntimeSettings) => TTSHostToolbarLayout;

package/dist/services/tts-runtime-config.js

@@ -236,9 +236,12 @@ const applyRuntimeDefaults = (config) => {
 export const resolveTTSRuntimeSettings = (config) => {
     const configRecord = toRecord(config);
     const settingsRecord = toRecord(configRecord.settings);
+    const { provider, ...merged } = { ...configRecord, ...settingsRecord };
+    // A runtime provider object in `provider` is for the tool registration; the
+    // runtime settings carry only a server provider id.
     return applyRuntimeDefaults({
-        ...configRecord,
-        ...settingsRecord,
+        ...merged,
+        ...(typeof provider === "string" ? { provider } : {}),
     });
 };
 export const resolveTTSBackend = (config) => config.backend || "browser";
@@ -256,11 +259,12 @@ export const buildRuntimeTTSConfig = (config) => {
     const runtimeProvider = resolveRuntimeProvider(config, backend);
     const transportMode = resolveTransportMode(config, runtimeProvider);
     const mathSpeech = normalizeSREMathSpeechOptions(config.mathSpeech);
-    return {
+    const runtimeConfig = {
         voice: config.defaultVoice,
         rate: config.rate,
         pitch: config.pitch,
         providerOptions: {
+            ...toRecord(config.providerOptions),
             ...(config.language ? { locale: config.language } : {}),
             ...(backend === "polly" && config.engine
                 ? { engine: config.engine }
@@ -296,6 +300,9 @@ export const buildRuntimeTTSConfig = (config) => {
         endpointMode: config.endpointMode,
         endpointValidationMode: config.endpointValidationMode,
         includeAuthOnAssetFetch: config.includeAuthOnAssetFetch,
+        assetOrigins: config.assetOrigins,
+        credentials: config.credentials,
+        headers: config.headers,
         validateEndpoint: config.validateEndpoint,
         // Toolkit-level highlight setting carried through the config channel
         // (like apiEndpoint/transportMode); consumed by the highlight pipeline,
@@ -305,6 +312,7 @@ export const buildRuntimeTTSConfig = (config) => {
             ? { mathTokenHighlighting: config.mathTokenHighlighting }
             : {}),
     };
+    return runtimeConfig;
 };
 export const resolveTTSLayoutMode = (config) => normalizeTTSLayoutMode(config.layoutMode);
 export const resolveTTSHostToolbarLayout = (config) => {

package/dist/tools/client.d.ts

@@ -2,11 +2,9 @@
  * Client-only tool system exports
  *
  * This entry point exports only browser-safe code for use in custom elements.
- * It excludes server-side services like accommodationResolver, variantResolver, etc.
  *
  * Tools should import from '@pie-players/pie-assessment-toolkit/tools/client' instead of
  * '@pie-players/pie-assessment-toolkit' to ensure
  * they don't accidentally pull in server-side dependencies.
  */
-export { ResponseDiscoveryServiceImpl, responseDiscovery, } from "./response-discovery.js";
-export * from "./types.js";
+export type { CalculationHistoryEntry, Calculator, CalculatorProvider, CalculatorProviderCapabilities, CalculatorProviderConfig, CalculatorState, CalculatorType, } from "@pie-players/pie-calculator";

package/dist/tools/client.js

@@ -2,13 +2,9 @@
  * Client-only tool system exports
  *
  * This entry point exports only browser-safe code for use in custom elements.
- * It excludes server-side services like accommodationResolver, variantResolver, etc.
  *
  * Tools should import from '@pie-players/pie-assessment-toolkit/tools/client' instead of
  * '@pie-players/pie-assessment-toolkit' to ensure
  * they don't accidentally pull in server-side dependencies.
  */
-// Response discovery (client-safe, browser-only)
-export { ResponseDiscoveryServiceImpl, responseDiscovery, } from "./response-discovery.js";
-// Core types (client-safe)
-export * from "./types.js";
+export {};

package/dist/tools/internal.d.ts

@@ -4,8 +4,8 @@
  * What a package outside this one needs to write a `ToolRegistration`: the
  * registration types, the context predicates a tool answers `isVisibleInContext`
  * with, scoped-id and element-creation helpers, the toolbar button/overlay
- * helpers, and the provider descriptors for the two capabilities that ship a
- * provider.
+ * helpers, the provider contract a registration's descriptor creates, and the
+ * TTS provider.
  *
  * A separate entry point rather than additions to `.` for the same reason
  * `runtime/internal` and `policy/internal` exist: this is a surface for sibling
@@ -19,7 +19,7 @@
  * point — the mechanism is the same one our own registrations use.
  */
 export type { HostedToolContext, HostedToolSize, ResolvedToolContext, ToolActivation, ToolContentDependency, ToolContentDependencyContext, ToolModuleLoader, ToolProviderDescriptor, ToolRegistration, ToolRenderElement, ToolSingletonScope, ToolSurfaceRenderContext, ToolSurfaceRenderResult, ToolSurfaceServices, ToolToolbarButtonDefinition, ToolToolbarRenderResult, ToolWindowShellConfig, ToolbarContext, } from "../services/ToolRegistry.js";
-export { ToolRegistry } from "../services/ToolRegistry.js";
+export { resolveToolProviderId, ToolRegistry, } from "../services/ToolRegistry.js";
 export { resolveToolRegistrationName } from "../services/ToolRegistry.js";
 export type { CatalogOwnerCard, CatalogOwnerSnapshot, } from "../services/AccessibilityCatalogResolver.js";
 export type { ToolSelectionAction, ToolSelectionContext, } from "../services/selection-action.js";
@@ -36,8 +36,9 @@ export type { ToolComponentFactory, ToolComponentFactoryMap, ToolComponentOverri
 export { createToolElement, resolveToolTag, toToolIdFromTag, } from "./tool-tag-map.js";
 export { applyOverlaySurface, createScopedVisibilityBinding, syncButtonAndOverlayVisibility, } from "./registrations/toolbar-registration-helpers.js";
 export type { ElementToolStateStoreApi, ToolCoordinatorApi, ToolkitCoordinatorApi, TtsServiceApi, } from "../services/interfaces.js";
-export type { ToolPlacementConfig, ToolProviderConfig, } from "../services/tools-config-normalizer.js";
+export type { CalculatorToolProviderConfig, ToolPlacementConfig, ToolProviderConfig, } from "../services/tools-config-normalizer.js";
 export type { ToolConfigDiagnostic } from "../services/tool-config-validation.js";
-export { CortexToolProvider, DesmosToolProvider, GeoGebraToolProvider, TTSToolProvider, } from "../services/tool-providers/index.js";
+export type { ToolProviderApi, ToolProviderCapabilities, } from "../services/tool-providers/ToolProviderApi.js";
+export { TTSToolProvider } from "../services/tool-providers/index.js";
 export type { NormalizedTTSSpeedOption } from "../services/tts-runtime-config.js";
 export { buildRuntimeTTSConfig, normalizeTTSLayoutMode, normalizeTTSSpeedControlOptions, resolveRuntimeProvider, resolveTTSBackend, resolveTTSHostToolbarLayout, resolveTTSLayoutMode, resolveTTSRuntimeSettings, resolveTransportMode, } from "../services/tts-runtime-config.js";

package/dist/tools/internal.js

@@ -4,8 +4,8 @@
  * What a package outside this one needs to write a `ToolRegistration`: the
  * registration types, the context predicates a tool answers `isVisibleInContext`
  * with, scoped-id and element-creation helpers, the toolbar button/overlay
- * helpers, and the provider descriptors for the two capabilities that ship a
- * provider.
+ * helpers, the provider contract a registration's descriptor creates, and the
+ * TTS provider.
  *
  * A separate entry point rather than additions to `.` for the same reason
  * `runtime/internal` and `policy/internal` exist: this is a surface for sibling
@@ -18,7 +18,7 @@
  * A host writing its own capability package imports from here too, which is the
  * point — the mechanism is the same one our own registrations use.
  */
-export { ToolRegistry } from "../services/ToolRegistry.js";
+export { resolveToolProviderId, ToolRegistry, } from "../services/ToolRegistry.js";
 // A registration's own display name in the interface locale. A tool window's
 // title is the registration's name, so the shell needs the same `nameKey`-then-
 // `name` precedence the toolbar uses rather than the raw English field.
@@ -33,9 +33,7 @@ export { createScopedToolId } from "../services/tool-instance-id.js";
 export { createToolElement, resolveToolTag, toToolIdFromTag, } from "./tool-tag-map.js";
 // Toolbar button/overlay wiring shared by every toolbar-toggle registration.
 export { applyOverlaySurface, createScopedVisibilityBinding, syncButtonAndOverlayVisibility, } from "./registrations/toolbar-registration-helpers.js";
-// Provider descriptors for the two packaged capabilities that ship one. These
-// stay here rather than moving with the registrations because they are written
-// against the `pie-calculator` and `pie-tts` contract packages, which the
-// toolkit's own `TTSService` and provider registry also depend on.
-export { CortexToolProvider, DesmosToolProvider, GeoGebraToolProvider, TTSToolProvider, } from "../services/tool-providers/index.js";
+// The TTS provider stays here because it is written against the `pie-tts`
+// contract package, which the toolkit's own `TTSService` also depends on.
+export { TTSToolProvider } from "../services/tool-providers/index.js";
 export { buildRuntimeTTSConfig, normalizeTTSLayoutMode, normalizeTTSSpeedControlOptions, resolveRuntimeProvider, resolveTTSBackend, resolveTTSHostToolbarLayout, resolveTTSLayoutMode, resolveTTSRuntimeSettings, resolveTransportMode, } from "../services/tts-runtime-config.js";