npm - @fiodos/web-core - Versions diffs - 0.1.12 → 0.1.15 - Mend

@fiodos/web-core 0.1.12 → 0.1.15

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (44) hide show

package/dist/cjs/adapters/webCredentialAutofillAdapter.d.ts +16 -0
package/dist/cjs/adapters/webCredentialAutofillAdapter.js +47 -0
package/dist/cjs/api/backendClient.d.ts +10 -3
package/dist/cjs/api/backendClient.js +31 -9
package/dist/cjs/config/types.d.ts +22 -2
package/dist/cjs/controller/AgentController.d.ts +14 -0
package/dist/cjs/controller/AgentController.js +65 -2
package/dist/cjs/dropin/createFiodosAgent.d.ts +27 -1
package/dist/cjs/dropin/createFiodosAgent.js +48 -4
package/dist/cjs/embed/dynamics.d.ts +61 -0
package/dist/cjs/embed/dynamics.js +173 -0
package/dist/cjs/embed/global.d.ts +45 -0
package/dist/cjs/embed/global.js +48 -0
package/dist/cjs/index.d.ts +3 -0
package/dist/cjs/index.js +8 -1
package/dist/cjs/orb/mountOrb.js +172 -28
package/dist/cjs/orb/orbView.js +42 -8
package/dist/cjs/orb/publishedConfig.d.ts +4 -2
package/dist/cjs/orb/publishedConfig.js +56 -7
package/dist/cjs/version.d.ts +1 -1
package/dist/cjs/version.js +1 -1
package/dist/embed/fiodos-embed.js +66 -0
package/dist/esm/adapters/webCredentialAutofillAdapter.d.ts +16 -0
package/dist/esm/adapters/webCredentialAutofillAdapter.js +44 -0
package/dist/esm/api/backendClient.d.ts +10 -3
package/dist/esm/api/backendClient.js +32 -10
package/dist/esm/config/types.d.ts +22 -2
package/dist/esm/controller/AgentController.d.ts +14 -0
package/dist/esm/controller/AgentController.js +65 -2
package/dist/esm/dropin/createFiodosAgent.d.ts +27 -1
package/dist/esm/dropin/createFiodosAgent.js +48 -4
package/dist/esm/embed/dynamics.d.ts +61 -0
package/dist/esm/embed/dynamics.js +168 -0
package/dist/esm/embed/global.d.ts +45 -0
package/dist/esm/embed/global.js +46 -0
package/dist/esm/index.d.ts +3 -0
package/dist/esm/index.js +3 -0
package/dist/esm/orb/mountOrb.js +173 -29
package/dist/esm/orb/orbView.js +43 -9
package/dist/esm/orb/publishedConfig.d.ts +4 -2
package/dist/esm/orb/publishedConfig.js +56 -7
package/dist/esm/version.d.ts +1 -1
package/dist/esm/version.js +1 -1
package/package.json +5 -3

package/dist/esm/config/types.d.ts CHANGED Viewed

@@ -3,7 +3,7 @@
  * Mirrors @fiodos/react's FiodosWebAgentConfig (same adapters, same lifecycle).
  * Shared by every framework binding through the AgentController.
  */
