@fiodos/web-core 0.1.0

package/dist/esm/core/turnEngine.js

@@ -0,0 +1,92 @@
+/**
+ * Framework-free turn decision engine.
+ *
+ * Concentrates the SECURITY-CRITICAL decision logic of a turn so it can be
+ * unit-tested without any framework, and so every web binding (Vue, Svelte,
+ * Angular) and React Native share the exact same rules. It does NOT
+ * reimplement the engine: it delegates execution, prechecks and confirmation
+ * classification to @fiodos/core. It only sequences them.
+ *
+ * Invariants enforced here (identical to @fiodos/react-native):
+ *  1. The source of truth for "needs confirmation" is the MANIFEST
+ *     (`requireConfirmation`), never the LLM's flag.
+ *  2. A sensitive action is NEVER executed by `decideAction`; it returns a
+ *     PendingConfirmation and waits for an explicit confirmation.
+ *  3. Voice confirmation honours the manifest mode: 'disabled' can never be
+ *     confirmed by voice (tap only); 'strict' requires the exact phrase; a
+ *     loose "yes" does not confirm a strict action. Negation always wins.
+ */
+import { classifyConfirmationReply, classifyStrictConfirmationReply, formatMessage, } from '@fiodos/core';
+function findManifestAction(manifest, intent) {
+    if (!intent)
+        return undefined;
+    return manifest.actions.find((a) => a.intent === intent);
+}
+/**
+ * Decides what to do with a backend-proposed action. Sensitive actions are
+ * never executed here — they return `needs-confirmation`.
+ */
+export async function decideAction(params) {
+    const { action, manifest, executor, context, messages, userMessage } = params;
+    if (!action || action.type === 'none') {
+        return { kind: 'noop' };
+    }
+    if (action.type === 'navigate') {
+        const result = await executor.execute(action);
+        return { kind: 'executed', result };
+    }
+    if (action.type === 'execute') {
+        const manifestAction = findManifestAction(manifest, action.intent);
+        const needsConfirmation = manifestAction?.requireConfirmation === true;
+        if (!needsConfirmation) {
+            const result = await executor.execute(action, context);
+            return { kind: 'executed', result };
+        }
+        // Precheck (context + idempotency) BEFORE asking: applying an already-applied
+        // state answers directly without bothering the user with a confirmation.
+        const pre = await executor.precheck(action, context);
+        if (pre.kind === 'done') {
+            return { kind: 'precheck-resolved', result: pre.result };
+        }
+        const voiceMode = manifestAction?.voiceConfirmation ?? 'standard';
+        const strictPhrase = voiceMode === 'strict'
+            ? (manifestAction?.confirmationPhrase ??
+                formatMessage(messages.strictConfirmationPhraseTemplate, {
+                    label: (manifestAction?.label ?? action.intent ?? '').toLowerCase(),
+                }))
+            : null;
+        const pending = {
+            action,
+            context,
+            question: manifestAction?.confirmationMessageTemplate ??
+                action.confirmationMessage ??
+                messages.confirmationFallbackQuestion,
+            voiceMode,
+            strictPhrase,
+            remainingConfirmations: manifestAction?.doubleConfirmation === true ? 2 : 1,
+            userMessage,
+            intent: action.intent ?? '',
+        };
+        return { kind: 'needs-confirmation', pending };
+    }
+    return { kind: 'noop' };
+}
+/**
+ * Classifies a spoken reply against a pending confirmation, honouring the
+ * manifest's voice mode. Returns 'ambiguous' when voice cannot resolve it
+ * (disabled mode, silent turn, or unclear speech) — the caller must then rely
+ * on the tactile modal. NEVER returns 'affirmative' for a disabled/silent
+ * confirmation.
+ */
+export function classifyPendingReply(text, pending, lexicon, opts = {}) {
+    // Safety net: a stray transcript can NEVER resolve a tap-only confirmation.
+    if (pending.voiceMode === 'disabled' || opts.silent)
+        return 'ambiguous';
+    const trimmed = text.trim();
+    if (trimmed.length < 2)
+        return 'ambiguous';
+    if (pending.voiceMode === 'strict' && pending.strictPhrase != null) {
+        return classifyStrictConfirmationReply(trimmed, pending.strictPhrase, lexicon);
+    }
+    return classifyConfirmationReply(trimmed, lexicon);
+}

