dynim-react 1.0.0

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,cAAc,YAAY,CAAC;AAG3B,OAAO,EAEL,eAAe,EACf,UAAU,EAEV,YAAY,EACZ,cAAc,EAEd,WAAW,EACX,SAAS,EACT,aAAa,EAEb,UAAU,EAEV,UAAU,EACV,YAAY,EACZ,eAAe,EACf,YAAY,GACb,MAAM,WAAW,CAAC;AAEnB,YAAY,EACV,aAAa,EACb,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EACjB,gBAAgB,EAChB,cAAc,EACd,kBAAkB,EAClB,gBAAgB,EAChB,gBAAgB,EAChB,SAAS,GACV,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,iBAAiB,EACjB,wBAAwB,EACxB,mBAAmB,EACnB,gBAAgB,EAChB,oBAAoB,GACrB,MAAM,aAAa,CAAC;AAErB,YAAY,EACV,cAAc,EACd,sBAAsB,EACtB,cAAc,EACd,WAAW,GACZ,MAAM,aAAa,CAAC"}

package/dist/index.js

@@ -0,0 +1,24 @@
+/**
+ * dynim-react - React wrapper for dynim-core
+ *
+ * This package provides:
+ * - Re-exports everything from dynim-core (for convenience)
+ * - React components and hooks for the builder
+ * - Inference SDK for tenant customization loading
+ */
+// Re-export EVERYTHING from dynim-core
+export * from 'dynim-core';
+// Builder React exports
+export { 
+// Provider and hook
+BuilderProvider, useBuilder, 
+// Chat context
+ChatProvider, useChatContext, 
+// Components
+MessageList, ChatInput, CodeChatPanel, 
+// Headless hook
+useChatbot, 
+// Zone wrappers for customization control
+LockedZone, EditableZone, NonCustomizable, Customizable, } from './builder';
+// Inference exports
+export { InferenceProvider, InferenceProviderDefault, createSharedContext, getSharedContext, isSharedContextReady, } from './inference';

package/dist/inference/DynimProvider.d.ts

@@ -0,0 +1,23 @@
+import type { DynimProviderProps } from './types';
+/**
+ * DynimProvider - A React component that dynamically loads tenant-specific bundles.
+ *
+ * This provider handles the lifecycle of loading, rendering, and cleaning up
+ * tenant customization bundles. It supports optional pre-checks to determine
+ * if a tenant has customizations before attempting to load them.
+ *
+ * @example
+ * ```tsx
+ * <DynimProvider
+ *   tenantId={user?.tenantId}
+ *   bundleUrl={(id) => `https://cdn.example.com/bundles/${id}.js`}
+ *   loadingComponent={<Spinner />}
+ *   errorBanner={true}
+ * >
+ *   <YourBaseApp />
+ * </DynimProvider>
+ * ```
+ */
+export declare function DynimProvider({ tenantId, bundleUrl, checkCustomizations, loadingComponent, errorBanner, onError, onLoad, children, }: DynimProviderProps): JSX.Element;
+export default DynimProvider;
+//# sourceMappingURL=DynimProvider.d.ts.map

package/dist/inference/DynimProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DynimProvider.d.ts","sourceRoot":"","sources":["../../src/inference/DynimProvider.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAc,MAAM,SAAS,CAAC;AA8E9D;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAAC,EAC5B,QAAQ,EACR,SAAS,EACT,mBAAmB,EACnB,gBAAgB,EAChB,WAAmB,EACnB,OAAO,EACP,MAAM,EACN,QAAQ,GACT,EAAE,kBAAkB,GAAG,GAAG,CAAC,OAAO,CAuLlC;AAED,eAAe,aAAa,CAAC"}

package/dist/inference/DynimProvider.js