-import type { ActionRegistries, AgentBackendClient, AgentMessages, AppManifest, ConfirmationLexicon, MessageCatalog, NavigationAdapter, Sanitizer, StorageAdapter, TelemetryAdapter, VoiceAdapter } from '@fiodos/core';
+import type { ActionRegistries, AgentBackendClient, AgentMessages, AppManifest, ConfirmationLexicon, CredentialAutofillAdapter, MessageCatalog, NavigationAdapter, Sanitizer, StorageAdapter, TelemetryAdapter, VoiceAdapter } from '@fiodos/core';
 import type { ResolveUiMessagesOptions, WebUiMessages } from '../ui/messages.js';
 export type AgentPhase = 'idle' | 'listening' | 'thinking' | 'speaking' | 'confirming';
 export interface AgentTimings {
@@ -44,6 +44,13 @@ export interface FiodosWebAgentConfig {
     manifest: AppManifest;
     /** Agent locale (reply language, message catalogs). MANDATORY. */
     locale: string;
+    /**
+     * LIVE locale resolver. When set, the orb re-reads it periodically so the
+     * thought bubble follows the app's ACTIVE language (host language switcher,
+     * `<html lang>`, i18n runtime) without remounting. Falls back to `locale`
+     * whenever it returns nothing.
+     */
+    getLocale?: () => string | null | undefined;
     /** Speech recognition locale, e.g. 'en-US', 'es-ES'. MANDATORY. */
     sttLocale: string;
     /** Device-TTS fallback locale. Defaults to sttLocale. */
@@ -55,7 +62,20 @@ export interface FiodosWebAgentConfig {
     storage: StorageAdapter;
     telemetry?: TelemetryAdapter;
     /** Host auth check, required by manifest actions declaring requiresAuth. */
-    isAuthenticated?: () => boolean;
+    isAuthenticated?: () => boolean | null | undefined;
+    /**
+     * Fine-grained session capability flags from the wired session bridge
+     * (audience map: e.g. { has_payment_method: true }). Sent with each turn so
+     * the backend shows this user only THEIR face of the orb. Boolean flags
+     * only — never user data. null/undefined = unknown (nothing is filtered).
+     */
+    getSessionCapabilities?: () => Record<string, boolean> | null | undefined;
+    /**
+     * Platform saved-credential service powering the built-in SMART SIGN-IN
+     * flow (browser password manager). Defaults to the web Credential
+     * Management adapter; pass `null` to disable the feature entirely.
+     */
+    credentialAutofill?: CredentialAutofillAdapter | null;
     /**
      * Host end-user identity. Conversation memory is namespaced per identity
      * (hashed LOCALLY, never sent by this module): logout/account switches swap

package/dist/esm/controller/AgentController.d.ts CHANGED Viewed

@@ -74,6 +74,7 @@ export declare class AgentController {
     private readonly telemetry;
     private readonly consent;
     private readonly executor;
+    private readonly credentialAutofill;
     private readonly timings;
     private readonly chaining;
     private readonly ttsLocale;
@@ -191,6 +192,19 @@ export declare class AgentController {
     confirmPendingAction(): Promise<void>;
     cancelPendingAction(): void;
     private handleConfirmationTranscript;
+    /**
+     * Device capability flags advertised on each turn (never user data). Fresh
+     * per turn: cheap, and honest if the environment changes mid-session.
+     */
+    private platformCapabilities;
+    /**
+     * Live session verdict advertised on each turn (audience map — never user
+     * data): whether the user is signed in plus the app's boolean capability
+     * flags. Fresh per turn so login/logout mid-session is honest. Undefined
+     * when the host wired neither source (older installs — backend filters
+     * nothing, exactly today's behavior).
+     */
+    private sessionContext;
     private routeLabel;
     private actionLabel;
     /**

package/dist/esm/controller/AgentController.js CHANGED Viewed

@@ -16,6 +16,7 @@
  *  - The agent only ever executes actions declared in the manifest.
  */
 import { combineContexts, createActionExecutor, createConsentManager, createSafeTelemetry, createSanitizer, buildBubbleExchangeWindow, BUBBLE_PAGE_EXCHANGES, clearPersistedConversation, conversationIdentityKey, conversationRetentionOptions, createConversationSession, persistConversationSession, restoreConversationSession, defaultRouteContextText, formatMessage, prepareConversationForTurn, recordConversationExchange, resolveConfirmationLexicon, resolveMessages, validateManifest, } from '@fiodos/core';
+import { createWebCredentialAutofillAdapter } from '../adapters/webCredentialAutofillAdapter.js';
 import { AgentApiError } from '../api/errors.js';
 import { formatAgentTurnError } from '../api/formatTurnError.js';
 import { buildManifestPayload } from '../api/backendClient.js';
@@ -91,12 +92,19 @@ export class AgentController {
             appId: config.manifest.appId,
             version: config.consentVersion,
         });
+        // SMART SIGN-IN ships by default on web (browser password manager);
+        // hosts can override the adapter or pass null to opt out entirely.
+        this.credentialAutofill =
+            config.credentialAutofill === undefined
+                ? createWebCredentialAutofillAdapter()
+                : config.credentialAutofill;
         this.executor = createActionExecutor({
             manifest: config.manifest,
             registries: config.registries,
             navigation: config.navigation,
             messages: this.messages,
             isAuthenticated: config.isAuthenticated,
+            credentialAutofill: this.credentialAutofill,
         });
         this.timings = { ...DEFAULT_AGENT_TIMINGS, ...config.timings };
         // Chaining OFF by default; clamp to the same safe bounds as react/react-native.
@@ -581,6 +589,57 @@ export class AgentController {
                 this.beginConfirmationVoiceWindow();
         }
     }
+    /**
+     * Device capability flags advertised on each turn (never user data). Fresh
+     * per turn: cheap, and honest if the environment changes mid-session.
+     */
+    platformCapabilities() {
+        let autofill = false;
+        try {
+            autofill = this.credentialAutofill?.isSupported() === true;
+        }
+        catch {
+            autofill = false;
+        }
+        return autofill ? { credentialAutofill: true } : undefined;
+    }
+    /**
+     * Live session verdict advertised on each turn (audience map — never user
+     * data): whether the user is signed in plus the app's boolean capability
+     * flags. Fresh per turn so login/logout mid-session is honest. Undefined
+     * when the host wired neither source (older installs — backend filters
+     * nothing, exactly today's behavior).
+     */
+    sessionContext() {
+        const { isAuthenticated, getSessionCapabilities } = this.config;
+        if (!isAuthenticated && !getSessionCapabilities)
+            return undefined;
+        let authenticated = null;
+        try {
+            const v = isAuthenticated?.();
+            authenticated = v == null ? null : Boolean(v);
+        }
+        catch {
+            authenticated = null;
+        }
+        let capabilities;
+        try {
+            const raw = getSessionCapabilities?.();
+            if (raw && typeof raw === 'object') {
+                const clean = {};
+                for (const [k, v] of Object.entries(raw)) {
+                    if (typeof v === 'boolean')
+                        clean[k] = v;
+                }
+                if (Object.keys(clean).length > 0)
+                    capabilities = clean;
+            }
+        }
+        catch {
+            capabilities = undefined;
+        }
+        return { authenticated, ...(capabilities ? { capabilities } : {}) };
+    }
     routeLabel(intent) {
         return this.config.manifest.routes.find((r) => r.intent === intent)?.label;
     }
@@ -766,7 +825,9 @@ export class AgentController {
                         isContinuation: true,
                         chainStep: step,
                         lastStep,
-                        ...buildManifestPayload(this.config.manifest),
+                        platformCapabilities: this.platformCapabilities(),
+                        sessionContext: this.sessionContext(),
+                        ...buildManifestPayload(this.config.manifest, this.config.registries),
                     }, { signal: controller.signal });
                     oc = await this.applyOutcome(turn, routeNow, snap?.context ?? {}, state.userMessage);
                 }
