@usearete/sdk 0.1.5 → 0.3.0

package/dist/index.d.ts

@@ -1,16 +1,211 @@
+import { Buffer } from 'buffer';
+
+type TransactionCommitment = 'processed' | 'confirmed' | 'finalized';
+type TransactionAuthScope = 'transaction:inspect' | 'transaction:send';
+interface TransactionRequestContext {
+    commitment?: TransactionCommitment;
+    minContextSlot?: bigint;
+}
+interface LatestBlockhashResult {
+    blockhash: string;
+    contextSlot: bigint;
+    lastValidBlockHeight: bigint;
+}
+interface TransactionFeeResult {
+    feeLamports: bigint | null;
+    contextSlot: bigint;
+}
+interface TransactionSimulationOptions extends TransactionRequestContext {
+    accounts?: readonly string[];
+    innerInstructions?: boolean;
+    replaceRecentBlockhash?: boolean;
+}
+interface TransactionSimulationResult {
+    contextSlot: bigint;
+    err: unknown | null;
+    logs: readonly string[] | null;
+    unitsConsumed?: bigint;
+    accounts?: readonly unknown[] | null;
+}
+interface TransactionSendOptions {
+    skipPreflight?: boolean;
+    preflightCommitment?: TransactionCommitment;
+    minContextSlot?: bigint;
+}
+interface TransactionSendResult {
+    signature: string;
+}
+interface TransactionSignatureStatus {
+    signature: string;
+    slot: bigint | null;
+    confirmationStatus: TransactionCommitment | null;
+    err: unknown | null;
+}
+interface TransactionTransportErrorBody {
+    code: string;
+    message: string;
+    retryable: boolean;
+    request_id?: string;
+    submission_state?: 'not_submitted' | 'unknown';
+    signature?: string;
+    details?: unknown;
+}
+declare class TransactionTransportError extends Error {
+    readonly code: string;
+    readonly retryable: boolean;
+    readonly requestId?: string;
+    readonly submissionState?: 'not_submitted' | 'unknown';
+    readonly signature?: string;
+    readonly details?: unknown;
+    readonly status: number;
+    constructor(status: number, body: TransactionTransportErrorBody);
+}
+interface TransactionTransport {
+    getLatestBlockhash(options?: TransactionRequestContext): Promise<LatestBlockhashResult>;
+    getFeeForMessage(message: string, options?: TransactionRequestContext): Promise<TransactionFeeResult>;
+    simulateTransaction(transaction: string, options?: TransactionSimulationOptions): Promise<TransactionSimulationResult>;
+    sendTransaction(transaction: string, options?: TransactionSendOptions): Promise<TransactionSendResult>;
+    getSignatureStatus(signature: string, options?: TransactionRequestContext & {
+        searchTransactionHistory?: boolean;
+    }): Promise<TransactionSignatureStatus | null>;
+    getBlockHeight(options?: TransactionRequestContext): Promise<bigint>;
+}
+type AuthenticatedTransactionFetch = (input: string, init: RequestInit, scope: TransactionAuthScope, allowAuthReplay: boolean) => Promise<Response>;
+declare function createTransactionTransport(baseUrl: string, authenticatedFetch: AuthenticatedTransactionFetch): TransactionTransport;
+
+/**
+ * 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;
+}
+/**
+ * Adapter-specific options for unsigned transaction inspection.
+ *
+ * Inspection must not sign or submit the transaction. Concrete adapters may
+ * accept additional simulation options through this passthrough object.
+ */
+interface TransactionInspectionOptions {
+    [key: string]: unknown;
+}
+/**
+ * Unsigned transaction inspection returned by a capable wallet adapter.
+ */
+interface TransactionInspectionResult {
+    /** Estimated transaction fee in lamports, when available. */
+    feeLamports?: number;
+    /** Program logs produced by simulation, when available. */
+    logs?: readonly string[];
+    /** Compute units consumed by simulation, when available. */
+    computeUnitsConsumed?: number;
+    /** RPC context slot for the inspection, when available. */
+    contextSlot?: number;
+    /** Raw simulation failure, if the inspected transaction would fail. */
+    error?: unknown;
+    /** Adapter-specific inspection fields. */
+    [key: string]: unknown;
+}
+interface WalletExecutionContext {
+    transactionTransport?: TransactionTransport;
+}
 /**
  * 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(instructions: readonly BuiltInstruction[], options?: SendOptions, context?: WalletExecutionContext): Promise<SendResult>;
+    /**
+     * Inspect a transaction without signing, submitting, or prompting a wallet.
+     *
+     * This capability is optional because not every adapter has an RPC-backed
+     * unsigned simulation implementation.
      */
-    signAndSend: (transaction: unknown) => Promise<string>;
+    inspectTransaction?(instructions: readonly BuiltInstruction[], options?: TransactionInspectionOptions, context?: WalletExecutionContext): Promise<TransactionInspectionResult>;
 }
 /**
  * Wallet connection state
@@ -68,9 +263,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 +300,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) */
@@ -183,6 +384,7 @@ declare function createPublicKeySeed(address: string): Uint8Array;
  * This module handles serializing instruction arguments into the binary format
  * expected by Solana programs using Borsh serialization.
  */
+
 /**
  * Instruction argument schema for serialization.
  */
@@ -194,13 +396,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 +443,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.
  */
@@ -285,6 +465,46 @@ interface ErrorMetadata {
     name: string;
     msg: string;
 }
