@usearete/sdk 0.22.4 → 0.23.0

package/dist/index.d.ts

@@ -1041,9 +1041,26 @@ type ProgramReadDescriptors<TPrograms extends Record<string, ProgramSdkDefinitio
 type ProgramReadOverrides<TPrograms extends Record<string, ProgramSdkDefinition> | undefined> = TPrograms extends Record<string, ProgramSdkDefinition> ? {
     readonly [K in keyof TPrograms]?: ProgramReadOverride;
 } : Record<string, never>;
+/**
+ * The exact served version a generated stack definition was built for: one
+ * live alias of one StackManifest.
+ */
+interface StackRelease {
+    /** `arete:h1:stack-manifest:sha256:<64 hex>` */
+    readonly stackManifestHash: string;
+    /** The StackManifest live alias this definition serves. */
+    readonly liveAlias: string;
+}
 interface StackDefinition<TPrograms extends Record<string, ProgramSdkDefinition> = Record<string, ProgramSdkDefinition>> {
     readonly name: string;
     readonly endpoints: StackEndpoints;
+    /**
+     * Served version this definition was generated for. Present only on
+     * definitions generated from a hosted StackManifest; it is sent with the
+     * WebSocket session request for `endpoints.ws` so the session endpoint can
+     * route the client to that version.
+     */
+    readonly release?: StackRelease;
     readonly views: Record<string, ViewGroup>;
     readonly schemas?: Record<string, Schema<unknown>>;
     readonly patchSchemas?: Record<string, Schema<unknown>>;
@@ -1168,6 +1185,14 @@ type AuthTokenRequest = {
     readonly targetKind?: never;
     readonly targetId?: never;
     readonly programReleaseHash?: never;
+    /**
+     * Served version of the stack this session is for, when its stack
+     * definition carries one. A custom `getToken` provider can forward it
+     * to the session endpoint as `stackManifestHash`.
+     */
+    readonly stackManifestHash?: string;
+    /** Live alias paired with `stackManifestHash`, forwarded as `liveAlias`. */
+    readonly liveAlias?: string;
 } | ({
     readonly scopes: readonly string[];
 } & ProgramReadBindingAuthTarget) | ({
@@ -1210,6 +1235,11 @@ interface AreteConfig {
     auth?: AuthConfig;
     /** Fetch implementation used for authentication token requests. */
     fetch?: typeof fetch;
+    /**
+     * Served stack version to name in WebSocket session requests. Omitted
+     * requests are exactly what older clients send.
+     */
+    release?: StackRelease;
 }
 interface SocketIssue {
     error: string;
@@ -1228,7 +1258,24 @@ declare const DEFAULT_CONFIG: Required<Pick<AreteConfig, 'autoReconnect' | 'reco
  *
  * These codes match the Rust AuthErrorCode enum for cross-platform consistency.
  */
-type AuthErrorCode = 'TOKEN_MISSING' | 'TOKEN_EXPIRED' | 'TOKEN_INVALID_SIGNATURE' | 'TOKEN_INVALID_FORMAT' | 'TOKEN_INVALID_ISSUER' | 'TOKEN_INVALID_AUDIENCE' | 'TOKEN_MISSING_CLAIM' | 'TOKEN_KEY_NOT_FOUND' | 'ORIGIN_MISMATCH' | 'ORIGIN_REQUIRED' | 'ORIGIN_NOT_ALLOWED' | 'AUTH_REQUIRED' | 'MISSING_AUTHORIZATION_HEADER' | 'INVALID_AUTHORIZATION_FORMAT' | 'INVALID_API_KEY' | 'EXPIRED_API_KEY' | 'USER_NOT_FOUND' | 'SECRET_KEY_REQUIRED' | 'DEPLOYMENT_ACCESS_DENIED' | 'RATE_LIMIT_EXCEEDED' | 'WEBSOCKET_SESSION_RATE_LIMIT_EXCEEDED' | 'CONNECTION_LIMIT_EXCEEDED' | 'SUBSCRIPTION_LIMIT_EXCEEDED' | 'SNAPSHOT_LIMIT_EXCEEDED' | 'EGRESS_LIMIT_EXCEEDED' | 'QUOTA_EXCEEDED' | 'INVALID_STATIC_TOKEN' | 'INTERNAL_ERROR';
+type AuthErrorCode = 'TOKEN_MISSING' | 'TOKEN_EXPIRED' | 'TOKEN_INVALID_SIGNATURE' | 'TOKEN_INVALID_FORMAT' | 'TOKEN_INVALID_ISSUER' | 'TOKEN_INVALID_AUDIENCE' | 'TOKEN_MISSING_CLAIM' | 'TOKEN_KEY_NOT_FOUND' | 'ORIGIN_MISMATCH' | 'ORIGIN_REQUIRED' | 'ORIGIN_NOT_ALLOWED' | 'AUTH_REQUIRED' | 'MISSING_AUTHORIZATION_HEADER' | 'INVALID_AUTHORIZATION_FORMAT' | 'INVALID_API_KEY' | 'EXPIRED_API_KEY' | 'USER_NOT_FOUND' | 'SECRET_KEY_REQUIRED' | 'DEPLOYMENT_ACCESS_DENIED' | 'RATE_LIMIT_EXCEEDED' | 'WEBSOCKET_SESSION_RATE_LIMIT_EXCEEDED' | 'CONNECTION_LIMIT_EXCEEDED' | 'SUBSCRIPTION_LIMIT_EXCEEDED' | 'SNAPSHOT_LIMIT_EXCEEDED' | 'EGRESS_LIMIT_EXCEEDED' | 'QUOTA_EXCEEDED' | 'INVALID_STATIC_TOKEN' | 'STACK_VERSION_RETIRED' | 'STACK_VERSION_UNKNOWN' | 'INTERNAL_ERROR';
+/**
+ * Structured fields of a `STACK_VERSION_RETIRED` / `STACK_VERSION_UNKNOWN`
+ * session refusal, carried on {@link AreteError.details} alongside `status`,
+ * `wireErrorCode` and `responseBody`.
+ */
+interface StackVersionRefusal {
+    readonly replacement?: {
+        readonly version?: string;
+        readonly stackManifestHash?: string;
+    };
+    /** Command that installs the replacement, e.g. `a4 install stack ore@1.3.0`. */
+    readonly upgradeCommand?: string;
+    /** RFC 3339 time the version was retired. */
+    readonly retiredAt?: string;
+}
+/** True for the session refusals that no retry or reconnect can resolve. */
+declare function isStackVersionRefusalCode(code: string): boolean;
 /**
  * Refusals of a replay cursor. Each has a distinct recovery, so they reach the
  * consumer as the wire code rather than being folded into a generic failure.
@@ -1347,8 +1394,15 @@ interface ErrorFrame {
     code: string;
     retryable?: boolean;
     fatal: boolean;
+    /** Seconds to wait before retrying, as the server sends it. */
+    retryAfter?: number;
+    suggestedAction?: string;
+    docsUrl?: string;
+    /** @deprecated The server sends `retryAfter`; kept for older servers. */
     retry_after?: number;
+    /** @deprecated The server sends `suggestedAction`; kept for older servers. */
     suggested_action?: string;
+    /** @deprecated The server sends `docsUrl`; kept for older servers. */
     docs_url?: string;
     /** Present on cursor refusals: what the view can still serve. */
     replayWindow?: ReplayWindow;
@@ -1419,7 +1473,10 @@ declare class ConnectionManager {
     private tokenScopes;
     private requestedScopes;
     private readonly hostedAreteUrl;
+    private readonly release?;
     private reconnectForTokenRefresh;
+    /** Most recent reason the socket was lost, reported while reconnecting. */
+    private lastDisconnectReason?;
     constructor(config: AreteConfig);
     private getTokenEndpoint;
     private getAuthStrategy;
@@ -1474,7 +1531,14 @@ declare class ConnectionManager {
     private addQueuedSubscription;
     private updateState;
     private notifyFrameHandlers;
+    /**
+     * @param reason Why the connection was lost, when known. It is reported
+     * with the `reconnecting` state and kept for the terminal error if the
+     * attempts run out, so a server's close reason is never dropped.
+     */
     private handleReconnect;
+    /** Schedule the next attempt after a failed reconnect, unless nothing can succeed. */
+    private recoverFromFailedConnect;
     private clearReconnectTimeout;
     private startPingInterval;
     private stopPingInterval;
@@ -2660,5 +2724,5 @@ declare const Arete: typeof Arete$1 & {
     session: typeof createSession;
 };
 
-export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, Arete, AreteError, ConnectionManager, DEFAULT_CONFIG, DEFAULT_MAX_ENTRIES_PER_VIEW, FrameProcessor, InstructionError, MemoryAdapter, OPERATION_KIND, OperationCallbackError, OperationExecutionError, PROGRAM_OPERATION_EXTENSIONS, ProcessedSlotTimeoutError, QueryStore, ReadRequestError, SPL_TOKEN_PROGRAM_ADDRESS, STACK_RUNTIME_EXTENSIONS, SYSTEM_PROGRAM_ADDRESS, StreamGapError, SubscriptionRegistry, TOKEN_2022_PROGRAM_ADDRESS, TRANSACTION_RESOURCE_OPTION_KEYS, TransactionExecutionError, TransactionOptionsError, TransactionTransportError, account, appendFlowTransactions, appendTransactionInstructions, applyConnectedStackExtensions, arg, buildInstruction, bytes, canonicalQueryKey, chainAccountLoader, createChainClient, createEntityStream, createHostedSolanaGatewayTransports, createInstructionExecutor, createInstructionHandler, createPreparedFlow, createPreparedInstruction, createPreparedTransaction, createPreparedTransactionBody, createProgramPdas, createPublicKeySeed, createRichUpdateStream, createSeed, createSession, createSignerRegistry, createSubscriptionId, createTransactionTransport, createTypedListView, createTypedStateView, createTypedViews, createUpdateStream, decodeBase58, defineProgramExtensions, defineStackExtensions, deriveAssociatedTokenAccount, deriveHttpEndpoint, findProgramAddress as derivePda, describePreparedOperation, encodeBase58, executeInstruction, executePreparedOperation, extendProgram, extendPrograms, extendStack, findProgramAddress, findProgramAddressSync, flowOperation, formatPreparedOperation, formatProgramError, formatRawToUi, getMintDecimals, getOperationKind, getProgramRuntimeExtensions, getStackRuntimeExtensions, getTransactionFailureOutcome, hostedWebsocketSuffixes, inspectPreparedOperation, instructionOperation, isEntityFrame, isErrorFrame, isHostedAreteEndpoint, isReplayErrorCode, isSnapshotFrame, isSubscribedFrame, isUnsubscribedFrame, isValidFrame, literal, normalizeSubscription, normalizeSubscriptionQuery, normalizeSubscriptionRequest, normalizeTransactionError, parseFrame, parseFrameFromBlob, parseInstructionError, parseUiAmountToRaw, pda, prependFlowTransactionInstructions, prependTransactionInstructions, programAccountRead, programQuery, resolveAccounts, resolveAmount, resolveAmountToRaw, resolveAmountsToRaw, resolveTokenProgramAddress, resolveTransactionBuildOptions, safeToRawAmount, serializeInstructionData, serializeViewKey, setHostedWebsocketSuffixes, stackQuery, stringifyBigints, toJsonValue, toRawAmount, toWireResourceOptions, transactionOperation, unwrapOperationExecutionError, validateAccountResolution, validateProgramReadDescriptor, validateSubscriptionId, withProgramRead, withPrograms };
-export type { AccountCategory, AccountLoader, AccountMeta, AccountResolutionOptions, AccountResolutionResult, AmountInput, AnyOperation, AreteConfig, AreteOptions, AreteOptionsWithStorage, ArgSchema, ArgType, AuthConfig, AuthTokenRequest, AuthTokenResult, AuthTokenTarget, BuildOptions, BuiltAccountMeta, BuiltInstruction, ChainClient, ChainClock, ChainFailedTransactionOutcome, CompositionSessionOptions, ConfirmationLevel, ConfirmedTransactionOutcome, ConnectOptions, ConnectedArete, ConnectedStackClient, ConnectionState, ConnectionStateCallback, ContextSlotOptions, CreatePreparedFlowInput, CreatePreparedInstructionInput, CreatePreparedTransactionInput, DefaultViewKey, EntityFrame, ErrorFrame, ErrorMetadata, ExecuteOptions, ExecutionResult, ExtendedProgramDefinition, ExtendedStackDefinition, FlowOperation, FlowOperationNamespace, FlowOperationReceipt, Frame, FrameMode, FrameOp, FrameProcessorConfig, FrameValidationDiagnostic, HostedSolanaGatewayBindings, HostedSolanaGatewayCapabilityBinding, HostedSolanaGatewayTransportOptions, HostedSolanaGatewayTransports, HttpAuthMetadata, InstructionExecutor, InstructionHandler, InstructionHandlerConfig, InstructionOperation, InstructionOperationNamespace, JsonObject, JsonPrimitive, JsonValue, LatestBlockhashResult, MergeProgramMaps, MintAccountInfo, NativeBalanceInfo, NonEmptyReadonlyArray, NotSubmittedTransactionOutcome, OperationCallbackPhase, OperationExecutionEvent, OperationExecutionHost, OperationExecutionOptions, OperationExecutionSuccessEvent, OperationInspection, OperationInspectionOptions, OperationKind, OperationKindBrand, OperationNamespace, OperationPlan, OperationReceiptFor, OperationTransactionReceipt, PdaConfig, PdaDeriveContext, PdaFactory, PdaProgram, PdaProgramSelector, PdaSeed, PreparedFlow, PreparedInstruction, PreparedOperation, PreparedOperationDescription, PreparedTransaction, PreparedTransactionBody, PreparedTransactionInstruction, PreparedTransactionOperation, ProgramAccountBatchItem, ProgramAccountBatchResult, ProgramAccountReadDefinition, ProgramError, ProgramExtensionInput, ProgramInterface, ProgramOperationContext, ProgramOperations, ProgramOperationsOf, ProgramPdas, ProgramQueryDefinition, ProgramReadBinding, ProgramReadBindingAuthTarget, ProgramReadDescriptor, ProgramReadDescriptors, ProgramReadOf, ProgramReadOverride, ProgramReadOverrides, ProgramReadRequest, ProgramReadTransport, ProgramReleaseReference, ProgramRuntimeExtensionCarrier, ProgramRuntimeExtensions, ProgramSdkDefinition, ProgramsInterface, QueriesInterface, QueryLease, QuerySnapshot, RawAccountInfo, RawInstructionsInterface, RawProgramsInterface, ReadArgumentCount, ReadArgumentCounts, ReadTransportMethod, ReplayErrorCode, ReplayWindow, ResolvedAccount, ResolvedAccounts, ResolvedTransactionBuildOptions, ResolvedTransactionResourceOptions, ResourceLamports, ResourceUnits, RichUpdate, RichUpdateCallback, Schema, SchemaResult, SeedDef, SendOptions, SendResult, Session, SessionDefinition, SessionMemberOptions, SessionOptions, SignerRegistry, SingleTransactionOperationReceipt, SnapshotEntity, SnapshotFrame, SocketIssue, SocketIssueCallback, SolanaGatewayAuthMetadata, SolanaGatewayAuthScope, SolanaGatewayBindingAuthTarget, SortConfig, SortOrder, StackConnectedExtensions, StackDefinition, StackEndpoints, StackExtensionClient, StackExtensionInput, StackQueryDefinition, StackRuntimeExtensionCarrier, StackRuntimeExtensions, StackWithAttachedPrograms, StorageAdapter, StorageAdapterConfig, StringifiedBigints, SubmittedUnknownTransactionOutcome, SubscribeCallback, SubscribedFrame, Subscription, SubscriptionIdentity, SubscriptionOptions, SubscriptionQuery, SubscriptionRequest, SubscriptionSnapshotOptions, TokenAccountInfo, TokenBalanceInfo, TokenBalanceInput, TransactionBuildCapability, TransactionBuildOptions, TransactionCommitment, TransactionFailureOutcome, TransactionFailurePhase, TransactionFailureStatus, TransactionFeeResult, TransactionInspectionOptions, TransactionInspectionResult, TransactionOperation, TransactionOperationNamespace, TransactionOptions, TransactionOptionsErrorCode, TransactionOutcome, TransactionRequestContext, TransactionResourceOptionKey, TransactionResourceOptions, TransactionSendOptions, TransactionSendResult, TransactionSignatureStatus, TransactionSimulationOptions, TransactionSimulationResult, TransactionTransport, TransactionTransportErrorBody, TransactionVersion, TypedAccountReader, TypedInstruction, TypedListView, TypedQueryExecutor, TypedStateView, TypedViewGroup, TypedViews, UnsubscribeFn, UnsubscribedFrame, Update, UpdateCallback, ViewDef, ViewGroup, ViewKeyFields, ViewKeyValue, ViewSortConfig, WaitForProcessedSlotOptions, WalletAdapter, WalletConnectOptions, WalletExecutionContext, WalletState, WatchOptions, WebSocketFactoryInit };
+export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, Arete, AreteError, ConnectionManager, DEFAULT_CONFIG, DEFAULT_MAX_ENTRIES_PER_VIEW, FrameProcessor, InstructionError, MemoryAdapter, OPERATION_KIND, OperationCallbackError, OperationExecutionError, PROGRAM_OPERATION_EXTENSIONS, ProcessedSlotTimeoutError, QueryStore, ReadRequestError, SPL_TOKEN_PROGRAM_ADDRESS, STACK_RUNTIME_EXTENSIONS, SYSTEM_PROGRAM_ADDRESS, StreamGapError, SubscriptionRegistry, TOKEN_2022_PROGRAM_ADDRESS, TRANSACTION_RESOURCE_OPTION_KEYS, TransactionExecutionError, TransactionOptionsError, TransactionTransportError, account, appendFlowTransactions, appendTransactionInstructions, applyConnectedStackExtensions, arg, buildInstruction, bytes, canonicalQueryKey, chainAccountLoader, createChainClient, createEntityStream, createHostedSolanaGatewayTransports, createInstructionExecutor, createInstructionHandler, createPreparedFlow, createPreparedInstruction, createPreparedTransaction, createPreparedTransactionBody, createProgramPdas, createPublicKeySeed, createRichUpdateStream, createSeed, createSession, createSignerRegistry, createSubscriptionId, createTransactionTransport, createTypedListView, createTypedStateView, createTypedViews, createUpdateStream, decodeBase58, defineProgramExtensions, defineStackExtensions, deriveAssociatedTokenAccount, deriveHttpEndpoint, findProgramAddress as derivePda, describePreparedOperation, encodeBase58, executeInstruction, executePreparedOperation, extendProgram, extendPrograms, extendStack, findProgramAddress, findProgramAddressSync, flowOperation, formatPreparedOperation, formatProgramError, formatRawToUi, getMintDecimals, getOperationKind, getProgramRuntimeExtensions, getStackRuntimeExtensions, getTransactionFailureOutcome, hostedWebsocketSuffixes, inspectPreparedOperation, instructionOperation, isEntityFrame, isErrorFrame, isHostedAreteEndpoint, isReplayErrorCode, isSnapshotFrame, isStackVersionRefusalCode, isSubscribedFrame, isUnsubscribedFrame, isValidFrame, literal, normalizeSubscription, normalizeSubscriptionQuery, normalizeSubscriptionRequest, normalizeTransactionError, parseFrame, parseFrameFromBlob, parseInstructionError, parseUiAmountToRaw, pda, prependFlowTransactionInstructions, prependTransactionInstructions, programAccountRead, programQuery, resolveAccounts, resolveAmount, resolveAmountToRaw, resolveAmountsToRaw, resolveTokenProgramAddress, resolveTransactionBuildOptions, safeToRawAmount, serializeInstructionData, serializeViewKey, setHostedWebsocketSuffixes, stackQuery, stringifyBigints, toJsonValue, toRawAmount, toWireResourceOptions, transactionOperation, unwrapOperationExecutionError, validateAccountResolution, validateProgramReadDescriptor, validateSubscriptionId, withProgramRead, withPrograms };
+export type { AccountCategory, AccountLoader, AccountMeta, AccountResolutionOptions, AccountResolutionResult, AmountInput, AnyOperation, AreteConfig, AreteOptions, AreteOptionsWithStorage, ArgSchema, ArgType, AuthConfig, AuthTokenRequest, AuthTokenResult, AuthTokenTarget, BuildOptions, BuiltAccountMeta, BuiltInstruction, ChainClient, ChainClock, ChainFailedTransactionOutcome, CompositionSessionOptions, ConfirmationLevel, ConfirmedTransactionOutcome, ConnectOptions, ConnectedArete, ConnectedStackClient, ConnectionState, ConnectionStateCallback, ContextSlotOptions, CreatePreparedFlowInput, CreatePreparedInstructionInput, CreatePreparedTransactionInput, DefaultViewKey, EntityFrame, ErrorFrame, ErrorMetadata, ExecuteOptions, ExecutionResult, ExtendedProgramDefinition, ExtendedStackDefinition, FlowOperation, FlowOperationNamespace, FlowOperationReceipt, Frame, FrameMode, FrameOp, FrameProcessorConfig, FrameValidationDiagnostic, HostedSolanaGatewayBindings, HostedSolanaGatewayCapabilityBinding, HostedSolanaGatewayTransportOptions, HostedSolanaGatewayTransports, HttpAuthMetadata, InstructionExecutor, InstructionHandler, InstructionHandlerConfig, InstructionOperation, InstructionOperationNamespace, JsonObject, JsonPrimitive, JsonValue, LatestBlockhashResult, MergeProgramMaps, MintAccountInfo, NativeBalanceInfo, NonEmptyReadonlyArray, NotSubmittedTransactionOutcome, OperationCallbackPhase, OperationExecutionEvent, OperationExecutionHost, OperationExecutionOptions, OperationExecutionSuccessEvent, OperationInspection, OperationInspectionOptions, OperationKind, OperationKindBrand, OperationNamespace, OperationPlan, OperationReceiptFor, OperationTransactionReceipt, PdaConfig, PdaDeriveContext, PdaFactory, PdaProgram, PdaProgramSelector, PdaSeed, PreparedFlow, PreparedInstruction, PreparedOperation, PreparedOperationDescription, PreparedTransaction, PreparedTransactionBody, PreparedTransactionInstruction, PreparedTransactionOperation, ProgramAccountBatchItem, ProgramAccountBatchResult, ProgramAccountReadDefinition, ProgramError, ProgramExtensionInput, ProgramInterface, ProgramOperationContext, ProgramOperations, ProgramOperationsOf, ProgramPdas, ProgramQueryDefinition, ProgramReadBinding, ProgramReadBindingAuthTarget, ProgramReadDescriptor, ProgramReadDescriptors, ProgramReadOf, ProgramReadOverride, ProgramReadOverrides, ProgramReadRequest, ProgramReadTransport, ProgramReleaseReference, ProgramRuntimeExtensionCarrier, ProgramRuntimeExtensions, ProgramSdkDefinition, ProgramsInterface, QueriesInterface, QueryLease, QuerySnapshot, RawAccountInfo, RawInstructionsInterface, RawProgramsInterface, ReadArgumentCount, ReadArgumentCounts, ReadTransportMethod, ReplayErrorCode, ReplayWindow, ResolvedAccount, ResolvedAccounts, ResolvedTransactionBuildOptions, ResolvedTransactionResourceOptions, ResourceLamports, ResourceUnits, RichUpdate, RichUpdateCallback, Schema, SchemaResult, SeedDef, SendOptions, SendResult, Session, SessionDefinition, SessionMemberOptions, SessionOptions, SignerRegistry, SingleTransactionOperationReceipt, SnapshotEntity, SnapshotFrame, SocketIssue, SocketIssueCallback, SolanaGatewayAuthMetadata, SolanaGatewayAuthScope, SolanaGatewayBindingAuthTarget, SortConfig, SortOrder, StackConnectedExtensions, StackDefinition, StackEndpoints, StackExtensionClient, StackExtensionInput, StackQueryDefinition, StackRelease, StackRuntimeExtensionCarrier, StackRuntimeExtensions, StackVersionRefusal, StackWithAttachedPrograms, StorageAdapter, StorageAdapterConfig, StringifiedBigints, SubmittedUnknownTransactionOutcome, SubscribeCallback, SubscribedFrame, Subscription, SubscriptionIdentity, SubscriptionOptions, SubscriptionQuery, SubscriptionRequest, SubscriptionSnapshotOptions, TokenAccountInfo, TokenBalanceInfo, TokenBalanceInput, TransactionBuildCapability, TransactionBuildOptions, TransactionCommitment, TransactionFailureOutcome, TransactionFailurePhase, TransactionFailureStatus, TransactionFeeResult, TransactionInspectionOptions, TransactionInspectionResult, TransactionOperation, TransactionOperationNamespace, TransactionOptions, TransactionOptionsErrorCode, TransactionOutcome, TransactionRequestContext, TransactionResourceOptionKey, TransactionResourceOptions, TransactionSendOptions, TransactionSendResult, TransactionSignatureStatus, TransactionSimulationOptions, TransactionSimulationResult, TransactionTransport, TransactionTransportErrorBody, TransactionVersion, TypedAccountReader, TypedInstruction, TypedListView, TypedQueryExecutor, TypedStateView, TypedViewGroup, TypedViews, UnsubscribeFn, UnsubscribedFrame, Update, UpdateCallback, ViewDef, ViewGroup, ViewKeyFields, ViewKeyValue, ViewSortConfig, WaitForProcessedSlotOptions, WalletAdapter, WalletConnectOptions, WalletExecutionContext, WalletState, WatchOptions, WebSocketFactoryInit };

package/dist/index.esm.js

@@ -8,6 +8,10 @@ const DEFAULT_CONFIG = {
     maxReconnectAttempts: 5,
     maxEntriesPerView: DEFAULT_MAX_ENTRIES_PER_VIEW,
 };
+/** True for the session refusals that no retry or reconnect can resolve. */
+function isStackVersionRefusalCode(code) {
+    return code === 'STACK_VERSION_RETIRED' || code === 'STACK_VERSION_UNKNOWN';
+}
 const REPLAY_ERROR_CODES = {
     'cursor-expired': true,
     'cursor-epoch-changed': true,
@@ -46,41 +50,66 @@ class AreteError extends Error {
  * collapsing them into a generic failure would destroy the only distinction.
  */
 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',
-    };
     const normalized = errorCode.toLowerCase();
     if (isReplayErrorCode(normalized))
         return normalized;
-    return codeMap[normalized] || 'INTERNAL_ERROR';
+    return authErrorCodeFromWire(normalized) ?? 'INTERNAL_ERROR';
 }
+/**
+ * Resolve a wire error code the way {@link parseErrorCode} does, except that a
+ * code this SDK does not know is returned as sent instead of being collapsed
+ * into `INTERNAL_ERROR`. A newer server's refusal then still reaches the
+ * consumer under its own name.
+ */
+/** Whether `code` is a wire error code this SDK knows. */
+function isKnownWireErrorCode(code) {
+    const normalized = code.trim().toLowerCase();
+    return isReplayErrorCode(normalized) || authErrorCodeFromWire(normalized) !== undefined;
+}
+function parseWireErrorCode(errorCode) {
+    const trimmed = errorCode.trim();
+    const normalized = trimmed.toLowerCase();
+    if (isReplayErrorCode(normalized))
+        return normalized;
+    return authErrorCodeFromWire(normalized) ?? trimmed;
+}
+function authErrorCodeFromWire(normalized) {
+    return Object.prototype.hasOwnProperty.call(AUTH_ERROR_CODES_BY_WIRE, normalized)
+        ? AUTH_ERROR_CODES_BY_WIRE[normalized]
+        : undefined;
+}
+const AUTH_ERROR_CODES_BY_WIRE = {
+    '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',
+    'stack-version-retired': 'STACK_VERSION_RETIRED',
+    'stack-version-unknown': 'STACK_VERSION_UNKNOWN',
+};
 
 const GZIP_MAGIC_0 = 0x1f;
 const GZIP_MAGIC_1 = 0x8b;
@@ -623,6 +652,73 @@ function hostedWebsocketSuffixes() {
     return [HOSTED_WEBSOCKET_SUFFIX, ...extraHostedSuffixes];
 }
 const MAX_HTTP_AUTH_TOKEN_STATES = 32;
+function optionalString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+/** The structured fields of a stack version refusal, dropping malformed ones. */
+function parseStackVersionRefusal(body) {
+    const replacementBody = typeof body?.replacement === 'object' && body.replacement !== null
+        ? body.replacement
+        : undefined;
+    const version = optionalString(replacementBody?.['version']);
+    const stackManifestHash = optionalString(replacementBody?.['stackManifestHash']);
+    const upgradeCommand = optionalString(body?.upgradeCommand);
+    const retiredAt = optionalString(body?.retiredAt);
+    return {
+        ...(version !== undefined || stackManifestHash !== undefined
+            ? {
+                replacement: {
+                    ...(version !== undefined ? { version } : {}),
+                    ...(stackManifestHash !== undefined ? { stackManifestHash } : {}),
+                },
+            }
+            : {}),
+        ...(upgradeCommand !== undefined ? { upgradeCommand } : {}),
+        ...(retiredAt !== undefined ? { retiredAt } : {}),
+    };
+}
+/** The server's message, followed by the replacement and how to install it. */
+function describeStackVersionRefusal(message, refusal) {
+    const guidance = [];
+    const replacement = refusal.replacement?.version ?? refusal.replacement?.stackManifestHash;
+    if (replacement !== undefined)
+        guidance.push(`Replacement: ${replacement}.`);
+    if (refusal.upgradeCommand !== undefined)
+        guidance.push(`Upgrade with: ${refusal.upgradeCommand}`);
+    if (guidance.length === 0)
+        return message;
+    const trimmed = message.trimEnd();
+    return `${trimmed}${/[.!?]$/.test(trimmed) ? '' : '.'} ${guidance.join(' ')}`;
+}
+/**
+ * The wire code a close reason carries: the `code` of `code: message`, or the
+ * whole reason when it is exactly a known wire code. A free-form reason
+ * carries none.
+ */
+function closeReasonWireCode(reason) {
+    if (!reason)
+        return undefined;
+    const prefixed = reason.match(/^([\w-]+):/)?.[1];
+    if (prefixed !== undefined)
+        return prefixed;
+    const bare = reason.trim();
+    return isKnownWireErrorCode(bare) ? bare : undefined;
+}
+/** A stack version refusal ends the connection: no retry or reconnect can fix it. */
+function isTerminalRefusal(error) {
+    return error instanceof AreteError && isStackVersionRefusalCode(error.code);
+}
+function normalizeStackRelease(release) {
+    if (release === undefined)
+        return undefined;
+    if (typeof release.stackManifestHash !== 'string'
+        || release.stackManifestHash.length === 0
+        || typeof release.liveAlias !== 'string'
+        || release.liveAlias.length === 0) {
+        throw new AreteError('Stack release requires a non-empty stackManifestHash and liveAlias', 'INVALID_CONFIG');
+    }
+    return { stackManifestHash: release.stackManifestHash, liveAlias: release.liveAlias };
+}
 function normalizeTokenResult(result) {
     if (typeof result === 'string') {
         return { token: result };
@@ -799,6 +895,7 @@ class ConnectionManager {
         this.maxReconnectAttempts =
             config.maxReconnectAttempts ?? DEFAULT_CONFIG.maxReconnectAttempts;
         this.authConfig = config.auth;
+        this.release = normalizeStackRelease(config.release);
         this.authFetch = config.fetch ?? ((input, init) => {
             if (typeof globalThis.fetch !== 'function') {
                 throw new AreteError('A fetch implementation is required for authentication token requests', 'INVALID_CONFIG');
@@ -901,7 +998,15 @@ class ConnectionManager {
         }
     }
     async fetchAuthToken(scopes, isCurrent) {
-        const request = { scopes: normalizeScopes(scopes) };
+        const request = {
+            scopes: normalizeScopes(scopes),
+            ...(this.release
+                ? {
+                    stackManifestHash: this.release.stackManifestHash,
+                    liveAlias: this.release.liveAlias,
+                }
+                : {}),
+        };
         const result = await this.requestAuthToken(request, isCurrent);
         return result === undefined ? undefined : this.updateTokenState(result, request.scopes);
     }
@@ -1030,9 +1135,14 @@ class ConnectionManager {
                 ? { ...target, programReleaseHash: request.programReleaseHash }
                 : target;
         }
+        // Session requests from a stack definition without a release stay
+        // byte-for-byte what older clients send.
         return {
             websocket_url: this.websocketUrl ?? '',
             scopes: request.scopes,
+            ...(request.stackManifestHash !== undefined && request.liveAlias !== undefined
+                ? { stackManifestHash: request.stackManifestHash, liveAlias: request.liveAlias }
+                : {}),
         };
     }
     async fetchTokenFromEndpoint(tokenEndpoint, request) {
@@ -1069,6 +1179,15 @@ class ConnectionManager {
             const errorMessage = typeof parsedError?.error === 'string' && parsedError.error.length > 0
                 ? parsedError.error
                 : rawError || response.statusText || 'Authentication request failed';
+            if (isStackVersionRefusalCode(errorCode)) {
+                const refusal = parseStackVersionRefusal(parsedError);
+                throw new AreteError(describeStackVersionRefusal(`Token endpoint returned ${response.status}: ${errorMessage}`, refusal), errorCode, {
+                    status: response.status,
+                    wireErrorCode,
+                    responseBody: rawError || null,
+                    ...refusal,
+                });
+            }
             throw new AreteError(`Token endpoint returned ${response.status}: ${errorMessage}`, errorCode, {
                 status: response.status,
                 wireErrorCode,
@@ -1134,8 +1253,10 @@ class ConnectionManager {
                     this.scheduleTokenRefresh();
                 }
             }
-            catch {
-                if (this.tokenRefreshInFlight === refresh) {
+            catch (error) {
+                // A stack version refusal will not change on retry. Stop refreshing;
+                // the next connect after this session ends reports it.
+                if (this.tokenRefreshInFlight === refresh && !isTerminalRefusal(error)) {
                     this.scheduleTokenRefresh();
                 }
             }
@@ -1328,11 +1449,11 @@ class ConnectionManager {
         const issue = {
             error: message.error ?? message.code,
             message: message.message ?? message.error ?? message.code,
-            code: parseErrorCode(message.code),
+            code: parseWireErrorCode(message.code),
             retryable: message.retryable ?? false,
-            retryAfter: message.retry_after,
-            suggestedAction: message.suggested_action,
-            docsUrl: message.docs_url,
+            retryAfter: message.retryAfter ?? message.retry_after,
+            suggestedAction: message.suggestedAction ?? message.suggested_action,
+            docsUrl: message.docsUrl ?? message.docs_url,
             fatal: message.fatal,
             subscriptionId: message.subscriptionId,
         };
@@ -1368,7 +1489,7 @@ class ConnectionManager {
                 this.pendingConnect = null;
             }
             if (generation === this.socketGeneration) {
-                this.updateState(recovering ? 'reconnecting' : 'error', error instanceof Error ? error.message : 'Failed to get token');
+                this.updateState(recovering && !isTerminalRefusal(error) ? 'reconnecting' : 'error', error instanceof Error ? error.message : 'Failed to get token');
             }
             throw error;
         }
@@ -1396,6 +1517,7 @@ class ConnectionManager {
                     if (!isCurrentSocket())
                         return;
                     this.reconnectAttempts = 0;
+                    this.lastDisconnectReason = undefined;
                     this.updateState('connected');
                     this.startPingInterval();
                     this.scheduleTokenRefresh();
@@ -1469,8 +1591,19 @@ class ConnectionManager {
                             ? `${event.code}: ${event.reason}`
                             : `code ${event.code}`;
                         const errorMessage = `WebSocket closed before open (${detail})`;
-                        this.updateState(recovering ? 'reconnecting' : 'error', errorMessage);
-                        finish(() => reject(new AreteError(errorMessage, 'CONNECTION_ERROR')));
+                        const reasonCode = closeReasonWireCode(event.reason);
+                        const wireErrorCode = reasonCode === undefined
+                            ? undefined
+                            : parseWireErrorCode(reasonCode);
+                        // A stack version refusal is terminal even mid-reconnect: carry it
+                        // as the error code, so recovery stops instead of retrying.
+                        const refused = wireErrorCode !== undefined && isStackVersionRefusalCode(wireErrorCode);
+                        this.updateState(recovering && !refused ? 'reconnecting' : 'error', errorMessage);
+                        finish(() => reject(new AreteError(errorMessage, refused ? wireErrorCode : 'CONNECTION_ERROR', {
+                            closeCode: event.code,
+                            closeReason: event.reason || undefined,
+                            wireErrorCode,
+                        })));
                         return;
                     }
                     if (this.reconnectForTokenRefresh) {
@@ -1479,15 +1612,19 @@ class ConnectionManager {
                             this.updateState('error', 'WebSocket closed for token refresh and automatic reconnection is disabled');
                             return;
                         }
-                        void this.connect(true).catch(() => {
-                            this.handleReconnect();
+                        void this.connect(true).catch((error) => {
+                            this.recoverFromFailedConnect(error);
                         });
                         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;
+                    const reasonCode = closeReasonWireCode(closeReason);
+                    const errorCode = reasonCode === undefined ? null : parseWireErrorCode(reasonCode);
+                    if (errorCode !== null && isStackVersionRefusalCode(errorCode)) {
+                        this.updateState('error', `WebSocket closed (${event.code}: ${closeReason})`);
+                        return;
+                    }
                     // Check for auth errors that require token refresh
                     if (event.code === 1008 || errorCode) {
                         const isAuthError = errorCode
@@ -1500,8 +1637,8 @@ class ConnectionManager {
                                 return;
                             }
                             // Try to reconnect immediately with a fresh token
-                            void this.connect(true).catch(() => {
-                                this.handleReconnect();
+                            void this.connect(true).catch((error) => {
+                                this.recoverFromFailedConnect(error);
                             });
                             return;
                         }
@@ -1516,13 +1653,13 @@ class ConnectionManager {
                         }
                     }
                     if (this.currentState !== 'disconnected') {
+                        const detail = event.reason
+                            ? `${event.code}: ${event.reason}`
+                            : `code ${event.code}`;
                         if (this.autoReconnect) {
-                            this.handleReconnect();
+                            this.handleReconnect(`WebSocket closed (${detail})`);
                         }
                         else {
-                            const detail = event.reason
-                                ? `${event.code}: ${event.reason}`
-                                : `code ${event.code}`;
                             this.updateState('error', `WebSocket closed (${detail}) and automatic reconnection is disabled`);
                         }
                     }
@@ -1541,6 +1678,7 @@ class ConnectionManager {
         this.stopPingInterval();
         this.clearTokenRefreshTimeout();
         this.reconnectForTokenRefresh = false;
+        this.lastDisconnectReason = undefined;
         const pendingConnect = this.pendingConnect;
         this.pendingConnect = null;
         this.tokenRequestInFlight = null;
@@ -1670,29 +1808,47 @@ class ConnectionManager {
             handler(frame);
         }
     }
-    handleReconnect() {
+    /**
+     * @param reason Why the connection was lost, when known. It is reported
+     * with the `reconnecting` state and kept for the terminal error if the
+     * attempts run out, so a server's close reason is never dropped.
+     */
+    handleReconnect(reason) {
+        if (reason !== undefined) {
+            this.lastDisconnectReason = reason;
+        }
         if (!this.autoReconnect) {
             this.updateState('error', 'Automatic reconnection is disabled');
             return;
         }
         if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-            this.updateState('error', `Max reconnection attempts (${this.reconnectAttempts}) reached`);
+            const lastReason = this.lastDisconnectReason;
+            this.updateState('error', `Max reconnection attempts (${this.reconnectAttempts}) reached`
+                + (lastReason ? `; last disconnect: ${lastReason}` : ''));
             return;
         }
-        this.updateState('reconnecting');
+        this.updateState('reconnecting', this.lastDisconnectReason);
         const attemptIndex = Math.min(this.reconnectAttempts, this.reconnectIntervals.length - 1);
         const delay = this.reconnectIntervals[attemptIndex] ?? 1000;
         this.reconnectAttempts++;
         this.reconnectTimeout = setTimeout(() => {
-            this.connect(true).catch(() => {
+            this.connect(true).catch((error) => {
                 // Once a socket exists, its close event owns the next retry. Token
                 // acquisition and socket construction can fail before that point.
                 if (this.ws === null && this.currentState !== 'disconnected') {
-                    this.handleReconnect();
+                    this.recoverFromFailedConnect(error);
                 }
             });
         }, delay);
     }
+    /** Schedule the next attempt after a failed reconnect, unless nothing can succeed. */
+    recoverFromFailedConnect(error) {
+        if (isTerminalRefusal(error)) {
+            // connect() already reported the refusal as the terminal error state.
+            return;
+        }
+        this.handleReconnect(error instanceof Error ? error.message : undefined);
+    }
     clearReconnectTimeout() {
         if (this.reconnectTimeout) {
             clearTimeout(this.reconnectTimeout);
@@ -7030,6 +7186,9 @@ let Arete$1 = class Arete {
             maxReconnectAttempts: options.maxReconnectAttempts,
             auth: options.auth,
             fetch: this.fetchImpl,
+            // The release names the version served at the generated endpoint. A
+            // different `url` points somewhere the generator knew nothing about.
+            release: url !== null && url === this.stack.endpoints.ws ? this.stack.release : undefined,
         });
         this.processor.useCursorTracker(this.connection.cursors);
         this.subscriptionRegistry = new SubscriptionRegistry(this.connection, this.queryStore);
@@ -7923,5 +8082,5 @@ function stringifyBigints(value) {
 
 const Arete = Object.assign(Arete$1, { session: createSession });
 
-export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, Arete, AreteError, ConnectionManager, DEFAULT_CONFIG, DEFAULT_MAX_ENTRIES_PER_VIEW, FrameProcessor, InstructionError, MemoryAdapter, OPERATION_KIND, OperationCallbackError, OperationExecutionError, PROGRAM_OPERATION_EXTENSIONS, ProcessedSlotTimeoutError, QueryStore, ReadRequestError, SPL_TOKEN_PROGRAM_ADDRESS, STACK_RUNTIME_EXTENSIONS, SYSTEM_PROGRAM_ADDRESS, StreamGapError, SubscriptionRegistry, TOKEN_2022_PROGRAM_ADDRESS, TRANSACTION_RESOURCE_OPTION_KEYS, TransactionExecutionError, TransactionOptionsError, TransactionTransportError, account, appendFlowTransactions, appendTransactionInstructions, applyConnectedStackExtensions, arg, buildInstruction, bytes, canonicalQueryKey, chainAccountLoader, createChainClient, createEntityStream, createHostedSolanaGatewayTransports, createInstructionExecutor, createInstructionHandler, createPreparedFlow, createPreparedInstruction, createPreparedTransaction, createPreparedTransactionBody, createProgramPdas, createPublicKeySeed, createRichUpdateStream, createSeed, createSession, createSignerRegistry, createSubscriptionId, createTransactionTransport, createTypedListView, createTypedStateView, createTypedViews, createUpdateStream, decodeBase58, defineProgramExtensions, defineStackExtensions, deriveAssociatedTokenAccount, deriveHttpEndpoint, findProgramAddress as derivePda, describePreparedOperation, encodeBase58, executeInstruction, executePreparedOperation, extendProgram, extendPrograms, extendStack, findProgramAddress, findProgramAddressSync, flowOperation, formatPreparedOperation, formatProgramError, formatRawToUi, getMintDecimals, getOperationKind, getProgramRuntimeExtensions, getStackRuntimeExtensions, getTransactionFailureOutcome, hostedWebsocketSuffixes, inspectPreparedOperation, instructionOperation, isEntityFrame, isErrorFrame, isHostedAreteEndpoint, isReplayErrorCode, isSnapshotFrame, isSubscribedFrame, isUnsubscribedFrame, isValidFrame, literal, normalizeSubscription, normalizeSubscriptionQuery, normalizeSubscriptionRequest, normalizeTransactionError, parseFrame, parseFrameFromBlob, parseInstructionError, parseUiAmountToRaw, pda, prependFlowTransactionInstructions, prependTransactionInstructions, programAccountRead, programQuery, resolveAccounts, resolveAmount, resolveAmountToRaw, resolveAmountsToRaw, resolveTokenProgramAddress, resolveTransactionBuildOptions, safeToRawAmount, serializeInstructionData, serializeViewKey, setHostedWebsocketSuffixes, stackQuery, stringifyBigints, toJsonValue, toRawAmount, toWireResourceOptions, transactionOperation, unwrapOperationExecutionError, validateAccountResolution, validateProgramReadDescriptor, validateSubscriptionId, withProgramRead, withPrograms };
+export { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, Arete, AreteError, ConnectionManager, DEFAULT_CONFIG, DEFAULT_MAX_ENTRIES_PER_VIEW, FrameProcessor, InstructionError, MemoryAdapter, OPERATION_KIND, OperationCallbackError, OperationExecutionError, PROGRAM_OPERATION_EXTENSIONS, ProcessedSlotTimeoutError, QueryStore, ReadRequestError, SPL_TOKEN_PROGRAM_ADDRESS, STACK_RUNTIME_EXTENSIONS, SYSTEM_PROGRAM_ADDRESS, StreamGapError, SubscriptionRegistry, TOKEN_2022_PROGRAM_ADDRESS, TRANSACTION_RESOURCE_OPTION_KEYS, TransactionExecutionError, TransactionOptionsError, TransactionTransportError, account, appendFlowTransactions, appendTransactionInstructions, applyConnectedStackExtensions, arg, buildInstruction, bytes, canonicalQueryKey, chainAccountLoader, createChainClient, createEntityStream, createHostedSolanaGatewayTransports, createInstructionExecutor, createInstructionHandler, createPreparedFlow, createPreparedInstruction, createPreparedTransaction, createPreparedTransactionBody, createProgramPdas, createPublicKeySeed, createRichUpdateStream, createSeed, createSession, createSignerRegistry, createSubscriptionId, createTransactionTransport, createTypedListView, createTypedStateView, createTypedViews, createUpdateStream, decodeBase58, defineProgramExtensions, defineStackExtensions, deriveAssociatedTokenAccount, deriveHttpEndpoint, findProgramAddress as derivePda, describePreparedOperation, encodeBase58, executeInstruction, executePreparedOperation, extendProgram, extendPrograms, extendStack, findProgramAddress, findProgramAddressSync, flowOperation, formatPreparedOperation, formatProgramError, formatRawToUi, getMintDecimals, getOperationKind, getProgramRuntimeExtensions, getStackRuntimeExtensions, getTransactionFailureOutcome, hostedWebsocketSuffixes, inspectPreparedOperation, instructionOperation, isEntityFrame, isErrorFrame, isHostedAreteEndpoint, isReplayErrorCode, isSnapshotFrame, isStackVersionRefusalCode, isSubscribedFrame, isUnsubscribedFrame, isValidFrame, literal, normalizeSubscription, normalizeSubscriptionQuery, normalizeSubscriptionRequest, normalizeTransactionError, parseFrame, parseFrameFromBlob, parseInstructionError, parseUiAmountToRaw, pda, prependFlowTransactionInstructions, prependTransactionInstructions, programAccountRead, programQuery, resolveAccounts, resolveAmount, resolveAmountToRaw, resolveAmountsToRaw, resolveTokenProgramAddress, resolveTransactionBuildOptions, safeToRawAmount, serializeInstructionData, serializeViewKey, setHostedWebsocketSuffixes, stackQuery, stringifyBigints, toJsonValue, toRawAmount, toWireResourceOptions, transactionOperation, unwrapOperationExecutionError, validateAccountResolution, validateProgramReadDescriptor, validateSubscriptionId, withProgramRead, withPrograms };
 //# sourceMappingURL=index.esm.js.map