hyperstack-react 0.1.2

package/dist/index.esm.js

@@ -0,0 +1,834 @@
+import React, { createContext, useMemo, useRef, useEffect, useContext, useState, useCallback, useSyncExternalStore } from 'react';
+import { create } from 'zustand';
+
+// Sensible defaults - can be overridden per ConnectionManager instance
+const DEFAULT_CONFIG = {
+    websocketUrl: 'ws://localhost:8080', // default local development server
+    reconnectIntervals: [1000, 2000, 4000, 8000, 16000], // exponential backoff: 1s, 2s, 4s, 8s, 16s
+    maxReconnectAttempts: 5, // retry 5 times before giving up (matches array length)
+    initialSubscriptions: [], // no global subscriptions by default
+    supportsUnsubscribe: false, // conservative default - many servers don't support this
+    autoSubscribeDefault: true, // hooks auto-subscribe by default
+};
+// Custom error class for SDK-specific errors with structured details
+class HyperStreamError extends Error {
+    constructor(message, // human-readable error message
+    code, // machine-readable error code (e.g., 'CONNECTION_FAILED')
+    details // additional context (original error, frame data, etc.)
+    ) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = 'HyperStreamError'; // Proper error name for debugging/logging
+    }
+}
+
+// Manages WebSocket connection lifecycle and subscription queuing
+class ConnectionManager {
+    constructor(config = {}) {
+        this.ws = null;
+        this.reconnectAttempts = 0;
+        this.reconnectTimeout = null;
+        this.pingInterval = null;
+        this.currentState = 'disconnected';
+        this.subscriptionQueue = [];
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    // set callbacks
+    setHandlers(handlers) {
+        this.onFrame = handlers.onFrame;
+        this.onStateChange = handlers.onStateChange;
+    }
+    // public getters for external state inspection
+    getState() {
+        return this.currentState;
+    }
+    getConfig() {
+        return this.config;
+    }
+    // Initiate WebSocket connection with subscription restoration
+    connect() {
+        // prevent duplicate connections
+        if (this.ws?.readyState === WebSocket.OPEN ||
+            this.ws?.readyState === WebSocket.CONNECTING ||
+            this.currentState === 'connecting') {
+            console.log('Connection already exists or in progress, skipping connect');
+            return;
+        }
+        console.log('[Hyperstack] Connecting to WebSocket...');
+        this.updateState('connecting'); // update UI state immediately
+        try {
+            this.ws = new WebSocket(this.config.websocketUrl);
+            this.ws.onopen = () => {
+                console.log('[Hyperstack] WebSocket connected');
+                this.reconnectAttempts = 0; // reset retry counter on successful connect
+                this.updateState('connected'); // notify store/UI of successful connection
+                this.startPingInterval(); // start keep-alive ping
+                // send global subscriptions first (from config)
+                if (this.config.initialSubscriptions) {
+                    for (const sub of this.config.initialSubscriptions) {
+                        this.subscribe(sub);
+                    }
+                }
+                // flush queued subscriptions from when we were offline
+                while (this.subscriptionQueue.length > 0) {
+                    const sub = this.subscriptionQueue.shift();
+                    this.subscribe(sub);
+                }
+            };
+            // core message handler - parses incoming data into EntityFrames
+            this.ws.onmessage = async (event) => {
+                try {
+                    let frame;
+                    if (event.data instanceof ArrayBuffer) {
+                        // binary data as ArrayBuffer
+                        frame = this.parseBinaryFrame(event.data);
+                    }
+                    else if (event.data instanceof Blob) {
+                        // binary data as Blob - convert to ArrayBuffer
+                        const arrayBuffer = await event.data.arrayBuffer();
+                        frame = this.parseBinaryFrame(arrayBuffer);
+                    }
+                    else if (typeof event.data === 'string') {
+                        // JSON text data
+                        frame = JSON.parse(event.data);
+                    }
+                    else {
+                        throw new Error(`Unsupported message type: ${typeof event.data}`);
+                    }
+                    // fw parsed frame to store for entity updates
+                    this.onFrame?.(frame);
+                }
+                catch (error) {
+                    console.error('Failed to parse frame:', error);
+                    this.updateState('error', 'Failed to parse frame from server');
+                }
+            };
+            // WebSocket error handling
+            this.ws.onerror = (error) => {
+                console.error('WebSocket error:', error);
+                this.updateState('error', 'WebSocket connection error'); // Notify store/UI of errors
+            };
+            // connection lost handler with auto-reconnection
+            this.ws.onclose = () => {
+                console.log('WebSocket disconnected');
+                this.stopPingInterval();
+                this.ws = null;
+                // only auto-reconnect if we didn't explicitly disconnect
+                // this preserves subscriptions across temporary network issues
+                if (this.currentState !== 'disconnected') {
+                    this.handleReconnect();
+                }
+            };
+        }
+        catch (error) {
+            console.error('Failed to create WebSocket:', error);
+            this.updateState('error', 'Failed to create WebSocket connection');
+        }
+    }
+    disconnect() {
+        this.clearReconnectTimeout();
+        this.stopPingInterval();
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.updateState('disconnected');
+    }
+    updateConfig(newConfig) {
+        this.config = { ...this.config, ...newConfig };
+    }
+    subscribe(subscription) {
+        if (this.currentState === 'connected' && this.ws && this.ws.readyState === WebSocket.OPEN) {
+            console.log('[Hyperstack] Subscribing to:', subscription.view);
+            const message = JSON.stringify(subscription);
+            this.ws.send(message);
+        }
+        else {
+            this.subscriptionQueue.push(subscription);
+        }
+    }
+    // Unsubscribe support (feature-gated by server capabilities)
+    unsubscribe(_view, _key) {
+        if (this.config.supportsUnsubscribe && this.currentState === 'connected' && this.ws) {
+            // only send unsubscribe if server supports it - TO DO
+            console.warn('Unsubscribe not yet implemented on server side');
+        }
+    }
+    // binary frame parser - converts WebSocket binary data to EntityFrame
+    parseBinaryFrame(data) {
+        // server sends JSON Frame serialized as binary bytes
+        // convert binary data back to JSON string and parse
+        const decoder = new TextDecoder('utf-8');
+        const jsonString = decoder.decode(data);
+        // parse the Frame JSON sent by projector
+        const frame = JSON.parse(jsonString);
+        // convert to EntityFrame format expected by SDK
+        return {
+            mode: frame.mode,
+            entity: frame.entity, // Backend serializes view path as 'entity' field
+            op: frame.op,
+            key: frame.key,
+            data: frame.data
+        };
+    }
+    // Internal state change handler - notifies store and triggers UI re-renders
+    updateState(state, error) {
+        this.currentState = state;
+        this.onStateChange?.(state, error);
+    }
+    // Auto-reconnection with true exponential backoff protection
+    handleReconnect() {
+        const intervals = this.config.reconnectIntervals || [1000, 2000, 4000, 8000, 16000];
+        const maxAttempts = this.config.maxReconnectAttempts || intervals.length;
+        if (this.reconnectAttempts >= maxAttempts) {
+            // give up after max attempts to avoid infinite retry loops
+            this.updateState('error', `Max reconnection attempts (${this.reconnectAttempts}) reached`);
+            return;
+        }
+        this.updateState('reconnecting'); // update store/UI to show reconnection status
+        // get delay for current attempt (use last interval if we exceed array length)
+        const attemptIndex = Math.min(this.reconnectAttempts, intervals.length - 1);
+        const delay = intervals[attemptIndex];
+        this.reconnectAttempts++;
+        // delayed reconnection with exponential backoff
+        this.reconnectTimeout = setTimeout(() => {
+            console.log(`Reconnect attempt ${this.reconnectAttempts} after ${delay}ms delay`);
+            this.connect(); // recursive call - will restore subscriptions on success
+        }, delay);
+    }
+    // Cleanup helper for reconnection timer
+    clearReconnectTimeout() {
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+        }
+    }
+    startPingInterval() {
+        this.stopPingInterval();
+        this.pingInterval = setInterval(() => {
+            if (this.ws?.readyState === WebSocket.OPEN) {
+                this.ws.send(JSON.stringify({ type: 'ping' }));
+            }
+        }, 15000);
+    }
+    stopPingInterval() {
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+            this.pingInterval = null;
+        }
+    }
+}
+
+function deepMerge(target, source) {
+    if (!isObject(target) || !isObject(source)) {
+        return source;
+    }
+    const result = { ...target };
+    for (const key in source) {
+        const sourceValue = source[key];
+        const targetValue = result[key];
+        if (isObject(sourceValue) && isObject(targetValue)) {
+            result[key] = deepMerge(targetValue, sourceValue);
+        }
+        else {
+            result[key] = sourceValue;
+        }
+    }
+    return result;
+}
+function isObject(item) {
+    return item && typeof item === 'object' && !Array.isArray(item);
+}
+function createHyperStore(config = {}) {
+    return create((set, get) => {
+        const connectionManager = new ConnectionManager({ ...DEFAULT_CONFIG, ...config });
+        const makeSubKey = (subscription) => `${subscription.view}:${subscription.key ?? '*'}:${subscription.partition ?? ''}:${JSON.stringify(subscription.filters ?? {})}`;
+        connectionManager.setHandlers({
+            onFrame: (frame) => {
+                get().handleFrame(frame);
+            },
+            onStateChange: (connectionState, error) => {
+                set({ connectionState, lastError: error });
+            }
+        });
+        return {
+            connectionState: 'disconnected',
+            lastError: undefined,
+            entities: new Map(),
+            recentFrames: [],
+            subscriptionRefs: new Map(),
+            connectionManager,
+            viewCache: {},
+            handleFrame: (frame) => {
+                set((state) => {
+                    const newEntities = new Map(state.entities);
+                    const viewPath = frame.entity;
+                    const entityMap = new Map(newEntities.get(viewPath) || new Map());
+                    switch (frame.op) {
+                        case 'upsert':
+                            entityMap.set(frame.key, frame.data);
+                            break;
+                        case 'patch':
+                            const existing = entityMap.get(frame.key);
+                            if (existing && typeof existing === 'object' && typeof frame.data === 'object') {
+                                entityMap.set(frame.key, deepMerge(existing, frame.data));
+                            }
+                            else {
+                                entityMap.set(frame.key, frame.data);
+                            }
+                            break;
+                        case 'delete':
+                            entityMap.delete(frame.key);
+                            break;
+                    }
+                    newEntities.set(viewPath, entityMap);
+                    const newViewCache = { ...state.viewCache };
+                    const currentMetadata = newViewCache[viewPath];
+                    const keys = Array.from(entityMap.keys());
+                    newViewCache[viewPath] = {
+                        mode: (frame.mode === 'state' || frame.mode === 'list') ? frame.mode : 'list',
+                        keys,
+                        lastUpdatedAt: Date.now(),
+                        lastArgs: currentMetadata?.lastArgs
+                    };
+                    return {
+                        ...state,
+                        entities: newEntities,
+                        recentFrames: [frame, ...state.recentFrames],
+                        viewCache: newViewCache
+                    };
+                });
+            },
+            _incRef: (subscription) => {
+                const subKey = makeSubKey(subscription);
+                const { subscriptionRefs } = get();
+                const existing = subscriptionRefs.get(subKey);
+                if (existing) {
+                    existing.refCount++;
+                }
+                else {
+                    subscriptionRefs.set(subKey, {
+                        subscription,
+                        refCount: 1
+                    });
+                    connectionManager.subscribe(subscription);
+                }
+            },
+            _decRef: (subscription) => {
+                const subKey = makeSubKey(subscription);
+                const { subscriptionRefs } = get();
+                const existing = subscriptionRefs.get(subKey);
+                if (existing) {
+                    existing.refCount--;
+                    if (existing.refCount <= 0) {
+                        subscriptionRefs.delete(subKey);
+                        connectionManager.unsubscribe(subscription.view, subscription.key);
+                    }
+                }
+            },
+            _getRefCount: (subscription) => {
+                const subKey = makeSubKey(subscription);
+                return get().subscriptionRefs.get(subKey)?.refCount ?? 0;
+            },
+            subscribe: (subscription) => {
+                connectionManager.subscribe(subscription);
+            },
+            unsubscribe: (view, key) => {
+                connectionManager.unsubscribe(view, key);
+            },
+            connect: () => {
+                connectionManager.connect();
+            },
+            disconnect: () => {
+                connectionManager.disconnect();
+            },
+            updateConfig: (newConfig) => {
+                connectionManager.updateConfig(newConfig);
+            }
+        };
+    });
+}
+
+function createRuntime(config) {
+    const store = createHyperStore({
+        websocketUrl: config.websocketUrl
+    });
+    const connection = store.getState().connectionManager;
+    return {
+        store,
+        connection,
+        wallet: config.wallet,
+        subscribe(view, key, filters) {
+            const subscription = { view, key, filters };
+            store.getState()._incRef(subscription);
+            return {
+                view,
+                key,
+                filters,
+                unsubscribe: () => store.getState()._decRef(subscription)
+            };
+        },
+        unsubscribe(handle) {
+            handle.unsubscribe();
+        }
+    };
+}
+
+const HyperstackContext = createContext(null);
+function resolveNetworkConfig(network, websocketUrl) {
+    if (websocketUrl) {
+        return {
+            name: 'custom',
+            websocketUrl
+        };
+    }
+    if (typeof network === 'object') {
+        return network;
+    }
+    if (network === 'mainnet') {
+        return {
+            name: 'mainnet',
+            websocketUrl: 'wss://mainnet.hyperstack.xyz',
+        };
+    }
+    if (network === 'devnet') {
+        return {
+            name: 'devnet',
+            websocketUrl: 'ws://localhost:8080',
+        };
+    }
+    if (network === 'localnet') {
+        return {
+            name: 'localnet',
+            websocketUrl: 'ws://localhost:8080',
+        };
+    }
+    throw new Error('Must provide either network or websocketUrl');
+}
+function HyperstackProvider({ children, ...config }) {
+    const networkConfig = useMemo(() => {
+        try {
+            return resolveNetworkConfig(config.network, config.websocketUrl);
+        }
+        catch (error) {
+            console.error('[Hyperstack] Invalid network configuration:', error);
+            throw error;
+        }
+    }, [config.network, config.websocketUrl]);
+    const runtimeRef = useRef(null);
+    if (!runtimeRef.current) {
+        try {
+            runtimeRef.current = createRuntime({
+                ...config,
+                websocketUrl: networkConfig.websocketUrl,
+                network: networkConfig
+            });
+        }
+        catch (error) {
+            console.error('[Hyperstack] Failed to create runtime:', error);
+            throw error;
+        }
+    }
+    const runtime = runtimeRef.current;
+    const isMountedRef = useRef(true);
+    useEffect(() => {
+        isMountedRef.current = true;
+        if (config.autoConnect !== false) {
+            try {
+                runtime.connection.connect();
+            }
+            catch (error) {
+                console.error('[Hyperstack] Failed to auto-connect:', error);
+            }
+        }
+        return () => {
+            isMountedRef.current = false;
+            setTimeout(() => {
+                if (!isMountedRef.current) {
+                    try {
+                        runtime.connection.disconnect();
+                    }
+                    catch (error) {
+                        console.error('[Hyperstack] Failed to disconnect:', error);
+                    }
+                }
+            }, 100);
+        };
+    }, [runtime, config.autoConnect]);
+    const value = {
+        runtime,
+        config: { ...config, network: networkConfig }
+    };
+    return (React.createElement(HyperstackContext.Provider, { value: value }, children));
+}
+function useHyperstackContext() {
+    const context = useContext(HyperstackContext);
+    if (!context) {
+        throw new Error('useHyperstackContext must be used within HyperstackProvider');
+    }
+    return context;
+}
+
+function createStateViewHook(viewDef, runtime) {
+    return {
+        use: (key, options) => {
+            const [isLoading, setIsLoading] = useState(!options?.initialData);
+            const [error, setError] = useState();
+            const keyString = Object.values(key)[0];
+            const enabled = options?.enabled !== false;
+            useEffect(() => {
+                if (!enabled)
+                    return undefined;
+                try {
+                    const handle = runtime.subscribe(viewDef.view, keyString);
+                    setIsLoading(true);
+                    return () => {
+                        try {
+                            handle.unsubscribe();
+                        }
+                        catch (err) {
+                            console.error('[Hyperstack] Error unsubscribing from view:', err);
+                        }
+                    };
+                }
+                catch (err) {
+                    setError(err instanceof Error ? err : new Error('Subscription failed'));
+                    setIsLoading(false);
+                    return undefined;
+                }
+            }, [keyString, enabled]);
+            const refresh = useCallback(() => {
+                if (!enabled)
+                    return;
+                try {
+                    const handle = runtime.subscribe(viewDef.view, keyString);
+                    setIsLoading(true);
+                    setTimeout(() => {
+                        try {
+                            handle.unsubscribe();
+                        }
+                        catch (err) {
+                            console.error('[Hyperstack] Error during refresh unsubscribe:', err);
+                        }
+                    }, 0);
+                }
+                catch (err) {
+                    setError(err instanceof Error ? err : new Error('Refresh failed'));
+                    setIsLoading(false);
+                }
+            }, [keyString, enabled]);
+            const data = useSyncExternalStore((callback) => {
+                const unsubscribe = runtime.store.subscribe(() => {
+                    callback();
+                });
+                return unsubscribe;
+            }, () => {
+                const rawData = runtime.store.getState().entities.get(viewDef.view)?.get(keyString);
+                if (rawData && viewDef.transform) {
+                    try {
+                        return viewDef.transform(rawData);
+                    }
+                    catch (err) {
+                        return undefined;
+                    }
+                }
+                return rawData;
+            });
+            useEffect(() => {
+                if (data && isLoading) {
+                    setIsLoading(false);
+                }
+            }, [data, isLoading]);
+            return {
+                data: options?.initialData ?? data,
+                isLoading,
+                error,
+                refresh
+            };
+        }
+    };
+}
+function createListViewHook(viewDef, runtime) {
+    return {
+        use: (params, options) => {
+            const [isLoading, setIsLoading] = useState(!options?.initialData);
+            const [error, setError] = useState();
+            const cachedDataRef = useRef(undefined);
+            const lastMapRef = useRef(undefined);
+            const enabled = options?.enabled !== false;
+            const key = params?.key;
+            // Stabilize filters object to prevent unnecessary re-subscriptions
+            // We use a JSON string as the dependency to detect actual value changes
+            const filtersJson = params?.filters ? JSON.stringify(params.filters) : undefined;
+            const filters = useMemo(() => params?.filters, [filtersJson]);
+            useEffect(() => {
+                if (!enabled)
+                    return undefined;
+                try {
+                    const handle = runtime.subscribe(viewDef.view, key, filters);
+                    setIsLoading(true);
+                    return () => {
+                        try {
+                            handle.unsubscribe();
+                        }
+                        catch (err) {
+                            console.error('[Hyperstack] Error unsubscribing from list view:', err);
+                        }
+                    };
+                }
+                catch (err) {
+                    setError(err instanceof Error ? err : new Error('Subscription failed'));
+                    setIsLoading(false);
+                    return undefined;
+                }
+            }, [enabled, key, filtersJson]);
+            const refresh = useCallback(() => {
+                if (!enabled)
+                    return;
+                try {
+                    const handle = runtime.subscribe(viewDef.view, key, filters);
+                    setIsLoading(true);
+                    setTimeout(() => {
+                        try {
+                            handle.unsubscribe();
+                        }
+                        catch (err) {
+                            console.error('[Hyperstack] Error during list refresh unsubscribe:', err);
+                        }
+                    }, 0);
+                }
+                catch (err) {
+                    setError(err instanceof Error ? err : new Error('Refresh failed'));
+                    setIsLoading(false);
+                }
+            }, [enabled, key, filtersJson]);
+            const data = useSyncExternalStore((callback) => {
+                const unsubscribe = runtime.store.subscribe(() => {
+                    callback();
+                });
+                return unsubscribe;
+            }, () => {
+                let baseMap = runtime.store.getState().entities.get(viewDef.view);
+                if (!baseMap) {
+                    if (cachedDataRef.current !== undefined) {
+                        cachedDataRef.current = undefined;
+                        lastMapRef.current = undefined;
+                    }
+                    return undefined;
+                }
+                if (lastMapRef.current === baseMap && cachedDataRef.current !== undefined) {
+                    return cachedDataRef.current;
+                }
+                let items = Array.from(baseMap.values()).map((value) => {
+                    const item = value?.item ?? value;
+                    if (viewDef.transform) {
+                        try {
+                            return viewDef.transform(item);
+                        }
+                        catch (err) {
+                            console.log("Error transforming", err);
+                            return item;
+                        }
+                    }
+                    return item;
+                });
+                if (params?.where) {
+                    items = items.filter((item) => {
+                        return Object.entries(params.where).every(([key, condition]) => {
+                            const value = item[key];
+                            if (typeof condition === 'object' && condition !== null) {
+                                if ('gte' in condition)
+                                    return value >= condition.gte;
+                                if ('lte' in condition)
+                                    return value <= condition.lte;
+                                if ('gt' in condition)
+                                    return value > condition.gt;
+                                if ('lt' in condition)
+                                    return value < condition.lt;
+                            }
+                            return value === condition;
+                        });
+                    });
+                }
+                if (params?.limit) {
+                    items = items.slice(0, params.limit);
+                }
+                lastMapRef.current = runtime.store.getState().entities.get(viewDef.view);
+                cachedDataRef.current = items;
+                return items;
+            });
+            useEffect(() => {
+                if (data && isLoading) {
+                    setIsLoading(false);
+                }
+            }, [data, isLoading]);
+            return {
+                data: options?.initialData ?? data,
+                isLoading,
+                error,
+                refresh
+            };
+        }
+    };
+}
+
+function createTxMutationHook(runtime, transactions) {
+    return function useMutation() {
+        const [status, setStatus] = useState('idle');
+        const [error, setError] = useState();
+        const [signature, setSignature] = useState();
+        const submit = async (instructionOrTx) => {
+            setStatus('pending');
+            setError(undefined);
+            setSignature(undefined);
+            try {
+                if (!instructionOrTx) {
+                    throw new Error('Transaction instruction or transaction object is required');
+                }
+                if (!runtime.wallet) {
+                    throw new Error('Wallet not connected. Please provide a wallet adapter to HyperstackProvider.');
+                }
+                console.log('[Hyperstack] Submitting transaction:', instructionOrTx);
+                let txSignature;
+                let instructionsToRefresh = [];
+                if (Array.isArray(instructionOrTx)) {
+                    console.log('[Hyperstack] Processing multiple instructions');
+                    txSignature = await runtime.wallet.signAndSend(instructionOrTx);
+                    instructionsToRefresh = instructionOrTx.filter(inst => inst && typeof inst === 'object' && inst.instruction && inst.params !== undefined);
+                }
+                else if (typeof instructionOrTx === 'object' &&
+                    instructionOrTx.instruction &&
+                    instructionOrTx.params !== undefined) {
+                    console.log('[Hyperstack] Processing single instruction');
+                    txSignature = await runtime.wallet.signAndSend(instructionOrTx);
+                    instructionsToRefresh = [instructionOrTx];
+                }
+                else {
+                    console.log('[Hyperstack] Processing raw transaction');
+                    txSignature = await runtime.wallet.signAndSend(instructionOrTx);
+                }
+                setSignature(txSignature);
+                setStatus('success');
+                if (transactions && instructionsToRefresh.length > 0) {
+                    for (const inst of instructionsToRefresh) {
+                        const txDef = transactions[inst.instruction];
+                        if (txDef?.refresh) {
+                            for (const refreshTarget of txDef.refresh) {
+                                try {
+                                    const key = typeof refreshTarget.key === 'function'
+                                        ? refreshTarget.key(inst.params)
+                                        : refreshTarget.key;
+                                    runtime.subscribe(refreshTarget.view, key);
+                                }
+                                catch (err) {
+                                    console.error('[Hyperstack] Error refreshing view after transaction:', err);
+                                }
+                            }
+                        }
+                    }
+                }
+                return txSignature;
+            }
+            catch (err) {
+                const errorMessage = err instanceof Error ? err.message : 'Transaction failed';
+                console.error('[Hyperstack] Transaction error:', errorMessage, err);
+                setStatus('error');
+                setError(errorMessage);
+                throw err;
+            }
+        };
+        const reset = () => {
+            setStatus('idle');
+            setError(undefined);
+            setSignature(undefined);
+        };
+        return {
+            submit,
+            status,
+            error,
+            signature,
+            reset
+        };
+    };
+}
+
+function defineStack(definition) {
+    if (!definition.name) {
+        throw new Error('[Hyperstack] Stack definition must have a name');
+    }
+    if (!definition.views || typeof definition.views !== 'object') {
+        throw new Error('[Hyperstack] Stack definition must have views');
+    }
+    return definition;
+}
+function useHyperstack(stack) {
+    if (!stack) {
+        throw new Error('[Hyperstack] Stack definition is required');
+    }
+    const { runtime } = useHyperstackContext();
+    const views = {};
+    try {
+        for (const [viewName, viewGroup] of Object.entries(stack.views)) {
+            views[viewName] = {};
+            if (typeof viewGroup === 'object' && viewGroup !== null) {
+                if ('state' in viewGroup && viewGroup.state) {
+                    views[viewName].state = createStateViewHook(viewGroup.state, runtime);
+                }
+                if ('list' in viewGroup && viewGroup.list) {
+                    views[viewName].list = createListViewHook(viewGroup.list, runtime);
+                }
+            }
+        }
+    }
+    catch (err) {
+        console.error('[Hyperstack] Error creating view hooks:', err);
+        throw err;
+    }
+    const tx = {};
+    try {
+        if (stack.transactions) {
+            for (const [txName, txDef] of Object.entries(stack.transactions)) {
+                tx[txName] = txDef.build;
+            }
+        }
+        tx.useMutation = createTxMutationHook(runtime, stack.transactions);
+    }
+    catch (err) {
+        console.error('[Hyperstack] Error creating transaction hooks:', err);
+        tx.useMutation = () => ({
+            submit: async () => { },
+            status: 'idle',
+            error: 'Failed to initialize transaction hooks',
+            signature: undefined,
+            reset: () => { }
+        });
+    }
+    return {
+        views,
+        tx,
+        helpers: stack.helpers || {},
+        store: runtime.store,
+        runtime
+    };
+}
+
+function createStateView(viewPath, options) {
+    return {
+        mode: 'state',
+        view: viewPath,
+        type: {},
+        transform: options?.transform
+    };
+}
+function createListView(viewPath, options) {
+    return {
+        mode: 'list',
+        view: viewPath,
+        type: {},
+        transform: options?.transform
+    };
+}
+
+export { ConnectionManager, DEFAULT_CONFIG, HyperStreamError, HyperstackProvider, createListView, createRuntime, createStateView, defineStack, useHyperstack, useHyperstackContext };
+//# sourceMappingURL=index.esm.js.map