+type TransactionFailureStatus = 'not-submitted' | 'submitted-unknown' | 'chain-failed';
+type TransactionFailurePhase = 'build' | 'wallet' | 'send' | 'confirmation' | 'chain';
+interface ConfirmedTransactionOutcome {
+    readonly status: 'confirmed';
+    readonly phase: 'confirmation';
+    readonly signature: string;
+    readonly slot?: number;
+}
+interface NotSubmittedTransactionOutcome {
+    readonly status: 'not-submitted';
+    readonly phase: 'build' | 'wallet' | 'send';
+    readonly cause: unknown;
+}
+interface SubmittedUnknownTransactionOutcome {
+    readonly status: 'submitted-unknown';
+    readonly phase: 'send' | 'confirmation';
+    readonly signature: string;
+    readonly slot?: number;
+    readonly cause: unknown;
+}
+interface ChainFailedTransactionOutcome {
+    readonly status: 'chain-failed';
+    readonly phase: 'confirmation' | 'chain';
+    readonly signature?: string;
+    readonly slot?: number;
+    readonly programError?: ProgramError;
+    readonly cause: unknown;
+}
+type TransactionFailureOutcome = NotSubmittedTransactionOutcome | SubmittedUnknownTransactionOutcome | ChainFailedTransactionOutcome;
+type TransactionOutcome = ConfirmedTransactionOutcome | TransactionFailureOutcome;
+/**
+ * Structured transaction failure thrown by adapters and the core executor.
+ */
+declare class TransactionExecutionError extends Error {
+    readonly outcome: TransactionFailureOutcome;
+    readonly cause: unknown;
+    readonly signature?: string;
+    readonly slot?: number;
+    constructor(outcome: TransactionFailureOutcome, message?: string);
+}
 /**
  * Parses an error returned from a Solana transaction.
  *
@@ -292,7 +512,7 @@ interface ErrorMetadata {
  * @param errorMetadata - Error definitions from the IDL
  * @returns Parsed program error or null if not a program error
  */
-declare function parseInstructionError(error: unknown, errorMetadata: ErrorMetadata[]): ProgramError | null;
+declare function parseInstructionError(error: unknown, errorMetadata: readonly ErrorMetadata[]): ProgramError | null;
 /**
  * Formats an error for display.
  *
@@ -300,87 +520,149 @@ 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;
+    /** Structured chain-failure outcome, including signature and slot when known. */
+    readonly outcome: ChainFailedTransactionOutcome;
+    readonly signature?: string;
+    readonly slot?: number;
+    constructor(message: string, programError: ProgramError | null, cause: unknown, outcome?: ChainFailedTransactionOutcome);
+}
+/** Find a structured transaction failure through nested error causes. */
+declare function getTransactionFailureOutcome(error: unknown): TransactionFailureOutcome | null;
+/**
+ * Normalize an adapter/host exception without retrying or resubmitting.
+ */
+declare function normalizeTransactionError(cause: unknown, errorMetadata?: readonly ErrorMetadata[], fallbackPhase?: 'wallet' | 'send'): InstructionError | TransactionExecutionError;
 
 /**
- * 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;
+}
+/**
+ * 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;
 }
 /**
- * Executes an instruction handler with the given arguments and options.
+ * 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 +682,7 @@ type SeedDef = {
 interface PdaDeriveContext {
     accounts?: Record<string, string>;
     args?: Record<string, unknown>;
+    resolve?: Record<string, unknown>;
     programId?: string;
 }
 interface PdaFactory {
@@ -426,6 +709,9 @@ type Update<T> = {
     type: 'patch';
     key: string;
     data: Partial<T>;
+} | {
+    type: 'remove';
+    key: string;
 } | {
     type: 'delete';
     key: string;
@@ -440,41 +726,126 @@ type RichUpdate<T> = {
     before: T;
     after: T;
     patch?: unknown;
+} | {
+    type: 'removed';
+    key: string;
+    lastKnown?: T;
 } | {
     type: 'deleted';
     key: string;
     lastKnown?: T;
 };
-interface ViewDef<T, TMode extends 'state' | 'list'> {
+type ViewKeyValue = string | number | bigint;
+type ViewKeyFields<TKey> = unknown extends TKey ? readonly string[] : TKey extends object ? readonly Extract<keyof TKey, string>[] : readonly string[];
+interface ViewDef<T, TMode extends 'state' | 'list', TKey = unknown> {
     readonly mode: TMode;
     readonly view: string;
+    readonly keyFields?: ViewKeyFields<TKey>;
     readonly _entity?: T;
+    readonly _key?: TKey;
+}
+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;
+    /** Stable fingerprint of the generated program behavior used for client caching. */
+    readonly definitionHash?: 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'>;
-    list?: ViewDef<unknown, 'list'>;
+    state?: ViewDef<any, 'state', any>;
+    list?: ViewDef<any, 'list'>;
 }