@@ -0,0 +1,231 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState, useEffect, useCallback, useRef } from 'react';
+/**
+ * Default loading component shown while bundle is loading
+ */
+function DefaultLoadingComponent() {
+    return (_jsx("div", { style: {
+            display: 'flex',
+            justifyContent: 'center',
+            alignItems: 'center',
+            padding: '20px',
+        }, children: _jsx("span", { children: "Loading customizations..." }) }));
+}
+/**
+ * Default error banner component
+ */
+function DefaultErrorBanner({ error }) {
+    return (_jsxs("div", { style: {
+            background: '#fee2e2',
+            border: '1px solid #ef4444',
+            borderRadius: '4px',
+            padding: '12px 16px',
+            marginBottom: '16px',
+            color: '#991b1b',
+        }, children: [_jsx("strong", { children: "Customization Error:" }), " ", error.message] }));
+}
+/**
+ * Container for rendering tenant bundle content
+ */
+function BundleContainer() {
+    return _jsx("div", { id: "dynim-root" });
+}
+/**
+ * Loads a script from a URL and returns a promise that resolves when loaded
+ */
+function loadScript(url) {
+    return new Promise((resolve, reject) => {
+        // Check if script already exists
+        const existingScript = document.querySelector(`script[src="${url}"]`);
+        if (existingScript) {
+            resolve();
+            return;
+        }
+        const script = document.createElement('script');
+        script.src = url;
+        script.async = true;
+        script.onload = () => resolve();
+        script.onerror = () => reject(new Error(`Failed to load bundle from ${url}`));
+        document.head.appendChild(script);
+    });
+}
+/**
+ * Removes a previously loaded script
+ */
+function removeScript(url) {
+    const script = document.querySelector(`script[src="${url}"]`);
+    if (script) {
+        script.remove();
+    }
+}
+/**
+ * DynimProvider - A React component that dynamically loads tenant-specific bundles.
+ *
+ * This provider handles the lifecycle of loading, rendering, and cleaning up
+ * tenant customization bundles. It supports optional pre-checks to determine
+ * if a tenant has customizations before attempting to load them.
+ *
+ * @example
+ * ```tsx
+ * <DynimProvider
+ *   tenantId={user?.tenantId}
+ *   bundleUrl={(id) => `https://cdn.example.com/bundles/${id}.js`}
+ *   loadingComponent={<Spinner />}
+ *   errorBanner={true}
+ * >
+ *   <YourBaseApp />
+ * </DynimProvider>
+ * ```
+ */
+export function DynimProvider({ tenantId, bundleUrl, checkCustomizations, loadingComponent, errorBanner = false, onError, onLoad, children, }) {
+    const [state, setState] = useState({
+        status: 'idle',
+        error: null,
+        currentTenantId: null,
+    });
+    const loadedUrlRef = useRef(null);
+    /**
+     * Resolves the bundle URL for a given tenant ID
+     */
+    const resolveBundleUrl = useCallback((id) => {
+        if (typeof bundleUrl === 'function') {
+            return bundleUrl(id);
+        }
+        // If bundleUrl is a string template, replace {tenantId} placeholder
+        return bundleUrl.replace('{tenantId}', id);
+    }, [bundleUrl]);
+    /**
+     * Cleans up previously loaded bundle
+     */
+    const cleanup = useCallback(() => {
+        if (loadedUrlRef.current) {
+            removeScript(loadedUrlRef.current);
+            loadedUrlRef.current = null;
+        }
+        // Clear the bundle render target
+        const root = document.getElementById('dynim-root');
+        if (root) {
+            root.innerHTML = '';
+        }
+    }, []);
+    /**
+     * Main effect to handle tenant bundle loading
+     */
+    useEffect(() => {
+        // No tenant - reset to idle and show children
+        if (!tenantId) {
+            cleanup();
+            setState({
+                status: 'idle',
+                error: null,
+                currentTenantId: null,
+            });
+            return;
+        }
+        // Same tenant already loaded - do nothing
+        if (state.currentTenantId === tenantId && state.status === 'loaded') {
+            return;
+        }
+        let cancelled = false;
+        async function loadBundle() {
+            try {
+                // Step 1: Check if tenant has customizations (if check function provided)
+                if (checkCustomizations) {
+                    setState((prev) => ({ ...prev, status: 'checking' }));
+                    const hasCustomizations = await checkCustomizations(tenantId);
+                    if (cancelled)
+                        return;
+                    if (!hasCustomizations) {
+                        cleanup();
+                        setState({
+                            status: 'no-customization',
+                            error: null,
+                            currentTenantId: tenantId,
+                        });
+                        return;
+                    }
+                }
+                // Step 2: Load the bundle
+                setState((prev) => ({ ...prev, status: 'loading' }));
+                // Clean up previous bundle
+                cleanup();
+                const url = resolveBundleUrl(tenantId);
+                await loadScript(url);
+                if (cancelled) {
+                    removeScript(url);
+                    return;
+                }
+                loadedUrlRef.current = url;
+                setState({
+                    status: 'loaded',
+                    error: null,
+                    currentTenantId: tenantId,
+                });
+                onLoad?.(tenantId);
+            }
+            catch (err) {
+                if (cancelled)
+                    return;
+                const error = err instanceof Error ? err : new Error(String(err));
+                setState({
+                    status: 'error',
+                    error,
+                    currentTenantId: tenantId,
+                });
+                onError?.(error, tenantId);
+            }
+        }
+        loadBundle();
+        return () => {
+            cancelled = true;
+        };
+    }, [
+        tenantId,
+        checkCustomizations,
+        resolveBundleUrl,
+        cleanup,
+        onError,
+        onLoad,
+        state.currentTenantId,
+        state.status,
+    ]);
+    /**
+     * Cleanup on unmount
+     */
+    useEffect(() => {
+        return () => {
+            cleanup();
+        };
+    }, [cleanup]);
+    // Render error banner if enabled and there's an error
+    const renderErrorBanner = () => {
+        if (!errorBanner || state.status !== 'error' || !state.error) {
+            return null;
+        }
+        if (errorBanner === true) {
+            return _jsx(DefaultErrorBanner, { error: state.error });
+        }
+        return errorBanner;
+    };
+    // Determine what to render based on state
+    const renderContent = () => {
+        switch (state.status) {
+            case 'checking':
+            case 'loading':
+                return loadingComponent ?? _jsx(DefaultLoadingComponent, {});
+            case 'loaded':
+                // Bundle is loaded and will render itself into #dynim-root
+                return _jsx(BundleContainer, {});
+            case 'error':
+                // Show children as fallback with optional error banner
+                return (_jsxs(_Fragment, { children: [renderErrorBanner(), children] }));
+            case 'no-customization':
+            case 'idle':
+            default:
+                // No customizations or no tenant - render base app
+                return children;
+        }
+    };
+    return _jsx(_Fragment, { children: renderContent() });
+}
+export default DynimProvider;

