@pie-players/pie-assessment-toolkit 0.3.67 → 0.3.69

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

@@ -1,136 +1,26 @@
-/**
- * Desmos Calculator Tool Provider
- *
- * Provides Desmos calculators (basic, scientific, graphing)
- * with authentication and proxy support.
- *
- * SECURITY BEST PRACTICE:
- * - Development: Pass apiKey directly for local testing
- * - Production: Use proxyEndpoint or authFetcher to keep API key server-side
- *
- * Part of PIE Assessment Toolkit.
- */
-/**
- * Desmos Calculator Tool Provider
- *
- * Wraps DesmosCalculatorProvider with the ToolProviderApi interface
- * for use in the ToolProviderRegistry.
- *
- * @example
- * ```typescript
- * const provider = new DesmosToolProvider();
- *
- * await provider.initialize({
- *   apiKey: 'your-api-key', // Development only
- *   proxyEndpoint: '/api/desmos/token', // Production
- * });
- *
- * const calculatorProvider = await provider.createInstance();
- * ```
- */
-export class DesmosToolProvider {
+/** 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";
-    category = "calculator";
     version = "1.12";
     requiresAuth = true;
-    desmosProvider = null;
-    config = null;
-    async emitTelemetry(eventName, payload) {
-        try {
-            await this.config?.onTelemetry?.(eventName, payload);
-        }
-        catch (error) {
-            console.warn("[DesmosToolProvider] telemetry callback failed:", error);
-        }
-    }
-    /**
-     * Initialize Desmos calculator provider
-     *
-     * Loads the Desmos API library and authenticates with provided credentials.
-     *
-     * @param config Configuration with API key or proxy endpoint
-     * @throws Error if initialization fails
-     */
-    async initialize(config) {
-        if (this.desmosProvider) {
-            console.warn("[DesmosToolProvider] Already initialized, skipping reinitialization");
-            return;
-        }
-        this.config = config;
-        const moduleLoadStartedAt = Date.now();
-        await this.emitTelemetry("pie-tool-library-load-start", {
-            toolId: "calculator",
-            operation: "desmos-provider-module-import",
+    getDefinition() {
+        return {
             backend: "desmos",
-        });
-        const desmosModule = await (async () => {
-            try {
-                const loaded = (await import("@pie-players/pie-calculator-desmos"));
-                await this.emitTelemetry("pie-tool-library-load-success", {
-                    toolId: "calculator",
-                    operation: "desmos-provider-module-import",
-                    backend: "desmos",
-                    duration: Date.now() - moduleLoadStartedAt,
-                });
-                return loaded;
-            }
-            catch (error) {
-                await this.emitTelemetry("pie-tool-library-load-error", {
-                    toolId: "calculator",
-                    operation: "desmos-provider-module-import",
-                    backend: "desmos",
-                    duration: Date.now() - moduleLoadStartedAt,
-                    errorType: "ToolLibraryLoadError",
-                    message: error instanceof Error ? error.message : String(error),
-                });
-                throw error;
-            }
-        })();
-        this.desmosProvider = new desmosModule.DesmosCalculatorProvider();
-        // Initialize with API key or proxy
-        try {
-            await this.desmosProvider.initialize({
-                apiKey: config.apiKey,
-                proxyEndpoint: config.proxyEndpoint,
-                onTelemetry: config.onTelemetry,
-            });
-            console.log(`[DesmosToolProvider] Initialized successfully ${config.proxyEndpoint
-                ? "(using proxy)"
-                : config.apiKey
-                    ? "(direct API key)"
-                    : "(no auth)"}`);
-        }
-        catch (error) {
-            console.error("[DesmosToolProvider] Initialization failed:", error);
-            throw new Error("Failed to initialize Desmos calculator provider. Check API key or proxy endpoint.");
-        }
-    }
-    /**
-     * Create a calculator provider instance
-     *
-     * Returns the initialized Desmos calculator provider.
-     *
-     * @param config Optional instance-specific configuration (currently unused)
-     * @returns Desmos calculator provider
-     * @throws Error if provider not initialized
-     */
-    async createInstance(config) {
-        if (!this.desmosProvider) {
-            throw new Error("[DesmosToolProvider] Provider not initialized. Call initialize() first.");
-        }
-        return this.desmosProvider;
+            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.",
+        };
     }
-    /**
-     * Get provider capabilities
-     *
-     * @returns Desmos calculator capabilities
-     */
     getCapabilities() {
         return {
-            supportsOffline: false, // Requires Desmos CDN
+            supportsOffline: false,
             requiresAuth: true,
-            maxInstances: null, // Unlimited calculator instances
+            maxInstances: null,
             features: {
                 basic: true,
                 scientific: true,
@@ -139,25 +29,4 @@ export class DesmosToolProvider {
             },
         };
     }
-    /**
-     * Check if provider is ready
-     *
-     * @returns true if provider is initialized
-     */
-    isReady() {
-        return this.desmosProvider !== null;
-    }
-    /**
-     * Clean up provider resources
-     *
-     * Destroys the Desmos calculator provider and releases resources.
-     */
-    destroy() {
-        if (this.desmosProvider) {
-            this.desmosProvider.destroy();
-            this.desmosProvider = null;
-        }
-        this.config = null;
-        console.log("[DesmosToolProvider] Destroyed");
-    }
 }

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

@@ -0,0 +1,21 @@
+/** GeoGebra calculator adapter for the generic tool-provider registry. */
+import type { CalculatorToolProviderInitConfig } 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(): {
+        backend: string;
+        moduleImportOperation: string;
+        loadProvider: () => Promise<typeof import("@pie-players/pie-calculator-geogebra").GeoGebraCalculatorProvider>;
+        initializationErrorMessage: string;
+    };
+    getCapabilities(): ToolProviderCapabilities;
+}

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

@@ -0,0 +1,32 @@
+/** 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

@@ -0,0 +1,35 @@
+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>;
+};
+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

@@ -0,0 +1,95 @@
+/**
+ * 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/tool-providers/index.d.ts

@@ -11,5 +11,9 @@ export { ToolProviderRegistry } from "./ToolProviderRegistry.js";
 export type { ToolProviderConfig } from "./ToolProviderRegistry.js";
 export { DesmosToolProvider } from "./DesmosToolProvider.js";
 export type { DesmosToolProviderConfig } from "./DesmosToolProvider.js";
+export { CortexToolProvider } from "./CortexToolProvider.js";
+export type { CortexToolProviderConfig } from "./CortexToolProvider.js";
+export { GeoGebraToolProvider } from "./GeoGebraToolProvider.js";
+export type { GeoGebraToolProviderConfig } from "./GeoGebraToolProvider.js";
 export { TTSToolProvider } from "./TTSToolProvider.js";
 export type { TTSToolProviderConfig, TTSBackend, } from "./TTSToolProvider.js";

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

@@ -10,4 +10,6 @@
 export { ToolProviderRegistry } from "./ToolProviderRegistry.js";
 // Concrete providers
 export { DesmosToolProvider } from "./DesmosToolProvider.js";
+export { CortexToolProvider } from "./CortexToolProvider.js";
+export { GeoGebraToolProvider } from "./GeoGebraToolProvider.js";
 export { TTSToolProvider } from "./TTSToolProvider.js";

package/dist/services/tool-request.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Tool open requests.
+ *
+ * A surface that acts on the learner's current selection has to hand that selection
+ * to a tool it does not mount. The annotation strip is the case PIE ships: it is a
+ * section-scoped singleton in its own shadow root, and the tool it opens is mounted
+ * by a toolbar under a scoped instance id the strip cannot construct.
+ *
+ * Resolution is a claim, not a broadcast. Each toolbar registers as the target for its
+ * placement level, and a request reaches exactly one: the first target that currently
+ * hosts the tool, preferring section scope. A broadcast would open a panel in every
+ * toolbar whose scope contains the selection, which in a section player is the item
+ * card's toolbar and the section's both.
+ *
+ * `params` reaches the tool through the same seam a host-registered context resolver
+ * feeds, so receiving a request costs a tool nothing: whatever already reads
+ * `getToolRenderParams` sees it.
+ *
+ * Core names no capability. The requester supplies the tool id, which is why the
+ * pairing of a selection action to a dictionary lives in the composition layer.
+ */
+import type { ToolPlacementLevel } from "./tools-config-normalizer.js";
+/** Level a request resolves against when the requester names none. */
+export declare const DEFAULT_TOOL_REQUEST_LEVEL: ToolPlacementLevel;
+export interface ToolOpenRequest {
+    /** Unscoped tool id, as the registration declares it. */
+    toolId: string;
+    /**
+     * Merged over the host-resolved render params for this tool rather than
+     * replacing them, so a request carrying a term to look up leaves the endpoint
+     * the host configured in place.
+     */
+    params?: Record<string, unknown>;
+    /**
+     * Placement level of the toolbar that should open the tool.
+     *
+     * Naming one is a constraint and is honoured strictly: a requester that asks for
+     * `"item"` gets an item toolbar or nothing. Leaving it out asks for whichever
+     * toolbar hosts the tool, preferring `"section"` — the level at which a whole
+     * section shares one instance. A host that places a tool only at item scope would
+     * otherwise have the affordance silently disappear, and configuring a level here
+     * to match a placement made elsewhere is a step it has no reason to expect.
+     *
+     * At `"item"` and `"passage"` a section holds one target per card, and the first
+     * registered one that hosts the tool claims the request. A requester that needs a
+     * particular card's instance cannot express that here, and the gateway PIE ships
+     * does not need to: the strip is a section-scoped singleton acting on passage
+     * selections, so the selection belongs to no card, and what opens is a floating
+     * shell rather than anything rendered inside one.
+     */
+    level?: ToolPlacementLevel;
+}
+export interface ToolRequestTarget {
+    /** The placement level this toolbar renders. */
+    level: ToolPlacementLevel;
+    /** Whether this toolbar currently renders the tool, per its own policy pass. */
+    hostsTool: (toolId: string) => boolean;
+    /**
+     * Show the tool with `params` already applied.
+     *
+     * Show rather than toggle: a learner who selects a second word and asks for the
+     * dictionary again is asking for the dictionary, and a toggle would close it.
+     */
+    open: (toolId: string, params?: Record<string, unknown>) => void;
+}
+/**
+ * Registry of the toolbars a request can reach.
+ *
+ * Insertion order is the tie-break within a level, so a target registered while an
+ * earlier one is still mounted does not displace it.
+ */
+export declare class ToolRequestRegistry {
+    private readonly targets;
+    private readonly changeListeners;
+    registerTarget(target: ToolRequestTarget): () => void;
+    /**
+     * Whether a request for this tool would reach a toolbar.
+     *
+     * A surface asks before offering the affordance: a button that silently does
+     * nothing is worse than an absent one, and availability moves with policy —
+     * hence {@link onTargetsChange}.
+     */
+    canRequest(toolId: string, level?: ToolPlacementLevel): boolean;
+    /** Returns whether a target claimed the request. */
+    request(request: ToolOpenRequest): boolean;
+    /**
+     * Fires when a toolbar registers or unregisters.
+     *
+     * Not when a registered toolbar's own visible set changes: `hostsTool` is read
+     * live, so a caller re-asking `canRequest` gets the current answer. A surface
+     * that needs to notice a policy change should also follow the policy signal it
+     * already has.
+     */
+    onTargetsChange(listener: () => void): () => void;
+    /**
+     * An explicit level is a constraint; the default is a preference.
+     *
+     * Falling back off `"section"` is what lets a host place a tool at item scope only
+     * and still have a section-scoped gateway reach it. Requesting a level explicitly
+     * does not fall back, because a requester that named one meant it.
+     */
+    private findTarget;
+    private findTargetAtLevel;
+    private hostsTool;
+    private notifyChange;
+}

package/dist/services/tool-request.js

@@ -0,0 +1,127 @@
+/**
+ * Tool open requests.
+ *
+ * A surface that acts on the learner's current selection has to hand that selection
+ * to a tool it does not mount. The annotation strip is the case PIE ships: it is a
+ * section-scoped singleton in its own shadow root, and the tool it opens is mounted
+ * by a toolbar under a scoped instance id the strip cannot construct.
+ *
+ * Resolution is a claim, not a broadcast. Each toolbar registers as the target for its
+ * placement level, and a request reaches exactly one: the first target that currently
+ * hosts the tool, preferring section scope. A broadcast would open a panel in every
+ * toolbar whose scope contains the selection, which in a section player is the item
+ * card's toolbar and the section's both.
+ *
+ * `params` reaches the tool through the same seam a host-registered context resolver
+ * feeds, so receiving a request costs a tool nothing: whatever already reads
+ * `getToolRenderParams` sees it.
+ *
+ * Core names no capability. The requester supplies the tool id, which is why the
+ * pairing of a selection action to a dictionary lives in the composition layer.
+ */
+/** Level a request resolves against when the requester names none. */
+export const DEFAULT_TOOL_REQUEST_LEVEL = "section";
+/**
+ * Registry of the toolbars a request can reach.
+ *
+ * Insertion order is the tie-break within a level, so a target registered while an
+ * earlier one is still mounted does not displace it.
+ */
+export class ToolRequestRegistry {
+    targets = new Set();
+    changeListeners = new Set();
+    registerTarget(target) {
+        this.targets.add(target);
+        this.notifyChange();
+        return () => {
+            if (!this.targets.delete(target))
+                return;
+            this.notifyChange();
+        };
+    }
+    /**
+     * Whether a request for this tool would reach a toolbar.
+     *
+     * A surface asks before offering the affordance: a button that silently does
+     * nothing is worse than an absent one, and availability moves with policy —
+     * hence {@link onTargetsChange}.
+     */
+    canRequest(toolId, level) {
+        return this.findTarget(toolId, level) !== null;
+    }
+    /** Returns whether a target claimed the request. */
+    request(request) {
+        const target = this.findTarget(request.toolId, request.level);
+        if (!target)
+            return false;
+        try {
+            target.open(request.toolId, request.params);
+        }
+        catch (error) {
+            console.error(`[ToolRequestRegistry] Target failed to open "${request.toolId}":`, error);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Fires when a toolbar registers or unregisters.
+     *
+     * Not when a registered toolbar's own visible set changes: `hostsTool` is read
+     * live, so a caller re-asking `canRequest` gets the current answer. A surface
+     * that needs to notice a policy change should also follow the policy signal it
+     * already has.
+     */
+    onTargetsChange(listener) {
+        this.changeListeners.add(listener);
+        return () => {
+            this.changeListeners.delete(listener);
+        };
+    }
+    /**
+     * An explicit level is a constraint; the default is a preference.
+     *
+     * Falling back off `"section"` is what lets a host place a tool at item scope only
+     * and still have a section-scoped gateway reach it. Requesting a level explicitly
+     * does not fall back, because a requester that named one meant it.
+     */
+    findTarget(toolId, level) {
+        const preferred = this.findTargetAtLevel(toolId, level ?? DEFAULT_TOOL_REQUEST_LEVEL);
+        if (preferred || level !== undefined)
+            return preferred;
+        for (const target of this.targets) {
+            if (target.level === DEFAULT_TOOL_REQUEST_LEVEL)
+                continue;
+            if (this.hostsTool(target, toolId))
+                return target;
+        }
+        return null;
+    }
+    findTargetAtLevel(toolId, level) {
+        for (const target of this.targets) {
+            if (target.level !== level)
+                continue;
+            if (this.hostsTool(target, toolId))
+                return target;
+        }
+        return null;
+    }
+    hostsTool(target, toolId) {
+        try {
+            return target.hostsTool(toolId) === true;
+        }
+        catch (error) {
+            console.warn(`[ToolRequestRegistry] Target at level "${target.level}" failed the host check for "${toolId}":`, error);
+            return false;
+        }
+    }
+    notifyChange() {
+        for (const listener of this.changeListeners) {
+            try {
+                listener();
+            }
+            catch (error) {
+                console.warn("[ToolRequestRegistry] Target change listener threw:", error);
+            }
+        }
+    }
+}

package/dist/services/toolbar-items.d.ts

@@ -3,6 +3,12 @@ export interface ToolbarItemBase {
     label: string;
     ariaLabel?: string;
     icon?: string;
+    /**
+     * FontAwesome icon name, opting this item into `<nds-icon-button>` rendering
+     * where the host enables NDS icons. Set by a tool registration's button
+     * definition, or by a host contributing its own button.
+     */
+    faIconName?: string;
     tooltip?: string;
     active?: boolean;
     disabled?: boolean;

package/dist/tools/client.d.ts

@@ -8,7 +8,5 @@
  * '@pie-players/pie-assessment-toolkit' to ensure
  * they don't accidentally pull in server-side dependencies.
  */
-export { DesmosCalculatorProvider } from "./calculators/desmos-provider.js";
-export { COMMON_LIBRARIES, LibraryLoaderImpl, libraryLoader, } from "./library-loader.js";
 export { ResponseDiscoveryServiceImpl, responseDiscovery, } from "./response-discovery.js";
 export * from "./types.js";

package/dist/tools/client.js

@@ -8,10 +8,6 @@
  * '@pie-players/pie-assessment-toolkit' to ensure
  * they don't accidentally pull in server-side dependencies.
  */
-// Calculator providers (client-safe, have SSR guards)
-export { DesmosCalculatorProvider } from "./calculators/desmos-provider.js";
-// Library loader (client-safe, has SSR guards)
-export { COMMON_LIBRARIES, LibraryLoaderImpl, libraryLoader, } from "./library-loader.js";
 // Response discovery (client-safe, browser-only)
 export { ResponseDiscoveryServiceImpl, responseDiscovery, } from "./response-discovery.js";
 // Core types (client-safe)