-interface Subscription {
+interface SubscriptionQuery {
     view: string;
     key?: string;
     partition?: string;
-    filters?: Record<string, string>;
+    filters?: Record<string, unknown>;
     take?: number;
     skip?: number;
-    /** Whether to include initial snapshot (defaults to true for backward compatibility) */
-    withSnapshot?: boolean;
-    /** Cursor for resuming from a specific point (_seq value) */
     after?: string;
-    /** Maximum number of entities to include in snapshot (pagination hint) */
     snapshotLimit?: number;
 }
+interface SubscriptionSnapshotOptions {
+    enabled: boolean;
+}
+/** Protocol v2 wire subscription. The client-selected ID remains stable across reconnects. */
+interface Subscription {
+    type: 'subscribe';
+    protocolVersion: 2;
+    subscriptionId: string;
+    query: SubscriptionQuery;
+    snapshot: SubscriptionSnapshotOptions;
+}
+interface SubscriptionRequest {
+    query: SubscriptionQuery;
+    snapshot?: Partial<SubscriptionSnapshotOptions>;
+}
+/** Canonical query identity includes every server query field and snapshot behavior. */
+type SubscriptionIdentity = SubscriptionRequest;
+type SubscriptionOptions = SubscriptionSnapshotOptions;
+interface QuerySnapshot<T = unknown> {
+    readonly subscriptionId: string;
+    readonly query: SubscriptionQuery;
+    readonly keys: readonly string[];
+    readonly data: readonly T[];
+    readonly isLoading: boolean;
+    readonly isRefreshing: boolean;
+    readonly error?: AreteError;
+}
+interface QueryLease {
+    readonly subscription: Subscription;
+    readonly queryKey: string;
+    getSnapshot<T = unknown>(): QuerySnapshot<T>;
+    onChange(callback: () => void): UnsubscribeFn;
+    onUpdate<T = unknown>(callback: (update: Update<T>) => void): UnsubscribeFn;
+    onRichUpdate<T = unknown>(callback: (update: RichUpdate<T>) => void): UnsubscribeFn;
+    refresh(): Promise<void>;
+    release(): void;
+}
 type SchemaResult<T> = {
     success: true;
     data: T;
@@ -486,9 +857,10 @@ interface Schema<T> {
     safeParse: (input: unknown) => SchemaResult<T>;
 }
 interface WatchOptions<TSchema = unknown> {
+    partition?: string;
     take?: number;
     skip?: number;
-    filters?: Record<string, string>;
+    filters?: Record<string, unknown>;
     schema?: Schema<TSchema>;
     /** Whether to include initial snapshot (defaults to true) */
     withSnapshot?: boolean;
@@ -499,6 +871,9 @@ interface WatchOptions<TSchema = unknown> {
 }
 interface AreteOptions<TStack extends StackDefinition> {
     stack: TStack;
+    /** Connect immediately when the client is created (defaults to true). */
+    autoConnect?: boolean;
+    /** Reconnect automatically after an established connection is lost (defaults to true). */
     autoReconnect?: boolean;
     reconnectIntervals?: number[];
     maxReconnectAttempts?: number;
@@ -509,6 +884,10 @@ interface AuthTokenResult {
     token: string;
     expiresAt?: number;
     expires_at?: number;
+    scopes?: readonly string[];
+}
+interface AuthTokenRequest {
+    scopes: readonly string[];
 }
 interface WebSocketFactoryInit {
     headers?: Record<string, string>;
@@ -518,7 +897,7 @@ interface WebSocketFactoryInit {
  */
 interface AuthConfig {
     /** Custom token provider function - called before each connection and during refresh */
-    getToken?: () => Promise<string | AuthTokenResult>;
+    getToken?: (request?: AuthTokenRequest) => Promise<string | AuthTokenResult>;
     /** Arete Cloud token endpoint URL */
     tokenEndpoint?: string;
     /** Publishable key for Arete Cloud */
@@ -535,7 +914,10 @@ interface AuthConfig {
     tokenEndpointCredentials?: RequestCredentials;
 }
 interface AreteConfig {
-    websocketUrl?: string;
+    /** WebSocket endpoint. `null`/omitted disables the WebSocket transport (HTTP-only mode). */
+    websocketUrl?: string | null;
+    /** Reconnect automatically after an established connection is lost (defaults to true). */
+    autoReconnect?: boolean;
     reconnectIntervals?: number[];
     maxReconnectAttempts?: number;
     initialSubscriptions?: Subscription[];
@@ -546,14 +928,15 @@ interface AreteConfig {
 interface SocketIssue {
     error: string;
     message: string;
-    code: AuthErrorCode;
+    code: string | AuthErrorCode;
     retryable: boolean;
     retryAfter?: number;
     suggestedAction?: string;
     docsUrl?: string;
     fatal: boolean;
+    subscriptionId?: string | null;
 }
-declare const DEFAULT_CONFIG: Required<Pick<AreteConfig, 'reconnectIntervals' | 'maxReconnectAttempts' | 'maxEntriesPerView'>>;
+declare const DEFAULT_CONFIG: Required<Pick<AreteConfig, 'autoReconnect' | 'reconnectIntervals' | 'maxReconnectAttempts' | 'maxEntriesPerView'>>;
 /**
  * Machine-readable error codes for authentication and rate limiting failures
  *
@@ -569,21 +952,22 @@ type TypedViews<TViews extends StackDefinition['views']> = {
     [K in keyof TViews]: TypedViewGroup<TViews[K]>;
 };
 type TypedViewGroup<TGroup> = {
-    [K in keyof TGroup]: TGroup[K] extends ViewDef<infer T, 'state'> ? TypedStateView<T> : TGroup[K] extends ViewDef<infer T, 'list'> ? TypedListView<T> : never;
+    [K in keyof TGroup]: TGroup[K] extends ViewDef<infer T, 'state', infer TKey> ? TypedStateView<T, DefaultViewKey<TKey>> : TGroup[K] extends ViewDef<infer T, 'list'> ? TypedListView<T> : never;
 };
-interface TypedStateView<T> {
-    use<TSchema = T>(key: string, options?: WatchOptions<TSchema>): AsyncIterable<TSchema>;
-    watch(key: string, options?: WatchOptions): AsyncIterable<Update<T>>;
-    watchRich(key: string, options?: WatchOptions): AsyncIterable<RichUpdate<T>>;
-    get(key: string): Promise<T | null>;
-    getSync(key: string): T | null | undefined;
+type DefaultViewKey<TKey> = unknown extends TKey ? string : TKey;
+interface TypedStateView<T, TKey = string> {
+    use<TSchema = T>(key: TKey, options?: WatchOptions<TSchema>): AsyncIterable<TSchema>;
+    watch(key: TKey, options?: WatchOptions): AsyncIterable<Update<T>>;
+    watchRich(key: TKey, options?: WatchOptions): AsyncIterable<RichUpdate<T>>;
+    get(key: TKey, options?: WatchOptions): Promise<T | null>;
+    getSync(key: TKey, options?: WatchOptions): T | null | undefined;
 }
 interface TypedListView<T> {
     use<TSchema = T>(options?: WatchOptions<TSchema>): AsyncIterable<TSchema>;
     watch(options?: WatchOptions): AsyncIterable<Update<T>>;
     watchRich(options?: WatchOptions): AsyncIterable<RichUpdate<T>>;
-    get(): Promise<T[]>;
-    getSync(): T[] | undefined;
+    get(options?: WatchOptions): Promise<T[]>;
+    getSync(options?: WatchOptions): T[] | undefined;
 }
 type SubscribeCallback<T> = (update: Update<T>) => void;
 type UnsubscribeFn = () => void;
@@ -591,52 +975,77 @@ type ConnectionStateCallback = (state: ConnectionState, error?: string) => void;
 type SocketIssueCallback = (issue: SocketIssue) => void;
 
 type FrameMode = 'state' | 'append' | 'list';
-type FrameOp = 'create' | 'upsert' | 'patch' | 'delete' | 'snapshot' | 'subscribed';
+type FrameOp = 'subscribed' | 'unsubscribed' | 'snapshot' | 'upsert' | 'patch' | 'remove' | 'delete';
 type SortOrder = 'asc' | 'desc';
 interface SortConfig {
     field: string[];
     order: SortOrder;
 }
-interface SubscribedFrame {
+interface IdentifiedFrame {
+    protocolVersion: 2;
+    subscriptionId: string;
+}
+interface SubscribedFrame extends IdentifiedFrame {
     op: 'subscribed';
-    view: string;
+    query: SubscriptionQuery;
     mode: FrameMode;
     sort?: SortConfig;
 }
-interface EntityFrame<T = unknown> {
+interface UnsubscribedFrame extends IdentifiedFrame {
+    op: 'unsubscribed';
+}
+interface EntityFrame<T = unknown> extends IdentifiedFrame {
     mode: FrameMode;
     entity: string;
-    op: FrameOp;
+    op: 'upsert' | 'patch' | 'remove' | 'delete';
     key: string;
-    data: T;
+    data: T | null;
     append?: string[];
-    /** Sequence cursor for ordering and resume capability */
     seq?: string;
 }
 interface SnapshotEntity<T = unknown> {
     key: string;
     data: T;
 }
-interface SnapshotFrame<T = unknown> {
+interface SnapshotFrame<T = unknown> extends IdentifiedFrame {
+    snapshotId: string;
+    authoritative: boolean;
     mode: FrameMode;
     entity: string;
     op: 'snapshot';
+    key?: string;
     data: SnapshotEntity<T>[];
-    /** Indicates if this is the final snapshot batch. When false, more batches will follow. */
-    complete?: boolean;
+    complete: boolean;
 }
-type Frame<T = unknown> = EntityFrame<T> | SnapshotFrame<T> | SubscribedFrame;
+interface ErrorFrame {
+    type: 'error';
+    protocolVersion: 2;
+    subscriptionId: string | null;
+    error?: string;
+    message?: string;
+    code: string;
+    retryable?: boolean;
+    fatal: boolean;
+    retry_after?: number;
+    suggested_action?: string;
+    docs_url?: string;
+}
+type Frame<T = unknown> = EntityFrame<T> | SnapshotFrame<T> | SubscribedFrame | UnsubscribedFrame | ErrorFrame;
 declare function isSnapshotFrame<T>(frame: Frame<T>): frame is SnapshotFrame<T>;
 declare function isSubscribedFrame(frame: Frame): frame is SubscribedFrame;
+declare function isUnsubscribedFrame(frame: Frame): frame is UnsubscribedFrame;
+declare function isErrorFrame(frame: Frame): frame is ErrorFrame;
 declare function isEntityFrame<T>(frame: Frame<T>): frame is EntityFrame<T>;
 declare function parseFrame(data: ArrayBuffer | string): Frame;
 declare function parseFrameFromBlob(blob: Blob): Promise<Frame>;
 declare function isValidFrame(frame: unknown): frame is Frame;
 
 type FrameHandler = <T>(frame: Frame<T>) => void;
+declare function isHostedAreteEndpoint(url: string): boolean;
 declare class ConnectionManager {
     private ws;
     private websocketUrl;
+    private readonly autoReconnect;
     private reconnectIntervals;
     private maxReconnectAttempts;
     private reconnectAttempts;
@@ -644,15 +1053,20 @@ declare class ConnectionManager {
     private pingInterval;
     private tokenRefreshTimeout;
     private tokenRefreshInFlight;
+    private tokenRequestInFlight;
     private currentState;
     private subscriptionQueue;
     private activeSubscriptions;
+    private socketGeneration;
+    private pendingConnect;
     private frameHandlers;
     private stateHandlers;
     private socketIssueHandlers;
     private authConfig?;
     private currentToken?;
     private tokenExpiry?;
+    private tokenScopes;
+    private requestedScopes;
     private readonly hostedAreteUrl;
     private reconnectForTokenRefresh;
     constructor(config: AreteConfig);
@@ -661,7 +1075,9 @@ declare class ConnectionManager {
     private hasRefreshableAuth;
     private updateTokenState;
     private clearTokenState;
+    private tokenCovers;
     private getOrRefreshToken;
+    private fetchAuthToken;
     private createTokenEndpointRequestBody;
     private fetchTokenFromEndpoint;
     private isTokenExpired;
@@ -673,20 +1089,25 @@ declare class ConnectionManager {
     private handleSocketIssueMessage;
     private rotateConnectionForTokenRefresh;
     private buildAuthUrl;
+    private requireWebsocketUrl;
     private createWebSocket;
     getState(): ConnectionState;
+    getHttpAuthToken(forceRefresh?: boolean): Promise<string | undefined>;
+    getHttpAuthToken(requiredScopes?: readonly string[], forceRefresh?: boolean): Promise<string | undefined>;
+    clearHttpAuthToken(): void;
     onFrame(handler: FrameHandler): () => void;
     onStateChange(handler: ConnectionStateCallback): () => void;
     onSocketIssue(handler: SocketIssueCallback): () => void;
     private notifySocketIssue;
-    connect(): Promise<void>;
+    connect(recovering?: boolean): Promise<void>;
     disconnect(): void;
     subscribe(subscription: Subscription): void;
-    unsubscribe(view: string, key?: string): void;
+    unsubscribe(subscriptionId: string): void;
+    refresh(subscription: Subscription): void;
     isConnected(): boolean;
-    private makeSubKey;
     private flushSubscriptionQueue;
     private resubscribeActive;
+    private addQueuedSubscription;
     private updateState;
     private notifyFrameHandlers;
     private handleReconnect;
@@ -696,7 +1117,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,77 +1143,57 @@ 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;
 }
 
-declare class SubscriptionRegistry {
-    private subscriptions;
-    private connection;
-    constructor(connection: ConnectionManager);
-    subscribe(subscription: Subscription): UnsubscribeFn;
-    unsubscribe(subscription: Subscription): void;
-    getRefCount(subscription: Subscription): number;
-    getActiveSubscriptions(): Subscription[];
+declare class QueryStore {
+    private readonly storage;
+    private readonly records;
+    constructor(storage: StorageAdapter);
+    register(subscription: Subscription, queryKey: string): void;
+    unregister(subscriptionId: string): void;
+    getSubscription(subscriptionId: string): Subscription | undefined;
+    getQueryKey(subscriptionId: string): string | undefined;
+    getSnapshot<T>(subscriptionId: string): QuerySnapshot<T> | undefined;
+    onChange(subscriptionId: string, callback: () => void): UnsubscribeFn;
+    onUpdate<T>(subscriptionId: string, callback: (update: Update<T>) => void): UnsubscribeFn;
+    onRichUpdate<T>(subscriptionId: string, callback: (update: RichUpdate<T>) => void): UnsubscribeFn;
+    acknowledge(subscriptionId: string, effectiveQuery: SubscriptionQuery, mode: FrameMode, sort?: SortConfig): void;
+    stageSnapshot(frame: SnapshotFrame, keys: readonly string[]): void;
+    applyLive(subscriptionId: string, key: string, update: Update<unknown>, richUpdate?: RichUpdate<unknown>, sequence?: string): void;
+    deleteGlobal(view: string, key: string, lastKnown?: unknown): void;
+    evict(view: string, key: string): void;
+    failFrame(frame: ErrorFrame): void;
+    beginRefresh(subscriptionId: string, waitForSnapshot?: boolean): Promise<void>;
+    failRefresh(subscriptionId: string, error: AreteError): void;
+    beginReconnect(): void;
+    failRefreshing(error: AreteError): void;
     clear(): void;
-    private makeSubKey;
+    private mergeIncremental;
+    private sortKeys;
+    private entitySequence;
+    private fail;
+    private resolveRefresh;
+    private rejectRefresh;
+    private requireRecord;
+    private touch;
+    private emitUpdate;
+    private emitRichUpdate;
 }
 
-interface ConnectOptions {
-    url?: string;
-    storage?: StorageAdapter;
-    maxEntriesPerView?: number | null;
-    autoReconnect?: boolean;
-    reconnectIntervals?: number[];
-    maxReconnectAttempts?: number;
-    flushIntervalMs?: number;
-    validateFrames?: boolean;
-    /** Authentication configuration */
-    auth?: AuthConfig;
-}
-/** @deprecated Use ConnectOptions instead */
-interface AreteOptionsWithStorage<TStack extends StackDefinition> extends AreteOptions<TStack> {
-    storage?: StorageAdapter;
-    maxEntriesPerView?: number | null;
-    flushIntervalMs?: number;
-    auth?: AuthConfig;
+interface WaitForProcessedSlotOptions {
+    /** Reject if the requested slot has not been processed within this duration. */
+    timeoutMs?: number;
+    /** Abort this wait without affecting frame processing or the connection. */
+    signal?: AbortSignal;
 }
-interface InstructionExecutorOptions extends Omit<ExecuteOptions, 'wallet'> {
-    wallet: WalletAdapter;
-}
-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> {
-    private readonly connection;
-    private readonly storage;
-    private readonly processor;
-    private readonly subscriptionRegistry;
-    private readonly _views;
-    private readonly stack;
-    private readonly _instructions;
-    private constructor();
-    private buildInstructions;
-    static connect<T extends StackDefinition>(stack: T, options?: ConnectOptions): Promise<Arete<T>>;
-    get views(): TypedViews<TStack['views']>;
-    get instructions(): InstructionsInterface<TStack['instructions']>;
-    get connectionState(): ConnectionState;
-    get stackName(): string;
-    get store(): StorageAdapter;
-    onConnectionStateChange(callback: ConnectionStateCallback): UnsubscribeFn;
-    onFrame(callback: (frame: Frame) => void): UnsubscribeFn;
-    onSocketIssue(callback: SocketIssueCallback): UnsubscribeFn;
-    connect(): Promise<void>;
-    disconnect(): void;
-    isConnected(): boolean;
-    clearStore(): void;
-    getStore(): StorageAdapter;
-    getConnection(): ConnectionManager;
-    getSubscriptionRegistry(): SubscriptionRegistry;
+declare class ProcessedSlotTimeoutError extends Error {
+    readonly targetSlot: bigint;
+    readonly processedSlot: bigint | null;
+    constructor(targetSlot: bigint, processedSlot: bigint | null);
 }
-
 interface FrameProcessorConfig {
     maxEntriesPerView?: number | null;
     /**
@@ -805,24 +1206,54 @@ interface FrameProcessorConfig {
      */
     flushIntervalMs?: number;
     schemas?: Record<string, Schema<unknown>>;
+    patchSchemas?: Record<string, Schema<unknown>>;
+    queryStore?: QueryStore;
+    /** Whether rejected frames should also be written to `console.warn`. */
+    warnOnValidationError?: boolean;
+    /** Receives structured details whenever a generated schema rejects a frame. */
+    onValidationError?: (diagnostic: FrameValidationDiagnostic) => void;
+}
+interface FrameValidationDiagnostic {
+    readonly view: string;
+    readonly key?: string;
+    readonly seq?: string;
+    readonly operation: 'snapshot' | 'upsert' | 'patch';
+    readonly error: unknown;
 }
 declare class FrameProcessor {
     private storage;
     private maxEntriesPerView;
     private flushIntervalMs;
     private schemas?;
+    private patchSchemas?;
+    private queryStore?;
+    private warnOnValidationError;
+    private onValidationError?;
     private pendingUpdates;
     private flushTimer;
     private isProcessing;
+    private latestProcessedSlot;
+    private processedSlotWaiters;
     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 compareSeq;
+    private attachInternalSeq;
     handleFrame<T>(frame: Frame<T>): void;
     /**
      * Immediately flush all pending updates.
      * Useful for ensuring all updates are processed before reading state.
      */
     flush(): void;
+    getProcessedSlot(): bigint | null;
+    waitForProcessedSlot(slot: number | bigint, options?: WaitForProcessedSlotOptions): Promise<bigint>;
     /**
      * Clean up any pending timers. Call when disposing the processor.
      */
@@ -830,6 +1261,12 @@ declare class FrameProcessor {
     private scheduleFlush;
     private flushPendingUpdates;
     private processFrame;
+    private normalizeSlot;
+    private slotFromSeq;
+    private frameSlot;
+    private markFrameProcessed;
+    private removeProcessedSlotWaiter;
+    private createAbortError;
     private processFrameWithoutEnforce;
     private handleSubscribedFrame;
     private handleSnapshotFrame;
@@ -837,48 +1274,867 @@ declare class FrameProcessor {
     private handleEntityFrame;
     private handleEntityFrameWithoutEnforce;
     private emitRichUpdate;
+    private createRichUpdate;
     private enforceMaxEntries;
 }
 
-interface EntityStoreConfig {
-    maxEntriesPerView?: number | null;
+interface NormalizedSubscriptionRequest {
+    query: SubscriptionQuery;
+    snapshot: SubscriptionSnapshotOptions;
 }
-interface ViewConfig {
-    sort?: SortConfig;
+declare function validateSubscriptionId(subscriptionId: string): void;
+declare function createSubscriptionId(): string;
+declare function normalizeSubscriptionQuery(query: SubscriptionQuery): SubscriptionQuery;
+declare function normalizeSubscriptionRequest(request: SubscriptionRequest): NormalizedSubscriptionRequest;
+declare function canonicalQueryKey(request: SubscriptionRequest): string;
+declare function normalizeSubscription(subscription: Subscription): Subscription;
+declare class SubscriptionRegistry {
+    private readonly connection;
+    private readonly queryStore;
+    private readonly subscriptions;
+    private readonly subscriptionsById;
+    constructor(connection: ConnectionManager, queryStore: QueryStore);
+    subscribe(query: SubscriptionQuery, snapshotEnabled?: boolean): QueryLease;
+    refresh(query: SubscriptionQuery, snapshotEnabled?: boolean): Promise<void>;
+    /**
+     * Refresh every active subscription for a view, optionally narrowed to one
+     * serialized key. Resolves immediately when nothing matches — refreshing a
+     * view with no active subscriptions is a no-op, not an error.
+     */
+    refreshView(view: string, key?: string): Promise<void>;
+    getRefCount(query: SubscriptionQuery, snapshotEnabled?: boolean): number;
+    getActiveSubscriptions(): Subscription[];
+    getSnapshot<T>(query: SubscriptionQuery, snapshotEnabled?: boolean): QuerySnapshot<T> | undefined;
+    handleConnectionState(state: ConnectionState): void;
+    clear(): void;
+    private createLease;
+    private getTracker;
+    private refreshTracker;
+    private releaseTracker;
 }
-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;
+
+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;
+    contextSlot: bigint;
+}
+interface NativeBalanceInfo {
+    lamports: bigint;
+    contextSlot: bigint;
+}
+interface ContextSlotOptions {
+    minContextSlot?: number | bigint;
+}
+interface TokenBalanceInput {
+    owner: string;
+    mint: string;
+    tokenProgram?: string;
+}
+interface RawAccountInfo {
+    address: string;
+    ownerProgram: string;
+    lamports: number;
+    executable: boolean;
+    data: Uint8Array;
+}
+interface ChainClient {
+    exists(address: string): Promise<boolean>;
+    lamports(address: string): Promise<number>;
+    nativeBalance(address: string, options?: ContextSlotOptions): Promise<NativeBalanceInfo>;
+    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: TokenBalanceInput, options?: ContextSlotOptions): 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;
-    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 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 OperationInspection {
+    /** JSON-safe description produced by {@link describePreparedOperation}. */
+    readonly description: PreparedOperationDescription;
+    /** Raw unsigned inspection returned by the adapter. */
+    readonly transaction: TransactionInspectionResult;
+    /** IDL-aware program error parsed from the inspection failure, if any. */
+    readonly programError: ProgramError | null;
+}
+interface OperationInspectionOptions {
+    wallet?: WalletAdapter;
+    inspect?: TransactionInspectionOptions;
+    transactionTransport?: TransactionTransport;
+}
+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;
+    readonly callbackErrors?: readonly OperationCallbackError[];
+}
+interface FlowOperationReceipt<TArtifacts> {
+    readonly kind: 'flow';
+    readonly operationName: string;
+    readonly artifacts: TArtifacts;
+    readonly signatures: NonEmptyReadonlyArray<string>;
+    readonly transactions: NonEmptyReadonlyArray<OperationTransactionReceipt>;
+    readonly callbackErrors?: readonly OperationCallbackError[];
+}
+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;
+}
+type OperationCallbackPhase = 'transaction-start' | 'transaction-success';
+interface OperationExecutionOptions<TSigner = unknown, TPrepared extends PreparedOperation = PreparedOperation> {
+    wallet?: WalletAdapter;
+    transactionTransport?: TransactionTransport;
+    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>;
+    /** Receives observer failures without changing the transaction outcome. */
+    onCallbackError?: (error: OperationCallbackError<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[];
+        transactionTransport?: TransactionTransport;
+    }): Promise<{
+        signature: string;
+        slot?: number;
+    }>;
+}
+declare class OperationCallbackError<TPrepared extends PreparedOperation = PreparedOperation> extends Error {
+    readonly phase: OperationCallbackPhase;
+    readonly operation: TPrepared;
+    readonly transaction: PreparedTransactionBody;
+    readonly transactionIndex: number;
+    readonly receipt?: OperationTransactionReceipt;
+    readonly cause: unknown;
+    constructor(input: {
+        phase: OperationCallbackPhase;
+        operation: TPrepared;
+        transaction: PreparedTransactionBody;
+        transactionIndex: number;
+        receipt?: OperationTransactionReceipt;
+        cause: unknown;
+    });
+}
+declare class OperationExecutionError<TPrepared extends PreparedOperation = PreparedOperation> extends Error {
+    readonly operation: TPrepared;
+    readonly failedTransaction: PreparedTransactionBody;
+    readonly failedTransactionIndex: number;
+    readonly completedReceipts: readonly OperationTransactionReceipt[];
+    readonly callbackErrors: readonly OperationCallbackError<TPrepared>[];
+    readonly outcome: TransactionFailureOutcome;
+    readonly signature?: string;
+    readonly slot?: number;
+    readonly cause: unknown;
+    constructor(input: {
+        operation: TPrepared;
+        failedTransaction: PreparedTransactionBody;
+        failedTransactionIndex: number;
+        completedReceipts: readonly OperationTransactionReceipt[];
+        callbackErrors?: readonly OperationCallbackError<TPrepared>[];
+        outcome?: TransactionFailureOutcome;
+        cause: unknown;
+    });
+}
+declare function executePreparedOperation<TPrepared extends PreparedOperation, TSigner = unknown>(host: OperationExecutionHost<TSigner>, operation: TPrepared, options?: OperationExecutionOptions<TSigner, TPrepared>): Promise<OperationReceiptFor<TPrepared>>;
+/**
+ * Recursively unwrap operation context while retaining structured transaction outcomes.
+ */
+declare function unwrapOperationExecutionError(error: unknown): InstructionError | TransactionFailureOutcome | unknown;
+declare function toJsonValue(value: unknown): JsonValue;
+declare function describePreparedOperation(operation: PreparedOperation): PreparedOperationDescription;
+/**
+ * Inspect one prepared instruction/transaction without signing or submission.
+ * Multi-transaction flows are intentionally unsupported.
+ */
+declare function inspectPreparedOperation(wallet: WalletAdapter | undefined, operation: PreparedOperation, options?: TransactionInspectionOptions, context?: WalletExecutionContext): Promise<OperationInspection>;
+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>;
+/** Fixed arity, or `[required, total]` when a read has optional arguments. */
+type ReadArgumentCount = number | readonly [required: number, total: number];
+type RequiredArgumentCount<TArgs extends readonly unknown[], TCount extends readonly unknown[] = []> = TArgs extends readonly [infer THead, ...infer TTail] ? undefined extends THead ? TCount['length'] : RequiredArgumentCount<TTail, readonly [...TCount, unknown]> : TCount['length'];
+type ReadArgumentCountFor<TRead> = TRead extends (...args: infer TArgs) => unknown ? number extends Required<TArgs>['length'] ? ReadArgumentCount : RequiredArgumentCount<TArgs> extends Required<TArgs>['length'] ? Required<TArgs>['length'] : readonly [
+    required: RequiredArgumentCount<TArgs>,
+    total: Required<TArgs>['length']
+] : never;
+type ReadArgumentCounts<TRead = Record<string, unknown>> = {
+    readonly [K in keyof TRead]: ReadArgumentCountFor<TRead[K]>;
+};
+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> = Omit<TBase, 'definitionHash'> & 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 readArgCounts?: ReadArgumentCounts<TRead>;
+    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 readArgCounts?: ReadArgumentCounts<TRead>;
+    readonly createRead?: (client: TClient) => TRead;
+    readonly createFlows?: (client: TClient) => TFlows;
+}
+type ReadArgumentCountRequirement<TExtension> = TExtension extends {
+    readonly createRead: (...args: any[]) => infer TRead;
+} ? {
+    readonly readArgCounts: ReadArgumentCounts<TRead>;
+} : {};
+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>(): <const TExtension extends StackExtensionInput<any, any, any, any, any, FlowOperationNamespace | EmptyRecord, any>>(extensions: TExtension & ReadArgumentCountRequirement<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 & ReadArgumentCountRequirement<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<StackReadOf<TStack>> | 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;
+    /** Connect immediately when the client is created (defaults to true). */
+    autoConnect?: boolean;
+    /** Reconnect automatically after an established connection is lost (defaults to true). */
+    autoReconnect?: boolean;
+    reconnectIntervals?: number[];
+    maxReconnectAttempts?: number;
+    flushIntervalMs?: number;
+    /**
+     * Generated schemas are always applied to normalize typed entities. Set this
+     * to `false` to suppress console warnings for rejected frames while keeping
+     * schema normalization and `onFrameValidationError` active.
+     */
+    validateFrames?: boolean;
+    /** Observe generated-schema rejections without scraping console warnings. */
+    onFrameValidationError?: (diagnostic: FrameValidationDiagnostic) => void;
+    /** 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>;
+    onFrameValidationError?: (diagnostic: FrameValidationDiagnostic) => void;
+}
+interface TransactionOptions<TSigner = unknown> {
+    wallet?: WalletAdapter;
+    transactionTransport?: TransactionTransport;
+    send?: SendOptions;
+    errors?: ErrorMetadata[];
+    signers?: readonly TSigner[];
+}
+/**
+ * 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;
+}
+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 queryStore;
+    private readonly _views;
+    private readonly _queries;
+    private readonly _programs;
+    private readonly _chain;
+    private readonly _transactions;
+    private readonly stack;
+    private readonly httpBaseUrl;
+    private readonly fetchImpl;
+    private readonly executionDefaults?;
+    private _wallet?;
+    private _aggregatedErrors?;
+    private constructor();
+    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 queries(): QueriesInterface<TStack['queries']>;
+    get programs(): ProgramsInterface<TStack['programs']>;
+    get chain(): ChainClient;
+    get transactions(): TransactionTransport;
+    /** 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>>;
+    /** Inspect one prepared instruction/transaction without signing or submitting it. */
+    inspectOperation(prepared: PreparedOperation, options?: OperationInspectionOptions): Promise<OperationInspection>;
+    /** Error metadata from every handler in the stack, deduped by code. */
+    private aggregateErrors;
+    get connectionState(): ConnectionState;
+    get stackName(): string;
+    get store(): StorageAdapter;
+    /** Highest Solana slot whose streamed frame has been stored locally. */
+    get processedSlot(): bigint | null;
+    /**
+     * Wait until a frame at or beyond `slot` has been applied to local storage.
+     * Buffered frames satisfy the wait only after their storage batch is flushed.
+     */
+    waitForProcessedSlot(slot: number | bigint, options?: WaitForProcessedSlotOptions): Promise<bigint>;
+    onConnectionStateChange(callback: ConnectionStateCallback): UnsubscribeFn;
+    onFrame(callback: (frame: Frame) => void): UnsubscribeFn;
+    onSocketIssue(callback: SocketIssueCallback): UnsubscribeFn;
+    connect(): Promise<void>;
+    disconnect(): void;
+    isConnected(): boolean;
+    clearStore(): void;
+    getStore(): StorageAdapter;
+    getConnection(): ConnectionManager;
+    getSubscriptionRegistry(): SubscriptionRegistry;
+    getQueryStore(): QueryStore;
 }
 
+/**
+ * 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;
+    autoConnect?: boolean;
+    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;
+    /** Transaction transport override; defaults to the execution host's authenticated client. */
+    transactions?: TransactionTransport;
+    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;
+    readonly transactions: TransactionTransport;
+    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;
+/** Convert an amount to raw units without throwing on invalid user input. */
+declare function safeToRawAmount(amount: AmountInput, decimals: number): SchemaResult<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;
+}>;
+
+/**
+ * Recursively convert bigints to their decimal string form.
+ *
+ * Streamed entities contain bigints, which makes them unsafe to pass through
+ * anything that JSON-stringifies (React's dev-mode performance tooling, log
+ * pipelines, `JSON.stringify` persistence). Prefer stack-provided UI fields
+ * (e.g. `deployedPerSquareUi`) when they exist; use this for the remaining
+ * raw values such as account snapshots.
+ *
+ * Arrays and plain objects are converted structurally and the return type
+ * maps every `bigint` to `string`; class instances (PublicKey, Date, …) are
+ * returned untouched.
+ */
+type StringifiedBigints<T> = T extends bigint ? string : T extends readonly (infer U)[] ? readonly StringifiedBigints<U>[] : T extends object ? {
+    [K in keyof T]: StringifiedBigints<T[K]>;
+} : T;
+declare function stringifyBigints<T>(value: T): StringifiedBigints<T>;
+
+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>;
+
 declare class MemoryAdapter implements StorageAdapter {
     private views;
     private updateCallbacks;
@@ -896,18 +2152,23 @@ 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;
 }
 
-declare function createUpdateStream<T>(storage: StorageAdapter, subscriptionRegistry: SubscriptionRegistry, subscription: Subscription, keyFilter?: string): AsyncIterable<Update<T>>;
-declare function createEntityStream<T>(storage: StorageAdapter, subscriptionRegistry: SubscriptionRegistry, subscription: Subscription, options?: WatchOptions<any>, keyFilter?: string): AsyncIterable<T>;
-declare function createRichUpdateStream<T>(storage: StorageAdapter, subscriptionRegistry: SubscriptionRegistry, subscription: Subscription, keyFilter?: string): AsyncIterable<RichUpdate<T>>;
+declare function createUpdateStream<T>(_storage: StorageAdapter, subscriptionRegistry: SubscriptionRegistry, query: SubscriptionQuery, keyFilter?: string, snapshotEnabled?: boolean): AsyncIterable<Update<T>>;
+declare function createEntityStream<T>(_storage: StorageAdapter, subscriptionRegistry: SubscriptionRegistry, query: SubscriptionQuery, options?: WatchOptions<any>, keyFilter?: string): AsyncIterable<T>;
+declare function createRichUpdateStream<T>(_storage: StorageAdapter, subscriptionRegistry: SubscriptionRegistry, query: SubscriptionQuery, keyFilter?: string, snapshotEnabled?: boolean): AsyncIterable<RichUpdate<T>>;
 
-declare function createTypedStateView<T>(viewDef: ViewDef<T, 'state'>, storage: StorageAdapter, subscriptionRegistry: SubscriptionRegistry): TypedStateView<T>;
+declare function serializeViewKey<TKey>(viewDef: ViewDef<unknown, 'state', TKey>, key: TKey): string;
+declare function createTypedStateView<T, TKey = unknown>(viewDef: ViewDef<T, 'state', TKey>, storage: StorageAdapter, subscriptionRegistry: SubscriptionRegistry): TypedStateView<T, DefaultViewKey<TKey>>;
 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, OperationCallbackError, OperationExecutionError, PROGRAM_OPERATION_EXTENSIONS, ProcessedSlotTimeoutError, QueryStore, ReadRequestError, SPL_TOKEN_PROGRAM_ADDRESS, STACK_RUNTIME_EXTENSIONS, SYSTEM_PROGRAM_ADDRESS, SubscriptionRegistry, TOKEN_2022_PROGRAM_ADDRESS, TransactionExecutionError, TransactionTransportError, account, appendFlowTransactions, appendTransactionInstructions, applyConnectedStackExtensions, arg, buildInstruction, bytes, canonicalQueryKey, chainAccountLoader, createChainClient, createEntityStream, 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, getProgramRuntimeExtensions, getStackRuntimeExtensions, getTransactionFailureOutcome, inspectPreparedOperation, instructionOperation, isEntityFrame, isErrorFrame, isHostedAreteEndpoint, isSnapshotFrame, isSubscribedFrame, isUnsubscribedFrame, isValidFrame, literal, normalizeSubscription, normalizeSubscriptionQuery, normalizeSubscriptionRequest, normalizeTransactionError, parseFrame, parseFrameFromBlob, parseInstructionError, parseUiAmountToRaw, pda, prependFlowTransactionInstructions, prependTransactionInstructions, programAccountRead, programQuery, resolveAccounts, resolveAmount, resolveAmountToRaw, resolveAmountsToRaw, resolveTokenProgramAddress, safeToRawAmount, serializeInstructionData, serializeViewKey, stackQuery, stringifyBigints, toJsonValue, toRawAmount, transactionOperation, unwrapOperationExecutionError, validateAccountResolution, validateSubscriptionId, withPrograms };
+export type { AccountCategory, AccountLoader, AccountMeta, AccountResolutionOptions, AccountResolutionResult, AmountInput, AnyOperation, AreteConfig, AreteOptions, AreteOptionsWithStorage, ArgSchema, ArgType, AuthConfig, AuthTokenRequest, AuthTokenResult, BuildOptions, BuiltAccountMeta, BuiltInstruction, ChainClient, ChainClock, ChainFailedTransactionOutcome, 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, InstructionExecutor, InstructionHandler, InstructionHandlerConfig, InstructionOperation, InstructionOperationNamespace, JsonObject, JsonPrimitive, JsonValue, LatestBlockhashResult, MergeProgramMaps, MintAccountInfo, NativeBalanceInfo, NonEmptyReadonlyArray, NotSubmittedTransactionOutcome, OperationCallbackPhase, OperationExecutionEvent, OperationExecutionHost, OperationExecutionOptions, OperationExecutionSuccessEvent, OperationInspection, OperationInspectionOptions, 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, QueryLease, QuerySnapshot, RawAccountInfo, RawInstructionsInterface, RawProgramsInterface, ReadArgumentCount, ReadArgumentCounts, 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, StringifiedBigints, SubmittedUnknownTransactionOutcome, SubscribeCallback, SubscribedFrame, Subscription, SubscriptionIdentity, SubscriptionOptions, SubscriptionQuery, SubscriptionRequest, SubscriptionSnapshotOptions, TokenAccountInfo, TokenBalanceInfo, TokenBalanceInput, TransactionCommitment, TransactionFailureOutcome, TransactionFailurePhase, TransactionFailureStatus, TransactionFeeResult, TransactionInspectionOptions, TransactionInspectionResult, TransactionOperation, TransactionOperationNamespace, TransactionOptions, TransactionOutcome, TransactionRequestContext, TransactionSendOptions, TransactionSendResult, TransactionSignatureStatus, TransactionSimulationOptions, TransactionSimulationResult, TransactionTransport, TransactionTransportErrorBody, TypedAccountReader, TypedInstruction, TypedListView, TypedQueryExecutor, TypedStateView, TypedViewGroup, TypedViews, UnsubscribeFn, UnsubscribedFrame, Update, UpdateCallback, ViewDef, ViewGroup, ViewKeyFields, ViewKeyValue, ViewSortConfig, WaitForProcessedSlotOptions, WalletAdapter, WalletConnectOptions, WalletExecutionContext, WalletState, WatchOptions, WebSocketFactoryInit };