package/dist/inference/InferenceProvider.d.ts

@@ -0,0 +1,23 @@
+import type { InferenceProviderProps } from './types';
+/**
+ * InferenceProvider - A React component that dynamically loads tenant-specific bundles.
+ *
+ * This provider handles the lifecycle of loading, rendering, and cleaning up
+ * tenant customization bundles. It supports optional pre-checks to determine
+ * if a tenant has customizations before attempting to load them.
+ *
+ * @example
+ * ```tsx
+ * <InferenceProvider
+ *   tenantId={user?.tenantId}
+ *   bundleUrl={(id) => `https://cdn.example.com/bundles/${id}.js`}
+ *   loadingComponent={<Spinner />}
+ *   errorBanner={true}
+ * >
+ *   <YourBaseApp />
+ * </InferenceProvider>
+ * ```
+ */
+export declare function InferenceProvider({ tenantId, bundleUrl, bundleToken, checkCustomizations, loadingComponent, errorBanner, onError, onLoad, children, }: InferenceProviderProps): JSX.Element;
+export default InferenceProvider;
+//# sourceMappingURL=InferenceProvider.d.ts.map

package/dist/inference/InferenceProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InferenceProvider.d.ts","sourceRoot":"","sources":["../../src/inference/InferenceProvider.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAkB,MAAM,SAAS,CAAC;AAkHtE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,QAAQ,EACR,SAAS,EACT,WAAW,EACX,mBAAmB,EACnB,gBAAgB,EAChB,WAAmB,EACnB,OAAO,EACP,MAAM,EACN,QAAQ,GACT,EAAE,sBAAsB,GAAG,GAAG,CAAC,OAAO,CA8LtC;AAED,eAAe,iBAAiB,CAAC"}

