@usearete/sdk 0.2.0 → 0.4.0

package/dist/index.js

@@ -1,4448 +0,0 @@
-'use strict';
-
-var pako = require('pako');
-var ed25519 = require('@noble/ed25519');
-
-const DEFAULT_MAX_ENTRIES_PER_VIEW = 10000;
-const DEFAULT_CONFIG = {
-    reconnectIntervals: [1000, 2000, 4000, 8000, 16000],
-    maxReconnectAttempts: 5,
-    maxEntriesPerView: DEFAULT_MAX_ENTRIES_PER_VIEW,
-};
-/**
- * Determines if the error indicates the client should fetch a new token
- */
-function shouldRefreshToken(code) {
-    return [
-        'TOKEN_EXPIRED',
-        'TOKEN_INVALID_SIGNATURE',
-        'TOKEN_INVALID_FORMAT',
-        'TOKEN_INVALID_ISSUER',
-        'TOKEN_INVALID_AUDIENCE',
-        'TOKEN_KEY_NOT_FOUND',
-    ].includes(code);
-}
-class AreteError extends Error {
-    constructor(message, code, details) {
-        super(message);
-        this.code = code;
-        this.details = details;
-        this.name = 'AreteError';
-    }
-}
-/**
- * Parse a kebab-case error code string (from X-Error-Code header) to AuthErrorCode
- */
-function parseErrorCode(errorCode) {
-    const codeMap = {
-        'token-missing': 'TOKEN_MISSING',
-        'token-expired': 'TOKEN_EXPIRED',
-        'token-invalid-signature': 'TOKEN_INVALID_SIGNATURE',
-        'token-invalid-format': 'TOKEN_INVALID_FORMAT',
-        'token-invalid-issuer': 'TOKEN_INVALID_ISSUER',
-        'token-invalid-audience': 'TOKEN_INVALID_AUDIENCE',
-        'token-missing-claim': 'TOKEN_MISSING_CLAIM',
-        'token-key-not-found': 'TOKEN_KEY_NOT_FOUND',
-        'origin-mismatch': 'ORIGIN_MISMATCH',
-        'origin-required': 'ORIGIN_REQUIRED',
-        'origin-not-allowed': 'ORIGIN_NOT_ALLOWED',
-        'rate-limit-exceeded': 'RATE_LIMIT_EXCEEDED',
-        'websocket-session-rate-limit-exceeded': 'WEBSOCKET_SESSION_RATE_LIMIT_EXCEEDED',
-        'connection-limit-exceeded': 'CONNECTION_LIMIT_EXCEEDED',
-        'subscription-limit-exceeded': 'SUBSCRIPTION_LIMIT_EXCEEDED',
-        'snapshot-limit-exceeded': 'SNAPSHOT_LIMIT_EXCEEDED',
-        'egress-limit-exceeded': 'EGRESS_LIMIT_EXCEEDED',
-        'invalid-static-token': 'INVALID_STATIC_TOKEN',
-        'internal-error': 'INTERNAL_ERROR',
-        'auth-required': 'AUTH_REQUIRED',
-        'missing-authorization-header': 'MISSING_AUTHORIZATION_HEADER',
-        'invalid-authorization-format': 'INVALID_AUTHORIZATION_FORMAT',
-        'invalid-api-key': 'INVALID_API_KEY',
-        'expired-api-key': 'EXPIRED_API_KEY',
-        'user-not-found': 'USER_NOT_FOUND',
-        'secret-key-required': 'SECRET_KEY_REQUIRED',
-        'deployment-access-denied': 'DEPLOYMENT_ACCESS_DENIED',
-        'quota-exceeded': 'QUOTA_EXCEEDED',
-    };
-    return codeMap[errorCode.toLowerCase()] || 'INTERNAL_ERROR';
-}
-
-const GZIP_MAGIC_0 = 0x1f;
-const GZIP_MAGIC_1 = 0x8b;
-function isGzipData(data) {
-    return data.length >= 2 && data[0] === GZIP_MAGIC_0 && data[1] === GZIP_MAGIC_1;
-}
-function isSnapshotFrame(frame) {
-    return frame.op === 'snapshot';
-}
-function isSubscribedFrame(frame) {
-    return frame.op === 'subscribed';
-}
-function isEntityFrame(frame) {
-    return ['create', 'upsert', 'patch', 'delete'].includes(frame.op);
-}
-function parseFrame(data) {
-    if (typeof data === 'string') {
-        return JSON.parse(data);
-    }
-    const bytes = new Uint8Array(data);
-    if (isGzipData(bytes)) {
-        const decompressed = pako.inflate(bytes);
-        const jsonString = new TextDecoder().decode(decompressed);
-        return JSON.parse(jsonString);
-    }
-    const jsonString = new TextDecoder('utf-8').decode(data);
-    return JSON.parse(jsonString);
-}
-async function parseFrameFromBlob(blob) {
-    const arrayBuffer = await blob.arrayBuffer();
-    return parseFrame(arrayBuffer);
-}
-function isValidFrame(frame) {
-    if (typeof frame !== 'object' || frame === null) {
-        return false;
-    }
-    const f = frame;
-    if (typeof f['entity'] !== 'string' ||
-        typeof f['op'] !== 'string' ||
-        typeof f['mode'] !== 'string' ||
-        !['state', 'append', 'list'].includes(f['mode'])) {
-        return false;
-    }
-    if (f['op'] === 'snapshot') {
-        return Array.isArray(f['data']);
-    }
-    return (typeof f['key'] === 'string' &&
-        ['create', 'upsert', 'patch', 'delete'].includes(f['op']));
-}
-
-const TOKEN_REFRESH_BUFFER_SECONDS = 60;
-const MIN_REFRESH_DELAY_MS = 1000;
-const DEFAULT_QUERY_PARAMETER = 'hs_token';
-const DEFAULT_HOSTED_TOKEN_ENDPOINT = 'https://api.arete.run/ws/sessions';
-const HOSTED_WEBSOCKET_SUFFIX = '.stack.arete.run';
-function normalizeTokenResult(result) {
-    if (typeof result === 'string') {
-        return { token: result };
-    }
-    return result;
-}
-function decodeBase64Url(value) {
-    const normalized = value.replace(/-/g, '+').replace(/_/g, '/');
-    const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, '=');
-    if (typeof atob === 'function') {
-        return atob(padded);
-    }
-    const bufferCtor = globalThis.Buffer;
-    if (bufferCtor) {
-        return bufferCtor.from(padded, 'base64').toString('utf-8');
-    }
-    return undefined;
-}
-function parseJwtExpiry(token) {
-    const parts = token.split('.');
-    if (parts.length !== 3) {
-        return undefined;
-    }
-    const payload = decodeBase64Url(parts[1] ?? '');
-    if (!payload) {
-        return undefined;
-    }
-    try {
-        const decoded = JSON.parse(payload);
-        return typeof decoded.exp === 'number' ? decoded.exp : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function normalizeExpiryTimestamp(expiresAt, expires_at) {
-    return expiresAt ?? expires_at;
-}
-function isRefreshAuthResponseMessage(value) {
-    if (typeof value !== 'object' || value === null) {
-        return false;
-    }
-    const candidate = value;
-    return typeof candidate['success'] === 'boolean'
-        && !('op' in candidate)
-        && !('entity' in candidate)
-        && !('mode' in candidate);
-}
-function isSocketIssueMessage(value) {
-    if (typeof value !== 'object' || value === null) {
-        return false;
-    }
-    const candidate = value;
-    return candidate['type'] === 'error'
-        && typeof candidate['message'] === 'string'
-        && typeof candidate['code'] === 'string'
-        && typeof candidate['retryable'] === 'boolean'
-        && typeof candidate['fatal'] === 'boolean';
-}
-function isHostedAreteWebsocketUrl(websocketUrl) {
-    try {
-        return new URL(websocketUrl).hostname.toLowerCase().endsWith(HOSTED_WEBSOCKET_SUFFIX);
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Historical sentinel accepted for back-compat: connecting with this URL is
- * treated the same as passing no WebSocket URL at all (HTTP-only mode).
- */
-const DISABLED_WEBSOCKET_URL = 'ws://127.0.0.1/__arete_disabled__';
-class ConnectionManager {
-    constructor(config) {
-        this.ws = null;
-        this.reconnectAttempts = 0;
-        this.reconnectTimeout = null;
-        this.pingInterval = null;
-        this.tokenRefreshTimeout = null;
-        this.tokenRefreshInFlight = null;
-        this.currentState = 'disconnected';
-        this.subscriptionQueue = [];
-        this.activeSubscriptions = new Set();
-        this.frameHandlers = new Set();
-        this.stateHandlers = new Set();
-        this.socketIssueHandlers = new Set();
-        this.reconnectForTokenRefresh = false;
-        const websocketUrl = config.websocketUrl && config.websocketUrl !== DISABLED_WEBSOCKET_URL
-            ? config.websocketUrl
-            : null;
-        this.websocketUrl = websocketUrl;
-        this.hostedAreteUrl = websocketUrl !== null && isHostedAreteWebsocketUrl(websocketUrl);
-        this.reconnectIntervals = config.reconnectIntervals ?? DEFAULT_CONFIG.reconnectIntervals;
-        this.maxReconnectAttempts =
-            config.maxReconnectAttempts ?? DEFAULT_CONFIG.maxReconnectAttempts;
-        this.authConfig = config.auth;
-        if (config.initialSubscriptions) {
-            this.subscriptionQueue.push(...config.initialSubscriptions);
-        }
-    }
-    getTokenEndpoint() {
-        if (this.authConfig?.tokenEndpoint) {
-            return this.authConfig.tokenEndpoint;
-        }
-        // Require publishableKey for hosted token endpoint
-        if (this.hostedAreteUrl && this.authConfig?.publishableKey) {
-            return DEFAULT_HOSTED_TOKEN_ENDPOINT;
-        }
-        return undefined;
-    }
-    getAuthStrategy() {
-        if (this.authConfig?.token) {
-            return { kind: 'static-token', token: this.authConfig.token };
-        }
-        if (this.authConfig?.getToken) {
-            return { kind: 'token-provider', getToken: this.authConfig.getToken };
-        }
-        const tokenEndpoint = this.getTokenEndpoint();
-        if (tokenEndpoint) {
-            return { kind: 'token-endpoint', endpoint: tokenEndpoint };
-        }
-        return { kind: 'none' };
-    }
-    hasRefreshableAuth() {
-        const strategy = this.getAuthStrategy();
-        return strategy.kind === 'token-provider' || strategy.kind === 'token-endpoint';
-    }
-    updateTokenState(result) {
-        const normalized = normalizeTokenResult(result);
-        if (!normalized.token) {
-            throw new AreteError('Authentication provider returned an empty token', 'TOKEN_INVALID');
-        }
-        this.currentToken = normalized.token;
-        this.tokenExpiry = normalizeExpiryTimestamp(normalized.expiresAt, normalized.expires_at)
-            ?? parseJwtExpiry(normalized.token);
-        if (this.isTokenExpired()) {
-            throw new AreteError('Authentication token is expired', 'TOKEN_EXPIRED');
-        }
-        return normalized.token;
-    }
-    clearTokenState() {
-        this.currentToken = undefined;
-        this.tokenExpiry = undefined;
-    }
-    async getOrRefreshToken(forceRefresh = false) {
-        if (!forceRefresh && this.currentToken && !this.isTokenExpired()) {
-            return this.currentToken;
-        }
-        const strategy = this.getAuthStrategy();
-        // For hosted Arete URLs, auth is required - fail early with clear message
-        if (strategy.kind === 'none' && this.hostedAreteUrl) {
-            throw new AreteError('Arete authentication required. Please provide auth.publishableKey to AreteProvider. ' +
-                'Get your key from https://arete.run/dashboard', 'AUTH_REQUIRED');
-        }
-        switch (strategy.kind) {
-            case 'static-token':
-                return this.updateTokenState(strategy.token);
-            case 'token-provider':
-                try {
-                    return this.updateTokenState(await strategy.getToken());
-                }
-                catch (error) {
-                    if (error instanceof AreteError) {
-                        throw error;
-                    }
-                    throw new AreteError('Failed to get authentication token', 'AUTH_REQUIRED', error);
-                }
-            case 'token-endpoint':
-                try {
-                    return this.updateTokenState(await this.fetchTokenFromEndpoint(strategy.endpoint));
-                }
-                catch (error) {
-                    if (error instanceof AreteError) {
-                        throw error;
-                    }
-                    throw new AreteError('Failed to fetch authentication token from endpoint', 'AUTH_REQUIRED', error);
-                }
-            case 'none':
-                return undefined;
-        }
-    }
-    createTokenEndpointRequestBody() {
-        return {
-            websocket_url: this.websocketUrl ?? '',
-        };
-    }
-    async fetchTokenFromEndpoint(tokenEndpoint) {
-        const response = await fetch(tokenEndpoint, {
-            method: 'POST',
-            headers: {
-                ...(this.authConfig?.publishableKey
-                    ? { Authorization: `Bearer ${this.authConfig.publishableKey}` }
-                    : {}),
-                ...(this.authConfig?.tokenEndpointHeaders ?? {}),
-                'Content-Type': 'application/json',
-            },
-            credentials: this.authConfig?.tokenEndpointCredentials,
-            body: JSON.stringify(this.createTokenEndpointRequestBody()),
-        });
-        if (!response.ok) {
-            const rawError = await response.text();
-            let parsedError;
-            if (rawError) {
-                try {
-                    parsedError = JSON.parse(rawError);
-                }
-                catch {
-                    parsedError = undefined;
-                }
-            }
-            const wireErrorCode = response.headers.get('X-Error-Code')
-                ?? (typeof parsedError?.code === 'string' ? parsedError.code : null);
-            const errorCode = wireErrorCode
-                ? parseErrorCode(wireErrorCode)
-                : response.status === 429
-                    ? 'QUOTA_EXCEEDED'
-                    : 'AUTH_REQUIRED';
-            const errorMessage = typeof parsedError?.error === 'string' && parsedError.error.length > 0
-                ? parsedError.error
-                : rawError || response.statusText || 'Authentication request failed';
-            throw new AreteError(`Token endpoint returned ${response.status}: ${errorMessage}`, errorCode, {
-                status: response.status,
-                wireErrorCode,
-                responseBody: rawError || null,
-            });
-        }
-        const data = (await response.json());
-        if (!data.token) {
-            throw new AreteError('Token endpoint did not return a token', 'TOKEN_INVALID');
-        }
-        return data;
-    }
-    isTokenExpired() {
-        if (!this.tokenExpiry) {
-            return false;
-        }
-        return Date.now() >= (this.tokenExpiry - TOKEN_REFRESH_BUFFER_SECONDS) * 1000;
-    }
-    scheduleTokenRefresh() {
-        this.clearTokenRefreshTimeout();
-        if (!this.hasRefreshableAuth() || !this.tokenExpiry) {
-            return;
-        }
-        const refreshAtMs = Math.max(Date.now() + MIN_REFRESH_DELAY_MS, (this.tokenExpiry - TOKEN_REFRESH_BUFFER_SECONDS) * 1000);
-        const delayMs = Math.max(MIN_REFRESH_DELAY_MS, refreshAtMs - Date.now());
-        this.tokenRefreshTimeout = setTimeout(() => {
-            void this.refreshTokenInBackground();
-        }, delayMs);
-    }
-    clearTokenRefreshTimeout() {
-        if (this.tokenRefreshTimeout) {
-            clearTimeout(this.tokenRefreshTimeout);
-            this.tokenRefreshTimeout = null;
-        }
-    }
-    async refreshTokenInBackground() {
-        if (!this.hasRefreshableAuth()) {
-            return;
-        }
-        if (this.tokenRefreshInFlight) {
-            return this.tokenRefreshInFlight;
-        }
-        this.tokenRefreshInFlight = (async () => {
-            const previousToken = this.currentToken;
-            try {
-                await this.getOrRefreshToken(true);
-                if (previousToken &&
-                    this.currentToken &&
-                    this.currentToken !== previousToken &&
-                    this.ws?.readyState === WebSocket.OPEN) {
-                    // Try in-band auth refresh first
-                    const refreshed = await this.sendInBandAuthRefresh(this.currentToken);
-                    if (!refreshed) {
-                        // Fall back to reconnecting if in-band refresh failed
-                        this.rotateConnectionForTokenRefresh();
-                    }
-                }
-                this.scheduleTokenRefresh();
-            }
-            catch {
-                this.scheduleTokenRefresh();
-            }
-            finally {
-                this.tokenRefreshInFlight = null;
-            }
-        })();
-        return this.tokenRefreshInFlight;
-    }
-    async sendInBandAuthRefresh(token) {
-        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-            return false;
-        }
-        try {
-            const message = JSON.stringify({
-                type: 'refresh_auth',
-                token: token,
-            });
-            this.ws.send(message);
-            return true;
-        }
-        catch (error) {
-            console.warn('Failed to send in-band auth refresh:', error);
-            return false;
-        }
-    }
-    handleRefreshAuthResponse(message) {
-        if (message.success) {
-            const expiresAt = normalizeExpiryTimestamp(message.expiresAt, message.expires_at);
-            if (typeof expiresAt === 'number') {
-                this.tokenExpiry = expiresAt;
-            }
-            this.scheduleTokenRefresh();
-            return true;
-        }
-        const errorCode = message.error ? parseErrorCode(message.error) : 'INTERNAL_ERROR';
-        if (shouldRefreshToken(errorCode)) {
-            this.clearTokenState();
-        }
-        this.rotateConnectionForTokenRefresh();
-        return true;
-    }
-    handleSocketIssueMessage(message) {
-        this.notifySocketIssue(message);
-        if (message.fatal) {
-            this.updateState('error', message.message);
-        }
-        return true;
-    }
-    rotateConnectionForTokenRefresh() {
-        if (!this.ws || this.ws.readyState !== WebSocket.OPEN || this.reconnectForTokenRefresh) {
-            return;
-        }
-        this.reconnectForTokenRefresh = true;
-        this.updateState('reconnecting');
-        this.ws.close(1000, 'token refresh');
-    }
-    buildAuthUrl(token) {
-        const websocketUrl = this.requireWebsocketUrl();
-        if (this.authConfig?.tokenTransport === 'bearer') {
-            return websocketUrl;
-        }
-        if (!token) {
-            return websocketUrl;
-        }
-        const separator = websocketUrl.includes('?') ? '&' : '?';
-        return `${websocketUrl}${separator}${DEFAULT_QUERY_PARAMETER}=${encodeURIComponent(token)}`;
-    }
-    requireWebsocketUrl() {
-        if (this.websocketUrl === null) {
-            throw new AreteError('WebSocket transport is disabled (client was connected with transport: "http"); views and subscriptions are unavailable', 'WEBSOCKET_DISABLED');
-        }
-        return this.websocketUrl;
-    }
-    createWebSocket(url, token) {
-        if (this.authConfig?.tokenTransport === 'bearer') {
-            const init = token
-                ? { headers: { Authorization: `Bearer ${token}` } }
-                : undefined;
-            if (this.authConfig.websocketFactory) {
-                return this.authConfig.websocketFactory(url, init);
-            }
-            throw new AreteError('auth.tokenTransport="bearer" requires auth.websocketFactory in this environment', 'INVALID_CONFIG');
-        }
-        if (this.authConfig?.websocketFactory) {
-            return this.authConfig.websocketFactory(url);
-        }
-        return new WebSocket(url);
-    }
-    getState() {
-        return this.currentState;
-    }
-    async getHttpAuthToken(forceRefresh = false) {
-        return this.getOrRefreshToken(forceRefresh);
-    }
-    clearHttpAuthToken() {
-        this.clearTokenState();
-    }
-    onFrame(handler) {
-        this.frameHandlers.add(handler);
-        return () => {
-            this.frameHandlers.delete(handler);
-        };
-    }
-    onStateChange(handler) {
-        this.stateHandlers.add(handler);
-        return () => {
-            this.stateHandlers.delete(handler);
-        };
-    }
-    onSocketIssue(handler) {
-        this.socketIssueHandlers.add(handler);
-        return () => {
-            this.socketIssueHandlers.delete(handler);
-        };
-    }
-    notifySocketIssue(message) {
-        const issue = {
-            error: message.error,
-            message: message.message,
-            code: parseErrorCode(message.code),
-            retryable: message.retryable,
-            retryAfter: message.retry_after,
-            suggestedAction: message.suggested_action,
-            docsUrl: message.docs_url,
-            fatal: message.fatal,
-        };
-        for (const handler of this.socketIssueHandlers) {
-            handler(issue);
-        }
-        return issue;
-    }
-    async connect() {
-        this.requireWebsocketUrl();
-        if (this.ws?.readyState === WebSocket.OPEN ||
-            this.ws?.readyState === WebSocket.CONNECTING ||
-            this.currentState === 'connecting') {
-            return;
-        }
-        this.updateState('connecting');
-        let token;
-        try {
-            token = await this.getOrRefreshToken();
-        }
-        catch (error) {
-            this.updateState('error', error instanceof Error ? error.message : 'Failed to get token');
-            throw error;
-        }
-        const wsUrl = this.buildAuthUrl(token);
-        return new Promise((resolve, reject) => {
-            let settled = false;
-            const finish = (fn) => {
-                if (settled) {
-                    return;
-                }
-                settled = true;
-                fn();
-            };
-            try {
-                this.ws = this.createWebSocket(wsUrl, token);
-                this.ws.onopen = () => {
-                    this.reconnectAttempts = 0;
-                    this.updateState('connected');
-                    this.startPingInterval();
-                    this.scheduleTokenRefresh();
-                    this.resubscribeActive();
-                    this.flushSubscriptionQueue();
-                    finish(() => resolve());
-                };
-                this.ws.onmessage = async (event) => {
-                    try {
-                        let frame;
-                        if (event.data instanceof ArrayBuffer) {
-                            frame = parseFrame(event.data);
-                        }
-                        else if (event.data instanceof Blob) {
-                            frame = await parseFrameFromBlob(event.data);
-                        }
-                        else if (typeof event.data === 'string') {
-                            const parsed = JSON.parse(event.data);
-                            if (isRefreshAuthResponseMessage(parsed)) {
-                                this.handleRefreshAuthResponse(parsed);
-                                return;
-                            }
-                            if (isSocketIssueMessage(parsed)) {
-                                this.handleSocketIssueMessage(parsed);
-                                return;
-                            }
-                            frame = parseFrame(JSON.stringify(parsed));
-                        }
-                        else {
-                            throw new AreteError(`Unsupported message type: ${typeof event.data}`, 'PARSE_ERROR');
-                        }
-                        this.notifyFrameHandlers(frame);
-                    }
-                    catch {
-                        this.updateState('error', 'Failed to parse frame from server');
-                    }
-                };
-                this.ws.onerror = () => {
-                    const error = new AreteError('WebSocket connection error', 'CONNECTION_ERROR');
-                    const wasConnecting = this.currentState === 'connecting';
-                    this.updateState('error', error.message);
-                    if (wasConnecting) {
-                        finish(() => reject(error));
-                    }
-                };
-                this.ws.onclose = (event) => {
-                    this.stopPingInterval();
-                    this.clearTokenRefreshTimeout();
-                    this.ws = null;
-                    if (!settled) {
-                        const detail = event.reason
-                            ? `${event.code}: ${event.reason}`
-                            : `code ${event.code}`;
-                        const errorMessage = `WebSocket closed before open (${detail})`;
-                        this.updateState('error', errorMessage);
-                        finish(() => reject(new AreteError(errorMessage, 'CONNECTION_ERROR')));
-                        return;
-                    }
-                    if (this.reconnectForTokenRefresh) {
-                        this.reconnectForTokenRefresh = false;
-                        void this.connect().catch(() => {
-                            this.handleReconnect();
-                        });
-                        return;
-                    }
-                    // Parse close reason for error codes (e.g., "token-expired: Token has expired")
-                    const closeReason = event.reason || '';
-                    const errorCodeMatch = closeReason.match(/^([\w-]+):/);
-                    const errorCode = errorCodeMatch ? parseErrorCode(errorCodeMatch[1]) : null;
-                    // Check for auth errors that require token refresh
-                    if (event.code === 1008 || errorCode) {
-                        const isAuthError = errorCode
-                            ? shouldRefreshToken(errorCode)
-                            : /expired|invalid|token/i.test(closeReason);
-                        if (isAuthError) {
-                            this.clearTokenState();
-                            // Try to reconnect immediately with a fresh token
-                            void this.connect().catch(() => {
-                                this.handleReconnect();
-                            });
-                            return;
-                        }
-                        // Check for rate limit errors
-                        const isRateLimit = errorCode === 'RATE_LIMIT_EXCEEDED' ||
-                            errorCode === 'CONNECTION_LIMIT_EXCEEDED' ||
-                            /rate.?limit|quota|limit.?exceeded/i.test(closeReason);
-                        if (isRateLimit) {
-                            this.updateState('error', `Rate limit exceeded: ${closeReason}`);
-                            // Don't auto-reconnect on rate limits, let user handle it
-                            return;
-                        }
-                    }
-                    if (this.currentState !== 'disconnected') {
-                        this.handleReconnect();
-                    }
-                };
-            }
-            catch (error) {
-                const hsError = new AreteError('Failed to create WebSocket connection', 'CONNECTION_ERROR', error);
-                this.updateState('error', hsError.message);
-                reject(hsError);
-            }
-        });
-    }
-    disconnect() {
-        this.clearReconnectTimeout();
-        this.stopPingInterval();
-        this.clearTokenRefreshTimeout();
-        this.reconnectForTokenRefresh = false;
-        this.updateState('disconnected');
-        if (this.ws) {
-            this.ws.close();
-            this.ws = null;
-        }
-    }
-    subscribe(subscription) {
-        this.requireWebsocketUrl();
-        const subKey = this.makeSubKey(subscription);
-        if (this.currentState === 'connected' && this.ws?.readyState === WebSocket.OPEN) {
-            if (this.activeSubscriptions.has(subKey)) {
-                return;
-            }
-            const subMsg = { type: 'subscribe', ...subscription };
-            this.ws.send(JSON.stringify(subMsg));
-            this.activeSubscriptions.add(subKey);
-        }
-        else {
-            const alreadyQueued = this.subscriptionQueue.some((queuedSubscription) => this.makeSubKey(queuedSubscription) === subKey);
-            if (!alreadyQueued) {
-                this.subscriptionQueue.push(subscription);
-            }
-        }
-    }
-    unsubscribe(view, key) {
-        const subscription = { view, key };
-        const subKey = this.makeSubKey(subscription);
-        if (this.activeSubscriptions.has(subKey)) {
-            this.activeSubscriptions.delete(subKey);
-            if (this.ws?.readyState === WebSocket.OPEN) {
-                const unsubMsg = { type: 'unsubscribe', view, key };
-                this.ws.send(JSON.stringify(unsubMsg));
-            }
-        }
-    }
-    isConnected() {
-        return this.currentState === 'connected' && this.ws?.readyState === WebSocket.OPEN;
-    }
-    makeSubKey(subscription) {
-        return `${subscription.view}:${subscription.key ?? '*'}:${subscription.partition ?? ''}`;
-    }
-    flushSubscriptionQueue() {
-        while (this.subscriptionQueue.length > 0) {
-            const subscription = this.subscriptionQueue.shift();
-            if (subscription) {
-                this.subscribe(subscription);
-            }
-        }
-    }
-    resubscribeActive() {
-        for (const subKey of this.activeSubscriptions) {
-            const [view, key, partition] = subKey.split(':');
-            const subscription = {
-                view: view ?? '',
-                key: key === '*' ? undefined : key,
-                partition: partition || undefined,
-            };
-            if (this.ws?.readyState === WebSocket.OPEN) {
-                const subMsg = { type: 'subscribe', ...subscription };
-                this.ws.send(JSON.stringify(subMsg));
-            }
-        }
-    }
-    updateState(state, error) {
-        this.currentState = state;
-        for (const handler of this.stateHandlers) {
-            handler(state, error);
-        }
-    }
-    notifyFrameHandlers(frame) {
-        for (const handler of this.frameHandlers) {
-            handler(frame);
-        }
-    }
-    handleReconnect() {
-        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-            this.updateState('error', `Max reconnection attempts (${this.reconnectAttempts}) reached`);
-            return;
-        }
-        this.updateState('reconnecting');
-        const attemptIndex = Math.min(this.reconnectAttempts, this.reconnectIntervals.length - 1);
-        const delay = this.reconnectIntervals[attemptIndex] ?? 1000;
-        this.reconnectAttempts++;
-        this.reconnectTimeout = setTimeout(() => {
-            this.connect().catch(() => {
-                /* retry handled by onclose */
-            });
-        }, delay);
-    }
-    clearReconnectTimeout() {
-        if (this.reconnectTimeout) {
-            clearTimeout(this.reconnectTimeout);
-            this.reconnectTimeout = null;
-        }
-    }
-    startPingInterval() {
-        this.stopPingInterval();
-        this.pingInterval = setInterval(() => {
-            if (this.ws?.readyState === WebSocket.OPEN) {
-                this.ws.send('{"type":"ping"}');
-            }
-        }, 15000);
-    }
-    stopPingInterval() {
-        if (this.pingInterval) {
-            clearInterval(this.pingInterval);
-            this.pingInterval = null;
-        }
-    }
-}
-
-const INTERNAL_SEQ_FIELD = '__seq';
-function isObject(item) {
-    return item !== null && typeof item === 'object' && !Array.isArray(item);
-}
-function deepMergeWithAppend(target, source, appendPaths, currentPath = '') {
-    if (!isObject(target) || !isObject(source)) {
-        return source;
-    }
-    const result = { ...target };
-    for (const key in source) {
-        const sourceValue = source[key];
-        if (sourceValue === undefined) {
-            continue;
-        }
-        const targetValue = result[key];
-        const fieldPath = currentPath ? `${currentPath}.${key}` : key;
-        if (Array.isArray(sourceValue) && Array.isArray(targetValue)) {
-            if (appendPaths.includes(fieldPath)) {
-                result[key] = [...targetValue, ...sourceValue];
-            }
-            else {
-                result[key] = sourceValue;
-            }
-        }
-        else if (isObject(sourceValue) && isObject(targetValue)) {
-            result[key] = deepMergeWithAppend(targetValue, sourceValue, appendPaths, fieldPath);
-        }
-        else {
-            result[key] = sourceValue;
-        }
-    }
-    return result;
-}
-function stripUndefinedProperties(value) {
-    if (Array.isArray(value)) {
-        return value.map(item => stripUndefinedProperties(item));
-    }
-    if (!isObject(value)) {
-        return value;
-    }
-    const result = {};
-    for (const [key, nestedValue] of Object.entries(value)) {
-        if (nestedValue === undefined) {
-            continue;
-        }
-        result[key] = stripUndefinedProperties(nestedValue);
-    }
-    return result;
-}
-function toCamelCaseSegment(value) {
-    if (value === '_seq') {
-        return INTERNAL_SEQ_FIELD;
-    }
-    const pascal = value
-        .split(/[_.-]/)
-        .filter(segment => segment.length > 0)
-        .map(segment => segment[0].toUpperCase() + segment.slice(1))
-        .join('');
-    if (pascal.length === 0) {
-        return value;
-    }
-    return pascal[0].toLowerCase() + pascal.slice(1);
-}
-class FrameProcessor {
-    constructor(storage, config = {}) {
-        this.pendingUpdates = [];
-        this.flushTimer = null;
-        this.isProcessing = false;
-        this.storage = storage;
-        this.maxEntriesPerView = config.maxEntriesPerView === undefined
-            ? DEFAULT_MAX_ENTRIES_PER_VIEW
-            : config.maxEntriesPerView;
-        this.flushIntervalMs = config.flushIntervalMs ?? 0;
-        this.schemas = config.schemas;
-        this.patchSchemas = config.patchSchemas;
-    }
-    getSchema(viewPath, patch = false) {
-        const schemas = patch ? this.patchSchemas : this.schemas;
-        if (!schemas)
-            return null;
-        const entityName = viewPath.split('/')[0];
-        if (typeof entityName !== 'string' || entityName.length === 0)
-            return null;
-        const entityKey = entityName;
-        return schemas[entityKey] ?? null;
-    }
-    normalizeEntity(viewPath, data, patch = false) {
-        const schema = this.getSchema(viewPath, patch)
-            ?? (!patch ? null : this.getSchema(viewPath));
-        if (!schema)
-            return data;
-        const result = schema.safeParse(data);
-        if (!result.success) {
-            console.warn('[Arete] Frame validation failed:', {
-                view: viewPath,
-                error: result.error,
-            });
-            return null;
-        }
-        return stripUndefinedProperties(result.data);
-    }
-    hasSchema(viewPath) {
-        return this.getSchema(viewPath) !== null;
-    }
-    normalizePathSegment(viewPath, segment) {
-        if (!this.hasSchema(viewPath)) {
-            return segment;
-        }
-        return toCamelCaseSegment(segment);
-    }
-    normalizePath(viewPath, path) {
-        if (!this.hasSchema(viewPath)) {
-            return path;
-        }
-        return path
-            .split('.')
-            .filter(segment => segment.length > 0)
-            .map(segment => this.normalizePathSegment(viewPath, segment))
-            .join('.');
-    }
-    normalizeSortConfig(viewPath, sort) {
-        if (!this.hasSchema(viewPath)) {
-            return sort;
-        }
-        return {
-            ...sort,
-            field: sort.field.map(segment => this.normalizePathSegment(viewPath, segment)),
-        };
-    }
-    normalizeAppendPaths(viewPath, append) {
-        if (!append || append.length === 0 || !this.hasSchema(viewPath)) {
-            return append ?? [];
-        }
-        return append.map(path => this.normalizePath(viewPath, path));
-    }
-    extractSeq(data) {
-        if (!isObject(data)) {
-            return undefined;
-        }
-        const seq = data._seq;
-        if (typeof seq === 'string') {
-            return seq;
-        }
-        if (typeof seq === 'number' && Number.isFinite(seq)) {
-            return String(seq);
-        }
-        return undefined;
-    }
-    getInternalSeq(data) {
-        if (!isObject(data)) {
-            return undefined;
-        }
-        const seq = data[INTERNAL_SEQ_FIELD];
-        return typeof seq === 'string' ? seq : undefined;
-    }
-    attachInternalSeq(viewPath, data, seq) {
-        if (!seq || !this.hasSchema(viewPath) || !isObject(data)) {
-            return data;
-        }
-        Object.defineProperty(data, INTERNAL_SEQ_FIELD, {
-            value: seq,
-            enumerable: false,
-            configurable: true,
-            writable: true,
-        });
-        return data;
-    }
-    handleFrame(frame) {
-        if (this.flushIntervalMs === 0) {
-            this.processFrame(frame);
-            return;
-        }
-        this.pendingUpdates.push({ frame });
-        this.scheduleFlush();
-    }
-    /**
-     * Immediately flush all pending updates.
-     * Useful for ensuring all updates are processed before reading state.
-     */
-    flush() {
-        if (this.flushTimer !== null) {
-            clearTimeout(this.flushTimer);
-            this.flushTimer = null;
-        }
-        this.flushPendingUpdates();
-    }
-    /**
-     * Clean up any pending timers. Call when disposing the processor.
-     */
-    dispose() {
-        if (this.flushTimer !== null) {
-            clearTimeout(this.flushTimer);
-            this.flushTimer = null;
-        }
-        this.pendingUpdates = [];
-    }
-    scheduleFlush() {
-        if (this.flushTimer !== null) {
-            return;
-        }
-        this.flushTimer = setTimeout(() => {
-            this.flushTimer = null;
-            this.flushPendingUpdates();
-        }, this.flushIntervalMs);
-    }
-    flushPendingUpdates() {
-        if (this.isProcessing || this.pendingUpdates.length === 0) {
-            return;
-        }
-        this.isProcessing = true;
-        const batch = this.pendingUpdates;
-        this.pendingUpdates = [];
-        const viewsToEnforce = new Set();
-        for (const { frame } of batch) {
-            const viewPath = this.processFrameWithoutEnforce(frame);
-            if (viewPath) {
-                viewsToEnforce.add(viewPath);
-            }
-        }
-        viewsToEnforce.forEach((viewPath) => {
-            this.enforceMaxEntries(viewPath);
-        });
-        this.isProcessing = false;
-    }
-    processFrame(frame) {
-        if (isSubscribedFrame(frame)) {
-            this.handleSubscribedFrame(frame);
-        }
-        else if (isSnapshotFrame(frame)) {
-            this.handleSnapshotFrame(frame);
-        }
-        else {
-            this.handleEntityFrame(frame);
-        }
-    }
-    processFrameWithoutEnforce(frame) {
-        if (isSubscribedFrame(frame)) {
-            this.handleSubscribedFrame(frame);
-            return null;
-        }
-        else if (isSnapshotFrame(frame)) {
-            this.handleSnapshotFrameWithoutEnforce(frame);
-            return frame.entity;
-        }
-        else {
-            this.handleEntityFrameWithoutEnforce(frame);
-            return frame.entity;
-        }
-    }
-    handleSubscribedFrame(frame) {
-        if (this.storage.setViewConfig && frame.sort) {
-            this.storage.setViewConfig(frame.view, {
-                sort: this.normalizeSortConfig(frame.view, frame.sort),
-            });
-        }
-    }
-    handleSnapshotFrame(frame) {
-        this.handleSnapshotFrameWithoutEnforce(frame);
-        this.enforceMaxEntries(frame.entity);
-    }
-    handleSnapshotFrameWithoutEnforce(frame) {
-        const viewPath = frame.entity;
-        for (const entity of frame.data) {
-            const normalized = this.normalizeEntity(viewPath, entity.data);
-            if (normalized === null) {
-                continue;
-            }
-            const nextValue = this.attachInternalSeq(viewPath, normalized, this.extractSeq(entity.data));
-            const previousValue = this.storage.get(viewPath, entity.key);
-            this.storage.set(viewPath, entity.key, nextValue);
-            this.storage.notifyUpdate(viewPath, entity.key, {
-                type: 'upsert',
-                key: entity.key,
-                data: nextValue,
-            });
-            this.emitRichUpdate(viewPath, entity.key, previousValue, nextValue, 'upsert');
-        }
-    }
-    handleEntityFrame(frame) {
-        this.handleEntityFrameWithoutEnforce(frame);
-        this.enforceMaxEntries(frame.entity);
-    }
-    handleEntityFrameWithoutEnforce(frame) {
-        const viewPath = frame.entity;
-        const previousValue = this.storage.get(viewPath, frame.key);
-        switch (frame.op) {
-            case 'create':
-            case 'upsert':
-                {
-                    const normalized = this.normalizeEntity(viewPath, frame.data);
-                    if (normalized === null) {
-                        break;
-                    }
-                    const nextValue = this.attachInternalSeq(viewPath, normalized, frame.seq ?? this.extractSeq(frame.data));
-                    this.storage.set(viewPath, frame.key, nextValue);
-                    this.storage.notifyUpdate(viewPath, frame.key, {
-                        type: 'upsert',
-                        key: frame.key,
-                        data: nextValue,
-                    });
-                    this.emitRichUpdate(viewPath, frame.key, previousValue, nextValue, frame.op);
-                    break;
-                }
-            case 'patch': {
-                const existing = this.storage.get(viewPath, frame.key);
-                const normalizedPatch = this.normalizeEntity(viewPath, frame.data, true);
-                if (normalizedPatch === null) {
-                    break;
-                }
-                const appendPaths = this.normalizeAppendPaths(viewPath, frame.append);
-                const merged = existing
-                    ? deepMergeWithAppend(existing, normalizedPatch, appendPaths)
-                    : normalizedPatch;
-                const nextValue = this.attachInternalSeq(viewPath, merged, frame.seq ?? this.extractSeq(frame.data) ?? this.getInternalSeq(existing));
-                this.storage.set(viewPath, frame.key, nextValue);
-                this.storage.notifyUpdate(viewPath, frame.key, {
-                    type: 'patch',
-                    key: frame.key,
-                    data: normalizedPatch,
-                });
-                this.emitRichUpdate(viewPath, frame.key, previousValue, nextValue, 'patch', normalizedPatch);
-                break;
-            }
-            case 'delete':
-                this.storage.delete(viewPath, frame.key);
-                this.storage.notifyUpdate(viewPath, frame.key, {
-                    type: 'delete',
-                    key: frame.key,
-                });
-                if (previousValue !== null) {
-                    const richUpdate = { type: 'deleted', key: frame.key, lastKnown: previousValue };
-                    this.storage.notifyRichUpdate(viewPath, frame.key, richUpdate);
-                }
-                break;
-        }
-    }
-    emitRichUpdate(viewPath, key, before, after, _op, patch) {
-        const richUpdate = before === null
-            ? { type: 'created', key, data: after }
-            : { type: 'updated', key, before, after, patch };
-        this.storage.notifyRichUpdate(viewPath, key, richUpdate);
-    }
-    enforceMaxEntries(viewPath) {
-        if (this.maxEntriesPerView === null)
-            return;
-        if (!this.storage.evictOldest)
-            return;
-        while (this.storage.size(viewPath) > this.maxEntriesPerView) {
-            this.storage.evictOldest(viewPath);
-        }
-    }
-}
-
-class ViewData {
-    constructor() {
-        this.entities = new Map();
-        this.accessOrder = [];
-    }
-    get(key) {
-        return this.entities.get(key);
-    }
-    set(key, value) {
-        if (!this.entities.has(key)) {
-            this.accessOrder.push(key);
-        }
-        else {
-            this.touch(key);
-        }
-        this.entities.set(key, value);
-    }
-    delete(key) {
-        const idx = this.accessOrder.indexOf(key);
-        if (idx !== -1) {
-            this.accessOrder.splice(idx, 1);
-        }
-        return this.entities.delete(key);
-    }
-    has(key) {
-        return this.entities.has(key);
-    }
-    values() {
-        return this.entities.values();
-    }
-    keys() {
-        return this.entities.keys();
-    }
-    get size() {
-        return this.entities.size;
-    }
-    touch(key) {
-        const idx = this.accessOrder.indexOf(key);
-        if (idx !== -1) {
-            this.accessOrder.splice(idx, 1);
-            this.accessOrder.push(key);
-        }
-    }
-    evictOldest() {
-        const oldest = this.accessOrder.shift();
-        if (oldest !== undefined) {
-            this.entities.delete(oldest);
-        }
-        return oldest;
-    }
-    clear() {
-        this.entities.clear();
-        this.accessOrder = [];
-    }
-}
-class MemoryAdapter {
-    constructor(_config = {}) {
-        this.views = new Map();
-        this.updateCallbacks = new Set();
-        this.richUpdateCallbacks = new Set();
-    }
-    get(viewPath, key) {
-        const view = this.views.get(viewPath);
-        if (!view)
-            return null;
-        const value = view.get(key);
-        return value !== undefined ? value : null;
-    }
-    getAll(viewPath) {
-        const view = this.views.get(viewPath);
-        if (!view)
-            return [];
-        return Array.from(view.values());
-    }
-    getAllSync(viewPath) {
-        const view = this.views.get(viewPath);
-        if (!view)
-            return undefined;
-        return Array.from(view.values());
-    }
-    getSync(viewPath, key) {
-        const view = this.views.get(viewPath);
-        if (!view)
-            return undefined;
-        const value = view.get(key);
-        return value !== undefined ? value : null;
-    }
-    has(viewPath, key) {
-        return this.views.get(viewPath)?.has(key) ?? false;
-    }
-    keys(viewPath) {
-        const view = this.views.get(viewPath);
-        if (!view)
-            return [];
-        return Array.from(view.keys());
-    }
-    size(viewPath) {
-        return this.views.get(viewPath)?.size ?? 0;
-    }
-    set(viewPath, key, data) {
-        let view = this.views.get(viewPath);
-        if (!view) {
-            view = new ViewData();
-            this.views.set(viewPath, view);
-        }
-        view.set(key, data);
-    }
-    delete(viewPath, key) {
-        this.views.get(viewPath)?.delete(key);
-    }
-    clear(viewPath) {
-        if (viewPath) {
-            this.views.get(viewPath)?.clear();
-            this.views.delete(viewPath);
-        }
-        else {
-            this.views.clear();
-        }
-    }
-    evictOldest(viewPath) {
-        return this.views.get(viewPath)?.evictOldest();
-    }
-    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);
-        }
-    }
-}
-
-function getNestedValue(obj, path) {
-    let current = obj;
-    for (const segment of path) {
-        if (current === null || current === undefined)
-            return undefined;
-        if (typeof current !== 'object')
-            return undefined;
-        current = current[segment];
-    }
-    return current;
-}
-function compareSortValues(a, b) {
-    if (a === b)
-        return 0;
-    if (a === undefined || a === null)
-        return -1;
-    if (b === undefined || b === null)
-        return 1;
-    if (typeof a === 'bigint' && typeof b === 'bigint') {
-        return a < b ? -1 : 1;
-    }
-    if (typeof a === 'number' && typeof b === 'number') {
-        return a - b;
-    }
-    if (typeof a === 'bigint' && typeof b === 'number' && Number.isInteger(b)) {
-        return a < BigInt(b) ? -1 : 1;
-    }
-    if (typeof a === 'number' && typeof b === 'bigint' && Number.isInteger(a)) {
-        return BigInt(a) < b ? -1 : 1;
-    }
-    if (typeof a === 'string' && typeof b === 'string') {
-        return a.localeCompare(b);
-    }
-    if (typeof a === 'boolean' && typeof b === 'boolean') {
-        return (a ? 1 : 0) - (b ? 1 : 0);
-    }
-    return String(a).localeCompare(String(b));
-}
-class SortedStorageDecorator {
-    constructor(inner) {
-        this.sortConfigs = new Map();
-        this.sortedKeysMap = new Map();
-        this.inner = inner;
-    }
-    get(viewPath, key) {
-        return this.inner.get(viewPath, key);
-    }
-    getAll(viewPath) {
-        const sortedKeys = this.sortedKeysMap.get(viewPath);
-        if (sortedKeys && sortedKeys.length > 0) {
-            return sortedKeys
-                .map(k => this.inner.get(viewPath, k))
-                .filter((v) => v !== null);
-        }
-        return this.inner.getAll(viewPath);
-    }
-    getAllSync(viewPath) {
-        const sortedKeys = this.sortedKeysMap.get(viewPath);
-        if (sortedKeys && sortedKeys.length > 0) {
-            return sortedKeys
-                .map(k => this.inner.getSync(viewPath, k))
-                .filter((v) => v !== null && v !== undefined);
-        }
-        return this.inner.getAllSync(viewPath);
-    }
-    getSync(viewPath, key) {
-        return this.inner.getSync(viewPath, key);
-    }
-    has(viewPath, key) {
-        return this.inner.has(viewPath, key);
-    }
-    keys(viewPath) {
-        const sortedKeys = this.sortedKeysMap.get(viewPath);
-        if (sortedKeys)
-            return [...sortedKeys];
-        return this.inner.keys(viewPath);
-    }
-    size(viewPath) {
-        return this.inner.size(viewPath);
-    }
-    set(viewPath, key, data) {
-        this.inner.set(viewPath, key, data);
-        const sortConfig = this.sortConfigs.get(viewPath);
-        if (sortConfig) {
-            this.updateSortedPosition(viewPath, key, data, sortConfig);
-        }
-    }
-    delete(viewPath, key) {
-        const sortedKeys = this.sortedKeysMap.get(viewPath);
-        if (sortedKeys) {
-            const idx = sortedKeys.indexOf(key);
-            if (idx !== -1) {
-                sortedKeys.splice(idx, 1);
-            }
-        }
-        this.inner.delete(viewPath, key);
-    }
-    clear(viewPath) {
-        if (viewPath) {
-            this.sortedKeysMap.delete(viewPath);
-            this.sortConfigs.delete(viewPath);
-        }
-        else {
-            this.sortedKeysMap.clear();
-            this.sortConfigs.clear();
-        }
-        this.inner.clear(viewPath);
-    }
-    evictOldest(viewPath) {
-        const sortedKeys = this.sortedKeysMap.get(viewPath);
-        if (sortedKeys && sortedKeys.length > 0) {
-            const oldest = sortedKeys.pop();
-            this.inner.delete(viewPath, oldest);
-            return oldest;
-        }
-        return this.inner.evictOldest?.(viewPath);
-    }
-    setViewConfig(viewPath, config) {
-        if (config.sort && !this.sortConfigs.has(viewPath)) {
-            this.sortConfigs.set(viewPath, config.sort);
-            this.rebuildSortedKeys(viewPath, config.sort);
-        }
-        this.inner.setViewConfig?.(viewPath, config);
-    }
-    getViewConfig(viewPath) {
-        const sortConfig = this.sortConfigs.get(viewPath);
-        if (sortConfig)
-            return { sort: sortConfig };
-        return this.inner.getViewConfig?.(viewPath);
-    }
-    onUpdate(callback) {
-        return this.inner.onUpdate(callback);
-    }
-    onRichUpdate(callback) {
-        return this.inner.onRichUpdate(callback);
-    }
-    notifyUpdate(viewPath, key, update) {
-        this.inner.notifyUpdate(viewPath, key, update);
-    }
-    notifyRichUpdate(viewPath, key, update) {
-        this.inner.notifyRichUpdate(viewPath, key, update);
-    }
-    updateSortedPosition(viewPath, key, data, sortConfig) {
-        let sortedKeys = this.sortedKeysMap.get(viewPath);
-        if (!sortedKeys) {
-            sortedKeys = [];
-            this.sortedKeysMap.set(viewPath, sortedKeys);
-        }
-        const existingIdx = sortedKeys.indexOf(key);
-        if (existingIdx !== -1) {
-            sortedKeys.splice(existingIdx, 1);
-        }
-        const insertIdx = this.binarySearchInsertPosition(viewPath, sortedKeys, sortConfig, key, data);
-        sortedKeys.splice(insertIdx, 0, key);
-    }
-    binarySearchInsertPosition(viewPath, sortedKeys, sortConfig, newKey, newValue) {
-        const newSortValue = getNestedValue(newValue, sortConfig.field);
-        const isDesc = sortConfig.order === 'desc';
-        let low = 0;
-        let high = sortedKeys.length;
-        while (low < high) {
-            const mid = Math.floor((low + high) / 2);
-            const midKey = sortedKeys[mid];
-            const midEntity = this.inner.get(viewPath, midKey);
-            const midValue = getNestedValue(midEntity, sortConfig.field);
-            let cmp = compareSortValues(newSortValue, midValue);
-            if (isDesc)
-                cmp = -cmp;
-            if (cmp === 0) {
-                cmp = newKey.localeCompare(midKey);
-            }
-            if (cmp < 0) {
-                high = mid;
-            }
-            else {
-                low = mid + 1;
-            }
-        }
-        return low;
-    }
-    rebuildSortedKeys(viewPath, sortConfig) {
-        const allKeys = this.inner.keys(viewPath);
-        if (allKeys.length === 0)
-            return;
-        const isDesc = sortConfig.order === 'desc';
-        const entries = allKeys.map(k => [k, this.inner.get(viewPath, k)]);
-        entries.sort((a, b) => {
-            const aValue = getNestedValue(a[1], sortConfig.field);
-            const bValue = getNestedValue(b[1], sortConfig.field);
-            let cmp = compareSortValues(aValue, bValue);
-            if (isDesc)
-                cmp = -cmp;
-            if (cmp === 0) {
-                cmp = a[0].localeCompare(b[0]);
-            }
-            return cmp;
-        });
-        this.sortedKeysMap.set(viewPath, entries.map(([k]) => k));
-    }
-}
-
-class SubscriptionRegistry {
-    constructor(connection) {
-        this.subscriptions = new Map();
-        this.connection = connection;
-    }
-    subscribe(subscription) {
-        const subKey = this.makeSubKey(subscription);
-        const existing = this.subscriptions.get(subKey);
-        if (existing) {
-            existing.refCount++;
-        }
-        else {
-            this.subscriptions.set(subKey, {
-                subscription,
-                refCount: 1,
-            });
-            this.connection.subscribe(subscription);
-        }
-        return () => this.unsubscribe(subscription);
-    }
-    unsubscribe(subscription) {
-        const subKey = this.makeSubKey(subscription);
-        const existing = this.subscriptions.get(subKey);
-        if (existing) {
-            existing.refCount--;
-            if (existing.refCount <= 0) {
-                this.subscriptions.delete(subKey);
-                this.connection.unsubscribe(subscription.view, subscription.key);
-            }
-        }
-    }
-    getRefCount(subscription) {
-        const subKey = this.makeSubKey(subscription);
-        return this.subscriptions.get(subKey)?.refCount ?? 0;
-    }
-    getActiveSubscriptions() {
-        return Array.from(this.subscriptions.values()).map((t) => t.subscription);
-    }
-    clear() {
-        for (const { subscription } of this.subscriptions.values()) {
-            this.connection.unsubscribe(subscription.view, subscription.key);
-        }
-        this.subscriptions.clear();
-    }
-    makeSubKey(subscription) {
-        const filters = subscription.filters ? JSON.stringify(subscription.filters) : '{}';
-        return `${subscription.view}:${subscription.key ?? '*'}:${subscription.partition ?? ''}:${filters}`;
-    }
-}
-
-const MAX_QUEUE_SIZE = 1000;
-function createUpdateStream(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;
-                const typedUpdate = update;
-                if (waitingResolve) {
-                    const resolve = waitingResolve;
-                    waitingResolve = null;
-                    resolve({ value: typedUpdate, done: false });
-                }
-                else {
-                    if (queue.length >= MAX_QUEUE_SIZE) {
-                        queue.shift();
-                    }
-                    queue.push({
-                        update: typedUpdate,
-                        resolve: () => { },
-                    });
-                }
-            };
-            const start = () => {
-                unsubscribeStorage = storage.onUpdate(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.update, done: false };
-                    }
-                    return new Promise((resolve) => {
-                        waitingResolve = resolve;
-                    });
-                },
-                async return() {
-                    cleanup();
-                    return { value: undefined, done: true };
-                },
-                async throw(error) {
-                    cleanup();
-                    throw error;
-                },
-            };
-        },
-    };
-}
-function createEntityStream(storage, subscriptionRegistry, subscription, options, keyFilter) {
-    const schema = options?.schema;
-    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);
-                let output;
-                if (schema) {
-                    const parsed = schema.safeParse(entity);
-                    if (!parsed.success) {
-                        return;
-                    }
-                    output = parsed.data;
-                }
-                else {
-                    output = entity;
-                }
-                if (waitingResolve) {
-                    const resolve = waitingResolve;
-                    waitingResolve = null;
-                    resolve({ value: output, done: false });
-                }
-                else {
-                    if (queue.length >= MAX_QUEUE_SIZE) {
-                        queue.shift();
-                    }
-                    queue.push(output);
-                }
-            };
-            const start = () => {
-                unsubscribeStorage = storage.onRichUpdate(handler);
-                unsubscribeRegistry = subscriptionRegistry.subscribe(subscription);
-            };
-            const cleanup = () => {
-                done = true;
-                unsubscribeStorage?.();
-                unsubscribeRegistry?.();
-            };
-            start();
-            const iterator = {
-                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;
-                },
-            };
-            return iterator;
-        },
-    };
-}
-function createRichUpdateStream(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;
-                const typedUpdate = update;
-                if (waitingResolve) {
-                    const resolve = waitingResolve;
-                    waitingResolve = null;
-                    resolve({ value: typedUpdate, done: false });
-                }
-                else {
-                    if (queue.length >= MAX_QUEUE_SIZE) {
-                        queue.shift();
-                    }
-                    queue.push({
-                        update: typedUpdate,
-                        resolve: () => { },
-                    });
-                }
-            };
-            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.update, done: false };
-                    }
-                    return new Promise((resolve) => {
-                        waitingResolve = resolve;
-                    });
-                },
-                async return() {
-                    cleanup();
-                    return { value: undefined, done: true };
-                },
-                async throw(error) {
-                    cleanup();
-                    throw error;
-                },
-            };
-        },
-    };
-}
-
-function createTypedStateView(viewDef, storage, subscriptionRegistry) {
-    return {
-        use(key, options) {
-            const { schema: _schema, ...subscriptionOptions } = options ?? {};
-            return createEntityStream(storage, subscriptionRegistry, { view: viewDef.view, key, ...subscriptionOptions }, options, key);
-        },
-        watch(key, options) {
-            const { schema: _schema, ...subscriptionOptions } = options ?? {};
-            return createUpdateStream(storage, subscriptionRegistry, { view: viewDef.view, key, ...subscriptionOptions }, key);
-        },
-        watchRich(key, options) {
-            const { schema: _schema, ...subscriptionOptions } = options ?? {};
-            return createRichUpdateStream(storage, subscriptionRegistry, { view: viewDef.view, key, ...subscriptionOptions }, key);
-        },
-        async get(key) {
-            return storage.get(viewDef.view, key);
-        },
-        getSync(key) {
-            return storage.getSync(viewDef.view, key);
-        },
-    };
-}
-function createTypedListView(viewDef, storage, subscriptionRegistry) {
-    return {
-        use(options) {
-            const { schema: _schema, ...subscriptionOptions } = options ?? {};
-            return createEntityStream(storage, subscriptionRegistry, { view: viewDef.view, ...subscriptionOptions }, options);
-        },
-        watch(options) {
-            const { schema: _schema, ...subscriptionOptions } = options ?? {};
-            return createUpdateStream(storage, subscriptionRegistry, { view: viewDef.view, ...subscriptionOptions });
-        },
-        watchRich(options) {
-            const { schema: _schema, ...subscriptionOptions } = options ?? {};
-            return createRichUpdateStream(storage, subscriptionRegistry, { view: viewDef.view, ...subscriptionOptions });
-        },
-        async get() {
-            return storage.getAll(viewDef.view);
-        },
-        getSync() {
-            return storage.getAllSync(viewDef.view);
-        },
-    };
-}
-function createTypedViews(stack, storage, subscriptionRegistry) {
-    const views = {};
-    for (const [entityName, viewGroup] of Object.entries(stack.views)) {
-        const group = viewGroup;
-        const typedGroup = {};
-        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[entityName] = typedGroup;
-    }
-    return views;
-}
-
-class ReadRequestError extends Error {
-    constructor(input) {
-        super(`Read request to '${input.path}' failed (${input.status}): ${input.body}`);
-        this.name = 'ReadRequestError';
-        this.status = input.status;
-        this.path = input.path;
-        this.body = input.body;
-        this.serverErrorCode = input.serverErrorCode;
-    }
-}
-function getServerErrorCode(response, body) {
-    const headerCode = response.headers.get('X-Error-Code');
-    if (headerCode) {
-        return headerCode;
-    }
-    try {
-        const parsed = JSON.parse(body);
-        return typeof parsed.code === 'string' ? parsed.code : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-async function parseReadResponse(response, path) {
-    if (!response.ok) {
-        const body = await response.text();
-        throw new ReadRequestError({
-            status: response.status,
-            path,
-            body,
-            serverErrorCode: getServerErrorCode(response, body),
-        });
-    }
-    return response.json();
-}
-function programAccountRead(input) {
-    return {
-        account: input.account,
-        path: input.path,
-        schema: input.schema,
-    };
-}
-function programQuery(input) {
-    return {
-        name: input.name,
-        path: input.path,
-        method: input.method,
-        schema: input.schema,
-    };
-}
-function stackQuery(input) {
-    return {
-        name: input.name,
-        path: input.path,
-        method: input.method,
-        schema: input.schema,
-    };
-}
-
-function joinUrl(baseUrl, path) {
-    return `${baseUrl.replace(/\/$/, '')}${path.startsWith('/') ? path : `/${path}`}`;
-}
-function decodeBase64(encoded) {
-    if (typeof atob === 'function') {
-        const binary = atob(encoded);
-        const bytes = new Uint8Array(binary.length);
-        for (let i = 0; i < binary.length; i++) {
-            bytes[i] = binary.charCodeAt(i);
-        }
-        return bytes;
-    }
-    const bufferCtor = globalThis.Buffer;
-    if (bufferCtor) {
-        return new Uint8Array(bufferCtor.from(encoded, 'base64'));
-    }
-    throw new Error('No base64 decoder available in this environment');
-}
-function deriveHttpEndpoint(wsUrl) {
-    try {
-        const parsed = new URL(wsUrl);
-        if (parsed.protocol === 'ws:') {
-            parsed.protocol = 'http:';
-        }
-        else if (parsed.protocol === 'wss:') {
-            parsed.protocol = 'https:';
-        }
-        return parsed.toString().replace(/\/$/, '');
-    }
-    catch {
-        return wsUrl.replace(/^wss?:/i, (protocol) => protocol.toLowerCase() === 'wss:' ? 'https:' : 'http:');
-    }
-}
-function createChainClient(httpBaseUrl, fetchImpl) {
-    return {
-        async exists(address) {
-            const path = `/chain/exists/${encodeURIComponent(address)}`;
-            const response = await fetchImpl(joinUrl(httpBaseUrl, path));
-            const body = await parseReadResponse(response, path);
-            return body.exists;
-        },
-        async lamports(address) {
-            const path = `/chain/lamports/${encodeURIComponent(address)}`;
-            const response = await fetchImpl(joinUrl(httpBaseUrl, path));
-            const body = await parseReadResponse(response, path);
-            return body.lamports;
-        },
-        async minimumBalanceForRentExemption(space) {
-            const path = `/chain/rent-exemption/${encodeURIComponent(String(space))}`;
-            const response = await fetchImpl(joinUrl(httpBaseUrl, path));
-            const body = await parseReadResponse(response, path);
-            return body.lamports;
-        },
-        async clock() {
-            const path = '/chain/clock';
-            const response = await fetchImpl(joinUrl(httpBaseUrl, path));
-            return parseReadResponse(response, path);
-        },
-        async account(address) {
-            const path = `/chain/accounts/${encodeURIComponent(address)}`;
-            const response = await fetchImpl(joinUrl(httpBaseUrl, path));
-            const body = await parseReadResponse(response, path);
-            if (!body) {
-                return null;
-            }
-            return {
-                address: body.address,
-                ownerProgram: body.ownerProgram,
-                lamports: body.lamports,
-                executable: body.executable,
-                data: decodeBase64(body.data),
-            };
-        },
-        async mint(address) {
-            const path = `/chain/mints/${encodeURIComponent(address)}`;
-            const response = await fetchImpl(joinUrl(httpBaseUrl, path));
-            return parseReadResponse(response, path);
-        },
-        async tokenAccount(address) {
-            const path = `/chain/token-accounts/${encodeURIComponent(address)}`;
-            const response = await fetchImpl(joinUrl(httpBaseUrl, path));
-            return parseReadResponse(response, path);
-        },
-        async balance(input) {
-            const path = '/chain/balances';
-            const response = await fetchImpl(joinUrl(httpBaseUrl, path), {
-                method: 'POST',
-                headers: { 'content-type': 'application/json' },
-                body: JSON.stringify(input),
-            });
-            return parseReadResponse(response, path);
-        },
-    };
-}
-
-/**
- * PDA (Program Derived Address) derivation utilities.
- *
- * Implements Solana's PDA derivation algorithm without depending on @solana/web3.js.
- */
-// Base58 alphabet (Bitcoin/Solana style)
-const BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
-/**
- * Decode base58 string to Uint8Array.
- */
-function decodeBase58(str) {
-    if (str.length === 0) {
-        return new Uint8Array(0);
-    }
-    // Big-endian byte accumulator (stored little-endian here, reversed at the
-    // end). Must start empty: a leading `[0]` produces a spurious extra byte for
-    // all-zero values such as the System Program ("111...1").
-    const bytes = [];
-    for (const char of str) {
-        const value = BASE58_ALPHABET.indexOf(char);
-        if (value === -1) {
-            throw new Error('Invalid base58 character: ' + char);
-        }
-        let carry = value;
-        for (let i = 0; i < bytes.length; i++) {
-            carry += (bytes[i] ?? 0) * 58;
-            bytes[i] = carry & 0xff;
-            carry >>= 8;
-        }
-        while (carry > 0) {
-            bytes.push(carry & 0xff);
-            carry >>= 8;
-        }
-    }
-    // Add leading zeros for each leading '1' in input
-    for (const char of str) {
-        if (char !== '1')
-            break;
-        bytes.push(0);
-    }
-    return new Uint8Array(bytes.reverse());
-}
-/**
- * Encode Uint8Array to base58 string.
- */
-function encodeBase58(bytes) {
-    if (bytes.length === 0) {
-        return '';
-    }
-    // Must start empty for the same reason as `decodeBase58`: a leading `[0]`
-    // yields an extra '1' character when encoding all-zero inputs.
-    const digits = [];
-    for (const byte of bytes) {
-        let carry = byte;
-        for (let i = 0; i < digits.length; i++) {
-            carry += (digits[i] ?? 0) << 8;
-            digits[i] = carry % 58;
-            carry = (carry / 58) | 0;
-        }
-        while (carry > 0) {
-            digits.push(carry % 58);
-            carry = (carry / 58) | 0;
-        }
-    }
-    // Add leading zeros for each leading 0 byte in input
-    for (const byte of bytes) {
-        if (byte !== 0)
-            break;
-        digits.push(0);
-    }
-    return digits.reverse().map(d => BASE58_ALPHABET[d]).join('');
-}
-// SHA-256 round constants (first 32 bits of the fractional parts of the cube
-// roots of the first 64 primes).
-const SHA256_K = new Uint32Array([
-    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
-    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
-    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
-    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
-    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
-    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
-    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
-    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
-]);
-/**
- * Dependency-free, synchronous SHA-256.
- *
- * Used so PDA derivation works identically in browsers, Node (both CJS and
- * ESM), and bundlers without relying on `require('crypto')` or async WebCrypto.
- */
-function sha256Pure(data) {
-    const h = new Uint32Array([
-        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
-        0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
-    ]);
-    const bitLen = data.length * 8;
-    // Pad: append 0x80, then zeros, until length ≡ 56 (mod 64), then 8-byte length.
-    const paddedLen = ((data.length + 8) >> 6) * 64 + 64;
-    const msg = new Uint8Array(paddedLen);
-    msg.set(data);
-    msg[data.length] = 0x80;
-    // 64-bit big-endian bit length (high 32 bits assumed 0 for our seed sizes).
-    const dv = new DataView(msg.buffer);
-    dv.setUint32(paddedLen - 4, bitLen >>> 0, false);
-    dv.setUint32(paddedLen - 8, Math.floor(bitLen / 0x100000000), false);
-    const w = new Uint32Array(64);
-    for (let offset = 0; offset < paddedLen; offset += 64) {
-        for (let i = 0; i < 16; i++) {
-            w[i] = dv.getUint32(offset + i * 4, false);
-        }
-        for (let i = 16; i < 64; i++) {
-            const w15 = w[i - 15];
-            const w2 = w[i - 2];
-            const s0 = ((w15 >>> 7) | (w15 << 25)) ^ ((w15 >>> 18) | (w15 << 14)) ^ (w15 >>> 3);
-            const s1 = ((w2 >>> 17) | (w2 << 15)) ^ ((w2 >>> 19) | (w2 << 13)) ^ (w2 >>> 10);
-            w[i] = (w[i - 16] + s0 + w[i - 7] + s1) >>> 0;
-        }
-        let a = h[0], b = h[1], c = h[2], d = h[3];
-        let e = h[4], f = h[5], g = h[6], hh = h[7];
-        for (let i = 0; i < 64; i++) {
-            const S1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7));
-            const ch = (e & f) ^ (~e & g);
-            const t1 = (hh + S1 + ch + SHA256_K[i] + w[i]) >>> 0;
-            const S0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10));
-            const maj = (a & b) ^ (a & c) ^ (b & c);
-            const t2 = (S0 + maj) >>> 0;
-            hh = g;
-            g = f;
-            f = e;
-            e = (d + t1) >>> 0;
-            d = c;
-            c = b;
-            b = a;
-            a = (t1 + t2) >>> 0;
-        }
-        h[0] = (h[0] + a) >>> 0;
-        h[1] = (h[1] + b) >>> 0;
-        h[2] = (h[2] + c) >>> 0;
-        h[3] = (h[3] + d) >>> 0;
-        h[4] = (h[4] + e) >>> 0;
-        h[5] = (h[5] + f) >>> 0;
-        h[6] = (h[6] + g) >>> 0;
-        h[7] = (h[7] + hh) >>> 0;
-    }
-    const out = new Uint8Array(32);
-    const outView = new DataView(out.buffer);
-    for (let i = 0; i < 8; i++) {
-        outView.setUint32(i * 4, h[i], false);
-    }
-    return out;
-}
-/**
- * SHA-256 hash function (synchronous).
- */
-function sha256Sync(data) {
-    return sha256Pure(data);
-}
-/**
- * SHA-256 hash function (async). Uses WebCrypto when available for speed,
- * otherwise falls back to the pure implementation.
- */
-async function sha256Async(data) {
-    if (typeof globalThis !== 'undefined' && globalThis.crypto && globalThis.crypto.subtle) {
-        const copy = new Uint8Array(data);
-        const hashBuffer = await globalThis.crypto.subtle.digest('SHA-256', copy);
-        return new Uint8Array(hashBuffer);
-    }
-    return sha256Pure(data);
-}
-/**
- * Check if a 32-byte value is a valid point on the ed25519 curve.
- *
- * A valid PDA must be OFF the curve (it must NOT correspond to a real
- * ed25519 public key, so that no private key can ever sign for it).
- *
- * We determine on-curve status by attempting to decompress the candidate
- * as a compressed Edwards point. If decompression succeeds the value lies
- * on the curve; if it throws, the value is off-curve and is a valid PDA.
- * This matches the behaviour of `PublicKey.isOnCurve` in @solana/web3.js.
- */
-function isOnCurve(publicKey) {
-    if (publicKey.length !== 32) {
-        return false;
-    }
-    try {
-        ed25519.Point.fromHex(publicKey);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * PDA marker bytes appended to seeds before hashing.
- */
-const PDA_MARKER = new TextEncoder().encode('ProgramDerivedAddress');
-/**
- * Build the hash input buffer for PDA derivation.
- */
-function buildPdaBuffer(seeds, programIdBytes, bump) {
-    const totalLength = seeds.reduce((sum, s) => sum + s.length, 0)
-        + 1 // bump
-        + 32 // programId
-        + PDA_MARKER.length;
-    const buffer = new Uint8Array(totalLength);
-    let offset = 0;
-    // Copy seeds
-    for (const seed of seeds) {
-        buffer.set(seed, offset);
-        offset += seed.length;
-    }
-    // Add bump seed
-    buffer[offset++] = bump;
-    // Add program ID
-    buffer.set(programIdBytes, offset);
-    offset += 32;
-    // Add PDA marker
-    buffer.set(PDA_MARKER, offset);
-    return buffer;
-}
-/**
- * Validate seeds before PDA derivation.
- */
-function validateSeeds(seeds) {
-    if (seeds.length > 16) {
-        throw new Error('Maximum of 16 seeds allowed');
-    }
-    for (let i = 0; i < seeds.length; i++) {
-        const seed = seeds[i];
-        if (seed && seed.length > 32) {
-            throw new Error('Seed ' + i + ' exceeds maximum length of 32 bytes');
-        }
-    }
-}
-/**
- * Derives a Program-Derived Address (PDA) from seeds and program ID.
- *
- * Algorithm:
- * 1. For bump = 255 down to 0:
- *    a. Concatenate: seeds + [bump] + programId + "ProgramDerivedAddress"
- *    b. SHA-256 hash the concatenation
- *    c. If result is off the ed25519 curve, return it
- * 2. If no valid PDA found after 256 attempts, throw error
- *
- * @param seeds - Array of seed buffers (max 32 bytes each, max 16 seeds)
- * @param programId - The program ID (base58 string)
- * @returns Tuple of [derivedAddress (base58), bumpSeed]
- */
-async function findProgramAddress(seeds, programId) {
-    validateSeeds(seeds);
-    const programIdBytes = decodeBase58(programId);
-    if (programIdBytes.length !== 32) {
-        throw new Error('Program ID must be 32 bytes');
-    }
-    // Try bump seeds from 255 down to 0
-    for (let bump = 255; bump >= 0; bump--) {
-        const buffer = buildPdaBuffer(seeds, programIdBytes, bump);
-        const hash = await sha256Async(buffer);
-        if (!isOnCurve(hash)) {
-            return [encodeBase58(hash), bump];
-        }
-    }
-    throw new Error('Unable to find a valid PDA');
-}
-/**
- * Synchronous version of findProgramAddress.
- * Uses synchronous SHA-256 (Node.js crypto module).
- */
-function findProgramAddressSync(seeds, programId) {
-    validateSeeds(seeds);
-    const programIdBytes = decodeBase58(programId);
-    if (programIdBytes.length !== 32) {
-        throw new Error('Program ID must be 32 bytes');
-    }
-    // Try bump seeds from 255 down to 0
-    for (let bump = 255; bump >= 0; bump--) {
-        const buffer = buildPdaBuffer(seeds, programIdBytes, bump);
-        const hash = sha256Sync(buffer);
-        if (!isOnCurve(hash)) {
-            return [encodeBase58(hash), bump];
-        }
-    }
-    throw new Error('Unable to find a valid PDA');
-}
-/**
- * Creates a seed buffer from various input types.
- *
- * @param value - The value to convert to a seed
- * @returns Uint8Array suitable for PDA derivation
- */
-function createSeed(value) {
-    if (value instanceof Uint8Array) {
-        return value;
-    }
-    if (typeof value === 'string') {
-        return new TextEncoder().encode(value);
-    }
-    if (typeof value === 'bigint') {
-        // Convert bigint to 8-byte buffer (u64 little-endian)
-        const buffer = new Uint8Array(8);
-        let n = value;
-        for (let i = 0; i < 8; i++) {
-            buffer[i] = Number(n & BigInt(0xff));
-            n >>= BigInt(8);
-        }
-        return buffer;
-    }
-    if (typeof value === 'number') {
-        // Assume u64
-        return createSeed(BigInt(value));
-    }
-    throw new Error('Cannot create seed from value');
-}
-/**
- * Creates a public key seed from a base58-encoded address.
- *
- * @param address - Base58-encoded public key
- * @returns 32-byte Uint8Array
- */
-function createPublicKeySeed(address) {
-    const decoded = decodeBase58(address);
-    if (decoded.length !== 32) {
-        throw new Error('Invalid public key length: expected 32, got ' + decoded.length);
-    }
-    return decoded;
-}
-
-/**
- * Typed serialization of PDA seed values.
- *
- * Shared by the standalone PDA DSL (`pda-dsl.ts`) and instruction account
- * resolution (`account-resolver.ts`). When a seed carries a declared type
- * (from the IDL or the `pdas!` registry), encoding is exact: pubkeys are
- * base58-decoded to 32 bytes, integers are little-endian at the declared
- * width. Without a type, legacy heuristics apply for backward compatibility.
- */
-/**
- * Normalizes the type-name variants that IDLs and codegen produce
- * ("Pubkey", "publicKey", "solana_pubkey::Pubkey", "String", ...) to a
- * canonical seed type. Returns undefined for types that cannot be a seed.
- */
-function normalizeSeedType(argType) {
-    if (!argType)
-        return undefined;
-    // Strip any path qualifier (e.g. solana_pubkey::Pubkey).
-    const parts = argType.split('::');
-    const t = (parts[parts.length - 1] ?? argType).trim();
-    if (/^[ui](8|16|32|64|128)$/.test(t)) {
-        return t;
-    }
-    switch (t) {
-        case 'pubkey':
-        case 'Pubkey':
-        case 'publicKey':
-        case 'PublicKey':
-            return 'pubkey';
-        case 'string':
-        case 'String':
-        case 'str':
-            return 'string';
-        default:
-            return undefined;
-    }
-}
-/**
- * Serializes a PDA seed value.
- *
- * With a recognized `argType`, encoding is strict and width-exact; an
- * incompatible value throws rather than deriving a wrong address. Without
- * one, the legacy heuristics apply: raw bytes pass through, 43/44-character
- * strings are tried as base58, other strings are utf-8, numbers are 8-byte
- * little-endian u64.
- */
-function serializeSeedValue(value, argType) {
-    if (value instanceof Uint8Array) {
-        return value;
-    }
-    const t = normalizeSeedType(argType);
-    if (t === 'pubkey') {
-        if (typeof value !== 'string') {
-            throw new Error(`Pubkey seed requires a base58 string, got ${typeof value}`);
-        }
-        const decoded = decodeBase58(value);
-        if (decoded.length !== 32) {
-            throw new Error(`Pubkey seed '${value}' decoded to ${decoded.length} bytes, expected 32`);
-        }
-        return decoded;
-    }
-    if (t === 'string') {
-        if (typeof value !== 'string') {
-            throw new Error(`String seed requires a string value, got ${typeof value}`);
-        }
-        return new TextEncoder().encode(value);
-    }
-    if (t !== undefined) {
-        // Numeric type at a declared width.
-        if (typeof value !== 'bigint' && typeof value !== 'number') {
-            throw new Error(`Numeric seed of type ${t} requires a number/bigint, got ${typeof value}`);
-        }
-        const bits = parseInt(t.slice(1), 10);
-        return serializeNumber(value, bits / 8, t.startsWith('i'));
-    }
-    // --- Untyped: legacy heuristics. ---
-    if (typeof value === 'string') {
-        if (value.length === 43 || value.length === 44) {
-            try {
-                return decodeBase58(value);
-            }
-            catch {
-                return new TextEncoder().encode(value);
-            }
-        }
-        return new TextEncoder().encode(value);
-    }
-    if (typeof value === 'bigint' || typeof value === 'number') {
-        return serializeNumber(value, 8, true);
-    }
-    throw new Error(`Cannot serialize value for PDA seed: ${typeof value}`);
-}
-/**
- * Little-endian two's-complement encoding at a fixed byte width, with an
- * overflow check so out-of-range values fail instead of silently truncating.
- */
-function serializeNumber(value, size, signed) {
-    const buffer = new Uint8Array(size);
-    let n = typeof value === 'bigint' ? value : BigInt(value);
-    const original = n;
-    for (let i = 0; i < size; i++) {
-        buffer[i] = Number(n & BigInt(0xff));
-        n >>= BigInt(8);
-    }
-    const fits = signed ? n === BigInt(0) || n === BigInt(-1) : n === BigInt(0);
-    if (!fits) {
-        throw new Error(`Seed value ${original} does not fit in ${size * 8} bits`);
-    }
-    return buffer;
-}
-
-function getValueByPath(source, path) {
-    if (!source) {
-        return undefined;
-    }
-    if (Object.prototype.hasOwnProperty.call(source, path)) {
-        return source[path];
-    }
-    let current = source;
-    for (const segment of path.split('.')) {
-        if (current === null || typeof current !== 'object') {
-            return undefined;
-        }
-        current = current[segment];
-    }
-    return current;
-}
-
-/**
- * Topologically sort accounts so that dependencies (accountRef) are resolved first.
- * Non-PDA accounts come first, then PDAs in dependency order.
- */
-function sortAccountsByDependency(accountMetas) {
-    // Separate non-PDA and PDA accounts
-    const nonPda = [];
-    const pda = [];
-    for (const meta of accountMetas) {
-        if (meta.category === 'pda') {
-            pda.push(meta);
-        }
-        else {
-            nonPda.push(meta);
-        }
-    }
-    // Build dependency graph for PDAs
-    const pdaDeps = new Map();
-    for (const meta of pda) {
-        const deps = new Set();
-        if (meta.pdaConfig) {
-            for (const seed of meta.pdaConfig.seeds) {
-                if (seed.type === 'accountRef') {
-                    deps.add(seed.accountName);
-                }
-            }
-        }
-        pdaDeps.set(meta.name, deps);
-    }
-    // Topological sort PDAs
-    const sortedPda = [];
-    const visited = new Set();
-    const visiting = new Set();
-    function visit(name) {
-        if (visited.has(name))
-            return;
-        if (visiting.has(name)) {
-            throw new Error('Circular dependency in PDA accounts: ' + name);
-        }
-        const meta = pda.find(m => m.name === name);
-        if (!meta)
-            return; // Not a PDA, skip
-        visiting.add(name);
-        const deps = pdaDeps.get(name) || new Set();
-        for (const dep of deps) {
-            // Only visit if dep is also a PDA
-            if (pda.some(m => m.name === dep)) {
-                visit(dep);
-            }
-        }
-        visiting.delete(name);
-        visited.add(name);
-        sortedPda.push(meta);
-    }
-    for (const meta of pda) {
-        visit(meta.name);
-    }
-    return [...nonPda, ...sortedPda];
-}
-/**
- * Resolves instruction accounts by categorizing and deriving addresses.
- *
- * Resolution order:
- * 1. Non-PDA accounts (signer, known, userProvided) are resolved first
- * 2. PDA accounts are resolved in dependency order (accounts they reference come first)
- *
- * @param accountMetas - Account metadata from the instruction definition
- * @param args - Instruction arguments (used for PDA derivation with argRef seeds)
- * @param options - Resolution options including wallet, user-provided accounts, and programId
- * @returns Resolved accounts and any missing required accounts
- */
-function resolveAccounts(accountMetas, args, options) {
-    // Sort accounts by dependency
-    const sorted = sortAccountsByDependency(accountMetas);
-    // Track resolved accounts for PDA accountRef lookups
-    const resolvedMap = {};
-    const missing = [];
-    for (const meta of sorted) {
-        const resolvedAccount = resolveSingleAccount(meta, args, options, resolvedMap);
-        if (resolvedAccount) {
-            resolvedMap[meta.name] = resolvedAccount;
-        }
-        else if (!meta.isOptional) {
-            missing.push(meta.name);
-        }
-    }
-    // Return accounts in original order (as defined in accountMetas).
-    //
-    // Omitted optional accounts that precede a resolved account cannot simply
-    // be dropped — that would shift every later account into the wrong slot.
-    // Anchor's convention is to pass the program ID as a placeholder; trailing
-    // omitted optionals are dropped as usual.
-    const lastResolvedIndex = accountMetas.reduce((last, meta, index) => (resolvedMap[meta.name] ? index : last), -1);
-    const orderedAccounts = [];
-    for (let i = 0; i < accountMetas.length; i++) {
-        const meta = accountMetas[i];
-        const resolved = resolvedMap[meta.name];
-        if (resolved) {
-            orderedAccounts.push(resolved);
-        }
-        else if (meta.isOptional && i < lastResolvedIndex) {
-            if (!options.programId) {
-                throw new Error('Omitted optional account "' + meta.name + '" precedes other accounts and needs ' +
-                    'the program ID as a placeholder, but no programId was provided in options.');
-            }
-            orderedAccounts.push({
-                name: meta.name,
-                address: options.programId,
-                isSigner: false,
-                isWritable: false,
-            });
-        }
-    }
-    return {
-        accounts: orderedAccounts,
-        missingUserAccounts: missing,
-    };
-}
-function resolveSingleAccount(meta, args, options, resolvedMap) {
-    switch (meta.category) {
-        case 'signer':
-            return resolveSignerAccount(meta, options.accounts, options.wallet);
-        case 'known':
-            return resolveKnownAccount(meta);
-        case 'pda':
-            return resolvePdaAccount(meta, args, resolvedMap, options.programId, options.resolve);
-        case 'userProvided':
-            return resolveUserProvidedAccount(meta, options.accounts);
-        default:
-            return null;
-    }
-}
-function resolveSignerAccount(meta, accounts, wallet) {
-    const address = accounts?.[meta.name] ?? wallet?.publicKey;
-    if (!address) {
-        return null;
-    }
-    return {
-        name: meta.name,
-        address,
-        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, resolvedMap, programId, resolve) {
-    if (!meta.pdaConfig) {
-        return null;
-    }
-    // Determine which program to derive against
-    const pdaProgramId = meta.pdaConfig.programId || programId;
-    if (!pdaProgramId) {
-        throw new Error('Cannot derive PDA for "' + meta.name + '": no programId specified. ' +
-            'Either set pdaConfig.programId or pass programId in options.');
-    }
-    // Build seeds array
-    const seeds = [];
-    for (const seed of meta.pdaConfig.seeds) {
-        switch (seed.type) {
-            case 'literal':
-                seeds.push(createSeed(seed.value));
-                break;
-            case 'bytes':
-                seeds.push(Uint8Array.from(seed.value));
-                break;
-            case 'argRef': {
-                const argValue = getValueByPath(args, seed.argName) ?? getValueByPath(resolve, seed.argName);
-                if (argValue === undefined) {
-                    throw new Error('PDA seed references missing argument: ' + seed.argName +
-                        ' (for account "' + meta.name + '")');
-                }
-                seeds.push(serializeSeedValue(argValue, seed.argType));
-                break;
-            }
-            case 'accountRef': {
-                const refAccount = resolvedMap[seed.accountName];
-                if (!refAccount) {
-                    throw new Error('PDA seed references unresolved account: ' + seed.accountName +
-                        ' (for account "' + meta.name + '")');
-                }
-                // Account addresses are 32 bytes
-                seeds.push(decodeBase58(refAccount.address));
-                break;
-            }
-            default:
-                throw new Error('Unknown seed type');
-        }
-    }
-    // Derive the PDA
-    const [derivedAddress] = findProgramAddressSync(seeds, pdaProgramId);
-    return {
-        name: meta.name,
-        address: derivedAddress,
-        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(', '));
-    }
-}
-
-/**
- * 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];
-        // Option fields treat undefined as None; everything else must be present
-        // (silently encoding zeros for a missing arg corrupts instruction data).
-        if (value === undefined && !(typeof field.type === 'object' && 'option' in field.type)) {
-            throw new Error(`Missing required argument "${field.name}" (type ${JSON.stringify(field.type)})`);
-        }
-        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]);
-    }
-    if ('hashMap' in type) {
-        return serializeHashMap(value, type.hashMap[0], type.hashMap[1]);
-    }
-    if ('struct' in type) {
-        return serializeStruct(value, type.struct);
-    }
-    if ('enum' in type) {
-        return serializeEnum(value, type.enum);
-    }
-    throw new Error(`Unknown type: ${JSON.stringify(type)}`);
-}
-function serializeStruct(value, fields) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-        throw new Error(`Struct value must be a plain object, got ${typeof value}`);
-    }
-    const obj = value;
-    const buffers = [];
-    for (const field of fields) {
-        const fieldValue = obj[field.name];
-        if (fieldValue === undefined &&
-            !(typeof field.type === 'object' && 'option' in field.type)) {
-            throw new Error(`Missing required struct field "${field.name}"`);
-        }
-        buffers.push(serializeValue(fieldValue, field.type));
-    }
-    return Buffer.concat(buffers);
-}
-function serializeHashMap(value, keyType, valueType) {
-    if (keyType !== 'string') {
-        throw new Error(`Instruction hashMap keys must use the 'string' schema, got ${JSON.stringify(keyType)}`);
-    }
-    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-        throw new Error(`HashMap value must be a plain object, got ${typeof value}`);
-    }
-    const entries = Object.entries(value).sort(([left], [right]) => 
-    // Rust/Borsh sorts String keys by their UTF-8 bytes before serializing.
-    Buffer.compare(Buffer.from(left, 'utf8'), Buffer.from(right, 'utf8')));
-    const len = Buffer.alloc(4);
-    len.writeUInt32LE(entries.length, 0);
-    const entryBuffers = [];
-    for (const [key, entryValue] of entries) {
-        entryBuffers.push(serializePrimitive(key, 'string'));
-        entryBuffers.push(serializeValue(entryValue, valueType));
-    }
-    return Buffer.concat([len, ...entryBuffers]);
-}
-function variantName(variant) {
-    return typeof variant === 'string' ? variant : variant.name;
-}
-function serializeEnum(value, variants) {
-    // Numeric value: a bare variant index (fieldless variants only).
-    if (typeof value === 'number') {
-        if (!Number.isInteger(value) || value < 0 || value >= variants.length) {
-            throw new Error(`Enum variant index ${value} out of range (0..${variants.length - 1})`);
-        }
-        const variant = variants[value];
-        if (typeof variant !== 'string') {
-            throw new Error(`Enum variant "${variantName(variant)}" carries data; pass { ${variantName(variant)}: ... } instead of an index`);
-        }
-        return Buffer.from([value]);
-    }
-    // String value: a fieldless variant by name.
-    if (typeof value === 'string') {
-        const index = variants.findIndex((v) => variantName(v) === value);
-        if (index === -1) {
-            throw new Error(`Unknown enum variant "${value}". Expected one of: ${variants.map(variantName).join(', ')}`);
-        }
-        const variant = variants[index];
-        if (typeof variant !== 'string') {
-            throw new Error(`Enum variant "${value}" carries data; pass { ${value}: ... } instead of a bare name`);
-        }
-        return Buffer.from([index]);
-    }
-    // Object value: { variantName: payload } for data-carrying variants.
-    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-        const keys = Object.keys(value);
-        if (keys.length !== 1) {
-            throw new Error(`Enum value must be a single-key object ({ variantName: payload }), got keys [${keys.join(', ')}]`);
-        }
-        const key = keys[0];
-        const payload = value[key];
-        const index = variants.findIndex((v) => variantName(v) === key);
-        if (index === -1) {
-            throw new Error(`Unknown enum variant "${key}". Expected one of: ${variants.map(variantName).join(', ')}`);
-        }
-        const variant = variants[index];
-        if (typeof variant === 'string') {
-            throw new Error(`Enum variant "${key}" is fieldless; pass '${key}' instead of an object`);
-        }
-        const prefix = Buffer.from([index]);
-        if ('fields' in variant) {
-            return Buffer.concat([prefix, serializeStruct(payload, variant.fields)]);
-        }
-        const tuple = payload;
-        if (!Array.isArray(tuple) || tuple.length !== variant.tuple.length) {
-            throw new Error(`Enum variant "${key}" expects a tuple of length ${variant.tuple.length}`);
-        }
-        const elements = variant.tuple.map((elementType, i) => serializeValue(tuple[i], elementType));
-        return Buffer.concat([prefix, ...elements]);
-    }
-    throw new Error(`Cannot serialize enum from value of type ${typeof value}`);
-}
-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);
-            // The masked low limb is always non-negative, so it must be written
-            // unsigned; the arithmetic-shifted high limb carries the sign.
-            i128.writeBigUInt64LE(bigI128 & BigInt('0xFFFFFFFFFFFFFFFF'), 0);
-            i128.writeBigInt64LE(bigI128 >> BigInt(64), 8);
-            return i128;
-        case 'f32': {
-            const f32 = Buffer.alloc(4);
-            f32.writeFloatLE(value, 0);
-            return f32;
-        }
-        case 'f64': {
-            const f64 = Buffer.alloc(8);
-            f64.writeDoubleLE(value, 0);
-            return f64;
-        }
-        case 'bool':
-            return Buffer.from([value ? 1 : 0]);
-        case 'bytes': {
-            // Borsh bytes: u32 LE length prefix + raw bytes.
-            const raw = value instanceof Uint8Array
-                ? value
-                : Array.isArray(value)
-                    ? Uint8Array.from(value)
-                    : null;
-            if (raw === null) {
-                throw new Error(`Cannot serialize bytes from value of type ${typeof value}`);
-            }
-            const lenPrefix = Buffer.alloc(4);
-            lenPrefix.writeUInt32LE(raw.length, 0);
-            return Buffer.concat([lenPrefix, Buffer.from(raw)]);
-        }
-        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': {
-            // Public key is 32 bytes. Accept base58 strings or raw 32-byte buffers.
-            if (value instanceof Uint8Array) {
-                if (value.length !== 32) {
-                    throw new Error(`Invalid pubkey byte length: expected 32, got ${value.length}`);
-                }
-                return Buffer.from(value);
-            }
-            if (typeof value === 'string') {
-                const decoded = decodeBase58(value);
-                if (decoded.length !== 32) {
-                    throw new Error(`Invalid pubkey: '${value}' decoded to ${decoded.length} bytes, expected 32`);
-                }
-                return Buffer.from(decoded);
-            }
-            throw new Error(`Cannot serialize pubkey from value of type ${typeof value}`);
-        }
-        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);
-}
-
-/**
- * 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}`;
-}
-/**
- * Error thrown when an instruction fails to send and the underlying failure
- * could be parsed against the handler's IDL error definitions.
- */
-class InstructionError extends Error {
-    constructor(message, programError, cause) {
-        super(message);
-        this.name = 'InstructionError';
-        this.programError = programError;
-        this.cause = cause;
-    }
-}
-
-/**
- * Creates a data-driven instruction handler.
- *
- * The returned handler implements `build()` generically: it serializes args
- * via the schema-driven serializer and constructs the account key list from
- * the resolved, ordered accounts. No imperative per-instruction code is
- * required, which keeps generated SDKs tiny and puts all serialization logic
- * in one tested place.
- */
-function createInstructionHandler(config) {
-    const discriminator = config.discriminator instanceof Uint8Array
-        ? config.discriminator
-        : Uint8Array.from(config.discriminator);
-    const argNames = config.args.map((a) => a.name);
-    const errors = config.errors ?? [];
-    return {
-        programId: config.programId,
-        accounts: config.accounts,
-        errors,
-        argNames,
-        build(args, resolved) {
-            const data = serializeInstructionData(discriminator, args, config.args);
-            return {
-                programId: config.programId,
-                keys: resolved.map((r) => ({
-                    pubkey: r.address,
-                    isSigner: r.isSigner,
-                    isWritable: r.isWritable,
-                })),
-                data,
-            };
-        },
-    };
-}
-/**
- * Splits a merged params object into serialized args and account overrides.
- *
- * Keys matching a declared argument name are args; keys matching a declared
- * account name (with a string value) are account address overrides. This
- * applies to signer slots too, allowing explicit signer addresses to override
- * the wallet fallback. Anything else throws — a typo'd key silently dropped
- * here would otherwise change the built instruction. `options.accounts` on
- * {@link BuildOptions} remains an unvalidated escape hatch for advanced callers.
- */
-function splitParams(handler, params) {
-    const argNameSet = new Set(handler.argNames);
-    const accountNameSet = new Set(handler.accounts.map((a) => a.name));
-    const args = {};
-    const accountOverrides = {};
-    let resolve;
-    for (const [key, value] of Object.entries(params)) {
-        if (argNameSet.has(key)) {
-            args[key] = value;
-        }
-        else if (key === 'resolve' && !accountNameSet.has(key)) {
-            if (value === undefined) {
-                continue;
-            }
-            if (value === null || Array.isArray(value) || typeof value !== 'object') {
-                throw new Error('Parameter "resolve" must be an object when provided');
-            }
-            resolve = value;
-        }
-        else if (accountNameSet.has(key)) {
-            if (typeof value !== 'string') {
-                // Non-string values are not valid account addresses.
-                throw new Error(`Parameter "${key}" is not a known argument and is not a base58 account address`);
-            }
-            accountOverrides[key] = value;
-        }
-        else {
-            throw new Error(`Unknown parameter "${key}". Expected one of args [${[...argNameSet].join(', ')}] ` +
-                `or accounts [${[...accountNameSet].join(', ')}]`);
-        }
-    }
-    return { args, accountOverrides, resolve };
-}
-/**
- * Builds a {@link BuiltInstruction} from a handler and a merged params object.
- *
- * This is a pure function: it performs no network access. It is the unit of
- * composition for batching (`wallet.signAndSend([a, b, c])`).
- */
-function buildInstruction(handler, params, options = {}) {
-    const { args, accountOverrides, resolve } = splitParams(handler, params);
-    const resolutionOptions = {
-        accounts: { ...accountOverrides, ...options.accounts },
-        resolve,
-        wallet: options.wallet,
-        programId: handler.programId,
-    };
-    const resolution = resolveAccounts(handler.accounts, args, resolutionOptions);
-    validateAccountResolution(resolution);
-    const instruction = handler.build(args, resolution.accounts);
-    if (options.remainingAccounts?.length) {
-        instruction.keys.push(...options.remainingAccounts);
-    }
-    return instruction;
-}
-/**
- * Builds, signs, and sends an instruction via the wallet adapter.
- *
- * The core SDK does not touch RPC: the adapter owns blockhash, compilation,
- * signing, sending, and confirmation. On failure, program errors are parsed
- * against the handler's IDL error definitions and surfaced as an
- * {@link InstructionError}.
- */
-async function executeInstruction(handler, params, options = {}) {
-    const instruction = buildInstruction(handler, params, options);
-    if (!options.wallet) {
-        throw new Error('Wallet required to sign and send transaction');
-    }
-    const sendOptions = {
-        ...options.send,
-    };
-    if (options.confirmationLevel !== undefined) {
-        sendOptions.confirmationLevel = options.confirmationLevel;
-    }
-    try {
-        const result = await options.wallet.signAndSend([instruction], sendOptions);
-        return { signature: result.signature, slot: result.slot };
-    }
-    catch (err) {
-        const programError = parseInstructionError(err, handler.errors);
-        if (programError) {
-            throw new InstructionError(`${programError.name} (${programError.code}): ${programError.message}`, programError, err);
-        }
-        throw err;
-    }
-}
-/**
- * Creates an instruction executor bound to a specific wallet.
- */
-function createInstructionExecutor(wallet) {
-    return {
-        execute: async (handler, params, options) => {
-            return executeInstruction(handler, params, { ...options, wallet });
-        },
-        build: (handler, params, options) => {
-            return buildInstruction(handler, params, { ...options, wallet });
-        },
-    };
-}
-
-function literal(value) {
-    return { type: 'literal', value };
-}
-function account(name) {
-    return { type: 'accountRef', accountName: name };
-}
-function arg(name, type) {
-    return { type: 'argRef', argName: name, argType: type };
-}
-function bytes(value) {
-    return { type: 'bytes', value };
-}
-function resolveSeeds(seeds, context) {
-    return seeds.map((seed) => {
-        switch (seed.type) {
-            case 'literal':
-                return new TextEncoder().encode(seed.value);
-            case 'bytes':
-                return seed.value;
-            case 'argRef': {
-                const value = getValueByPath(context.args, seed.argName) ?? getValueByPath(context.resolve, seed.argName);
-                if (value === undefined) {
-                    throw new Error(`Missing arg for PDA seed: ${seed.argName}`);
-                }
-                return serializeSeedValue(value, seed.argType);
-            }
-            case 'accountRef': {
-                const address = context.accounts?.[seed.accountName];
-                if (!address) {
-                    throw new Error(`Missing account for PDA seed: ${seed.accountName}`);
-                }
-                return decodeBase58(address);
-            }
-        }
-    });
-}
-function pda(programId, ...seeds) {
-    return {
-        seeds,
-        programId,
-        program(newProgramId) {
-            return pda(newProgramId, ...seeds);
-        },
-        async derive(context) {
-            const resolvedSeeds = resolveSeeds(this.seeds, context);
-            const pid = context.programId ?? this.programId;
-            const [address] = await findProgramAddress(resolvedSeeds, pid);
-            return address;
-        },
-        deriveSync(context) {
-            const resolvedSeeds = resolveSeeds(this.seeds, context);
-            const pid = context.programId ?? this.programId;
-            const [address] = findProgramAddressSync(resolvedSeeds, pid);
-            return address;
-        },
-    };
-}
-function createProgramPdas(pdas) {
-    return pdas;
-}
-
-const STACK_RUNTIME_EXTENSIONS = '__areteStackRuntimeExtensions';
-const PROGRAM_OPERATION_EXTENSIONS = '__areteProgramOperationExtensions';
-function defineProgramExtensions() {
-    return (extensions) => extensions;
-}
-function mergeNamespace(base, extension) {
-    if (base && typeof base === 'object' && !Array.isArray(base)
-        && extension && typeof extension === 'object' && !Array.isArray(extension)) {
-        const merged = { ...base };
-        for (const [key, value] of Object.entries(extension)) {
-            merged[key] = key in merged ? mergeNamespace(merged[key], value) : value;
-        }
-        return merged;
-    }
-    return extension;
-}
-function mergeOperations(base, extension) {
-    return {
-        instructions: mergeNamespace(base?.instructions, extension?.instructions),
-        transactions: mergeNamespace(base?.transactions, extension?.transactions),
-        flows: mergeNamespace(base?.flows, extension?.flows),
-    };
-}
-function extendProgram(program, extensions) {
-    const base = program;
-    const extended = { ...program };
-    for (const key of ['pdas', 'accounts', 'queries', 'addresses', 'constants', 'defaults', 'math']) {
-        const extensionValue = extensions[key];
-        if (extensionValue !== undefined) {
-            extended[key] = mergeNamespace(base[key], extensionValue);
-        }
-    }
-    if (extensions.raw !== undefined) {
-        extended.rawInstructions = mergeNamespace(base.rawInstructions, extensions.raw);
-    }
-    const baseFactory = base[PROGRAM_OPERATION_EXTENSIONS]?.createOperations;
-    const extensionFactory = extensions.createOperations;
-    if (baseFactory || extensionFactory) {
-        Object.defineProperty(extended, PROGRAM_OPERATION_EXTENSIONS, {
-            value: {
-                createOperations(context) {
-                    const baseOperations = baseFactory?.(context);
-                    if (baseOperations) {
-                        const connectedProgram = context.program;
-                        connectedProgram.instructions = mergeNamespace(connectedProgram.instructions, baseOperations.instructions);
-                        connectedProgram.transactions = mergeNamespace(connectedProgram.transactions, baseOperations.transactions);
-                        connectedProgram.flows = mergeNamespace(connectedProgram.flows, baseOperations.flows);
-                    }
-                    return mergeOperations(baseOperations, extensionFactory?.(context));
-                },
-            },
-            enumerable: false,
-            configurable: false,
-            writable: false,
-        });
-    }
-    return extended;
-}
-function extendPrograms(programs, extensions) {
-    const merged = { ...programs };
-    for (const [name, program] of Object.entries(programs)) {
-        const extension = extensions[name];
-        merged[name] = extension
-            ? extendProgram(program, extension)
-            : program;
-    }
-    return merged;
-}
-function getProgramRuntimeExtensions(program) {
-    return program[PROGRAM_OPERATION_EXTENSIONS];
-}
-function defineStackExtensions() {
-    return (extensions) => extensions;
-}
-function extendStack(stack, extensions) {
-    const base = stack;
-    const extended = { ...stack };
-    for (const key of ['addresses', 'constants', 'defaults', 'math']) {
-        if (extensions[key] !== undefined) {
-            extended[key] = mergeNamespace(base[key], extensions[key]);
-        }
-    }
-    const baseRuntime = base[STACK_RUNTIME_EXTENSIONS];
-    if (baseRuntime || extensions.createRead || extensions.createFlows) {
-        Object.defineProperty(extended, STACK_RUNTIME_EXTENSIONS, {
-            value: {
-                createRead: baseRuntime?.createRead && extensions.createRead
-                    ? (client) => mergeNamespace(baseRuntime.createRead(client), extensions.createRead(client))
-                    : extensions.createRead ?? baseRuntime?.createRead,
-                createFlows: baseRuntime?.createFlows && extensions.createFlows
-                    ? (client) => mergeNamespace(baseRuntime.createFlows(client), extensions.createFlows(client))
-                    : extensions.createFlows ?? baseRuntime?.createFlows,
-            },
-            enumerable: false,
-            configurable: false,
-            writable: false,
-        });
-    }
-    return extended;
-}
-function getStackRuntimeExtensions(stack) {
-    return stack[STACK_RUNTIME_EXTENSIONS];
-}
-function defineClientField(target, key, value) {
-    if (value === undefined || key in target) {
-        return;
-    }
-    Object.defineProperty(target, key, {
-        value,
-        enumerable: true,
-        configurable: true,
-        writable: false,
-    });
-}
-function applyConnectedStackExtensions(client, stack) {
-    const extendedStack = stack;
-    defineClientField(client, 'addresses', extendedStack.addresses);
-    defineClientField(client, 'constants', extendedStack.constants);
-    defineClientField(client, 'defaults', extendedStack.defaults);
-    defineClientField(client, 'math', extendedStack.math);
-    const runtime = getStackRuntimeExtensions(stack);
-    defineClientField(client, 'flows', runtime?.createFlows?.(client));
-    defineClientField(client, 'read', runtime?.createRead?.(client));
-    return client;
-}
-
-function isPreparedInstruction(instruction) {
-    return 'kind' in instruction
-        && instruction.kind === 'instruction'
-        && 'instruction' in instruction;
-}
-function nonEmpty(values, label) {
-    if (values.length === 0) {
-        throw new Error(`${label} must contain at least one item`);
-    }
-    return [...values];
-}
-function dedupe(values) {
-    return [...new Set(values)];
-}
-function inferSignerAddresses(instructions) {
-    return dedupe(instructions.flatMap((instruction) => instruction.keys.filter((key) => key.isSigner).map((key) => key.pubkey)));
-}
-function createPreparedTransactionBody(input) {
-    const instructions = nonEmpty(input.instructions, `Transaction '${input.name}'`);
-    return {
-        name: input.name,
-        instructions,
-        requiredSignerAddresses: dedupe(input.requiredSignerAddresses ?? inferSignerAddresses(instructions)),
-        errors: [...(input.errors ?? [])],
-    };
-}
-function createPlan(name, artifacts, transactions) {
-    return {
-        name,
-        artifacts,
-        transactions: nonEmpty(transactions, `Flow '${name}'`),
-    };
-}
-function createPreparedInstruction(input) {
-    const transaction = createPreparedTransactionBody({
-        name: input.name,
-        instructions: [input.instruction],
-        requiredSignerAddresses: input.requiredSignerAddresses,
-        errors: input.errors,
-    });
-    return {
-        kind: 'instruction',
-        name: input.name,
-        instruction: input.instruction,
-        transaction,
-        plan: createPlan(input.name, input.artifacts, [transaction]),
-        artifacts: input.artifacts,
-    };
-}
-function createPreparedTransaction(input) {
-    const hasInstructions = input.instructions !== undefined;
-    const hasOperations = input.operations !== undefined;
-    if (hasInstructions === hasOperations) {
-        throw new Error(`Transaction '${input.name}' must provide exactly one of instructions or operations`);
-    }
-    const transactionParts = hasOperations
-        ? input.operations.map((operation) => operation.transaction)
-        : input.instructions.map((instruction) => isPreparedInstruction(instruction)
-            ? instruction.transaction
-            : createPreparedTransactionBody({
-                name: input.name,
-                instructions: [instruction],
-            }));
-    const transaction = createPreparedTransactionBody({
-        name: input.name,
-        instructions: transactionParts.flatMap((part) => part.instructions),
-        requiredSignerAddresses: input.requiredSignerAddresses
-            ?? transactionParts.flatMap((part) => part.requiredSignerAddresses),
-        errors: input.errors ?? transactionParts.flatMap((part) => part.errors),
-    });
-    return {
-        kind: 'transaction',
-        name: input.name,
-        transaction,
-        plan: createPlan(input.name, input.artifacts, [transaction]),
-        artifacts: input.artifacts,
-    };
-}
-function createPreparedFlow(input) {
-    const transactions = input.transactions.map((transaction) => createPreparedTransactionBody(transaction));
-    return {
-        kind: 'flow',
-        name: input.name,
-        plan: createPlan(input.name, input.artifacts, transactions),
-        artifacts: input.artifacts,
-    };
-}
-function prependTransactionInstructions(transaction, instructions) {
-    return createPreparedTransactionBody({
-        ...transaction,
-        instructions: [...instructions, ...transaction.instructions],
-        requiredSignerAddresses: [
-            ...inferSignerAddresses(instructions),
-            ...transaction.requiredSignerAddresses,
-        ],
-    });
-}
-function appendTransactionInstructions(transaction, instructions) {
-    return createPreparedTransactionBody({
-        ...transaction,
-        instructions: [...transaction.instructions, ...instructions],
-        requiredSignerAddresses: [
-            ...transaction.requiredSignerAddresses,
-            ...inferSignerAddresses(instructions),
-        ],
-    });
-}
-function appendFlowTransactions(flow, transactions) {
-    return createPreparedFlow({
-        name: flow.name,
-        artifacts: flow.artifacts,
-        transactions: [...flow.plan.transactions, ...transactions],
-    });
-}
-function prependFlowTransactionInstructions(flow, transactionIndex, instructions) {
-    const transaction = flow.plan.transactions[transactionIndex];
-    if (!transaction) {
-        throw new Error(`Flow '${flow.name}' has no transaction at index ${transactionIndex}`);
-    }
-    const transactions = [...flow.plan.transactions];
-    transactions[transactionIndex] = prependTransactionInstructions(transaction, instructions);
-    return createPreparedFlow({
-        name: flow.name,
-        artifacts: flow.artifacts,
-        transactions,
-    });
-}
-function inferSignerAddress(value) {
-    if (typeof value === 'string' && value.length > 0) {
-        return value;
-    }
-    if (!value || typeof value !== 'object') {
-        return null;
-    }
-    const candidate = value;
-    if (typeof candidate.address === 'string' && candidate.address.length > 0) {
-        return candidate.address;
-    }
-    if (typeof candidate.publicKey === 'string' && candidate.publicKey.length > 0) {
-        return candidate.publicKey;
-    }
-    const publicKey = candidate.publicKey;
-    return typeof publicKey?.toBase58 === 'function' ? publicKey.toBase58() : null;
-}
-function validateTransactionSigners(transaction, host, options) {
-    const signerAddresses = (options.signers ?? []).map(inferSignerAddress);
-    const available = new Set(options.availableSignerAddresses ?? []);
-    for (const address of options.signerRegistry?.addresses() ?? []) {
-        available.add(address);
-    }
-    const wallet = options.wallet ?? host.wallet;
-    for (const address of wallet?.signerAddresses ?? []) {
-        available.add(address);
-    }
-    const walletAddress = wallet?.publicKey ?? host.publicKey;
-    if (walletAddress) {
-        available.add(walletAddress);
-    }
-    for (const address of signerAddresses) {
-        if (address) {
-            available.add(address);
-        }
-    }
-    const missing = transaction.requiredSignerAddresses.filter((address) => !available.has(address));
-    if (missing.length > 0) {
-        throw new Error(`Missing signer(s) for ${transaction.name}: ${missing.join(', ')}`);
-    }
-}
-class OperationExecutionError extends Error {
-    constructor(input) {
-        super(`Operation '${input.operation.name}' failed at transaction ${input.failedTransactionIndex + 1} (${input.failedTransaction.name})`);
-        this.name = 'OperationExecutionError';
-        this.operation = input.operation;
-        this.failedTransaction = input.failedTransaction;
-        this.failedTransactionIndex = input.failedTransactionIndex;
-        this.completedReceipts = [...input.completedReceipts];
-        this.cause = input.cause;
-    }
-}
-async function executePreparedOperation(host, operation, options = {}) {
-    const receipts = [];
-    const signers = [
-        ...new Set([
-            ...(options.signerRegistry?.values() ?? []),
-            ...(options.signers ?? []),
-        ]),
-    ];
-    for (const [transactionIndex, transaction] of operation.plan.transactions.entries()) {
-        try {
-            validateTransactionSigners(transaction, host, options);
-            await options.onTransactionStart?.({ operation, transaction, transactionIndex });
-            const result = await host.transaction(transaction.instructions, {
-                wallet: options.wallet,
-                send: options.send,
-                errors: [...transaction.errors],
-                signers: signers.length > 0 ? signers : undefined,
-            });
-            const receipt = {
-                transactionIndex,
-                transactionName: transaction.name,
-                signature: result.signature,
-                slot: result.slot,
-            };
-            receipts.push(receipt);
-            await options.onTransactionSuccess?.({
-                operation,
-                transaction,
-                transactionIndex,
-                receipt,
-            });
-        }
-        catch (cause) {
-            throw new OperationExecutionError({
-                operation,
-                failedTransaction: transaction,
-                failedTransactionIndex: transactionIndex,
-                completedReceipts: receipts,
-                cause,
-            });
-        }
-    }
-    if (operation.kind === 'flow') {
-        return {
-            kind: 'flow',
-            operationName: operation.name,
-            artifacts: operation.artifacts,
-            signatures: nonEmpty(receipts.map((receipt) => receipt.signature), `Operation '${operation.name}' signatures`),
-            transactions: nonEmpty(receipts, `Operation '${operation.name}' receipts`),
-        };
-    }
-    return {
-        kind: operation.kind,
-        operationName: operation.name,
-        artifacts: operation.artifacts,
-        signatures: [receipts[0].signature],
-        transaction: receipts[0],
-    };
-}
-function convertToJsonValue(value, ancestors) {
-    if (value === null || typeof value === 'string' || typeof value === 'boolean') {
-        return value;
-    }
-    if (typeof value === 'number') {
-        return Number.isFinite(value) ? value : null;
-    }
-    if (typeof value === 'bigint') {
-        return value.toString();
-    }
-    if (value === undefined
-        || typeof value === 'function'
-        || typeof value === 'symbol') {
-        return undefined;
-    }
-    if (typeof value !== 'object') {
-        return String(value);
-    }
-    if (ancestors.has(value)) {
-        throw new Error('Cannot convert a circular value to JSON');
-    }
-    ancestors.add(value);
-    try {
-        if (ArrayBuffer.isView(value)) {
-            return Array.from(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
-        }
-        if (value instanceof ArrayBuffer) {
-            return Array.from(new Uint8Array(value));
-        }
-        if (Array.isArray(value)) {
-            return value.map((entry) => convertToJsonValue(entry, ancestors) ?? null);
-        }
-        if (value instanceof Set) {
-            return [...value].map((entry) => convertToJsonValue(entry, ancestors) ?? null);
-        }
-        if (value instanceof Map) {
-            const result = {};
-            for (const [key, entry] of value) {
-                const converted = convertToJsonValue(entry, ancestors);
-                if (converted !== undefined) {
-                    result[String(key)] = converted;
-                }
-            }
-            return result;
-        }
-        const toJSON = value.toJSON;
-        if (typeof toJSON === 'function') {
-            return convertToJsonValue(toJSON.call(value), ancestors) ?? null;
-        }
-        const result = {};
-        for (const [key, entry] of Object.entries(value)) {
-            const converted = convertToJsonValue(entry, ancestors);
-            if (converted !== undefined) {
-                result[key] = converted;
-            }
-        }
-        return result;
-    }
-    finally {
-        ancestors.delete(value);
-    }
-}
-function toJsonValue(value) {
-    return convertToJsonValue(value, new Set()) ?? null;
-}
-function describePreparedOperation(operation) {
-    return {
-        kind: operation.kind,
-        name: operation.name,
-        artifacts: toJsonValue(operation.artifacts),
-        transactions: operation.plan.transactions.map((transaction) => ({
-            name: transaction.name,
-            requiredSignerAddresses: transaction.requiredSignerAddresses,
-            errors: transaction.errors,
-            instructions: transaction.instructions.map((instruction) => ({
-                programId: instruction.programId,
-                keys: instruction.keys,
-                data: Array.from(instruction.data),
-            })),
-        })),
-    };
-}
-function formatPreparedOperation(operation) {
-    const lines = [
-        `${operation.kind}: ${operation.name}`,
-        `Transactions: ${operation.plan.transactions.length}`,
-    ];
-    for (const [index, transaction] of operation.plan.transactions.entries()) {
-        lines.push(`  ${index + 1}. ${transaction.name} (${transaction.instructions.length} instruction${transaction.instructions.length === 1 ? '' : 's'})`);
-        if (transaction.requiredSignerAddresses.length > 0) {
-            lines.push(`    Signers: ${transaction.requiredSignerAddresses.join(', ')}`);
-        }
-    }
-    return lines.join('\n');
-}
-
-function mergeAttachedPrograms(stack, attachedPrograms) {
-    const merged = { ...(attachedPrograms ?? {}) };
-    for (const [name, definition] of Object.entries(stack.programs ?? {})) {
-        if (name in merged) {
-            console.warn(`Ignoring attached program '${name}' for stack '${stack.name}' because the stack already defines that key`);
-        }
-        merged[name] = definition;
-    }
-    return merged;
-}
-function normalizeProgramAccountWireKeys(value) {
-    if (Array.isArray(value)) {
-        return value.map(normalizeProgramAccountWireKeys);
-    }
-    if (!value || typeof value !== 'object') {
-        return value;
-    }
-    return Object.fromEntries(Object.entries(value).map(([key, nestedValue]) => [
-        key.replace(/[A-Z]/g, (letter, index) => `${index === 0 ? '' : '_'}${letter.toLowerCase()}`),
-        normalizeProgramAccountWireKeys(nestedValue),
-    ]));
-}
-function parseProgramAccountValue(definition, value) {
-    const schema = definition.schema;
-    if (!schema) {
-        return value;
-    }
-    const parsed = schema.safeParse(value);
-    if (parsed.success) {
-        return parsed.data;
-    }
-    const normalized = schema.safeParse(normalizeProgramAccountWireKeys(value));
-    if (normalized.success) {
-        return normalized.data;
-    }
-    throw new Error(`Program account read '${definition.account}' failed schema validation`);
-}
-function cloneStackWithPrograms(stack, programs) {
-    const cloned = Object.create(Object.getPrototypeOf(stack), Object.getOwnPropertyDescriptors(stack));
-    cloned.programs = programs;
-    return cloned;
-}
-function withPrograms(stack, attachedPrograms) {
-    return cloneStackWithPrograms(stack, mergeAttachedPrograms(stack, attachedPrograms));
-}
-let Arete$1 = class Arete {
-    constructor(url, httpBaseUrl, options) {
-        this.stack = options.stack;
-        this._wallet = options.wallet;
-        this.executionDefaults = options.execution;
-        this.httpBaseUrl = httpBaseUrl;
-        this.fetchImpl = options.fetch ?? this.resolveFetchImpl();
-        this.storage = new SortedStorageDecorator(options.storage ?? new MemoryAdapter());
-        this.processor = new FrameProcessor(this.storage, {
-            maxEntriesPerView: options.maxEntriesPerView,
-            flushIntervalMs: options.flushIntervalMs,
-            schemas: this.stack.schemas,
-            patchSchemas: this.stack.patchSchemas,
-        });
-        this.connection = new ConnectionManager({
-            websocketUrl: url,
-            reconnectIntervals: options.reconnectIntervals,
-            maxReconnectAttempts: options.maxReconnectAttempts,
-            auth: options.auth,
-        });
-        this.subscriptionRegistry = new SubscriptionRegistry(this.connection);
-        this.connection.onFrame((frame) => {
-            this.processor.handleFrame(frame);
-        });
-        this._views = createTypedViews(this.stack, this.storage, this.subscriptionRegistry);
-        this._queries = this.buildQueries();
-        this._chain = createChainClient(this.httpBaseUrl, this.authenticatedFetch.bind(this));
-        this._programs = this.buildPrograms();
-    }
-    resolveFetchImpl() {
-        if (typeof globalThis.fetch !== 'function') {
-            throw new AreteError('A fetch implementation is required for HTTP point reads (provide ConnectOptions.fetch or use an environment with global fetch)', 'INVALID_CONFIG');
-        }
-        return globalThis.fetch.bind(globalThis);
-    }
-    buildQueries() {
-        const queries = {};
-        for (const [name, definition] of Object.entries(this.stack.queries ?? {})) {
-            queries[name] = this.createQueryExecutor(definition);
-        }
-        return queries;
-    }
-    buildPrograms() {
-        const bases = {};
-        for (const [name, definition] of Object.entries(this.stack.programs ?? {})) {
-            const instructions = {};
-            for (const [instructionName, handler] of Object.entries(definition.rawInstructions ?? {})) {
-                instructions[instructionName] = this.createTypedInstruction(handler);
-            }
-            const accounts = {};
-            for (const [accountName, accountDefinition] of Object.entries(definition.accounts ?? {})) {
-                accounts[accountName] = this.createAccountReader(accountDefinition);
-            }
-            const queries = {};
-            for (const [queryName, queryDefinition] of Object.entries(definition.queries ?? {})) {
-                queries[queryName] = this.createQueryExecutor(queryDefinition);
-            }
-            bases[name] = {
-                name: definition.name,
-                programId: definition.programId,
-                schemas: definition.schemas,
-                pdas: definition.pdas ?? {},
-                accounts,
-                queries,
-                raw: instructions,
-                addresses: definition.addresses ?? {},
-                constants: definition.constants ?? {},
-                defaults: definition.defaults ?? {},
-                math: definition.math ?? {},
-            };
-        }
-        const programs = {};
-        const client = this;
-        for (const [name, definition] of Object.entries(this.stack.programs ?? {})) {
-            const base = bases[name];
-            const connectedProgram = {
-                ...base,
-                instructions: {},
-                transactions: {},
-                flows: {},
-            };
-            const runtime = getProgramRuntimeExtensions(definition);
-            const operations = runtime?.createOperations({
-                chain: this._chain,
-                get wallet() {
-                    return client._wallet;
-                },
-                program: connectedProgram,
-            });
-            connectedProgram.instructions = operations?.instructions ?? {};
-            connectedProgram.transactions = operations?.transactions ?? {};
-            connectedProgram.flows = operations?.flows ?? {};
-            programs[name] = connectedProgram;
-        }
-        return programs;
-    }
-    createTypedInstruction(handler) {
-        return {
-            build: (params, options) => buildInstruction(handler, params, this.withWallet(options)),
-        };
-    }
-    createAccountReader(definition) {
-        return {
-            fetch: async (address) => {
-                const result = await this.readJson(`${definition.path}/${encodeURIComponent(address)}`);
-                return result === null ? null : parseProgramAccountValue(definition, result);
-            },
-            fetchMany: async (addresses) => {
-                const result = await this.readJson(definition.path, {
-                    method: 'POST',
-                    body: { addresses },
-                });
-                return result.map((value) => value === null ? null : parseProgramAccountValue(definition, value));
-            },
-            exists: async (address) => {
-                const result = await this.readJson(`${definition.path}/${encodeURIComponent(address)}/exists`);
-                return result.exists;
-            },
-        };
-    }
-    createQueryExecutor(definition) {
-        return async (params) => {
-            const result = await this.readJson(definition.path, {
-                method: definition.method ?? 'POST',
-                body: params,
-            });
-            if (!definition.schema) {
-                return result;
-            }
-            const parsed = definition.schema.safeParse(result);
-            if (!parsed.success) {
-                throw new Error(`Query '${definition.name}' failed schema validation`);
-            }
-            return parsed.data;
-        };
-    }
-    async readJson(path, options) {
-        const response = await this.authenticatedFetch(this.resolveReadUrl(path), {
-            method: options?.method ?? 'GET',
-            headers: options?.body === undefined ? undefined : { 'content-type': 'application/json' },
-            body: options?.body === undefined ? undefined : JSON.stringify(options.body),
-        });
-        return parseReadResponse(response, path);
-    }
-    async authenticatedFetch(input, init) {
-        const attempt = async (forceRefresh = false) => {
-            const token = await this.connection.getHttpAuthToken(forceRefresh);
-            const headers = new Headers(init?.headers ?? undefined);
-            if (token) {
-                headers.set('authorization', `Bearer ${token}`);
-            }
-            return this.fetchImpl(input, {
-                ...init,
-                headers,
-            });
-        };
-        let response = await attempt(false);
-        if (!response.ok) {
-            const wireErrorCode = response.headers.get('X-Error-Code');
-            const errorCode = wireErrorCode ? parseErrorCode(wireErrorCode) : undefined;
-            if (errorCode && shouldRefreshToken(errorCode)) {
-                this.connection.clearHttpAuthToken();
-                response = await attempt(true);
-            }
-        }
-        return response;
-    }
-    resolveReadUrl(path) {
-        return `${this.httpBaseUrl.replace(/\/$/, '')}${path.startsWith('/') ? path : `/${path}`}`;
-    }
-    /** Merge the client's default wallet into call options (call options win). */
-    withWallet(options) {
-        const merged = { ...(options ?? {}) };
-        if (!merged.wallet && this._wallet) {
-            merged.wallet = this._wallet;
-        }
-        return merged;
-    }
-    static async connect(stack, options) {
-        const requestedUrl = options?.url ?? stack.endpoints.ws;
-        const autoReconnect = options?.autoReconnect !== false;
-        const httpOnly = options?.transport === 'http' || (!requestedUrl && !autoReconnect);
-        const url = httpOnly ? null : requestedUrl;
-        const httpUrl = options?.httpUrl
-            ?? stack.endpoints.http
-            ?? (requestedUrl ? deriveHttpEndpoint(requestedUrl) : undefined);
-        if (!httpOnly && !url) {
-            throw new AreteError('WebSocket URL is required (provide url option or define endpoints.ws in stack)', 'INVALID_CONFIG');
-        }
-        if (!httpUrl) {
-            throw new AreteError('HTTP endpoint is required for transport: "http" (provide httpUrl option or define endpoints.http in stack)', 'INVALID_CONFIG');
-        }
-        const attachedPrograms = options?.programs;
-        const effectiveStack = withPrograms(stack, attachedPrograms);
-        const internalOptions = {
-            stack: effectiveStack,
-            httpUrl,
-            storage: options?.storage,
-            maxEntriesPerView: options?.maxEntriesPerView,
-            flushIntervalMs: options?.flushIntervalMs,
-            autoReconnect: options?.autoReconnect,
-            reconnectIntervals: options?.reconnectIntervals,
-            maxReconnectAttempts: options?.maxReconnectAttempts,
-            validateFrames: options?.validateFrames,
-            auth: options?.auth,
-            wallet: options?.wallet,
-            fetch: options?.fetch,
-            execution: options?.execution,
-        };
-        const client = new Arete(url, httpUrl, internalOptions);
-        if (!httpOnly && autoReconnect) {
-            await client.connection.connect();
-        }
-        return applyConnectedStackExtensions(client, effectiveStack);
-    }
-    get views() {
-        return this._views;
-    }
-    get queries() {
-        return this._queries;
-    }
-    get programs() {
-        return this._programs;
-    }
-    get chain() {
-        return this._chain;
-    }
-    /** The default wallet adapter, if one was configured. */
-    get wallet() {
-        return this._wallet;
-    }
-    /** The connected wallet address, if a default wallet was configured. */
-    get publicKey() {
-        return this._wallet?.publicKey;
-    }
-    /**
-     * Set (or clear) the default wallet adapter used for instruction execution.
-     * Useful for connecting/disconnecting a wallet after the client is created.
-     */
-    setWallet(wallet) {
-        this._wallet = wallet;
-    }
-    /**
-     * Sign and send a batch of pre-built instructions as a single transaction.
-     *
-     * Build instructions with `client.programs.<program>.raw.<name>.build(params)`
-     * and compose them here. RPC/compilation/confirmation are owned by the adapter.
-     *
-     * On failure, the error is parsed against `options.errors` when given,
-     * otherwise against error metadata aggregated from all the stack's handlers
-     * (deduped by code, first-wins — if the stack bundles programs with
-     * overlapping error codes, pass `options.errors` or use the per-instruction
-     * call path for precise attribution).
-     */
-    async transaction(instructions, options) {
-        const wallet = options?.wallet ?? this._wallet;
-        if (!wallet) {
-            throw new Error('Wallet required to sign and send transaction');
-        }
-        try {
-            const sendOptions = {
-                ...(options?.send ?? {}),
-            };
-            if (options?.signers !== undefined) {
-                sendOptions.signers = options.signers;
-            }
-            const result = await wallet.signAndSend(instructions, sendOptions);
-            return { signature: result.signature, slot: result.slot };
-        }
-        catch (err) {
-            const programError = parseInstructionError(err, options?.errors ?? this.aggregateErrors());
-            if (programError) {
-                throw new InstructionError(`${programError.name} (${programError.code}): ${programError.message}`, programError, err);
-            }
-            throw err;
-        }
-    }
-    execute(prepared, options) {
-        const defaults = this.executionDefaults;
-        return executePreparedOperation(this, prepared, {
-            wallet: options?.wallet ?? defaults?.wallet,
-            send: defaults?.send || options?.send
-                ? { ...(defaults?.send ?? {}), ...(options?.send ?? {}) }
-                : undefined,
-            signers: options?.signers ?? defaults?.signers,
-            signerRegistry: options?.signerRegistry ?? defaults?.signerRegistry,
-            availableSignerAddresses: options?.availableSignerAddresses ?? defaults?.availableSignerAddresses,
-            onTransactionStart: options?.onTransactionStart ?? defaults?.onTransactionStart,
-            onTransactionSuccess: options?.onTransactionSuccess ?? defaults?.onTransactionSuccess,
-        });
-    }
-    /** Error metadata from every handler in the stack, deduped by code. */
-    aggregateErrors() {
-        if (!this._aggregatedErrors) {
-            const all = [];
-            const seen = new Set();
-            const collect = (handler) => {
-                for (const error of handler.errors ?? []) {
-                    if (!seen.has(error.code)) {
-                        seen.add(error.code);
-                        all.push(error);
-                    }
-                }
-            };
-            for (const program of Object.values(this.stack.programs ?? {})) {
-                for (const handler of Object.values(program.rawInstructions ?? {})) {
-                    collect(handler);
-                }
-            }
-            this._aggregatedErrors = all;
-        }
-        return this._aggregatedErrors;
-    }
-    get connectionState() {
-        return this.connection.getState();
-    }
-    get stackName() {
-        return this.stack.name;
-    }
-    get store() {
-        return this.storage;
-    }
-    onConnectionStateChange(callback) {
-        return this.connection.onStateChange(callback);
-    }
-    onFrame(callback) {
-        return this.connection.onFrame(callback);
-    }
-    onSocketIssue(callback) {
-        return this.connection.onSocketIssue(callback);
-    }
-    async connect() {
-        await this.connection.connect();
-    }
-    disconnect() {
-        this.subscriptionRegistry.clear();
-        this.connection.disconnect();
-    }
-    isConnected() {
-        return this.connection.isConnected();
-    }
-    clearStore() {
-        this.storage.clear();
-    }
-    getStore() {
-        return this.storage;
-    }
-    getConnection() {
-        return this.connection;
-    }
-    getSubscriptionRegistry() {
-        return this.subscriptionRegistry;
-    }
-};
-
-function createSignerRegistry(entries = []) {
-    const signers = new Map();
-    for (const [address, signer] of entries) {
-        if (!address) {
-            throw new Error('Signer registry addresses must not be empty');
-        }
-        signers.set(address, signer);
-    }
-    return {
-        register(address, signer) {
-            if (!address) {
-                throw new Error('Signer registry addresses must not be empty');
-            }
-            signers.set(address, signer);
-        },
-        unregister(address) {
-            return signers.delete(address);
-        },
-        get(address) {
-            return signers.get(address);
-        },
-        has(address) {
-            return signers.has(address);
-        },
-        addresses() {
-            return [...signers.keys()];
-        },
-        values() {
-            return [...signers.values()];
-        },
-        entries() {
-            return [...signers.entries()];
-        },
-        clear() {
-            signers.clear();
-        },
-    };
-}
-
-function resolveMemberConnectOptions(stack, member, options, forceHttpOnly) {
-    const transport = member?.transport ?? options?.transport ?? (forceHttpOnly ? 'http' : 'ws');
-    // Resolution order: per-member override → the stack's own endpoints →
-    // session-wide fallback endpoints.
-    const url = member?.url ?? (stack.endpoints.ws || options?.endpoints?.ws);
-    const httpUrl = member?.httpUrl ?? stack.endpoints.http ?? options?.endpoints?.http;
-    return {
-        url,
-        httpUrl,
-        transport,
-        auth: member?.auth ?? options?.auth,
-        storage: member?.storage,
-        autoReconnect: member?.autoReconnect,
-        wallet: options?.wallet,
-        fetch: options?.fetch,
-    };
-}
-function programAsStack(name, program) {
-    return {
-        name,
-        endpoints: { ws: '' },
-        views: {},
-        programs: { [name]: program },
-    };
-}
-async function createSession(definition, options) {
-    const stackEntries = Object.entries(definition.stacks ?? {});
-    const programEntries = Object.entries(definition.programs ?? {});
-    if (stackEntries.length === 0 && programEntries.length === 0) {
-        throw new AreteError('createSession requires at least one stack or program member', 'INVALID_CONFIG');
-    }
-    let wallet = options?.wallet;
-    const signerRegistry = options?.signerRegistry ?? createSignerRegistry();
-    const connectedStacks = await Promise.all(stackEntries.map(async ([key, stack]) => {
-        const memberOptions = options?.stacks?.[key];
-        const effectiveStack = withPrograms(stack, memberOptions?.programs);
-        const connectOptions = resolveMemberConnectOptions(effectiveStack, memberOptions, options, false);
-        const client = await Arete$1.connect(effectiveStack, connectOptions);
-        return [key, client];
-    }));
-    const connectedPrograms = await Promise.all(programEntries.map(async ([key, program]) => {
-        const syntheticStack = programAsStack(key, program);
-        const connectOptions = resolveMemberConnectOptions(syntheticStack, options?.programs?.[key], options, true);
-        const client = await Arete$1.connect(syntheticStack, connectOptions);
-        return [key, client];
-    }));
-    const memberClients = [
-        ...connectedStacks.map(([, client]) => client),
-        ...connectedPrograms.map(([, client]) => client),
-    ];
-    const executionHost = memberClients[0];
-    const stacks = Object.fromEntries(connectedStacks);
-    const explicitProgramKeys = new Set(connectedPrograms.map(([key]) => key));
-    const programOwners = new Map();
-    const connectedProgramEntries = connectedPrograms.map(([key, client]) => [
-        key,
-        client.programs[key],
-    ]);
-    const promotedPrograms = Object.fromEntries(connectedProgramEntries);
-    for (const [stackKey, client] of connectedStacks) {
-        for (const [programKey, program] of Object.entries(client.programs)) {
-            if (explicitProgramKeys.has(programKey)) {
-                continue;
-            }
-            const existingOwner = programOwners.get(programKey);
-            if (existingOwner) {
-                console.warn(`Program '${programKey}' is bundled by stacks '${existingOwner.stack}'` +
-                    ` (${existingOwner.programId ?? 'unknown program ID'}) and '${stackKey}'` +
-                    ` (${program.programId ?? 'unknown program ID'}); session.programs.${programKey}` +
-                    ` uses '${existingOwner.stack}' because it was connected first`);
-                continue;
-            }
-            promotedPrograms[programKey] = program;
-            programOwners.set(programKey, { stack: stackKey, programId: program.programId });
-        }
-    }
-    const programs = promotedPrograms;
-    const chain = options?.chain ?? (options?.endpoints?.http !== undefined
-        ? createChainClient(options.endpoints.http, (options?.fetch ?? globalThis.fetch?.bind(globalThis)))
-        : executionHost.chain);
-    const session = {
-        stacks,
-        programs,
-        get wallet() {
-            return wallet;
-        },
-        signerRegistry,
-        chain,
-        transaction(instructions, transactionOptions) {
-            const defaults = options?.execution;
-            const configuredSigners = transactionOptions?.signers ?? defaults?.signers;
-            const signers = [...new Set([...signerRegistry.values(), ...(configuredSigners ?? [])])];
-            return executionHost.transaction(instructions, {
-                wallet: transactionOptions?.wallet ?? defaults?.wallet,
-                send: defaults?.send || transactionOptions?.send
-                    ? { ...(defaults?.send ?? {}), ...(transactionOptions?.send ?? {}) }
-                    : undefined,
-                errors: transactionOptions?.errors,
-                signers: signers.length > 0 ? signers : undefined,
-            });
-        },
-        execute(prepared, executionOptions) {
-            const defaults = options?.execution;
-            const configuredSigners = executionOptions?.signers ?? defaults?.signers;
-            return executionHost.execute(prepared, {
-                wallet: executionOptions?.wallet ?? defaults?.wallet,
-                send: defaults?.send || executionOptions?.send
-                    ? { ...(defaults?.send ?? {}), ...(executionOptions?.send ?? {}) }
-                    : undefined,
-                signers: configuredSigners,
-                signerRegistry,
-                availableSignerAddresses: executionOptions?.availableSignerAddresses ?? defaults?.availableSignerAddresses,
-                onTransactionStart: executionOptions?.onTransactionStart ?? defaults?.onTransactionStart,
-                onTransactionSuccess: executionOptions?.onTransactionSuccess ?? defaults?.onTransactionSuccess,
-            });
-        },
-        setWallet(nextWallet) {
-            wallet = nextWallet;
-            for (const client of memberClients) {
-                client.setWallet(nextWallet);
-            }
-        },
-        close() {
-            for (const client of memberClients) {
-                client.disconnect();
-            }
-        },
-    };
-    return session;
-}
-
-function instructionOperation(prepare) {
-    return {
-        kind: 'instruction',
-        prepare: async (input) => prepare(input),
-    };
-}
-function transactionOperation(prepare) {
-    return {
-        kind: 'transaction',
-        prepare: async (input) => prepare(input),
-    };
-}
-function flowOperation(prepare) {
-    return {
-        kind: 'flow',
-        prepare: async (input) => prepare(input),
-    };
-}
-
-function chainAccountLoader(chain) {
-    return {
-        async getAccount(address) {
-            const account = await chain.account(address);
-            return account ? { data: account.data } : null;
-        },
-    };
-}
-
-const SPL_TOKEN_PROGRAM_ADDRESS = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA';
-const TOKEN_2022_PROGRAM_ADDRESS = 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb';
-const ASSOCIATED_TOKEN_PROGRAM_ADDRESS = 'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL';
-const SYSTEM_PROGRAM_ADDRESS = '11111111111111111111111111111111';
-async function resolveTokenProgramAddress(chain, mint, override) {
-    if (override) {
-        return override;
-    }
-    const mintAccount = await chain.mint(mint);
-    if (!mintAccount) {
-        throw new Error(`Mint account not found while resolving token program: ${mint}`);
-    }
-    if (mintAccount.ownerProgram !== SPL_TOKEN_PROGRAM_ADDRESS &&
-        mintAccount.ownerProgram !== TOKEN_2022_PROGRAM_ADDRESS) {
-        throw new Error(`Mint ${mint} is owned by unsupported token program ${mintAccount.ownerProgram}`);
-    }
-    return mintAccount.ownerProgram;
-}
-function deriveAssociatedTokenAccount(input) {
-    const [address] = findProgramAddressSync([
-        createPublicKeySeed(input.owner),
-        createPublicKeySeed(input.tokenProgram ?? SPL_TOKEN_PROGRAM_ADDRESS),
-        createPublicKeySeed(input.mint),
-    ], ASSOCIATED_TOKEN_PROGRAM_ADDRESS);
-    return address;
-}
-
-/** Convert a UI amount ("1.5") to raw base units using string math (no float precision loss). */
-function parseUiAmountToRaw(value, decimals) {
-    const trimmed = String(value).trim();
-    if (!/^\d+(?:\.\d+)?$/.test(trimmed)) {
-        throw new Error(`Invalid UI amount: ${value}`);
-    }
-    const [wholePart, fractionPart = ''] = trimmed.split('.');
-    if (fractionPart.length > decimals) {
-        const excess = fractionPart.slice(decimals);
-        if (/[1-9]/.test(excess)) {
-            throw new Error(`UI amount ${value} has more fractional digits than the mint's ${decimals} decimals`);
-        }
-    }
-    const fraction = fractionPart.padEnd(decimals, '0');
-    const whole = BigInt(wholePart || '0') * 10n ** BigInt(decimals);
-    const fractional = BigInt(fraction.slice(0, decimals) || '0');
-    return whole + fractional;
-}
-/** Format raw base units as a UI decimal string (inverse of {@link parseUiAmountToRaw}). */
-function formatRawToUi(raw, decimals) {
-    const value = BigInt(raw);
-    const negative = value < 0n;
-    const magnitude = negative ? -value : value;
-    const scale = 10n ** BigInt(decimals);
-    const whole = magnitude / scale;
-    const fraction = magnitude % scale;
-    const sign = negative ? '-' : '';
-    if (decimals === 0 || fraction === 0n) {
-        return `${sign}${whole.toString()}`;
-    }
-    const fractionText = fraction.toString().padStart(decimals, '0').replace(/0+$/, '');
-    return `${sign}${whole.toString()}.${fractionText}`;
-}
-/** Resolve an {@link AmountInput} to raw base units with known decimals. */
-function toRawAmount(amount, decimals) {
-    if (typeof amount === 'bigint') {
-        return amount;
-    }
-    if ('raw' in amount) {
-        return BigInt(amount.raw);
-    }
-    return parseUiAmountToRaw(amount.ui, decimals);
-}
-/** Fetch a mint's decimals via the chain read endpoint, throwing when unavailable. */
-async function getMintDecimals(chain, mint) {
-    const account = await chain.mint(mint);
-    if (!account || account.decimals == null) {
-        throw new Error(`Mint ${mint} is missing decimals on the configured read endpoint.`);
-    }
-    return account.decimals;
-}
-/**
- * Resolve an {@link AmountInput} to raw base units, fetching the mint's
- * decimals only when they are unknown and actually needed (a bare bigint or
- * `{raw}` input with explicit `decimals` never touches the network).
- */
-async function resolveAmount(chain, input) {
-    const needsDecimalsForParse = typeof input.amount !== 'bigint' && 'ui' in input.amount;
-    if (!needsDecimalsForParse) {
-        const raw = typeof input.amount === 'bigint'
-            ? input.amount
-            : BigInt(input.amount.raw);
-        const decimals = input.decimals ?? await getMintDecimals(chain, input.mint);
-        return { raw, decimals };
-    }
-    const decimals = input.decimals ?? await getMintDecimals(chain, input.mint);
-    return { raw: toRawAmount(input.amount, decimals), decimals };
-}
-/**
- * Resolve an {@link AmountInput} to raw base units without forcing a decimals
- * fetch when the input is already expressed in raw units.
- */
-async function resolveAmountToRaw(chain, input) {
-    if (typeof input.amount === 'bigint') {
-        return input.amount;
-    }
-    if ('raw' in input.amount) {
-        return BigInt(input.amount.raw);
-    }
-    const decimals = input.decimals ?? await getMintDecimals(chain, input.mint);
-    return toRawAmount(input.amount, decimals);
-}
-/** Resolve a named set of {@link AmountInput} values to raw base units. */
-async function resolveAmountsToRaw(chain, inputs) {
-    const entries = await Promise.all(Object.entries(inputs).map(async ([name, input]) => {
-        const raw = await resolveAmountToRaw(chain, input);
-        return [name, raw];
-    }));
-    return Object.fromEntries(entries);
-}
-
-const Arete = Object.assign(Arete$1, { session: createSession });
-
-exports.ASSOCIATED_TOKEN_PROGRAM_ADDRESS = ASSOCIATED_TOKEN_PROGRAM_ADDRESS;
-exports.Arete = Arete;
-exports.AreteError = AreteError;
-exports.ConnectionManager = ConnectionManager;
-exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
-exports.DEFAULT_MAX_ENTRIES_PER_VIEW = DEFAULT_MAX_ENTRIES_PER_VIEW;
-exports.FrameProcessor = FrameProcessor;
-exports.InstructionError = InstructionError;
-exports.MemoryAdapter = MemoryAdapter;
-exports.OperationExecutionError = OperationExecutionError;
-exports.PROGRAM_OPERATION_EXTENSIONS = PROGRAM_OPERATION_EXTENSIONS;
-exports.ReadRequestError = ReadRequestError;
-exports.SPL_TOKEN_PROGRAM_ADDRESS = SPL_TOKEN_PROGRAM_ADDRESS;
-exports.STACK_RUNTIME_EXTENSIONS = STACK_RUNTIME_EXTENSIONS;
-exports.SYSTEM_PROGRAM_ADDRESS = SYSTEM_PROGRAM_ADDRESS;
-exports.SubscriptionRegistry = SubscriptionRegistry;
-exports.TOKEN_2022_PROGRAM_ADDRESS = TOKEN_2022_PROGRAM_ADDRESS;
-exports.account = account;
-exports.appendFlowTransactions = appendFlowTransactions;
-exports.appendTransactionInstructions = appendTransactionInstructions;
-exports.applyConnectedStackExtensions = applyConnectedStackExtensions;
-exports.arg = arg;
-exports.buildInstruction = buildInstruction;
-exports.bytes = bytes;
-exports.chainAccountLoader = chainAccountLoader;
-exports.createChainClient = createChainClient;
-exports.createEntityStream = createEntityStream;
-exports.createInstructionExecutor = createInstructionExecutor;
-exports.createInstructionHandler = createInstructionHandler;
-exports.createPreparedFlow = createPreparedFlow;
-exports.createPreparedInstruction = createPreparedInstruction;
-exports.createPreparedTransaction = createPreparedTransaction;
-exports.createPreparedTransactionBody = createPreparedTransactionBody;
-exports.createProgramPdas = createProgramPdas;
-exports.createPublicKeySeed = createPublicKeySeed;
-exports.createRichUpdateStream = createRichUpdateStream;
-exports.createSeed = createSeed;
-exports.createSession = createSession;
-exports.createSignerRegistry = createSignerRegistry;
-exports.createTypedListView = createTypedListView;
-exports.createTypedStateView = createTypedStateView;
-exports.createTypedViews = createTypedViews;
-exports.createUpdateStream = createUpdateStream;
-exports.decodeBase58 = decodeBase58;
-exports.defineProgramExtensions = defineProgramExtensions;
-exports.defineStackExtensions = defineStackExtensions;
-exports.deriveAssociatedTokenAccount = deriveAssociatedTokenAccount;
-exports.deriveHttpEndpoint = deriveHttpEndpoint;
-exports.derivePda = findProgramAddress;
-exports.describePreparedOperation = describePreparedOperation;
-exports.encodeBase58 = encodeBase58;
-exports.executeInstruction = executeInstruction;
-exports.executePreparedOperation = executePreparedOperation;
-exports.extendProgram = extendProgram;
-exports.extendPrograms = extendPrograms;
-exports.extendStack = extendStack;
-exports.findProgramAddress = findProgramAddress;
-exports.findProgramAddressSync = findProgramAddressSync;
-exports.flowOperation = flowOperation;
-exports.formatPreparedOperation = formatPreparedOperation;
-exports.formatProgramError = formatProgramError;
-exports.formatRawToUi = formatRawToUi;
-exports.getMintDecimals = getMintDecimals;
-exports.getProgramRuntimeExtensions = getProgramRuntimeExtensions;
-exports.getStackRuntimeExtensions = getStackRuntimeExtensions;
-exports.instructionOperation = instructionOperation;
-exports.isEntityFrame = isEntityFrame;
-exports.isSnapshotFrame = isSnapshotFrame;
-exports.isSubscribedFrame = isSubscribedFrame;
-exports.isValidFrame = isValidFrame;
-exports.literal = literal;
-exports.parseFrame = parseFrame;
-exports.parseFrameFromBlob = parseFrameFromBlob;
-exports.parseInstructionError = parseInstructionError;
-exports.parseUiAmountToRaw = parseUiAmountToRaw;
-exports.pda = pda;
-exports.prependFlowTransactionInstructions = prependFlowTransactionInstructions;
-exports.prependTransactionInstructions = prependTransactionInstructions;
-exports.programAccountRead = programAccountRead;
-exports.programQuery = programQuery;
-exports.resolveAccounts = resolveAccounts;
-exports.resolveAmount = resolveAmount;
-exports.resolveAmountToRaw = resolveAmountToRaw;
-exports.resolveAmountsToRaw = resolveAmountsToRaw;
-exports.resolveTokenProgramAddress = resolveTokenProgramAddress;
-exports.serializeInstructionData = serializeInstructionData;
-exports.stackQuery = stackQuery;
-exports.toJsonValue = toJsonValue;
-exports.toRawAmount = toRawAmount;
-exports.transactionOperation = transactionOperation;
-exports.validateAccountResolution = validateAccountResolution;
-exports.withPrograms = withPrograms;
-//# sourceMappingURL=index.js.map