package/dist/esm/dropin/createFiodosAgent.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Vanilla drop-in — assembles the default browser adapters, builds an
+ * AgentController and (optionally) mounts the DOM orb in one call. Frameworks
+ * use the AgentController + their own components; this is the zero-framework
+ * path (and the reference the Vue/Svelte/Angular drop-ins follow).
+ *
+ * PARITY WITH @fiodos/react's <FiodosAgent/>: when `manifest` is omitted, the
+ * agent self-bootstraps — it fetches the published manifest by `apiKey`
+ * (GET /v1/client/manifest), assembles default browser adapters, mounts the orb
+ * and posts the `orb-seen` heartbeat. So a one-line drop-in needs only an
+ * apiKey, exactly like React. Passing a manifest keeps the fully-synchronous,
+ * manual path.
+ */
+import { type ActionRegistries, type AppManifest } from '@fiodos/core';
+import { AgentController } from '../controller/AgentController.js';
+import { type MountOrbOptions, type MountedOrb } from '../orb/mountOrb.js';
+import type { FiodosWebAgentConfig } from '../config/types.js';
+export interface CreateFiodosAgentOptions {
+    /** Backend base URL. Defaults to the public Fiodos backend. */
+    baseUrl?: string;
+    /** Client API key (x-api-key). Required when `manifest` is omitted (auto-fetch). */
+    apiKey?: string;
+    /**
+     * The validated app manifest. OPTIONAL: omit it to self-fetch the published
+     * manifest by apiKey (the React-parity drop-in path).
+     */
+    manifest?: AppManifest;
+    /** Action handlers / context validators (defaults to empty registries). */
+    registries?: ActionRegistries;
+    /** Agent reply locale (e.g. 'es', 'en'). Defaults to the browser language. */
+    locale?: string;
+    /** STT locale (e.g. 'es-ES', 'en-US'). Defaults to the browser language. */
+    sttLocale?: string;
+    /** Host router navigate delegate. Defaults to location.assign. */
+    navigate?: (route: string) => void;
+    /** Host auth check for actions requiring auth. */
+    isAuthenticated?: () => boolean;
+    /** Voice id forwarded to the backend TTS. */
+    ttsVoice?: string | (() => string | undefined);
+    /** End-user id for rate limiting / telemetry correlation. */
+    getUserId?: () => string | null;
+    /** Mount the built-in DOM orb. Default: true. Pass false to render your own. */
+    mount?: boolean;
+    orb?: MountOrbOptions;
+    /** Escape hatch: extra config merged into the controller config. */
+    configOverrides?: Partial<FiodosWebAgentConfig>;
+    /** Called once the manifest loaded and the orb mounted (auto-fetch path). */
+    onReady?: (controller: AgentController) => void;
+    /** Called when self-bootstrap fails (network / rejected key / no manifest). */
+    onError?: (error: Error) => void;
+}
+export interface FiodosAgentHandle {
+    /** Null until the async self-bootstrap resolves (auto-fetch path). */
+    controller: AgentController | null;
+    orb: MountedOrb | null;
+    /** Resolves once the controller is ready (immediately on the manual path). */
+    ready: Promise<AgentController | null>;
+    destroy(): void;
+}
+export declare function createFiodosAgent(options: CreateFiodosAgentOptions): FiodosAgentHandle;

package/dist/esm/dropin/createFiodosAgent.js