@@ -923,7 +984,9 @@ export class AgentController {
                 conversationHistory: conv.history,
                 conversationSummary: conv.summary ?? undefined,
                 sessionId: this.sessionId,
-                ...buildManifestPayload(this.config.manifest),
+                platformCapabilities: this.platformCapabilities(),
+                sessionContext: this.sessionContext(),
+                ...buildManifestPayload(this.config.manifest, this.config.registries),
             }, { signal: controller.signal });
             outcome = await this.applyOutcome(turn, currentRoute, snapshot?.context ?? {}, text);
         }

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

@@ -13,6 +13,7 @@
  */
 import { type ActionRegistries, type AppManifest } from '@fiodos/core';
 import { AgentController } from '../controller/AgentController.js';
+import type { AgentScreenSnapshot } from '../context/screenContextStore.js';
 import { type MountOrbOptions, type MountedOrb } from '../orb/mountOrb.js';
 import type { FiodosWebAgentConfig } from '../config/types.js';
 export interface CreateFiodosAgentOptions {
@@ -37,8 +38,22 @@ export interface CreateFiodosAgentOptions {
     sttLocale?: string;
     /** Host router navigate delegate. Defaults to location.assign. */
     navigate?: (route: string) => void;
+    /**
+     * Current route/screen resolver for the agent's screen awareness. Defaults
+     * to location.pathname + search. Apps whose screens are CLIENT STATE (no URL
+     * change) pass the generated `fyodosGetCurrentRoute` here so the orb knows
+     * which screen the user is on (see screen-truth wiring).
+     */
+    getCurrentRoute?: () => string | null;
     /** Host auth check for actions requiring auth. */
-    isAuthenticated?: () => boolean;
+    isAuthenticated?: () => boolean | null | undefined;
+    /**
+     * Fine-grained session capability flags (audience map, e.g.
+     * { has_payment_method: true }) from the generated session wiring. Boolean
+     * flags only; sent with each turn so the orb shows this user only THEIR
+     * available actions.
+     */
+    getSessionCapabilities?: () => Record<string, boolean> | null | undefined;
     /** Voice id forwarded to the backend TTS. */
     ttsVoice?: string | (() => string | undefined);
     /** End-user id for rate limiting / telemetry correlation. */
@@ -64,6 +79,17 @@ export interface FiodosAgentHandle {
      * Call it from the app's logout for a hard wipe; no-op until ready.
      */
     resetConversation(): void;
+    /**
+     * Publishes WHAT THE USER IS SEEING so 'execute' actions can target it —
+     * the embed-host equivalent of the React `useAgentScreenContext` hook.
+     * Hosts without our SDK on screens (Dynamics web resources, WinCC CWCs)
+     * call this whenever their form/record/view changes. On the auto-fetch
+     * path, calls made before the controller is ready are kept and applied on
+     * ready, so hosts don't need to await `ready` themselves.
+     */
+    setScreenContext(snapshot: AgentScreenSnapshot): void;
+    /** Clears a previously published snapshot (e.g. the record was closed). */
+    clearScreenContext(): void;
     destroy(): void;
 }
 export declare function createFiodosAgent(options: CreateFiodosAgentOptions): FiodosAgentHandle;

package/dist/esm/dropin/createFiodosAgent.js CHANGED Viewed

@@ -29,6 +29,11 @@ function browserLocale() {
     const lang = typeof navigator !== 'undefined' && navigator.language ? navigator.language : 'en-US';
     return { locale: lang.split('-')[0] || 'en', sttLocale: lang };
 }
+function documentLocale() {
+    return typeof document !== 'undefined'
+        ? document.documentElement.lang?.split(/[-_]/)[0]?.trim() || ''
+        : '';
+}
 function resolveAgentLocale(options) {
     const fromApp = options.getLocale?.()?.trim();
     if (fromApp)
@@ -38,12 +43,16 @@ function resolveAgentLocale(options) {
     if (options.localeDetection === 'browser')
         return browserLocale().locale;
     if (options.localeDetection === 'document') {
-        const docLang = typeof document !== 'undefined'
-            ? document.documentElement.lang?.split(/[-_]/)[0]?.trim()
-            : '';
+        const docLang = documentLocale();
         if (docLang)
             return docLang;
     }
+    // Default (nothing configured): follow the HOST PAGE's language when the
+    // page declares one (<html lang>), so the orb bubble speaks the language the
+    // end user is actually browsing in. English only as the last resort.
+    const docLang = documentLocale();
+    if (docLang)
+        return docLang;
     return 'en';
 }
 /** Build the controller + adapters from a known manifest (shared by both paths). */
@@ -64,14 +73,22 @@ function assemble(options, manifest, baseUrl) {
     const config = {
         manifest,
         locale,
+        // Live resolver: re-runs the same resolution chain (app getLocale → static
+        // locale → detection) on every read, so the bubble follows the host app's
+        // language switcher / <html lang> without remounting the agent.
+        getLocale: () => resolveAgentLocale(options),
         sttLocale,
-        navigation: createWebNavigationAdapter({ navigate: options.navigate ?? defaultNavigate }),
+        navigation: createWebNavigationAdapter({
+            navigate: options.navigate ?? defaultNavigate,
+            getCurrentRoute: options.getCurrentRoute,
+        }),
         registries: options.registries ?? { handlers: {}, idempotencyCheckers: {} },
         backend,
         voice: createWebVoiceAdapter(),
         storage: createWebStorageAdapter(),
         telemetry,
         isAuthenticated: options.isAuthenticated,
+        getSessionCapabilities: options.getSessionCapabilities,
         getUserId: options.getUserId,
         ttsVoice: options.ttsVoice,
         ...options.configOverrides,
@@ -83,6 +100,9 @@ function assemble(options, manifest, baseUrl) {
 export function createFiodosAgent(options) {
     const baseUrl = (options.baseUrl ?? DEFAULT_WEB_API_URL).replace(/\/$/, '');
     const shouldMount = options.mount !== false;
+    // One stable owner id per handle: the host is "one screen" from the store's
+    // point of view, so consecutive setScreenContext calls replace each other.
+    const contextOwner = Symbol('fiodos-embed-host');
     // ── Manual path: manifest provided → fully synchronous (back-compat). ───────
     if (options.manifest) {
         const controller = assemble(options, options.manifest, baseUrl);
@@ -98,6 +118,12 @@ export function createFiodosAgent(options) {
             resetConversation() {
                 controller.resetConversation();
             },
+            setScreenContext(snapshot) {
+                controller.screenStore.set(contextOwner, snapshot);
+            },
+            clearScreenContext() {
+                controller.screenStore.clear(contextOwner);
+            },
             destroy() {
                 orb?.unmount();
                 controller.dispose();
@@ -106,6 +132,9 @@ export function createFiodosAgent(options) {
         return handle;
     }
     // ── Auto path (React parity): fetch manifest by apiKey, then assemble. ──────
+    // Context published before the controller resolves is buffered (last one
+    // wins) and applied on ready — hosts fire form events without awaiting us.
+    let pendingSnapshot;
     const handle = {
         controller: null,
         orb: null,
@@ -113,6 +142,18 @@ export function createFiodosAgent(options) {
         resetConversation() {
             handle.controller?.resetConversation();
         },
+        setScreenContext(snapshot) {
+            if (handle.controller)
+                handle.controller.screenStore.set(contextOwner, snapshot);
+            else
+                pendingSnapshot = snapshot;
+        },
+        clearScreenContext() {
+            if (handle.controller)
+                handle.controller.screenStore.clear(contextOwner);
+            else
+                pendingSnapshot = null;
+        },
         destroy() {
             cancelled = true;
             handle.orb?.unmount();
@@ -148,6 +189,9 @@ export function createFiodosAgent(options) {
                 return null;
             }
             handle.controller = controller;
+            if (pendingSnapshot)
+                controller.screenStore.set(contextOwner, pendingSnapshot);
+            pendingSnapshot = undefined;
             handle.orb = shouldMount ? mountOrb(controller, options.orb) : null;
             if (shouldMount && options.apiKey) {
                 void sendOrbSeen({ baseUrl, apiKey: options.apiKey });

package/dist/esm/embed/dynamics.d.ts ADDED Viewed

@@ -0,0 +1,61 @@
+import type { AgentScreenSnapshot } from '../context/screenContextStore.js';
+interface XrmAttributeLike {
+    getName(): string;
+    getValue(): unknown;
+    /** Present on optionset/lookup attributes; preferred over raw values. */
+    getText?(): string | string[] | null;
+}
+interface XrmEntityLike {
+    getEntityName(): string;
+    /** Record GUID, usually brace-wrapped: "{1D2C...}". Empty on create forms. */
+    getId(): string;
+    getPrimaryAttributeValue?(): string | null;
+    attributes?: {
+        forEach(cb: (attribute: XrmAttributeLike) => void): void;
+    };
+    /** Model-driven apps expose save events here (Xrm ≥ 9.x). */
+    addOnPostSave?(handler: () => void): void;
+    removeOnPostSave?(handler: () => void): void;
+}
+export interface DynamicsFormContextLike {
+    data: {
+        entity: XrmEntityLike;
+    };
+    ui?: {
+        getFormType?(): number;
+    };
+}
+/** The subset of FiodosAgentHandle the bridge needs (keeps this module cheap to test). */
+export interface ScreenContextSink {
+    setScreenContext(snapshot: AgentScreenSnapshot): void;
+    clearScreenContext(): void;
+}
+export interface DynamicsSnapshotOptions {
+    /**
+     * Logical names of the attributes to expose to the agent. When omitted, the
+     * first `maxAttributes` non-empty scalar attributes are included.
+     */
+    attributes?: string[];
+    /** Cap when no allowlist is given. Default 12. */
+    maxAttributes?: number;
+}
+/** "{1D2C…}" → "1d2c…" (Web API URLs want bare lowercase GUIDs). */
+export declare function normalizeDynamicsId(rawId: string): string;
+/**
+ * Builds the AgentScreenSnapshot for the current form state, or null when
+ * there is nothing referenceable yet (create form: no record id).
+ */
+export declare function dynamicsFormSnapshot(formContext: DynamicsFormContextLike, options?: DynamicsSnapshotOptions): AgentScreenSnapshot | null;
+export interface DynamicsContextBridge {
+    /** Re-reads the form and republishes the snapshot (wire to OnChange/OnSave). */
+    refresh(): void;
+    /** Stops publishing and clears the agent's screen context. */
+    disconnect(): void;
+}
+/**
+ * Publishes the form snapshot now, republishes after every save (when the
+ * form exposes OnPostSave), and clears the context on disconnect. Call it from
+ * the form's OnLoad handler.
+ */
+export declare function connectDynamicsFormContext(agent: ScreenContextSink, formContext: DynamicsFormContextLike, options?: DynamicsSnapshotOptions): DynamicsContextBridge;
+export {};

package/dist/esm/embed/dynamics.js ADDED Viewed

@@ -0,0 +1,168 @@
+// ── Value normalization ──────────────────────────────────────────────────────
+const MAX_VALUE_CHARS = 120;
+function clip(text) {
+    const t = text.trim();
+    return t.length > MAX_VALUE_CHARS ? `${t.slice(0, MAX_VALUE_CHARS - 1)}…` : t;
+}
+/** Lookup values arrive as [{ id, name, entityType }] — show the names. */
+function lookupNames(value) {
+    const names = value
+        .map((v) => v && typeof v === 'object' && typeof v.name === 'string'
+        ? (v.name)
+        : null)
+        .filter((n) => !!n);
+    return names.length ? names.join(', ') : null;
+}
+function normalizeAttributeValue(attribute) {
+    // Optionset / lookup / boolean attributes carry a human label — prefer it.
+    try {
+        const text = attribute.getText?.();
+        if (typeof text === 'string' && text.trim())
+            return clip(text);
+        if (Array.isArray(text) && text.length)
+            return clip(text.join(', '));
+    }
+    catch {
+        /* some attribute types throw on getText — fall through to raw value */
+    }
+    let value;
+    try {
+        value = attribute.getValue();
+    }
+    catch {
+        return null;
+    }
+    if (value == null)
+        return null;
+    if (typeof value === 'string')
+        return value.trim() ? clip(value) : null;
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return value;
+    if (value instanceof Date)
+        return value.toISOString();
+    if (Array.isArray(value)) {
+        const names = lookupNames(value);
+        return names ? clip(names) : null;
+    }
+    return null; // collections / unknown object shapes are skipped, never guessed
+}
+/** "{1D2C…}" → "1d2c…" (Web API URLs want bare lowercase GUIDs). */
+export function normalizeDynamicsId(rawId) {
+    return rawId.replace(/[{}]/g, '').trim().toLowerCase();
+}
+// ── Snapshot builder ─────────────────────────────────────────────────────────
+/**
+ * Builds the AgentScreenSnapshot for the current form state, or null when
+ * there is nothing referenceable yet (create form: no record id).
+ */
+export function dynamicsFormSnapshot(formContext, options = {}) {
+    const entity = formContext.data?.entity;
+    if (!entity)
+        return null;
+    const entityName = entity.getEntityName();
+    const recordId = normalizeDynamicsId(entity.getId() ?? '');
+    const allowlist = options.attributes?.length
+        ? new Set(options.attributes.map((a) => a.trim().toLowerCase()).filter(Boolean))
+        : null;
+    const maxAttributes = options.maxAttributes ?? 12;
+    const fields = {};
+    let count = 0;
+    entity.attributes?.forEach((attribute) => {
+        let name;
+        try {
+            name = attribute.getName();
+        }
+        catch {
+            return;
+        }
+        if (!name)
+            return;
+        if (allowlist) {
+            if (!allowlist.has(name.toLowerCase()))
+                return;
+        }
+        else if (count >= maxAttributes) {
+            return;
+        }
+        const value = normalizeAttributeValue(attribute);
+        if (value == null)
+            return;
+        fields[name] = value;
+        count += 1;
+    });
+    let title;
+    try {
+        title = entity.getPrimaryAttributeValue?.() ?? undefined;
+    }
+    catch {
+        title = undefined;
+    }
+    // Create forms have no id yet: the agent can still SEE the fields, but there
+    // is no target for execute actions, so we publish text-only context.
+    const item = recordId
+        ? { id: recordId, kind: entityName, title, metadata: fields }
+        : null;
+    const fieldSummary = Object.entries(fields)
+        .map(([k, v]) => `${k}: ${v}`)
+        .join('; ');
+    const textParts = [
+        `Dynamics 365 form — entity "${entityName}"`,
+        recordId ? `record "${title ?? recordId}" (id ${recordId})` : 'new record (not saved yet)',
+    ];
+    if (fieldSummary)
+        textParts.push(`Fields: ${fieldSummary}`);
+    const context = {
+        ...(item ? { visibleContent: { items: [item], focusedIndex: 0 } } : {}),
+        custom: {
+            platform: 'dynamics365',
+            entityName,
+            ...(recordId ? { recordId } : {}),
+            ...(typeof formContext.ui?.getFormType === 'function'
+                ? { formType: formContext.ui.getFormType() }
+                : {}),
+        },
+    };
+    return { kind: `dynamics-form:${entityName}`, text: textParts.join('. '), context };
+}
+/**
+ * Publishes the form snapshot now, republishes after every save (when the
+ * form exposes OnPostSave), and clears the context on disconnect. Call it from
+ * the form's OnLoad handler.
+ */
+export function connectDynamicsFormContext(agent, formContext, options = {}) {
+    let disconnected = false;
+    const publish = () => {
+        if (disconnected)
+            return;
+        const snapshot = dynamicsFormSnapshot(formContext, options);
+        if (snapshot)
+            agent.setScreenContext(snapshot);
+        else
+            agent.clearScreenContext();
+    };
+    publish();
+    const entity = formContext.data?.entity;
+    if (entity?.addOnPostSave) {
+        try {
+            entity.addOnPostSave(publish);
+        }
+        catch {
+            /* older clients — the host can still call refresh() manually */
+        }
+    }
+    return {
+        refresh: publish,
+        disconnect() {
+            if (disconnected)
+                return;
+            disconnected = true;
+            try {
+                entity?.removeOnPostSave?.(publish);
+            }
+            catch {
+                /* best-effort unsubscribe */
+            }
+            agent.clearScreenContext();
+        },
+    };
+}

package/dist/esm/embed/global.d.ts ADDED Viewed

@@ -0,0 +1,45 @@
+/**
+ * Embed entrypoint — single-file IIFE bundle for CLOSED third-party hosts
+ * where npm/ESM is not available: Dynamics 365 web resources, WinCC Unified
+ * Custom Web Controls, Salesforce LWC iframes, plain <script> tags.
+ *
+ * Built by `npm run build:embed` into dist/embed/fiodos-embed.js and exposed
+ * as the `Fiodos` global:
+ *
+ *   <script src="fiodos-embed.js"></script>
+ *   <script>
+ *     const agent = Fiodos.createFiodosAgent({
+ *       manifest,                                   // e.g. from `fiodos from-odata`
+ *       registries: Fiodos.buildApiActionRegistries(manifest, {
+ *         baseUrl: 'https://org.crm.dynamics.com/api/data/v9.2',
+ *         authProviders: { dataverse: () => ({ Authorization: `Bearer ${token}` }) },
+ *       }),
+ *     });
+ *   </script>
+ *
+ * The bundle is self-contained (core + web-core inlined) and side-effect-free
+ * beyond assigning the global — it never auto-mounts; the host decides when.
+ */
+import { createFiodosAgent } from '../dropin/createFiodosAgent.js';
+import { mountOrb } from '../orb/mountOrb.js';
+import { AgentController } from '../controller/AgentController.js';
+import { createScreenContextStore } from '../context/screenContextStore.js';
+import { connectDynamicsFormContext, dynamicsFormSnapshot, normalizeDynamicsId } from './dynamics.js';
+import { buildApiActionRegistries, validateManifest } from '@fiodos/core';
+declare const api: {
+    readonly version: "0.1.15";
+    readonly createFiodosAgent: typeof createFiodosAgent;
+    readonly mountOrb: typeof mountOrb;
+    readonly AgentController: typeof AgentController;
+    readonly createScreenContextStore: typeof createScreenContextStore;
+    readonly buildApiActionRegistries: typeof buildApiActionRegistries;
+    readonly validateManifest: typeof validateManifest;
+    readonly connectDynamicsFormContext: typeof connectDynamicsFormContext;
+    readonly dynamicsFormSnapshot: typeof dynamicsFormSnapshot;
+    readonly normalizeDynamicsId: typeof normalizeDynamicsId;
+};
+declare global {
+    var Fiodos: typeof api | undefined;
+}
+export type FiodosEmbedApi = typeof api;
+export {};

package/dist/esm/embed/global.js ADDED Viewed

@@ -0,0 +1,46 @@
+/**
+ * Embed entrypoint — single-file IIFE bundle for CLOSED third-party hosts
+ * where npm/ESM is not available: Dynamics 365 web resources, WinCC Unified
+ * Custom Web Controls, Salesforce LWC iframes, plain <script> tags.
+ *
+ * Built by `npm run build:embed` into dist/embed/fiodos-embed.js and exposed
+ * as the `Fiodos` global:
+ *
+ *   <script src="fiodos-embed.js"></script>
+ *   <script>
+ *     const agent = Fiodos.createFiodosAgent({
+ *       manifest,                                   // e.g. from `fiodos from-odata`
+ *       registries: Fiodos.buildApiActionRegistries(manifest, {
+ *         baseUrl: 'https://org.crm.dynamics.com/api/data/v9.2',
+ *         authProviders: { dataverse: () => ({ Authorization: `Bearer ${token}` }) },
+ *       }),
+ *     });
+ *   </script>
+ *
+ * The bundle is self-contained (core + web-core inlined) and side-effect-free
+ * beyond assigning the global — it never auto-mounts; the host decides when.
+ */
+import { createFiodosAgent } from '../dropin/createFiodosAgent.js';
+import { mountOrb } from '../orb/mountOrb.js';
+import { AgentController } from '../controller/AgentController.js';
+import { createScreenContextStore } from '../context/screenContextStore.js';
+import { connectDynamicsFormContext, dynamicsFormSnapshot, normalizeDynamicsId, } from './dynamics.js';
+import { SDK_VERSION } from '../version.js';
+import { buildApiActionRegistries, validateManifest } from '@fiodos/core';
+const api = {
+    version: SDK_VERSION,
+    createFiodosAgent,
+    mountOrb,
+    AgentController,
+    createScreenContextStore,
+    // Closed-software mode: turn ApiExecutionSpec manifests into live handlers,
+    // and validate hand-written / from-odata manifests before mounting.
+    buildApiActionRegistries,
+    validateManifest,
+    // Context bridges: tell the orb what the host is showing. Dynamics gets a
+    // dedicated mapper (formContext); any other host calls agent.setScreenContext.
+    connectDynamicsFormContext,
+    dynamicsFormSnapshot,
+    normalizeDynamicsId,
+};
+globalThis.Fiodos = api;