@ironflow/browser 0.19.3 → 0.20.2

package/dist/client.js

@@ -1,2220 +0,0 @@
-/**
- * Ironflow Browser Client
- *
- * Singleton client for browser-based real-time interactions with Ironflow.
- */
-import { NotConfiguredError, IronflowError, RunFailedError, RunCancelledError, UnauthenticatedError, EnterpriseRequiredError, UnauthorizedError, ValidationError, createLogger, createNoopLogger, DEFAULT_TIMEOUTS, HEADERS, TriggerResponseSchema, TriggerSyncResponseSchema, RunResponseSchema, ListRunsResponseSchema, RunStatusSchema, ErrorResponseSchema, safeJsonParse, patterns, } from "@ironflow/core";
-import { mergeConfig } from "./config.js";
-import { SubscriptionManager, } from "./subscription.js";
-import { createWebSocketTransport } from "./transport/websocket.js";
-import { createConnectRPCTransport } from "./transport/connectrpc.js";
-import { filterWaitStreamFrames } from "./projection-stream.js";
-import { BrowserKVClient } from "./kv.js";
-import { BrowserConfigClient } from "./config-client.js";
-/**
- * Ironflow browser client singleton
- */
-class IronflowClient {
-    config = null;
-    logger = createNoopLogger();
-    transport = null;
-    subscriptionManager = null;
-    visibilityHandler = null;
-    /**
-     * Configure the client
-     *
-     * Must be called before any other operations.
-     */
-    configure(options = {}) {
-        this.config = mergeConfig(options);
-        // Set up logger
-        if (this.config.logger === false) {
-            this.logger = createNoopLogger();
-        }
-        else if (this.config.logger) {
-            this.logger = this.config.logger;
-        }
-        else {
-            this.logger = createLogger({ prefix: "[ironflow]" });
-        }
-        // Clean up existing resources
-        this.cleanup();
-        // Create transport
-        const transportOptions = {
-            auth: this.config.auth,
-            autoReconnect: this.config.reconnect.enabled,
-            reconnectDelay: this.config.reconnect.backoff.initial,
-            maxReconnectDelay: this.config.reconnect.backoff.max,
-            reconnectBackoff: this.config.reconnect.backoff.multiplier,
-            environment: this.config.environment,
-        };
-        // Create transport based on config (ConnectRPC by default)
-        if (this.config.transport === "websocket") {
-            this.transport = createWebSocketTransport(this.config.serverUrl, transportOptions);
-        }
-        else {
-            // Default to ConnectRPC
-            this.transport = createConnectRPCTransport(this.config.serverUrl, transportOptions);
-        }
-        // Create subscription manager
-        this.subscriptionManager = new SubscriptionManager(this.transport, this.config.logger);
-        // Set up visibility handling
-        if (this.config.visibility.pauseOnHidden && typeof document !== "undefined") {
-            this.setupVisibilityHandling();
-        }
-        this.logger.info("Ironflow client configured", {
-            serverUrl: this.config.serverUrl,
-            transport: this.config.transport,
-        });
-    }
-    /**
-     * Check if the client is configured
-     */
-    get isConfigured() {
-        return this.config !== null;
-    }
-    /**
-     * Detect which transport the server supports
-     *
-     * Returns the best available transport based on server capabilities.
-     * ConnectRPC is preferred over WebSocket.
-     *
-     * @example
-     * ```typescript
-     * const transport = await ironflow.detectTransport();
-     * // Returns 'connectrpc' | 'websocket'
-     * ```
-     */
-    async detectTransport() {
-        const serverUrl = this.config?.serverUrl ?? "http://localhost:9123";
-        try {
-            // Try to get server capabilities via ConnectRPC endpoint
-            const detectHeaders = {
-                "Content-Type": "application/json",
-            };
-            if (this.config?.environment) {
-                detectHeaders[HEADERS.ENVIRONMENT] = this.config.environment;
-            }
-            const response = await fetch(`${serverUrl}/ironflow.v1.IronflowService/GetCapabilities`, {
-                method: "POST",
-                headers: detectHeaders,
-                body: "{}",
-            });
-            if (response.ok) {
-                const data = await response.json();
-                const transports = data.transports;
-                // Check if server explicitly supports connectrpc
-                if (transports?.includes("connectrpc") || transports?.includes("grpc")) {
-                    return "connectrpc";
-                }
-                // Server responded, so ConnectRPC endpoint works
-                return "connectrpc";
-            }
-        }
-        catch {
-            // ConnectRPC not available
-        }
-        // Fall back to WebSocket
-        return "websocket";
-    }
-    /**
-     * Get the current configuration
-     */
-    getConfig() {
-        if (!this.config) {
-            throw new NotConfiguredError();
-        }
-        return this.config;
-    }
-    // ============================================================================
-    // Connection Management
-    // ============================================================================
-    /**
-     * Connect to the Ironflow server
-     */
-    async connect() {
-        this.ensureConfigured();
-        await this.subscriptionManager.connect();
-    }
-    /**
-     * Disconnect from the Ironflow server
-     */
-    disconnect() {
-        if (this.subscriptionManager) {
-            this.subscriptionManager.disconnect();
-        }
-    }
-    /**
-     * Register a callback for connection state changes
-     */
-    onConnectionChange(callback) {
-        this.ensureConfigured();
-        return this.subscriptionManager.onConnectionChange(callback);
-    }
-    /**
-     * Get current connection state
-     */
-    get connectionState() {
-        if (!this.subscriptionManager) {
-            return "disconnected";
-        }
-        return this.subscriptionManager.connectionState;
-    }
-    // ============================================================================
-    // Subscriptions
-    // ============================================================================
-    /**
-     * Subscribe to events matching a pattern
-     *
-     * @example
-     * ```typescript
-     * // Basic subscription
-     * const sub = await ironflow.subscribe('events:order.*', {
-     *   onEvent: (event) => console.log(event),
-     * });
-     *
-     * // Multiple patterns
-     * const sub = await ironflow.subscribe(['system.run.*', 'events:order.*'], {
-     *   onEvent: (event) => { ... }
-     * });
-     *
-     * // With options
-     * const sub = await ironflow.subscribe('events:*', {
-     *   onEvent: (e) => { ... },
-     *   replay: 10,
-     *   trackState: true,
-     *   ackMode: 'manual',
-     * });
-     * ```
-     */
-    subscribe(pattern, callbacksAndOptions) {
-        this.ensureConfigured();
-        return this.subscriptionManager.subscribe(pattern, callbacksAndOptions);
-    }
-    /**
-     * Create a subscription group for batch management
-     *
-     * @example
-     * ```typescript
-     * const group = ironflow.subscriptionGroup();
-     * await group.add('system.run.*', { onEvent: handleRun });
-     * await group.add('events:payment.*', { onEvent: handlePayment });
-     * // Later:
-     * group.unsubscribeAll();
-     * ```
-     */
-    subscriptionGroup() {
-        this.ensureConfigured();
-        return this.subscriptionManager.createGroup();
-    }
-    /**
-     * Register a global error handler
-     */
-    onError(callback) {
-        this.ensureConfigured();
-        return this.subscriptionManager.onError(callback);
-    }
-    // ============================================================================
-    // Workflow Operations
-    // ============================================================================
-    /**
-     * Invoke a workflow function by ID
-     *
-     * @example
-     * ```typescript
-     * const run = await ironflow.invoke<OrderInput, OrderOutput>('process-order', {
-     *   data: { orderId: '123' }
-     * });
-     * ```
-     */
-    async invoke(functionId, options) {
-        this.ensureConfigured();
-        const response = await this.request(TriggerResponseSchema, "POST", "/ironflow.v1.IronflowService/Trigger", {
-            event: functionId,
-            data: options.data,
-        });
-        return {
-            runIds: response.runIds ?? [],
-            eventId: response.eventId,
-        };
-    }
-    /**
-     * Get run status
-     */
-    async getRun(runId) {
-        this.ensureConfigured();
-        const response = await this.request(RunResponseSchema, "POST", "/ironflow.v1.IronflowService/GetRun", { id: runId });
-        return this.mapRunResponse(response);
-    }
-    /**
-     * List runs with filtering
-     */
-    async listRuns(options) {
-        this.ensureConfigured();
-        const response = await this.request(ListRunsResponseSchema, "POST", "/ironflow.v1.IronflowService/ListRuns", {
-            function_id: options?.functionId,
-            status: options?.status?.toUpperCase(),
-            limit: options?.limit,
-            cursor: options?.cursor,
-        });
-        return {
-            runs: (response.runs ?? []).map((r) => this.mapRunResponse(r)),
-            nextCursor: response.nextCursor,
-            totalCount: response.totalCount ?? 0,
-        };
-    }
-    /**
-     * Cancel a running run
-     */
-    async cancelRun(runId, reason) {
-        this.ensureConfigured();
-        const response = await this.request(RunResponseSchema, "POST", "/ironflow.v1.IronflowService/CancelRun", { id: runId, reason });
-        return this.mapRunResponse(response);
-    }
-    /**
-     * Retry a failed run
-     */
-    async retryRun(runId, fromStep) {
-        this.ensureConfigured();
-        const response = await this.request(RunResponseSchema, "POST", "/ironflow.v1.IronflowService/RetryRun", { id: runId, fromStep });
-        return this.mapRunResponse(response);
-    }
-    /**
-     * Patch a step's output (hot patching)
-     */
-    async patchStep(stepId, output, reason) {
-        this.ensureConfigured();
-        const url = `${this.config.serverUrl}/api/v1/steps/patch`;
-        const timeout = this.config.timeout ?? DEFAULT_TIMEOUTS.CLIENT;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        try {
-            const headers = {
-                "Content-Type": "application/json",
-                [HEADERS.ENVIRONMENT]: this.config.environment,
-            };
-            if (this.config.auth?.apiKey) {
-                headers["Authorization"] = `Bearer ${this.config.auth.apiKey}`;
-            }
-            const response = await fetch(url, {
-                method: "POST",
-                headers,
-                body: JSON.stringify({ step_id: stepId, output, reason: reason || "" }),
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                const error = safeJsonParse(await response.text());
-                throw new IronflowError(error?.message || `Patch step failed: ${response.status}`, { code: error?.code || "PATCH_FAILED" });
-            }
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    /**
-     * Resume a paused or failed run
-     */
-    async resumeRun(runId, fromStep) {
-        this.ensureConfigured();
-        const url = `${this.config.serverUrl}/api/v1/runs/resume`;
-        const timeout = this.config.timeout ?? DEFAULT_TIMEOUTS.CLIENT;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        try {
-            const headers = {
-                "Content-Type": "application/json",
-                [HEADERS.ENVIRONMENT]: this.config.environment,
-            };
-            if (this.config.auth?.apiKey) {
-                headers["Authorization"] = `Bearer ${this.config.auth.apiKey}`;
-            }
-            const response = await fetch(url, {
-                method: "POST",
-                headers,
-                body: JSON.stringify({ run_id: runId, from_step: fromStep || "" }),
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                const error = safeJsonParse(await response.text());
-                throw new IronflowError(error?.message || `Resume run failed: ${response.status}`, { code: error?.code || "RESUME_FAILED" });
-            }
-            return response.json();
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    /**
-     * Pause a running workflow at the next step boundary (scoped injection).
-     */
-    async pauseRun(runId) {
-        this.ensureConfigured();
-        const url = `${this.config.serverUrl}/ironflow.v1.IronflowService/PauseRun`;
-        const timeout = this.config.timeout ?? DEFAULT_TIMEOUTS.CLIENT;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        try {
-            const headers = {
-                "Content-Type": "application/json",
-                [HEADERS.ENVIRONMENT]: this.config.environment,
-            };
-            if (this.config.auth?.apiKey) {
-                headers["Authorization"] = `Bearer ${this.config.auth.apiKey}`;
-            }
-            const response = await fetch(url, {
-                method: "POST",
-                headers,
-                body: JSON.stringify({ run_id: runId }),
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                const error = safeJsonParse(await response.text());
-                throw new IronflowError(error?.message || `Pause run failed: ${response.status}`, { code: error?.code || "PAUSE_FAILED" });
-            }
-            return response.json();
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    /**
-     * Get the paused state of a run, including completed steps and next step hint.
-     */
-    async getPausedState(runId) {
-        this.ensureConfigured();
-        const url = `${this.config.serverUrl}/ironflow.v1.IronflowService/GetPausedState`;
-        const timeout = this.config.timeout ?? DEFAULT_TIMEOUTS.CLIENT;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        try {
-            const headers = {
-                "Content-Type": "application/json",
-                [HEADERS.ENVIRONMENT]: this.config.environment,
-            };
-            if (this.config.auth?.apiKey) {
-                headers["Authorization"] = `Bearer ${this.config.auth.apiKey}`;
-            }
-            const response = await fetch(url, {
-                method: "POST",
-                headers,
-                body: JSON.stringify({ run_id: runId }),
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                const error = safeJsonParse(await response.text());
-                throw new IronflowError(error?.message || `Get paused state failed: ${response.status}`, { code: error?.code || "GET_PAUSED_STATE_FAILED" });
-            }
-            const data = (await response.json());
-            return {
-                steps: (data.steps || []).map((s) => ({
-                    id: s.id,
-                    name: s.name,
-                    output: s.output ? JSON.parse(s.output) : null,
-                    injected: s.injected,
-                    completedAt: s.completed_at,
-                })),
-                nextStepHint: data.next_step_hint,
-                pauseReason: data.pause_reason,
-            };
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    /**
-     * Inject new output for a step in a paused run (scoped injection).
-     */
-    async injectStepOutput(runId, stepId, newOutput, reason) {
-        this.ensureConfigured();
-        const url = `${this.config.serverUrl}/ironflow.v1.IronflowService/InjectStepOutput`;
-        const timeout = this.config.timeout ?? DEFAULT_TIMEOUTS.CLIENT;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        try {
-            const headers = {
-                "Content-Type": "application/json",
-                [HEADERS.ENVIRONMENT]: this.config.environment,
-            };
-            if (this.config.auth?.apiKey) {
-                headers["Authorization"] = `Bearer ${this.config.auth.apiKey}`;
-            }
-            const response = await fetch(url, {
-                method: "POST",
-                headers,
-                body: JSON.stringify({
-                    run_id: runId,
-                    step_id: stepId,
-                    new_output: JSON.stringify(newOutput),
-                    reason: reason ?? "",
-                }),
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                const error = safeJsonParse(await response.text());
-                throw new IronflowError(error?.message || `Inject step output failed: ${response.status}`, { code: error?.code || "INJECT_FAILED" });
-            }
-            const data = (await response.json());
-            return {
-                stepId: data.step_id,
-                previousOutput: data.previous_output
-                    ? JSON.parse(data.previous_output)
-                    : null,
-            };
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    // ==========================================================================
-    // Time-Travel Debugging
-    // ==========================================================================
-    /**
-     * Get the reconstructed state of a run at a specific timestamp.
-     */
-    async getRunStateAt(runId, timestamp) {
-        this.ensureConfigured();
-        const url = `${this.config.serverUrl}/ironflow.v1.TimeTravelService/GetRunStateAt`;
-        const timeout = this.config.timeout ?? DEFAULT_TIMEOUTS.CLIENT;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        try {
-            const headers = {
-                "Content-Type": "application/json",
-                [HEADERS.ENVIRONMENT]: this.config.environment,
-            };
-            if (this.config.auth?.apiKey) {
-                headers["Authorization"] = `Bearer ${this.config.auth.apiKey}`;
-            }
-            const response = await fetch(url, {
-                method: "POST",
-                headers,
-                body: JSON.stringify({
-                    runId,
-                    timestamp: timestamp.toISOString(),
-                }),
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                const error = safeJsonParse(await response.text());
-                throw new IronflowError(error?.message || `Get run state failed: ${response.status}`, { code: error?.code || "GET_RUN_STATE_FAILED" });
-            }
-            const data = (await response.json());
-            const s = data.snapshot;
-            return {
-                runId: s.runId,
-                functionId: s.functionId,
-                status: s.status,
-                input: s.input ? JSON.parse(atob(s.input)) : null,
-                steps: (s.steps || []).map((step) => ({
-                    stepId: step.stepId,
-                    name: step.name,
-                    type: step.type,
-                    sequence: step.sequence,
-                    status: step.status,
-                    output: step.output ? JSON.parse(atob(step.output)) : null,
-                    error: step.error ? JSON.parse(atob(step.error)) : null,
-                    originalOutput: step.originalOutput ? JSON.parse(atob(step.originalOutput)) : null,
-                    startedAt: step.startedAt ? new Date(step.startedAt) : null,
-                    completedAt: step.completedAt ? new Date(step.completedAt) : null,
-                    durationMs: step.durationMs ?? null,
-                    injected: step.injected,
-                    patched: step.patched,
-                })),
-                timestamp: new Date(s.timestamp),
-                createdAt: s.createdAt ? new Date(s.createdAt) : null,
-            };
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    /**
-     * Get the timeline of audit events for a run.
-     */
-    async getRunTimeline(runId) {
-        this.ensureConfigured();
-        const url = `${this.config.serverUrl}/ironflow.v1.TimeTravelService/GetRunTimeline`;
-        const timeout = this.config.timeout ?? DEFAULT_TIMEOUTS.CLIENT;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        try {
-            const headers = {
-                "Content-Type": "application/json",
-                [HEADERS.ENVIRONMENT]: this.config.environment,
-            };
-            if (this.config.auth?.apiKey) {
-                headers["Authorization"] = `Bearer ${this.config.auth.apiKey}`;
-            }
-            const response = await fetch(url, {
-                method: "POST",
-                headers,
-                body: JSON.stringify({ runId }),
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                const error = safeJsonParse(await response.text());
-                throw new IronflowError(error?.message || `Get run timeline failed: ${response.status}`, { code: error?.code || "GET_TIMELINE_FAILED" });
-            }
-            const data = (await response.json());
-            return (data.events || []).map((e) => ({
-                id: e.id,
-                eventType: e.eventType,
-                stepId: e.stepId || "",
-                stepName: e.stepName || "",
-                summary: e.summary,
-                significant: e.significant,
-                timestamp: new Date(e.timestamp),
-            }));
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    /**
-     * Get the output of a specific step at a specific timestamp.
-     */
-    async getStepOutputAt(runId, stepId, timestamp) {
-        this.ensureConfigured();
-        const url = `${this.config.serverUrl}/ironflow.v1.TimeTravelService/GetStepOutputAt`;
-        const timeout = this.config.timeout ?? DEFAULT_TIMEOUTS.CLIENT;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        try {
-            const headers = {
-                "Content-Type": "application/json",
-                [HEADERS.ENVIRONMENT]: this.config.environment,
-            };
-            if (this.config.auth?.apiKey) {
-                headers["Authorization"] = `Bearer ${this.config.auth.apiKey}`;
-            }
-            const response = await fetch(url, {
-                method: "POST",
-                headers,
-                body: JSON.stringify({
-                    runId,
-                    stepId,
-                    timestamp: timestamp.toISOString(),
-                }),
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                const error = safeJsonParse(await response.text());
-                throw new IronflowError(error?.message || `Get step output failed: ${response.status}`, { code: error?.code || "GET_STEP_OUTPUT_FAILED" });
-            }
-            const data = (await response.json());
-            return {
-                stepId: data.stepId,
-                status: data.status,
-                output: data.output ? JSON.parse(atob(data.output)) : null,
-                originalOutput: data.originalOutput ? JSON.parse(atob(data.originalOutput)) : null,
-                patched: data.patched,
-                injected: data.injected,
-            };
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    /**
-     * List registered functions
-     */
-    async listFunctions() {
-        this.ensureConfigured();
-        const url = `${this.config.serverUrl}/api/v1/functions`;
-        const timeout = this.config.timeout ?? DEFAULT_TIMEOUTS.CLIENT;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        try {
-            const headers = {
-                [HEADERS.ENVIRONMENT]: this.config.environment,
-            };
-            if (this.config.auth?.apiKey) {
-                headers["Authorization"] = `Bearer ${this.config.auth.apiKey}`;
-            }
-            const response = await fetch(url, {
-                method: "GET",
-                headers,
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                throw new IronflowError(`List functions failed: ${response.status}`, { code: "LIST_FUNCTIONS_FAILED" });
-            }
-            const data = await response.json();
-            return data.functions || [];
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    /**
-     * List connected workers
-     */
-    async listWorkers() {
-        this.ensureConfigured();
-        const url = `${this.config.serverUrl}/api/v1/workers`;
-        const timeout = this.config.timeout ?? DEFAULT_TIMEOUTS.CLIENT;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        try {
-            const headers = {
-                [HEADERS.ENVIRONMENT]: this.config.environment,
-            };
-            if (this.config.auth?.apiKey) {
-                headers["Authorization"] = `Bearer ${this.config.auth.apiKey}`;
-            }
-            const response = await fetch(url, {
-                method: "GET",
-                headers,
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                throw new IronflowError(`List workers failed: ${response.status}`, { code: "LIST_WORKERS_FAILED" });
-            }
-            const data = await response.json();
-            return data.workers || [];
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    /**
-     * Health check
-     */
-    async health() {
-        this.ensureConfigured();
-        const url = `${this.config.serverUrl}/health`;
-        const timeout = this.config.timeout ?? DEFAULT_TIMEOUTS.CLIENT;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        try {
-            const response = await fetch(url, {
-                method: "GET",
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                throw new IronflowError(`Health check failed: ${response.status}`, { code: "HEALTH_FAILED" });
-            }
-            return response.json();
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    /**
-     * Get server capabilities
-     */
-    async getCapabilities() {
-        this.ensureConfigured();
-        const url = `${this.config.serverUrl}/api/v1/capabilities`;
-        const timeout = this.config.timeout ?? DEFAULT_TIMEOUTS.CLIENT;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        try {
-            const response = await fetch(url, {
-                method: "GET",
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                throw new IronflowError(`Get capabilities failed: ${response.status}`, { code: "CAPABILITIES_FAILED" });
-            }
-            return response.json();
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    // ============================================================================
-    // Event Emission
-    // ============================================================================
-    /**
-     * Emit an event
-     *
-     * @example
-     * ```typescript
-     * await ironflow.emit('order.approved', {
-     *   orderId: '123',
-     *   approvedBy: 'user@example.com'
-     * });
-     * ```
-     */
-    async emit(eventName, data, options) {
-        this.ensureConfigured();
-        const response = await this.request(TriggerResponseSchema, "POST", "/ironflow.v1.PubSubService/Emit", {
-            event: eventName,
-            data,
-            ...(options?.version ? { version: options.version } : {}),
-            idempotency_key: options?.idempotencyKey,
-            metadata: options?.metadata,
-            namespace: options?.namespace,
-        });
-        return {
-            runIds: response.runIds ?? [],
-            eventId: response.eventId,
-        };
-    }
-    /**
-     * Emit an event synchronously — waits for the triggered run to complete and returns the result.
-     *
-     * Calls the TriggerSync endpoint, which blocks until the run finishes or the timeout elapses.
-     * Throws RunFailedError if the run fails, RunCancelledError if it is cancelled.
-     *
-     * @example
-     * ```typescript
-     * const result = await ironflow.emitSync("order.placed", { orderId: "123" });
-     * console.log("Output:", result.output);
-     * ```
-     */
-    async emitSync(eventName, data, options) {
-        this.ensureConfigured();
-        const timeout = options?.timeout ?? 30000;
-        const response = await this.request(TriggerSyncResponseSchema, "POST", "/ironflow.v1.IronflowService/TriggerSync", { event: eventName, data, timeout_ms: timeout });
-        const results = response.results;
-        if (!results?.length) {
-            throw new IronflowError("No results returned from TriggerSync", { code: "NO_RESULTS", retryable: false });
-        }
-        const result = results[0];
-        if (!result) {
-            throw new IronflowError("No results returned from TriggerSync", { code: "NO_RESULTS", retryable: false });
-        }
-        if (result.status === "failed") {
-            throw new RunFailedError(result.runId, result.error);
-        }
-        if (result.status === "cancelled") {
-            throw new RunCancelledError(result.runId);
-        }
-        return {
-            runId: result.runId,
-            functionId: result.functionId,
-            status: result.status,
-            output: result.output,
-            durationMs: result.durationMs,
-        };
-    }
-    // ============================================================================
-    // Consumer Groups
-    // ============================================================================
-    /**
-     * Join a consumer group for load-balanced event processing
-     */
-    async joinConsumerGroup(groupName, pattern, callbacksAndOptions) {
-        this.ensureConfigured();
-        const sub = await this.subscribe(pattern, {
-            ...callbacksAndOptions,
-            consumerGroup: groupName,
-            ackMode: "manual",
-        });
-        return sub;
-    }
-    // ============================================================================
-    // Entity Streams
-    // ============================================================================
-    /**
-     * Entity stream operations
-     *
-     * @example
-     * ```typescript
-     * // Append an event to a stream
-     * const result = await ironflow.streams.append("order-123", {
-     *   name: "order.created",
-     *   data: { total: 100 },
-     *   entityType: "order",
-     * });
-     *
-     * // Read events from a stream
-     * const { events } = await ironflow.streams.read("order-123", { limit: 10 });
-     *
-     * // Get stream info
-     * const info = await ironflow.streams.getInfo("order-123");
-     * ```
-     */
-    streams = {
-        /**
-         * Append an event to an entity stream
-         */
-        append: async (entityId, input, options) => {
-            this.ensureConfigured();
-            const body = {
-                entity_id: entityId,
-                entity_type: input.entityType,
-                event_name: input.name,
-                data: input.data,
-                expected_version: options?.expectedVersion ?? -1,
-                idempotency_key: options?.idempotencyKey ?? "",
-                version: options?.version ?? 1,
-            };
-            if (options?.metadata !== undefined) {
-                body.metadata = options.metadata;
-            }
-            const response = await this.streamRequest("/ironflow.v1.EntityStreamService/AppendEvent", body);
-            return {
-                entityVersion: Number(response.entityVersion ?? 0),
-                eventId: response.eventId ?? "",
-            };
-        },
-        /**
-         * Read events from an entity stream
-         */
-        read: async (entityId, options) => {
-            this.ensureConfigured();
-            const response = await this.streamRequest("/ironflow.v1.EntityStreamService/ReadStream", {
-                entity_id: entityId,
-                from_version: options?.fromVersion ?? 0,
-                limit: options?.limit ?? 0,
-                direction: options?.direction ?? "forward",
-            });
-            return {
-                events: (response.events ?? []).map((e) => ({
-                    id: e.id,
-                    name: e.name,
-                    data: e.data ?? {},
-                    entityVersion: Number(e.entityVersion ?? 0),
-                    version: e.version,
-                    timestamp: e.timestamp,
-                    source: e.source,
-                    metadata: e.metadata,
-                })),
-                totalCount: Number(response.totalCount ?? 0),
-            };
-        },
-        /**
-         * Get information about an entity stream.
-         *
-         * Returns `null` if no events have been written to this stream yet — safe to
-         * pass `expectedVersion: 0` to `append()` in that case to create the first event.
-         *
-         * @example
-         * ```typescript
-         * const info = await ironflow.streams.getInfo("order-123");
-         * await ironflow.streams.append("order-123", event, {
-         *   expectedVersion: info ? info.version : 0,
-         * });
-         * ```
-         */
-        getInfo: async (entityId) => {
-            this.ensureConfigured();
-            try {
-                const response = await this.streamRequest("/ironflow.v1.EntityStreamService/GetStreamInfo", {
-                    entity_id: entityId,
-                });
-                return {
-                    entityId: response.entityId ?? "",
-                    entityType: response.entityType ?? "",
-                    version: Number(response.version ?? 0),
-                    eventCount: Number(response.eventCount ?? 0),
-                    createdAt: response.createdAt ?? "",
-                    updatedAt: response.updatedAt ?? "",
-                };
-            }
-            catch (err) {
-                if (err instanceof IronflowError && err.message === "stream not found") {
-                    return null;
-                }
-                throw err;
-            }
-        },
-        /**
-         * Create a snapshot of the materialized state at a specific stream version.
-         */
-        createSnapshot: async (entityId, input) => {
-            this.ensureConfigured();
-            const response = await this.streamRequest("/ironflow.v1.EntityStreamService/CreateSnapshot", {
-                entity_id: entityId,
-                entity_type: input.entityType,
-                entity_version: input.entityVersion,
-                state: input.state,
-            });
-            return { snapshotId: response.snapshotId ?? "" };
-        },
-        /**
-         * Get the latest snapshot at or before a given version.
-         */
-        getSnapshot: async (entityId, options) => {
-            this.ensureConfigured();
-            const response = await this.streamRequest("/ironflow.v1.EntityStreamService/GetSnapshot", {
-                entity_id: entityId,
-                before_version: options?.beforeVersion ?? 0,
-            });
-            return {
-                snapshotId: response.snapshotId ?? "",
-                entityId: response.entityId ?? "",
-                entityType: response.entityType ?? "",
-                entityVersion: Number(response.entityVersion ?? 0),
-                state: response.state ?? {},
-                createdAt: response.createdAt ?? "",
-            };
-        },
-        /**
-         * Subscribe to real-time events for an entity stream
-         *
-         * @example
-         * ```typescript
-         * const sub = await ironflow.streams.subscribe("order-123", {
-         *   entityType: "order",
-         *   onEvent: (event) => console.log(event),
-         *   replay: 100,
-         * });
-         *
-         * // Cleanup
-         * sub.unsubscribe();
-         * ```
-         */
-        subscribe: async (entityId, options) => {
-            this.ensureConfigured();
-            const pattern = `entity:${options.entityType}.${entityId}.>`;
-            const sub = await this.subscribe(pattern, {
-                onEvent: (event) => {
-                    const data = event.data;
-                    const streamEvent = {
-                        id: data.id ?? "",
-                        name: data.name ?? "",
-                        data: data.data ?? {},
-                        entityVersion: data.entityVersion ?? 0,
-                        version: data.version ?? 0,
-                        timestamp: data.timestamp ?? "",
-                        source: data.source,
-                        metadata: data.metadata,
-                    };
-                    options.onEvent(streamEvent);
-                },
-                onError: options.onError
-                    ? (info) => options.onError(new Error(info.message))
-                    : undefined,
-                replay: options.replay,
-            });
-            return sub;
-        },
-    };
-    // ============================================================================
-    // Projections
-    // ============================================================================
-    /**
-     * Get the current state of a projection
-     *
-     * @example
-     * ```typescript
-     * const result = await ironflow.getProjection<OrderStats>('order-stats');
-     * console.log(result.state); // { totalOrders: 42, ... }
-     *
-     * // With partition
-     * const result = await ironflow.getProjection('order-stats', { partition: 'customer-123' });
-     * ```
-     */
-    async getProjection(name, options) {
-        this.ensureConfigured();
-        let url = `${this.config.serverUrl}/api/v1/projections/${encodeURIComponent(name)}`;
-        if (options?.partition) {
-            url += `?partition=${encodeURIComponent(options.partition)}`;
-        }
-        const timeout = this.config.timeout ?? DEFAULT_TIMEOUTS.CLIENT;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        try {
-            const headers = {
-                [HEADERS.ENVIRONMENT]: this.config.environment,
-            };
-            if (this.config.auth?.apiKey) {
-                headers["Authorization"] = `Bearer ${this.config.auth.apiKey}`;
-            }
-            const response = await fetch(url, {
-                method: "GET",
-                headers,
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                const error = safeJsonParse(await response.text());
-                throw new IronflowError(error?.message || `Get projection failed: ${response.status}`, { code: error?.code || "GET_PROJECTION_FAILED" });
-            }
-            const data = await response.json();
-            return {
-                name: data.name,
-                partition: data.state?.partition_key ?? "__global__",
-                state: data.state?.state ?? {},
-                lastEventId: data.state?.last_event_id ?? "",
-                lastEventTime: data.state?.last_event_time
-                    ? new Date(data.state.last_event_time)
-                    : new Date(0),
-                version: data.state?.version ?? 0,
-                mode: data.mode,
-            };
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    /**
-     * Query a SQL-backed projection table with optional filtering, ordering, and pagination.
-     *
-     * @example
-     * ```typescript
-     * const result = await ironflow.querySQLProjection('board', {
-     *   where: "status = 'OPEN'",
-     *   orderBy: "title ASC",
-     *   limit: 50,
-     * });
-     * ```
-     */
-    async querySQLProjection(name, options) {
-        this.ensureConfigured();
-        const response = await this.streamRequest("/ironflow.v1.ProjectionService/QuerySQLProjection", {
-            name,
-            where: options?.where ?? "",
-            order_by: options?.orderBy ?? "",
-            limit: options?.limit ?? 100,
-            offset: options?.offset ?? 0,
-        });
-        return {
-            columns: response.columns ?? [],
-            rows: (response.rows ?? []).map((r) => r.values),
-            totalCount: Number(response.totalCount ?? 0),
-        };
-    }
-    /**
-     * Get the status of a projection
-     *
-     * @example
-     * ```typescript
-     * const status = await ironflow.getProjectionStatus('order-stats');
-     * console.log(status.status); // 'active' | 'rebuilding' | 'paused' | 'error'
-     * ```
-     */
-    async getProjectionStatus(name) {
-        this.ensureConfigured();
-        const url = `${this.config.serverUrl}/api/v1/projections/${encodeURIComponent(name)}/status`;
-        const timeout = this.config.timeout ?? DEFAULT_TIMEOUTS.CLIENT;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        try {
-            const headers = {
-                [HEADERS.ENVIRONMENT]: this.config.environment,
-            };
-            if (this.config.auth?.apiKey) {
-                headers["Authorization"] = `Bearer ${this.config.auth.apiKey}`;
-            }
-            const response = await fetch(url, {
-                method: "GET",
-                headers,
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                const error = safeJsonParse(await response.text());
-                throw new IronflowError(error?.message || `Get projection status failed: ${response.status}`, { code: error?.code || "GET_PROJECTION_STATUS_FAILED" });
-            }
-            const data = await response.json();
-            return {
-                name: data.name,
-                status: data.status,
-                mode: data.mode,
-                lastEventSeq: data.last_event_seq ?? 0,
-                lag: data.lag ?? 0,
-                errorMessage: data.error_message || undefined,
-                updatedAt: data.updated_at ? new Date(data.updated_at) : new Date(),
-            };
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    /**
-     * Trigger a rebuild of a projection
-     *
-     * @example
-     * ```typescript
-     * const result = await ironflow.rebuildProjection('order-stats');
-     * ```
-     */
-    async rebuildProjection(name, options) {
-        this.ensureConfigured();
-        const url = `${this.config.serverUrl}/api/v1/projections/${encodeURIComponent(name)}/rebuild`;
-        const timeout = this.config.timeout ?? DEFAULT_TIMEOUTS.CLIENT;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        try {
-            const headers = {
-                "Content-Type": "application/json",
-                [HEADERS.ENVIRONMENT]: this.config.environment,
-            };
-            if (this.config.auth?.apiKey) {
-                headers["Authorization"] = `Bearer ${this.config.auth.apiKey}`;
-            }
-            const response = await fetch(url, {
-                method: "POST",
-                headers,
-                body: JSON.stringify({
-                    partition: options?.partition,
-                    from_event_id: options?.fromEventId,
-                    dry_run: options?.dryRun,
-                }),
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                const error = safeJsonParse(await response.text());
-                throw new IronflowError(error?.message || `Rebuild projection failed: ${response.status}`, { code: error?.code || "REBUILD_PROJECTION_FAILED" });
-            }
-            return response.json();
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    /**
-     * Wait until the named projection has processed events up to `minSeq`,
-     * or the timeout elapses. Read-your-writes primitive for CQRS UIs:
-     * pair with `sequence` from an `appendEntityEvent` response.
-     *
-     * Issue #473.
-     */
-    async waitForProjectionCatchup(name, opts) {
-        this.ensureConfigured();
-        const params = new URLSearchParams();
-        params.set("minSeq", String(opts.minSeq));
-        if (opts.timeoutMs !== undefined)
-            params.set("timeout", String(opts.timeoutMs));
-        if (opts.partition)
-            params.set("partition", opts.partition);
-        const url = `${this.config.serverUrl}/api/v1/projections/${encodeURIComponent(name)}/catchup?${params.toString()}`;
-        // The wait timeout may exceed the normal client timeout — use the
-        // opts.timeoutMs (plus a small grace period) so the client doesn't
-        // abort the request before the server gets a chance to time out.
-        const clientTimeoutMs = (opts.timeoutMs ?? 30_000) + 2_000;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), clientTimeoutMs);
-        try {
-            const headers = {
-                [HEADERS.ENVIRONMENT]: this.config.environment,
-            };
-            if (this.config.auth?.apiKey) {
-                headers["Authorization"] = `Bearer ${this.config.auth.apiKey}`;
-            }
-            const response = await fetch(url, {
-                method: "GET",
-                headers,
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                const error = safeJsonParse(await response.text());
-                throw new IronflowError(error?.message || `Wait for projection catchup failed: ${response.status}`, { code: error?.code || "WAIT_FOR_PROJECTION_FAILED" });
-            }
-            return (await response.json());
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    /**
-     * Streaming wait for a projection to catch up to `minSeq` (issue #476).
-     *
-     * Returns an `AsyncIterable<WaitProgress>` that yields a frame each time
-     * the projection cursor advances, plus one terminal frame (`terminal:
-     * true`) on catch-up, timeout, or error, after which iteration ends.
-     * Heartbeats are filtered inside the SDK — callers never see them.
-     *
-     * Unlike the unary `waitForProjectionCatchup`, this path uses a
-     * server-streaming ConnectRPC connection. The server caps the wait at
-     * 300s regardless of `timeoutMs`. Pass `opts.signal` to cancel early
-     * (e.g., on React unmount); breaking out of `for await` also aborts
-     * the stream.
-     *
-     * Example:
-     * ```ts
-     * for await (const p of ironflow.waitForProjectionCatchupStream("order-view", { minSeq: 42 })) {
-     *   if (p.terminal) {
-     *     if (p.caughtUp) return;
-     *     throw new Error(`wait failed: timedOut=${p.timedOut} error=${p.error}`);
-     *   }
-     *   console.log(`progress: ${p.currentSeq}/${p.targetSeq} behind=${p.behindByEvents}`);
-     * }
-     * ```
-     */
-    async *waitForProjectionCatchupStream(name, opts) {
-        this.ensureConfigured();
-        // Lazy-load the generated projection client deps only when someone
-        // actually calls the streaming API — keeps the tree-shaken bundle small
-        // for apps that only use the unary wait.
-        const { createClient } = await import("@connectrpc/connect");
-        const { createConnectTransport } = await import("@connectrpc/connect-web");
-        const { create } = await import("@bufbuild/protobuf");
-        const { ProjectionService, WaitProjectionCatchupRequestSchema, WaitStreamFrameKind } = await import("@ironflow/core/gen");
-        const transport = createConnectTransport({
-            baseUrl: this.config.serverUrl,
-            interceptors: [
-                (next) => async (req) => {
-                    req.header.set(HEADERS.ENVIRONMENT, this.config.environment);
-                    const token = this.config.auth?.apiKey || this.config.auth?.token;
-                    if (token)
-                        req.header.set("Authorization", `Bearer ${token}`);
-                    return next(req);
-                },
-            ],
-        });
-        const client = createClient(ProjectionService, transport);
-        const request = create(WaitProjectionCatchupRequestSchema, {
-            name,
-            minSeq: typeof opts.minSeq === "bigint" ? opts.minSeq : BigInt(opts.minSeq),
-            partition: opts.partition ?? "",
-            timeout: opts.timeoutMs !== undefined
-                ? {
-                    $typeName: "google.protobuf.Duration",
-                    seconds: BigInt(Math.floor(opts.timeoutMs / 1000)),
-                    nanos: (opts.timeoutMs % 1000) * 1_000_000,
-                }
-                : undefined,
-        });
-        const stream = client.waitProjectionCatchupStream(request, { signal: opts.signal });
-        yield* filterWaitStreamFrames(stream, WaitStreamFrameKind);
-    }
-    /**
-     * Wait for a specific event to be processed by the given projection.
-     * The server resolves `eventId` to its NATS sequence internally.
-     *
-     * Issue #473.
-     */
-    async waitForEvent(eventId, projection, opts = {}) {
-        this.ensureConfigured();
-        const url = `${this.config.serverUrl}/api/v1/projections/wait-for-event`;
-        const clientTimeoutMs = (opts.timeoutMs ?? 30_000) + 2_000;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), clientTimeoutMs);
-        try {
-            const headers = {
-                "Content-Type": "application/json",
-                [HEADERS.ENVIRONMENT]: this.config.environment,
-            };
-            if (this.config.auth?.apiKey) {
-                headers["Authorization"] = `Bearer ${this.config.auth.apiKey}`;
-            }
-            const body = { eventId, projection };
-            if (opts.timeoutMs !== undefined)
-                body.timeoutMs = opts.timeoutMs;
-            if (opts.partition)
-                body.partition = opts.partition;
-            const response = await fetch(url, {
-                method: "POST",
-                headers,
-                body: JSON.stringify(body),
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                const error = safeJsonParse(await response.text());
-                throw new IronflowError(error?.message || `Wait for event failed: ${response.status}`, { code: error?.code || "WAIT_FOR_EVENT_FAILED" });
-            }
-            return (await response.json());
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    /**
-     * List all registered projections
-     *
-     * @example
-     * ```typescript
-     * const projections = await ironflow.listProjections();
-     * projections.forEach(p => console.log(p.name, p.status));
-     * ```
-     */
-    async listProjections() {
-        this.ensureConfigured();
-        const url = `${this.config.serverUrl}/api/v1/projections`;
-        const timeout = this.config.timeout ?? DEFAULT_TIMEOUTS.CLIENT;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        try {
-            const headers = {
-                [HEADERS.ENVIRONMENT]: this.config.environment,
-            };
-            if (this.config.auth?.apiKey) {
-                headers["Authorization"] = `Bearer ${this.config.auth.apiKey}`;
-            }
-            const response = await fetch(url, {
-                method: "GET",
-                headers,
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                throw new IronflowError(`List projections failed: ${response.status}`, { code: "LIST_PROJECTIONS_FAILED" });
-            }
-            const data = await response.json();
-            const projections = data.projections || [];
-            return projections.map((p) => ({
-                name: p.name,
-                status: p.status,
-                mode: p.mode,
-                lastEventSeq: p.last_event_seq ?? 0,
-                lag: 0,
-                errorMessage: p.error_message || undefined,
-                updatedAt: p.updated_at ? new Date(p.updated_at) : new Date(),
-            }));
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    /**
-     * Subscribe to real-time updates for a projection
-     *
-     * @example
-     * ```typescript
-     * const sub = await ironflow.subscribeToProjection<OrderStats>('order-stats', {
-     *   onUpdate: (state, event) => console.log('Updated:', state),
-     *   onError: (error) => console.error(error),
-     * });
-     *
-     * // With partition
-     * const sub = await ironflow.subscribeToProjection('order-stats', {
-     *   onUpdate: (state, event) => console.log('Updated:', state),
-     * }, { partition: 'customer-123' });
-     *
-     * // Cleanup
-     * sub.unsubscribe();
-     * ```
-     */
-    async subscribeToProjection(name, callbacks, options) {
-        this.ensureConfigured();
-        // Build the subscription pattern
-        let pattern;
-        if (options?.partition) {
-            pattern = `system.projection.${name}.${options.partition}.updated`;
-        }
-        else {
-            pattern = `system.projection.${name}.>`;
-        }
-        const sub = await this.subscribe(pattern, {
-            onEvent: (event) => {
-                const payload = event.data;
-                const state = payload.state ?? {};
-                callbacks.onUpdate(state, {
-                    id: payload.last_event_id ?? "",
-                    name: payload.last_event_name ?? "",
-                });
-            },
-            onError: callbacks.onError
-                ? (info) => callbacks.onError(new Error(info.message))
-                : undefined,
-            replay: options?.replay,
-        });
-        return sub;
-    }
-    // ============================================================================
-    // KV Store
-    // ============================================================================
-    /**
-     * KV store operations
-     *
-     * @example
-     * ```typescript
-     * const kv = ironflow.kv();
-     * const bucket = await kv.createBucket({ name: "sessions", ttlSeconds: 3600 });
-     * const handle = kv.bucket("sessions");
-     * const { revision } = await handle.put("user.123", { token: "abc" });
-     * const entry = await handle.get("user.123");
-     *
-     * // Watch for changes
-     * const watcher = handle.watch({
-     *   onUpdate: (event) => console.log(event),
-     * }, { key: "user.*" });
-     * ```
-     */
-    kv() {
-        this.ensureConfigured();
-        return new BrowserKVClient(this.config);
-    }
-    // ============================================================================
-    // Config Management
-    // ============================================================================
-    /**
-     * Config management operations
-     *
-     * @example
-     * ```typescript
-     * const cfg = ironflow.configManager();
-     * await cfg.set("app", { featureX: true, maxRetries: 3 });
-     * const { data, revision } = await cfg.get("app");
-     * await cfg.patch("app", { maxRetries: 5 });
-     * const configs = await cfg.list();
-     * await cfg.delete("app");
-     *
-     * // Watch for changes
-     * const sub = await cfg.watch("app", {
-     *   onEvent: (config) => console.log(config),
-     * });
-     * sub.unsubscribe();
-     * ```
-     */
-    configManager() {
-        this.ensureConfigured();
-        return new BrowserConfigClient(this.config, (pattern, callbacks) => this.subscribe(pattern, callbacks));
-    }
-    // ============================================================================
-    // Auth Management
-    // ============================================================================
-    /**
-     * API key management operations
-     *
-     * @example
-     * ```typescript
-     * // Create an API key
-     * const key = await ironflow.apiKeys.create({ name: "my-key" });
-     * console.log(key.key); // Only shown once
-     *
-     * // List API keys
-     * const keys = await ironflow.apiKeys.list();
-     *
-     * // Delete an API key
-     * await ironflow.apiKeys.delete(key.id);
-     * ```
-     */
-    apiKeys = {
-        /**
-         * Create a new API key
-         */
-        create: async (input) => {
-            this.ensureConfigured();
-            return this.restRequest("POST", "/api/v1/apikeys", input);
-        },
-        /**
-         * List all API keys
-         */
-        list: async () => {
-            this.ensureConfigured();
-            return this.restRequest("GET", "/api/v1/apikeys");
-        },
-        /**
-         * Get an API key by ID
-         */
-        get: async (id) => {
-            this.ensureConfigured();
-            return this.restRequest("GET", `/api/v1/apikeys/${encodeURIComponent(id)}`);
-        },
-        /**
-         * Delete an API key
-         */
-        delete: async (id) => {
-            this.ensureConfigured();
-            await this.restRequest("DELETE", `/api/v1/apikeys/${encodeURIComponent(id)}`);
-        },
-        /**
-         * Rotate an API key, returning a new secret
-         */
-        rotate: async (id) => {
-            this.ensureConfigured();
-            return this.restRequest("POST", `/api/v1/apikeys/${encodeURIComponent(id)}/rotate`);
-        },
-    };
-    /**
-     * Organization management operations (enterprise-only)
-     *
-     * @example
-     * ```typescript
-     * // Create an organization
-     * const org = await ironflow.orgs.create({ name: "Acme Corp" });
-     *
-     * // List organizations
-     * const orgs = await ironflow.orgs.list();
-     *
-     * // Update an organization
-     * await ironflow.orgs.update(org.id, { name: "Acme Inc" });
-     * ```
-     */
-    orgs = {
-        /**
-         * Create a new organization
-         */
-        create: async (input) => {
-            this.ensureConfigured();
-            return this.restRequest("POST", "/api/v1/orgs", input);
-        },
-        /**
-         * List all organizations
-         */
-        list: async () => {
-            this.ensureConfigured();
-            return this.restRequest("GET", "/api/v1/orgs");
-        },
-        /**
-         * Get an organization by ID
-         */
-        get: async (id) => {
-            this.ensureConfigured();
-            return this.restRequest("GET", `/api/v1/orgs/${encodeURIComponent(id)}`);
-        },
-        /**
-         * Update an organization
-         */
-        update: async (id, input) => {
-            this.ensureConfigured();
-            return this.restRequest("PATCH", `/api/v1/orgs/${encodeURIComponent(id)}`, input);
-        },
-        /**
-         * Delete an organization
-         */
-        delete: async (id) => {
-            this.ensureConfigured();
-            await this.restRequest("DELETE", `/api/v1/orgs/${encodeURIComponent(id)}`);
-        },
-    };
-    /**
-     * Role management operations (enterprise-only)
-     *
-     * @example
-     * ```typescript
-     * // Create a role
-     * const role = await ironflow.roles.create({ name: "editor", org_id: "org-1" });
-     *
-     * // Assign a policy to the role
-     * await ironflow.roles.assignPolicy(role.id, policyId);
-     *
-     * // List roles
-     * const roles = await ironflow.roles.list();
-     * ```
-     */
-    roles = {
-        /**
-         * Create a new role
-         */
-        create: async (input) => {
-            this.ensureConfigured();
-            return this.restRequest("POST", "/api/v1/roles", input);
-        },
-        /**
-         * List all roles
-         */
-        list: async (orgId) => {
-            this.ensureConfigured();
-            const query = orgId ? `?org_id=${encodeURIComponent(orgId)}` : "";
-            return this.restRequest("GET", `/api/v1/roles${query}`);
-        },
-        /**
-         * Get a role by ID
-         */
-        get: async (id) => {
-            this.ensureConfigured();
-            return this.restRequest("GET", `/api/v1/roles/${encodeURIComponent(id)}`);
-        },
-        /**
-         * Update a role
-         */
-        update: async (id, input) => {
-            this.ensureConfigured();
-            return this.restRequest("PATCH", `/api/v1/roles/${encodeURIComponent(id)}`, input);
-        },
-        /**
-         * Delete a role
-         */
-        delete: async (id) => {
-            this.ensureConfigured();
-            await this.restRequest("DELETE", `/api/v1/roles/${encodeURIComponent(id)}`);
-        },
-        /**
-         * Assign a policy to a role
-         */
-        assignPolicy: async (roleId, policyId) => {
-            this.ensureConfigured();
-            await this.restRequest("POST", `/api/v1/roles/${encodeURIComponent(roleId)}/policies`, { policy_id: policyId });
-        },
-        /**
-         * Remove a policy from a role
-         */
-        removePolicy: async (roleId, policyId) => {
-            this.ensureConfigured();
-            await this.restRequest("DELETE", `/api/v1/roles/${encodeURIComponent(roleId)}/policies/${encodeURIComponent(policyId)}`);
-        },
-    };
-    /**
-     * Policy management operations (enterprise-only)
-     *
-     * @example
-     * ```typescript
-     * // Create a policy
-     * const policy = await ironflow.policies.create({
-     *   name: "allow-read",
-     *   effect: "allow",
-     *   actions: "read",
-     *   resources: "*",
-     *   org_id: "org-1",
-     * });
-     *
-     * // List policies
-     * const policies = await ironflow.policies.list();
-     * ```
-     */
-    policies = {
-        /**
-         * Create a new policy
-         */
-        create: async (input) => {
-            this.ensureConfigured();
-            return this.restRequest("POST", "/api/v1/policies", input);
-        },
-        /**
-         * List all policies
-         */
-        list: async (orgId) => {
-            this.ensureConfigured();
-            const query = orgId ? `?org_id=${encodeURIComponent(orgId)}` : "";
-            return this.restRequest("GET", `/api/v1/policies${query}`);
-        },
-        /**
-         * Get a policy by ID
-         */
-        get: async (id) => {
-            this.ensureConfigured();
-            return this.restRequest("GET", `/api/v1/policies/${encodeURIComponent(id)}`);
-        },
-        /**
-         * Update a policy
-         */
-        update: async (id, input) => {
-            this.ensureConfigured();
-            return this.restRequest("PATCH", `/api/v1/policies/${encodeURIComponent(id)}`, input);
-        },
-        /**
-         * Delete a policy
-         */
-        delete: async (id) => {
-            this.ensureConfigured();
-            await this.restRequest("DELETE", `/api/v1/policies/${encodeURIComponent(id)}`);
-        },
-    };
-    /**
-     * Event schema registry operations
-     *
-     * @example
-     * ```typescript
-     * // Register a schema
-     * const schema = await ironflow.schemas.register({
-     *   name: "order.placed",
-     *   version: 1,
-     *   schema: { type: "object", properties: { orderId: { type: "string" } } },
-     * });
-     *
-     * // List all schemas
-     * const schemas = await ironflow.schemas.list();
-     *
-     * // Get latest version of a schema
-     * const latest = await ironflow.schemas.get("order.placed");
-     *
-     * // Test an upcast transformation
-     * const result = await ironflow.schemas.testUpcast({
-     *   eventName: "order.placed",
-     *   fromVersion: 1,
-     *   toVersion: 2,
-     *   data: { orderId: "123" },
-     * });
-     * ```
-     */
-    schemas = {
-        /** Register a new event schema (or a new version of an existing schema) */
-        register: async (input) => {
-            this.ensureConfigured();
-            return this.restRequest("POST", "/api/v1/events/schemas", {
-                event_name: input.name,
-                version: input.version,
-                schema_json: JSON.stringify(input.schema),
-            });
-        },
-        /** List all registered event schemas */
-        list: async () => {
-            this.ensureConfigured();
-            const resp = await this.restRequest("GET", "/api/v1/events/schemas");
-            return resp.schemas ?? [];
-        },
-        /** Get the latest version of an event schema by name */
-        get: async (name) => {
-            this.ensureConfigured();
-            return this.restRequest("GET", `/api/v1/events/schemas/${encodeURIComponent(name)}`);
-        },
-        /** Get a specific version of an event schema */
-        getVersion: async (name, version) => {
-            this.ensureConfigured();
-            return this.restRequest("GET", `/api/v1/events/schemas/${encodeURIComponent(name)}/${version}`);
-        },
-        /** Delete a specific version of an event schema */
-        delete: async (name, version) => {
-            this.ensureConfigured();
-            await this.restRequest("DELETE", `/api/v1/events/schemas/${encodeURIComponent(name)}/${version}`);
-        },
-        /** Test an upcast transformation between two schema versions */
-        testUpcast: async (input) => {
-            this.ensureConfigured();
-            return this.restRequest("POST", "/api/v1/events/upcast", input);
-        },
-    };
-    // ============================================================================
-    // Audit Trail
-    // ============================================================================
-    /**
-     * Get the audit trail for a run.
-     *
-     * @param runId The run ID to retrieve the audit trail for
-     * @param options Optional filtering options
-     *
-     * @example
-     * ```typescript
-     * const result = await ironflow.getAuditTrail("run-abc123");
-     * for (const event of result.events) {
-     *   console.log(event.eventType, event.createdAt);
-     * }
-     * ```
-     */
-    async getAuditTrail(runId, options) {
-        this.ensureConfigured();
-        const response = await this.streamRequest("/ironflow.v1.AuditService/GetAuditTrail", {
-            run_id: runId,
-            event_type: options?.eventType ?? "",
-            from_timestamp: options?.fromTimestamp ?? "",
-            to_timestamp: options?.toTimestamp ?? "",
-            limit: options?.limit ?? 0,
-            cursor: options?.cursor ?? "",
-        });
-        return {
-            events: (response.events ?? []).map((e) => ({
-                id: e.id,
-                runId: e.run_id,
-                functionId: e.function_id,
-                stepId: e.step_id,
-                eventType: e.event_type,
-                payload: e.payload ?? {},
-                metadata: e.metadata,
-                createdAt: e.created_at,
-            })),
-            totalCount: response.total_count ?? 0,
-            nextCursor: response.next_cursor,
-        };
-    }
-    // ============================================================================
-    // Webhook Management
-    // ============================================================================
-    /**
-     * Webhook management operations
-     *
-     * @example
-     * ```typescript
-     * // List all webhook sources
-     * const sources = await ironflow.webhooks.listSources();
-     *
-     * // Delete a webhook source
-     * await ironflow.webhooks.deleteSource("my-webhook");
-     *
-     * // List deliveries
-     * const { deliveries } = await ironflow.webhooks.listDeliveries({ sourceId: "my-webhook" });
-     * ```
-     */
-    webhooks = {
-        /** Create a new webhook source */
-        create: async (input) => {
-            this.ensureConfigured();
-            const response = await this.streamRequest("/ironflow.v1.WebhookService/CreateWebhookSource", {
-                id: input.id,
-                event_prefix: input.eventPrefix,
-                verify_header: input.verifyHeader ?? "",
-                verify_algorithm: input.verifyAlgorithm ?? "",
-                verify_secret: input.verifySecret ?? "",
-                metadata: input.metadata,
-            });
-            return {
-                id: response.id,
-                eventPrefix: response.event_prefix,
-                verifyHeader: response.verify_header,
-                verifyAlgorithm: response.verify_algorithm,
-                sourceType: response.source_type,
-                metadata: response.metadata,
-                createdAt: response.created_at,
-                updatedAt: response.updated_at,
-            };
-        },
-        /** List all registered webhook sources */
-        listSources: async () => {
-            this.ensureConfigured();
-            const response = await this.streamRequest("/ironflow.v1.WebhookService/ListWebhookSources", { limit: 0, offset: 0 });
-            return (response.sources ?? []).map((s) => ({
-                id: s.id,
-                eventPrefix: s.event_prefix,
-                verifyHeader: s.verify_header,
-                verifyAlgorithm: s.verify_algorithm,
-                sourceType: s.source_type,
-                metadata: s.metadata,
-                createdAt: s.created_at,
-                updatedAt: s.updated_at,
-            }));
-        },
-        /** Delete a webhook source by ID */
-        deleteSource: async (id) => {
-            this.ensureConfigured();
-            await this.streamRequest("/ironflow.v1.WebhookService/DeleteWebhookSource", { id });
-        },
-        /** List webhook deliveries with optional filtering */
-        listDeliveries: async (opts) => {
-            this.ensureConfigured();
-            const response = await this.streamRequest("/ironflow.v1.WebhookService/ListWebhookDeliveries", {
-                source_id: opts?.sourceId ?? "",
-                status: opts?.status ?? "",
-                limit: opts?.limit ?? 0,
-                offset: opts?.offset ?? 0,
-            });
-            return {
-                deliveries: (response.deliveries ?? []).map((d) => ({
-                    id: d.id,
-                    sourceId: d.source_id,
-                    externalId: d.external_id,
-                    status: d.status,
-                    eventId: d.event_id,
-                    error: d.error,
-                    createdAt: d.created_at,
-                })),
-                totalCount: response.total_count ?? 0,
-            };
-        },
-    };
-    // ============================================================================
-    // User Management
-    // ============================================================================
-    /**
-     * User management operations
-     *
-     * @example
-     * ```typescript
-     * // List all users
-     * const users = await ironflow.users.list();
-     *
-     * // Create a user
-     * const user = await ironflow.users.create({
-     *   email: "alice@example.com",
-     *   password: "secret",
-     *   roles: ["admin"],
-     * });
-     *
-     * // Update a user
-     * await ironflow.users.update(user.id, { name: "Alice" });
-     * ```
-     */
-    users = {
-        /** Create a new user (admin only) */
-        create: async (input) => {
-            this.ensureConfigured();
-            return this.restRequest("POST", "/api/v1/users", input);
-        },
-        /** List all users in the current organization (admin only) */
-        list: async () => {
-            this.ensureConfigured();
-            return this.restRequest("GET", "/api/v1/users");
-        },
-        /** Get a user by ID */
-        get: async (id) => {
-            this.ensureConfigured();
-            return this.restRequest("GET", `/api/v1/users/${encodeURIComponent(id)}`);
-        },
-        /** Update a user's profile (admin only) */
-        update: async (id, input) => {
-            this.ensureConfigured();
-            return this.restRequest("PATCH", `/api/v1/users/${encodeURIComponent(id)}`, input);
-        },
-        /** Delete a user (admin only) */
-        delete: async (id) => {
-            this.ensureConfigured();
-            await this.restRequest("DELETE", `/api/v1/users/${encodeURIComponent(id)}`);
-        },
-    };
-    /**
-     * Tenant management operations (enterprise-only)
-     *
-     * @example
-     * ```typescript
-     * // List all tenants
-     * const tenants = await ironflow.tenants.list();
-     * ```
-     */
-    tenants = {
-        /** List all tenants (enterprise-only) */
-        list: async () => {
-            this.ensureConfigured();
-            return this.restRequest("GET", "/api/v1/tenants");
-        },
-    };
-    // ============================================================================
-    // Pattern Helpers (static)
-    // ============================================================================
-    /**
-     * Pattern helpers for building subscription patterns
-     */
-    static patterns = patterns;
-    // ============================================================================
-    // Internal Methods
-    // ============================================================================
-    ensureConfigured() {
-        if (!this.config) {
-            throw new NotConfiguredError();
-        }
-    }
-    cleanup() {
-        if (this.visibilityHandler) {
-            document.removeEventListener("visibilitychange", this.visibilityHandler);
-            this.visibilityHandler = null;
-        }
-        if (this.subscriptionManager) {
-            this.subscriptionManager.disconnect();
-            this.subscriptionManager = null;
-        }
-        this.transport = null;
-    }
-    /**
-     * Reset client state for testing. Not intended for production use.
-     * @internal
-     */
-    _resetForTesting() {
-        this.cleanup();
-        this.config = null;
-        this.logger = createNoopLogger();
-    }
-    setupVisibilityHandling() {
-        this.visibilityHandler = () => {
-            if (document.hidden) {
-                this.logger.debug("Tab hidden, pausing subscriptions");
-                this.subscriptionManager?.pause();
-            }
-            else {
-                if (this.config?.visibility.reconnectOnVisible) {
-                    this.logger.debug("Tab visible, resuming subscriptions");
-                    this.subscriptionManager?.resume();
-                }
-            }
-        };
-        document.addEventListener("visibilitychange", this.visibilityHandler);
-    }
-    async request(schema, method, path, body) {
-        const url = `${this.config.serverUrl}${path}`;
-        const timeout = this.config.timeout ?? DEFAULT_TIMEOUTS.CLIENT;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        try {
-            const headers = {
-                "Content-Type": "application/json",
-                [HEADERS.ENVIRONMENT]: this.config.environment,
-            };
-            if (this.config.auth?.apiKey) {
-                headers["Authorization"] = `Bearer ${this.config.auth.apiKey}`;
-            }
-            else if (this.config.auth?.token) {
-                headers["Authorization"] = `Bearer ${this.config.auth.token}`;
-            }
-            const response = await fetch(url, {
-                method,
-                headers,
-                body: JSON.stringify(body),
-                signal: controller.signal,
-            });
-            const responseBody = await response.text();
-            if (!response.ok) {
-                const errorResult = ErrorResponseSchema.safeParse(safeJsonParse(responseBody));
-                const errorData = errorResult.success
-                    ? errorResult.data
-                    : { message: responseBody };
-                throw new IronflowError(errorData.message ?? `Request failed: ${response.status}`, {
-                    code: errorData.code ?? `HTTP_${response.status}`,
-                    retryable: response.status >= 500,
-                });
-            }
-            const parsed = safeJsonParse(responseBody);
-            if (parsed === undefined) {
-                throw new ValidationError("Invalid JSON response from server");
-            }
-            const result = schema.safeParse(parsed);
-            if (!result.success) {
-                const issues = result.error.issues
-                    .map((i) => `${i.path.join(".")}: ${i.message}`)
-                    .join(", ");
-                throw new ValidationError(`Invalid response from server: ${issues}`);
-            }
-            return result.data;
-        }
-        catch (error) {
-            if (error instanceof IronflowError || error instanceof ValidationError) {
-                throw error;
-            }
-            if (error instanceof Error && error.name === "AbortError") {
-                throw new IronflowError(`Request timeout after ${timeout}ms for ${method} ${path}`, {
-                    code: "TIMEOUT",
-                    retryable: true,
-                });
-            }
-            throw new IronflowError(error instanceof Error
-                ? `${method} ${path} failed: ${error.message}`
-                : `${method} ${path} failed`, {
-                code: "REQUEST_FAILED",
-                retryable: true,
-                cause: error instanceof Error ? error : undefined,
-            });
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    async streamRequest(path, body) {
-        const url = `${this.config.serverUrl}${path}`;
-        const timeout = this.config.timeout ?? DEFAULT_TIMEOUTS.CLIENT;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        try {
-            const headers = {
-                "Content-Type": "application/json",
-                [HEADERS.ENVIRONMENT]: this.config.environment,
-            };
-            if (this.config.auth?.apiKey) {
-                headers["Authorization"] = `Bearer ${this.config.auth.apiKey}`;
-            }
-            else if (this.config.auth?.token) {
-                headers["Authorization"] = `Bearer ${this.config.auth.token}`;
-            }
-            const response = await fetch(url, {
-                method: "POST",
-                headers,
-                body: JSON.stringify(body),
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                const errorBody = safeJsonParse(await response.text());
-                throw new IronflowError(errorBody?.message ?? `Request failed: ${response.status}`, {
-                    code: errorBody?.code ?? `HTTP_${response.status}`,
-                    retryable: response.status >= 500,
-                });
-            }
-            return response.json();
-        }
-        catch (error) {
-            if (error instanceof IronflowError) {
-                throw error;
-            }
-            if (error instanceof Error && error.name === "AbortError") {
-                throw new IronflowError(`Request timeout after ${timeout}ms for POST ${path}`, { code: "TIMEOUT", retryable: true });
-            }
-            throw new IronflowError(error instanceof Error
-                ? `POST ${path} failed: ${error.message}`
-                : `POST ${path} failed`, {
-                code: "REQUEST_FAILED",
-                retryable: true,
-                cause: error instanceof Error ? error : undefined,
-            });
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    /**
-     * REST request helper for auth management endpoints.
-     *
-     * Supports GET, POST, PATCH, DELETE methods with typed error mapping:
-     * - 401 → UnauthenticatedError
-     * - 402 → EnterpriseRequiredError
-     * - 403 → UnauthorizedError
-     */
-    async restRequest(method, path, body) {
-        const url = `${this.config.serverUrl}${path}`;
-        const timeout = this.config.timeout ?? DEFAULT_TIMEOUTS.CLIENT;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        try {
-            const headers = {
-                [HEADERS.ENVIRONMENT]: this.config.environment,
-            };
-            if (body !== undefined) {
-                headers["Content-Type"] = "application/json";
-            }
-            if (this.config.auth?.apiKey) {
-                headers["Authorization"] = `Bearer ${this.config.auth.apiKey}`;
-            }
-            else if (this.config.auth?.token) {
-                headers["Authorization"] = `Bearer ${this.config.auth.token}`;
-            }
-            const fetchOptions = {
-                method,
-                headers,
-                signal: controller.signal,
-            };
-            if (body !== undefined) {
-                fetchOptions.body = JSON.stringify(body);
-            }
-            const response = await fetch(url, fetchOptions);
-            // Handle 204 No Content
-            if (response.status === 204) {
-                return undefined;
-            }
-            if (!response.ok) {
-                const errorText = await response.text();
-                let errorMessage = `Request failed with status ${response.status}`;
-                if (errorText) {
-                    const errorJson = safeJsonParse(errorText);
-                    if (errorJson?.message) {
-                        errorMessage = errorJson.message;
-                    }
-                    else if (errorText) {
-                        errorMessage = errorText;
-                    }
-                }
-                switch (response.status) {
-                    case 401:
-                        throw new UnauthenticatedError(errorMessage);
-                    case 402:
-                        throw new EnterpriseRequiredError(errorMessage);
-                    case 403:
-                        throw new UnauthorizedError(errorMessage);
-                    default:
-                        throw new IronflowError(errorMessage, {
-                            code: `HTTP_${response.status}`,
-                            retryable: response.status >= 500,
-                        });
-                }
-            }
-            return response.json();
-        }
-        catch (error) {
-            if (error instanceof IronflowError ||
-                error instanceof UnauthenticatedError ||
-                error instanceof EnterpriseRequiredError ||
-                error instanceof UnauthorizedError) {
-                throw error;
-            }
-            if (error instanceof Error && error.name === "AbortError") {
-                throw new IronflowError(`Request timeout after ${timeout}ms for ${method} ${path}`, { code: "TIMEOUT", retryable: true });
-            }
-            throw new IronflowError(error instanceof Error
-                ? `${method} ${path} failed: ${error.message}`
-                : `${method} ${path} failed`, {
-                code: "REQUEST_FAILED",
-                retryable: true,
-                cause: error instanceof Error ? error : undefined,
-            });
-        }
-        finally {
-            clearTimeout(timeoutId);
-        }
-    }
-    mapRunResponse(response) {
-        // ConnectRPC returns proto enum strings like "RUN_STATUS_COMPLETED" — normalize to "completed"
-        const rawStatus = response.status.toLowerCase().replace(/^run_status_/, "");
-        const statusResult = RunStatusSchema.safeParse(rawStatus);
-        const status = statusResult.success ? statusResult.data : "failed";
-        return {
-            id: response.id,
-            functionId: response.functionId,
-            eventId: response.eventId,
-            status,
-            attempt: response.attempt,
-            maxAttempts: response.maxAttempts,
-            input: response.input,
-            output: response.output,
-            error: response.error,
-            startedAt: response.startedAt ? new Date(response.startedAt) : undefined,
-            endedAt: response.endedAt ? new Date(response.endedAt) : undefined,
-            createdAt: new Date(response.createdAt),
-            updatedAt: new Date(response.updatedAt),
-        };
-    }
-}
-/**
- * Singleton instance
- */
-export const ironflow = new IronflowClient();
-/**
- * Export the class for advanced usage
- */
-export { IronflowClient };
-//# sourceMappingURL=client.js.map