@pie-players/pie-assessment-toolkit 0.3.73 → 0.3.75

package/dist/services/tool-providers/GeoGebraToolProvider.d.ts

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

package/dist/services/tool-providers/GeoGebraToolProvider.js

@@ -1,32 +0,0 @@
-/** 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;
-    getDefinition() {
-        return {
-            backend: "geogebra",
-            moduleImportOperation: "geogebra-provider-module-import",
-            loadProvider: async () => {
-                const module = await import("@pie-players/pie-calculator-geogebra");
-                return module.GeoGebraCalculatorProvider;
-            },
-            initializationErrorMessage: "Failed to initialize GeoGebra calculator provider. Confirm that the deployment may load GeoGebra and that its script URL is reachable.",
-        };
-    }
-    getCapabilities() {
-        return {
-            supportsOffline: false,
-            requiresAuth: false,
-            maxInstances: null,
-            features: {
-                basic: true,
-                scientific: true,
-                graphing: true,
-                fourFunction: false,
-            },
-        };
-    }
-}

package/dist/services/tool-providers/LazyCalculatorToolProvider.d.ts

@@ -1,35 +0,0 @@
-import type { CalculatorProvider, CalculatorProviderInit } from "@pie-players/pie-calculator";
-import type { ToolProviderApi, ToolProviderCapabilities } from "./ToolProviderApi.js";
-export type CalculatorToolProviderInitConfig = Pick<CalculatorProviderInit, "onTelemetry">;
-type InitializableCalculatorProvider<TConfig> = CalculatorProvider & {
-    initialize(config: TConfig): Promise<void>;
-};
-export interface LazyCalculatorProviderDefinition<TConfig> {
-    backend: string;
-    moduleImportOperation: string;
-    loadProvider: () => Promise<new () => InitializableCalculatorProvider<TConfig>>;
-    initializationErrorMessage: string;
-}
-/**
- * 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;
-    abstract readonly providerName: string;
-    readonly category: "calculator";
-    abstract readonly version: string;
-    abstract readonly requiresAuth: boolean;
-    protected abstract getDefinition(): LazyCalculatorProviderDefinition<TConfig>;
-    abstract getCapabilities(): ToolProviderCapabilities;
-    private calculatorProvider;
-    private initializationPromise;
-    private lifecycleGeneration;
-    private emitTelemetry;
-    initialize(config?: TConfig): Promise<void>;
-    private initializeProvider;
-    createInstance(): Promise<CalculatorProvider>;
-    isReady(): boolean;
-    destroy(): void;
-}
-export {};

package/dist/services/tool-providers/LazyCalculatorToolProvider.js

@@ -1,95 +0,0 @@
-/**
- * Shared lazy-module and lifecycle implementation for calculator tool adapters.
- * Concrete adapters own only their metadata, capabilities and provider import.
- */
-export class LazyCalculatorToolProvider {
-    category = "calculator";
-    calculatorProvider = null;
-    initializationPromise = null;
-    lifecycleGeneration = 0;
-    async emitTelemetry(config, eventName, payload) {
-        try {
-            await config.onTelemetry?.(eventName, payload);
-        }
-        catch (error) {
-            console.warn(`[${this.providerName}] telemetry callback failed:`, error);
-        }
-    }
-    async initialize(config = {}) {
-        if (this.calculatorProvider)
-            return;
-        if (this.initializationPromise)
-            return this.initializationPromise;
-        const generation = ++this.lifecycleGeneration;
-        const initializationPromise = this.initializeProvider(config, generation);
-        this.initializationPromise = initializationPromise;
-        try {
-            await initializationPromise;
-        }
-        finally {
-            if (this.initializationPromise === initializationPromise) {
-                this.initializationPromise = null;
-            }
-        }
-    }
-    async initializeProvider(config, generation) {
-        const definition = this.getDefinition();
-        const moduleLoadStartedAt = Date.now();
-        await this.emitTelemetry(config, "pie-tool-library-load-start", {
-            toolId: "calculator",
-            operation: definition.moduleImportOperation,
-            backend: definition.backend,
-        });
-        let ProviderConstructor;
-        try {
-            ProviderConstructor = await definition.loadProvider();
-            await this.emitTelemetry(config, "pie-tool-library-load-success", {
-                toolId: "calculator",
-                operation: definition.moduleImportOperation,
-                backend: definition.backend,
-                duration: Date.now() - moduleLoadStartedAt,
-            });
-        }
-        catch (error) {
-            await this.emitTelemetry(config, "pie-tool-library-load-error", {
-                toolId: "calculator",
-                operation: definition.moduleImportOperation,
-                backend: definition.backend,
-                duration: Date.now() - moduleLoadStartedAt,
-                errorType: "ToolLibraryLoadError",
-                message: error instanceof Error ? error.message : String(error),
-            });
-            throw new Error(definition.initializationErrorMessage, { cause: error });
-        }
-        if (generation !== this.lifecycleGeneration) {
-            throw new Error(`${this.providerName} initialization was cancelled`);
-        }
-        const candidate = new ProviderConstructor();
-        try {
-            await candidate.initialize(config);
-            if (generation !== this.lifecycleGeneration) {
-                throw new Error(`${this.providerName} initialization was cancelled`);
-            }
-            this.calculatorProvider = candidate;
-        }
-        catch (error) {
-            candidate.destroy();
-            throw new Error(definition.initializationErrorMessage, { cause: error });
-        }
-    }
-    async createInstance() {
-        if (!this.calculatorProvider) {
-            throw new Error(`[${this.providerName}] Provider not initialized. Call initialize() first.`);
-        }
-        return this.calculatorProvider;
-    }
-    isReady() {
-        return this.calculatorProvider !== null;
-    }
-    destroy() {
-        this.lifecycleGeneration += 1;
-        this.initializationPromise = null;
-        this.calculatorProvider?.destroy();
-        this.calculatorProvider = null;
-    }
-}