package/dist/inference/InferenceProvider.js

@@ -0,0 +1,270 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useState, useEffect, useCallback, useRef } from 'react';
+/**
+ * Default loading component shown while bundle is loading
+ */
+function DefaultLoadingComponent() {
+    return (_jsx("div", { style: {
+            display: 'flex',
+            justifyContent: 'center',
+            alignItems: 'center',
+            padding: '20px',
+        }, children: _jsx("span", { children: "Loading customizations..." }) }));
+}
+/**
+ * Default error banner component
+ */
+function DefaultErrorBanner({ error }) {
+    return (_jsxs("div", { style: {
+            background: '#fee2e2',
+            border: '1px solid #ef4444',
+            borderRadius: '4px',
+            padding: '12px 16px',
+            marginBottom: '16px',
+            color: '#991b1b',
+        }, children: [_jsx("strong", { children: "Customization Error:" }), " ", error.message] }));
+}
+/**
+ * Container for rendering tenant bundle content
+ */
+function BundleContainer() {
+    return _jsx("div", { id: "dynim-root" });
+}
+/**
+ * Loads a script from a URL and returns a promise that resolves when loaded
+ */
+function loadScript(url) {
+    return new Promise((resolve, reject) => {
+        // Check if script already exists
+        const existingScript = document.querySelector(`script[src="${url}"]`);
+        if (existingScript) {
+            resolve();
+            return;
+        }
+        const script = document.createElement('script');
+        script.src = url;
+        script.async = true;
+        script.onload = () => resolve();
+        script.onerror = () => reject(new Error(`Failed to load bundle from ${url}`));
+        document.head.appendChild(script);
+    });
+}
+/**
+ * Loads a script from a URL with authentication and returns a promise
+ */
+async function loadScriptWithAuth(url, token) {
+    const response = await fetch(url, {
+        headers: {
+            Authorization: `Bearer ${token}`,
+        },
+    });
+    if (!response.ok) {
+        if (response.status === 401) {
+            throw new Error('Bundle token is invalid or expired');
+        }
+        if (response.status === 404) {
+            throw new Error('Bundle not found');
+        }
+        throw new Error(`Failed to load bundle: ${response.status} ${response.statusText}`);
+    }
+    const scriptContent = await response.text();
+    // Execute the script content
+    const script = document.createElement('script');
+    script.textContent = scriptContent;
+    script.setAttribute('data-dynim-bundle', url);
+    document.head.appendChild(script);
+}
+/**
+ * Removes a previously loaded script (handles both src and data-dynim-bundle attributes)
+ */
+function removeScript(url) {
+    // Try src attribute first (script tag injection)
+    let script = document.querySelector(`script[src="${url}"]`);
+    if (script) {
+        script.remove();
+        return;
+    }
+    // Try data-dynim-bundle attribute (authenticated fetch)
+    script = document.querySelector(`script[data-dynim-bundle="${url}"]`);
+    if (script) {
+        script.remove();
+    }
+}
+/**
+ * InferenceProvider - A React component that dynamically loads tenant-specific bundles.
+ *
+ * This provider handles the lifecycle of loading, rendering, and cleaning up
+ * tenant customization bundles. It supports optional pre-checks to determine
+ * if a tenant has customizations before attempting to load them.
+ *
+ * @example
+ * ```tsx
+ * <InferenceProvider
+ *   tenantId={user?.tenantId}
+ *   bundleUrl={(id) => `https://cdn.example.com/bundles/${id}.js`}
+ *   loadingComponent={<Spinner />}
+ *   errorBanner={true}
+ * >
+ *   <YourBaseApp />
+ * </InferenceProvider>
+ * ```
+ */
+export function InferenceProvider({ tenantId, bundleUrl, bundleToken, checkCustomizations, loadingComponent, errorBanner = false, onError, onLoad, children, }) {
+    const [state, setState] = useState({
+        status: 'idle',
+        error: null,
+        currentTenantId: null,
+    });
+    const loadedUrlRef = useRef(null);
+    /**
+     * Resolves the bundle URL for a given tenant ID
+     */
+    const resolveBundleUrl = useCallback((id) => {
+        if (typeof bundleUrl === 'function') {
+            return bundleUrl(id);
+        }
+        // If bundleUrl is a string template, replace {tenantId} placeholder
+        return bundleUrl.replace('{tenantId}', id);
+    }, [bundleUrl]);
+    /**
+     * Cleans up previously loaded bundle
+     */
+    const cleanup = useCallback(() => {
+        if (loadedUrlRef.current) {
+            removeScript(loadedUrlRef.current);
+            loadedUrlRef.current = null;
+        }
+        // Clear the bundle render target
+        const root = document.getElementById('dynim-root');
+        if (root) {
+            root.innerHTML = '';
+        }
+    }, []);
+    /**
+     * Main effect to handle tenant bundle loading
+     */
+    useEffect(() => {
+        // No tenant - reset to idle and show children
+        if (!tenantId) {
+            cleanup();
+            setState({
+                status: 'idle',
+                error: null,
+                currentTenantId: null,
+            });
+            return;
+        }
+        // Same tenant already loaded - do nothing
+        if (state.currentTenantId === tenantId && state.status === 'loaded') {
+            return;
+        }
+        let cancelled = false;
+        async function loadBundle() {
+            try {
+                // Step 1: Check if tenant has customizations (if check function provided)
+                if (checkCustomizations) {
+                    setState((prev) => ({ ...prev, status: 'checking' }));
+                    const hasCustomizations = await checkCustomizations(tenantId);
+                    if (cancelled)
+                        return;
+                    if (!hasCustomizations) {
+                        cleanup();
+                        setState({
+                            status: 'no-customization',
+                            error: null,
+                            currentTenantId: tenantId,
+                        });
+                        return;
+                    }
+                }
+                // Step 2: Load the bundle
+                setState((prev) => ({ ...prev, status: 'loading' }));
+                // Clean up previous bundle
+                cleanup();
+                const url = resolveBundleUrl(tenantId);
+                // Use authenticated fetch if bundleToken is provided, otherwise use script tag
+                if (bundleToken) {
+                    await loadScriptWithAuth(url, bundleToken);
+                }
+                else {
+                    await loadScript(url);
+                }
+                if (cancelled) {
+                    removeScript(url);
+                    return;
+                }
+                loadedUrlRef.current = url;
+                setState({
+                    status: 'loaded',
+                    error: null,
+                    currentTenantId: tenantId,
+                });
+                onLoad?.(tenantId);
+            }
+            catch (err) {
+                if (cancelled)
+                    return;
+                const error = err instanceof Error ? err : new Error(String(err));
+                setState({
+                    status: 'error',
+                    error,
+                    currentTenantId: tenantId,
+                });
+                onError?.(error, tenantId);
+            }
+        }
+        loadBundle();
+        return () => {
+            cancelled = true;
+        };
+    }, [
+        tenantId,
+        bundleToken,
+        checkCustomizations,
+        resolveBundleUrl,
+        cleanup,
+        onError,
+        onLoad,
+        state.currentTenantId,
+        state.status,
+    ]);
+    /**
+     * Cleanup on unmount
+     */
+    useEffect(() => {
+        return () => {
+            cleanup();
+        };
+    }, [cleanup]);
+    // Render error banner if enabled and there's an error
+    const renderErrorBanner = () => {
+        if (!errorBanner || state.status !== 'error' || !state.error) {
+            return null;
+        }
+        if (errorBanner === true) {
+            return _jsx(DefaultErrorBanner, { error: state.error });
+        }
+        return errorBanner;
+    };
+    // Determine what to render based on state
+    const renderContent = () => {
+        switch (state.status) {
+            case 'checking':
+            case 'loading':
+                return loadingComponent ?? _jsx(DefaultLoadingComponent, {});
+            case 'loaded':
+                // Bundle is loaded and will render itself into #dynim-root
+                return _jsx(BundleContainer, {});
+            case 'error':
+                // Show children as fallback with optional error banner
+                return (_jsxs(_Fragment, { children: [renderErrorBanner(), children] }));
+            case 'no-customization':
+            case 'idle':
+            default:
+                // No customizations or no tenant - render base app
+                return children;
+        }
+    };
+    return _jsx(_Fragment, { children: renderContent() });
+}
+export default InferenceProvider;

