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

package/dist/services/createDefaultToolRegistry.js

@@ -1,45 +0,0 @@
-/**
- * Tool Registry Factory
- *
- * 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 { DEFAULT_TOOL_PLACEMENT } from "./tool-config-defaults.js";
-/**
- * Create a tool registry.
- *
- * @returns an empty `ToolRegistry` unless `registrations` is supplied
- */
-export function createDefaultToolRegistry(options = {}) {
-    const registry = new ToolRegistry();
-    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({
-        toolTagMap: options.toolTagMap,
-        toolComponentFactory: options.toolComponentFactory,
-        toolComponentFactories: options.toolComponentFactories,
-    });
-    return registry;
-}
-/**
- * Placement configuration with every level empty.
- *
- * 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 };

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

@@ -1,13 +0,0 @@
-/** Fully bundled open-source calculator adapter for the tool-provider registry. */
-import type { CalculatorToolProviderInitConfig, LazyCalculatorProviderDefinition } from "./LazyCalculatorToolProvider.js";
-import { LazyCalculatorToolProvider } from "./LazyCalculatorToolProvider.js";
-import type { ToolProviderCapabilities } from "./ToolProviderApi.js";
-export type CortexToolProviderConfig = CalculatorToolProviderInitConfig;
-export declare class CortexToolProvider extends LazyCalculatorToolProvider<CortexToolProviderConfig> {
-    readonly providerId = "cortex-calculator";
-    readonly providerName = "PIE Open-Source Calculator";
-    readonly version = "1";
-    readonly requiresAuth = false;
-    protected getDefinition(): LazyCalculatorProviderDefinition<CortexToolProviderConfig>;
-    getCapabilities(): ToolProviderCapabilities;
-}

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

@@ -1,32 +0,0 @@
-/** Fully bundled open-source calculator adapter for the tool-provider registry. */
-import { LazyCalculatorToolProvider } from "./LazyCalculatorToolProvider.js";
-export class CortexToolProvider extends LazyCalculatorToolProvider {
-    providerId = "cortex-calculator";
-    providerName = "PIE Open-Source Calculator";
-    version = "1";
-    requiresAuth = false;
-    getDefinition() {
-        return {
-            backend: "cortex",
-            moduleImportOperation: "cortex-provider-module-import",
-            loadProvider: async () => {
-                const module = await import("@pie-players/pie-calculator-cortex");
-                return module.CortexCalculatorProvider;
-            },
-            initializationErrorMessage: "Failed to initialize the PIE open-source calculator provider. Confirm that this browser supports module workers and that the bundled worker assets are available.",
-        };
-    }
-    getCapabilities() {
-        return {
-            supportsOffline: true,
-            requiresAuth: false,
-            maxInstances: null,
-            features: {
-                basic: true,
-                scientific: true,
-                graphing: true,
-                fourFunction: true,
-            },
-        };
-    }
-}

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

@@ -1,14 +0,0 @@
-/** Desmos calculator adapter for the generic tool-provider registry. */
-import type { CalculatorProviderInit } from "@pie-players/pie-calculator";
-import { LazyCalculatorToolProvider, type LazyCalculatorProviderDefinition } from "./LazyCalculatorToolProvider.js";
-import type { ToolProviderCapabilities } from "./ToolProviderApi.js";
-/** Provider initialization is the provider-neutral calculator contract. */
-export type DesmosToolProviderConfig = CalculatorProviderInit;
-export declare class DesmosToolProvider extends LazyCalculatorToolProvider<DesmosToolProviderConfig> {
-    readonly providerId = "desmos-calculator";
-    readonly providerName = "Desmos Calculator";
-    readonly version = "1.12";
-    readonly requiresAuth = true;
-    protected getDefinition(): LazyCalculatorProviderDefinition<DesmosToolProviderConfig>;
-    getCapabilities(): ToolProviderCapabilities;
-}

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

@@ -1,32 +0,0 @@
-/** Desmos calculator adapter for the generic tool-provider registry. */
-import { LazyCalculatorToolProvider, } from "./LazyCalculatorToolProvider.js";
-export class DesmosToolProvider extends LazyCalculatorToolProvider {
-    providerId = "desmos-calculator";
-    providerName = "Desmos Calculator";
-    version = "1.12";
-    requiresAuth = true;
-    getDefinition() {
-        return {
-            backend: "desmos",
-            moduleImportOperation: "desmos-provider-module-import",
-            loadProvider: async () => {
-                const module = await import("@pie-players/pie-calculator-desmos");
-                return module.DesmosCalculatorProvider;
-            },
-            initializationErrorMessage: "Failed to initialize Desmos calculator provider. Check the application key, preloaded API, runtime endpoint, or network access.",
-        };
-    }
-    getCapabilities() {
-        return {
-            supportsOffline: false,
-            requiresAuth: true,
-            maxInstances: null,
-            features: {
-                basic: true,
-                scientific: true,
-                graphing: true,
-                fourFunction: true,
-            },
-        };
-    }
-}

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