@pie-players/pie-assessment-toolkit 1.0.0-beta.7 → 1.0.0-beta.8

package/dist/services/ToolkitCoordinator.js

@@ -31,9 +31,9 @@ import { FrameworkErrorBus, } from "./framework-error-bus.js";
 import { HighlightCoordinator } from "./HighlightCoordinator.js";
 import { ToolCoordinator } from "./ToolCoordinator.js";
 import { TTSService } from "./TTSService.js";
-import { BrowserTTSProvider, browserFallbackConfig, } from "./tts/browser-provider.js";
-import { buildRuntimeTTSConfig, resolveTTSBackend, resolveTTSRuntimeSettings, } from "./tts-runtime-config.js";
 import { ToolProviderRegistry } from "./tool-providers/index.js";
+import { TtsLifecycle, TTS_TOOL_ID, deepMergeMathSpeech, } from "./tts/tts-lifecycle.js";
+import { DEFAULT_TOOL_PROVIDERS } from "./tool-provider-defaults.js";
 import { ToolRegistry } from "./ToolRegistry.js";
 import { ToolRequestRegistry } from "./tool-request.js";
 import { ToolPolicyEngine, } from "../policy/engine.js";
@@ -52,13 +52,11 @@ class SectionControllerRetiredError extends Error {
         this.name = "SectionControllerRetiredError";
     }
 }
