hyperstack-react 0.3.14 → 0.4.0

package/dist/index.js

@@ -7500,6 +7500,69 @@ function createUpdateStream(storage, subscriptionRegistry, subscription, keyFilt
         },
     };
 }
+function createEntityStream(storage, subscriptionRegistry, subscription, keyFilter) {
+    return {
+        [Symbol.asyncIterator]() {
+            const queue = [];
+            let waitingResolve = null;
+            let unsubscribeStorage = null;
+            let unsubscribeRegistry = null;
+            let done = false;
+            const handler = (viewPath, key, update) => {
+                if (viewPath !== subscription.view)
+                    return;
+                if (keyFilter !== undefined && key !== keyFilter)
+                    return;
+                if (update.type === 'deleted')
+                    return;
+                const entity = (update.type === 'created' ? update.data : update.after);
+                if (waitingResolve) {
+                    const resolve = waitingResolve;
+                    waitingResolve = null;
+                    resolve({ value: entity, done: false });
+                }
+                else {
+                    if (queue.length >= MAX_QUEUE_SIZE) {
+                        queue.shift();
+                    }
+                    queue.push(entity);
+                }
+            };
+            const start = () => {
+                unsubscribeStorage = storage.onRichUpdate(handler);
+                unsubscribeRegistry = subscriptionRegistry.subscribe(subscription);
+            };
+            const cleanup = () => {
+                done = true;
+                unsubscribeStorage?.();
+                unsubscribeRegistry?.();
+            };
+            start();
+            return {
+                async next() {
+                    if (done) {
+                        return { value: undefined, done: true };
+                    }
+                    const queued = queue.shift();
+                    if (queued) {
+                        return { value: queued, done: false };
+                    }
+                    return new Promise((resolve) => {
+                        waitingResolve = resolve;
+                    });
+                },
+                async return() {
+                    cleanup();
+                    return { value: undefined, done: true };
+                },
+                async throw(error) {
+                    cleanup();
+                    throw error;
+                },
+            };
+        },
+    };
+}
 function createRichUpdateStream(storage, subscriptionRegistry, subscription, keyFilter) {
     return {
         [Symbol.asyncIterator]() {
@@ -7567,11 +7630,14 @@ function createRichUpdateStream(storage, subscriptionRegistry, subscription, key
 
 function createTypedStateView(viewDef, storage, subscriptionRegistry) {
     return {
-        watch(key) {
-            return createUpdateStream(storage, subscriptionRegistry, { view: viewDef.view, key }, key);
+        use(key, options) {
+            return createEntityStream(storage, subscriptionRegistry, { view: viewDef.view, key, ...options }, key);
+        },
+        watch(key, options) {
+            return createUpdateStream(storage, subscriptionRegistry, { view: viewDef.view, key, ...options }, key);
         },
-        watchRich(key) {
-            return createRichUpdateStream(storage, subscriptionRegistry, { view: viewDef.view, key }, key);
+        watchRich(key, options) {
+            return createRichUpdateStream(storage, subscriptionRegistry, { view: viewDef.view, key, ...options }, key);
         },
         async get(key) {
             return storage.get(viewDef.view, key);
@@ -7583,11 +7649,14 @@ function createTypedStateView(viewDef, storage, subscriptionRegistry) {
 }
 function createTypedListView(viewDef, storage, subscriptionRegistry) {
     return {
-        watch() {
-            return createUpdateStream(storage, subscriptionRegistry, { view: viewDef.view });
+        use(options) {
+            return createEntityStream(storage, subscriptionRegistry, { view: viewDef.view, ...options });
+        },
+        watch(options) {
+            return createUpdateStream(storage, subscriptionRegistry, { view: viewDef.view, ...options });
         },
-        watchRich() {
-            return createRichUpdateStream(storage, subscriptionRegistry, { view: viewDef.view });
+        watchRich(options) {
+            return createRichUpdateStream(storage, subscriptionRegistry, { view: viewDef.view, ...options });
         },
         async get() {
             return storage.getAll(viewDef.view);
@@ -7599,20 +7668,512 @@ function createTypedListView(viewDef, storage, subscriptionRegistry) {
 }
 function createTypedViews(stack, storage, subscriptionRegistry) {
     const views = {};
-    for (const [viewName, viewGroup] of Object.entries(stack.views)) {
+    for (const [entityName, viewGroup] of Object.entries(stack.views)) {
         const group = viewGroup;
         const typedGroup = {};
-        if (group.state) {
-            typedGroup.state = createTypedStateView(group.state, storage, subscriptionRegistry);
-        }
-        if (group.list) {
-            typedGroup.list = createTypedListView(group.list, storage, subscriptionRegistry);
+        for (const [viewName, viewDef] of Object.entries(group)) {
+            if (viewDef.mode === 'state') {
+                typedGroup[viewName] = createTypedStateView(viewDef, storage, subscriptionRegistry);
+            }
+            else if (viewDef.mode === 'list') {
+                typedGroup[viewName] = createTypedListView(viewDef, storage, subscriptionRegistry);
+            }
         }
-        views[viewName] = typedGroup;
+        views[entityName] = typedGroup;
     }
     return views;
 }
 
+/**
+ * Resolves instruction accounts by categorizing and deriving addresses.
+ *
+ * @param accountMetas - Account metadata from the instruction definition
+ * @param args - Instruction arguments (used for PDA derivation)
+ * @param options - Resolution options including wallet and user-provided accounts
+ * @returns Resolved accounts and any missing required accounts
+ */
+function resolveAccounts(accountMetas, args, options) {
+    const resolved = [];
+    const missing = [];
+    for (const meta of accountMetas) {
+        const resolvedAccount = resolveSingleAccount(meta, args, options);
+        if (resolvedAccount) {
+            resolved.push(resolvedAccount);
+        }
+        else if (!meta.isOptional) {
+            missing.push(meta.name);
+        }
+    }
+    return {
+        accounts: resolved,
+        missingUserAccounts: missing,
+    };
+}
+function resolveSingleAccount(meta, args, options) {
+    switch (meta.category) {
+        case 'signer':
+            return resolveSignerAccount(meta, options.wallet);
+        case 'known':
+            return resolveKnownAccount(meta);
+        case 'pda':
+            return resolvePdaAccount(meta);
+        case 'userProvided':
+            return resolveUserProvidedAccount(meta, options.accounts);
+        default:
+            return null;
+    }
+}
+function resolveSignerAccount(meta, wallet) {
+    if (!wallet) {
+        return null;
+    }
+    return {
+        name: meta.name,
+        address: wallet.publicKey,
+        isSigner: true,
+        isWritable: meta.isWritable,
+    };
+}
+function resolveKnownAccount(meta) {
+    if (!meta.knownAddress) {
+        return null;
+    }
+    return {
+        name: meta.name,
+        address: meta.knownAddress,
+        isSigner: meta.isSigner,
+        isWritable: meta.isWritable,
+    };
+}
+function resolvePdaAccount(meta, args) {
+    if (!meta.pdaConfig) {
+        return null;
+    }
+    // PDA derivation will be implemented in pda.ts
+    // For now, return a placeholder that will be resolved later
+    return {
+        name: meta.name,
+        address: '', // Will be derived
+        isSigner: meta.isSigner,
+        isWritable: meta.isWritable,
+    };
+}
+function resolveUserProvidedAccount(meta, accounts) {
+    const address = accounts?.[meta.name];
+    if (!address) {
+        return null;
+    }
+    return {
+        name: meta.name,
+        address,
+        isSigner: meta.isSigner,
+        isWritable: meta.isWritable,
+    };
+}
+/**
+ * Validates that all required accounts are present.
+ *
+ * @param result - Account resolution result
+ * @throws Error if any required accounts are missing
+ */
+function validateAccountResolution(result) {
+    if (result.missingUserAccounts.length > 0) {
+        throw new Error(`Missing required accounts: ${result.missingUserAccounts.join(', ')}`);
+    }
+}
+
+/**
+ * Derives a Program-Derived Address (PDA) from seeds and program ID.
+ *
+ * This function implements PDA derivation using the Solana algorithm:
+ * 1. Concatenate all seeds
+ * 2. Hash with SHA-256
+ * 3. Check if result is off-curve (valid PDA)
+ *
+ * Note: This is a placeholder implementation. In production, you would use
+ * the actual Solana web3.js library's PDA derivation.
+ *
+ * @param seeds - Array of seed buffers
+ * @param programId - The program ID (as base58 string)
+ * @returns The derived PDA address (base58 string)
+ */
+async function derivePda(seeds, programId) {
+    // In production, this would use:
+    // PublicKey.findProgramAddressSync(seeds, new PublicKey(programId))
+    // For now, return a placeholder that will be replaced with actual implementation
+    const combined = Buffer.concat(seeds);
+    // Simulate PDA derivation (this is NOT the actual algorithm)
+    const hash = await simulateHash(combined);
+    // Return base58-encoded address
+    return bs58Encode(hash);
+}
+/**
+ * Creates a seed buffer from various input types.
+ *
+ * @param value - The value to convert to a seed
+ * @returns Buffer suitable for PDA derivation
+ */
+function createSeed(value) {
+    if (Buffer.isBuffer(value)) {
+        return value;
+    }
+    if (value instanceof Uint8Array) {
+        return Buffer.from(value);
+    }
+    if (typeof value === 'string') {
+        return Buffer.from(value, 'utf-8');
+    }
+    if (typeof value === 'bigint') {
+        // Convert bigint to 8-byte buffer (u64)
+        const buffer = Buffer.alloc(8);
+        buffer.writeBigUInt64LE(value);
+        return buffer;
+    }
+    throw new Error(`Cannot create seed from type: ${typeof value}`);
+}
+/**
+ * Creates a public key seed from a base58-encoded address.
+ *
+ * @param address - Base58-encoded public key
+ * @returns 32-byte buffer
+ */
+function createPublicKeySeed(address) {
+    // In production, decode base58 to 32-byte buffer
+    // For now, return placeholder
+    return Buffer.alloc(32);
+}
+async function simulateHash(data) {
+    // In production, use actual SHA-256
+    // This is a placeholder
+    if (typeof crypto !== 'undefined' && crypto.subtle) {
+        const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+        return Buffer.from(hashBuffer);
+    }
+    // Fallback for Node.js
+    return Buffer.alloc(32, 0);
+}
+function bs58Encode(buffer) {
+    // In production, use actual base58 encoding
+    // This is a placeholder
+    return 'P' + buffer.toString('hex').slice(0, 31);
+}
+
+/**
+ * Borsh-compatible instruction data serializer.
+ *
+ * This module handles serializing instruction arguments into the binary format
+ * expected by Solana programs using Borsh serialization.
+ */
+/**
+ * Serializes instruction arguments into a Buffer using Borsh encoding.
+ *
+ * @param discriminator - The 8-byte instruction discriminator
+ * @param args - Arguments to serialize
+ * @param schema - Schema defining argument types
+ * @returns Serialized instruction data
+ */
+function serializeInstructionData(discriminator, args, schema) {
+    const buffers = [Buffer.from(discriminator)];
+    for (const field of schema) {
+        const value = args[field.name];
+        const serialized = serializeValue(value, field.type);
+        buffers.push(serialized);
+    }
+    return Buffer.concat(buffers);
+}
+function serializeValue(value, type) {
+    if (typeof type === 'string') {
+        return serializePrimitive(value, type);
+    }
+    if ('vec' in type) {
+        return serializeVec(value, type.vec);
+    }
+    if ('option' in type) {
+        return serializeOption(value, type.option);
+    }
+    if ('array' in type) {
+        return serializeArray(value, type.array[0], type.array[1]);
+    }
+    throw new Error(`Unknown type: ${JSON.stringify(type)}`);
+}
+function serializePrimitive(value, type) {
+    switch (type) {
+        case 'u8':
+            return Buffer.from([value]);
+        case 'u16':
+            const u16 = Buffer.alloc(2);
+            u16.writeUInt16LE(value, 0);
+            return u16;
+        case 'u32':
+            const u32 = Buffer.alloc(4);
+            u32.writeUInt32LE(value, 0);
+            return u32;
+        case 'u64':
+            const u64 = Buffer.alloc(8);
+            u64.writeBigUInt64LE(BigInt(value), 0);
+            return u64;
+        case 'u128':
+            // u128 is 16 bytes, little-endian
+            const u128 = Buffer.alloc(16);
+            const bigU128 = BigInt(value);
+            u128.writeBigUInt64LE(bigU128 & BigInt('0xFFFFFFFFFFFFFFFF'), 0);
+            u128.writeBigUInt64LE(bigU128 >> BigInt(64), 8);
+            return u128;
+        case 'i8':
+            return Buffer.from([value]);
+        case 'i16':
+            const i16 = Buffer.alloc(2);
+            i16.writeInt16LE(value, 0);
+            return i16;
+        case 'i32':
+            const i32 = Buffer.alloc(4);
+            i32.writeInt32LE(value, 0);
+            return i32;
+        case 'i64':
+            const i64 = Buffer.alloc(8);
+            i64.writeBigInt64LE(BigInt(value), 0);
+            return i64;
+        case 'i128':
+            const i128 = Buffer.alloc(16);
+            const bigI128 = BigInt(value);
+            i128.writeBigInt64LE(bigI128 & BigInt('0xFFFFFFFFFFFFFFFF'), 0);
+            i128.writeBigInt64LE(bigI128 >> BigInt(64), 8);
+            return i128;
+        case 'bool':
+            return Buffer.from([value ? 1 : 0]);
+        case 'string':
+            const str = value;
+            const strBytes = Buffer.from(str, 'utf-8');
+            const strLen = Buffer.alloc(4);
+            strLen.writeUInt32LE(strBytes.length, 0);
+            return Buffer.concat([strLen, strBytes]);
+        case 'pubkey':
+            // In production, decode base58 to 32 bytes
+            return Buffer.alloc(32, 0);
+        default:
+            throw new Error(`Unknown primitive type: ${type}`);
+    }
+}
+function serializeVec(values, elementType) {
+    const len = Buffer.alloc(4);
+    len.writeUInt32LE(values.length, 0);
+    const elementBuffers = values.map(v => serializeValue(v, elementType));
+    return Buffer.concat([len, ...elementBuffers]);
+}
+function serializeOption(value, innerType) {
+    if (value === null || value === undefined) {
+        return Buffer.from([0]); // None
+    }
+    const inner = serializeValue(value, innerType);
+    return Buffer.concat([Buffer.from([1]), inner]); // Some
+}
+function serializeArray(values, elementType, length) {
+    if (values.length !== length) {
+        throw new Error(`Array length mismatch: expected ${length}, got ${values.length}`);
+    }
+    const elementBuffers = values.map(v => serializeValue(v, elementType));
+    return Buffer.concat(elementBuffers);
+}
+
+/**
+ * Waits for transaction confirmation.
+ *
+ * @param signature - Transaction signature
+ * @param level - Desired confirmation level
+ * @param timeout - Maximum wait time in milliseconds
+ * @returns Confirmation result
+ */
+async function waitForConfirmation(signature, level = 'confirmed', timeout = 60000) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+        const status = await checkTransactionStatus();
+        if (status.err) {
+            throw new Error(`Transaction failed: ${JSON.stringify(status.err)}`);
+        }
+        if (isConfirmationLevelSufficient(status.confirmations, level)) {
+            return {
+                level,
+                slot: status.slot,
+            };
+        }
+        await sleep(1000);
+    }
+    throw new Error(`Transaction confirmation timeout after ${timeout}ms`);
+}
+async function checkTransactionStatus(signature) {
+    // In production, query the Solana RPC
+    return {
+        err: null,
+        confirmations: 32,
+        slot: 123456789,
+    };
+}
+function isConfirmationLevelSufficient(confirmations, level) {
+    if (confirmations === null) {
+        return false;
+    }
+    switch (level) {
+        case 'processed':
+            return confirmations >= 0;
+        case 'confirmed':
+            return confirmations >= 1;
+        case 'finalized':
+            return confirmations >= 32;
+        default:
+            return false;
+    }
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Parses and handles instruction errors.
+ */
+/**
+ * Parses an error returned from a Solana transaction.
+ *
+ * @param error - The error from the transaction
+ * @param errorMetadata - Error definitions from the IDL
+ * @returns Parsed program error or null if not a program error
+ */
+function parseInstructionError(error, errorMetadata) {
+    if (!error) {
+        return null;
+    }
+    const errorCode = extractErrorCode(error);
+    if (errorCode === null) {
+        return null;
+    }
+    const metadata = errorMetadata.find(e => e.code === errorCode);
+    if (metadata) {
+        return {
+            code: metadata.code,
+            name: metadata.name,
+            message: metadata.msg,
+        };
+    }
+    return {
+        code: errorCode,
+        name: `CustomError${errorCode}`,
+        message: `Unknown error with code ${errorCode}`,
+    };
+}
+function extractErrorCode(error) {
+    if (typeof error !== 'object' || error === null) {
+        return null;
+    }
+    const errorObj = error;
+    // Check for InstructionError format
+    if (errorObj.InstructionError) {
+        const instructionError = errorObj.InstructionError;
+        if (instructionError[1]?.Custom !== undefined) {
+            return instructionError[1].Custom;
+        }
+    }
+    // Check for direct code
+    if (typeof errorObj.code === 'number') {
+        return errorObj.code;
+    }
+    return null;
+}
+/**
+ * Formats an error for display.
+ *
+ * @param error - The program error
+ * @returns Human-readable error message
+ */
+function formatProgramError(error) {
+    return `${error.name} (${error.code}): ${error.message}`;
+}
+
+/**
+ * Converts resolved account array to a map for the builder.
+ */
+function toResolvedAccountsMap(accounts) {
+    const map = {};
+    for (const account of accounts) {
+        map[account.name] = account.address;
+    }
+    return map;
+}
+/**
+ * Executes an instruction handler with the given arguments and options.
+ *
+ * This is the main function for executing Solana instructions. It handles:
+ * 1. Account resolution (signer, PDA, user-provided)
+ * 2. Calling the generated build() function
+ * 3. Transaction signing and sending
+ * 4. Confirmation waiting
+ *
+ * @param handler - Instruction handler from generated SDK
+ * @param args - Instruction arguments
+ * @param options - Execution options
+ * @returns Execution result with signature
+ */
+async function executeInstruction(handler, args, options = {}) {
+    // Step 1: Resolve accounts using handler's account metadata
+    const resolutionOptions = {
+        accounts: options.accounts,
+        wallet: options.wallet,
+    };
+    const resolution = resolveAccounts(handler.accounts, args, resolutionOptions);
+    validateAccountResolution(resolution);
+    // Step 2: Call generated build() function
+    const resolvedAccountsMap = toResolvedAccountsMap(resolution.accounts);
+    const instruction = handler.build(args, resolvedAccountsMap);
+    // Step 3: Build transaction from the built instruction
+    const transaction = buildTransaction(instruction);
+    // Step 4: Sign and send
+    if (!options.wallet) {
+        throw new Error('Wallet required to sign transaction');
+    }
+    const signature = await options.wallet.signAndSend(transaction);
+    // Step 5: Wait for confirmation
+    const confirmationLevel = options.confirmationLevel ?? 'confirmed';
+    const timeout = options.timeout ?? 60000;
+    const confirmation = await waitForConfirmation(signature, confirmationLevel, timeout);
+    return {
+        signature,
+        confirmationLevel: confirmation.level,
+        slot: confirmation.slot,
+    };
+}
+/**
+ * Creates a transaction object from a built instruction.
+ *
+ * @param instruction - Built instruction from handler
+ * @returns Transaction object ready for signing
+ */
+function buildTransaction(instruction) {
+    // This returns a framework-agnostic transaction representation.
+    // The wallet adapter is responsible for converting this to the
+    // appropriate format (@solana/web3.js Transaction, etc.)
+    return {
+        instructions: [{
+                programId: instruction.programId,
+                keys: instruction.keys,
+                data: Array.from(instruction.data),
+            }],
+    };
+}
+/**
+ * Creates an instruction executor bound to a specific wallet.
+ *
+ * @param wallet - Wallet adapter
+ * @returns Bound executor function
+ */
+function createInstructionExecutor(wallet) {
+    return {
+        execute: async (handler, args, options) => {
+            return executeInstruction(handler, args, {
+                ...options,
+                wallet,
+            });
+        },
+    };
+}
+
 class HyperStack {
     constructor(url, options) {
         this.stack = options.stack;
@@ -7630,16 +8191,34 @@ class HyperStack {
             this.processor.handleFrame(frame);
         });
         this._views = createTypedViews(this.stack, this.storage, this.subscriptionRegistry);
+        this._instructions = this.buildInstructions();
+    }
+    buildInstructions() {
+        const instructions = {};
+        if (this.stack.instructions) {
+            for (const [name, handler] of Object.entries(this.stack.instructions)) {
+                instructions[name] = (args, options) => {
+                    return executeInstruction(handler, args, options);
+                };
+            }
+        }
+        return instructions;
     }
-    static async connect(url, options) {
+    static async connect(stack, options) {
+        const url = options?.url ?? stack.url;
         if (!url) {
-            throw new HyperStackError('URL is required', 'INVALID_CONFIG');
-        }
-        if (!options.stack) {
-            throw new HyperStackError('Stack definition is required', 'INVALID_CONFIG');
-        }
-        const client = new HyperStack(url, options);
-        if (options.autoReconnect !== false) {
+            throw new HyperStackError('URL is required (provide url option or define url in stack)', 'INVALID_CONFIG');
+        }
+        const internalOptions = {
+            stack,
+            storage: options?.storage,
+            maxEntriesPerView: options?.maxEntriesPerView,
+            autoReconnect: options?.autoReconnect,
+            reconnectIntervals: options?.reconnectIntervals,
+            maxReconnectAttempts: options?.maxReconnectAttempts,
+        };
+        const client = new HyperStack(url, internalOptions);
+        if (options?.autoReconnect !== false) {
             await client.connection.connect();
         }
         return client;
@@ -7647,6 +8226,9 @@ class HyperStack {
     get views() {
         return this._views;
     }
+    get instructions() {
+        return this._instructions;
+    }
     get connectionState() {
         return this.connection.getState();
     }
@@ -7686,6 +8268,469 @@ class HyperStack {
     }
 }
 
+const HyperstackContext = React.createContext(null);
+function HyperstackProvider({ children, fallback = null, ...config }) {
+    const clientsRef = React.useRef(new Map());
+    const connectingRef = React.useRef(new Map());
+    const getOrCreateClient = React.useCallback(async (stack, urlOverride) => {
+        const cacheKey = urlOverride ? `${stack.name}:${urlOverride}` : stack.name;
+        const existing = clientsRef.current.get(cacheKey);
+        if (existing) {
+            return existing.client;
+        }
+        const connecting = connectingRef.current.get(cacheKey);
+        if (connecting) {
+            return connecting;
+        }
+        const connectionPromise = HyperStack.connect(stack, {
+            url: urlOverride,
+            autoReconnect: config.autoConnect,
+            reconnectIntervals: config.reconnectIntervals,
+            maxReconnectAttempts: config.maxReconnectAttempts,
+            maxEntriesPerView: config.maxEntriesPerView,
+        }).then((client) => {
+            clientsRef.current.set(cacheKey, {
+                client,
+                disconnect: () => client.disconnect()
+            });
+            connectingRef.current.delete(cacheKey);
+            return client;
+        });
+        connectingRef.current.set(cacheKey, connectionPromise);
+        return connectionPromise;
+    }, [config.autoConnect, config.reconnectIntervals, config.maxReconnectAttempts, config.maxEntriesPerView]);
+    const getClient = React.useCallback((stack) => {
+        if (!stack)
+            return null;
+        const entry = clientsRef.current.get(stack.name);
+        return entry ? entry.client : null;
+    }, []);
+    React.useEffect(() => {
+        return () => {
+            clientsRef.current.forEach((entry) => {
+                entry.disconnect();
+            });
+            clientsRef.current.clear();
+            connectingRef.current.clear();
+        };
+    }, []);
+    const value = {
+        getOrCreateClient,
+        getClient,
+        config,
+    };
+    return (React.createElement(HyperstackContext.Provider, { value: value }, children));
+}
+function useHyperstackContext() {
+    const context = React.useContext(HyperstackContext);
+    if (!context) {
+        throw new Error('useHyperstackContext must be used within HyperstackProvider');
+    }
+    return context;
+}
+function useConnectionState(stack) {
+    const { getClient } = useHyperstackContext();
+    const client = stack ? getClient(stack) : null;
+    return React.useSyncExternalStore((callback) => {
+        if (!client)
+            return () => { };
+        return client.onConnectionStateChange(callback);
+    }, () => client?.connectionState ?? 'disconnected');
+}
+function useView(stack, viewPath) {
+    const { getClient } = useHyperstackContext();
+    const client = getClient(stack);
+    return React.useSyncExternalStore((callback) => {
+        if (!client)
+            return () => { };
+        return client.store.onUpdate(callback);
+    }, () => {
+        if (!client)
+            return [];
+        const data = client.store.getAll(viewPath);
+        return data;
+    });
+}
+function useEntity(stack, viewPath, key) {
+    const { getClient } = useHyperstackContext();
+    const client = getClient(stack);
+    return React.useSyncExternalStore((callback) => {
+        if (!client)
+            return () => { };
+        return client.store.onUpdate(callback);
+    }, () => {
+        if (!client)
+            return null;
+        const data = client.store.get(viewPath, key);
+        return data;
+    });
+}
+
+function shallowArrayEqual(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
+function useStateView(viewDef, client, key, options) {
+    const [isLoading, setIsLoading] = React.useState(!options?.initialData);
+    const [error, setError] = React.useState();
+    const clientRef = React.useRef(client);
+    clientRef.current = client;
+    const cachedSnapshotRef = React.useRef(undefined);
+    const keyString = key ? Object.values(key)[0] : undefined;
+    const enabled = options?.enabled !== false;
+    React.useEffect(() => {
+        if (!enabled || !clientRef.current)
+            return undefined;
+        try {
+            const registry = clientRef.current.getSubscriptionRegistry();
+            const unsubscribe = registry.subscribe({ view: viewDef.view, key: keyString });
+            setIsLoading(true);
+            return () => {
+                try {
+                    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;
+        }
+    }, [viewDef.view, keyString, enabled, client]);
+    const refresh = React.useCallback(() => {
+        if (!enabled || !clientRef.current)
+            return;
+        try {
+            const registry = clientRef.current.getSubscriptionRegistry();
+            const unsubscribe = registry.subscribe({ view: viewDef.view, key: keyString });
+            setIsLoading(true);
+            setTimeout(() => {
+                try {
+                    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);
+        }
+    }, [viewDef.view, keyString, enabled]);
+    const subscribe = React.useCallback((callback) => {
+        if (!clientRef.current)
+            return () => { };
+        return clientRef.current.store.onUpdate(callback);
+    }, [client]);
+    const getSnapshot = React.useCallback(() => {
+        if (!clientRef.current)
+            return cachedSnapshotRef.current;
+        const entity = keyString
+            ? clientRef.current.store.get(viewDef.view, keyString)
+            : clientRef.current.store.getAll(viewDef.view)[0];
+        // Cache the result to return stable reference for useSyncExternalStore
+        if (entity !== cachedSnapshotRef.current) {
+            cachedSnapshotRef.current = entity;
+        }
+        return cachedSnapshotRef.current;
+    }, [viewDef.view, keyString, client]);
+    const data = React.useSyncExternalStore(subscribe, getSnapshot);
+    React.useEffect(() => {
+        if (data !== undefined && isLoading) {
+            setIsLoading(false);
+        }
+    }, [data, isLoading]);
+    return {
+        data: (options?.initialData ?? data),
+        isLoading: client === null || isLoading,
+        error,
+        refresh
+    };
+}
+function useListView(viewDef, client, params, options) {
+    const [isLoading, setIsLoading] = React.useState(!options?.initialData);
+    const [error, setError] = React.useState();
+    const clientRef = React.useRef(client);
+    clientRef.current = client;
+    const cachedSnapshotRef = React.useRef(undefined);
+    const enabled = options?.enabled !== false;
+    const key = params?.key;
+    const take = params?.take;
+    const skip = params?.skip;
+    const whereJson = params?.where ? JSON.stringify(params.where) : undefined;
+    const filtersJson = params?.filters ? JSON.stringify(params.filters) : undefined;
+    const limit = params?.limit;
+    React.useEffect(() => {
+        if (!enabled || !clientRef.current)
+            return undefined;
+        try {
+            const registry = clientRef.current.getSubscriptionRegistry();
+            const unsubscribe = registry.subscribe({
+                view: viewDef.view,
+                key,
+                filters: params?.filters,
+                take,
+                skip
+            });
+            setIsLoading(true);
+            return () => {
+                try {
+                    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;
+        }
+    }, [viewDef.view, enabled, key, filtersJson, take, skip, client]);
+    const refresh = React.useCallback(() => {
+        if (!enabled || !clientRef.current)
+            return;
+        try {
+            const registry = clientRef.current.getSubscriptionRegistry();
+            const unsubscribe = registry.subscribe({
+                view: viewDef.view,
+                key,
+                filters: params?.filters,
+                take,
+                skip
+            });
+            setIsLoading(true);
+            setTimeout(() => {
+                try {
+                    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);
+        }
+    }, [viewDef.view, enabled, key, filtersJson, take, skip]);
+    const subscribe = React.useCallback((callback) => {
+        if (!clientRef.current)
+            return () => { };
+        return clientRef.current.store.onUpdate(callback);
+    }, [client]);
+    const getSnapshot = React.useCallback(() => {
+        if (!clientRef.current)
+            return cachedSnapshotRef.current;
+        const viewData = clientRef.current.store.getAll(viewDef.view);
+        if (!viewData || viewData.length === 0) {
+            if (cachedSnapshotRef.current !== undefined) {
+                cachedSnapshotRef.current = undefined;
+            }
+            return cachedSnapshotRef.current;
+        }
+        let items = viewData;
+        if (params?.where) {
+            items = items.filter((item) => {
+                return Object.entries(params.where).every(([fieldKey, condition]) => {
+                    const value = item[fieldKey];
+                    if (typeof condition === 'object' && condition !== null) {
+                        const cond = condition;
+                        if ('gte' in cond)
+                            return value >= cond.gte;
+                        if ('lte' in cond)
+                            return value <= cond.lte;
+                        if ('gt' in cond)
+                            return value > cond.gt;
+                        if ('lt' in cond)
+                            return value < cond.lt;
+                    }
+                    return value === condition;
+                });
+            });
+        }
+        if (limit) {
+            items = items.slice(0, limit);
+        }
+        const result = items;
+        // Cache the result - only update if data actually changed
+        if (!shallowArrayEqual(cachedSnapshotRef.current, result)) {
+            cachedSnapshotRef.current = result;
+        }
+        return cachedSnapshotRef.current;
+    }, [viewDef.view, whereJson, limit, client]);
+    const data = React.useSyncExternalStore(subscribe, getSnapshot);
+    React.useEffect(() => {
+        if (data !== undefined && isLoading) {
+            setIsLoading(false);
+        }
+    }, [data, isLoading]);
+    return {
+        data: (options?.initialData ?? data),
+        isLoading: client === null || isLoading,
+        error,
+        refresh
+    };
+}
+function createStateViewHook(viewDef, client) {
+    return {
+        use: (key, options) => {
+            return useStateView(viewDef, client, key, options);
+        }
+    };
+}
+function createListViewHook(viewDef, client) {
+    function use(params, options) {
+        const result = useListView(viewDef, client, params, options);
+        if (params?.take === 1) {
+            return {
+                data: result.data?.[0],
+                isLoading: result.isLoading,
+                error: result.error,
+                refresh: result.refresh
+            };
+        }
+        return result;
+    }
+    function useOne(params, options) {
+        const paramsWithTake = params ? { ...params, take: 1 } : { take: 1 };
+        const result = useListView(viewDef, client, paramsWithTake, options);
+        return {
+            data: result.data?.[0],
+            isLoading: result.isLoading,
+            error: result.error,
+            refresh: result.refresh
+        };
+    }
+    return { use, useOne };
+}
+
+function useInstructionMutation(execute) {
+    const [status, setStatus] = React.useState('idle');
+    const [error, setError] = React.useState(null);
+    const [signature, setSignature] = React.useState(null);
+    const submit = React.useCallback(async (args, options) => {
+        setStatus('pending');
+        setError(null);
+        setSignature(null);
+        try {
+            const result = await execute(args, options);
+            setStatus('success');
+            setSignature(result.signature);
+            if (options?.onSuccess) {
+                options.onSuccess(result);
+            }
+            return result;
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            const programError = parseInstructionError(err, []);
+            const displayError = programError
+                ? `${programError.name}: ${programError.message}`
+                : errorMessage;
+            setStatus('error');
+            setError(displayError);
+            if (options?.onError && err instanceof Error) {
+                options.onError(err);
+            }
+            throw err;
+        }
+    }, [execute]);
+    const reset = React.useCallback(() => {
+        setStatus('idle');
+        setError(null);
+        setSignature(null);
+    }, []);
+    return {
+        submit,
+        status,
+        error,
+        signature,
+        isLoading: status === 'pending',
+        reset,
+    };
+}
+
+function useHyperstack(stack, options) {
+    const { getOrCreateClient, getClient } = useHyperstackContext();
+    const urlOverride = options?.url;
+    const [client, setClient] = React.useState(getClient(stack));
+    const [isLoading, setIsLoading] = React.useState(!client);
+    const [error, setError] = React.useState(null);
+    React.useEffect(() => {
+        const existingClient = getClient(stack);
+        if (existingClient && !urlOverride) {
+            setClient(existingClient);
+            setIsLoading(false);
+            return;
+        }
+        setIsLoading(true);
+        setError(null);
+        getOrCreateClient(stack, urlOverride)
+            .then((newClient) => {
+            setClient(newClient);
+            setIsLoading(false);
+        })
+            .catch((err) => {
+            setError(err instanceof Error ? err : new Error(String(err)));
+            setIsLoading(false);
+        });
+    }, [stack, getOrCreateClient, getClient, urlOverride]);
+    const views = React.useMemo(() => {
+        const result = {};
+        for (const [viewName, viewGroup] of Object.entries(stack.views)) {
+            result[viewName] = {};
+            if (typeof viewGroup === 'object' && viewGroup !== null) {
+                for (const [subViewName, viewDef] of Object.entries(viewGroup)) {
+                    if (!viewDef || typeof viewDef !== 'object' || !('mode' in viewDef))
+                        continue;
+                    if (viewDef.mode === 'state') {
+                        result[viewName][subViewName] = createStateViewHook(viewDef, client);
+                    }
+                    else if (viewDef.mode === 'list') {
+                        result[viewName][subViewName] = createListViewHook(viewDef, client);
+                    }
+                }
+            }
+        }
+        return result;
+    }, [stack, client]);
+    const instructions = React.useMemo(() => {
+        const result = {};
+        if (client?.instructions) {
+            for (const [instructionName, executeFn] of Object.entries(client.instructions)) {
+                result[instructionName] = {
+                    execute: executeFn,
+                    useMutation: () => useInstructionMutation(executeFn)
+                };
+            }
+        }
+        return result;
+    }, [client]);
+    return {
+        views: views,
+        instructions: instructions,
+        zustandStore: client?.store,
+        client: client,
+        isLoading,
+        error
+    };
+}
+
 function getNestedValue(obj, path) {
     let current = obj;
     for (const segment of path) {
@@ -7981,503 +9026,6 @@ class ZustandAdapter {
     }
 }
 
-const DEFAULT_FLUSH_INTERVAL_MS = 16;
-
-function createRuntime(config) {
-    const adapter = new ZustandAdapter();
-    const processor = new FrameProcessor(adapter, {
-        maxEntriesPerView: config.maxEntriesPerView,
-        flushIntervalMs: config.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS,
-    });
-    const connection = new ConnectionManager({
-        websocketUrl: config.websocketUrl,
-        reconnectIntervals: config.reconnectIntervals,
-        maxReconnectAttempts: config.maxReconnectAttempts,
-    });
-    const subscriptionRegistry = new SubscriptionRegistry(connection);
-    connection.onFrame((frame) => {
-        processor.handleFrame(frame);
-    });
-    connection.onStateChange((state, error) => {
-        adapter.setConnectionState(state, error);
-    });
-    return {
-        zustandStore: adapter.store,
-        adapter,
-        connection,
-        subscriptionRegistry,
-        wallet: config.wallet,
-        subscribe(view, key, filters, take, skip) {
-            const subscription = { view, key, filters, take, skip };
-            const unsubscribe = subscriptionRegistry.subscribe(subscription);
-            return {
-                view,
-                key,
-                filters,
-                take,
-                skip,
-                unsubscribe,
-            };
-        },
-        unsubscribe(handle) {
-            handle.unsubscribe();
-        },
-    };
-}
-
-const HyperstackContext = React.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 = React.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 = React.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 = React.useRef(true);
-    React.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.subscriptionRegistry.clear();
-                        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 = React.useContext(HyperstackContext);
-    if (!context) {
-        throw new Error('useHyperstackContext must be used within HyperstackProvider');
-    }
-    return context;
-}
-function useConnectionState() {
-    const { runtime } = useHyperstackContext();
-    return React.useSyncExternalStore((callback) => {
-        const unsubscribe = runtime.zustandStore.subscribe(callback);
-        return unsubscribe;
-    }, () => runtime.zustandStore.getState().connectionState);
-}
-function useView(viewPath) {
-    const { runtime } = useHyperstackContext();
-    return React.useSyncExternalStore((callback) => runtime.zustandStore.subscribe(callback), () => {
-        const viewMap = runtime.zustandStore.getState().entities.get(viewPath);
-        if (!viewMap)
-            return [];
-        return Array.from(viewMap.values());
-    });
-}
-function useEntity(viewPath, key) {
-    const { runtime } = useHyperstackContext();
-    return React.useSyncExternalStore((callback) => runtime.zustandStore.subscribe(callback), () => {
-        const viewMap = runtime.zustandStore.getState().entities.get(viewPath);
-        if (!viewMap)
-            return null;
-        const value = viewMap.get(key);
-        return value !== undefined ? value : null;
-    });
-}
-
-function createStateViewHook(viewDef, runtime) {
-    return {
-        use: (key, options) => {
-            const [isLoading, setIsLoading] = React.useState(!options?.initialData);
-            const [error, setError] = React.useState();
-            const keyString = key ? Object.values(key)[0] : undefined;
-            const enabled = options?.enabled !== false;
-            React.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 = React.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 = React.useSyncExternalStore((callback) => {
-                const unsubscribe = runtime.zustandStore.subscribe(callback);
-                return unsubscribe;
-            }, () => {
-                const viewMap = runtime.zustandStore.getState().entities.get(viewDef.view);
-                if (!viewMap)
-                    return undefined;
-                if (keyString) {
-                    return viewMap.get(keyString);
-                }
-                const firstEntry = viewMap.values().next();
-                return firstEntry.done ? undefined : firstEntry.value;
-            });
-            React.useEffect(() => {
-                if (data && isLoading) {
-                    setIsLoading(false);
-                }
-            }, [data, isLoading]);
-            return {
-                data: (options?.initialData ?? data),
-                isLoading,
-                error,
-                refresh
-            };
-        }
-    };
-}
-function useListViewInternal(viewDef, runtime, params, options) {
-    const [isLoading, setIsLoading] = React.useState(!options?.initialData);
-    const [error, setError] = React.useState();
-    const cachedDataRef = React.useRef(undefined);
-    const lastMapRef = React.useRef(undefined);
-    const lastSortedKeysRef = React.useRef(undefined);
-    const enabled = options?.enabled !== false;
-    const key = params?.key;
-    const take = params?.take;
-    const skip = params?.skip;
-    const filtersJson = params?.filters ? JSON.stringify(params.filters) : undefined;
-    const filters = React.useMemo(() => params?.filters, [filtersJson]);
-    React.useEffect(() => {
-        if (!enabled)
-            return undefined;
-        try {
-            const handle = runtime.subscribe(viewDef.view, key, filters, take, skip);
-            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, take, skip]);
-    const refresh = React.useCallback(() => {
-        if (!enabled)
-            return;
-        try {
-            const handle = runtime.subscribe(viewDef.view, key, filters, take, skip);
-            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, take, skip]);
-    const data = React.useSyncExternalStore((callback) => {
-        const unsubscribe = runtime.zustandStore.subscribe(callback);
-        return unsubscribe;
-    }, () => {
-        const state = runtime.zustandStore.getState();
-        const baseMap = state.entities.get(viewDef.view);
-        const sortedKeys = state.sortedKeys.get(viewDef.view);
-        if (!baseMap) {
-            if (cachedDataRef.current !== undefined) {
-                cachedDataRef.current = undefined;
-                lastMapRef.current = undefined;
-                lastSortedKeysRef.current = undefined;
-            }
-            return undefined;
-        }
-        if (lastMapRef.current === baseMap && lastSortedKeysRef.current === sortedKeys && cachedDataRef.current !== undefined) {
-            return cachedDataRef.current;
-        }
-        let items;
-        if (sortedKeys && sortedKeys.length > 0) {
-            items = sortedKeys.map(k => baseMap.get(k)).filter(v => v !== undefined);
-        }
-        else {
-            items = Array.from(baseMap.values());
-        }
-        if (params?.where) {
-            items = items.filter((item) => {
-                return Object.entries(params.where).every(([fieldKey, condition]) => {
-                    const value = item[fieldKey];
-                    if (typeof condition === 'object' && condition !== null) {
-                        const cond = condition;
-                        if ('gte' in cond)
-                            return value >= cond.gte;
-                        if ('lte' in cond)
-                            return value <= cond.lte;
-                        if ('gt' in cond)
-                            return value > cond.gt;
-                        if ('lt' in cond)
-                            return value < cond.lt;
-                    }
-                    return value === condition;
-                });
-            });
-        }
-        if (params?.limit) {
-            items = items.slice(0, params.limit);
-        }
-        lastMapRef.current = baseMap;
-        lastSortedKeysRef.current = sortedKeys;
-        cachedDataRef.current = items;
-        return items;
-    });
-    React.useEffect(() => {
-        if (data && isLoading) {
-            setIsLoading(false);
-        }
-    }, [data, isLoading]);
-    return {
-        data: (options?.initialData ?? data),
-        isLoading,
-        error,
-        refresh
-    };
-}
-function createListViewHook(viewDef, runtime) {
-    function use(params, options) {
-        const result = useListViewInternal(viewDef, runtime, params, options);
-        if (params?.take === 1) {
-            return {
-                data: result.data?.[0],
-                isLoading: result.isLoading,
-                error: result.error,
-                refresh: result.refresh
-            };
-        }
-        return result;
-    }
-    function useOne(params, options) {
-        const paramsWithTake = params ? { ...params, take: 1 } : { take: 1 };
-        const result = useListViewInternal(viewDef, runtime, paramsWithTake, options);
-        return {
-            data: result.data?.[0],
-            isLoading: result.isLoading,
-            error: result.error,
-            refresh: result.refresh
-        };
-    }
-    return { use, useOne };
-}
-
-function createTxMutationHook(runtime, transactions) {
-    return function useMutation() {
-        const [status, setStatus] = React.useState('idle');
-        const [error, setError] = React.useState();
-        const [signature, setSignature] = React.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.');
-                }
-                let txSignature;
-                let instructionsToRefresh = [];
-                if (Array.isArray(instructionOrTx)) {
-                    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) {
-                    txSignature = await runtime.wallet.signAndSend(instructionOrTx);
-                    instructionsToRefresh = [instructionOrTx];
-                }
-                else {
-                    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 useHyperstack(stack) {
-    if (!stack) {
-        throw new Error('[Hyperstack] Stack definition is required');
-    }
-    const { runtime } = useHyperstackContext();
-    const views = {};
-    for (const [viewName, viewGroup] of Object.entries(stack.views)) {
-        views[viewName] = {};
-        if (typeof viewGroup === 'object' && viewGroup !== null) {
-            const group = viewGroup;
-            for (const [subViewName, viewDef] of Object.entries(group)) {
-                if (!viewDef || typeof viewDef !== 'object' || !('mode' in viewDef))
-                    continue;
-                if (viewDef.mode === 'state') {
-                    views[viewName][subViewName] = createStateViewHook(viewDef, runtime);
-                }
-                else if (viewDef.mode === 'list') {
-                    views[viewName][subViewName] = createListViewHook(viewDef, runtime);
-                }
-            }
-        }
-    }
-    const tx = {};
-    if (stack.transactions) {
-        for (const [txName, txDef] of Object.entries(stack.transactions)) {
-            tx[txName] = txDef.build;
-        }
-    }
-    tx.useMutation = createTxMutationHook(runtime, stack.transactions);
-    return {
-        views,
-        tx,
-        zustandStore: runtime.zustandStore,
-        runtime
-    };
-}
-
 exports.ConnectionManager = ConnectionManager;
 exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
 exports.DEFAULT_MAX_ENTRIES_PER_VIEW = DEFAULT_MAX_ENTRIES_PER_VIEW;
@@ -8488,14 +9036,25 @@ exports.HyperstackProvider = HyperstackProvider;
 exports.MemoryAdapter = MemoryAdapter;
 exports.SubscriptionRegistry = SubscriptionRegistry;
 exports.ZustandAdapter = ZustandAdapter;
-exports.createRuntime = createRuntime;
+exports.createInstructionExecutor = createInstructionExecutor;
+exports.createPublicKeySeed = createPublicKeySeed;
+exports.createSeed = createSeed;
+exports.derivePda = derivePda;
+exports.executeInstruction = executeInstruction;
+exports.formatProgramError = formatProgramError;
 exports.isSnapshotFrame = isSnapshotFrame;
 exports.isValidFrame = isValidFrame;
 exports.parseFrame = parseFrame;
 exports.parseFrameFromBlob = parseFrameFromBlob;
+exports.parseInstructionError = parseInstructionError;
+exports.resolveAccounts = resolveAccounts;
+exports.serializeInstructionData = serializeInstructionData;
 exports.useConnectionState = useConnectionState;
 exports.useEntity = useEntity;
 exports.useHyperstack = useHyperstack;
 exports.useHyperstackContext = useHyperstackContext;
+exports.useInstructionMutation = useInstructionMutation;
 exports.useView = useView;
+exports.validateAccountResolution = validateAccountResolution;
+exports.waitForConfirmation = waitForConfirmation;
 //# sourceMappingURL=index.js.map