package/dist/inference/createDynimSDK.d.ts

@@ -0,0 +1,39 @@
+import type { DynimSDKConfig, DynimGlobal } from './types';
+/**
+ * Creates and registers the Dynim SDK on the window object.
+ * This makes React, ReactDOM, hooks, and contexts available to tenant bundles.
+ *
+ * @param config - Configuration object containing React, ReactDOM, hooks, and contexts
+ * @returns The created SDK object
+ *
+ * @example
+ * ```tsx
+ * import { createDynimSDK } from 'dynim-react';
+ * import React from 'react';
+ * import ReactDOM from 'react-dom';
+ * import { useAuth, useNotifications } from './hooks';
+ * import { AuthContext, NotificationContext } from './contexts';
+ *
+ * createDynimSDK({
+ *   React,
+ *   ReactDOM,
+ *   hooks: { useAuth, useNotifications },
+ *   contexts: { AuthContext, NotificationContext }
+ * });
+ * ```
+ */
+export declare function createDynimSDK(config: DynimSDKConfig): DynimGlobal;
+/**
+ * Gets the current Dynim SDK instance from the window object.
+ * Useful for tenant bundles to access the SDK.
+ *
+ * @returns The SDK instance or undefined if not initialized
+ */
+export declare function getDynimSDK(): DynimGlobal | undefined;
+/**
+ * Checks if the Dynim SDK has been initialized.
+ *
+ * @returns true if the SDK is available
+ */
+export declare function isDynimSDKReady(): boolean;
+//# sourceMappingURL=createDynimSDK.d.ts.map

