@usearete/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,3074 @@
+'use strict';
+
+var pako = require('pako');
+
+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;
+    }
+}
+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;
+        if (!config.websocketUrl) {
+            throw new AreteError('websocketUrl is required', 'INVALID_CONFIG');
+        }
+        this.websocketUrl = config.websocketUrl;
+        this.hostedAreteUrl = isHostedAreteWebsocketUrl(config.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) {
+        if (this.authConfig?.tokenTransport === 'bearer') {
+            return this.websocketUrl;
+        }
+        if (!token) {
+            return this.websocketUrl;
+        }
+        const separator = this.websocketUrl.includes('?') ? '&' : '?';
+        return `${this.websocketUrl}${separator}${DEFAULT_QUERY_PARAMETER}=${encodeURIComponent(token)}`;
+    }
+    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;
+    }
+    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() {
+        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) {
+        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;
+        }
+    }
+}
+
+function isObject$1(item) {
+    return item !== null && typeof item === 'object' && !Array.isArray(item);
+}
+function deepMergeWithAppend$1(target, source, appendPaths, currentPath = '') {
+    if (!isObject$1(target) || !isObject$1(source)) {
+        return source;
+    }
+    const result = { ...target };
+    for (const key in source) {
+        const sourceValue = source[key];
+        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$1(sourceValue) && isObject$1(targetValue)) {
+            result[key] = deepMergeWithAppend$1(targetValue, sourceValue, appendPaths, fieldPath);
+        }
+        else {
+            result[key] = sourceValue;
+        }
+    }
+    return result;
+}
+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;
+    }
+    getSchema(viewPath) {
+        const schemas = 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;
+    }
+    validateEntity(viewPath, data) {
+        const schema = this.getSchema(viewPath);
+        if (!schema)
+            return true;
+        const result = schema.safeParse(data);
+        if (!result.success) {
+            console.warn('[Arete] Frame validation failed:', {
+                view: viewPath,
+                error: result.error,
+            });
+            return false;
+        }
+        return true;
+    }
+    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: frame.sort });
+        }
+    }
+    handleSnapshotFrame(frame) {
+        this.handleSnapshotFrameWithoutEnforce(frame);
+        this.enforceMaxEntries(frame.entity);
+    }
+    handleSnapshotFrameWithoutEnforce(frame) {
+        const viewPath = frame.entity;
+        for (const entity of frame.data) {
+            if (!this.validateEntity(viewPath, entity.data)) {
+                continue;
+            }
+            const previousValue = this.storage.get(viewPath, entity.key);
+            this.storage.set(viewPath, entity.key, entity.data);
+            this.storage.notifyUpdate(viewPath, entity.key, {
+                type: 'upsert',
+                key: entity.key,
+                data: entity.data,
+            });
+            this.emitRichUpdate(viewPath, entity.key, previousValue, entity.data, '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':
+                if (!this.validateEntity(viewPath, frame.data)) {
+                    break;
+                }
+                this.storage.set(viewPath, frame.key, frame.data);
+                this.storage.notifyUpdate(viewPath, frame.key, {
+                    type: 'upsert',
+                    key: frame.key,
+                    data: frame.data,
+                });
+                this.emitRichUpdate(viewPath, frame.key, previousValue, frame.data, frame.op);
+                break;
+            case 'patch': {
+                const existing = this.storage.get(viewPath, frame.key);
+                const appendPaths = frame.append ?? [];
+                const merged = existing
+                    ? deepMergeWithAppend$1(existing, frame.data, appendPaths)
+                    : frame.data;
+                if (!this.validateEntity(viewPath, merged)) {
+                    break;
+                }
+                this.storage.set(viewPath, frame.key, merged);
+                this.storage.notifyUpdate(viewPath, frame.key, {
+                    type: 'patch',
+                    key: frame.key,
+                    data: frame.data,
+                });
+                this.emitRichUpdate(viewPath, frame.key, previousValue, merged, 'patch', frame.data);
+                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);
+        }
+    }
+}
+
+let ViewData$1 = 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$1();
+            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$1(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$1(a, b) {
+    if (a === b)
+        return 0;
+    if (a === undefined || a === null)
+        return -1;
+    if (b === undefined || b === null)
+        return 1;
+    if (typeof a === 'number' && typeof b === 'number') {
+        return a - b;
+    }
+    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$1(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$1(midEntity, sortConfig.field);
+            let cmp = compareSortValues$1(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$1(a[1], sortConfig.field);
+            const bValue = getNestedValue$1(b[1], sortConfig.field);
+            let cmp = compareSortValues$1(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;
+}
+
+/**
+ * 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);
+    }
+    const bytes = [0];
+    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 '';
+    }
+    const digits = [0];
+    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 hash function (synchronous, Node.js).
+ */
+function sha256Sync(data) {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const { createHash } = require('crypto');
+    return new Uint8Array(createHash('sha256').update(Buffer.from(data)).digest());
+}
+/**
+ * SHA-256 hash function (async, works in browser and Node.js).
+ */
+async function sha256Async(data) {
+    if (typeof globalThis !== 'undefined' && globalThis.crypto && globalThis.crypto.subtle) {
+        // Create a copy of the data to ensure we have an ArrayBuffer
+        const copy = new Uint8Array(data);
+        const hashBuffer = await globalThis.crypto.subtle.digest('SHA-256', copy);
+        return new Uint8Array(hashBuffer);
+    }
+    return sha256Sync(data);
+}
+/**
+ * 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);
+        {
+            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);
+        {
+            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;
+}
+
+/**
+ * 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)
+    const orderedAccounts = [];
+    for (const meta of accountMetas) {
+        const resolved = resolvedMap[meta.name];
+        if (resolved) {
+            orderedAccounts.push(resolved);
+        }
+    }
+    return {
+        accounts: orderedAccounts,
+        missingUserAccounts: missing,
+    };
+}
+function resolveSingleAccount(meta, args, options, resolvedMap) {
+    switch (meta.category) {
+        case 'signer':
+            return resolveSignerAccount(meta, options.wallet);
+        case 'known':
+            return resolveKnownAccount(meta);
+        case 'pda':
+            return resolvePdaAccount(meta, args, resolvedMap, options.programId);
+        case 'userProvided':
+            return resolveUserProvidedAccount(meta, options.accounts);
+        default:
+            return null;
+    }
+}
+function resolveSignerAccount(meta, wallet) {
+    if (!wallet) {
+        return null;
+    }
+    return {
+        name: meta.name,
+        address: wallet.publicKey,
+        isSigner: true,
+        isWritable: meta.isWritable,
+    };
+}
+function resolveKnownAccount(meta) {
+    if (!meta.knownAddress) {
+        return null;
+    }
+    return {
+        name: meta.name,
+        address: meta.knownAddress,
+        isSigner: meta.isSigner,
+        isWritable: meta.isWritable,
+    };
+}
+function resolvePdaAccount(meta, args, resolvedMap, programId) {
+    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 'argRef': {
+                const argValue = args[seed.argName];
+                if (argValue === undefined) {
+                    throw new Error('PDA seed references missing argument: ' + seed.argName +
+                        ' (for account "' + meta.name + '")');
+                }
+                seeds.push(createSeed(argValue));
+                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];
+        const serialized = serializeValue(value, field.type);
+        buffers.push(serialized);
+    }
+    return Buffer.concat(buffers);
+}
+function serializeValue(value, type) {
+    if (typeof type === 'string') {
+        return serializePrimitive(value, type);
+    }
+    if ('vec' in type) {
+        return serializeVec(value, type.vec);
+    }
+    if ('option' in type) {
+        return serializeOption(value, type.option);
+    }
+    if ('array' in type) {
+        return serializeArray(value, type.array[0], type.array[1]);
+    }
+    throw new Error(`Unknown type: ${JSON.stringify(type)}`);
+}
+function serializePrimitive(value, type) {
+    switch (type) {
+        case 'u8':
+            return Buffer.from([value]);
+        case 'u16':
+            const u16 = Buffer.alloc(2);
+            u16.writeUInt16LE(value, 0);
+            return u16;
+        case 'u32':
+            const u32 = Buffer.alloc(4);
+            u32.writeUInt32LE(value, 0);
+            return u32;
+        case 'u64':
+            const u64 = Buffer.alloc(8);
+            u64.writeBigUInt64LE(BigInt(value), 0);
+            return u64;
+        case 'u128':
+            // u128 is 16 bytes, little-endian
+            const u128 = Buffer.alloc(16);
+            const bigU128 = BigInt(value);
+            u128.writeBigUInt64LE(bigU128 & BigInt('0xFFFFFFFFFFFFFFFF'), 0);
+            u128.writeBigUInt64LE(bigU128 >> BigInt(64), 8);
+            return u128;
+        case 'i8':
+            return Buffer.from([value]);
+        case 'i16':
+            const i16 = Buffer.alloc(2);
+            i16.writeInt16LE(value, 0);
+            return i16;
+        case 'i32':
+            const i32 = Buffer.alloc(4);
+            i32.writeInt32LE(value, 0);
+            return i32;
+        case 'i64':
+            const i64 = Buffer.alloc(8);
+            i64.writeBigInt64LE(BigInt(value), 0);
+            return i64;
+        case 'i128':
+            const i128 = Buffer.alloc(16);
+            const bigI128 = BigInt(value);
+            i128.writeBigInt64LE(bigI128 & BigInt('0xFFFFFFFFFFFFFFFF'), 0);
+            i128.writeBigInt64LE(bigI128 >> BigInt(64), 8);
+            return i128;
+        case 'bool':
+            return Buffer.from([value ? 1 : 0]);
+        case 'string':
+            const str = value;
+            const strBytes = Buffer.from(str, 'utf-8');
+            const strLen = Buffer.alloc(4);
+            strLen.writeUInt32LE(strBytes.length, 0);
+            return Buffer.concat([strLen, strBytes]);
+        case 'pubkey':
+            // Public key is 32 bytes
+            // In production, decode base58 to 32 bytes
+            return Buffer.alloc(32, 0);
+        default:
+            throw new Error(`Unknown primitive type: ${type}`);
+    }
+}
+function serializeVec(values, elementType) {
+    const len = Buffer.alloc(4);
+    len.writeUInt32LE(values.length, 0);
+    const elementBuffers = values.map(v => serializeValue(v, elementType));
+    return Buffer.concat([len, ...elementBuffers]);
+}
+function serializeOption(value, innerType) {
+    if (value === null || value === undefined) {
+        return Buffer.from([0]); // None
+    }
+    const inner = serializeValue(value, innerType);
+    return Buffer.concat([Buffer.from([1]), inner]); // Some
+}
+function serializeArray(values, elementType, length) {
+    if (values.length !== length) {
+        throw new Error(`Array length mismatch: expected ${length}, got ${values.length}`);
+    }
+    const elementBuffers = values.map(v => serializeValue(v, elementType));
+    return Buffer.concat(elementBuffers);
+}
+
+/**
+ * Waits for transaction confirmation.
+ *
+ * @param signature - Transaction signature
+ * @param level - Desired confirmation level
+ * @param timeout - Maximum wait time in milliseconds
+ * @returns Confirmation result
+ */
+async function waitForConfirmation(signature, level = 'confirmed', timeout = 60000) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+        const status = await checkTransactionStatus();
+        if (status.err) {
+            throw new Error(`Transaction failed: ${JSON.stringify(status.err)}`);
+        }
+        if (isConfirmationLevelSufficient(status.confirmations, level)) {
+            return {
+                level,
+                slot: status.slot,
+            };
+        }
+        await sleep(1000);
+    }
+    throw new Error(`Transaction confirmation timeout after ${timeout}ms`);
+}
+async function checkTransactionStatus(_signature) {
+    // In production, query the Solana RPC
+    return {
+        err: null,
+        confirmations: 32,
+        slot: 123456789,
+    };
+}
+function isConfirmationLevelSufficient(confirmations, level) {
+    if (confirmations === null) {
+        return false;
+    }
+    switch (level) {
+        case 'processed':
+            return confirmations >= 0;
+        case 'confirmed':
+            return confirmations >= 1;
+        case 'finalized':
+            return confirmations >= 32;
+        default:
+            return false;
+    }
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Parses and handles instruction errors.
+ */
+/**
+ * Parses an error returned from a Solana transaction.
+ *
+ * @param error - The error from the transaction
+ * @param errorMetadata - Error definitions from the IDL
+ * @returns Parsed program error or null if not a program error
+ */
+function parseInstructionError(error, errorMetadata) {
+    if (!error) {
+        return null;
+    }
+    const errorCode = extractErrorCode(error);
+    if (errorCode === null) {
+        return null;
+    }
+    const metadata = errorMetadata.find(e => e.code === errorCode);
+    if (metadata) {
+        return {
+            code: metadata.code,
+            name: metadata.name,
+            message: metadata.msg,
+        };
+    }
+    return {
+        code: errorCode,
+        name: `CustomError${errorCode}`,
+        message: `Unknown error with code ${errorCode}`,
+    };
+}
+function extractErrorCode(error) {
+    if (typeof error !== 'object' || error === null) {
+        return null;
+    }
+    const errorObj = error;
+    // Check for InstructionError format
+    if (errorObj.InstructionError) {
+        const instructionError = errorObj.InstructionError;
+        if (instructionError[1]?.Custom !== undefined) {
+            return instructionError[1].Custom;
+        }
+    }
+    // Check for direct code
+    if (typeof errorObj.code === 'number') {
+        return errorObj.code;
+    }
+    return null;
+}
+/**
+ * Formats an error for display.
+ *
+ * @param error - The program error
+ * @returns Human-readable error message
+ */
+function formatProgramError(error) {
+    return `${error.name} (${error.code}): ${error.message}`;
+}
+
+/**
+ * Converts resolved account array to a map for the builder.
+ */
+function toResolvedAccountsMap(accounts) {
+    const map = {};
+    for (const account of accounts) {
+        map[account.name] = account.address;
+    }
+    return map;
+}
+/**
+ * Executes an instruction handler with the given arguments and options.
+ *
+ * This is the main function for executing Solana instructions. It handles:
+ * 1. Account resolution (signer, PDA, user-provided)
+ * 2. Calling the generated build() function
+ * 3. Transaction signing and sending
+ * 4. Confirmation waiting
+ *
+ * @param handler - Instruction handler from generated SDK
+ * @param args - Instruction arguments
+ * @param options - Execution options
+ * @returns Execution result with signature
+ */
+async function executeInstruction(handler, args, options = {}) {
+    // Step 1: Resolve accounts using handler's account metadata
+    const resolutionOptions = {
+        accounts: options.accounts,
+        wallet: options.wallet,
+        programId: handler.programId, // Pass programId for PDA derivation
+    };
+    const resolution = resolveAccounts(handler.accounts, args, resolutionOptions);
+    validateAccountResolution(resolution);
+    // Step 2: Call generated build() function
+    const resolvedAccountsMap = toResolvedAccountsMap(resolution.accounts);
+    const instruction = handler.build(args, resolvedAccountsMap);
+    // Step 3: Build transaction from the built instruction
+    const transaction = buildTransaction(instruction);
+    // Step 4: Sign and send
+    if (!options.wallet) {
+        throw new Error('Wallet required to sign transaction');
+    }
+    const signature = await options.wallet.signAndSend(transaction);
+    // Step 5: Wait for confirmation
+    const confirmationLevel = options.confirmationLevel ?? 'confirmed';
+    const timeout = options.timeout ?? 60000;
+    const confirmation = await waitForConfirmation(signature, confirmationLevel, timeout);
+    return {
+        signature,
+        confirmationLevel: confirmation.level,
+        slot: confirmation.slot,
+    };
+}
+/**
+ * Creates a transaction object from a built instruction.
+ *
+ * @param instruction - Built instruction from handler
+ * @returns Transaction object ready for signing
+ */
+function buildTransaction(instruction) {
+    // This returns a framework-agnostic transaction representation.
+    // The wallet adapter is responsible for converting this to the
+    // appropriate format (@solana/web3.js Transaction, etc.)
+    return {
+        instructions: [{
+                programId: instruction.programId,
+                keys: instruction.keys,
+                data: Array.from(instruction.data),
+            }],
+    };
+}
+/**
+ * Creates an instruction executor bound to a specific wallet.
+ *
+ * @param wallet - Wallet adapter
+ * @returns Bound executor function
+ */
+function createInstructionExecutor(wallet) {
+    return {
+        execute: async (handler, args, options) => {
+            return executeInstruction(handler, args, {
+                ...options,
+                wallet,
+            });
+        },
+    };
+}
+
+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 = context.args?.[seed.argName];
+                if (value === undefined) {
+                    throw new Error(`Missing arg for PDA seed: ${seed.argName}`);
+                }
+                return serializeArgForSeed(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 serializeArgForSeed(value, argType) {
+    if (value instanceof Uint8Array) {
+        return value;
+    }
+    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') {
+        const size = getArgSize(argType);
+        return serializeNumber(value, size);
+    }
+    throw new Error(`Cannot serialize value for PDA seed: ${typeof value}`);
+}
+function getArgSize(argType) {
+    if (!argType)
+        return 8;
+    const match = argType.match(/^[ui](\d+)$/);
+    if (match && match[1]) {
+        return parseInt(match[1], 10) / 8;
+    }
+    if (argType === 'pubkey')
+        return 32;
+    return 8;
+}
+function serializeNumber(value, size) {
+    const buffer = new Uint8Array(size);
+    let n = typeof value === 'bigint' ? value : BigInt(value);
+    for (let i = 0; i < size; i++) {
+        buffer[i] = Number(n & BigInt(0xff));
+        n >>= BigInt(8);
+    }
+    return buffer;
+}
+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;
+}
+
+class Arete {
+    constructor(url, options) {
+        this.stack = options.stack;
+        this.storage = new SortedStorageDecorator(options.storage ?? new MemoryAdapter());
+        this.processor = new FrameProcessor(this.storage, {
+            maxEntriesPerView: options.maxEntriesPerView,
+            flushIntervalMs: options.flushIntervalMs,
+            schemas: options.validateFrames ? this.stack.schemas : undefined,
+        });
+        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._instructions = this.buildInstructions();
+    }
+    buildInstructions() {
+        const instructions = {};
+        if (this.stack.instructions) {
+            for (const [name, handler] of Object.entries(this.stack.instructions)) {
+                instructions[name] = (args, options) => {
+                    return executeInstruction(handler, args, options);
+                };
+            }
+        }
+        return instructions;
+    }
+    static async connect(stack, options) {
+        const url = options?.url ?? stack.url;
+        if (!url) {
+            throw new AreteError('URL is required (provide url option or define url in stack)', 'INVALID_CONFIG');
+        }
+        const internalOptions = {
+            stack,
+            storage: options?.storage,
+            maxEntriesPerView: options?.maxEntriesPerView,
+            flushIntervalMs: options?.flushIntervalMs,
+            autoReconnect: options?.autoReconnect,
+            reconnectIntervals: options?.reconnectIntervals,
+            maxReconnectAttempts: options?.maxReconnectAttempts,
+            validateFrames: options?.validateFrames,
+            auth: options?.auth,
+        };
+        const client = new Arete(url, internalOptions);
+        if (options?.autoReconnect !== false) {
+            await client.connection.connect();
+        }
+        return client;
+    }
+    get views() {
+        return this._views;
+    }
+    get instructions() {
+        return this._instructions;
+    }
+    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 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 === 'number' && typeof b === 'number') {
+        return a - b;
+    }
+    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 ViewData {
+    constructor(sortConfig) {
+        this.entities = new Map();
+        this.accessOrder = [];
+        this.sortedKeys = [];
+        this.sortConfig = sortConfig;
+    }
+    get(key) {
+        return this.entities.get(key);
+    }
+    set(key, value) {
+        const isNew = !this.entities.has(key);
+        this.entities.set(key, value);
+        if (this.sortConfig) {
+            this.updateSortedPosition(key, value, isNew);
+        }
+        else {
+            if (isNew) {
+                this.accessOrder.push(key);
+            }
+            else {
+                this.touch(key);
+            }
+        }
+    }
+    updateSortedPosition(key, value, isNew) {
+        if (!isNew) {
+            const existingIdx = this.sortedKeys.indexOf(key);
+            if (existingIdx !== -1) {
+                this.sortedKeys.splice(existingIdx, 1);
+            }
+        }
+        const sortValue = getNestedValue(value, this.sortConfig.field);
+        const isDesc = this.sortConfig.order === 'desc';
+        let insertIdx = this.binarySearchInsertPosition(sortValue, key, isDesc);
+        this.sortedKeys.splice(insertIdx, 0, key);
+    }
+    binarySearchInsertPosition(sortValue, key, isDesc) {
+        let low = 0;
+        let high = this.sortedKeys.length;
+        while (low < high) {
+            const mid = Math.floor((low + high) / 2);
+            const midKey = this.sortedKeys[mid];
+            if (midKey === undefined)
+                break;
+            const midEntity = this.entities.get(midKey);
+            const midValue = getNestedValue(midEntity, this.sortConfig.field);
+            let cmp = compareSortValues(sortValue, midValue);
+            if (isDesc)
+                cmp = -cmp;
+            if (cmp === 0) {
+                cmp = key.localeCompare(midKey);
+            }
+            if (cmp < 0) {
+                high = mid;
+            }
+            else {
+                low = mid + 1;
+            }
+        }
+        return low;
+    }
+    delete(key) {
+        if (this.sortConfig) {
+            const idx = this.sortedKeys.indexOf(key);
+            if (idx !== -1) {
+                this.sortedKeys.splice(idx, 1);
+            }
+        }
+        else {
+            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() {
+        if (this.sortConfig) {
+            return this.sortedKeys.map(k => this.entities.get(k));
+        }
+        return Array.from(this.entities.values());
+    }
+    keys() {
+        if (this.sortConfig) {
+            return [...this.sortedKeys];
+        }
+        return Array.from(this.entities.keys());
+    }
+    get size() {
+        return this.entities.size;
+    }
+    touch(key) {
+        if (this.sortConfig)
+            return;
+        const idx = this.accessOrder.indexOf(key);
+        if (idx !== -1) {
+            this.accessOrder.splice(idx, 1);
+            this.accessOrder.push(key);
+        }
+    }
+    evictOldest() {
+        if (this.sortConfig) {
+            const oldest = this.sortedKeys.pop();
+            if (oldest !== undefined) {
+                this.entities.delete(oldest);
+            }
+            return oldest;
+        }
+        const oldest = this.accessOrder.shift();
+        if (oldest !== undefined) {
+            this.entities.delete(oldest);
+        }
+        return oldest;
+    }
+    setSortConfig(config) {
+        if (this.sortConfig)
+            return;
+        this.sortConfig = config;
+        this.rebuildSortedKeys();
+    }
+    rebuildSortedKeys() {
+        if (!this.sortConfig)
+            return;
+        const entries = Array.from(this.entities.entries());
+        const isDesc = this.sortConfig.order === 'desc';
+        entries.sort((a, b) => {
+            const aValue = getNestedValue(a[1], this.sortConfig.field);
+            const bValue = getNestedValue(b[1], this.sortConfig.field);
+            let cmp = compareSortValues(aValue, bValue);
+            if (isDesc)
+                cmp = -cmp;
+            if (cmp === 0) {
+                cmp = a[0].localeCompare(b[0]);
+            }
+            return cmp;
+        });
+        this.sortedKeys = entries.map(([k]) => k);
+        this.accessOrder = [];
+    }
+    getSortConfig() {
+        return this.sortConfig;
+    }
+}
+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];
+        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;
+}
+class EntityStore {
+    constructor(config = {}) {
+        this.views = new Map();
+        this.viewConfigs = new Map();
+        this.updateCallbacks = new Set();
+        this.richUpdateCallbacks = new Set();
+        this.maxEntriesPerView = config.maxEntriesPerView === undefined
+            ? DEFAULT_MAX_ENTRIES_PER_VIEW
+            : config.maxEntriesPerView;
+    }
+    enforceMaxEntries(viewData) {
+        if (this.maxEntriesPerView === null)
+            return;
+        while (viewData.size > this.maxEntriesPerView) {
+            viewData.evictOldest();
+        }
+    }
+    handleFrame(frame) {
+        if (isSubscribedFrame(frame)) {
+            this.handleSubscribedFrame(frame);
+            return;
+        }
+        if (isSnapshotFrame(frame)) {
+            this.handleSnapshotFrame(frame);
+            return;
+        }
+        this.handleEntityFrame(frame);
+    }
+    handleSubscribedFrame(frame) {
+        const viewPath = frame.view;
+        const config = {};
+        if (frame.sort) {
+            config.sort = frame.sort;
+        }
+        this.viewConfigs.set(viewPath, config);
+        const existingView = this.views.get(viewPath);
+        if (existingView && frame.sort) {
+            existingView.setSortConfig(frame.sort);
+        }
+    }
+    handleSnapshotFrame(frame) {
+        const viewPath = frame.entity;
+        let viewData = this.views.get(viewPath);
+        const viewConfig = this.viewConfigs.get(viewPath);
+        if (!viewData) {
+            viewData = new ViewData(viewConfig?.sort);
+            this.views.set(viewPath, viewData);
+        }
+        for (const entity of frame.data) {
+            const previousValue = viewData.get(entity.key);
+            viewData.set(entity.key, entity.data);
+            this.notifyUpdate(viewPath, entity.key, {
+                type: 'upsert',
+                key: entity.key,
+                data: entity.data,
+            });
+            this.notifyRichUpdate(viewPath, entity.key, previousValue, entity.data, 'upsert');
+        }
+        this.enforceMaxEntries(viewData);
+    }
+    handleEntityFrame(frame) {
+        const viewPath = frame.entity;
+        let viewData = this.views.get(viewPath);
+        const viewConfig = this.viewConfigs.get(viewPath);
+        if (!viewData) {
+            viewData = new ViewData(viewConfig?.sort);
+            this.views.set(viewPath, viewData);
+        }
+        const previousValue = viewData.get(frame.key);
+        switch (frame.op) {
+            case 'create':
+            case 'upsert':
+                viewData.set(frame.key, frame.data);
+                this.enforceMaxEntries(viewData);
+                this.notifyUpdate(viewPath, frame.key, {
+                    type: 'upsert',
+                    key: frame.key,
+                    data: frame.data,
+                });
+                this.notifyRichUpdate(viewPath, frame.key, previousValue, frame.data, frame.op);
+                break;
+            case 'patch': {
+                const existing = viewData.get(frame.key);
+                const appendPaths = frame.append ?? [];
+                const merged = existing
+                    ? deepMergeWithAppend(existing, frame.data, appendPaths)
+                    : frame.data;
+                viewData.set(frame.key, merged);
+                this.enforceMaxEntries(viewData);
+                this.notifyUpdate(viewPath, frame.key, {
+                    type: 'patch',
+                    key: frame.key,
+                    data: frame.data,
+                });
+                this.notifyRichUpdate(viewPath, frame.key, previousValue, merged, 'patch', frame.data);
+                break;
+            }
+            case 'delete':
+                viewData.delete(frame.key);
+                this.notifyUpdate(viewPath, frame.key, {
+                    type: 'delete',
+                    key: frame.key,
+                });
+                if (previousValue !== undefined) {
+                    this.notifyRichDelete(viewPath, frame.key, previousValue);
+                }
+                break;
+        }
+    }
+    getAll(viewPath) {
+        const viewData = this.views.get(viewPath);
+        if (!viewData)
+            return [];
+        return viewData.values();
+    }
+    get(viewPath, key) {
+        const viewData = this.views.get(viewPath);
+        if (!viewData)
+            return null;
+        const value = viewData.get(key);
+        return value !== undefined ? value : null;
+    }
+    getAllSync(viewPath) {
+        const viewData = this.views.get(viewPath);
+        if (!viewData)
+            return undefined;
+        return viewData.values();
+    }
+    getSync(viewPath, key) {
+        const viewData = this.views.get(viewPath);
+        if (!viewData)
+            return undefined;
+        const value = viewData.get(key);
+        return value !== undefined ? value : null;
+    }
+    keys(viewPath) {
+        const viewData = this.views.get(viewPath);
+        if (!viewData)
+            return [];
+        return viewData.keys();
+    }
+    size(viewPath) {
+        const viewData = this.views.get(viewPath);
+        return viewData?.size ?? 0;
+    }
+    clear() {
+        this.views.clear();
+    }
+    clearView(viewPath) {
+        this.views.delete(viewPath);
+        this.viewConfigs.delete(viewPath);
+    }
+    getViewConfig(viewPath) {
+        return this.viewConfigs.get(viewPath);
+    }
+    setViewConfig(viewPath, config) {
+        this.viewConfigs.set(viewPath, config);
+        const existingView = this.views.get(viewPath);
+        if (existingView && config.sort) {
+            existingView.setSortConfig(config.sort);
+        }
+    }
+    onUpdate(callback) {
+        this.updateCallbacks.add(callback);
+        return () => {
+            this.updateCallbacks.delete(callback);
+        };
+    }
+    onRichUpdate(callback) {
+        this.richUpdateCallbacks.add(callback);
+        return () => {
+            this.richUpdateCallbacks.delete(callback);
+        };
+    }
+    subscribe(viewPath, callback) {
+        const handler = (path, _key, update) => {
+            if (path === viewPath) {
+                callback(update);
+            }
+        };
+        this.updateCallbacks.add(handler);
+        return () => {
+            this.updateCallbacks.delete(handler);
+        };
+    }
+    subscribeToKey(viewPath, key, callback) {
+        const handler = (path, updateKey, update) => {
+            if (path === viewPath && updateKey === key) {
+                callback(update);
+            }
+        };
+        this.updateCallbacks.add(handler);
+        return () => {
+            this.updateCallbacks.delete(handler);
+        };
+    }
+    notifyUpdate(viewPath, key, update) {
+        for (const callback of this.updateCallbacks) {
+            callback(viewPath, key, update);
+        }
+    }
+    notifyRichUpdate(viewPath, key, before, after, _op, patch) {
+        const richUpdate = before === undefined
+            ? { type: 'created', key, data: after }
+            : { type: 'updated', key, before, after, patch };
+        for (const callback of this.richUpdateCallbacks) {
+            callback(viewPath, key, richUpdate);
+        }
+    }
+    notifyRichDelete(viewPath, key, lastKnown) {
+        const richUpdate = { type: 'deleted', key, lastKnown };
+        for (const callback of this.richUpdateCallbacks) {
+            callback(viewPath, key, richUpdate);
+        }
+    }
+}
+
+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.EntityStore = EntityStore;
+exports.FrameProcessor = FrameProcessor;
+exports.MemoryAdapter = MemoryAdapter;
+exports.SubscriptionRegistry = SubscriptionRegistry;
+exports.account = account;
+exports.arg = arg;
+exports.bytes = bytes;
+exports.createEntityStream = createEntityStream;
+exports.createInstructionExecutor = createInstructionExecutor;
+exports.createProgramPdas = createProgramPdas;
+exports.createPublicKeySeed = createPublicKeySeed;
+exports.createRichUpdateStream = createRichUpdateStream;
+exports.createSeed = createSeed;
+exports.createTypedListView = createTypedListView;
+exports.createTypedStateView = createTypedStateView;
+exports.createTypedViews = createTypedViews;
+exports.createUpdateStream = createUpdateStream;
+exports.decodeBase58 = decodeBase58;
+exports.derivePda = findProgramAddress;
+exports.encodeBase58 = encodeBase58;
+exports.executeInstruction = executeInstruction;
+exports.findProgramAddress = findProgramAddress;
+exports.findProgramAddressSync = findProgramAddressSync;
+exports.formatProgramError = formatProgramError;
+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.pda = pda;
+exports.resolveAccounts = resolveAccounts;
+exports.serializeInstructionData = serializeInstructionData;
+exports.validateAccountResolution = validateAccountResolution;
+exports.waitForConfirmation = waitForConfirmation;
+//# sourceMappingURL=index.js.map