@final-commerce/command-frame 0.1.16 → 0.1.17

package/dist/client.js

@@ -2,7 +2,6 @@
  * Command Frame Client for iframe communication
  * Allows the iframe to call functions on the parent window via postMessage
  */
-import { MOCK_REGISTRY } from "./demo/registry";
 export class CommandFrameClient {
     constructor(options = {}) {
         this.pendingRequests = new Map();
@@ -12,11 +11,20 @@ export class CommandFrameClient {
         this.useGlobalDebug = options.debug === undefined;
         // Default to provided mockMode or false. Detection happens via getFinalContext.
         this.mockMode = options.mockMode ?? false;
+        this.mockRegistry = options.mockRegistry || {};
+        // If running standalone (no parent window), force Mock Mode immediately
+        // This prevents the 2s delay and ensures immediate response in dev/standalone mode
+        if (typeof window !== 'undefined' && (!window.parent || window.parent === window)) {
+            if (this.isDebugEnabled()) {
+                console.log("[ActionsClient] Standalone mode detected. Enabling Mock Mode immediately.");
+            }
+            this.mockMode = true;
+        }
         if (typeof window !== 'undefined') {
             window.addEventListener("message", this.handleMessage.bind(this));
         }
         // Auto-detect mock mode on initialization
-        this.getFinalContext().then((context) => {
+        this.detectContext().then((context) => {
             if (!context) {
                 if (this.isDebugEnabled()) {
                     console.warn("[ActionsClient] Environment detection failed (timeout or error). Switching to Mock Mode.");
@@ -31,6 +39,18 @@ export class CommandFrameClient {
                 mockMode: this.mockMode
             });
         }
+        // Return a Proxy to enable dynamic method calls
+        // This allows client.getProducts() to map to client.call('getProducts')
+        return new Proxy(this, {
+            get: (target, prop) => {
+                // If the property exists on the instance, return it
+                if (prop in target) {
+                    return target[prop];
+                }
+                // Otherwise, assume it's an action name and return a wrapper function
+                return (params) => target.call(prop, params);
+            }
+        });
     }
     isDebugEnabled() {
         if (!this.useGlobalDebug) {
@@ -44,7 +64,7 @@ export class CommandFrameClient {
             if (this.isDebugEnabled()) {
                 console.log("[ActionsClient] Mock Call", { action, params });
             }
-            const mockHandler = MOCK_REGISTRY[action];
+            const mockHandler = this.mockRegistry[action];
             if (mockHandler) {
                 // Simulate async delay
                 await new Promise(resolve => setTimeout(resolve, 100));
@@ -111,7 +131,7 @@ export class CommandFrameClient {
         });
     }
     // Private check to determine environment
-    getFinalContext() {
+    detectContext() {
         return new Promise((resolve) => {
             if (typeof window === 'undefined' || !window.parent || window.parent === window)
                 return resolve(null);

package/dist/demo/database.d.ts

@@ -49,4 +49,8 @@ export declare const MOCK_OUTLET: CFActiveOutlet;
 export declare let MOCK_CART: CFActiveCart;
 export declare const resetMockCart: () => void;
 export declare const safeSerialize: <T>(data: T) => T;
+type MockEventCallback = (event: any) => void;
+export declare const mockPublishEvent: (topic: string, eventType: string, data: any) => void;
+export declare const mockSubscribeToTopic: (topic: string, callback: MockEventCallback) => void;
 export declare const createOrderFromCart: (paymentType: string, amount: number | string, processor?: string) => CFActiveOrder;
+export {};

package/dist/demo/database.js

@@ -467,6 +467,30 @@ export const resetMockCart = () => {
 export const safeSerialize = (data) => {
     return JSON.parse(JSON.stringify(data));
 };
+const mockTopicSubscribers = {};
+export const mockPublishEvent = (topic, eventType, data) => {
+    const subscribers = mockTopicSubscribers[topic] || [];
+    const event = {
+        topic,
+        type: eventType,
+        data,
+        timestamp: new Date().toISOString()
+    };
+    subscribers.forEach(callback => {
+        try {
+            callback(event);
+        }
+        catch (error) {
+            console.error(`[Mock] Error in topic callback for ${topic}:`, error);
+        }
+    });
+};
+export const mockSubscribeToTopic = (topic, callback) => {
+    if (!mockTopicSubscribers[topic]) {
+        mockTopicSubscribers[topic] = [];
+    }
+    mockTopicSubscribers[topic].push(callback);
+};
 // Helper to create order from cart
 export const createOrderFromCart = (paymentType, amount, processor = "cash") => {
     // Generate new Order ID
@@ -545,5 +569,7 @@ export const createOrderFromCart = (paymentType, amount, processor = "cash") =>
     };
     MOCK_ORDERS.push(newOrder);
     resetMockCart();
+    // Publish cart-created event after cart is reset (simulates new empty cart)
+    mockPublishEvent('cart', 'cart-created', {});
     return newOrder;
 };

package/dist/index.d.ts

@@ -93,6 +93,10 @@ export type { SwitchUser, SwitchUserParams, SwitchUserResponse } from "./actions
 export type { TriggerWebhook, TriggerWebhookPresetType, TriggerWebhookParams, TriggerWebhookResponse } from "./actions/trigger-webhook/types";
 export type { TriggerZapierWebhook, TriggerZapierWebhookParams, TriggerZapierWebhookResponse } from "./actions/trigger-zapier-webhook/types";
 export * from "./CommonTypes";
+export { CommandFrameProvider } from "./provider";
+export type { ActionHandler, ActionHandlers } from "./provider";
+export * from "./projects/render";
+export * from "./projects/manage";
 export { commandFrameClient, CommandFrameClient } from "./client";
 export type { PostMessageRequest, PostMessageResponse } from "./client";
 export { topics } from "./pubsub/topic";

package/dist/index.js

@@ -107,6 +107,12 @@ export const command = {
 };
 // Export Common Types
 export * from "./CommonTypes";
+// Export Provider
+export { CommandFrameProvider } from "./provider";
+// Export Render Project
+export * from "./projects/render";
+// Export Manage Project
+export * from "./projects/manage";
 // Export client
 export { commandFrameClient, CommandFrameClient } from "./client";
 // Export Pub/Sub

package/dist/projects/manage/client.d.ts

@@ -0,0 +1,13 @@
+import { CommandFrameClient } from "../../client";
+import { ManageProviderActions } from "./types";
+export interface ManageClient extends ManageProviderActions {
+}
+export declare class ManageClient extends CommandFrameClient {
+    constructor(options?: {
+        timeout?: number;
+        origin?: string;
+        debug?: boolean;
+        mockMode?: boolean;
+    });
+}
+export declare const manageClient: ManageClient;

package/dist/projects/manage/client.js

@@ -0,0 +1,13 @@
+import { CommandFrameClient } from "../../client";
+import { MANAGE_MOCKS } from "./mocks";
+export class ManageClient extends CommandFrameClient {
+    constructor(options = {}) {
+        super({
+            ...options,
+            mockRegistry: MANAGE_MOCKS
+        });
+    }
+}
+export const manageClient = new ManageClient({
+    debug: typeof window !== "undefined" && window.__POSTMESSAGE_DEBUG__ === true
+});

package/dist/projects/manage/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./mocks";
+export * from "./provider";
+export * from "./client";

package/dist/projects/manage/index.js

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./mocks";
+export * from "./provider";
+export * from "./client";

package/dist/projects/manage/mocks.d.ts

@@ -0,0 +1,2 @@
+import { ManageProviderActions } from "./types";
+export declare const MANAGE_MOCKS: ManageProviderActions;

package/dist/projects/manage/mocks.js

@@ -0,0 +1,6 @@
+import { mockGetContext } from "../../actions/get-context/mock";
+import { mockGetFinalContext } from "../../actions/get-final-context/mock";
+export const MANAGE_MOCKS = {
+    getContext: mockGetContext,
+    getFinalContext: mockGetFinalContext
+};

package/dist/projects/manage/provider.d.ts

@@ -0,0 +1,8 @@
+import { CommandFrameProvider } from "../../provider";
+import { ManageProviderActions } from "./types";
+export declare class ManageCommandFrameProvider extends CommandFrameProvider<ManageProviderActions> {
+    constructor(actions: ManageProviderActions, options?: {
+        origin?: string;
+        debug?: boolean;
+    });
+}

package/dist/projects/manage/provider.js

@@ -0,0 +1,6 @@
+import { CommandFrameProvider } from "../../provider";
+export class ManageCommandFrameProvider extends CommandFrameProvider {
+    constructor(actions, options) {
+        super(actions, options);
+    }
+}

package/dist/projects/manage/types.d.ts

@@ -0,0 +1,5 @@
+import type { GetContext, GetFinalContext } from "../../index";
+export interface ManageProviderActions {
+    getContext: GetContext;
+    getFinalContext: GetFinalContext;
+}

package/dist/projects/manage/types.js

@@ -0,0 +1 @@
+export {};

package/dist/projects/render/client.d.ts

@@ -0,0 +1,13 @@
+import { CommandFrameClient } from "../../client";
+import { RenderProviderActions } from "./types";
+export interface RenderClient extends RenderProviderActions {
+}
+export declare class RenderClient extends CommandFrameClient {
+    constructor(options?: {
+        timeout?: number;
+        origin?: string;
+        debug?: boolean;
+        mockMode?: boolean;
+    });
+}
+export declare const renderClient: RenderClient;

package/dist/projects/render/client.js

@@ -0,0 +1,13 @@
+import { CommandFrameClient } from "../../client";
+import { RENDER_MOCKS } from "./mocks";
+export class RenderClient extends CommandFrameClient {
+    constructor(options = {}) {
+        super({
+            ...options,
+            mockRegistry: RENDER_MOCKS
+        });
+    }
+}
+export const renderClient = new RenderClient({
+    debug: typeof window !== "undefined" && window.__POSTMESSAGE_DEBUG__ === true
+});

package/dist/projects/render/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./mocks";
+export * from "./provider";
+export * from "./client";

package/dist/projects/render/index.js

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./mocks";
+export * from "./provider";
+export * from "./client";

package/dist/projects/render/mocks.d.ts

@@ -0,0 +1,2 @@
+import { RenderProviderActions } from "./types";
+export declare const RENDER_MOCKS: RenderProviderActions;

package/dist/projects/render/mocks.js

@@ -0,0 +1,94 @@
+import { mockAddCartDiscount } from "../../actions/add-cart-discount/mock";
+import { mockAddCartFee } from "../../actions/add-cart-fee/mock";
+import { mockAddCustomSale } from "../../actions/add-custom-sale/mock";
+import { mockAddCustomer } from "../../actions/add-customer/mock";
+import { mockAddCustomerNote } from "../../actions/add-customer-note/mock";
+import { mockAddOrderNote } from "../../actions/add-order-note/mock";
+import { mockAddProductDiscount } from "../../actions/add-product-discount/mock";
+import { mockAddProductFee } from "../../actions/add-product-fee/mock";
+import { mockAddProductNote } from "../../actions/add-product-note/mock";
+import { mockAddProductToCart } from "../../actions/add-product-to-cart/mock";
+import { mockAdjustInventory } from "../../actions/adjust-inventory/mock";
+import { mockAssignCustomer } from "../../actions/assign-customer/mock";
+import { mockAuthenticateUser } from "../../actions/authenticate-user/mock";
+import { mockCalculateRefundTotal } from "../../actions/calculate-refund-total/mock";
+import { mockCashPayment } from "../../actions/cash-payment/mock";
+import { mockClearCart } from "../../actions/clear-cart/mock";
+import { mockDeleteParkedOrder } from "../../actions/delete-parked-order/mock";
+import { mockExampleFunction } from "../../actions/example-function/mock";
+import { mockGetCategories } from "../../actions/get-categories/mock";
+import { mockGetContext } from "../../actions/get-context/mock";
+import { mockGetCurrentCart } from "../../actions/get-current-cart/mock";
+import { mockGetCustomers } from "../../actions/get-customers/mock";
+import { mockGetOrders } from "../../actions/get-orders/mock";
+import { mockGetProducts } from "../../actions/get-products/mock";
+import { mockGetRefunds } from "../../actions/get-refunds/mock";
+import { mockGetRemainingRefundableQuantities } from "../../actions/get-remaining-refundable-quantities/mock";
+import { mockGoToStationHome } from "../../actions/go-to-station-home/mock";
+import { mockInitiateRefund } from "../../actions/initiate-refund/mock";
+import { mockOpenCashDrawer } from "../../actions/open-cash-drawer/mock";
+import { mockParkOrder } from "../../actions/park-order/mock";
+import { mockPartialPayment } from "../../actions/partial-payment/mock";
+import { mockProcessPartialRefund } from "../../actions/process-partial-refund/mock";
+import { mockRemoveCustomerFromCart } from "../../actions/remove-customer-from-cart/mock";
+import { mockResetRefundDetails } from "../../actions/reset-refund-details/mock";
+import { mockResumeParkedOrder } from "../../actions/resume-parked-order/mock";
+import { mockSelectAllRefundItems } from "../../actions/select-all-refund-items/mock";
+import { mockSetRefundStockAction } from "../../actions/set-refund-stock-action/mock";
+import { mockShowConfirmation } from "../../actions/show-confirmation/mock";
+import { mockShowNotification } from "../../actions/show-notification/mock";
+import { mockSwitchUser } from "../../actions/switch-user/mock";
+import { mockTapToPayPayment } from "../../actions/tap-to-pay-payment/mock";
+import { mockTerminalPayment } from "../../actions/terminal-payment/mock";
+import { mockTriggerWebhook } from "../../actions/trigger-webhook/mock";
+import { mockTriggerZapierWebhook } from "../../actions/trigger-zapier-webhook/mock";
+import { mockVendaraPayment } from "../../actions/vendara-payment/mock";
+import { mockGetFinalContext } from "../../actions/get-final-context/mock";
+export const RENDER_MOCKS = {
+    addCartDiscount: mockAddCartDiscount,
+    addCartFee: mockAddCartFee,
+    addCustomSale: mockAddCustomSale,
+    addCustomer: mockAddCustomer,
+    addCustomerNote: mockAddCustomerNote,
+    addOrderNote: mockAddOrderNote,
+    addProductDiscount: mockAddProductDiscount,
+    addProductFee: mockAddProductFee,
+    addProductNote: mockAddProductNote,
+    addProductToCart: mockAddProductToCart,
+    adjustInventory: mockAdjustInventory,
+    assignCustomer: mockAssignCustomer,
+    authenticateUser: mockAuthenticateUser,
+    calculateRefundTotal: mockCalculateRefundTotal,
+    cashPayment: mockCashPayment,
+    clearCart: mockClearCart,
+    deleteParkedOrder: mockDeleteParkedOrder,
+    exampleFunction: mockExampleFunction,
+    getCategories: mockGetCategories,
+    getContext: mockGetContext,
+    getCurrentCart: mockGetCurrentCart,
+    getCustomers: mockGetCustomers,
+    getOrders: mockGetOrders,
+    getProducts: mockGetProducts,
+    getRefunds: mockGetRefunds,
+    getRemainingRefundableQuantities: mockGetRemainingRefundableQuantities,
+    goToStationHome: mockGoToStationHome,
+    initiateRefund: mockInitiateRefund,
+    openCashDrawer: mockOpenCashDrawer,
+    parkOrder: mockParkOrder,
+    partialPayment: mockPartialPayment,
+    processPartialRefund: mockProcessPartialRefund,
+    removeCustomerFromCart: mockRemoveCustomerFromCart,
+    resetRefundDetails: mockResetRefundDetails,
+    resumeParkedOrder: mockResumeParkedOrder,
+    selectAllRefundItems: mockSelectAllRefundItems,
+    setRefundStockAction: mockSetRefundStockAction,
+    showConfirmation: mockShowConfirmation,
+    showNotification: mockShowNotification,
+    switchUser: mockSwitchUser,
+    tapToPayPayment: mockTapToPayPayment,
+    terminalPayment: mockTerminalPayment,
+    triggerWebhook: mockTriggerWebhook,
+    triggerZapierWebhook: mockTriggerZapierWebhook,
+    vendaraPayment: mockVendaraPayment,
+    getFinalContext: mockGetFinalContext,
+};

package/dist/projects/render/provider.d.ts

@@ -0,0 +1,8 @@
+import { CommandFrameProvider } from "../../provider";
+import { RenderProviderActions } from "./types";
+export declare class RenderCommandFrameProvider extends CommandFrameProvider<RenderProviderActions> {
+    constructor(actions: RenderProviderActions, options?: {
+        origin?: string;
+        debug?: boolean;
+    });
+}

package/dist/projects/render/provider.js

@@ -0,0 +1,6 @@
+import { CommandFrameProvider } from "../../provider";
+export class RenderCommandFrameProvider extends CommandFrameProvider {
+    constructor(actions, options) {
+        super(actions, options);
+    }
+}

package/dist/projects/render/types.d.ts

@@ -0,0 +1,49 @@
+import type { ExampleFunction, GetProducts, AddCustomSale, GetCustomers, AssignCustomer, AddCustomer, GetCategories, GetOrders, GetRefunds, AddProductDiscount, AddProductToCart, AddCartDiscount, GetContext, GetFinalContext, AddProductNote, AddProductFee, AdjustInventory, AddOrderNote, AddCartFee, ClearCart, ParkOrder, ResumeParkedOrder, DeleteParkedOrder, InitiateRefund, CashPayment, TapToPayPayment, TerminalPayment, VendaraPayment, AddCustomerNote, RemoveCustomerFromCart, GoToStationHome, OpenCashDrawer, ShowNotification, ShowConfirmation, AuthenticateUser, PartialPayment, SwitchUser, TriggerWebhook, TriggerZapierWebhook, SetRefundStockAction, SelectAllRefundItems, ResetRefundDetails, CalculateRefundTotal, GetRemainingRefundableQuantities, ProcessPartialRefund, GetCurrentCart } from "../../index";
+export interface RenderProviderActions {
+    exampleFunction: ExampleFunction;
+    getProducts: GetProducts;
+    addCustomSale: AddCustomSale;
+    getCustomers: GetCustomers;
+    assignCustomer: AssignCustomer;
+    addCustomer: AddCustomer;
+    getCategories: GetCategories;
+    getOrders: GetOrders;
+    getRefunds: GetRefunds;
+    addProductDiscount: AddProductDiscount;
+    addProductToCart: AddProductToCart;
+    addCartDiscount: AddCartDiscount;
+    getContext: GetContext;
+    getFinalContext: GetFinalContext;
+    addProductNote: AddProductNote;
+    addProductFee: AddProductFee;
+    adjustInventory: AdjustInventory;
+    addOrderNote: AddOrderNote;
+    addCartFee: AddCartFee;
+    clearCart: ClearCart;
+    parkOrder: ParkOrder;
+    resumeParkedOrder: ResumeParkedOrder;
+    deleteParkedOrder: DeleteParkedOrder;
+    initiateRefund: InitiateRefund;
+    cashPayment: CashPayment;
+    tapToPayPayment: TapToPayPayment;
+    terminalPayment: TerminalPayment;
+    vendaraPayment: VendaraPayment;
+    addCustomerNote: AddCustomerNote;
+    removeCustomerFromCart: RemoveCustomerFromCart;
+    goToStationHome: GoToStationHome;
+    openCashDrawer: OpenCashDrawer;
+    showNotification: ShowNotification;
+    showConfirmation: ShowConfirmation;
+    authenticateUser: AuthenticateUser;
+    partialPayment: PartialPayment;
+    switchUser: SwitchUser;
+    triggerWebhook: TriggerWebhook;
+    triggerZapierWebhook: TriggerZapierWebhook;
+    setRefundStockAction: SetRefundStockAction;
+    selectAllRefundItems: SelectAllRefundItems;
+    resetRefundDetails: ResetRefundDetails;
+    calculateRefundTotal: CalculateRefundTotal;
+    getRemainingRefundableQuantities: GetRemainingRefundableQuantities;
+    processPartialRefund: ProcessPartialRefund;
+    getCurrentCart: GetCurrentCart;
+}

package/dist/projects/render/types.js

@@ -0,0 +1 @@
+export {};

package/dist/provider.d.ts

@@ -0,0 +1,19 @@
+export type ActionHandler<TParams = any, TResponse = any> = (params: TParams) => Promise<TResponse> | TResponse;
+export type ActionHandlers = Map<string, ActionHandler>;
+export declare class CommandFrameProvider<TActions extends object = any> {
+    private handlers;
+    private origin;
+    private debug;
+    private destroyed;
+    private boundHandleMessage;
+    constructor(actions?: TActions, options?: {
+        origin?: string;
+        debug?: boolean;
+    });
+    register<TParams = any, TResponse = any>(action: string, handler: ActionHandler<TParams, TResponse>): void;
+    unregister(action: string): void;
+    private handleMessage;
+    private sendResponse;
+    destroy(): void;
+    isDestroyed(): boolean;
+}

package/dist/provider.js

@@ -0,0 +1,178 @@
+export class CommandFrameProvider {
+    constructor(actions, options = {}) {
+        this.handlers = new Map();
+        this.destroyed = false;
+        this.origin = options.origin || "*";
+        this.debug = options.debug || false;
+        this.boundHandleMessage = this.handleMessage.bind(this);
+        if (typeof window !== "undefined") {
+            window.addEventListener("message", this.boundHandleMessage);
+        }
+        if (actions) {
+            Object.keys(actions).forEach((actionName) => {
+                const handler = actions[actionName];
+                if (typeof handler === "function") {
+                    this.register(actionName, handler);
+                }
+            });
+        }
+        if (this.debug) {
+            console.log("[CommandFrameProvider] Initialized", {
+                origin: this.origin,
+                debug: this.debug
+            });
+        }
+    }
+    register(action, handler) {
+        if (this.destroyed) {
+            if (this.debug) {
+                console.warn("[CommandFrameProvider] Cannot register action after destruction", { action });
+            }
+            return;
+        }
+        this.handlers.set(action, handler);
+        if (this.debug) {
+            console.log("[CommandFrameProvider] Registered action", { action });
+        }
+    }
+    unregister(action) {
+        if (this.destroyed) {
+            if (this.debug) {
+                console.warn("[CommandFrameProvider] Cannot unregister action after destruction", { action });
+            }
+            return;
+        }
+        this.handlers.delete(action);
+        if (this.debug) {
+            console.log("[CommandFrameProvider] Unregistered action", { action });
+        }
+    }
+    async handleMessage(event) {
+        // Ignore messages after destruction
+        if (this.destroyed) {
+            return;
+        }
+        const request = event.data;
+        if (!request || typeof request !== "object" || !("action" in request)) {
+            return;
+        }
+        if (this.origin !== "*" && event.origin !== this.origin) {
+            if (this.debug) {
+                console.warn("[CommandFrameProvider] Origin mismatch", {
+                    expected: this.origin,
+                    received: event.origin
+                });
+            }
+            return;
+        }
+        if (!request.action || !request.requestId) {
+            if (this.debug) {
+                console.warn("[CommandFrameProvider] Invalid request format", {
+                    data: event.data,
+                    origin: event.origin
+                });
+            }
+            return;
+        }
+        if (this.debug) {
+            console.log("[CommandFrameProvider] Received request", {
+                origin: event.origin,
+                action: request.action,
+                requestId: request.requestId,
+                timestamp: new Date().toISOString()
+            });
+        }
+        const handler = this.handlers.get(request.action);
+        if (!handler) {
+            if (this.debug) {
+                console.warn("[CommandFrameProvider] Unknown action", { action: request.action });
+            }
+            // Only send response if source window is still available
+            if (event.source && event.source !== window) {
+                this.sendResponse(event.source, request.requestId, {
+                    success: false,
+                    error: `Unknown action: ${request.action}`
+                });
+            }
+            return;
+        }
+        try {
+            const result = await handler(request.params);
+            // Only send response if source window is still available
+            if (event.source && event.source !== window) {
+                this.sendResponse(event.source, request.requestId, {
+                    success: true,
+                    data: result
+                });
+                if (this.debug) {
+                    console.log("[CommandFrameProvider] Action executed", {
+                        action: request.action,
+                        requestId: request.requestId
+                    });
+                }
+            }
+            else if (this.debug) {
+                console.warn("[CommandFrameProvider] Cannot send response - source window unavailable", {
+                    action: request.action,
+                    requestId: request.requestId
+                });
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+            // Only send response if source window is still available
+            if (event.source && event.source !== window) {
+                this.sendResponse(event.source, request.requestId, {
+                    success: false,
+                    error: errorMessage
+                });
+                if (this.debug) {
+                    console.error("[CommandFrameProvider] Action failed", {
+                        action: request.action,
+                        requestId: request.requestId,
+                        error: errorMessage
+                    });
+                }
+            }
+            else if (this.debug) {
+                console.warn("[CommandFrameProvider] Cannot send error response - source window unavailable", {
+                    action: request.action,
+                    requestId: request.requestId,
+                    error: errorMessage
+                });
+            }
+        }
+    }
+    sendResponse(target, requestId, response) {
+        const message = {
+            requestId,
+            ...response
+        };
+        if (this.debug) {
+            console.log("[CommandFrameProvider] Sending response", {
+                requestId,
+                success: response.success
+            });
+        }
+        target.postMessage(message, this.origin);
+    }
+    destroy() {
+        if (this.destroyed) {
+            if (this.debug) {
+                console.warn("[CommandFrameProvider] Already destroyed");
+            }
+            return;
+        }
+        this.destroyed = true;
+        this.handlers.clear();
+        if (typeof window !== "undefined") {
+            window.removeEventListener("message", this.boundHandleMessage);
+        }
+        if (this.debug) {
+            console.log("[CommandFrameProvider] Destroyed");
+        }
+    }
+    isDestroyed() {
+        return this.destroyed;
+    }
+}

package/dist/pubsub/subscriber.d.ts

@@ -11,10 +11,14 @@ export declare class TopicSubscriber {
     private useGlobalDebug;
     private boundHandleMessage;
     private subscriptionIdCounter;
+    private mockMode;
+    private detectionTimeout;
     constructor(options?: {
         origin?: string;
         debug?: boolean;
     });
+    private initDetection;
+    private switchToMockMode;
     private isDebugEnabled;
     /**
      * Request the list of available topics from the host