@usearete/react 0.1.5 → 0.3.0

package/dist/index.cjs

@@ -0,0 +1,2344 @@
+'use strict';
+
+var React = require('react');
+var sdk = require('@usearete/sdk');
+var zustand = require('zustand');
+
+const DEFAULT_FLUSH_INTERVAL_MS = 16;
+
+class ZustandAdapter {
+    constructor(_config = {}) {
+        this.updateCallbacks = new Set();
+        this.richUpdateCallbacks = new Set();
+        this.accessOrder = new Map();
+        this.store = zustand.create((set) => ({
+            entities: new Map(),
+            viewConfigs: new Map(),
+            connectionState: 'disconnected',
+            lastError: undefined,
+            _set: (viewPath, key, data) => {
+                set((state) => {
+                    const newEntities = new Map(state.entities);
+                    const viewMap = new Map(newEntities.get(viewPath) ?? new Map());
+                    viewMap.set(key, data);
+                    newEntities.set(viewPath, viewMap);
+                    return { entities: newEntities };
+                });
+            },
+            _delete: (viewPath, key) => {
+                set((state) => {
+                    const newEntities = new Map(state.entities);
+                    const viewMap = newEntities.get(viewPath);
+                    if (viewMap) {
+                        const newViewMap = new Map(viewMap);
+                        newViewMap.delete(key);
+                        newEntities.set(viewPath, newViewMap);
+                    }
+                    return { entities: newEntities };
+                });
+            },
+            _clear: (viewPath) => {
+                set((state) => {
+                    if (viewPath) {
+                        const newEntities = new Map(state.entities);
+                        newEntities.delete(viewPath);
+                        return { entities: newEntities };
+                    }
+                    return { entities: new Map() };
+                });
+            },
+            _setConnectionState: (connectionState, lastError) => {
+                set({ connectionState, lastError });
+            },
+            _setViewConfig: (viewPath, config) => {
+                set((state) => {
+                    const newConfigs = new Map(state.viewConfigs);
+                    newConfigs.set(viewPath, config);
+                    return { viewConfigs: newConfigs };
+                });
+            },
+        }));
+    }
+    get(viewPath, key) {
+        const viewMap = this.store.getState().entities.get(viewPath);
+        if (!viewMap)
+            return null;
+        const value = viewMap.get(key);
+        return value !== undefined ? value : null;
+    }
+    getAll(viewPath) {
+        const viewMap = this.store.getState().entities.get(viewPath);
+        if (!viewMap)
+            return [];
+        return Array.from(viewMap.values());
+    }
+    getAllSync(viewPath) {
+        const viewMap = this.store.getState().entities.get(viewPath);
+        if (!viewMap)
+            return undefined;
+        return Array.from(viewMap.values());
+    }
+    getSync(viewPath, key) {
+        const viewMap = this.store.getState().entities.get(viewPath);
+        if (!viewMap)
+            return undefined;
+        const value = viewMap.get(key);
+        return value !== undefined ? value : null;
+    }
+    has(viewPath, key) {
+        return this.store.getState().entities.get(viewPath)?.has(key) ?? false;
+    }
+    keys(viewPath) {
+        const viewMap = this.store.getState().entities.get(viewPath);
+        if (!viewMap)
+            return [];
+        return Array.from(viewMap.keys());
+    }
+    size(viewPath) {
+        return this.store.getState().entities.get(viewPath)?.size ?? 0;
+    }
+    set(viewPath, key, data) {
+        let order = this.accessOrder.get(viewPath);
+        if (!order) {
+            order = [];
+            this.accessOrder.set(viewPath, order);
+        }
+        const existingIdx = order.indexOf(key);
+        if (existingIdx !== -1) {
+            order.splice(existingIdx, 1);
+        }
+        order.push(key);
+        this.store.getState()._set(viewPath, key, data);
+    }
+    delete(viewPath, key) {
+        const order = this.accessOrder.get(viewPath);
+        if (order) {
+            const idx = order.indexOf(key);
+            if (idx !== -1) {
+                order.splice(idx, 1);
+            }
+        }
+        this.store.getState()._delete(viewPath, key);
+    }
+    clear(viewPath) {
+        if (viewPath) {
+            this.accessOrder.delete(viewPath);
+        }
+        else {
+            this.accessOrder.clear();
+        }
+        this.store.getState()._clear(viewPath);
+    }
+    evictOldest(viewPath) {
+        const order = this.accessOrder.get(viewPath);
+        if (!order || order.length === 0)
+            return undefined;
+        const oldest = order.shift();
+        if (oldest !== undefined) {
+            this.store.getState()._delete(viewPath, oldest);
+        }
+        return oldest;
+    }
+    onUpdate(callback) {
+        this.updateCallbacks.add(callback);
+        return () => this.updateCallbacks.delete(callback);
+    }
+    onRichUpdate(callback) {
+        this.richUpdateCallbacks.add(callback);
+        return () => this.richUpdateCallbacks.delete(callback);
+    }
+    notifyUpdate(viewPath, key, update) {
+        for (const callback of this.updateCallbacks) {
+            callback(viewPath, key, update);
+        }
+    }
+    notifyRichUpdate(viewPath, key, update) {
+        for (const callback of this.richUpdateCallbacks) {
+            callback(viewPath, key, update);
+        }
+    }
+    setConnectionState(state, error) {
+        this.store.getState()._setConnectionState(state, error);
+    }
+    setViewConfig(viewPath, config) {
+        const state = this.store.getState();
+        const existingConfig = state.viewConfigs.get(viewPath);
+        if (existingConfig)
+            return;
+        state._setViewConfig(viewPath, config);
+    }
+    getViewConfig(viewPath) {
+        return this.store.getState().viewConfigs.get(viewPath);
+    }
+}
+
+function syncClientWallets(entries, wallet) {
+    for (const entry of entries) {
+        entry.client.setWallet(wallet);
+    }
+}
+function initializeConnectedClient(client, adapter, wallet) {
+    client.setWallet(wallet);
+    client.onConnectionStateChange((state) => {
+        adapter.setConnectionState(state);
+    });
+    adapter.setConnectionState(client.connectionState);
+}
+
+const objectKeys = new WeakMap();
+let nextObjectKey = 0;
+function getObjectKey(value, prefix) {
+    const existing = objectKeys.get(value);
+    if (existing) {
+        return existing;
+    }
+    const key = `${prefix}-${++nextObjectKey}`;
+    objectKeys.set(value, key);
+    return key;
+}
+/**
+ * Generated programs share by their behavior fingerprint. Manual definitions
+ * fall back to object identity so definitions with unknown behavior never
+ * accidentally share a client.
+ */
+function getProgramsKey(programs) {
+    const entries = Object.entries(programs)
+        .map(([key, definition]) => [
+        key,
+        definition.definitionHash
+            ?? getObjectKey(definition, 'program'),
+    ])
+        .sort(([left], [right]) => left.localeCompare(right));
+    return entries.length > 0 ? JSON.stringify(entries) : 'programs-empty';
+}
+function createClientCacheKey(stack, options) {
+    if (!stack) {
+        return null;
+    }
+    return [
+        getObjectKey(stack, 'stack'),
+        options?.transport ?? 'ws',
+        options?.url ?? stack.endpoints.ws,
+        options?.httpUrl ?? stack.endpoints.http ?? '',
+        options?.programs
+            ? getProgramsKey(options.programs)
+            : 'programs-none',
+    ].join(':');
+}
+
+function trackConnectingPromise(connecting, cacheKey, promise) {
+    connecting.set(cacheKey, promise);
+    void promise.catch(() => {
+        if (connecting.get(cacheKey) === promise) {
+            connecting.delete(cacheKey);
+        }
+    });
+    return promise;
+}
+
+const AreteContext = React.createContext(null);
+function AreteProvider({ children, ...config }) {
+    const clientsRef = React.useRef(new Map());
+    const connectingRef = React.useRef(new Map());
+    const clientChangeListenersRef = React.useRef(new Set());
+    const latestWalletRef = React.useRef(config.wallet);
+    const lifecycleRef = React.useRef({ active: true, generation: 0 });
+    latestWalletRef.current = config.wallet;
+    const notifyClientChange = React.useCallback((change) => {
+        clientChangeListenersRef.current.forEach(cb => { cb(change); });
+    }, []);
+    const subscribeToClientChanges = React.useCallback((callback) => {
+        clientChangeListenersRef.current.add(callback);
+        return () => {
+            clientChangeListenersRef.current.delete(callback);
+        };
+    }, []);
+    const getOrCreateClient = React.useCallback(async (stack, options) => {
+        const cacheKey = createClientCacheKey(stack, options);
+        if (!cacheKey) {
+            throw new Error('Stack is required to create an Arete client');
+        }
+        const existing = clientsRef.current.get(cacheKey);
+        if (existing) {
+            return existing.client;
+        }
+        const connecting = connectingRef.current.get(cacheKey);
+        if (connecting) {
+            return connecting;
+        }
+        const adapter = new ZustandAdapter();
+        const lifecycleGeneration = lifecycleRef.current.generation;
+        let connectionPromise;
+        connectionPromise = sdk.Arete.connect(stack, {
+            url: options?.url,
+            httpUrl: options?.httpUrl,
+            transport: options?.transport,
+            programs: options?.programs,
+            storage: adapter,
+            autoConnect: config.autoConnect,
+            autoReconnect: config.autoReconnect,
+            reconnectIntervals: config.reconnectIntervals,
+            maxReconnectAttempts: config.maxReconnectAttempts,
+            maxEntriesPerView: config.maxEntriesPerView,
+            flushIntervalMs: config.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS,
+            fetch: config.fetch,
+            validateFrames: config.validateFrames,
+            onFrameValidationError: config.onFrameValidationError,
+            auth: config.auth,
+            wallet: latestWalletRef.current,
+        }).then((client) => {
+            const ownsAttempt = lifecycleRef.current.active
+                && lifecycleRef.current.generation === lifecycleGeneration
+                && connectingRef.current.get(cacheKey) === connectionPromise;
+            if (!ownsAttempt) {
+                client.disconnect();
+                throw new Error('Arete connection attempt was superseded');
+            }
+            initializeConnectedClient(client, adapter, latestWalletRef.current);
+            clientsRef.current.set(cacheKey, {
+                client: client,
+                disconnect: () => client.disconnect()
+            });
+            connectingRef.current.delete(cacheKey);
+            notifyClientChange({ cacheKey, status: 'connected' });
+            return client;
+        }).catch((value) => {
+            const error = value instanceof Error ? value : new Error(String(value));
+            if (connectingRef.current.get(cacheKey) === connectionPromise) {
+                connectingRef.current.delete(cacheKey);
+                if (lifecycleRef.current.active
+                    && lifecycleRef.current.generation === lifecycleGeneration) {
+                    notifyClientChange({ cacheKey, status: 'error', error });
+                }
+            }
+            throw error;
+        });
+        trackConnectingPromise(connectingRef.current, cacheKey, connectionPromise);
+        notifyClientChange({ cacheKey, status: 'connecting' });
+        return connectionPromise;
+    }, [config.autoConnect, config.autoReconnect, config.reconnectIntervals, config.maxReconnectAttempts, config.maxEntriesPerView, config.flushIntervalMs, config.fetch, config.validateFrames, config.onFrameValidationError, config.auth, notifyClientChange]);
+    const getClient = React.useCallback((stack, options) => {
+        if (!stack) {
+            if (clientsRef.current.size === 1) {
+                const firstEntry = clientsRef.current.values().next().value;
+                return firstEntry ? firstEntry.client : null;
+            }
+            return null;
+        }
+        const cacheKey = createClientCacheKey(stack, options);
+        if (!cacheKey) {
+            return null;
+        }
+        const entry = clientsRef.current.get(cacheKey);
+        return entry ? entry.client : null;
+    }, []);
+    const retryClient = React.useCallback((stack, options) => {
+        const cacheKey = createClientCacheKey(stack, options);
+        if (!cacheKey) {
+            return Promise.reject(new Error('Stack is required to retry an Arete client'));
+        }
+        const existing = clientsRef.current.get(cacheKey);
+        if (existing) {
+            existing.disconnect();
+            clientsRef.current.delete(cacheKey);
+        }
+        return getOrCreateClient(stack, options);
+    }, [getOrCreateClient]);
+    React.useEffect(() => {
+        syncClientWallets(clientsRef.current.values(), config.wallet);
+        notifyClientChange();
+    }, [config.wallet, notifyClientChange]);
+    React.useEffect(() => {
+        const lifecycle = lifecycleRef.current;
+        const clients = clientsRef.current;
+        const connecting = connectingRef.current;
+        lifecycle.active = true;
+        return () => {
+            lifecycle.active = false;
+            lifecycle.generation++;
+            clients.forEach((entry) => {
+                entry.disconnect();
+            });
+            clients.clear();
+            connecting.clear();
+        };
+    }, []);
+    const value = {
+        getOrCreateClient,
+        getClient,
+        retryClient,
+        subscribeToClientChanges,
+        config,
+    };
+    return (React.createElement(AreteContext.Provider, { value: value }, children));
+}
+function useAreteContext() {
+    const context = React.useContext(AreteContext);
+    if (!context) {
+        throw new Error('useAreteContext must be used within AreteProvider');
+    }
+    return context;
+}
+function useConnectionState(stack, options) {
+    const { getClient, subscribeToClientChanges } = useAreteContext();
+    const [state, setState] = React.useState(() => {
+        const client = getClient(stack, options);
+        return client?.connectionState ?? 'disconnected';
+    });
+    const unsubscribeRef = React.useRef(undefined);
+    React.useEffect(() => {
+        let mounted = true;
+        const setupClientSubscription = () => {
+            unsubscribeRef.current?.();
+            unsubscribeRef.current = undefined;
+            const client = getClient(stack, options);
+            if (client && mounted) {
+                setState(client.connectionState);
+                unsubscribeRef.current = client.onConnectionStateChange((newState) => {
+                    if (mounted)
+                        setState(newState);
+                });
+            }
+            else if (mounted) {
+                setState('disconnected');
+            }
+        };
+        const unsubscribeFromClientChanges = subscribeToClientChanges(setupClientSubscription);
+        setupClientSubscription();
+        return () => {
+            mounted = false;
+            unsubscribeFromClientChanges();
+            unsubscribeRef.current?.();
+        };
+    }, [getClient, subscribeToClientChanges, stack, options]);
+    return state;
+}
+
+function isMarkedDefaultReconciliation(value) {
+    return (typeof value === 'function'
+        && value.areteDefaultReconciliation === true
+        && typeof value.shouldReconcile === 'function'
+        && typeof value.withOverrides === 'function');
+}
+function initialMutationState() {
+    return {
+        status: 'idle',
+        phase: 'idle',
+        latestEvent: null,
+        displayError: null,
+        failure: null,
+        outcome: null,
+        prepared: null,
+        result: undefined,
+        signatures: [],
+        completedReceipts: [],
+        callbackErrors: [],
+        reconciliationError: null,
+    };
+}
+function normalizeThrown(value) {
+    if (value instanceof Error) {
+        return value;
+    }
+    let message;
+    try {
+        message = typeof value === 'string' ? value : JSON.stringify(value);
+    }
+    catch {
+        message = String(value);
+    }
+    const error = new Error(message || String(value));
+    error.cause = value;
+    return error;
+}
+function displayErrorFor(error, failure) {
+    const unwrapped = sdk.unwrapOperationExecutionError(error);
+    if (unwrapped instanceof sdk.InstructionError && unwrapped.programError) {
+        return `${unwrapped.programError.name}: ${unwrapped.programError.message}`;
+    }
+    if (failure?.status === 'chain-failed' && failure.programError) {
+        return `${failure.programError.name}: ${failure.programError.message}`;
+    }
+    if (failure
+        && failure.cause instanceof Error
+        && failure.cause.message) {
+        return failure.cause.message;
+    }
+    return unwrapped instanceof Error ? unwrapped.message : error.message;
+}
+function isReceipt(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const receipt = value;
+    return (typeof receipt.transactionIndex === 'number'
+        && typeof receipt.transactionName === 'string'
+        && typeof receipt.signature === 'string');
+}
+function receiptsFrom(value) {
+    if (!value || typeof value !== 'object') {
+        return [];
+    }
+    const candidate = value;
+    if (Array.isArray(candidate.completedReceipts)) {
+        return candidate.completedReceipts.filter(isReceipt);
+    }
+    if (Array.isArray(candidate.transactions)) {
+        return candidate.transactions.filter(isReceipt);
+    }
+    return isReceipt(candidate.transaction) ? [candidate.transaction] : [];
+}
+function signaturesFrom(value) {
+    if (!value || typeof value !== 'object') {
+        return [];
+    }
+    const candidate = value;
+    if (Array.isArray(candidate.signatures)) {
+        return candidate.signatures.filter((signature) => typeof signature === 'string');
+    }
+    return typeof candidate.signature === 'string' ? [candidate.signature] : [];
+}
+function callbackErrorsFrom(value) {
+    if (!value || typeof value !== 'object') {
+        return [];
+    }
+    const callbackErrors = value.callbackErrors;
+    return Array.isArray(callbackErrors) ? callbackErrors.map(normalizeThrown) : [];
+}
+function uniqueErrors(errors) {
+    return [...new Set(errors)];
+}
+function uniqueStrings(values) {
+    return [...new Set(values)];
+}
+function confirmedOutcome(signatures, receipts) {
+    const signature = signatures[signatures.length - 1];
+    if (!signature) {
+        return null;
+    }
+    const receipt = [...receipts].reverse().find((entry) => entry.signature === signature);
+    return {
+        status: 'confirmed',
+        phase: 'confirmation',
+        signature,
+        slot: receipt?.slot,
+    };
+}
+function unreconciledError(value) {
+    if (!value || typeof value !== 'object') {
+        return null;
+    }
+    const result = value;
+    if (result.status !== 'confirmed-unreconciled') {
+        return null;
+    }
+    return normalizeThrown(result.error ?? new Error('Confirmed transaction was not reconciled'));
+}
+function useInstructionMutation(execute, defaults) {
+    const [state, setState] = React.useState((initialMutationState));
+    const invocationRef = React.useRef(0);
+    const reconciliationAbortRef = React.useRef(null);
+    const reconciliationRetryRef = React.useRef(null);
+    const defaultsRef = React.useRef(defaults);
+    defaultsRef.current = defaults;
+    const submit = React.useCallback(async (args, options) => {
+        const invocation = ++invocationRef.current;
+        reconciliationAbortRef.current?.abort();
+        reconciliationRetryRef.current = null;
+        const reconciliationAbort = new AbortController();
+        reconciliationAbortRef.current = reconciliationAbort;
+        const updateCurrent = (update) => {
+            if (invocation === invocationRef.current) {
+                setState(update);
+            }
+        };
+        const setPhase = (phase, patch = {}, transactionEvent) => {
+            updateCurrent((current) => ({
+                ...current,
+                ...patch,
+                phase,
+                latestEvent: {
+                    phase,
+                    prepared: patch.prepared === undefined ? current.prepared : patch.prepared,
+                    ...(patch.result === undefined ? {} : { result: patch.result }),
+                    ...(patch.failure ? { failure: patch.failure } : {}),
+                    ...(transactionEvent ? { transactionEvent } : {}),
+                },
+            }));
+        };
+        setState({
+            ...initialMutationState(),
+            status: 'pending',
+            phase: 'preparing',
+            latestEvent: { phase: 'preparing', prepared: null },
+        });
+        const mergedOptions = {
+            ...(defaultsRef.current ?? {}),
+            ...(options ?? {}),
+        };
+        const onConfirmed = mergedOptions.onConfirmed;
+        const onSuccess = mergedOptions.onSuccess;
+        const onError = mergedOptions.onError;
+        const reconcileOption = mergedOptions.reconcile;
+        const executionOptions = { ...mergedOptions };
+        delete executionOptions.onConfirmed;
+        delete executionOptions.onSuccess;
+        delete executionOptions.onError;
+        delete executionOptions.reconcile;
+        let prepared = null;
+        const observedReceipts = [];
+        const observedCallbackErrors = [];
+        const observer = {
+            onPrepared(nextPrepared) {
+                prepared = nextPrepared;
+                setPhase('awaiting-wallet', { prepared: nextPrepared });
+            },
+            onAwaitingWallet() {
+                setPhase('awaiting-wallet');
+            },
+            onTransactionStart(event) {
+                setPhase('awaiting-wallet', {}, event);
+            },
+            onTransactionSuccess(event) {
+                observedReceipts.push(event.receipt);
+                const receipts = [...observedReceipts];
+                const signatures = uniqueStrings(receipts.map((receipt) => receipt.signature));
+                setPhase('submitted', {
+                    completedReceipts: receipts,
+                    signatures,
+                }, event);
+            },
+            onCallbackError(value) {
+                const error = normalizeThrown(value);
+                observedCallbackErrors.push(error);
+                updateCurrent((current) => ({
+                    ...current,
+                    callbackErrors: uniqueErrors([...current.callbackErrors, error]),
+                }));
+            },
+        };
+        try {
+            let reconcile;
+            if (reconcileOption === false || reconcileOption === undefined) {
+                reconcile = undefined;
+            }
+            else if (typeof reconcileOption === 'function') {
+                reconcile = reconcileOption;
+            }
+            else {
+                const hookDefault = defaultsRef.current?.reconcile;
+                if (isMarkedDefaultReconciliation(hookDefault)) {
+                    reconcile = hookDefault.withOverrides(reconcileOption);
+                }
+                else {
+                    throw new Error('reconcile option objects require a generated program hook with default reconciliation; pass a reconcile function instead');
+                }
+            }
+            const result = await execute(args, executionOptions, observer);
+            const completedReceipts = receiptsFrom(result).length > 0
+                ? receiptsFrom(result)
+                : [...observedReceipts];
+            const signatures = uniqueStrings([
+                ...signaturesFrom(result),
+                ...completedReceipts.map((receipt) => receipt.signature),
+            ]);
+            const outcome = confirmedOutcome(signatures, completedReceipts);
+            const callbackErrors = uniqueErrors([
+                ...observedCallbackErrors,
+                ...callbackErrorsFrom(result),
+            ]);
+            const reconciliationContext = {
+                result,
+                prepared,
+                signatures,
+                completedReceipts,
+                signal: reconciliationAbort.signal,
+            };
+            const shouldReconcile = Boolean(reconcile
+                && (!isMarkedDefaultReconciliation(reconcile)
+                    || reconcile.shouldReconcile(reconciliationContext)));
+            if (invocation === invocationRef.current && reconcile && shouldReconcile) {
+                reconciliationRetryRef.current = {
+                    invocation,
+                    reconcile,
+                    context: {
+                        result,
+                        prepared,
+                        signatures,
+                        completedReceipts,
+                    },
+                    onSuccess,
+                };
+            }
+            setPhase('confirmed', {
+                status: 'pending',
+                result,
+                outcome,
+                prepared,
+                signatures,
+                completedReceipts,
+                callbackErrors,
+            });
+            if (onConfirmed) {
+                try {
+                    await onConfirmed(result);
+                }
+                catch (value) {
+                    const callbackError = normalizeThrown(value);
+                    observedCallbackErrors.push(callbackError);
+                    updateCurrent((current) => ({
+                        ...current,
+                        callbackErrors: uniqueErrors([...current.callbackErrors, callbackError]),
+                    }));
+                }
+            }
+            if (reconciliationAbort.signal.aborted || invocation !== invocationRef.current) {
+                return result;
+            }
+            let reconciled = !shouldReconcile;
+            if (reconcile && shouldReconcile) {
+                setPhase('reconciling', { status: 'pending' });
+                try {
+                    const reconciliationResult = await reconcile(reconciliationContext);
+                    const error = unreconciledError(reconciliationResult);
+                    if (error) {
+                        setPhase('confirmed-unreconciled', {
+                            status: 'pending',
+                            reconciliationError: error,
+                        });
+                    }
+                    else {
+                        reconciled = true;
+                        if (reconciliationRetryRef.current?.invocation === invocation) {
+                            reconciliationRetryRef.current = null;
+                        }
+                        setPhase('reconciled', { status: 'pending' });
+                    }
+                }
+                catch (value) {
+                    const reconciliationError = normalizeThrown(value);
+                    setPhase('confirmed-unreconciled', {
+                        status: 'pending',
+                        reconciliationError,
+                    });
+                }
+            }
+            if (reconciled
+                && onSuccess
+                && !reconciliationAbort.signal.aborted
+                && invocation === invocationRef.current) {
+                try {
+                    await onSuccess(result);
+                }
+                catch (value) {
+                    const callbackError = normalizeThrown(value);
+                    observedCallbackErrors.push(callbackError);
+                    updateCurrent((current) => ({
+                        ...current,
+                        callbackErrors: uniqueErrors([...current.callbackErrors, callbackError]),
+                    }));
+                }
+            }
+            updateCurrent((current) => ({ ...current, status: 'success' }));
+            return result;
+        }
+        catch (value) {
+            const error = normalizeThrown(value);
+            const failure = sdk.getTransactionFailureOutcome(error) ?? {
+                status: 'not-submitted',
+                phase: prepared ? 'send' : 'build',
+                cause: value,
+            };
+            const completedReceipts = value instanceof sdk.OperationExecutionError
+                ? [...value.completedReceipts]
+                : receiptsFrom(value);
+            const signatures = uniqueStrings([
+                ...completedReceipts.map((receipt) => receipt.signature),
+                ...(failure && 'signature' in failure && failure.signature ? [failure.signature] : []),
+            ]);
+            const callbackErrors = uniqueErrors([
+                ...observedCallbackErrors,
+                ...callbackErrorsFrom(value),
+            ]);
+            const phase = failure?.status ?? 'not-submitted';
+            const displayError = displayErrorFor(error, failure);
+            setPhase(phase, {
+                status: 'pending',
+                displayError,
+                failure,
+                outcome: failure,
+                prepared: value instanceof sdk.OperationExecutionError
+                    ? value.operation
+                    : prepared,
+                signatures,
+                completedReceipts,
+                callbackErrors,
+            });
+            if (onError) {
+                try {
+                    await onError(error);
+                }
+                catch (callbackValue) {
+                    const callbackError = normalizeThrown(callbackValue);
+                    updateCurrent((current) => ({
+                        ...current,
+                        callbackErrors: uniqueErrors([...current.callbackErrors, callbackError]),
+                    }));
+                }
+            }
+            updateCurrent((current) => ({ ...current, status: 'error' }));
+            throw error;
+        }
+        finally {
+            if (reconciliationAbortRef.current === reconciliationAbort) {
+                reconciliationAbortRef.current = null;
+            }
+        }
+    }, [execute]);
+    const retryReconciliation = React.useCallback(async () => {
+        const pending = reconciliationRetryRef.current;
+        if (!pending) {
+            throw new Error('No failed reconciliation is available to retry');
+        }
+        const invocation = ++invocationRef.current;
+        reconciliationAbortRef.current?.abort();
+        const reconciliationAbort = new AbortController();
+        reconciliationAbortRef.current = reconciliationAbort;
+        setState((current) => ({
+            ...current,
+            status: 'pending',
+            phase: 'reconciling',
+            reconciliationError: null,
+            latestEvent: {
+                phase: 'reconciling',
+                prepared: pending.context.prepared,
+                result: pending.context.result,
+            },
+        }));
+        try {
+            const result = await pending.reconcile({
+                ...pending.context,
+                signal: reconciliationAbort.signal,
+            });
+            const error = unreconciledError(result);
+            if (error)
+                throw error;
+            if (reconciliationAbort.signal.aborted || invocation !== invocationRef.current)
+                return;
+            reconciliationRetryRef.current = null;
+            setState((current) => ({
+                ...current,
+                status: 'pending',
+                phase: 'reconciled',
+                reconciliationError: null,
+                latestEvent: {
+                    phase: 'reconciled',
+                    prepared: pending.context.prepared,
+                    result: pending.context.result,
+                },
+            }));
+            if (pending.onSuccess) {
+                try {
+                    await pending.onSuccess(pending.context.result);
+                }
+                catch (value) {
+                    const callbackError = normalizeThrown(value);
+                    if (invocation === invocationRef.current) {
+                        setState((current) => ({
+                            ...current,
+                            callbackErrors: uniqueErrors([...current.callbackErrors, callbackError]),
+                        }));
+                    }
+                }
+            }
+            if (invocation === invocationRef.current) {
+                setState((current) => ({ ...current, status: 'success' }));
+            }
+        }
+        catch (value) {
+            const error = normalizeThrown(value);
+            if (!reconciliationAbort.signal.aborted && invocation === invocationRef.current) {
+                setState((current) => ({
+                    ...current,
+                    status: 'success',
+                    phase: 'confirmed-unreconciled',
+                    reconciliationError: error,
+                    latestEvent: {
+                        phase: 'confirmed-unreconciled',
+                        prepared: pending.context.prepared,
+                        result: pending.context.result,
+                        error,
+                    },
+                }));
+            }
+            throw error;
+        }
+        finally {
+            if (reconciliationAbortRef.current === reconciliationAbort) {
+                reconciliationAbortRef.current = null;
+            }
+        }
+    }, []);
+    const reset = React.useCallback(() => {
+        invocationRef.current += 1;
+        reconciliationAbortRef.current?.abort();
+        reconciliationAbortRef.current = null;
+        reconciliationRetryRef.current = null;
+        setState(initialMutationState());
+    }, []);
+    const mutate = React.useCallback((args, options) => {
+        void submit(args, options).catch(() => undefined);
+    }, [submit]);
+    const signature = state.signatures.length === 1 ? state.signatures[0] : null;
+    return {
+        mutate,
+        mutateAsync: submit,
+        submit,
+        status: state.status,
+        phase: state.phase,
+        latestEvent: state.latestEvent,
+        error: state.displayError,
+        displayError: state.displayError,
+        failure: state.failure,
+        outcome: state.outcome,
+        prepared: state.prepared,
+        data: state.result,
+        result: state.result,
+        signatures: state.signatures,
+        signature,
+        completedReceipts: state.completedReceipts,
+        callbackError: state.callbackErrors[state.callbackErrors.length - 1] ?? null,
+        callbackErrors: state.callbackErrors,
+        reconciliationError: state.reconciliationError,
+        isLoading: state.status === 'pending',
+        isConfirmed: state.outcome?.status === 'confirmed',
+        isSubmittedUnknown: state.failure?.status === 'submitted-unknown',
+        isPreparing: state.phase === 'preparing',
+        isAwaitingWallet: state.phase === 'awaiting-wallet',
+        isReconciling: state.phase === 'reconciling',
+        canRetryReconciliation: state.phase === 'confirmed-unreconciled'
+            && reconciliationRetryRef.current !== null,
+        retryReconciliation,
+        reset,
+    };
+}
+
+const DEFAULT_RECONCILIATION_TIMEOUT_MS = 30000;
+function toSlot(slot) {
+    if (typeof slot === 'number') {
+        if (!Number.isSafeInteger(slot) || slot < 0) {
+            throw new RangeError('slot must be a non-negative safe integer or bigint');
+        }
+        return BigInt(slot);
+    }
+    if (slot < 0n) {
+        throw new RangeError('slot must be non-negative');
+    }
+    return slot;
+}
+function reconciliationError(value) {
+    if (value instanceof Error) {
+        return value;
+    }
+    const error = new Error(typeof value === 'string' ? value : String(value));
+    error.cause = value;
+    return error;
+}
+async function refreshTargets(targets, timeoutMs, signal) {
+    if (targets.length === 0)
+        return;
+    let timeout;
+    let onAbort;
+    const interrupted = new Promise((_resolve, reject) => {
+        timeout = setTimeout(() => {
+            reject(new Error(`Timed out waiting for refreshed Arete data after ${timeoutMs}ms`));
+        }, timeoutMs);
+        if (signal) {
+            onAbort = () => reject(reconciliationError(signal.reason ?? 'Reconciliation was cancelled'));
+            if (signal.aborted) {
+                onAbort();
+            }
+            else {
+                signal.addEventListener('abort', onAbort, { once: true });
+            }
+        }
+    });
+    try {
+        await Promise.race([
+            Promise.all(targets.map((target) => typeof target === 'function' ? target() : target.refresh())),
+            interrupted,
+        ]);
+    }
+    finally {
+        if (timeout !== undefined)
+            clearTimeout(timeout);
+        if (signal && onAbort)
+            signal.removeEventListener('abort', onAbort);
+    }
+}
+async function reconcileProcessedSlot(client, slot, options = {}) {
+    const confirmedSlot = toSlot(slot);
+    if (!client) {
+        return {
+            status: 'confirmed-unreconciled',
+            confirmedSlot,
+            error: new Error('Arete client is not connected'),
+        };
+    }
+    try {
+        const processedSlot = await client.waitForProcessedSlot(confirmedSlot, {
+            timeoutMs: options.timeoutMs ?? DEFAULT_RECONCILIATION_TIMEOUT_MS,
+            signal: options.signal,
+        });
+        const refreshes = Array.isArray(options.refresh)
+            ? options.refresh
+            : options.refresh
+                ? [options.refresh]
+                : [];
+        await refreshTargets(refreshes, options.timeoutMs ?? DEFAULT_RECONCILIATION_TIMEOUT_MS, options.signal);
+        return { status: 'reconciled', confirmedSlot, processedSlot };
+    }
+    catch (value) {
+        return {
+            status: 'confirmed-unreconciled',
+            confirmedSlot,
+            error: reconciliationError(value),
+        };
+    }
+}
+function useReconcileProcessedSlot(client) {
+    return React.useCallback((slot, options) => reconcileProcessedSlot(client, slot, options), [client]);
+}
+/**
+ * Build the default reconciliation for generated program hooks: wait until the
+ * stream has processed the highest slot among completed transactions, then run
+ * any requested refreshes. Mutations without a reported slot (e.g. raw
+ * instruction sends) skip reconciliation silently.
+ */
+function createProcessedSlotReconciliation(client, baseOverrides = {}) {
+    const build = (overrides) => {
+        const receiptSlot = (context) => context.completedReceipts.reduce((highest, receipt) => receipt.slot === undefined
+            ? highest
+            : highest === undefined
+                ? receipt.slot
+                : Math.max(highest, receipt.slot), undefined);
+        const reconcile = async (context) => {
+            const slot = receiptSlot(context);
+            if (slot === undefined) {
+                return undefined;
+            }
+            return reconcileProcessedSlot(client, slot, {
+                signal: context.signal,
+                timeoutMs: overrides.timeoutMs,
+                refresh: overrides.refresh,
+            });
+        };
+        return Object.assign(reconcile, {
+            areteDefaultReconciliation: true,
+            shouldReconcile: (context) => receiptSlot(context) !== undefined,
+            withOverrides: (next) => build({ ...overrides, ...next }),
+        });
+    };
+    return build(baseOverrides);
+}
+
+function composeCallbacks(observerCallback, callerCallback) {
+    if (!observerCallback && !callerCallback)
+        return undefined;
+    return async (value) => {
+        const errors = [];
+        for (const callback of [observerCallback, callerCallback]) {
+            if (!callback)
+                continue;
+            try {
+                await callback(value);
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        if (errors.length > 0)
+            throw errors[0];
+    };
+}
+/**
+ * Wrap the mutation factory so every generated program hook reconciles against
+ * the stream by default: after confirmation, wait until the stack has
+ * processed the transaction's slot. Callers opt out per hook or per submit
+ * with `reconcile: false`, replace it with a function, or tweak it with a
+ * `{ refresh, timeoutMs }` shorthand object.
+ */
+function withDefaultReconciliation(createMutationHook, client) {
+    const defaultReconcile = client && typeof client.waitForProcessedSlot === 'function'
+        ? createProcessedSlotReconciliation(client)
+        : undefined;
+    if (!defaultReconcile) {
+        return createMutationHook;
+    }
+    const factory = (execute, options) => {
+        const callerReconcile = options?.reconcile;
+        let reconcile = callerReconcile;
+        if (callerReconcile !== false && typeof callerReconcile !== 'function') {
+            reconcile = (callerReconcile
+                ? defaultReconcile.withOverrides(callerReconcile)
+                : defaultReconcile);
+        }
+        return createMutationHook(execute, { ...options, reconcile });
+    };
+    return factory;
+}
+function wrapRawInstruction(instruction, client, createMutationHook) {
+    const execute = async (input, options, observer) => {
+        if (!client) {
+            throw new Error('Arete client is not connected');
+        }
+        const built = instruction.build(input);
+        observer?.onAwaitingWallet();
+        return client.transaction([built], options);
+    };
+    return {
+        execute,
+        build: instruction.build,
+        useMutation: (options) => createMutationHook(execute, options),
+    };
+}
+function isConnectedOperation(value) {
+    return Boolean(value && typeof value === 'object' && typeof value.prepare === 'function');
+}
+function wrapOperation(operation, client, createMutationHook) {
+    const execute = async (input, options, observer) => {
+        if (!client) {
+            throw new Error('Arete client is not connected');
+        }
+        const prepared = await operation.prepare(input);
+        observer?.onPrepared(prepared);
+        observer?.onAwaitingWallet();
+        const executionOptions = options;
+        return client.execute(prepared, {
+            ...(executionOptions ?? {}),
+            onTransactionStart: composeCallbacks(observer ? (event) => observer.onTransactionStart(event) : undefined, executionOptions?.onTransactionStart),
+            onTransactionSuccess: composeCallbacks(observer ? (event) => observer.onTransactionSuccess(event) : undefined, executionOptions?.onTransactionSuccess),
+            onCallbackError: composeCallbacks(observer ? (error) => observer.onCallbackError(error) : undefined, executionOptions?.onCallbackError),
+        });
+    };
+    return {
+        prepare: operation.prepare.bind(operation),
+        execute,
+        useMutation: (options) => createMutationHook(execute, options),
+    };
+}
+function wrapOperationNamespace(namespace, client, createMutationHook) {
+    const wrapped = {};
+    for (const [name, value] of Object.entries(namespace)) {
+        if (isConnectedOperation(value)) {
+            wrapped[name] = wrapOperation(value, client, createMutationHook);
+            continue;
+        }
+        if (value && typeof value === 'object') {
+            wrapped[name] = wrapOperationNamespace(value, client, createMutationHook);
+        }
+    }
+    return wrapped;
+}
+function wrapMaybeOperationNamespace(namespace, client, createMutationHook) {
+    return namespace
+        ? wrapOperationNamespace(namespace, client, createMutationHook)
+        : {};
+}
+const NOT_CONNECTED_ERROR = 'Arete client is not connected';
+function useDisconnectedMutation() {
+    return useInstructionMutation(async () => {
+        throw new Error(NOT_CONNECTED_ERROR);
+    });
+}
+/**
+ * Placeholder program hooks used before the client connects. Every namespace
+ * path resolves (so `arete.programs.ore.transactions.mining.deploy.useMutation()`
+ * is safe to call unconditionally) and every mutation hook keeps React state,
+ * but preparing, executing, or submitting throws "not connected" — matching
+ * what the real wrappers do. This lets components render their full tree
+ * while the stack is offline instead of gating on `arete.client`.
+ */
+function buildDisconnectedProgramHooks() {
+    const notConnected = () => {
+        throw new Error(NOT_CONNECTED_ERROR);
+    };
+    const leaf = Object.assign(notConnected, {
+        prepare: notConnected,
+        execute: notConnected,
+        send: notConnected,
+        resolve: notConnected,
+        plan: notConnected,
+        build: notConnected,
+        stage: notConnected,
+        useMutation: () => useDisconnectedMutation(),
+    });
+    // eslint-disable-next-line prefer-const
+    let proxy;
+    proxy = new Proxy(leaf, {
+        get(target, property) {
+            if (typeof property === 'string' && !(property in target)) {
+                return proxy;
+            }
+            return Reflect.get(target, property);
+        },
+    });
+    return proxy;
+}
+function buildProgramHookInterfaces(programs, client, createMutationHook, options = {}) {
+    const wrappedPrograms = {};
+    if (!programs) {
+        return wrappedPrograms;
+    }
+    const mutationHookFactory = options.defaultReconciliation === false
+        ? createMutationHook
+        : withDefaultReconciliation(createMutationHook, client);
+    for (const [name, program] of Object.entries(programs)) {
+        const raw = {};
+        for (const [instructionName, instruction] of Object.entries(program.raw)) {
+            raw[instructionName] = wrapRawInstruction(instruction, client, mutationHookFactory);
+        }
+        wrappedPrograms[name] = {
+            name: program.name,
+            programId: program.programId,
+            schemas: program.schemas,
+            pdas: program.pdas,
+            accounts: program.accounts,
+            queries: program.queries,
+            addresses: program.addresses,
+            constants: program.constants,
+            defaults: program.defaults,
+            math: program.math,
+            raw: raw,
+            instructions: wrapMaybeOperationNamespace(program.instructions, client, mutationHookFactory),
+            transactions: wrapMaybeOperationNamespace(program.transactions, client, mutationHookFactory),
+            flows: wrapMaybeOperationNamespace(program.flows, client, mutationHookFactory),
+        };
+    }
+    return wrappedPrograms;
+}
+
+function stableKeyPart(value) {
+    if (value === undefined)
+        return 'undefined';
+    if (value === null)
+        return 'null';
+    if (typeof value === 'bigint')
+        return `bigint:${value}`;
+    if (typeof value === 'string')
+        return `string:${JSON.stringify(value)}`;
+    if (typeof value === 'number')
+        return `number:${String(value)}`;
+    if (typeof value === 'boolean')
+        return `boolean:${String(value)}`;
+    if (Array.isArray(value)) {
+        return `[${value.map(stableKeyPart).join(',')}]`;
+    }
+    const record = value;
+    return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableKeyPart(record[key])}`).join(',')}}`;
+}
+function normalizeReadError(value) {
+    if (value instanceof Error) {
+        return value;
+    }
+    const error = new Error(typeof value === 'string' ? value : String(value));
+    error.cause = value;
+    return error;
+}
+/**
+ * Minimal keyed async state with no cache, retry, or request deduplication.
+ * A newer request aborts and supersedes the previous request for this hook.
+ *
+ * The returned state is tagged with the key that produced it: when the key
+ * changes, the hook immediately reports the fresh key's initial state instead
+ * of briefly exposing data fetched for the previous key. Callers never need
+ * to re-verify that `data` matches the arguments they passed.
+ */
+function useAsyncRead(key, read, options = {}) {
+    const stableKey = stableKeyPart(key);
+    const enabled = options.enabled ?? true;
+    const [state, setState] = React.useState(() => ({
+        key: stableKey,
+        enabled,
+        data: options.initialData,
+        hasResolved: options.initialData !== undefined,
+        error: null,
+        isLoading: enabled && options.initialData === undefined,
+        isRefreshing: false,
+    }));
+    const readRef = React.useRef(read);
+    const keyRef = React.useRef(key);
+    const enabledRef = React.useRef(enabled);
+    const initialDataRef = React.useRef(options.initialData);
+    const dataRef = React.useRef(options.initialData);
+    const hasResolvedRef = React.useRef(options.initialData !== undefined);
+    const requestRef = React.useRef({
+        id: 0,
+        controller: null,
+    });
+    const debounceTimerRef = React.useRef(null);
+    const mountedRef = React.useRef(true);
+    readRef.current = read;
+    keyRef.current = key;
+    enabledRef.current = enabled;
+    initialDataRef.current = options.initialData;
+    dataRef.current = state.data;
+    const cancelCurrent = React.useCallback(() => {
+        if (debounceTimerRef.current !== null) {
+            clearTimeout(debounceTimerRef.current);
+            debounceTimerRef.current = null;
+        }
+        requestRef.current.id += 1;
+        requestRef.current.controller?.abort();
+        requestRef.current.controller = null;
+    }, []);
+    const runRead = React.useCallback(async () => {
+        if (debounceTimerRef.current !== null) {
+            clearTimeout(debounceTimerRef.current);
+            debounceTimerRef.current = null;
+        }
+        if (!enabledRef.current) {
+            return dataRef.current;
+        }
+        const id = requestRef.current.id + 1;
+        requestRef.current.id = id;
+        requestRef.current.controller?.abort();
+        const controller = new AbortController();
+        requestRef.current.controller = controller;
+        const hasData = hasResolvedRef.current;
+        if (mountedRef.current) {
+            setState((current) => ({
+                ...current,
+                error: null,
+                isLoading: !hasData,
+                isRefreshing: hasData,
+            }));
+        }
+        try {
+            const data = await readRef.current({
+                signal: controller.signal,
+                key: keyRef.current,
+            });
+            if (mountedRef.current && requestRef.current.id === id) {
+                dataRef.current = data;
+                hasResolvedRef.current = true;
+                setState({
+                    key: stableKeyPart(keyRef.current),
+                    enabled: true,
+                    data,
+                    hasResolved: true,
+                    error: null,
+                    isLoading: false,
+                    isRefreshing: false,
+                });
+            }
+            return data;
+        }
+        catch (value) {
+            const error = normalizeReadError(value);
+            if (mountedRef.current
+                && requestRef.current.id === id
+                && !controller.signal.aborted) {
+                setState((current) => ({
+                    ...current,
+                    error,
+                    isLoading: false,
+                    isRefreshing: false,
+                }));
+            }
+            throw error;
+        }
+        finally {
+            if (requestRef.current.id === id) {
+                requestRef.current.controller = null;
+            }
+        }
+    }, []);
+    React.useEffect(() => {
+        mountedRef.current = true;
+        return () => {
+            mountedRef.current = false;
+        };
+    }, [cancelCurrent]);
+    React.useEffect(() => {
+        cancelCurrent();
+        dataRef.current = initialDataRef.current;
+        hasResolvedRef.current = initialDataRef.current !== undefined;
+        setState({
+            key: stableKey,
+            enabled: enabledRef.current,
+            data: initialDataRef.current,
+            hasResolved: initialDataRef.current !== undefined,
+            error: null,
+            isLoading: enabledRef.current && initialDataRef.current === undefined,
+            isRefreshing: false,
+        });
+        if (enabledRef.current) {
+            const debounceMs = options.debounceMs ?? 0;
+            if (debounceMs > 0) {
+                debounceTimerRef.current = setTimeout(() => {
+                    debounceTimerRef.current = null;
+                    void runRead().catch(() => undefined);
+                }, debounceMs);
+            }
+            else {
+                void runRead().catch(() => undefined);
+            }
+        }
+        return cancelCurrent;
+    }, [cancelCurrent, runRead, stableKey, enabled, options.debounceMs]);
+    // State committed under a different key must not leak into this render:
+    // report the fresh key's initial state until the effect above commits.
+    const visible = state.key === stableKey && state.enabled === enabled
+        ? state
+        : {
+            key: stableKey,
+            enabled,
+            data: options.initialData,
+            hasResolved: options.initialData !== undefined,
+            error: null,
+            isLoading: enabled && options.initialData === undefined,
+            isRefreshing: false,
+        };
+    const status = !enabled
+        ? options.disabledStatus ?? 'disabled'
+        : visible.error
+            ? 'error'
+            : visible.isLoading
+                ? 'loading'
+                : visible.isRefreshing
+                    ? 'refreshing'
+                    : 'ready';
+    return {
+        data: visible.data,
+        error: visible.error,
+        status,
+        isPending: status === 'connecting' || status === 'loading',
+        isReady: status === 'ready' || status === 'refreshing',
+        isEmpty: visible.hasResolved
+            && (status === 'ready' || status === 'refreshing')
+            && visible.data == null,
+        isLoading: visible.isLoading,
+        isRefreshing: visible.isRefreshing,
+        refresh: runRead,
+    };
+}
+
+const readSourceIds = new WeakMap();
+let nextReadSourceId = 0;
+function readSourceId(read) {
+    if (!read)
+        return 0;
+    const existing = readSourceIds.get(read);
+    if (existing !== undefined)
+        return existing;
+    const id = ++nextReadSourceId;
+    readSourceIds.set(read, id);
+    return id;
+}
+/**
+ * Wrap a stack's connected `read` functions in React hooks, mirroring how
+ * program operations get `useMutation`. Each read exposes `.use(...args)`:
+ * the args form the cache key and the read stays disabled while any required
+ * arg is nullish, so `read.solClaimPreview.use(authority)` simply waits for a
+ * connected wallet instead of needing non-null assertions and an `enabled`
+ * flag.
+ *
+ * Hook-only options occupy the position after every declared read argument.
+ * Optional read arguments must therefore be passed as `undefined` when options
+ * follow them, keeping object-valued read arguments unambiguous.
+ *
+ * A proxy backs the interface so hooks exist (and stay disabled) before the
+ * client connects — components can call them unconditionally.
+ */
+function buildReadInterfaces(read, readArgCounts) {
+    return new Proxy({}, {
+        get: (_target, name) => {
+            if (typeof name !== 'string') {
+                return undefined;
+            }
+            const readFn = read?.[name];
+            const sourceId = readSourceId(readFn);
+            const readArgCount = readArgCounts?.[name];
+            const [requiredArgCount, totalArgCount] = Array.isArray(readArgCount)
+                ? readArgCount
+                : [readArgCount, readArgCount];
+            const useRead = (options, args) => {
+                const hasArgs = args.length >= requiredArgCount
+                    && args
+                        .slice(0, requiredArgCount)
+                        .every((arg) => arg !== undefined && arg !== null);
+                return useAsyncRead([name, sourceId, ...args], async () => {
+                    if (!readFn) {
+                        throw new Error('Arete client is not connected');
+                    }
+                    return readFn(...args);
+                }, {
+                    ...options,
+                    enabled: readFn != null && hasArgs,
+                    disabledStatus: hasArgs && readFn == null ? 'connecting' : 'disabled',
+                });
+            };
+            const use = (...argsAndOptions) => {
+                if (!Number.isInteger(requiredArgCount)
+                    || !Number.isInteger(totalArgCount)
+                    || requiredArgCount < 0
+                    || totalArgCount < requiredArgCount) {
+                    throw new Error(`Missing read argument count metadata for "${name}"`);
+                }
+                let options;
+                let args = argsAndOptions;
+                if (argsAndOptions.length <= totalArgCount) {
+                    options = undefined;
+                }
+                else if (argsAndOptions.length !== totalArgCount + 1) {
+                    throw new Error(`Read hook "${name}" expects ${totalArgCount} argument(s) followed by optional hook options`);
+                }
+                else {
+                    const candidate = argsAndOptions[totalArgCount];
+                    if (candidate === null || typeof candidate !== 'object' || Array.isArray(candidate)) {
+                        throw new Error(`Read hook options for "${name}" must be an object`);
+                    }
+                    options = candidate;
+                    args = argsAndOptions.slice(0, totalArgCount);
+                }
+                return useRead(options, args);
+            };
+            const imperative = (...args) => {
+                if (!readFn) {
+                    throw new Error('Arete client is not connected');
+                }
+                return readFn(...args);
+            };
+            return Object.assign(imperative, {
+                use,
+            });
+        },
+    });
+}
+
+const noop = () => { };
+function queryError(value, fallback) {
+    if (value instanceof sdk.AreteError)
+        return value;
+    return new sdk.AreteError(value instanceof Error ? value.message : fallback, 'SUBSCRIPTION_ERROR', value);
+}
+function useQuery(client, query, snapshotEnabled, enabled, initialData) {
+    const queryKey = sdk.canonicalQueryKey({ query, snapshot: { enabled: snapshotEnabled } });
+    const stateRef = React.useRef({
+        client,
+        queryKey,
+        lease: null,
+        hasInitialData: initialData !== undefined,
+        fallback: {
+            subscriptionId: `pending:${queryKey}`,
+            query,
+            keys: [],
+            data: initialData ?? [],
+            isLoading: enabled && snapshotEnabled && initialData === undefined,
+            isRefreshing: false,
+        },
+    });
+    if (stateRef.current.client !== client || stateRef.current.queryKey !== queryKey) {
+        stateRef.current = {
+            client,
+            queryKey,
+            lease: null,
+            hasInitialData: initialData !== undefined,
+            fallback: {
+                subscriptionId: `pending:${queryKey}`,
+                query,
+                keys: [],
+                data: initialData ?? [],
+                isLoading: enabled && snapshotEnabled && initialData === undefined,
+                isRefreshing: false,
+            },
+        };
+    }
+    const state = stateRef.current;
+    const subscribe = React.useCallback((callback) => {
+        if (!enabled || !client)
+            return noop;
+        try {
+            const lease = client.getSubscriptionRegistry().subscribe(query, snapshotEnabled);
+            state.lease = lease;
+            const unsubscribe = lease.onChange(callback);
+            return () => {
+                unsubscribe();
+                lease.release();
+                if (state.lease === lease)
+                    state.lease = null;
+            };
+        }
+        catch (value) {
+            state.fallback = {
+                ...state.fallback,
+                isLoading: false,
+                isRefreshing: false,
+                error: queryError(value, 'Subscription failed'),
+            };
+            return noop;
+        }
+        // queryKey represents every query field; state is replaced with that key.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [client, enabled, queryKey, snapshotEnabled]);
+    const getSnapshot = React.useCallback(() => {
+        if (!state.lease)
+            return state.fallback;
+        try {
+            const current = state.lease.getSnapshot();
+            if (state.hasInitialData && current.isLoading && current.data.length === 0) {
+                if (state.seededSource !== current) {
+                    state.seededSource = current;
+                    state.seededSnapshot = {
+                        ...current,
+                        data: state.fallback.data,
+                        isLoading: false,
+                    };
+                }
+                return state.seededSnapshot;
+            }
+            return current;
+        }
+        catch (value) {
+            state.fallback = {
+                ...state.fallback,
+                isLoading: false,
+                isRefreshing: false,
+                error: queryError(value, 'Subscription snapshot failed'),
+            };
+            return state.fallback;
+        }
+        // state is replaced whenever either listed identity changes.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [queryKey, client]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    const getServerSnapshot = React.useCallback(() => state.fallback, [queryKey, client]);
+    const snapshot = React.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+    const refresh = React.useCallback(async () => {
+        if (!state.lease)
+            return;
+        await state.lease.refresh();
+        // state is replaced whenever either listed identity changes.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [queryKey, client]);
+    return { snapshot, refresh };
+}
+function computeStatus(enabled, client, snapshot) {
+    if (!enabled)
+        return 'disabled';
+    if (!client)
+        return 'connecting';
+    if (snapshot.error)
+        return 'error';
+    return snapshot.isLoading ? 'subscribing' : 'ready';
+}
+function useProjectedData(snapshot, schema, onSchemaValidationError) {
+    const callbackRef = React.useRef(onSchemaValidationError);
+    callbackRef.current = onSchemaValidationError;
+    const cache = React.useRef({ snapshot: null, schema, value: [], diagnostics: [] });
+    if (cache.current.snapshot !== snapshot || cache.current.schema !== schema) {
+        const value = [];
+        const diagnostics = [];
+        snapshot.data.forEach((entity, index) => {
+            if (!schema) {
+                value.push(entity);
+                return;
+            }
+            try {
+                const parsed = schema.safeParse(entity);
+                if (parsed.success) {
+                    value.push(parsed.data);
+                }
+                else {
+                    diagnostics.push({
+                        view: snapshot.query.view,
+                        ...(snapshot.keys[index] === undefined ? {} : { key: snapshot.keys[index] }),
+                        entity,
+                        error: parsed.error,
+                    });
+                }
+            }
+            catch (error) {
+                diagnostics.push({
+                    view: snapshot.query.view,
+                    ...(snapshot.keys[index] === undefined ? {} : { key: snapshot.keys[index] }),
+                    entity,
+                    error,
+                });
+            }
+        });
+        cache.current = { snapshot, schema, value, diagnostics };
+    }
+    const projection = cache.current;
+    React.useEffect(() => {
+        const callback = callbackRef.current;
+        if (!callback)
+            return;
+        for (const diagnostic of projection.diagnostics) {
+            try {
+                callback(diagnostic);
+            }
+            catch (error) {
+                console.error('[Arete] View schema validation callback failed:', error);
+            }
+        }
+    }, [projection]);
+    return projection.value;
+}
+function useStateView(viewDef, client, key, options) {
+    const enabled = options?.enabled !== false && key !== null && key !== undefined;
+    const keyString = key === null || key === undefined
+        ? undefined
+        : sdk.serializeViewKey(viewDef, key);
+    const query = {
+        view: viewDef.view,
+        ...(keyString === undefined ? {} : { key: keyString }),
+        ...(options?.partition === undefined ? {} : { partition: options.partition }),
+        ...(options?.filters === undefined ? {} : { filters: options.filters }),
+        ...(options?.after === undefined ? {} : { after: options.after }),
+        ...(options?.snapshotLimit === undefined ? {} : { snapshotLimit: options.snapshotLimit }),
+    };
+    const snapshotEnabled = options?.withSnapshot ?? true;
+    const { snapshot, refresh } = useQuery(client, query, snapshotEnabled, enabled, options?.initialData === undefined ? undefined : [options.initialData]);
+    const data = useProjectedData(snapshot, options?.schema, options?.onSchemaValidationError)[0];
+    const status = computeStatus(enabled, client, snapshot);
+    return {
+        data: enabled ? data : undefined,
+        status,
+        isPending: status === 'connecting' || status === 'subscribing',
+        isReady: status === 'ready',
+        isEmpty: status === 'ready' && data === undefined,
+        isLoading: enabled && snapshot.isLoading,
+        isRefreshing: enabled && snapshot.isRefreshing,
+        error: status === 'error' ? snapshot.error : undefined,
+        refresh,
+    };
+}
+function useListView(viewDef, client, params, options) {
+    const enabled = options?.enabled !== false;
+    const partition = params?.partition ?? options?.partition;
+    const filters = params?.filters ?? options?.filters;
+    const after = params?.after ?? options?.after;
+    const snapshotLimit = params?.snapshotLimit ?? options?.snapshotLimit;
+    const query = {
+        view: viewDef.view,
+        ...(params?.key === undefined ? {} : { key: params.key }),
+        ...(partition === undefined ? {} : { partition }),
+        ...(filters === undefined ? {} : { filters }),
+        ...(params?.take === undefined ? {} : { take: params.take }),
+        ...(params?.skip === undefined ? {} : { skip: params.skip }),
+        ...(after === undefined ? {} : { after }),
+        ...(snapshotLimit === undefined ? {} : { snapshotLimit }),
+    };
+    const snapshotEnabled = params?.withSnapshot ?? options?.withSnapshot ?? true;
+    const { snapshot, refresh } = useQuery(client, query, snapshotEnabled, enabled, options?.initialData);
+    const data = useProjectedData(snapshot, (params?.schema ?? options?.schema), params?.onSchemaValidationError ?? options?.onSchemaValidationError);
+    const status = computeStatus(enabled, client, snapshot);
+    return {
+        data: enabled ? data : options?.initialData,
+        status,
+        isPending: status === 'connecting' || status === 'subscribing',
+        isReady: status === 'ready',
+        isEmpty: status === 'ready' && data.length === 0,
+        isLoading: enabled && snapshot.isLoading,
+        isRefreshing: enabled && snapshot.isRefreshing,
+        error: status === 'error' ? snapshot.error : undefined,
+        refresh,
+    };
+}
+function createStateViewHook(viewDef, client) {
+    function use(key, options) {
+        return useStateView(viewDef, client, key, options);
+    }
+    function refresh(key) {
+        if (!client)
+            return Promise.resolve();
+        const keyString = key === null || key === undefined
+            ? undefined
+            : sdk.serializeViewKey(viewDef, key);
+        return client.getSubscriptionRegistry().refreshView(viewDef.view, keyString);
+    }
+    return { use, refresh };
+}
+function createListViewHook(viewDef, client) {
+    function use(params, options) {
+        const listOptions = params?.take === 1
+            ? options
+                ? {
+                    ...options,
+                    initialData: options.initialData === undefined
+                        ? undefined
+                        : [options.initialData],
+                }
+                : undefined
+            : options;
+        const result = useListView(viewDef, client, params, listOptions);
+        if (params?.take !== 1)
+            return result;
+        return { ...result, data: result.data?.[0] };
+    }
+    function useOne(params, options) {
+        const listOptions = options
+            ? {
+                ...options,
+                initialData: options.initialData === undefined
+                    ? undefined
+                    : [options.initialData],
+            }
+            : undefined;
+        const result = useListView(viewDef, client, { ...(params ?? {}), take: 1 }, listOptions);
+        return { ...result, data: result.data?.[0] };
+    }
+    function refresh() {
+        if (!client)
+            return Promise.resolve();
+        return client.getSubscriptionRegistry().refreshView(viewDef.view);
+    }
+    return { use, useOne, refresh };
+}
+
+function normalizeConnectionError(value, fallback) {
+    if (value instanceof Error)
+        return value;
+    return new Error(typeof value === 'string' && value.length > 0 ? value : fallback);
+}
+function useArete(stack, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+options
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    const { getOrCreateClient, getClient, retryClient, subscribeToClientChanges, config, } = useAreteContext();
+    const resolvedStack = stack ?? config.stack;
+    if (!resolvedStack) {
+        throw new Error('useArete() was called without a stack and no default stack is configured. ' +
+            'Pass a stack explicitly or set <AreteProvider stack={...}>.');
+    }
+    const usesProviderStack = stack === undefined || stack === config.stack;
+    const resolvedOptions = (usesProviderStack
+        ? { ...(config.stackOptions ?? {}), ...(options ?? {}) }
+        : options);
+    const url = resolvedOptions?.url;
+    const httpUrl = resolvedOptions?.httpUrl;
+    const transport = resolvedOptions?.transport;
+    const attachedPrograms = resolvedOptions?.programs;
+    const lookupOptions = React.useMemo(() => ({ url, httpUrl, transport, programs: attachedPrograms }), [url, httpUrl, transport, attachedPrograms]);
+    const lookupKey = createClientCacheKey(resolvedStack, lookupOptions);
+    const initialClient = getClient(resolvedStack, lookupOptions);
+    const [clientState, setClientState] = React.useState(() => ({ lookupKey, client: initialClient }));
+    const clientStateRef = React.useRef(clientState);
+    clientStateRef.current = clientState;
+    const client = clientState.lookupKey === lookupKey ? clientState.client : null;
+    const [isConnecting, setIsConnecting] = React.useState(!initialClient);
+    const [error, setError] = React.useState(null);
+    const [socketIssue, setSocketIssue] = React.useState(null);
+    const [connectionState, setConnectionState] = React.useState(() => client?.connectionState ?? 'disconnected');
+    const retryPromiseRef = React.useRef(null);
+    const lookupKeyRef = React.useRef(lookupKey);
+    lookupKeyRef.current = lookupKey;
+    React.useEffect(() => {
+        let active = true;
+        const existingClient = getClient(resolvedStack, lookupOptions);
+        if (existingClient) {
+            setClientState({
+                lookupKey,
+                client: existingClient,
+            });
+            setIsConnecting(false);
+            setError(null);
+            setSocketIssue(null);
+            return () => {
+                active = false;
+            };
+        }
+        setClientState({ lookupKey, client: null });
+        setIsConnecting(true);
+        setError(null);
+        setSocketIssue(null);
+        getOrCreateClient(resolvedStack, lookupOptions)
+            .then((newClient) => {
+            if (active) {
+                setClientState({
+                    lookupKey,
+                    client: newClient,
+                });
+                setIsConnecting(false);
+            }
+        })
+            .catch((err) => {
+            if (active) {
+                setError(err instanceof Error ? err : new Error(String(err)));
+                setIsConnecting(false);
+            }
+        });
+        return () => {
+            active = false;
+        };
+    }, [resolvedStack, getOrCreateClient, getClient, lookupKey, lookupOptions]);
+    React.useEffect(() => subscribeToClientChanges((change) => {
+        if (change && change.cacheKey !== lookupKey)
+            return;
+        const sharedClient = getClient(resolvedStack, lookupOptions);
+        const current = clientStateRef.current;
+        if (change?.status === 'connecting') {
+            const next = { lookupKey, client: null };
+            clientStateRef.current = next;
+            setClientState(next);
+            setIsConnecting(true);
+            setError(null);
+            setSocketIssue(null);
+            return;
+        }
+        if (change?.status === 'error') {
+            const next = { lookupKey, client: null };
+            clientStateRef.current = next;
+            setClientState(next);
+            setIsConnecting(false);
+            setError(change.error ?? new Error('Arete connection attempt failed'));
+            setSocketIssue(null);
+            return;
+        }
+        if (current.lookupKey === lookupKey && current.client === sharedClient)
+            return;
+        const next = { lookupKey, client: sharedClient };
+        clientStateRef.current = next;
+        setClientState(next);
+        setIsConnecting(sharedClient === null);
+        setError(null);
+        setSocketIssue(null);
+    }), [getClient, lookupKey, lookupOptions, resolvedStack, subscribeToClientChanges]);
+    React.useEffect(() => {
+        if (!client) {
+            setConnectionState('disconnected');
+            return;
+        }
+        setConnectionState(client.connectionState);
+        const unsubscribeState = client.onConnectionStateChange((state, stateError) => {
+            setConnectionState(state);
+            if (state === 'error') {
+                setError(normalizeConnectionError(stateError, 'Arete connection entered an error state'));
+            }
+            else if (state === 'connected') {
+                setError(null);
+                setSocketIssue(null);
+            }
+        });
+        const unsubscribeIssue = client.onSocketIssue((issue) => {
+            setSocketIssue(issue);
+        });
+        return () => {
+            unsubscribeIssue();
+            unsubscribeState();
+        };
+    }, [client]);
+    const retry = React.useCallback(() => {
+        if (retryPromiseRef.current?.lookupKey === lookupKey) {
+            return retryPromiseRef.current.promise;
+        }
+        const retryLookupKey = lookupKey;
+        setError(null);
+        setSocketIssue(null);
+        setIsConnecting(true);
+        setClientState({ lookupKey: retryLookupKey, client: null });
+        const attempt = retryClient(resolvedStack, lookupOptions).then((newClient) => {
+            if (lookupKeyRef.current === retryLookupKey) {
+                setClientState({
+                    lookupKey: retryLookupKey,
+                    client: newClient,
+                });
+                setIsConnecting(false);
+            }
+        });
+        const tracked = attempt.catch((value) => {
+            const retryError = normalizeConnectionError(value, 'Arete connection retry failed');
+            if (lookupKeyRef.current === retryLookupKey) {
+                setError(retryError);
+                setIsConnecting(false);
+            }
+            throw retryError;
+        }).finally(() => {
+            if (retryPromiseRef.current?.promise === tracked) {
+                retryPromiseRef.current = null;
+            }
+        });
+        retryPromiseRef.current = { lookupKey, promise: tracked };
+        return tracked;
+    }, [lookupKey, lookupOptions, retryClient, resolvedStack]);
+    const views = React.useMemo(() => {
+        const result = {};
+        for (const [viewName, viewGroup] of Object.entries(resolvedStack.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;
+    }, [resolvedStack, client]);
+    const programs = React.useMemo(() => {
+        if (!client) {
+            // Placeholder hooks so components can render (and keep hook order)
+            // before the client connects; submitting throws "not connected".
+            return buildDisconnectedProgramHooks();
+        }
+        return buildProgramHookInterfaces(client.programs, client, useInstructionMutation, { defaultReconciliation: transport !== 'http' });
+    }, [client, transport]);
+    const connectedRead = (client?.read ?? null);
+    const readArgCounts = sdk.getStackRuntimeExtensions(resolvedStack)?.readArgCounts;
+    const read = React.useMemo(() => buildReadInterfaces(connectedRead, readArgCounts), [connectedRead, readArgCounts]);
+    const isClientPending = clientState.lookupKey !== lookupKey || isConnecting;
+    const visibleError = clientState.lookupKey === lookupKey ? error : null;
+    const status = isClientPending
+        ? 'connecting'
+        : visibleError
+            ? 'error'
+            : client
+                ? connectionState
+                : 'disconnected';
+    return {
+        views: views,
+        queries: (client?.queries ?? {}),
+        programs: programs,
+        chain: client?.chain ?? null,
+        zustandStore: client?.store?.store ?? null,
+        client,
+        read,
+        reads: read,
+        addresses: (client?.addresses
+            ?? resolvedStack.addresses),
+        constants: (client?.constants
+            ?? resolvedStack.constants),
+        defaults: (client?.defaults
+            ?? resolvedStack.defaults),
+        math: (client?.math
+            ?? resolvedStack.math),
+        connectionState: client ? connectionState : 'disconnected',
+        status,
+        isConnected: Boolean(client) && connectionState === 'connected',
+        isLoading: isClientPending,
+        canRetry: config.autoConnect !== false
+            && (status === 'error' || status === 'disconnected'),
+        error: visibleError,
+        socketIssue: clientState.lookupKey === lookupKey ? socketIssue : null,
+        retry,
+    };
+}
+
+/**
+ * Bind the React SDK to one generated stack without ambient module
+ * augmentation. The returned hook remains explicit through an app-specific
+ * name such as `useOre`, while the generic provider and hook remain available
+ * for multi-stack applications.
+ */
+function createAreteReact(stack) {
+    function Provider({ children, ...config }) {
+        return (React.createElement(AreteProvider, { ...config, stack: stack }, children));
+    }
+    function useBoundArete(options) {
+        return useArete(stack, options);
+    }
+    return {
+        Provider,
+        useArete: useBoundArete,
+        stack,
+    };
+}
+
+/**
+ * Aggregate the status of connection, view, and read hook results into loading,
+ * refreshing, and error lists. Pure function; call it during render.
+ *
+ * ```tsx
+ * const streams = summarizeStatuses({ Board: board, Round: round, Miner: authority && miner });
+ * {streams.loading.length > 0 && <p>Loading: {streams.loading.join(', ')}</p>}
+ * {streams.errors.length > 0 && <p role="alert">{streams.errors.join(' · ')}</p>}
+ * ```
+ */
+function summarizeStatuses(sources) {
+    const loading = [];
+    const errors = [];
+    const refreshing = [];
+    for (const [name, source] of Object.entries(sources)) {
+        if (!source)
+            continue;
+        if (source.isLoading)
+            loading.push(name);
+        if (source.isRefreshing)
+            refreshing.push(name);
+        if (source.error)
+            errors.push(`${name}: ${source.error.message}`);
+    }
+    return {
+        isLoading: loading.length > 0,
+        hasError: errors.length > 0,
+        isRefreshing: refreshing.length > 0,
+        loading,
+        errors,
+        refreshing,
+    };
+}
+/** @deprecated Use summarizeStatuses; it also accepts connection and read results. */
+const summarizeViews = summarizeStatuses;
+
+const chainIds = new WeakMap();
+let nextChainId = 1;
+function chainKey(chain) {
+    if (!chain) {
+        return null;
+    }
+    const existing = chainIds.get(chain);
+    if (existing !== undefined) {
+        return existing;
+    }
+    const id = nextChainId++;
+    chainIds.set(chain, id);
+    return id;
+}
+function abortError() {
+    const error = new Error('Chain read was aborted');
+    error.name = 'AbortError';
+    return error;
+}
+function useNativeBalance(chain, address, options = {}) {
+    const enabled = (options.enabled ?? true) && Boolean(chain && address);
+    const minContextSlot = options.minContextSlot;
+    return useAsyncRead(['native-balance', chainKey(chain), address, minContextSlot?.toString()], async ({ signal }) => {
+        if (!chain || !address) {
+            throw new Error('Chain client and address are required for a native balance read');
+        }
+        if (signal.aborted)
+            throw abortError();
+        const result = await chain.nativeBalance(address, { minContextSlot });
+        if (signal.aborted)
+            throw abortError();
+        return result;
+    }, { enabled, initialData: options.initialData });
+}
+function useTokenBalance(chain, input, options = {}) {
+    const enabled = (options.enabled ?? true) && Boolean(chain && input);
+    const minContextSlot = options.minContextSlot;
+    return useAsyncRead([
+        'token-balance',
+        chainKey(chain),
+        input?.owner,
+        input?.mint,
+        input?.tokenProgram,
+        minContextSlot?.toString(),
+    ], async ({ signal }) => {
+        if (!chain || !input) {
+            throw new Error('Chain client and token input are required for a token balance read');
+        }
+        if (signal.aborted)
+            throw abortError();
+        const result = await chain.balance(input, { minContextSlot });
+        if (signal.aborted)
+            throw abortError();
+        return result;
+    }, { enabled, initialData: options.initialData });
+}
+
+Object.defineProperty(exports, 'Arete', {
+    enumerable: true,
+    get: function () { return sdk.Arete; }
+});
+Object.defineProperty(exports, 'AreteError', {
+    enumerable: true,
+    get: function () { return sdk.AreteError; }
+});
+Object.defineProperty(exports, 'ConnectionManager', {
+    enumerable: true,
+    get: function () { return sdk.ConnectionManager; }
+});
+Object.defineProperty(exports, 'DEFAULT_CONFIG', {
+    enumerable: true,
+    get: function () { return sdk.DEFAULT_CONFIG; }
+});
+Object.defineProperty(exports, 'DEFAULT_MAX_ENTRIES_PER_VIEW', {
+    enumerable: true,
+    get: function () { return sdk.DEFAULT_MAX_ENTRIES_PER_VIEW; }
+});
+Object.defineProperty(exports, 'FrameProcessor', {
+    enumerable: true,
+    get: function () { return sdk.FrameProcessor; }
+});
+Object.defineProperty(exports, 'InstructionError', {
+    enumerable: true,
+    get: function () { return sdk.InstructionError; }
+});
+Object.defineProperty(exports, 'MemoryAdapter', {
+    enumerable: true,
+    get: function () { return sdk.MemoryAdapter; }
+});
+Object.defineProperty(exports, 'OperationCallbackError', {
+    enumerable: true,
+    get: function () { return sdk.OperationCallbackError; }
+});
+Object.defineProperty(exports, 'OperationExecutionError', {
+    enumerable: true,
+    get: function () { return sdk.OperationExecutionError; }
+});
+Object.defineProperty(exports, 'ProcessedSlotTimeoutError', {
+    enumerable: true,
+    get: function () { return sdk.ProcessedSlotTimeoutError; }
+});
+Object.defineProperty(exports, 'QueryStore', {
+    enumerable: true,
+    get: function () { return sdk.QueryStore; }
+});
+Object.defineProperty(exports, 'ReadRequestError', {
+    enumerable: true,
+    get: function () { return sdk.ReadRequestError; }
+});
+Object.defineProperty(exports, 'SubscriptionRegistry', {
+    enumerable: true,
+    get: function () { return sdk.SubscriptionRegistry; }
+});
+Object.defineProperty(exports, 'TransactionExecutionError', {
+    enumerable: true,
+    get: function () { return sdk.TransactionExecutionError; }
+});
+Object.defineProperty(exports, 'buildInstruction', {
+    enumerable: true,
+    get: function () { return sdk.buildInstruction; }
+});
+Object.defineProperty(exports, 'canonicalQueryKey', {
+    enumerable: true,
+    get: function () { return sdk.canonicalQueryKey; }
+});
+Object.defineProperty(exports, 'createInstructionExecutor', {
+    enumerable: true,
+    get: function () { return sdk.createInstructionExecutor; }
+});
+Object.defineProperty(exports, 'createInstructionHandler', {
+    enumerable: true,
+    get: function () { return sdk.createInstructionHandler; }
+});
+Object.defineProperty(exports, 'createPublicKeySeed', {
+    enumerable: true,
+    get: function () { return sdk.createPublicKeySeed; }
+});
+Object.defineProperty(exports, 'createSeed', {
+    enumerable: true,
+    get: function () { return sdk.createSeed; }
+});
+Object.defineProperty(exports, 'derivePda', {
+    enumerable: true,
+    get: function () { return sdk.derivePda; }
+});
+Object.defineProperty(exports, 'executeInstruction', {
+    enumerable: true,
+    get: function () { return sdk.executeInstruction; }
+});
+Object.defineProperty(exports, 'formatProgramError', {
+    enumerable: true,
+    get: function () { return sdk.formatProgramError; }
+});
+Object.defineProperty(exports, 'formatRawToUi', {
+    enumerable: true,
+    get: function () { return sdk.formatRawToUi; }
+});
+Object.defineProperty(exports, 'getTransactionFailureOutcome', {
+    enumerable: true,
+    get: function () { return sdk.getTransactionFailureOutcome; }
+});
+Object.defineProperty(exports, 'isErrorFrame', {
+    enumerable: true,
+    get: function () { return sdk.isErrorFrame; }
+});
+Object.defineProperty(exports, 'isHostedAreteEndpoint', {
+    enumerable: true,
+    get: function () { return sdk.isHostedAreteEndpoint; }
+});
+Object.defineProperty(exports, 'isSnapshotFrame', {
+    enumerable: true,
+    get: function () { return sdk.isSnapshotFrame; }
+});
+Object.defineProperty(exports, 'isSubscribedFrame', {
+    enumerable: true,
+    get: function () { return sdk.isSubscribedFrame; }
+});
+Object.defineProperty(exports, 'isUnsubscribedFrame', {
+    enumerable: true,
+    get: function () { return sdk.isUnsubscribedFrame; }
+});
+Object.defineProperty(exports, 'isValidFrame', {
+    enumerable: true,
+    get: function () { return sdk.isValidFrame; }
+});
+Object.defineProperty(exports, 'normalizeSubscriptionQuery', {
+    enumerable: true,
+    get: function () { return sdk.normalizeSubscriptionQuery; }
+});
+Object.defineProperty(exports, 'parseFrame', {
+    enumerable: true,
+    get: function () { return sdk.parseFrame; }
+});
+Object.defineProperty(exports, 'parseFrameFromBlob', {
+    enumerable: true,
+    get: function () { return sdk.parseFrameFromBlob; }
+});
+Object.defineProperty(exports, 'parseInstructionError', {
+    enumerable: true,
+    get: function () { return sdk.parseInstructionError; }
+});
+Object.defineProperty(exports, 'resolveAccounts', {
+    enumerable: true,
+    get: function () { return sdk.resolveAccounts; }
+});
+Object.defineProperty(exports, 'safeToRawAmount', {
+    enumerable: true,
+    get: function () { return sdk.safeToRawAmount; }
+});
+Object.defineProperty(exports, 'serializeInstructionData', {
+    enumerable: true,
+    get: function () { return sdk.serializeInstructionData; }
+});
+Object.defineProperty(exports, 'serializeViewKey', {
+    enumerable: true,
+    get: function () { return sdk.serializeViewKey; }
+});
+Object.defineProperty(exports, 'stringifyBigints', {
+    enumerable: true,
+    get: function () { return sdk.stringifyBigints; }
+});
+Object.defineProperty(exports, 'toRawAmount', {
+    enumerable: true,
+    get: function () { return sdk.toRawAmount; }
+});
+Object.defineProperty(exports, 'unwrapOperationExecutionError', {
+    enumerable: true,
+    get: function () { return sdk.unwrapOperationExecutionError; }
+});
+Object.defineProperty(exports, 'validateAccountResolution', {
+    enumerable: true,
+    get: function () { return sdk.validateAccountResolution; }
+});
+Object.defineProperty(exports, 'withPrograms', {
+    enumerable: true,
+    get: function () { return sdk.withPrograms; }
+});
+exports.AreteProvider = AreteProvider;
+exports.DEFAULT_RECONCILIATION_TIMEOUT_MS = DEFAULT_RECONCILIATION_TIMEOUT_MS;
+exports.ZustandAdapter = ZustandAdapter;
+exports.createAreteReact = createAreteReact;
+exports.createProcessedSlotReconciliation = createProcessedSlotReconciliation;
+exports.reconcileProcessedSlot = reconcileProcessedSlot;
+exports.summarizeStatuses = summarizeStatuses;
+exports.summarizeViews = summarizeViews;
+exports.useArete = useArete;
+exports.useAreteContext = useAreteContext;
+exports.useAsyncRead = useAsyncRead;
+exports.useConnectionState = useConnectionState;
+exports.useInstructionMutation = useInstructionMutation;
+exports.useNativeBalance = useNativeBalance;
+exports.useReconcileProcessedSlot = useReconcileProcessedSlot;
+exports.useTokenBalance = useTokenBalance;
+//# sourceMappingURL=index.cjs.map