@@ -0,0 +1,140 @@
+/**
+ * Vanilla drop-in — assembles the default browser adapters, builds an
+ * AgentController and (optionally) mounts the DOM orb in one call. Frameworks
+ * use the AgentController + their own components; this is the zero-framework
+ * path (and the reference the Vue/Svelte/Angular drop-ins follow).
+ *
+ * PARITY WITH @fiodos/react's <FiodosAgent/>: when `manifest` is omitted, the
+ * agent self-bootstraps — it fetches the published manifest by `apiKey`
+ * (GET /v1/client/manifest), assembles default browser adapters, mounts the orb
+ * and posts the `orb-seen` heartbeat. So a one-line drop-in needs only an
+ * apiKey, exactly like React. Passing a manifest keeps the fully-synchronous,
+ * manual path.
+ */
+import { validateManifest } from '@fiodos/core';
+import { createFiodosBackendClient } from '../api/backendClient.js';
+import { createFiodosTelemetry } from '../api/backendTelemetry.js';
+import { createWebNavigationAdapter } from '../adapters/webNavigationAdapter.js';
+import { createWebStorageAdapter } from '../adapters/webStorageAdapter.js';
+import { createWebVoiceAdapter } from '../adapters/webVoiceAdapter.js';
+import { AgentController } from '../controller/AgentController.js';
+import { mountOrb } from '../orb/mountOrb.js';
+import { DEFAULT_WEB_API_URL, fetchClientManifest, sendOrbSeen } from '../api/clientBootstrap.js';
+function defaultNavigate(route) {
+    if (typeof window !== 'undefined' && window.location)
+        window.location.assign(route);
+}
+function browserLocale() {
+    const lang = typeof navigator !== 'undefined' && navigator.language ? navigator.language : 'en-US';
+    return { locale: lang.split('-')[0] || 'en', sttLocale: lang };
+}
+/** Build the controller + adapters from a known manifest (shared by both paths). */
+function assemble(options, manifest, baseUrl) {
+    const fallback = browserLocale();
+    const locale = options.locale ?? fallback.locale;
+    const sttLocale = options.sttLocale ?? options.locale ?? fallback.sttLocale;
+    const backend = createFiodosBackendClient({
+        baseUrl,
+        apiKey: options.apiKey,
+        getUserId: options.getUserId,
+    });
+    const telemetry = createFiodosTelemetry({
+        baseUrl,
+        apiKey: options.apiKey,
+        getUserId: options.getUserId,
+    });
+    const config = {
+        manifest,
+        locale,
+        sttLocale,
+        navigation: createWebNavigationAdapter({ navigate: options.navigate ?? defaultNavigate }),
+        registries: options.registries ?? { handlers: {}, idempotencyCheckers: {} },
+        backend,
+        voice: createWebVoiceAdapter(),
+        storage: createWebStorageAdapter(),
+        telemetry,
+        isAuthenticated: options.isAuthenticated,
+        ttsVoice: options.ttsVoice,
+        ...options.configOverrides,
+    };
+    const controller = new AgentController(config);
+    controller.warmUp();
+    return controller;
+}
+export function createFiodosAgent(options) {
+    const baseUrl = (options.baseUrl ?? DEFAULT_WEB_API_URL).replace(/\/$/, '');
+    const shouldMount = options.mount !== false;
+    // ── Manual path: manifest provided → fully synchronous (back-compat). ───────
+    if (options.manifest) {
+        const controller = assemble(options, options.manifest, baseUrl);
+        const orb = shouldMount ? mountOrb(controller, options.orb) : null;
+        if (shouldMount && options.apiKey) {
+            void sendOrbSeen({ baseUrl, apiKey: options.apiKey });
+        }
+        options.onReady?.(controller);
+        const handle = {
+            controller,
+            orb,
+            ready: Promise.resolve(controller),
+            destroy() {
+                orb?.unmount();
+                controller.dispose();
+            },
+        };
+        return handle;
+    }
+    // ── Auto path (React parity): fetch manifest by apiKey, then assemble. ──────
+    const handle = {
+        controller: null,
+        orb: null,
+        ready: Promise.resolve(null),
+        destroy() {
+            cancelled = true;
+            handle.orb?.unmount();
+            handle.controller?.dispose();
+        },
+    };
+    let cancelled = false;
+    handle.ready = (async () => {
+        try {
+            if (!options.apiKey) {
+                throw new Error('[fyodos] createFiodosAgent requires either a `manifest` or an `apiKey` ' +
+                    '(to self-fetch the published manifest).');
+            }
+            const result = await fetchClientManifest({ baseUrl, apiKey: options.apiKey });
+            if (cancelled)
+                return null;
+            if (result.status === 'no-manifest' || !result.manifest) {
+                // eslint-disable-next-line no-console
+                console.warn('[fyodos] The orb is idle: this project has no published manifest yet. ' +
+                    'Run the analysis from your Fiodos dashboard, then reload.');
+                return null;
+            }
+            // Fail loudly here (not deep inside the controller) so onError is precise.
+            const check = validateManifest(result.manifest);
+            if (!check.valid) {
+                throw new Error(`[fyodos] Invalid manifest for "${result.manifest.appId}":\n- ${check.errors.join('\n- ')}`);
+            }
+            const controller = assemble(options, result.manifest, baseUrl);
+            if (cancelled) {
+                controller.dispose();
+                return null;
+            }
+            handle.controller = controller;
+            handle.orb = shouldMount ? mountOrb(controller, options.orb) : null;
+            if (shouldMount && options.apiKey) {
+                void sendOrbSeen({ baseUrl, apiKey: options.apiKey });
+            }
+            options.onReady?.(controller);
+            return controller;
+        }
+        catch (e) {
+            const error = e instanceof Error ? e : new Error(String(e));
+            // eslint-disable-next-line no-console
+            console.error(error.message);
+            options.onError?.(error);
+            return null;
+        }
+    })();
+    return handle;
+}

