@usearete/sdk 0.1.5 → 0.2.0

package/dist/index.d.ts

@@ -1,16 +1,99 @@
+/**
+ * Wallet adapter boundary for the Arete SDK.
+ *
+ * The core SDK is intentionally RPC-free: it only constructs `BuiltInstruction`
+ * objects. Everything network-related (recent blockhash, message compilation,
+ * signing, sending, and confirmation) lives behind the `WalletAdapter`
+ * boundary, implemented by adapters that wrap the Solana library of your choice
+ * (@solana/web3.js, @solana/kit, a raw Keypair signer for scripts, etc.).
+ */
+/**
+ * A single account reference within a built instruction.
+ */
+interface BuiltAccountMeta {
+    /** Account address as a base58-encoded string */
+    pubkey: string;
+    /** Whether this account must sign the transaction */
+    isSigner: boolean;
+    /** Whether this account is writable */
+    isWritable: boolean;
+}
+/**
+ * A framework-agnostic representation of a Solana instruction.
+ *
+ * This is the boundary type between the core SDK (which builds instructions)
+ * and wallet adapters (which broadcast them). It maps 1:1 onto a
+ * @solana/web3.js `TransactionInstruction` or a @solana/kit `Instruction`.
+ */
+interface BuiltInstruction {
+    /** Program ID (base58) */
+    programId: string;
+    /** Account keys, in the exact order required by the program */
+    keys: BuiltAccountMeta[];
+    /** Serialized instruction data (discriminator + Borsh-encoded args) */
+    data: Uint8Array;
+}
+/**
+ * Confirmation level for transaction processing.
+ * - `processed`: Transaction processed but not confirmed
+ * - `confirmed`: Transaction confirmed by cluster
+ * - `finalized`: Transaction finalized (recommended for production)
+ */
+type ConfirmationLevel = 'processed' | 'confirmed' | 'finalized';
+/**
+ * Options forwarded to the wallet adapter when sending a transaction.
+ *
+ * The core SDK does not interpret these; it passes them straight through to
+ * the adapter, which owns all RPC semantics.
+ */
+interface SendOptions {
+    /** Confirmation level the adapter should wait for */
+    confirmationLevel?: ConfirmationLevel;
+    /** Skip the RPC preflight simulation */
+    skipPreflight?: boolean;
+    /**
+     * Optional extra local signers for this send.
+     *
+     * The concrete signer type depends on the wallet adapter implementation
+     * (for example `@solana/web3.js` Signers or `@solana/kit` TransactionSigners).
+     */
+    signers?: readonly unknown[];
+    /** Adapter-specific passthrough options (priority fees, lookup tables, etc.) */
+    [key: string]: unknown;
+}
+/**
+ * Result returned by a wallet adapter after broadcasting a transaction.
+ */
+interface SendResult {
+    /** Transaction signature (base58) */
+    signature: string;
+    /** Slot in which the transaction landed, if the adapter reports it */
+    slot?: number;
+}
 /**
  * Wallet adapter interface for signing and sending transactions.
- * This is framework-agnostic and can be implemented by any wallet provider.
+ *
+ * Implementations own blockhash fetching, message compilation (legacy or v0),
+ * signing, sending, and confirmation. The core SDK only needs `publicKey` for
+ * signer-account resolution and `signAndSend` to broadcast built instructions.
  */
 interface WalletAdapter {
     /** The wallet's public key as a base58-encoded string */
     publicKey: string;
+    /** Signer addresses the adapter can satisfy without per-send signers. */
+    readonly signerAddresses?: readonly string[];
     /**
-     * Sign and send a transaction.
-     * @param transaction - The transaction to sign and send (can be raw bytes, a Transaction object, or an array of instructions)
-     * @returns The transaction signature
+     * Compile, sign, and broadcast one or more built instructions as a single
+     * transaction.
+     *
+     * Accepting an array (rather than a single instruction) makes batching and
+     * composition fall out for free.
+     *
+     * @param instructions - Instructions to include in the transaction, in order
+     * @param options - Adapter-specific send/confirmation options
+     * @returns The transaction signature (and slot, if known)
      */
-    signAndSend: (transaction: unknown) => Promise<string>;
+    signAndSend(instructions: readonly BuiltInstruction[], options?: SendOptions): Promise<SendResult>;
 }
 /**
  * Wallet connection state
@@ -68,9 +151,13 @@ interface PdaConfig {
 type PdaSeed = {
     type: 'literal';
     value: string;
+} | {
+    type: 'bytes';
+    value: number[];
 } | {
     type: 'argRef';
     argName: string;
+    argType?: string;
 } | {
     type: 'accountRef';
     accountName: string;
@@ -101,8 +188,10 @@ interface AccountResolutionResult {
  * Options for account resolution.
  */
 interface AccountResolutionOptions {
-    /** User-provided account addresses */
+    /** Explicit account-address overrides, including signer slots when needed */
     accounts?: Record<string, string>;
+    /** Helper-only PDA seed inputs */
+    resolve?: Record<string, unknown>;
     /** Wallet adapter for signer accounts */
     wallet?: WalletAdapter;
     /** Program ID for PDA derivation (required if any PDAs exist) */
@@ -194,13 +283,42 @@ interface ArgSchema {
 }
 /**
  * Supported argument types for Borsh serialization.
+ *
+ * Struct and enum schemas are fully inlined (field names and types travel
+ * with the schema), so the serializer needs no runtime type registry.
  */
-type ArgType = 'u8' | 'u16' | 'u32' | 'u64' | 'u128' | 'i8' | 'i16' | 'i32' | 'i64' | 'i128' | 'bool' | 'string' | 'pubkey' | {
+type ArgType = 'u8' | 'u16' | 'u32' | 'u64' | 'u128' | 'i8' | 'i16' | 'i32' | 'i64' | 'i128' | 'f32' | 'f64' | 'bool' | 'string' | 'pubkey' | 'bytes' | {
     vec: ArgType;
 } | {
     option: ArgType;
 } | {
-    array: [ArgType, number];
+    array: readonly [ArgType, number];
+} | {
+    hashMap: readonly [ArgType, ArgType];
+} | {
+    struct: readonly ArgStructField[];
+} | {
+    enum: readonly EnumVariant[];
+};
+/** One field of a struct schema, in declaration (serialization) order. */
+interface ArgStructField {
+    readonly name: string;
+    readonly type: ArgType;
+}
+/**
+ * One enum variant: a bare string for fieldless variants, or a named variant
+ * carrying struct fields / tuple elements.
+ *
+ * Values: fieldless variants are passed as the variant name (or its index);
+ * data-carrying variants as a single-key object, e.g. `{ transfer: { amount } }`
+ * or `{ pair: [1, 2] }`.
+ */
+type EnumVariant = string | {
+    readonly name: string;
+    readonly fields: readonly ArgStructField[];
+} | {
+    readonly name: string;
+    readonly tuple: readonly ArgType[];
 };
 /**
  * Serializes instruction arguments into a Buffer using Borsh encoding.
@@ -212,57 +330,6 @@ type ArgType = 'u8' | 'u16' | 'u32' | 'u64' | 'u128' | 'i8' | 'i16' | 'i32' | 'i
  */
 declare function serializeInstructionData(discriminator: Uint8Array, args: Record<string, unknown>, schema: ArgSchema[]): Buffer;
 
-/**
- * Confirmation level for transaction processing.
- * - `processed`: Transaction processed but not confirmed
- * - `confirmed`: Transaction confirmed by cluster
- * - `finalized`: Transaction finalized (recommended for production)
- */
-type ConfirmationLevel = 'processed' | 'confirmed' | 'finalized';
-/**
- * Options for executing an instruction.
- */
-interface ExecuteOptions {
-    /** Wallet adapter for signing */
-    wallet?: WalletAdapter;
-    /** User-provided account addresses */
-    accounts?: Record<string, string>;
-    /** Confirmation level to wait for */
-    confirmationLevel?: ConfirmationLevel;
-    /** Maximum time to wait for confirmation (ms) */
-    timeout?: number;
-    /** Refresh view after transaction completes */
-    refresh?: {
-        view: string;
-        key?: string;
-    }[];
-}
-/**
- * Result of a successful instruction execution.
- */
-interface ExecutionResult {
-    /** Transaction signature */
-    signature: string;
-    /** Confirmation level achieved */
-    confirmationLevel: ConfirmationLevel;
-    /** Slot when transaction was processed */
-    slot: number;
-    /** Error code if transaction failed */
-    error?: string;
-}
-/**
- * Waits for transaction confirmation.
- *
- * @param signature - Transaction signature
- * @param level - Desired confirmation level
- * @param timeout - Maximum wait time in milliseconds
- * @returns Confirmation result
- */
-declare function waitForConfirmation(signature: string, level?: ConfirmationLevel, timeout?: number): Promise<{
-    level: ConfirmationLevel;
-    slot: number;
-}>;
-
 /**
  * Parses and handles instruction errors.
  */
@@ -300,87 +367,139 @@ declare function parseInstructionError(error: unknown, errorMetadata: ErrorMetad
  * @returns Human-readable error message
  */
 declare function formatProgramError(error: ProgramError): string;
+/**
+ * Error thrown when an instruction fails to send and the underlying failure
+ * could be parsed against the handler's IDL error definitions.
+ */
+declare class InstructionError extends Error {
+    /** Parsed program error, if the failure matched a known error code. */
+    readonly programError: ProgramError | null;
+    /** The original underlying error from the wallet adapter / RPC. */
+    readonly cause: unknown;
+    constructor(message: string, programError: ProgramError | null, cause: unknown);
+}
 
 /**
- * Resolved accounts map passed to the instruction builder.
+ * Resolved accounts map passed to a handler's build function.
  * Keys are account names, values are base58 addresses.
  */
 type ResolvedAccounts = Record<string, string>;
+
 /**
- * The instruction object returned by the handler's build function.
- * This is a framework-agnostic representation that can be converted
- * to @solana/web3.js TransactionInstruction.
+ * Instruction handler consumed by the core executor.
+ *
+ * Handlers are normally produced by {@link createInstructionHandler} (either
+ * hand-written or code-generated), so `build` is implemented generically and
+ * callers never deal with serialization directly.
+ *
+ * The phantom `_params` / `_error` fields carry compile-time type information
+ * for the typed client surface; they are never populated at runtime.
  */
-interface BuiltInstruction {
-    /** Program ID (base58) */
+interface InstructionHandler<TParams = Record<string, unknown>, TError = unknown> {
+    /** Program ID for this instruction (base58). Used for PDA derivation. */
+    programId?: string;
+    /** Ordered account metadata used by the core SDK for resolution. */
+    accounts: AccountMeta[];
+    /** Error definitions used for error parsing. */
+    errors: ErrorMetadata[];
+    /**
+     * Names of the instruction's serialized arguments. Everything in the merged
+     * params object that is NOT in this list is treated as a user-provided
+     * account address override.
+     */
+    argNames: string[];
+    /**
+     * Build the instruction from already-resolved, ordered accounts.
+     * Implemented by {@link createInstructionHandler}.
+     */
+    build(args: Record<string, unknown>, resolved: ResolvedAccount[]): BuiltInstruction;
+    /** Phantom: merged params type (args + user-provided accounts). */
+    readonly _params?: TParams;
+    /** Phantom: typed error union. */
+    readonly _error?: TError;
+}
+/**
+ * Configuration accepted by {@link createInstructionHandler}.
+ */
+interface InstructionHandlerConfig {
+    /** Program ID (base58). */
     programId: string;
-    /** Account keys in order */
-    keys: Array<{
-        pubkey: string;
-        isSigner: boolean;
-        isWritable: boolean;
-    }>;
-    /** Serialized instruction data */
-    data: Uint8Array;
+    /** Instruction discriminator bytes (8 for Anchor, 1 for Steel, etc.). */
+    discriminator: Uint8Array | number[];
+    /** Ordered account metadata. */
+    accounts: AccountMeta[];
+    /** Ordered argument schema for Borsh serialization. */
+    args: ArgSchema[];
+    /** Error definitions from the IDL. */
+    errors?: ErrorMetadata[];
 }
 /**
- * Instruction handler from the generated stack SDK.
- * The build() function is generated code that handles serialization.
+ * Creates a data-driven instruction handler.
+ *
+ * The returned handler implements `build()` generically: it serializes args
+ * via the schema-driven serializer and constructs the account key list from
+ * the resolved, ordered accounts. No imperative per-instruction code is
+ * required, which keeps generated SDKs tiny and puts all serialization logic
+ * in one tested place.
+ */
+declare function createInstructionHandler<TParams = Record<string, unknown>, TError = unknown>(config: InstructionHandlerConfig): InstructionHandler<TParams, TError>;
+/**
+ * Options for building an instruction (no network access).
  */
-interface InstructionHandler {
+interface BuildOptions {
+    /** Wallet, used only for `publicKey` to resolve signer accounts. */
+    wallet?: WalletAdapter;
+    /** Explicit account-address overrides, including signer slots when needed. */
+    accounts?: Record<string, string>;
     /**
-     * Build the instruction with resolved accounts.
-     * This is generated code - serialization logic lives here.
+     * Extra account metas appended after the instruction's declared accounts
+     * (Anchor's `remainingAccounts`) — for routers, transfer hooks, and other
+     * composition patterns the IDL cannot express.
      */
-    build(args: Record<string, unknown>, accounts: ResolvedAccounts): BuiltInstruction;
-    /** Account metadata - used by core SDK for resolution */
-    accounts: AccountMeta[];
-    /** Error definitions - used by core SDK for error parsing */
-    errors: ErrorMetadata[];
-    /** Program ID for this instruction (used for PDA derivation) */
-    programId?: string;
+    remainingAccounts?: BuiltAccountMeta[];
 }
 /**
- * @deprecated Use InstructionHandler instead. Will be removed in next major version.
- * Legacy instruction definition for backwards compatibility.
+ * Options for executing (building + sending) an instruction.
  */
-interface InstructionDefinition {
-    /** Instruction name */
-    name: string;
-    /** Program ID (base58) */
-    programId: string;
-    /** 8-byte discriminator */
-    discriminator: Uint8Array;
-    /** Account metadata */
-    accounts: AccountMeta[];
-    /** Argument schema for serialization */
-    argsSchema: ArgSchema[];
-    /** Error definitions */
-    errors: ErrorMetadata[];
+interface ExecuteOptions extends BuildOptions {
+    /** Wallet adapter that signs and broadcasts the transaction. */
+    wallet?: WalletAdapter;
+    /** Confirmation level forwarded to the adapter. */
+    confirmationLevel?: ConfirmationLevel;
+    /** Additional options forwarded verbatim to the wallet adapter. */
+    send?: SendOptions;
 }
 /**
- * Executes an instruction handler with the given arguments and options.
+ * Result of a successful instruction execution.
+ */
+interface ExecutionResult {
+    /** Transaction signature. */
+    signature: string;
+    /** Slot in which the transaction landed, if the adapter reports it. */
+    slot?: number;
+}
+/**
+ * Builds a {@link BuiltInstruction} from a handler and a merged params object.
  *
- * 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
+ * This is a pure function: it performs no network access. It is the unit of
+ * composition for batching (`wallet.signAndSend([a, b, c])`).
+ */
+declare function buildInstruction(handler: InstructionHandler<any, any>, params: Record<string, unknown>, options?: BuildOptions): BuiltInstruction;
+/**
+ * Builds, signs, and sends an instruction via the wallet adapter.
  *
- * @param handler - Instruction handler from generated SDK
- * @param args - Instruction arguments
- * @param options - Execution options
- * @returns Execution result with signature
+ * The core SDK does not touch RPC: the adapter owns blockhash, compilation,
+ * signing, sending, and confirmation. On failure, program errors are parsed
+ * against the handler's IDL error definitions and surfaced as an
+ * {@link InstructionError}.
  */
-declare function executeInstruction(handler: InstructionHandler, args: Record<string, unknown>, options?: ExecuteOptions): Promise<ExecutionResult>;
+declare function executeInstruction(handler: InstructionHandler<any, any>, params: Record<string, unknown>, options?: ExecuteOptions): Promise<ExecutionResult>;
 /**
  * Creates an instruction executor bound to a specific wallet.
- *
- * @param wallet - Wallet adapter
- * @returns Bound executor function
  */
 declare function createInstructionExecutor(wallet: WalletAdapter): {
-    execute: (handler: InstructionHandler, args: Record<string, unknown>, options?: Omit<ExecuteOptions, "wallet">) => Promise<ExecutionResult>;
+    execute: (handler: InstructionHandler, params: Record<string, unknown>, options?: Omit<ExecuteOptions, "wallet">) => Promise<ExecutionResult>;
+    build: (handler: InstructionHandler, params: Record<string, unknown>, options?: Omit<BuildOptions, "wallet">) => BuiltInstruction;
 };
 
 type SeedDef = {
@@ -400,6 +519,7 @@ type SeedDef = {
 interface PdaDeriveContext {
     accounts?: Record<string, string>;
     args?: Record<string, unknown>;
+    resolve?: Record<string, unknown>;
     programId?: string;
 }
 interface PdaFactory {
@@ -450,12 +570,54 @@ interface ViewDef<T, TMode extends 'state' | 'list'> {
     readonly view: string;
     readonly _entity?: T;
 }
+interface StackEndpoints {
+    readonly ws: string;
+    readonly http?: string;
+}
+type ReadTransportMethod = 'GET' | 'POST';
+interface ProgramAccountReadDefinition<T> {
+    readonly account: string;
+    readonly path: string;
+    readonly schema?: Schema<T>;
+    readonly _result?: T;
+}
+interface ProgramQueryDefinition<TParams = unknown, TResult = unknown> {
+    readonly name: string;
+    readonly path: string;
+    readonly method?: ReadTransportMethod;
+    readonly schema?: Schema<TResult>;
+    readonly _params?: TParams;
+    readonly _result?: TResult;
+}
+interface StackQueryDefinition<TParams = unknown, TResult = unknown> {
+    readonly name: string;
+    readonly path: string;
+    readonly method?: ReadTransportMethod;
+    readonly schema?: Schema<TResult>;
+    readonly _params?: TParams;
+    readonly _result?: TResult;
+}
+interface ProgramSdkDefinition {
+    readonly name: string;
+    readonly programId?: string;
+    readonly schemas?: Record<string, Schema<unknown>>;
+    readonly pdas?: Record<string, unknown>;
+    readonly accounts?: Record<string, ProgramAccountReadDefinition<unknown>>;
+    readonly queries?: Record<string, ProgramQueryDefinition<unknown, unknown>>;
+    readonly rawInstructions?: Record<string, InstructionHandler<any, any>>;
+    readonly addresses?: Record<string, unknown>;
+    readonly constants?: unknown;
+    readonly defaults?: unknown;
+    readonly math?: unknown;
+}
 interface StackDefinition {
     readonly name: string;
-    readonly url: string;
+    readonly endpoints: StackEndpoints;
     readonly views: Record<string, ViewGroup>;
     readonly schemas?: Record<string, Schema<unknown>>;
-    instructions?: Record<string, InstructionHandler>;
+    readonly patchSchemas?: Record<string, Schema<unknown>>;
+    readonly queries?: Record<string, StackQueryDefinition<unknown, unknown>>;
+    readonly programs?: Record<string, ProgramSdkDefinition>;
 }
 interface ViewGroup {
     state?: ViewDef<unknown, 'state'>;
@@ -535,7 +697,8 @@ interface AuthConfig {
     tokenEndpointCredentials?: RequestCredentials;
 }
 interface AreteConfig {
-    websocketUrl?: string;
+    /** WebSocket endpoint. `null`/omitted disables the WebSocket transport (HTTP-only mode). */
+    websocketUrl?: string | null;
     reconnectIntervals?: number[];
     maxReconnectAttempts?: number;
     initialSubscriptions?: Subscription[];
@@ -673,8 +836,11 @@ declare class ConnectionManager {
     private handleSocketIssueMessage;
     private rotateConnectionForTokenRefresh;
     private buildAuthUrl;
+    private requireWebsocketUrl;
     private createWebSocket;
     getState(): ConnectionState;
+    getHttpAuthToken(forceRefresh?: boolean): Promise<string | undefined>;
+    clearHttpAuthToken(): void;
     onFrame(handler: FrameHandler): () => void;
     onStateChange(handler: ConnectionStateCallback): () => void;
     onSocketIssue(handler: SocketIssueCallback): () => void;
@@ -696,7 +862,7 @@ declare class ConnectionManager {
 }
 
 type UpdateCallback<T = unknown> = (viewPath: string, key: string, update: Update<T>) => void;
-type RichUpdateCallback$1<T = unknown> = (viewPath: string, key: string, update: RichUpdate<T>) => void;
+type RichUpdateCallback<T = unknown> = (viewPath: string, key: string, update: RichUpdate<T>) => void;
 interface StorageAdapterConfig {
     maxEntriesPerView?: number | null;
 }
@@ -722,7 +888,7 @@ interface StorageAdapter {
     setViewConfig?(viewPath: string, config: ViewSortConfig): void;
     getViewConfig?(viewPath: string): ViewSortConfig | undefined;
     onUpdate(callback: UpdateCallback): () => void;
-    onRichUpdate(callback: RichUpdateCallback$1): () => void;
+    onRichUpdate(callback: RichUpdateCallback): () => void;
     notifyUpdate<T>(viewPath: string, key: string, update: Update<T>): void;
     notifyRichUpdate<T>(viewPath: string, key: string, update: RichUpdate<T>): void;
 }
@@ -739,8 +905,367 @@ declare class SubscriptionRegistry {
     private makeSubKey;
 }
 
-interface ConnectOptions {
+interface ChainClock {
+    slot: number;
+    epoch?: number;
+    leaderScheduleEpoch?: number;
+    unixTimestamp: number;
+}
+interface MintAccountInfo {
+    address: string;
+    ownerProgram: string;
+    decimals: number | null;
+    supply: string | null;
+    mintAuthority: string | null;
+    freezeAuthority: string | null;
+}
+interface TokenAccountInfo {
+    address: string;
+    ownerProgram: string;
+    mint: string | null;
+    owner: string | null;
+    amount: string | null;
+    uiAmountString: string | null;
+}
+interface TokenBalanceInfo {
+    exists: boolean;
+    address: string | null;
+    owner: string;
+    mint: string;
+    tokenProgram?: string;
+    amount: string;
+    decimals?: number | null;
+    uiAmountString?: string | null;
+}
+interface RawAccountInfo {
+    address: string;
+    ownerProgram: string;
+    lamports: number;
+    executable: boolean;
+    data: Uint8Array;
+}
+interface ChainClient {
+    exists(address: string): Promise<boolean>;
+    lamports(address: string): Promise<number>;
+    minimumBalanceForRentExemption(space: number): Promise<number>;
+    clock(): Promise<ChainClock>;
+    account(address: string): Promise<RawAccountInfo | null>;
+    mint(address: string): Promise<MintAccountInfo | null>;
+    tokenAccount(address: string): Promise<TokenAccountInfo | null>;
+    balance(input: {
+        owner: string;
+        mint: string;
+        tokenProgram?: string;
+    }): Promise<TokenBalanceInfo>;
+}
+type FetchLike = typeof fetch;
+declare function deriveHttpEndpoint(wsUrl: string): string;
+declare function createChainClient(httpBaseUrl: string, fetchImpl: FetchLike): ChainClient;
+
+interface SignerRegistry<TSigner = unknown> {
+    register(address: string, signer: TSigner): void;
+    unregister(address: string): boolean;
+    get(address: string): TSigner | undefined;
+    has(address: string): boolean;
+    addresses(): readonly string[];
+    values(): readonly TSigner[];
+    entries(): readonly (readonly [string, TSigner])[];
+    clear(): void;
+}
+declare function createSignerRegistry<TSigner = unknown>(entries?: Iterable<readonly [string, TSigner]>): SignerRegistry<TSigner>;
+
+type OperationKind = 'instruction' | 'transaction' | 'flow';
+type NonEmptyReadonlyArray<T> = readonly [T, ...T[]];
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonObject | readonly JsonValue[];
+interface JsonObject {
+    readonly [key: string]: JsonValue;
+}
+interface PreparedOperationDescription {
+    readonly kind: OperationKind;
+    readonly name: string;
+    readonly artifacts: JsonValue;
+    readonly transactions: readonly {
+        readonly name: string;
+        readonly requiredSignerAddresses: readonly string[];
+        readonly errors: readonly ErrorMetadata[];
+        readonly instructions: readonly {
+            readonly programId: string;
+            readonly keys: readonly {
+                readonly pubkey: string;
+                readonly isSigner: boolean;
+                readonly isWritable: boolean;
+            }[];
+            readonly data: readonly number[];
+        }[];
+    }[];
+}
+interface PreparedTransactionBody {
+    readonly name: string;
+    readonly instructions: NonEmptyReadonlyArray<BuiltInstruction>;
+    readonly requiredSignerAddresses: readonly string[];
+    readonly errors: readonly ErrorMetadata[];
+}
+interface OperationPlan<TArtifacts = void> {
+    readonly name: string;
+    readonly artifacts: TArtifacts;
+    readonly transactions: NonEmptyReadonlyArray<PreparedTransactionBody>;
+}
+interface PreparedOperationBase<TKind extends OperationKind, TArtifacts> {
+    readonly kind: TKind;
+    readonly name: string;
+    readonly plan: OperationPlan<TArtifacts>;
+    readonly artifacts: TArtifacts;
+}
+interface PreparedInstruction<TArtifacts = void> extends PreparedOperationBase<'instruction', TArtifacts> {
+    readonly instruction: BuiltInstruction;
+    readonly transaction: PreparedTransactionBody;
+}
+interface PreparedTransaction<TArtifacts = void> extends PreparedOperationBase<'transaction', TArtifacts> {
+    readonly transaction: PreparedTransactionBody;
+}
+interface PreparedFlow<TArtifacts = void> extends PreparedOperationBase<'flow', TArtifacts> {
+}
+type PreparedOperation<TArtifacts = unknown> = PreparedInstruction<TArtifacts> | PreparedTransaction<TArtifacts> | PreparedFlow<TArtifacts>;
+interface CreatePreparedInstructionInput<TArtifacts> {
+    name: string;
+    instruction: BuiltInstruction;
+    artifacts: TArtifacts;
+    requiredSignerAddresses?: readonly string[];
+    errors?: readonly ErrorMetadata[];
+}
+type PreparedTransactionInstruction = BuiltInstruction | PreparedInstruction<unknown>;
+type PreparedTransactionOperation = PreparedInstruction<unknown> | PreparedTransaction<unknown>;
+interface CreatePreparedTransactionBaseInput<TArtifacts> {
+    name: string;
+    artifacts: TArtifacts;
+    requiredSignerAddresses?: readonly string[];
+    errors?: readonly ErrorMetadata[];
+}
+type CreatePreparedTransactionInput<TArtifacts> = CreatePreparedTransactionBaseInput<TArtifacts> & ({
+    instructions: readonly PreparedTransactionInstruction[];
+    operations?: never;
+} | {
+    operations: readonly PreparedTransactionOperation[];
+    instructions?: never;
+});
+interface CreatePreparedFlowInput<TArtifacts> {
+    name: string;
+    transactions: readonly PreparedTransactionBody[];
+    artifacts: TArtifacts;
+}
+declare function createPreparedTransactionBody(input: {
+    name: string;
+    instructions: readonly BuiltInstruction[];
+    requiredSignerAddresses?: readonly string[];
+    errors?: readonly ErrorMetadata[];
+}): PreparedTransactionBody;
+declare function createPreparedInstruction<TArtifacts>(input: CreatePreparedInstructionInput<TArtifacts>): PreparedInstruction<TArtifacts>;
+declare function createPreparedTransaction<TArtifacts>(input: CreatePreparedTransactionInput<TArtifacts>): PreparedTransaction<TArtifacts>;
+declare function createPreparedFlow<TArtifacts>(input: CreatePreparedFlowInput<TArtifacts>): PreparedFlow<TArtifacts>;
+declare function prependTransactionInstructions(transaction: PreparedTransactionBody, instructions: readonly BuiltInstruction[]): PreparedTransactionBody;
+declare function appendTransactionInstructions(transaction: PreparedTransactionBody, instructions: readonly BuiltInstruction[]): PreparedTransactionBody;
+declare function appendFlowTransactions<TArtifacts>(flow: PreparedFlow<TArtifacts>, transactions: readonly PreparedTransactionBody[]): PreparedFlow<TArtifacts>;
+declare function prependFlowTransactionInstructions<TArtifacts>(flow: PreparedFlow<TArtifacts>, transactionIndex: number, instructions: readonly BuiltInstruction[]): PreparedFlow<TArtifacts>;
+interface OperationTransactionReceipt {
+    readonly transactionIndex: number;
+    readonly transactionName: string;
+    readonly signature: string;
+    readonly slot?: number;
+}
+interface SingleTransactionOperationReceipt<TArtifacts> {
+    readonly kind: 'instruction' | 'transaction';
+    readonly operationName: string;
+    readonly artifacts: TArtifacts;
+    readonly signatures: NonEmptyReadonlyArray<string>;
+    readonly transaction: OperationTransactionReceipt;
+}
+interface FlowOperationReceipt<TArtifacts> {
+    readonly kind: 'flow';
+    readonly operationName: string;
+    readonly artifacts: TArtifacts;
+    readonly signatures: NonEmptyReadonlyArray<string>;
+    readonly transactions: NonEmptyReadonlyArray<OperationTransactionReceipt>;
+}
+type OperationReceiptFor<TPrepared extends PreparedOperation> = TPrepared extends PreparedFlow<infer TArtifacts> ? FlowOperationReceipt<TArtifacts> : TPrepared extends PreparedInstruction<infer TArtifacts> ? SingleTransactionOperationReceipt<TArtifacts> : TPrepared extends PreparedTransaction<infer TArtifacts> ? SingleTransactionOperationReceipt<TArtifacts> : never;
+interface OperationExecutionEvent<TPrepared extends PreparedOperation = PreparedOperation> {
+    readonly operation: TPrepared;
+    readonly transaction: PreparedTransactionBody;
+    readonly transactionIndex: number;
+}
+interface OperationExecutionSuccessEvent<TPrepared extends PreparedOperation = PreparedOperation> extends OperationExecutionEvent<TPrepared> {
+    readonly receipt: OperationTransactionReceipt;
+}
+interface OperationExecutionOptions<TSigner = unknown, TPrepared extends PreparedOperation = PreparedOperation> {
+    wallet?: WalletAdapter;
+    send?: SendOptions;
+    signers?: readonly TSigner[];
+    signerRegistry?: SignerRegistry<TSigner>;
+    availableSignerAddresses?: readonly string[];
+    onTransactionStart?: (event: OperationExecutionEvent<TPrepared>) => void | Promise<void>;
+    onTransactionSuccess?: (event: OperationExecutionSuccessEvent<TPrepared>) => void | Promise<void>;
+}
+interface OperationExecutionHost<TSigner = unknown> {
+    readonly wallet?: WalletAdapter;
+    readonly publicKey?: string;
+    transaction(instructions: readonly BuiltInstruction[], options?: {
+        wallet?: WalletAdapter;
+        send?: SendOptions;
+        errors?: ErrorMetadata[];
+        signers?: readonly TSigner[];
+    }): Promise<{
+        signature: string;
+        slot?: number;
+    }>;
+}
+declare class OperationExecutionError<TPrepared extends PreparedOperation = PreparedOperation> extends Error {
+    readonly operation: TPrepared;
+    readonly failedTransaction: PreparedTransactionBody;
+    readonly failedTransactionIndex: number;
+    readonly completedReceipts: readonly OperationTransactionReceipt[];
+    readonly cause: unknown;
+    constructor(input: {
+        operation: TPrepared;
+        failedTransaction: PreparedTransactionBody;
+        failedTransactionIndex: number;
+        completedReceipts: readonly OperationTransactionReceipt[];
+        cause: unknown;
+    });
+}
+declare function executePreparedOperation<TPrepared extends PreparedOperation, TSigner = unknown>(host: OperationExecutionHost<TSigner>, operation: TPrepared, options?: OperationExecutionOptions<TSigner, TPrepared>): Promise<OperationReceiptFor<TPrepared>>;
+declare function toJsonValue(value: unknown): JsonValue;
+declare function describePreparedOperation(operation: PreparedOperation): PreparedOperationDescription;
+declare function formatPreparedOperation(operation: PreparedOperation): string;
+
+interface InstructionOperation<TInput = unknown, TArtifacts = void> {
+    readonly kind: 'instruction';
+    prepare(input: TInput): Promise<PreparedInstruction<TArtifacts>>;
+}
+interface TransactionOperation<TInput = unknown, TArtifacts = void> {
+    readonly kind: 'transaction';
+    prepare(input: TInput): Promise<PreparedTransaction<TArtifacts>>;
+}
+interface FlowOperation<TInput = unknown, TArtifacts = void> {
+    readonly kind: 'flow';
+    prepare(input: TInput): Promise<PreparedFlow<TArtifacts>>;
+}
+type AnyOperation = InstructionOperation<any, any> | TransactionOperation<any, any> | FlowOperation<any, any>;
+type OperationNamespace<TOperation extends AnyOperation = AnyOperation> = {
+    readonly [key: string]: TOperation | OperationNamespace<TOperation>;
+};
+type InstructionOperationNamespace = OperationNamespace<InstructionOperation<any, any>>;
+type TransactionOperationNamespace = OperationNamespace<TransactionOperation<any, any>>;
+type FlowOperationNamespace = OperationNamespace<FlowOperation<any, any>>;
+type MaybePromise<T> = T | Promise<T>;
+declare function instructionOperation<TInput, TArtifacts>(prepare: (input: TInput) => MaybePromise<PreparedInstruction<TArtifacts>>): InstructionOperation<TInput, TArtifacts>;
+declare function transactionOperation<TInput, TArtifacts>(prepare: (input: TInput) => MaybePromise<PreparedTransaction<TArtifacts>>): TransactionOperation<TInput, TArtifacts>;
+declare function flowOperation<TInput, TArtifacts>(prepare: (input: TInput) => MaybePromise<PreparedFlow<TArtifacts>>): FlowOperation<TInput, TArtifacts>;
+
+declare const STACK_RUNTIME_EXTENSIONS: "__areteStackRuntimeExtensions";
+declare const PROGRAM_OPERATION_EXTENSIONS: "__areteProgramOperationExtensions";
+type EmptyRecord = Record<string, never>;
+type MaybeField<TKey extends string, TValue> = [TValue] extends [never] ? {} : {
+    readonly [K in TKey]: TValue;
+};
+type Field<TValue, TKey extends PropertyKey> = TKey extends keyof TValue ? TValue[TKey] : never;
+type DeepMerge<TBase, TExtension> = TBase extends Record<string, unknown> ? TExtension extends Record<string, unknown> ? Omit<TBase, keyof TExtension> & {
+    readonly [K in keyof TExtension]: K extends keyof TBase ? DeepMerge<TBase[K], TExtension[K]> : TExtension[K];
+} : TExtension : TExtension;
+type MergeField<TBase, TExtension> = [TBase] extends [never] ? TExtension : [TExtension] extends [never] ? TBase : DeepMerge<TBase, TExtension>;
+type FactoryReturn<TValue, TKey extends PropertyKey> = TKey extends keyof TValue ? NonNullable<TValue[TKey]> extends (...args: any[]) => infer TResult ? TResult : never : never;
+interface ProgramOperations<TInstructions extends InstructionOperationNamespace | EmptyRecord = EmptyRecord, TTransactions extends TransactionOperationNamespace | EmptyRecord = EmptyRecord, TFlows extends FlowOperationNamespace | EmptyRecord = EmptyRecord> {
+    readonly instructions?: TInstructions;
+    readonly transactions?: TTransactions;
+    readonly flows?: TFlows;
+}
+type AnyProgramOperations = ProgramOperations<InstructionOperationNamespace, TransactionOperationNamespace, FlowOperationNamespace>;
+type InstructionOperationsOf<TOperations> = TOperations extends ProgramOperations<infer TInstructions, any, any> ? TInstructions : EmptyRecord;
+type TransactionOperationsOf<TOperations> = TOperations extends ProgramOperations<any, infer TTransactions, any> ? TTransactions : EmptyRecord;
+type FlowOperationsOf<TOperations> = TOperations extends ProgramOperations<any, any, infer TFlows> ? TFlows : EmptyRecord;
+interface ProgramOperationContext<TProgram extends ProgramSdkDefinition = ProgramSdkDefinition> {
+    readonly chain: ChainClient;
+    readonly wallet: WalletAdapter | undefined;
+    readonly program: ProgramInterface<TProgram>;
+}
+interface ProgramRuntimeExtensions<TOperations extends AnyProgramOperations = ProgramOperations, TProgram extends ProgramSdkDefinition = ProgramSdkDefinition> {
+    readonly createOperations: (context: ProgramOperationContext<TProgram>) => TOperations;
+}
+interface ProgramRuntimeExtensionCarrier<TOperations extends AnyProgramOperations = ProgramOperations> {
+    readonly [PROGRAM_OPERATION_EXTENSIONS]?: ProgramRuntimeExtensions<TOperations, any>;
+}
+type ProgramOperationsOf<TProgram> = TProgram extends ProgramRuntimeExtensionCarrier<infer TOperations> ? TOperations : ProgramOperations;
+type MergeProgramOperations<TBase extends AnyProgramOperations, TExtension extends AnyProgramOperations> = ProgramOperations<Extract<MergeField<InstructionOperationsOf<TBase>, InstructionOperationsOf<TExtension>>, InstructionOperationNamespace | EmptyRecord>, Extract<MergeField<TransactionOperationsOf<TBase>, TransactionOperationsOf<TExtension>>, TransactionOperationNamespace | EmptyRecord>, Extract<MergeField<FlowOperationsOf<TBase>, FlowOperationsOf<TExtension>>, FlowOperationNamespace | EmptyRecord>>;
+type ExtendedProgramDefinition<TBase extends ProgramSdkDefinition, TAddresses = never, TConstants = never, TDefaults = never, TOperations extends AnyProgramOperations = ProgramOperations, TMath = never> = TBase & MaybeField<'addresses', TAddresses> & MaybeField<'constants', TConstants> & MaybeField<'defaults', TDefaults> & MaybeField<'math', TMath> & ProgramRuntimeExtensionCarrier<MergeProgramOperations<ProgramOperationsOf<TBase>, TOperations>>;
+interface ProgramExtensionInput<TAddresses = never, TConstants = never, TDefaults = never, TOperations extends AnyProgramOperations = ProgramOperations, TProgram extends ProgramSdkDefinition = ProgramSdkDefinition, TMath = never> {
+    readonly pdas?: Record<string, unknown>;
+    readonly accounts?: Record<string, unknown>;
+    readonly queries?: Record<string, unknown>;
+    readonly raw?: Record<string, unknown>;
+    readonly addresses?: TAddresses;
+    readonly constants?: TConstants;
+    readonly defaults?: TDefaults;
+    readonly math?: TMath;
+    readonly createOperations?: (context: ProgramOperationContext<TProgram>) => TOperations;
+}
+declare function defineProgramExtensions<TBase extends ProgramSdkDefinition>(): <TAddresses = never, TConstants = never, TDefaults = never, TOperations extends AnyProgramOperations = ProgramOperations, TMath = never>(extensions: Omit<ProgramExtensionInput<any, any, any, any, any, any>, "addresses" | "constants" | "defaults" | "math" | "createOperations"> & {
+    readonly addresses?: TAddresses;
+    readonly constants?: TConstants;
+    readonly defaults?: TDefaults;
+    readonly math?: TMath;
+    readonly createOperations?: (context: ProgramOperationContext<ExtendedProgramDefinition<TBase, TAddresses, TConstants, TDefaults, ProgramOperations, TMath>>) => TOperations;
+}) => ProgramExtensionInput<TAddresses, TConstants, TDefaults, TOperations, ExtendedProgramDefinition<TBase, TAddresses, TConstants, TDefaults, ProgramOperations, TMath>, TMath>;
+declare function extendProgram<TBase extends ProgramSdkDefinition, TExtension extends ProgramExtensionInput<any, any, any, any, any, any>>(program: TBase, extensions: TExtension): ExtendedProgramDefinition<TBase, MergeField<Field<TBase, 'addresses'>, Field<TExtension, 'addresses'>>, MergeField<Field<TBase, 'constants'>, Field<TExtension, 'constants'>>, MergeField<Field<TBase, 'defaults'>, Field<TExtension, 'defaults'>>, Extract<FactoryReturn<TExtension, 'createOperations'>, AnyProgramOperations>, MergeField<Field<TBase, 'math'>, Field<TExtension, 'math'>>>;
+declare function extendPrograms<TPrograms extends Record<string, ProgramSdkDefinition>, TExtensions extends Partial<{
+    [K in keyof TPrograms]: ProgramExtensionInput<any, any, any, any, any, any>;
+}>>(programs: TPrograms, extensions: TExtensions): {
+    readonly [K in keyof TPrograms]: K extends keyof TExtensions ? NonNullable<TExtensions[K]> extends ProgramExtensionInput<infer TAddresses, infer THelpers, infer TTypes, infer TOperations, any, infer TMath> ? ExtendedProgramDefinition<TPrograms[K], TAddresses, THelpers, TTypes, TOperations, TMath> : TPrograms[K] : TPrograms[K];
+};
+declare function getProgramRuntimeExtensions<TProgram extends ProgramSdkDefinition>(program: TProgram): ProgramRuntimeExtensions<ProgramOperationsOf<TProgram>, TProgram> | undefined;
+interface StackRuntimeExtensions<TRead = EmptyRecord, TFlows extends FlowOperationNamespace | EmptyRecord = EmptyRecord, TClient = unknown> {
+    readonly createRead?: (client: TClient) => TRead;
+    readonly createFlows?: (client: TClient) => TFlows;
+}
+interface StackRuntimeExtensionCarrier<TRead = EmptyRecord, TFlows extends FlowOperationNamespace | EmptyRecord = EmptyRecord> {
+    readonly [STACK_RUNTIME_EXTENSIONS]?: StackRuntimeExtensions<TRead, TFlows>;
+}
+type ExtendedStackDefinition<TBase extends StackDefinition, TAddresses = never, TConstants = never, TDefaults = never, TMath = never, TRead = never, TFlows extends FlowOperationNamespace | EmptyRecord = never> = TBase & MaybeField<'addresses', TAddresses> & MaybeField<'constants', TConstants> & MaybeField<'defaults', TDefaults> & MaybeField<'math', TMath> & StackRuntimeExtensionCarrier<TRead, TFlows>;
+type StackConnectedExtensions<TStack> = MaybeField<'addresses', Field<TStack, 'addresses'>> & MaybeField<'constants', Field<TStack, 'constants'>> & MaybeField<'defaults', Field<TStack, 'defaults'>> & MaybeField<'math', Field<TStack, 'math'>> & (TStack extends StackRuntimeExtensionCarrier<infer TRead, infer TFlows> ? MaybeField<'read', TRead> & MaybeField<'flows', TFlows> : {});
+type ConnectedStackClient<TClient extends object, TStack> = TClient & StackConnectedExtensions<TStack>;
+type StackReadOf<TStack> = TStack extends StackRuntimeExtensionCarrier<infer TRead, any> ? TRead : never;
+type StackFlowsOf<TStack> = TStack extends StackRuntimeExtensionCarrier<any, infer TFlows> ? TFlows : never;
+interface StackExtensionInput<TAddresses = never, TConstants = never, TDefaults = never, TMath = never, TRead = never, TFlows extends FlowOperationNamespace | EmptyRecord = never, TClient = unknown> {
+    readonly addresses?: TAddresses;
+    readonly constants?: TConstants;
+    readonly defaults?: TDefaults;
+    readonly math?: TMath;
+    readonly createRead?: (client: TClient) => TRead;
+    readonly createFlows?: (client: TClient) => TFlows;
+}
+type StackExtensionClient<TBase extends StackDefinition, TAddresses = never, TConstants = never, TDefaults = never, TMath = never> = Arete$1<TBase> & MaybeField<'addresses', TAddresses> & MaybeField<'constants', TConstants> & MaybeField<'defaults', TDefaults> & MaybeField<'math', TMath>;
+declare function defineStackExtensions<TBase extends StackDefinition>(): <TExtension extends StackExtensionInput<any, any, any, any, any, FlowOperationNamespace | EmptyRecord, any>>(extensions: TExtension & {
+    readonly createRead?: (client: StackExtensionClient<TBase, any, any, any, any>) => unknown;
+    readonly createFlows?: (client: StackExtensionClient<TBase, any, any, any, any>) => FlowOperationNamespace | EmptyRecord;
+}) => TExtension;
+declare function extendStack<TBase extends StackDefinition, TExtension extends StackExtensionInput<any, any, any, any, any, any, any>>(stack: TBase, extensions: TExtension): ExtendedStackDefinition<TBase, MergeField<Field<TBase, 'addresses'>, Field<TExtension, 'addresses'>>, MergeField<Field<TBase, 'constants'>, Field<TExtension, 'constants'>>, MergeField<Field<TBase, 'defaults'>, Field<TExtension, 'defaults'>>, MergeField<Field<TBase, 'math'>, Field<TExtension, 'math'>>, MergeField<StackReadOf<TBase>, FactoryReturn<TExtension, 'createRead'>>, Extract<MergeField<StackFlowsOf<TBase>, FactoryReturn<TExtension, 'createFlows'>>, FlowOperationNamespace | EmptyRecord>>;
+declare function getStackRuntimeExtensions<TStack extends StackDefinition>(stack: TStack): StackRuntimeExtensions | undefined;
+declare function applyConnectedStackExtensions<TClient extends object, TStack extends StackDefinition>(client: TClient, stack: TStack): ConnectedStackClient<TClient, TStack>;
+
+type ProgramMap = Record<string, ProgramSdkDefinition>;
+type NormalizeProgramMap<TPrograms> = TPrograms extends ProgramMap ? TPrograms : Record<string, never>;
+type MergeProgramMaps<TStackPrograms, TAttachedPrograms> = Omit<NormalizeProgramMap<TAttachedPrograms>, keyof NormalizeProgramMap<TStackPrograms>> & NormalizeProgramMap<TStackPrograms>;
+type StackWithAttachedPrograms<TStack extends StackDefinition, TAttachedPrograms extends ProgramMap | undefined> = Omit<TStack, 'programs'> & {
+    programs: MergeProgramMaps<TStack['programs'], TAttachedPrograms>;
+};
+declare function withPrograms<TStack extends StackDefinition, TAttachedPrograms extends ProgramMap | undefined>(stack: TStack, attachedPrograms: TAttachedPrograms): StackWithAttachedPrograms<TStack, TAttachedPrograms>;
+interface ConnectOptions<TPrograms extends ProgramMap | undefined = undefined> {
     url?: string;
+    httpUrl?: string;
+    /**
+     * Transport mode. `'ws'` (default) opens the streaming WebSocket; `'http'`
+     * skips the socket entirely — point reads, chain reads, and instruction
+     * execution work, while views/subscriptions throw `WEBSOCKET_DISABLED`.
+     */
+    transport?: 'ws' | 'http';
     storage?: StorageAdapter;
     maxEntriesPerView?: number | null;
     autoReconnect?: boolean;
@@ -750,34 +1275,148 @@ interface ConnectOptions {
     validateFrames?: boolean;
     /** Authentication configuration */
     auth?: AuthConfig;
+    /** Default wallet adapter used for instruction execution (overridable per call). */
+    wallet?: WalletAdapter;
+    /** Optional fetch implementation for HTTP point reads. */
+    fetch?: typeof fetch;
+    /** Additional program SDKs exposed under client.programs.<key>. */
+    programs?: TPrograms;
+    /** Default semantic-operation execution settings. */
+    execution?: OperationExecutionOptions<any>;
 }
 /** @deprecated Use ConnectOptions instead */
 interface AreteOptionsWithStorage<TStack extends StackDefinition> extends AreteOptions<TStack> {
+    httpUrl?: string;
     storage?: StorageAdapter;
     maxEntriesPerView?: number | null;
     flushIntervalMs?: number;
     auth?: AuthConfig;
+    wallet?: WalletAdapter;
+    fetch?: typeof fetch;
+    execution?: OperationExecutionOptions<any>;
+}
+interface TransactionOptions<TSigner = unknown> {
+    wallet?: WalletAdapter;
+    send?: SendOptions;
+    errors?: ErrorMetadata[];
+    signers?: readonly TSigner[];
 }
-interface InstructionExecutorOptions extends Omit<ExecuteOptions, 'wallet'> {
-    wallet: WalletAdapter;
+/**
+ * A typed, callable instruction.
+ *
+ * Calling it builds + signs + sends the transaction. The attached `build`
+ * method is a pure prepare step that returns a {@link BuiltInstruction} for
+ * batching/composition.
+ */
+interface TypedInstruction<TParams, TError> {
+    build(params: TParams, options?: BuildOptions): BuiltInstruction;
+    /** Phantom error type for downstream inference. */
+    readonly _error?: TError;
 }
-type InstructionExecutor = (args: Record<string, unknown>, options: InstructionExecutorOptions) => Promise<ExecutionResult>;
-type InstructionsInterface<TInstructions extends Record<string, InstructionHandler> | undefined> = TInstructions extends Record<string, InstructionHandler> ? {
-    [K in keyof TInstructions]: InstructionExecutor;
-} : {};
-declare class Arete<TStack extends StackDefinition> {
+interface TypedAccountReader<T> {
+    fetch(address: string): Promise<T | null>;
+    fetchMany(addresses: readonly string[]): Promise<Array<T | null>>;
+    exists(address: string): Promise<boolean>;
+}
+type TypedQueryExecutor<TParams, TResult> = (params: TParams) => Promise<TResult>;
+type TypedAccountReaderFor<TEntry> = TEntry extends ProgramAccountReadDefinition<infer T> ? TypedAccountReader<T> : TypedAccountReader<unknown>;
+type TypedQueryFor<TEntry> = TEntry extends ProgramQueryDefinition<infer P, infer R> ? TypedQueryExecutor<P, R> : TEntry extends StackQueryDefinition<infer P, infer R> ? TypedQueryExecutor<P, R> : TypedQueryExecutor<Record<string, unknown>, unknown>;
+type RawInstructionsInterface<TInstructions extends Record<string, InstructionHandler<any, any>> | undefined> = TInstructions extends Record<string, InstructionHandler<any, any>> ? {
+    [K in keyof TInstructions]: TInstructions[K] extends InstructionHandler<infer P, infer E> ? TypedInstruction<P, E> : TypedInstruction<Record<string, unknown>, unknown>;
+} : Record<string, never>;
+type ProgramAccountsInterface<TAccounts extends Record<string, ProgramAccountReadDefinition<unknown>> | undefined> = TAccounts extends Record<string, ProgramAccountReadDefinition<unknown>> ? {
+    [K in keyof TAccounts]: TypedAccountReaderFor<TAccounts[K]>;
+} : Record<string, never>;
+type ProgramQueriesInterface<TQueries extends Record<string, ProgramQueryDefinition<unknown, unknown>> | undefined> = TQueries extends Record<string, ProgramQueryDefinition<unknown, unknown>> ? {
+    [K in keyof TQueries]: TypedQueryFor<TQueries[K]>;
+} : Record<string, never>;
+type ProgramNamespace<TNamespace> = TNamespace extends Record<string, unknown> ? TNamespace : Record<string, never>;
+type OperationField<TOperations, TKey extends PropertyKey> = TKey extends keyof TOperations ? ProgramNamespace<TOperations[TKey]> : Record<string, never>;
+type ProgramInterface<TProgram extends ProgramSdkDefinition> = {
+    name: TProgram['name'];
+    programId: TProgram['programId'];
+    schemas: TProgram['schemas'];
+    pdas: TProgram['pdas'] extends Record<string, unknown> ? TProgram['pdas'] : Record<string, never>;
+    accounts: ProgramAccountsInterface<TProgram['accounts']>;
+    queries: ProgramQueriesInterface<TProgram['queries']>;
+    raw: RawInstructionsInterface<TProgram['rawInstructions']>;
+    addresses: ProgramNamespace<TProgram['addresses']>;
+    constants: ProgramNamespace<TProgram['constants']>;
+    defaults: ProgramNamespace<TProgram['defaults']>;
+    math: ProgramNamespace<TProgram['math']>;
+    instructions: OperationField<ProgramOperationsOf<TProgram>, 'instructions'>;
+    transactions: OperationField<ProgramOperationsOf<TProgram>, 'transactions'>;
+    flows: OperationField<ProgramOperationsOf<TProgram>, 'flows'>;
+};
+type ProgramsInterface<TPrograms extends Record<string, ProgramSdkDefinition> | undefined> = TPrograms extends Record<string, ProgramSdkDefinition> ? {
+    [K in keyof TPrograms]: ProgramInterface<TPrograms[K]>;
+} : Record<string, never>;
+type QueriesInterface<TQueries extends Record<string, StackQueryDefinition<unknown, unknown>> | undefined> = TQueries extends Record<string, StackQueryDefinition<unknown, unknown>> ? {
+    [K in keyof TQueries]: TypedQueryFor<TQueries[K]>;
+} : Record<string, never>;
+type RawProgramsInterface<TPrograms extends Record<string, ProgramSdkDefinition> | undefined> = TPrograms extends Record<string, ProgramSdkDefinition> ? {
+    [K in keyof TPrograms]: RawInstructionsInterface<TPrograms[K]['rawInstructions']>;
+} : Record<string, never>;
+/** @deprecated Retained for backward compatibility; prefer {@link TypedInstruction}. */
+type InstructionExecutor = TypedInstruction<Record<string, unknown>, unknown>;
+type ConnectedArete<TStack extends StackDefinition, TExtensions = TStack> = Arete$1<TStack> & StackConnectedExtensions<TExtensions>;
+declare class Arete$1<TStack extends StackDefinition> {
     private readonly connection;
     private readonly storage;
     private readonly processor;
     private readonly subscriptionRegistry;
     private readonly _views;
+    private readonly _queries;
+    private readonly _programs;
+    private readonly _chain;
     private readonly stack;
-    private readonly _instructions;
+    private readonly httpBaseUrl;
+    private readonly fetchImpl;
+    private readonly executionDefaults?;
+    private _wallet?;
+    private _aggregatedErrors?;
     private constructor();
-    private buildInstructions;
-    static connect<T extends StackDefinition>(stack: T, options?: ConnectOptions): Promise<Arete<T>>;
+    private resolveFetchImpl;
+    private buildQueries;
+    private buildPrograms;
+    private createTypedInstruction;
+    private createAccountReader;
+    private createQueryExecutor;
+    private readJson;
+    private authenticatedFetch;
+    private resolveReadUrl;
+    /** Merge the client's default wallet into call options (call options win). */
+    private withWallet;
+    static connect<T extends StackDefinition, TPrograms extends ProgramMap | undefined = undefined>(stack: T, options?: ConnectOptions<TPrograms>): Promise<ConnectedArete<StackWithAttachedPrograms<T, TPrograms>, T>>;
     get views(): TypedViews<TStack['views']>;
-    get instructions(): InstructionsInterface<TStack['instructions']>;
+    get queries(): QueriesInterface<TStack['queries']>;
+    get programs(): ProgramsInterface<TStack['programs']>;
+    get chain(): ChainClient;
+    /** The default wallet adapter, if one was configured. */
+    get wallet(): WalletAdapter | undefined;
+    /** The connected wallet address, if a default wallet was configured. */
+    get publicKey(): string | undefined;
+    /**
+     * Set (or clear) the default wallet adapter used for instruction execution.
+     * Useful for connecting/disconnecting a wallet after the client is created.
+     */
+    setWallet(wallet: WalletAdapter | undefined): void;
+    /**
+     * Sign and send a batch of pre-built instructions as a single transaction.
+     *
+     * Build instructions with `client.programs.<program>.raw.<name>.build(params)`
+     * and compose them here. RPC/compilation/confirmation are owned by the adapter.
+     *
+     * On failure, the error is parsed against `options.errors` when given,
+     * otherwise against error metadata aggregated from all the stack's handlers
+     * (deduped by code, first-wins — if the stack bundles programs with
+     * overlapping error codes, pass `options.errors` or use the per-instruction
+     * call path for precise attribution).
+     */
+    transaction(instructions: readonly BuiltInstruction[], options?: TransactionOptions): Promise<ExecutionResult>;
+    execute<TPrepared extends PreparedOperation, TSigner = unknown>(prepared: TPrepared, options?: OperationExecutionOptions<TSigner, TPrepared>): Promise<OperationReceiptFor<TPrepared>>;
+    /** Error metadata from every handler in the stack, deduped by code. */
+    private aggregateErrors;
     get connectionState(): ConnectionState;
     get stackName(): string;
     get store(): StorageAdapter;
@@ -793,6 +1432,174 @@ declare class Arete<TStack extends StackDefinition> {
     getSubscriptionRegistry(): SubscriptionRegistry;
 }
 
+/**
+ * A session composes multiple stack and standalone-program SDK clients
+ * behind one wallet and one shared endpoint configuration.
+ *
+ * Each member gets its own client (connection + store); a stack is itself a
+ * composition of programs + views, and a standalone program member reuses the
+ * exact same machinery as a stack with no views, connected HTTP-only.
+ */
+interface SessionDefinition {
+    readonly stacks?: Record<string, StackDefinition>;
+    readonly programs?: Record<string, ProgramSdkDefinition>;
+}
+type SessionStackPrograms<TDef extends SessionDefinition> = Partial<{
+    [K in keyof NonNullable<TDef['stacks']>]: Record<string, ProgramSdkDefinition> | undefined;
+}>;
+type EffectiveStackPrograms<TDef extends SessionDefinition, TStackPrograms extends SessionStackPrograms<TDef>, K extends keyof NonNullable<TDef['stacks']>> = NonNullable<TDef['stacks']>[K] extends StackDefinition ? K extends keyof TStackPrograms ? StackWithAttachedPrograms<NonNullable<TDef['stacks']>[K], TStackPrograms[K]>['programs'] : NonNullable<NonNullable<TDef['stacks']>[K]['programs']> : never;
+type StackProgramKeys<TDef extends SessionDefinition, TStackPrograms extends SessionStackPrograms<TDef>> = {
+    [K in keyof NonNullable<TDef['stacks']>]: keyof EffectiveStackPrograms<TDef, TStackPrograms, K>;
+}[keyof NonNullable<TDef['stacks']>];
+/** Per-member connection overrides (a subset of {@link ConnectOptions}). */
+interface SessionMemberOptions<TPrograms extends Record<string, ProgramSdkDefinition> | undefined = undefined> {
+    url?: string;
+    httpUrl?: string;
+    transport?: 'ws' | 'http';
+    auth?: AuthConfig;
+    storage?: StorageAdapter;
+    autoReconnect?: boolean;
+    programs?: TPrograms;
+}
+interface SessionOptions<TDef extends SessionDefinition = SessionDefinition, TStackPrograms extends SessionStackPrograms<TDef> = {}> {
+    /** One wallet governs execution across every member. */
+    wallet?: WalletAdapter;
+    /** Canonical chain reader shared by the session when explicitly provided. */
+    chain?: ChainClient;
+    auth?: AuthConfig;
+    fetch?: typeof fetch;
+    /** Default transport for all members ('ws' unless overridden). */
+    transport?: 'ws' | 'http';
+    /** Shared fallback endpoints used when a member defines none of its own. */
+    endpoints?: {
+        http?: string;
+        ws?: string;
+    };
+    /** Default execution settings shared by transaction/plan helpers on the session. */
+    execution?: OperationExecutionOptions<any>;
+    /** Signers available to every transaction executed through this session. */
+    signerRegistry?: SignerRegistry<any>;
+    /** Per-member overrides, keyed by the member's key in the definition. */
+    stacks?: {
+        [K in keyof NonNullable<TDef['stacks']>]?: SessionMemberOptions<K extends keyof TStackPrograms ? TStackPrograms[K] : undefined>;
+    };
+    programs?: Record<string, SessionMemberOptions>;
+}
+type SessionStacks<TDef extends SessionDefinition, TStackPrograms extends SessionStackPrograms<TDef> = {}> = {
+    readonly [K in keyof NonNullable<TDef['stacks']>]: NonNullable<TDef['stacks']>[K] extends StackDefinition ? K extends keyof TStackPrograms ? ConnectedArete<StackWithAttachedPrograms<NonNullable<TDef['stacks']>[K], TStackPrograms[K]>, NonNullable<TDef['stacks']>[K]> : ConnectedArete<NonNullable<TDef['stacks']>[K], NonNullable<TDef['stacks']>[K]> : never;
+};
+type StackProgramInterfaceForKey<TDef extends SessionDefinition, TStackPrograms extends SessionStackPrograms<TDef>, P extends PropertyKey> = {
+    [K in keyof NonNullable<TDef['stacks']>]: P extends keyof SessionStacks<TDef, TStackPrograms>[K]['programs'] ? SessionStacks<TDef, TStackPrograms>[K]['programs'][P] : never;
+}[keyof NonNullable<TDef['stacks']>];
+type PromotedSessionPrograms<TDef extends SessionDefinition, TStackPrograms extends SessionStackPrograms<TDef>> = {
+    readonly [P in StackProgramKeys<TDef, TStackPrograms>]: StackProgramInterfaceForKey<TDef, TStackPrograms, P>;
+};
+type ExplicitSessionPrograms<TDef extends SessionDefinition> = {
+    readonly [K in keyof NonNullable<TDef['programs']>]: NonNullable<TDef['programs']>[K] extends ProgramSdkDefinition ? ProgramInterface<NonNullable<TDef['programs']>[K]> : never;
+};
+type SessionPrograms<TDef extends SessionDefinition, TStackPrograms extends SessionStackPrograms<TDef> = {}> = Omit<PromotedSessionPrograms<TDef, TStackPrograms>, keyof NonNullable<TDef['programs']>> & ExplicitSessionPrograms<TDef>;
+interface Session<TDef extends SessionDefinition = SessionDefinition, TStackPrograms extends SessionStackPrograms<TDef> = {}> {
+    readonly stacks: SessionStacks<TDef, TStackPrograms>;
+    readonly programs: SessionPrograms<TDef, TStackPrograms>;
+    readonly wallet: WalletAdapter | undefined;
+    readonly signerRegistry: SignerRegistry<any>;
+    readonly chain: ChainClient;
+    transaction(instructions: readonly BuiltInstruction[], options?: TransactionOptions): Promise<ExecutionResult>;
+    execute<TPrepared extends PreparedOperation, TSigner = unknown>(prepared: TPrepared, options?: OperationExecutionOptions<TSigner, TPrepared>): Promise<OperationReceiptFor<TPrepared>>;
+    setWallet(wallet: WalletAdapter | undefined): void;
+    close(): void;
+}
+declare function createSession<TDef extends SessionDefinition, TStackPrograms extends SessionStackPrograms<TDef> = {}>(definition: TDef, options?: SessionOptions<TDef, TStackPrograms>): Promise<Session<TDef, TStackPrograms>>;
+
+interface AccountLoader {
+    getAccount(address: string): Promise<{
+        data: Uint8Array;
+    } | null>;
+}
+declare function chainAccountLoader(chain: ChainClient): AccountLoader;
+
+declare const SPL_TOKEN_PROGRAM_ADDRESS = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+declare const TOKEN_2022_PROGRAM_ADDRESS = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
+declare const ASSOCIATED_TOKEN_PROGRAM_ADDRESS = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+declare const SYSTEM_PROGRAM_ADDRESS = "11111111111111111111111111111111";
+declare function resolveTokenProgramAddress(chain: ChainClient, mint: string, override?: string): Promise<string>;
+declare function deriveAssociatedTokenAccount(input: {
+    owner: string;
+    mint: string;
+    tokenProgram?: string;
+}): string;
+
+/**
+ * A token amount expressed either in UI units (human decimal string/number)
+ * or raw base units. A bare bigint is treated as raw.
+ */
+type AmountInput = bigint | {
+    ui: string | number;
+} | {
+    raw: bigint | string | number;
+};
+interface AmountResolutionInput {
+    mint: string;
+    amount: AmountInput;
+    decimals?: number;
+}
+/** Convert a UI amount ("1.5") to raw base units using string math (no float precision loss). */
+declare function parseUiAmountToRaw(value: string | number, decimals: number): bigint;
+/** Format raw base units as a UI decimal string (inverse of {@link parseUiAmountToRaw}). */
+declare function formatRawToUi(raw: bigint | string | number, decimals: number): string;
+/** Resolve an {@link AmountInput} to raw base units with known decimals. */
+declare function toRawAmount(amount: AmountInput, decimals: number): bigint;
+/** Fetch a mint's decimals via the chain read endpoint, throwing when unavailable. */
+declare function getMintDecimals(chain: ChainClient, mint: string): Promise<number>;
+/**
+ * Resolve an {@link AmountInput} to raw base units, fetching the mint's
+ * decimals only when they are unknown and actually needed (a bare bigint or
+ * `{raw}` input with explicit `decimals` never touches the network).
+ */
+declare function resolveAmount(chain: ChainClient, input: AmountResolutionInput): Promise<{
+    raw: bigint;
+    decimals: number;
+}>;
+/**
+ * Resolve an {@link AmountInput} to raw base units without forcing a decimals
+ * fetch when the input is already expressed in raw units.
+ */
+declare function resolveAmountToRaw(chain: ChainClient, input: AmountResolutionInput): Promise<bigint>;
+/** Resolve a named set of {@link AmountInput} values to raw base units. */
+declare function resolveAmountsToRaw<TInputs extends Record<string, AmountResolutionInput>>(chain: ChainClient, inputs: TInputs): Promise<{
+    [K in keyof TInputs]: bigint;
+}>;
+
+declare class ReadRequestError extends Error {
+    readonly status: number;
+    readonly path: string;
+    readonly body: string;
+    readonly serverErrorCode: string | undefined;
+    constructor(input: {
+        status: number;
+        path: string;
+        body: string;
+        serverErrorCode?: string;
+    });
+}
+declare function programAccountRead<T>(input: {
+    account: string;
+    path: string;
+    schema?: Schema<T>;
+}): ProgramAccountReadDefinition<T>;
+declare function programQuery<TParams = unknown, TResult = unknown>(input: {
+    name: string;
+    path: string;
+    method?: ReadTransportMethod;
+    schema?: Schema<TResult>;
+}): ProgramQueryDefinition<TParams, TResult>;
+declare function stackQuery<TParams = unknown, TResult = unknown>(input: {
+    name: string;
+    path: string;
+    method?: ReadTransportMethod;
+    schema?: Schema<TResult>;
+}): StackQueryDefinition<TParams, TResult>;
+
 interface FrameProcessorConfig {
     maxEntriesPerView?: number | null;
     /**
@@ -805,18 +1612,28 @@ interface FrameProcessorConfig {
      */
     flushIntervalMs?: number;
     schemas?: Record<string, Schema<unknown>>;
+    patchSchemas?: Record<string, Schema<unknown>>;
 }
 declare class FrameProcessor {
     private storage;
     private maxEntriesPerView;
     private flushIntervalMs;
     private schemas?;
+    private patchSchemas?;
     private pendingUpdates;
     private flushTimer;
     private isProcessing;
     constructor(storage: StorageAdapter, config?: FrameProcessorConfig);
     private getSchema;
-    private validateEntity;
+    private normalizeEntity;
+    private hasSchema;
+    private normalizePathSegment;
+    private normalizePath;
+    private normalizeSortConfig;
+    private normalizeAppendPaths;
+    private extractSeq;
+    private getInternalSeq;
+    private attachInternalSeq;
     handleFrame<T>(frame: Frame<T>): void;
     /**
      * Immediately flush all pending updates.
@@ -840,45 +1657,6 @@ declare class FrameProcessor {
     private enforceMaxEntries;
 }
 
-interface EntityStoreConfig {
-    maxEntriesPerView?: number | null;
-}
-interface ViewConfig {
-    sort?: SortConfig;
-}
-type EntityUpdateCallback = (viewPath: string, key: string, update: Update<unknown>) => void;
-type RichUpdateCallback = (viewPath: string, key: string, update: RichUpdate<unknown>) => void;
-declare class EntityStore {
-    private views;
-    private viewConfigs;
-    private updateCallbacks;
-    private richUpdateCallbacks;
-    private maxEntriesPerView;
-    constructor(config?: EntityStoreConfig);
-    private enforceMaxEntries;
-    handleFrame<T>(frame: Frame<T>): void;
-    private handleSubscribedFrame;
-    private handleSnapshotFrame;
-    private handleEntityFrame;
-    getAll<T>(viewPath: string): T[];
-    get<T>(viewPath: string, key: string): T | null;
-    getAllSync<T>(viewPath: string): T[] | undefined;
-    getSync<T>(viewPath: string, key: string): T | null | undefined;
-    keys(viewPath: string): string[];
-    size(viewPath: string): number;
-    clear(): void;
-    clearView(viewPath: string): void;
-    getViewConfig(viewPath: string): ViewConfig | undefined;
-    setViewConfig(viewPath: string, config: ViewConfig): void;
-    onUpdate(callback: EntityUpdateCallback): UnsubscribeFn;
-    onRichUpdate(callback: RichUpdateCallback): UnsubscribeFn;
-    subscribe<T>(viewPath: string, callback: SubscribeCallback<T>): UnsubscribeFn;
-    subscribeToKey<T>(viewPath: string, key: string, callback: SubscribeCallback<T>): UnsubscribeFn;
-    private notifyUpdate;
-    private notifyRichUpdate;
-    private notifyRichDelete;
-}
-
 declare class MemoryAdapter implements StorageAdapter {
     private views;
     private updateCallbacks;
@@ -896,7 +1674,7 @@ declare class MemoryAdapter implements StorageAdapter {
     clear(viewPath?: string): void;
     evictOldest(viewPath: string): string | undefined;
     onUpdate(callback: UpdateCallback): () => void;
-    onRichUpdate(callback: RichUpdateCallback$1): () => void;
+    onRichUpdate(callback: RichUpdateCallback): () => void;
     notifyUpdate<T>(viewPath: string, key: string, update: Update<T>): void;
     notifyRichUpdate<T>(viewPath: string, key: string, update: RichUpdate<T>): void;
 }
@@ -909,5 +1687,9 @@ declare function createTypedStateView<T>(viewDef: ViewDef<T, 'state'>, storage:
 declare function createTypedListView<T>(viewDef: ViewDef<T, 'list'>, storage: StorageAdapter, subscriptionRegistry: SubscriptionRegistry): TypedListView<T>;
 declare function createTypedViews<TStack extends StackDefinition>(stack: TStack, storage: StorageAdapter, subscriptionRegistry: SubscriptionRegistry): TypedViews<TStack['views']>;
 
-export { Arete, AreteError, ConnectionManager, DEFAULT_CONFIG, DEFAULT_MAX_ENTRIES_PER_VIEW, EntityStore, FrameProcessor, MemoryAdapter, SubscriptionRegistry, account, arg, bytes, createEntityStream, createInstructionExecutor, createProgramPdas, createPublicKeySeed, createRichUpdateStream, createSeed, createTypedListView, createTypedStateView, createTypedViews, createUpdateStream, decodeBase58, findProgramAddress as derivePda, encodeBase58, executeInstruction, findProgramAddress, findProgramAddressSync, formatProgramError, isEntityFrame, isSnapshotFrame, isSubscribedFrame, isValidFrame, literal, parseFrame, parseFrameFromBlob, parseInstructionError, pda, resolveAccounts, serializeInstructionData, validateAccountResolution, waitForConfirmation };
-export type { AccountCategory, AccountMeta, AccountResolutionOptions, AccountResolutionResult, AreteConfig, AreteOptions, AreteOptionsWithStorage, ArgSchema, ArgType, AuthConfig, AuthTokenResult, BuiltInstruction, ConfirmationLevel, ConnectionState, ConnectionStateCallback, EntityFrame, EntityStoreConfig, ErrorMetadata, ExecuteOptions, ExecutionResult, Frame, FrameMode, FrameOp, FrameProcessorConfig, InstructionDefinition, InstructionExecutor, InstructionExecutorOptions, InstructionHandler, PdaConfig, PdaDeriveContext, PdaFactory, PdaSeed, ProgramError, ProgramPdas, ResolvedAccount, ResolvedAccounts, RichUpdate, RichUpdateCallback$1 as RichUpdateCallback, Schema, SchemaResult, SeedDef, SnapshotEntity, SnapshotFrame, SocketIssue, SocketIssueCallback, SortConfig, SortOrder, StackDefinition, StorageAdapter, StorageAdapterConfig, SubscribeCallback, SubscribedFrame, Subscription, TypedListView, TypedStateView, TypedViewGroup, TypedViews, UnsubscribeFn, Update, UpdateCallback, ViewConfig, ViewDef, ViewGroup, ViewSortConfig, WalletAdapter, WalletConnectOptions, WalletState, WatchOptions, WebSocketFactoryInit };
+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, OperationExecutionError, PROGRAM_OPERATION_EXTENSIONS, ReadRequestError, SPL_TOKEN_PROGRAM_ADDRESS, STACK_RUNTIME_EXTENSIONS, SYSTEM_PROGRAM_ADDRESS, SubscriptionRegistry, TOKEN_2022_PROGRAM_ADDRESS, account, appendFlowTransactions, appendTransactionInstructions, applyConnectedStackExtensions, arg, buildInstruction, bytes, chainAccountLoader, createChainClient, createEntityStream, createInstructionExecutor, createInstructionHandler, createPreparedFlow, createPreparedInstruction, createPreparedTransaction, createPreparedTransactionBody, createProgramPdas, createPublicKeySeed, createRichUpdateStream, createSeed, createSession, createSignerRegistry, 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, getProgramRuntimeExtensions, getStackRuntimeExtensions, instructionOperation, isEntityFrame, isSnapshotFrame, isSubscribedFrame, isValidFrame, literal, parseFrame, parseFrameFromBlob, parseInstructionError, parseUiAmountToRaw, pda, prependFlowTransactionInstructions, prependTransactionInstructions, programAccountRead, programQuery, resolveAccounts, resolveAmount, resolveAmountToRaw, resolveAmountsToRaw, resolveTokenProgramAddress, serializeInstructionData, stackQuery, toJsonValue, toRawAmount, transactionOperation, validateAccountResolution, withPrograms };
+export type { AccountCategory, AccountLoader, AccountMeta, AccountResolutionOptions, AccountResolutionResult, AmountInput, AnyOperation, AreteConfig, AreteOptions, AreteOptionsWithStorage, ArgSchema, ArgType, AuthConfig, AuthTokenResult, BuildOptions, BuiltAccountMeta, BuiltInstruction, ChainClient, ChainClock, ConfirmationLevel, ConnectOptions, ConnectedArete, ConnectedStackClient, ConnectionState, ConnectionStateCallback, CreatePreparedFlowInput, CreatePreparedInstructionInput, CreatePreparedTransactionInput, EntityFrame, ErrorMetadata, ExecuteOptions, ExecutionResult, ExtendedProgramDefinition, ExtendedStackDefinition, FlowOperation, FlowOperationNamespace, FlowOperationReceipt, Frame, FrameMode, FrameOp, FrameProcessorConfig, InstructionExecutor, InstructionHandler, InstructionHandlerConfig, InstructionOperation, InstructionOperationNamespace, JsonObject, JsonPrimitive, JsonValue, MergeProgramMaps, MintAccountInfo, NonEmptyReadonlyArray, OperationExecutionEvent, OperationExecutionHost, OperationExecutionOptions, OperationExecutionSuccessEvent, OperationKind, OperationNamespace, OperationPlan, OperationReceiptFor, OperationTransactionReceipt, PdaConfig, PdaDeriveContext, PdaFactory, PdaSeed, PreparedFlow, PreparedInstruction, PreparedOperation, PreparedOperationDescription, PreparedTransaction, PreparedTransactionBody, PreparedTransactionInstruction, PreparedTransactionOperation, ProgramAccountReadDefinition, ProgramError, ProgramExtensionInput, ProgramInterface, ProgramOperationContext, ProgramOperations, ProgramOperationsOf, ProgramPdas, ProgramQueryDefinition, ProgramRuntimeExtensionCarrier, ProgramRuntimeExtensions, ProgramSdkDefinition, ProgramsInterface, QueriesInterface, RawAccountInfo, RawInstructionsInterface, RawProgramsInterface, ReadTransportMethod, ResolvedAccount, ResolvedAccounts, RichUpdate, RichUpdateCallback, Schema, SchemaResult, SeedDef, SendOptions, SendResult, Session, SessionDefinition, SessionMemberOptions, SessionOptions, SignerRegistry, SingleTransactionOperationReceipt, SnapshotEntity, SnapshotFrame, SocketIssue, SocketIssueCallback, SortConfig, SortOrder, StackConnectedExtensions, StackDefinition, StackEndpoints, StackExtensionClient, StackExtensionInput, StackQueryDefinition, StackRuntimeExtensionCarrier, StackRuntimeExtensions, StackWithAttachedPrograms, StorageAdapter, StorageAdapterConfig, SubscribeCallback, SubscribedFrame, Subscription, TokenAccountInfo, TokenBalanceInfo, TransactionOperation, TransactionOperationNamespace, TransactionOptions, TypedAccountReader, TypedInstruction, TypedListView, TypedQueryExecutor, TypedStateView, TypedViewGroup, TypedViews, UnsubscribeFn, Update, UpdateCallback, ViewDef, ViewGroup, ViewSortConfig, WalletAdapter, WalletConnectOptions, WalletState, WatchOptions, WebSocketFactoryInit };