-const isPlainRecord = (value) => !!value && typeof value === "object" && !Array.isArray(value);
 const mergeToolConfigUpdate = (toolId, current, updates) => {
     const next = { ...current, ...updates };
-    if (toolId === "textToSpeech" &&
-        isPlainRecord(current.mathSpeech) &&
-        isPlainRecord(updates.mathSpeech)) {
-        next.mathSpeech = { ...current.mathSpeech, ...updates.mathSpeech };
+    const deepMathSpeech = deepMergeMathSpeech(toolId, current, updates);
+    if (deepMathSpeech) {
+        next.mathSpeech = deepMathSpeech;
     }
     return next;
 };
@@ -136,11 +134,7 @@ export class ToolkitCoordinator {
     hooks;
     lazyInit;
     /** Track TTS initialization state */
-    ttsInitialized = false;
-    /** Text-to-speech failed to start and policy does not grant it. */
-    ttsDegraded = false;
-    ttsInitPromise;
-    ttsReconfigurePromise;
+    tts;
     /**
      * The loader ran, whether or not it returned state. A failed load is
      * reported once and the coordinator runs without saved tool state.
@@ -243,18 +237,6 @@ export class ToolkitCoordinator {
      * lifetime for no new information.
      */
     reportedUnboundFeaturePolicy = false;
-    /**
-     * Whether {@link _initializeTTS} has already reported a non-browser backend
-     * falling back to browser speech because no text-to-speech provider is registered.
-     * Once per coordinator: a text-to-speech config change re-runs
-     * initialization, and the missing provider is the same gap each time.
-     */
-    reportedMissingTTSProvider = false;
-    /**
-     * The backend of a fallback {@link reportMissingTTSProvider} held back while
-     * the registry was unsettled, reported if the bound toolkit has no registry.
-     */
-    heldMissingTTSProviderBackend = null;
     /**
      * Whether {@link validateToolsConfig} has already reported validating with
      * no registry (`tools.registryUnavailable`). Once per coordinator: every
@@ -278,13 +260,7 @@ export class ToolkitCoordinator {
                 toolRegistry,
             });
         const defaultProviders = {
-            textToSpeech: {
-                enabled: true,
-                backend: "browser",
-            },
-            annotationToolbar: {
-                enabled: true,
-            },
+            ...DEFAULT_TOOL_PROVIDERS,
         };
         return {
             ...config,
@@ -358,7 +334,27 @@ export class ToolkitCoordinator {
         // A caller that speaks without `ensureTTSReady()` first, such as selection
         // read-aloud, starts the service instead of finding it uninitialized.
         this.ttsService.setReadinessGate(() => this.ensureTTSReady());
-        this.ttsService.setMathSpeechSource(() => buildRuntimeTTSConfig(resolveTTSRuntimeSettings(this.resolveTTSToolConfig())).providerOptions?.mathSpeech);
+        this.tts = new TtsLifecycle({
+            assertNotDisposed: () => this.assertNotDisposed(),
+            isDisposalStarted: () => this.disposePromise !== null,
+            isDisposalError: (error) => error instanceof ToolkitCoordinatorDisposedError,
+            emitTelemetry: (eventName, payload) => this.emitTelemetry(eventName, payload),
+            hooks: this.hooks,
+            toolProviderRegistry: this.toolProviderRegistry,
+            initializeProvider: (toolId, fallbackFollows) => this.initializeProvider(toolId, fallbackFollows),
+            ttsService: this.ttsService,
+            catalogResolver: this.catalogResolver,
+            clearDegradedTool: (toolId) => void this.degradedTools.delete(toolId),
+            reportStartFailure: (error, context, toolIds) => this.reportStartFailure(error, context, toolIds),
+            isToolGranted: (toolId) => this.isToolGranted(toolId),
+            lazyInit: this.lazyInit,
+            isToolRegistryPending: () => this.toolRegistryPending(),
+            providersConfig: () => this.config.tools?.providers,
+            getProviderDescriptorTools: () => this.getProviderDescriptorTools(),
+            registerProviderFromTool: (tool, replace) => this.registerProviderFromTool(tool, replace),
+            notifyReadyChange: () => this.notifyReadyChange(),
+        });
+        this.ttsService.setMathSpeechSource(() => this.tts.mathSpeechRuntimeOptions());
         this.setupStatePersistenceHooks();
         // The unified ToolPolicyEngine, seeded with the validated tools config.
         // The assessment starts `null` and items register their settings as they
@@ -724,17 +720,6 @@ export class ToolkitCoordinator {
     toolRegistryPending() {
         return !this.toolRegistrySettled && !this.toolRegistryAbsent;
     }
-    reportMissingTTSProvider(backend) {
-        // The toolkit this coordinator binds to may still supply the provider.
-        if (this.toolRegistryPending()) {
-            this.heldMissingTTSProviderBackend = backend;
-            return;
-        }
-        if (this.reportedMissingTTSProvider)
-            return;
-        this.reportedMissingTTSProvider = true;
-        console.warn(`[ToolkitCoordinator] Text-to-speech is configured for the "${backend}" backend but falls back to browser speech: no "textToSpeech" tool provider is registered. A coordinator registers tool providers only from its \`toolRegistry\`, or from its toolkit's when constructed without one, so supply one that carries the text-to-speech registration — for the packaged capability set, \`createPackagedToolRegistry()\` from "@pie-players/pie-default-tool-loaders". Reported once per coordinator.`);
-    }
     /**
      * Take the registry of the toolkit this coordinator is bound to, when the host
      * constructed it without one: the config is validated against it, its
@@ -751,8 +736,6 @@ export class ToolkitCoordinator {
             return false;
         if (!registry && this.toolRegistryAbsent)
             return false;
-        const heldBackend = this.heldMissingTTSProviderBackend;
-        this.heldMissingTTSProviderBackend = null;
         const strictness = this.config.toolConfigStrictness ?? "error";
         const source = "ToolkitCoordinator.adoptToolRegistry";
         if (!registry) {
@@ -762,13 +745,13 @@ export class ToolkitCoordinator {
                 source,
                 toolRegistry: this.toolRegistry,
             });
-            if (heldBackend)
-                this.reportMissingTTSProvider(heldBackend);
+            this.tts.reportHeldMissingProvider();
             return false;
         }
         this.toolRegistrySettled = true;
         this.toolRegistry = registry;
         this.config.toolRegistry = registry;
+        this.tts.discardHeldMissingProvider();
         try {
             // Warn at most: the config was accepted at construction, and a binding
             // toolkit has no caller to throw to.
@@ -782,16 +765,14 @@ export class ToolkitCoordinator {
             console.warn("[ToolkitCoordinator] Tool config does not validate against the adopted tool registry:", err);
         }
         this.policyEngine.replaceToolRegistry(registry, this.config.tools);
-        const ttsStarted = this.ttsInitialized ||
-            this.ttsInitPromise !== undefined ||
-            this.ttsReconfigurePromise !== undefined;
+        const ttsStarted = this.tts.isStarted();
         for (const tool of this.getProviderDescriptorTools()) {
-            if (ttsStarted && tool.toolId === "textToSpeech")
+            if (ttsStarted && this.tts.ownsTool(tool.toolId))
                 continue;
             void this.registerProviderFromTool(tool);
         }
         if (ttsStarted)
-            this.scheduleTTSReconfigure();
+            this.tts.scheduleReconfigure();
         return true;
     }
     _registerToolProviders() {
@@ -1738,159 +1719,19 @@ export class ToolkitCoordinator {
         if (this.coordinatorReadyPromise) {
             pending.add(this.coordinatorReadyPromise);
         }
-        if (this.ttsInitPromise)
-            pending.add(this.ttsInitPromise);
-        if (this.ttsReconfigurePromise) {
-            pending.add(this.ttsReconfigurePromise);
-        }
+        this.tts.flushInitPromises(pending);
         for (const promise of this.providerInitPromises.values()) {
             pending.add(promise);
         }
         await settleAll(pending);
     }
     /**
-     * Initialize the TTS service from the `textToSpeech` tool config.
+     * Initialize the TTS service from the `textToSpeech` tool config. The
+     * lifecycle itself lives in `services/tts/tts-lifecycle.ts`; the coordinator
+     * keeps the public method hosts call.
      */
     async ensureTTSReady() {
-        this.assertNotDisposed();
-        await this.waitForPendingTTSReconfigure();
-        this.assertNotDisposed();
-        if (this.ttsInitialized)
-            return;
-        if (this.ttsInitPromise)
-            return this.ttsInitPromise;
-        this.ttsInitPromise = this._initializeTTS()
-            .then(() => this.assertNotDisposed())
-            .finally(() => {
-            this.ttsInitPromise = undefined;
-            this.notifyReadyChange();
-        });
-        return this.ttsInitPromise;
-    }
-    async waitForPendingTTSReconfigure() {
-        let pending = this.ttsReconfigurePromise;
-        while (pending) {
-            await pending;
-            pending = this.ttsReconfigurePromise;
-        }
-    }
-    async _initializeTTS() {
-        if (this.ttsInitialized)
-            return;
-        const resolvedToolConfig = this.resolveTTSToolConfig();
-        const runtimeSettings = resolveTTSRuntimeSettings(resolvedToolConfig);
-        const resolvedBackend = resolveTTSBackend(runtimeSettings);
-        const runtimeTTSConfig = buildRuntimeTTSConfig(runtimeSettings);
-        await this.hooks.onBeforeTTSInit?.({
-            phase: "tts-init",
-            details: {
-                backend: resolvedBackend,
-            },
-        });
-        this.assertNotDisposed();
-        await this.emitTelemetry("pie-toolkit-tts-init-start", {
-            backend: resolvedBackend,
-        });
-        await this.emitTelemetry("pie-tool-init-start", {
-            toolId: "textToSpeech",
-            operation: "tts-init",
-            backend: resolvedBackend,
-        });
-        if (this.toolProviderRegistry.has("textToSpeech")) {
-            try {
-                // Browser speech follows a server provider that fails to start.
-                const ttsProvider = await this.initializeProvider("textToSpeech", true);
-                const providerInstance = await ttsProvider.createInstance();
-                await this.initializeTTSService(providerInstance, runtimeTTSConfig);
-                await this.emitTelemetry("pie-toolkit-tts-init-success", {
-                    provider: "registry",
-                });
-                await this.emitTelemetry("pie-tool-init-success", {
-                    toolId: "textToSpeech",
-                    operation: "tts-init",
-                    backend: resolvedBackend,
-                    provider: "registry",
-                });
-                return;
-            }
-            catch (error) {
-                if (error instanceof ToolkitCoordinatorDisposedError)
-                    throw error;
-                const normalized = error instanceof Error ? error : new Error(String(error));
-                await this.emitTelemetry("pie-tool-init-fallback", {
-                    toolId: "textToSpeech",
-                    operation: "tts-init",
-                    backend: resolvedBackend,
-                    fromProvider: "registry",
-                    toProvider: "browser",
-                    reason: normalized.message,
-                });
-                console.warn("[ToolkitCoordinator] Failed to initialize TTS via registry, falling back to browser provider:", normalized);
-            }
-        }
-        else if (resolvedBackend !== "browser") {
-            this.reportMissingTTSProvider(resolvedBackend);
-        }
-        // Browser speech, configured or standing in for a backend that has no
-        // provider or failed to start.
-        const provider = new BrowserTTSProvider();
-        try {
-            await this.initializeTTSService(provider, resolvedBackend === "browser"
-                ? runtimeTTSConfig
-                : browserFallbackConfig(runtimeTTSConfig));
-            await this.emitTelemetry("pie-toolkit-tts-init-success", {
-                provider: "browser-fallback",
-            });
-            await this.emitTelemetry("pie-tool-init-success", {
-                toolId: "textToSpeech",
-                operation: "tts-init",
-                backend: resolvedBackend,
-                provider: "browser-fallback",
-            });
-        }
-        catch (error) {
-            if (error instanceof ToolkitCoordinatorDisposedError)
-                throw error;
-            const normalized = error instanceof Error ? error : new Error(String(error));
-            this.reportStartFailure(normalized, { phase: "tts-init" }, ["textToSpeech"]);
-            await this.emitTelemetry("pie-toolkit-tts-init-error", {
-                message: normalized.message,
-            });
-            await this.emitTelemetry("pie-tool-init-error", {
-                toolId: "textToSpeech",
-                operation: "tts-init",
-                backend: resolvedBackend,
-                errorType: "TTSInitError",
-                message: normalized.message,
-            });
-            throw normalized;
-        }
-    }
-    resolveTTSToolConfig() {
-        return this.getTTSConfigFromProviders() || {};
-    }
-    async initializeTTSService(provider, config) {
-        const nextProviderOptions = {
-            ...config.providerOptions,
-            __pieTelemetry: async (eventName, payload) => {
-                await this.emitTelemetry(eventName, {
-                    toolId: "textToSpeech",
-                    ...(payload || {}),
-                });
-            },
-        };
-        const nextConfig = {
-            ...config,
-            providerOptions: nextProviderOptions,
-        };
-        await this.ttsService.initialize(provider, nextConfig);
-        this.assertNotDisposed();
-        this.ttsService.setCatalogResolver(this.catalogResolver);
-        this.ttsInitialized = true;
-        this.ttsDegraded = false;
-        this.degradedTools.delete("textToSpeech");
-        await this.hooks.onTTSReady?.();
-        this.assertNotDisposed();
+        return this.tts.ensureReady();
     }
     async waitUntilReady() {
         this.assertNotDisposed();
@@ -1901,8 +1742,8 @@ export class ToolkitCoordinator {
         this.coordinatorReadyPromise = (async () => {
             await this.ensureStateLoaded();
             this.assertNotDisposed();
-            if (this.ttsRequiredForReadiness()) {
-                await this.startTTSForReadiness();
+            if (this.tts.requiredForReadiness()) {
+                await this.tts.startForReadiness();
             }
             this.assertNotDisposed();
             if (!this.coordinatorReadyNotified) {
@@ -1920,39 +1761,9 @@ export class ToolkitCoordinator {
     }
     isReady() {
         return ((this.stateLoadSettled || !this.hooks.loadToolState) &&
-            (this.ttsInitialized ||
-                this.ttsDegraded ||
-                !this.ttsRequiredForReadiness()));
-    }
-    /**
-     * Readiness waits for text-to-speech when it is enabled and either starts
-     * eagerly or is granted: a granted read-aloud fails before the learner starts.
-     */
-    ttsRequiredForReadiness() {
-        if (this.getTTSConfigFromProviders()?.enabled === false)
-            return false;
-        return !this.lazyInit || this.isToolGranted("textToSpeech");
-    }
-    /**
-     * Starts text-to-speech for readiness. A failure policy does not grant leaves
-     * the tool degraded, reporting itself unavailable, and readiness settles; a
-     * granted tool's failure rejects.
-     */
-    async startTTSForReadiness() {
-        try {
-            await this.ensureTTSReady();
-        }
-        catch (error) {
-            if (error instanceof ToolkitCoordinatorDisposedError)
-                throw error;
-            if (this.isToolGranted("textToSpeech"))
-                throw error;
-            this.ttsDegraded = true;
-            this.notifyReadyChange();
-        }
-    }
-    getTTSConfigFromProviders() {
-        return this.config.tools?.providers?.textToSpeech;
+            (this.tts.started ||
+                this.tts.failedUngranted ||
+                !this.tts.requiredForReadiness()));
     }
     assertCanonicalToolId(toolId) {
         if (typeof toolId !== "string" || toolId.trim().length === 0) {
@@ -2360,8 +2171,8 @@ export class ToolkitCoordinator {
     _applyToolConfigChange(toolId) {
         if (this.disposePromise !== null)
             return;
-        if (toolId === "textToSpeech") {
-            this.scheduleTTSReconfigure();
+        if (this.tts.ownsTool(toolId)) {
+            this.tts.scheduleReconfigure();
             return;
         }
         this._registerChangedToolProvider(toolId);
@@ -2379,54 +2190,4 @@ export class ToolkitCoordinator {
         this.degradedTools.delete(toolId);
         void this.registerProviderFromTool(registration, true);
     }
-    /**
-     * Re-register the text-to-speech provider for the current config and registry, then
-     * re-initialize unless initialization is lazy. An initialization already
-     * running finishes first: it would otherwise mark its provider ready after
-     * the reset.
-     */
-    scheduleTTSReconfigure() {
-        const inFlight = this.ttsInitPromise;
-        const reconfigurePromise = inFlight
-            ? inFlight.catch(() => { }).then(() => this._reconfigureTTSProvider())
-            : this._reconfigureTTSProvider();
-        this.ttsReconfigurePromise = reconfigurePromise;
-        void reconfigurePromise.finally(() => {
-            if (this.ttsReconfigurePromise === reconfigurePromise) {
-                this.ttsReconfigurePromise = undefined;
-            }
-        });
-        void reconfigurePromise
-            .then(async () => {
-            if (this.disposePromise !== null)
-                return;
-            if (this.ttsRequiredForReadiness())
-                await this.startTTSForReadiness();
-        })
-            // Reported where it failed; a granted failure has nowhere else to go.
-            .catch(() => { });
-    }
-    async _reconfigureTTSProvider() {
-        this.ttsInitialized = false;
-        this.ttsDegraded = false;
-        this.degradedTools.delete("textToSpeech");
-        this.ttsInitPromise = undefined;
-        this.notifyReadyChange();
-        try {
-            // The next speak waits on readiness, which starts the new provider.
-            this.ttsService.releaseProvider();
-        }
-        catch {
-            // noop: release best effort
-        }
-        if (this.toolProviderRegistry.has("textToSpeech")) {
-            await this.toolProviderRegistry.unregister("textToSpeech");
-        }
-        if (this.disposePromise !== null)
-            return;
-        const ttsRegistration = this.getProviderDescriptorTools().find((tool) => tool.toolId === "textToSpeech");
-        if (!ttsRegistration)
-            return;
-        await this.registerProviderFromTool(ttsRegistration);
-    }
 }

package/dist/services/section-controller-types.d.ts

@@ -270,6 +270,26 @@ export type SectionControllerTimedMediaInvalidEvent = SectionControllerEventBase
 };
 export type SectionControllerEvent = SectionControllerItemSessionDataChangedEvent | SectionControllerItemSessionMetaChangedEvent | SectionControllerItemSelectedEvent | SectionControllerSectionNavigationChangedEvent | SectionControllerSectionSessionAppliedEvent | SectionControllerContentLoadedEvent | SectionControllerItemPlayerErrorEvent | SectionControllerItemCompleteChangedEvent | SectionControllerSectionLoadingCompleteEvent | SectionControllerSectionItemsCompleteChangedEvent | SectionControllerSectionErrorEvent | SectionControllerFormativeTryRecordedEvent | SectionControllerFormativeRevealChangedEvent | SectionControllerSectionMasteryChangedEvent | SectionControllerTimedMediaCueChangedEvent | SectionControllerTimedMediaAudioStartedEvent | SectionControllerTimedMediaPolicyDegradedEvent | SectionControllerTimedMediaInvalidEvent;
 export type SectionControllerEventType = SectionControllerEvent["type"];
+/** One item's part of a {@link SectionScore}. */
+export type SectionItemScore = {
+    canonicalItemId: string;
+    /**
+     * The item's element outcomes, one slot per scored model as
+     * `pie-item-player.provideScore()` returns them. `null` while the item is not
+     * rendered, or when it has no scorable model.
+     */
+    outcomes: Array<Record<string, unknown> | undefined> | null;
+};
+/** The section's browser score, from {@link SectionControllerHandle.score}. */
+export type SectionScore = {
+    /** Every item in the section, in section order. */
+    items: SectionItemScore[];
+};
+/**
+ * Scores one rendered item in the browser: its element outcomes, or `false` when
+ * the item is not rendered or has no scorable model.
+ */
+export type SectionItemScorer = (canonicalItemId: string) => Promise<false | Array<Record<string, unknown> | undefined>>;
 /**
  * Host-facing controller for a single section cohort.
  *
@@ -422,6 +442,26 @@ export interface SectionControllerHandle {
      * those boundaries.
      */
     setPendingSessionCommit?(commit: (() => void) | null): void;
+    /**
+     * Commit every element's pending response to the section session, so the
+     * next `getSession()` holds it. For a host about to read or submit the
+     * session; the controller already commits before its own boundaries.
+     */
+    commitPendingSessions?(): void;
+    /**
+     * Register how the controller scores a rendered item. The controller is
+     * DOM-free, so the layout that renders the item players supplies it, as with
+     * `setPendingSessionCommit`. The latest registration wins; the returned
+     * release unregisters this scorer and leaves a later one in place, so two
+     * layouts on one controller do not unregister each other.
+     */
+    registerItemScorer?(scorer: SectionItemScorer): () => void;
+    /**
+     * Score the section in the browser: each item's element outcomes, in section
+     * order. An item that is not rendered, or has no scorable model, scores
+     * `null`.
+     */
+    score?(): Promise<SectionScore>;
     /**
      * Record one Try for an item: derive correctness from the element outcomes,
      * increment the Try count, and reveal feedback if the item's resolved

package/dist/services/tool-config-validation.d.ts

@@ -3,7 +3,7 @@ import type { ToolRegistry } from "./ToolRegistry.js";
 export type ToolConfigStrictness = "off" | "warn" | "error";
 export type ToolConfigDiagnosticSeverity = "warning" | "error";
 export interface ToolConfigDiagnostic {
-    code: "tools.unknownToolId" | "tools.unsupportedLevel" | "tools.unplaceableActivation" | "tools.registryUnavailable" | "tools.unknownProviderKey" | "tools.providerSanitizeFailed" | "tools.providerValidateFailed" | "tools.invalidProviderValidation";
+    code: "tools.unknownToolId" | "tools.unsupportedLevel" | "tools.unplaceableActivation" | "tools.registryUnavailable" | "tools.unknownProviderKey" | "tools.providerSanitizeFailed" | "tools.providerValidateFailed" | "tools.invalidProviderValidation" | "tools.invalidProviderConfig";
     severity: ToolConfigDiagnosticSeverity;
     path: string;
     message: string;

package/dist/services/tool-context.js

@@ -31,6 +31,45 @@ function isElementContext(context) {
     return context.level === "element";
 }
 const stripHtml = (value) => value.replace(/<[^>]*>/g, " ").trim();
+// The digit fold mirrors pie-elements-ng's response normalizer
+// (`controller-utils/src/response-normalizer.ts`), so tool visibility and
+// scoring read one number the same way. The separators fold to the
+// point-decimal marks the patterns below are written in.
+const DECIMAL_DIGIT = /\p{Nd}/u;
+const NON_ASCII_DIGITS = /(?![0-9])\p{Nd}/gu;
+// ALM, LRM, RLM, the embeddings and overrides, the isolates, and tatweel.
+const BIDI_CONTROLS_AND_TATWEEL = /[\u061C\u200E\u200F\u202A-\u202E\u2066-\u2069\u0640]/g;
+const digitValues = new Map();
+/**
+ * A decimal digit's value: its offset into its run of ten. Unicode assigns
+ * decimal digits only in ascending runs from zero, and runs can abut, hence the
+ * modulo.
+ */
+function digitValue(codePoint) {
+    const cached = digitValues.get(codePoint);
+    if (cached !== undefined)
+        return cached;
+    let offset = 0;
+    while (DECIMAL_DIGIT.test(String.fromCodePoint(codePoint - offset - 1))) {
+        offset += 1;
+    }
+    const value = offset % 10;
+    digitValues.set(codePoint, value);
+    return value;
+}
+/**
+ * Text with every decimal digit in ASCII, the Arabic decimal, thousands and
+ * percent signs as `.`, `,` and `%`, and bidi controls and tatweel removed, so
+ * the patterns below match `٣٫٥ × ٢ = ٧` as they match `3.5 × 2 = 7`.
+ */
+function foldNumerals(text) {
+    return text
+        .replace(BIDI_CONTROLS_AND_TATWEEL, "")
+        .replace(NON_ASCII_DIGITS, (digit) => String(digitValue(digit.codePointAt(0))))
+        .replace(/\u066B/g, ".")
+        .replace(/\u066C/g, ",")
+        .replace(/\u066A/g, "%");
+}
 /**
  * A config's `models` as a list, whether it was authored as an array or as a
  * record keyed by element id. Both forms are in the wild.
@@ -155,6 +194,10 @@ function extractContent(context, transform) {
 function extractTextContent(context) {
     return extractContent(context, stripHtml);
 }
+/** The plain text a context carries, with its numerals folded for matching. */
+function extractMatchableText(context) {
+    return foldNumerals(extractTextContent(context));
+}
 /**
  * The authored markup a context carries, tags intact.
  *
@@ -250,10 +293,24 @@ function hasSpacedSubtraction(text) {
     });
 }
 const PERCENTAGE = /\d\s*%/;
-/** A percentage taken of a number: `20% of 50`, `15% of $80`, `el 20% de 50`. */
-const PERCENTAGE_OF_NUMBER = /\d\s*%\s+(?:of|de|van)\s+[$€£]?\s?\d/i;
-/** A money amount: `$40`, `€ 12`, `12,50 €`. */
-const MONEY = /[$€£]\s?\d|\d\s?[€£]/;
+/**
+ * A percentage taken of a number: `20% of 50`, `15% of $80`, `el 20% de 50`,
+ * `٢٠٪ من ٥٠`.
+ */
+const PERCENTAGE_OF_NUMBER = /\d\s*%\s+(?:of|de|van|من)\s+\p{Sc}?\s?\d/iu;
+/** A money amount: `$40`, `€ 12`, `12,50 €`, `٥٠ ؋`. */
+const MONEY = /\p{Sc}\s?\d|\d\s?\p{Sc}/u;
+/**
+ * Currencies written as a word after the amount, by content language.
+ *
+ * Arabic writes most currencies as a word or an abbreviation where English
+ * writes a sign: `٥٠ ريالًا`, `١٢ د.إ`. English has no set, because its
+ * spelled-out "40 dollars" never counted. Script-disjoint, so every set is
+ * tried. The Arabic set is pending the native review (PIE-1364).
+ */
+const CURRENCY_WORDS = {
+    ar: /\d\s*(?:ريال|دينار|درهم|جنيه|دولار|يورو|ليرة|ر\.س|د\.إ|د\.ك|ج\.م)/u,
+};
 /**
  * Whether the text applies a percentage to a quantity.
  *
@@ -265,7 +322,10 @@ const MONEY = /[$€£]\s?\d|\d\s?[€£]/;
 function hasAppliedPercentage(text) {
     if (PERCENTAGE_OF_NUMBER.test(text))
         return true;
-    return PERCENTAGE.test(text) && MONEY.test(text);
+    if (!PERCENTAGE.test(text))
+        return false;
+    return (MONEY.test(text) ||
+        Object.values(CURRENCY_WORDS).some((pattern) => pattern.test(text)));
 }
 /**
  * Helper to check if context contains mathematical content
@@ -283,7 +343,7 @@ export function hasMathContent(context) {
     ];
     if (structuralIndicators.some((pattern) => pattern.test(markup)))
         return true;
-    const text = extractTextContent(context);
+    const text = extractMatchableText(context);
     // No bare-operator pattern: a lone hyphen or slash matches "well-known" and
     // "and/or", which would make nearly every item mathematical. An operator
     // counts only with operands around it, or when the character has no prose
@@ -399,16 +459,39 @@ export function hasSpokenContent(context) {
  * (Basic heuristic - can be overridden by tools)
  */
 export function hasScienceContent(context) {
-    const text = extractTextContent(context);
+    const text = extractMatchableText(context);
     if (hasChemicalFormula(text))
         return true;
     if (/[A-Z][a-z]?[\u2080-\u2089]/.test(text))
         return true; // Subscripted: H₂O, CO₂
-    const scienceIndicators = [
+    return Object.values(SCIENCE_KEYWORDS).some((patterns) => patterns.some((pattern) => pattern.test(text)));
+}
+/**
+ * Science vocabulary by content language, one pattern per field: chemistry,
+ * element naming, biology, physics.
+ *
+ * Every set is tried, because the sets are script-disjoint and content often
+ * declares no language: an Arabic pattern cannot match English text. A language
+ * is added as a set of its own.
+ *
+ * Arabic attaches the conjunction, prepositions and article to the word, so its
+ * patterns match stems unanchored. The exceptions are قوة (force) and طاقة
+ * (energy), bounded the way `\bforce\b` is: unbounded, بطاقة (card) and بقوة
+ * (strongly) would match. "compound" has no Arabic entry, since مركب is also a
+ * vehicle; كيميائي covers a chemical compound. The Arabic set is pending the
+ * native review (PIE-1364).
+ */
+const SCIENCE_KEYWORDS = {
+    en: [
         /chemistry|chemical|molecule|compound|periodic\s+table/i,
         /\bchemical\s+element\b|\belement\s+symbol\b/i,
         /biology|organism|\bDNA\b|\bRNA\b|protein|photosynthesis|ecosystem/i,
         /physics|\bforce\b|\benergy\b|velocity|acceleration|momentum/i,
-    ];
-    return scienceIndicators.some((pattern) => pattern.test(text));
-}
+    ],
+    ar: [
+        /كيمياء|كيميائي|جزيء|جزيئ|جدول\s+(?:ال)?دوري/u,
+        /رمز\s+(?:ال)?عنصر/u,
+        /علم\s+الأحياء|كائن(?:ات)?\s+(?:ال)?حي|حمض\s+(?:ال)?نووي|بروتين|(?:بناء|تمثيل)\s+(?:ال)?ضوئي|(?:نظام|نظم|أنظمة)\s+(?:ال)?بيئي/u,
+        /فيزياء|فيزيائي|(?<!\p{L})(?:و|ال|وال)?(?:قوة|قوى|طاقة)(?!\p{L})|سرعة\s+(?:ال)?متجهة|تسارع|كمية\s+(?:ال)?حركة/u,
+    ],
+};