package/dist/esm/dropin/createFyodosAgent.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Vanilla drop-in — assembles the default browser adapters, builds an
+ * AgentController and (optionally) mounts the DOM orb in one call. Frameworks
+ * use the AgentController + their own components; this is the zero-framework
+ * path (and the reference the Vue/Svelte/Angular drop-ins follow).
+ *
+ * PARITY WITH @fyodos/react's <FyodosAgent/>: when `manifest` is omitted, the
+ * agent self-bootstraps — it fetches the published manifest by `apiKey`
+ * (GET /v1/client/manifest), assembles default browser adapters, mounts the orb
+ * and posts the `orb-seen` heartbeat. So a one-line drop-in needs only an
+ * apiKey, exactly like React. Passing a manifest keeps the fully-synchronous,
+ * manual path.
+ */
+import { type ActionRegistries, type AppManifest } from '@fyodos/core';
+import { AgentController } from '../controller/AgentController.js';
+import { type MountOrbOptions, type MountedOrb } from '../orb/mountOrb.js';
+import type { FyodosWebAgentConfig } from '../config/types.js';
+export interface CreateFyodosAgentOptions {
+    /** Backend base URL. Defaults to the public Fyodos backend. */
+    baseUrl?: string;
+    /** Client API key (x-api-key). Required when `manifest` is omitted (auto-fetch). */
+    apiKey?: string;
+    /**
+     * The validated app manifest. OPTIONAL: omit it to self-fetch the published
+     * manifest by apiKey (the React-parity drop-in path).
+     */
+    manifest?: AppManifest;
+    /** Action handlers / context validators (defaults to empty registries). */
+    registries?: ActionRegistries;
+    /** Agent reply locale (e.g. 'es', 'en'). Defaults to the browser language. */
+    locale?: string;
+    /** STT locale (e.g. 'es-ES', 'en-US'). Defaults to the browser language. */
+    sttLocale?: string;
+    /** Host router navigate delegate. Defaults to location.assign. */
+    navigate?: (route: string) => void;
+    /** Host auth check for actions requiring auth. */
+    isAuthenticated?: () => boolean;
+    /** Voice id forwarded to the backend TTS. */
+    ttsVoice?: string | (() => string | undefined);
+    /** End-user id for rate limiting / telemetry correlation. */
+    getUserId?: () => string | null;
+    /** Mount the built-in DOM orb. Default: true. Pass false to render your own. */
+    mount?: boolean;
+    orb?: MountOrbOptions;
+    /** Escape hatch: extra config merged into the controller config. */
+    configOverrides?: Partial<FyodosWebAgentConfig>;
+    /** Called once the manifest loaded and the orb mounted (auto-fetch path). */
+    onReady?: (controller: AgentController) => void;
+    /** Called when self-bootstrap fails (network / rejected key / no manifest). */
+    onError?: (error: Error) => void;
+}
+export interface FyodosAgentHandle {
+    /** Null until the async self-bootstrap resolves (auto-fetch path). */
+    controller: AgentController | null;
+    orb: MountedOrb | null;
+    /** Resolves once the controller is ready (immediately on the manual path). */
+    ready: Promise<AgentController | null>;
+    destroy(): void;
+}
+export declare function createFyodosAgent(options: CreateFyodosAgentOptions): FyodosAgentHandle;

package/dist/esm/dropin/createFyodosAgent.js