package/dist/inference/createDynimSDK.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createDynimSDK.d.ts","sourceRoot":"","sources":["../../src/inference/createDynimSDK.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,cAAc,GAAG,WAAW,CAqBlE;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,IAAI,WAAW,GAAG,SAAS,CAKrD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,IAAI,OAAO,CAEzC"}

package/dist/inference/createDynimSDK.js

@@ -0,0 +1,61 @@
+/**
+ * Creates and registers the Dynim SDK on the window object.
+ * This makes React, ReactDOM, hooks, and contexts available to tenant bundles.
+ *
+ * @param config - Configuration object containing React, ReactDOM, hooks, and contexts
+ * @returns The created SDK object
+ *
+ * @example
+ * ```tsx
+ * import { createDynimSDK } from 'dynim-react';
+ * import React from 'react';
+ * import ReactDOM from 'react-dom';
+ * import { useAuth, useNotifications } from './hooks';
+ * import { AuthContext, NotificationContext } from './contexts';
+ *
+ * createDynimSDK({
+ *   React,
+ *   ReactDOM,
+ *   hooks: { useAuth, useNotifications },
+ *   contexts: { AuthContext, NotificationContext }
+ * });
+ * ```
+ */
+export function createDynimSDK(config) {
+    const { React, ReactDOM, hooks = {}, contexts = {}, globals = {} } = config;
+    const sdk = {
+        React,
+        ReactDOM,
+        hooks,
+        contexts,
+        ...globals,
+    };
+    // Register on window for tenant bundles to access
+    if (typeof window !== 'undefined') {
+        window.__DYNIM__ = sdk;
+        // Also expose React and ReactDOM directly on window for bundles using standard imports
+        window.React = React;
+        window.ReactDOM = ReactDOM;
+    }
+    return sdk;
+}
+/**
+ * Gets the current Dynim SDK instance from the window object.
+ * Useful for tenant bundles to access the SDK.
+ *
+ * @returns The SDK instance or undefined if not initialized
+ */
+export function getDynimSDK() {
+    if (typeof window !== 'undefined') {
+        return window.__DYNIM__;
+    }
+    return undefined;
+}
+/**
+ * Checks if the Dynim SDK has been initialized.
+ *
+ * @returns true if the SDK is available
+ */
+export function isDynimSDKReady() {
+    return typeof window !== 'undefined' && window.__DYNIM__ !== undefined;
+}