package/dist/services/tts/visual-line-ranges.d.ts

@@ -1,18 +0,0 @@
-/**
- * Derive visual line box ranges inside a root element for TTS read-along.
- *
- * Cloud TTS (Polly, Google, etc.) only provides word/sentence character offsets.
- * “Lines” are layout-dependent (wrap, zoom, font size), so we compute them in
- * the browser from the same DOM Range already used for word highlighting.
- */
-/**
- * Intersect `range` with the contents of `root` (document order).
- * Returns null if there is no non-empty intersection.
- */
-export declare function intersectRangeWithElement(range: Range, root: Element): Range | null;
-/**
- * Returns one Range per visual line that intersects `focus`, expanded to the
- * full width of each line within `root`. Falls back to `[intersectedFocus]`
- * when layout or caret APIs are unavailable.
- */
-export declare function visualLineRangesForFocusInRoot(root: Element, focus: Range): Range[];

package/dist/services/tts/visual-line-ranges.js

@@ -1,226 +0,0 @@
-/**
- * Derive visual line box ranges inside a root element for TTS read-along.
- *
- * Cloud TTS (Polly, Google, etc.) only provides word/sentence character offsets.
- * “Lines” are layout-dependent (wrap, zoom, font size), so we compute them in
- * the browser from the same DOM Range already used for word highlighting.
- */
-const LINE_TOP_EPSILON = 2;
-const CARET_INSET = 1;
-const HORIZONTAL_PROBE_STEP = 3;
-const MAX_HORIZONTAL_PROBES = 400;
-const MAX_LINE_RANGES = 48;
-function caretRangeAtPoint(doc, x, y) {
-    const d = doc;
-    if (typeof d.caretRangeFromPoint === "function") {
-        try {
-            return d.caretRangeFromPoint(x, y);
-        }
-        catch {
-            return null;
-        }
-    }
-    const pos = d.caretPositionFromPoint?.(x, y);
-    if (pos?.offsetNode?.nodeType === Node.TEXT_NODE ||
-        pos?.offsetNode?.nodeType === Node.ELEMENT_NODE) {
-        const r = doc.createRange();
-        try {
-            r.setStart(pos.offsetNode, pos.offset);
-            r.collapse(true);
-            return r;
-        }
-        catch {
-            return null;
-        }
-    }
-    return null;
-}
-function collapsedRangeTop(r) {
-    const rects = r.getClientRects();
-    if (rects.length === 0)
-        return null;
-    return rects[0].top;
-}
-/**
- * Intersect `range` with the contents of `root` (document order).
- * Returns null if there is no non-empty intersection.
- */
-export function intersectRangeWithElement(range, root) {
-    if (typeof document === "undefined")
-        return null;
-    if (typeof range.compareBoundaryPoints !== "function")
-        return null;
-    try {
-        const doc = range.startContainer.ownerDocument || document;
-        const rootRange = doc.createRange();
-        rootRange.selectNodeContents(root);
-        if (range.compareBoundaryPoints(Range.END_TO_START, rootRange) <= 0) {
-            return null;
-        }
-        if (range.compareBoundaryPoints(Range.START_TO_END, rootRange) >= 0) {
-            return null;
-        }
-        const out = doc.createRange();
-        if (range.compareBoundaryPoints(Range.START_TO_START, rootRange) < 0) {
-            out.setStart(rootRange.startContainer, rootRange.startOffset);
-        }
-        else {
-            out.setStart(range.startContainer, range.startOffset);
-        }
-        if (range.compareBoundaryPoints(Range.END_TO_END, rootRange) > 0) {
-            out.setEnd(rootRange.endContainer, rootRange.endOffset);
-        }
-        else {
-            out.setEnd(range.endContainer, range.endOffset);
-        }
-        if (out.collapsed)
-            return null;
-        return out;
-    }
-    catch {
-        return null;
-    }
-}
-function lineKeyForRect(top) {
-    return Math.round(top / LINE_TOP_EPSILON);
-}
-function extendLineEdge(doc, root, refTop, midY, startX, rootLeft, rootRight, direction) {
-    let lastGood = null;
-    let x = startX;
-    if (direction === "left") {
-        for (let i = 0; i < MAX_HORIZONTAL_PROBES && x >= rootLeft + CARET_INSET; i++) {
-            const cr = caretRangeAtPoint(doc, x, midY);
-            if (!cr || !rootContainsNode(root, cr.startContainer))
-                break;
-            const t = collapsedRangeTop(cr);
-            if (t === null || Math.abs(t - refTop) > LINE_TOP_EPSILON)
-                break;
-            lastGood = cr.cloneRange();
-            x -= HORIZONTAL_PROBE_STEP;
-        }
-    }
-    else {
-        for (let i = 0; i < MAX_HORIZONTAL_PROBES && x <= rootRight - CARET_INSET; i++) {
-            const cr = caretRangeAtPoint(doc, x, midY);
-            if (!cr || !rootContainsNode(root, cr.startContainer))
-                break;
-            const t = collapsedRangeTop(cr);
-            if (t === null || Math.abs(t - refTop) > LINE_TOP_EPSILON)
-                break;
-            lastGood = cr.cloneRange();
-            x += HORIZONTAL_PROBE_STEP;
-        }
-    }
-    return lastGood;
-}
-function rootContainsNode(root, node) {
-    if (typeof root.contains !== "function")
-        return false;
-    try {
-        return root.contains(node);
-    }
-    catch {
-        return false;
-    }
-}
-function fallbackSingleRangeFromFocus(focus) {
-    try {
-        const doc = focus.startContainer.ownerDocument || document;
-        const r = doc.createRange();
-        r.setStart(focus.startContainer, focus.startOffset);
-        r.setEnd(focus.endContainer, focus.endOffset);
-        return [r];
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Returns one Range per visual line that intersects `focus`, expanded to the
- * full width of each line within `root`. Falls back to `[intersectedFocus]`
- * when layout or caret APIs are unavailable.
- */
-export function visualLineRangesForFocusInRoot(root, focus) {
-    if (typeof document === "undefined")
-        return [];
-    if (!focus.startContainer) {
-        return [];
-    }
-    const doc = focus.startContainer.ownerDocument || document;
-    const intersected = intersectRangeWithElement(focus, root);
-    if (!intersected) {
-        return fallbackSingleRangeFromFocus(focus);
-    }
-    let rects;
-    try {
-        rects = Array.from(intersected.getClientRects()).filter((r) => r.width > 0 && r.height > 0);
-    }
-    catch {
-        return [intersected.cloneRange()];
-    }
-    if (rects.length === 0) {
-        return [intersected.cloneRange()];
-    }
-    let rootBounds;
-    try {
-        rootBounds = root.getBoundingClientRect();
-    }
-    catch {
-        return [intersected.cloneRange()];
-    }
-    const groups = new Map();
-    for (const rect of rects) {
-        const key = lineKeyForRect(rect.top);
-        const list = groups.get(key);
-        if (list)
-            list.push(rect);
-        else
-            groups.set(key, [rect]);
-    }
-    const sortedKeys = Array.from(groups.keys()).sort((a, b) => a - b);
-    const out = [];
-    for (const key of sortedKeys) {
-        if (out.length >= MAX_LINE_RANGES)
-            break;
-        const group = groups.get(key);
-        if (!group?.length)
-            continue;
-        let sumTop = 0;
-        let sumMid = 0;
-        let minL = Infinity;
-        let maxR = -Infinity;
-        for (const r of group) {
-            sumTop += r.top;
-            sumMid += r.top + r.height / 2;
-            minL = Math.min(minL, r.left);
-            maxR = Math.max(maxR, r.right);
-        }
-        const refTop = sumTop / group.length;
-        const midY = sumMid / group.length;
-        const leftEdge = extendLineEdge(doc, root, refTop, midY, minL, rootBounds.left, rootBounds.right, "left");
-        const rightEdge = extendLineEdge(doc, root, refTop, midY, maxR, rootBounds.left, rootBounds.right, "right");
-        if (!leftEdge || !rightEdge) {
-            const fallback = intersected.cloneRange();
-            return [fallback];
-        }
-        const lineRange = doc.createRange();
-        try {
-            lineRange.setStart(leftEdge.startContainer, leftEdge.startOffset);
-            lineRange.setEnd(rightEdge.startContainer, rightEdge.startOffset);
-        }
-        catch {
-            return [intersected.cloneRange()];
-        }
-        if (lineRange.collapsed) {
-            return [intersected.cloneRange()];
-        }
-        const clipped = intersectRangeWithElement(lineRange, root);
-        if (clipped && !clipped.collapsed) {
-            out.push(clipped);
-        }
-        else {
-            return [intersected.cloneRange()];
-        }
-    }
-    return out.length > 0 ? out : [intersected.cloneRange()];
-}

package/dist/tools/client.d.ts

@@ -1,12 +0,0 @@
-/**
- * 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";

package/dist/tools/client.js

@@ -1,14 +0,0 @@
-/**
- * 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";

package/dist/tools/index.d.ts

@@ -1,8 +0,0 @@
-/**
- * Tool system exports
- *
- * For custom elements and client-side code, use
- * '@pie-players/pie-assessment-toolkit/tools/client' instead.
- */
-export * from "./client.js";
-export { VariantResolverImpl } from "./variant-resolver.js";

package/dist/tools/index.js

@@ -1,10 +0,0 @@
-/**
- * Tool system exports
- *
- * For custom elements and client-side code, use
- * '@pie-players/pie-assessment-toolkit/tools/client' instead.
- */
-// Re-export everything from client.ts (client-safe code)
-export * from "./client.js";
-// Variant resolver
-export { VariantResolverImpl } from "./variant-resolver.js";

package/dist/tools/internal.d.ts

@@ -1,43 +0,0 @@
-/**
- * Registration-authoring surface.
- *
- * 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.
- *
- * A separate entry point rather than additions to `.` for the same reason
- * `runtime/internal` and `policy/internal` exist: this is a surface for sibling
- * packages in this repo, not a contract offered to hosts. Widening `.` with two
- * dozen registration-authoring helpers would make every one of them something a
- * host could reasonably expect us to keep.
- *
- * It exists because the packaged registrations moved out to the composition layer
- * (`@pie-players/pie-default-tool-loaders`) so core stops naming capabilities.
- * 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 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 { resolveToolRegistrationName } from "../services/ToolRegistry.js";
-export type { CatalogOwnerCard, CatalogOwnerSnapshot, } from "../services/AccessibilityCatalogResolver.js";
-export type { ToolSelectionAction, ToolSelectionContext, } from "../services/selection-action.js";
-export type { ToolOpenRequest, ToolRequestTarget, } from "../services/tool-request.js";
-export { resolveFallbackToolIcon, TOOL_FALLBACK_ICONS, } from "../services/tool-icons.js";
-export type { ContentCapabilityPhase, ContentCapabilityPolicy, ResolveContentCapabilitiesArgs, ResolvedContentCapability, } from "./content-capability-resolution.js";
-export { resolveContentCapabilities } from "./content-capability-resolution.js";
-export type { ToolSurfaceHost, ToolSurfaceHostInput, ToolSurfaceHostOptions, ToolSurfaceHostSnapshot, ToolSurfaceScope, } from "./tool-surface-host.js";
-export { createToolSurfaceHost } from "./tool-surface-host.js";
-export type { ToolContext, ToolLevel } from "../services/tool-context.js";
-export { hasChoiceInteraction, hasMathContent, hasReadableText, hasScienceContent, } from "../services/tool-context.js";
-export { createScopedToolId } from "../services/tool-instance-id.js";
-export type { ToolComponentFactory, ToolComponentFactoryMap, ToolComponentOverrides, ToolTagMap, } from "./tool-tag-map.js";
-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 { ToolConfigDiagnostic } from "../services/tool-config-validation.js";
-export { CortexToolProvider, DesmosToolProvider, GeoGebraToolProvider, 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

@@ -1,41 +0,0 @@
-/**
- * Registration-authoring surface.
- *
- * 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.
- *
- * A separate entry point rather than additions to `.` for the same reason
- * `runtime/internal` and `policy/internal` exist: this is a surface for sibling
- * packages in this repo, not a contract offered to hosts. Widening `.` with two
- * dozen registration-authoring helpers would make every one of them something a
- * host could reasonably expect us to keep.
- *
- * It exists because the packaged registrations moved out to the composition layer
- * (`@pie-players/pie-default-tool-loaders`) so core stops naming capabilities.
- * 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";
-// 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.
-export { resolveToolRegistrationName } from "../services/ToolRegistry.js";
-// So a gateway button and the toolbar button for the same tool draw one icon.
-export { resolveFallbackToolIcon, TOOL_FALLBACK_ICONS, } from "../services/tool-icons.js";
-export { resolveContentCapabilities } from "./content-capability-resolution.js";
-export { createToolSurfaceHost } from "./tool-surface-host.js";
-export { hasChoiceInteraction, hasMathContent, hasReadableText, hasScienceContent, } from "../services/tool-context.js";
-// Scoped tool instance ids, so two placements of one tool do not share state.
-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";
-export { buildRuntimeTTSConfig, normalizeTTSLayoutMode, normalizeTTSSpeedControlOptions, resolveRuntimeProvider, resolveTTSBackend, resolveTTSHostToolbarLayout, resolveTTSLayoutMode, resolveTTSRuntimeSettings, resolveTransportMode, } from "../services/tts-runtime-config.js";

package/dist/tools/response-discovery.d.ts

@@ -1,61 +0,0 @@
-/**
- * Response Discovery Service
- * Finds and manages PIE response components for tool-to-response integration
- *
- * Enables tools (e.g., calculator) to insert content into response fields
- * Based on capability-based interface pattern (inspired by VS Code extension API)
- */
-import type { ContentFormat, PIEResponseComponent, ResponseDiscoveryService } from "./types.js";
-export declare class ResponseDiscoveryServiceImpl implements ResponseDiscoveryService {
-    private responses;
-    private activeResponseId;
-    private activeResponseListeners;
-    /**
-     * Get currently active (focused) response component
-     */
-    getActiveResponse(): PIEResponseComponent | null;
-    /**
-     * Get response by ID
-     */
-    getResponse(responseId: string): PIEResponseComponent | null;
-    /**
-     * Get all registered responses
-     */
-    getAllResponses(): PIEResponseComponent[];
-    /**
-     * Get responses that accept a specific content format
-     */
-    getResponsesAccepting(format: ContentFormat): PIEResponseComponent[];
-    /**
-     * Register a response component
-     */
-    registerResponse(response: PIEResponseComponent): void;
-    /**
-     * Unregister a response component
-     */
-    unregisterResponse(responseId: string): void;
-    /**
-     * Explicitly signal that a registered response is active.
-     */
-    signalActive(responseId: string): void;
-    /**
-     * Explicitly signal that a response is no longer active.
-     */
-    signalInactive(responseId: string): void;
-    /**
-     * Set active response (internal use)
-     */
-    private setActiveResponse;
-    /**
-     * Listen for active response changes
-     */
-    onActiveResponseChanged(listener: (response: PIEResponseComponent | null) => void): void;
-    /**
-     * Clear all responses (for cleanup)
-     */
-    clear(): void;
-}
-/**
- * Singleton instance
- */
-export declare const responseDiscovery: ResponseDiscoveryServiceImpl;