@@ -0,0 +1,140 @@
+/**
+ * Vanilla drop-in — assembles the default browser adapters, builds an
+ * AgentController and (optionally) mounts the DOM orb in one call. Frameworks
+ * use the AgentController + their own components; this is the zero-framework
+ * path (and the reference the Vue/Svelte/Angular drop-ins follow).
+ *
+ * PARITY WITH @fyodos/react's <FyodosAgent/>: when `manifest` is omitted, the
+ * agent self-bootstraps — it fetches the published manifest by `apiKey`
+ * (GET /v1/client/manifest), assembles default browser adapters, mounts the orb
+ * and posts the `orb-seen` heartbeat. So a one-line drop-in needs only an
+ * apiKey, exactly like React. Passing a manifest keeps the fully-synchronous,
+ * manual path.
+ */
+import { validateManifest } from '@fyodos/core';
+import { createFyodosBackendClient } from '../api/backendClient.js';
+import { createFyodosTelemetry } from '../api/backendTelemetry.js';
+import { createWebNavigationAdapter } from '../adapters/webNavigationAdapter.js';
+import { createWebStorageAdapter } from '../adapters/webStorageAdapter.js';
+import { createWebVoiceAdapter } from '../adapters/webVoiceAdapter.js';
+import { AgentController } from '../controller/AgentController.js';
+import { mountOrb } from '../orb/mountOrb.js';
+import { DEFAULT_WEB_API_URL, fetchClientManifest, sendOrbSeen } from '../api/clientBootstrap.js';
+function defaultNavigate(route) {
+    if (typeof window !== 'undefined' && window.location)
+        window.location.assign(route);
+}
+function browserLocale() {
+    const lang = typeof navigator !== 'undefined' && navigator.language ? navigator.language : 'en-US';
+    return { locale: lang.split('-')[0] || 'en', sttLocale: lang };
+}
+/** Build the controller + adapters from a known manifest (shared by both paths). */
+function assemble(options, manifest, baseUrl) {
+    const fallback = browserLocale();
+    const locale = options.locale ?? fallback.locale;
+    const sttLocale = options.sttLocale ?? options.locale ?? fallback.sttLocale;
+    const backend = createFyodosBackendClient({
+        baseUrl,
+        apiKey: options.apiKey,
+        getUserId: options.getUserId,
+    });
+    const telemetry = createFyodosTelemetry({
+        baseUrl,
+        apiKey: options.apiKey,
+        getUserId: options.getUserId,
+    });
+    const config = {
+        manifest,
+        locale,
+        sttLocale,
+        navigation: createWebNavigationAdapter({ navigate: options.navigate ?? defaultNavigate }),
+        registries: options.registries ?? { handlers: {}, idempotencyCheckers: {} },
+        backend,
+        voice: createWebVoiceAdapter(),
+        storage: createWebStorageAdapter(),
+        telemetry,
+        isAuthenticated: options.isAuthenticated,
+        ttsVoice: options.ttsVoice,
+        ...options.configOverrides,
+    };
+    const controller = new AgentController(config);
+    controller.warmUp();
+    return controller;
+}
+export function createFyodosAgent(options) {
+    const baseUrl = (options.baseUrl ?? DEFAULT_WEB_API_URL).replace(/\/$/, '');
+    const shouldMount = options.mount !== false;
+    // ── Manual path: manifest provided → fully synchronous (back-compat). ───────
+    if (options.manifest) {
+        const controller = assemble(options, options.manifest, baseUrl);
+        const orb = shouldMount ? mountOrb(controller, options.orb) : null;
+        if (shouldMount && options.apiKey) {
+            void sendOrbSeen({ baseUrl, apiKey: options.apiKey });
+        }
+        options.onReady?.(controller);
+        const handle = {
+            controller,
+            orb,
+            ready: Promise.resolve(controller),
+            destroy() {
+                orb?.unmount();
+                controller.dispose();
+            },
+        };
+        return handle;
+    }
+    // ── Auto path (React parity): fetch manifest by apiKey, then assemble. ──────
+    const handle = {
+        controller: null,
+        orb: null,
+        ready: Promise.resolve(null),
+        destroy() {
+            cancelled = true;
+            handle.orb?.unmount();
+            handle.controller?.dispose();
+        },
+    };
+    let cancelled = false;
+    handle.ready = (async () => {
+        try {
+            if (!options.apiKey) {
+                throw new Error('[fyodos] createFyodosAgent requires either a `manifest` or an `apiKey` ' +
+                    '(to self-fetch the published manifest).');
+            }
+            const result = await fetchClientManifest({ baseUrl, apiKey: options.apiKey });
+            if (cancelled)
+                return null;
+            if (result.status === 'no-manifest' || !result.manifest) {
+                // eslint-disable-next-line no-console
+                console.warn('[fyodos] The orb is idle: this project has no published manifest yet. ' +
+                    'Run the analysis from your Fyodos dashboard, then reload.');
+                return null;
+            }
+            // Fail loudly here (not deep inside the controller) so onError is precise.
+            const check = validateManifest(result.manifest);
+            if (!check.valid) {
+                throw new Error(`[fyodos] Invalid manifest for "${result.manifest.appId}":\n- ${check.errors.join('\n- ')}`);
+            }
+            const controller = assemble(options, result.manifest, baseUrl);
+            if (cancelled) {
+                controller.dispose();
+                return null;
+            }
+            handle.controller = controller;
+            handle.orb = shouldMount ? mountOrb(controller, options.orb) : null;
+            if (shouldMount && options.apiKey) {
+                void sendOrbSeen({ baseUrl, apiKey: options.apiKey });
+            }
+            options.onReady?.(controller);
+            return controller;
+        }
+        catch (e) {
+            const error = e instanceof Error ? e : new Error(String(e));
+            // eslint-disable-next-line no-console
+            console.error(error.message);
+            options.onError?.(error);
+            return null;
+        }
+    })();
+    return handle;
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @fiodos/web-core — framework-agnostic browser layer for the Fiodos agent.
+ *
+ * Contains the vanilla orchestrator (AgentController), the browser adapters,
+ * the HTTP client, the decision engine and a vanilla DOM orb — all over
+ * @fiodos/core. @fiodos/vue, @fiodos/svelte and @fiodos/angular are thin
+ * reactive wrappers around THIS package, so they share identical agent
+ * behaviour and security. No framework imports live here.
+ */
+export { AgentController } from './controller/AgentController.js';
+export type { AgentState, AgentExchange } from './controller/AgentController.js';
+export { createFiodosAgent } from './dropin/createFiodosAgent.js';
+export type { CreateFiodosAgentOptions, FiodosAgentHandle } from './dropin/createFiodosAgent.js';
+export { DEFAULT_WEB_API_URL, fetchClientManifest, sendOrbSeen, } from './api/clientBootstrap.js';
+export type { ManifestBootstrapResult, ManifestBootstrapStatus, } from './api/clientBootstrap.js';
+export { mountOrb } from './orb/mountOrb.js';
+export type { MountOrbOptions, MountedOrb, OrbCorner } from './orb/mountOrb.js';
+export { createOrbVisual, buildKeyboardChip, DEFAULT_ORB_APPEARANCE } from './orb/orbView.js';
+export type { OrbAppearance, OrbVisual, OrbVisualState, ChipTheme } from './orb/orbView.js';
+export { watchPublishedConfig } from './orb/publishedConfig.js';
+export type { ResolvedOrbConfig, WatchPublishedConfigOptions } from './orb/publishedConfig.js';
+export { createWebStorageAdapter } from './adapters/webStorageAdapter.js';
+export type { WebStorageAdapterOptions } from './adapters/webStorageAdapter.js';
+export { createWebNavigationAdapter, BACK_ROUTE, } from './adapters/webNavigationAdapter.js';
+export type { WebNavigationAdapter, WebNavigationAdapterOptions, } from './adapters/webNavigationAdapter.js';
+export { createWebVoiceAdapter } from './adapters/webVoiceAdapter.js';
+export type { WebVoiceAdapterOptions } from './adapters/webVoiceAdapter.js';
+export { createFiodosBackendClient, buildManifestPayload } from './api/backendClient.js';
+export type { FiodosBackendClientOptions } from './api/backendClient.js';
+export { createFiodosTelemetry } from './api/backendTelemetry.js';
+export type { FiodosTelemetryOptions } from './api/backendTelemetry.js';
+export { AgentApiError, isAgentApiError } from './api/errors.js';
+export type { AgentApiErrorCode } from './api/errors.js';
+export { createBridge } from './bridge/createBridge.js';
+export type { Bridge } from './bridge/createBridge.js';
+export { createScreenContextStore } from './context/screenContextStore.js';
+export type { ScreenContextStore, AgentScreenSnapshot } from './context/screenContextStore.js';
+export { createSpeechSession } from './speech/speechSession.js';
+export type { SpeechSession, SpeechSessionOptions, SpeechSessionState, SpeechSessionSnapshot, } from './speech/speechSession.js';
+export { DEFAULT_AGENT_TIMINGS } from './config/types.js';
+export type { FiodosWebAgentConfig, AgentPhase, AgentTimings, TurnGateVerdict, } from './config/types.js';
+export { resolveUiMessages } from './ui/messages.js';
+export type { WebUiMessages, ResolveUiMessagesOptions } from './ui/messages.js';
+export { decideAction, classifyPendingReply } from './core/turnEngine.js';
+export type { ActionDecision, PendingConfirmation, VoiceConfirmationMode, DecideActionParams, } from './core/turnEngine.js';

package/dist/esm/index.js

@@ -0,0 +1,38 @@
+/**
+ * @fiodos/web-core — framework-agnostic browser layer for the Fiodos agent.
+ *
+ * Contains the vanilla orchestrator (AgentController), the browser adapters,
+ * the HTTP client, the decision engine and a vanilla DOM orb — all over
+ * @fiodos/core. @fiodos/vue, @fiodos/svelte and @fiodos/angular are thin
+ * reactive wrappers around THIS package, so they share identical agent
+ * behaviour and security. No framework imports live here.
+ */
+// ── Orchestrator ──────────────────────────────────────────────────────────────
+export { AgentController } from './controller/AgentController.js';
+// ── Drop-in (zero-wiring) ─────────────────────────────────────────────────────
+export { createFiodosAgent } from './dropin/createFiodosAgent.js';
+// ── Client self-bootstrap (manifest auto-fetch + orb-seen heartbeat) ──────────
+export { DEFAULT_WEB_API_URL, fetchClientManifest, sendOrbSeen, } from './api/clientBootstrap.js';
+// ── Vanilla DOM orb ───────────────────────────────────────────────────────────
+export { mountOrb } from './orb/mountOrb.js';
+export { createOrbVisual, buildKeyboardChip, DEFAULT_ORB_APPEARANCE } from './orb/orbView.js';
+export { watchPublishedConfig } from './orb/publishedConfig.js';
+// ── Adapters (browser implementations of @fiodos/core contracts) ──────────────
+export { createWebStorageAdapter } from './adapters/webStorageAdapter.js';
+export { createWebNavigationAdapter, BACK_ROUTE, } from './adapters/webNavigationAdapter.js';
+export { createWebVoiceAdapter } from './adapters/webVoiceAdapter.js';
+// ── Backend + telemetry (same wire contract as every platform) ────────────────
+export { createFiodosBackendClient, buildManifestPayload } from './api/backendClient.js';
+export { createFiodosTelemetry } from './api/backendTelemetry.js';
+export { AgentApiError, isAgentApiError } from './api/errors.js';
+// ── Bridges ───────────────────────────────────────────────────────────────────
+export { createBridge } from './bridge/createBridge.js';
+// ── Screen context ────────────────────────────────────────────────────────────
+export { createScreenContextStore } from './context/screenContextStore.js';
+// ── Speech session ──────────────────────────────────────────────────────────────
+export { createSpeechSession } from './speech/speechSession.js';
+// ── Config / i18n ─────────────────────────────────────────────────────────────
+export { DEFAULT_AGENT_TIMINGS } from './config/types.js';
+export { resolveUiMessages } from './ui/messages.js';
+// ── Decision engine (shared, framework-free; advanced use / testing) ──────────
+export { decideAction, classifyPendingReply } from './core/turnEngine.js';

package/dist/esm/orb/mountOrb.d.ts

@@ -0,0 +1,24 @@
+import type { AgentController } from '../controller/AgentController.js';
+export type OrbCorner = 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+export interface MountOrbOptions {
+    /** Where to mount. Defaults to document.body. */
+    container?: HTMLElement;
+    /** Screen corner for the floating orb (fallback when no published position). */
+    corner?: OrbCorner;
+    /** Override the orb diameter in px (otherwise the published/default size). */
+    size?: number;
+    /** Override the accent (fill/border) color (otherwise published/default). */
+    accent?: string;
+    /** Show the text-input affordance. Default: true. */
+    enableTextInput?: boolean;
+    /** Base z-index for the orb + modals. Default: 2147483000. */
+    zIndex?: number;
+    /** Poll interval (ms) for live dashboard config. Default 12000 (0 = off). */
+    appearancePollMs?: number;
+    /** Honour the dashboard's published screen position. Default: true. */
+    usePublishedPosition?: boolean;
+}
+export interface MountedOrb {
+    unmount(): void;
+}
+export declare function mountOrb(controller: AgentController, options?: MountOrbOptions): MountedOrb;