@usearete/sdk 0.1.5 → 0.2.0

package/dist/index.esm.js

@@ -1,4 +1,5 @@
 import { inflate } from 'pako';
+import { Point } from '@noble/ed25519';
 
 const DEFAULT_MAX_ENTRIES_PER_VIEW = 10000;
 const DEFAULT_CONFIG = {
@@ -185,6 +186,11 @@ function isHostedAreteWebsocketUrl(websocketUrl) {
         return false;
     }
 }
+/**
+ * Historical sentinel accepted for back-compat: connecting with this URL is
+ * treated the same as passing no WebSocket URL at all (HTTP-only mode).
+ */
+const DISABLED_WEBSOCKET_URL = 'ws://127.0.0.1/__arete_disabled__';
 class ConnectionManager {
     constructor(config) {
         this.ws = null;
@@ -200,11 +206,11 @@ class ConnectionManager {
         this.stateHandlers = new Set();
         this.socketIssueHandlers = new Set();
         this.reconnectForTokenRefresh = false;
-        if (!config.websocketUrl) {
-            throw new AreteError('websocketUrl is required', 'INVALID_CONFIG');
-        }
-        this.websocketUrl = config.websocketUrl;
-        this.hostedAreteUrl = isHostedAreteWebsocketUrl(config.websocketUrl);
+        const websocketUrl = config.websocketUrl && config.websocketUrl !== DISABLED_WEBSOCKET_URL
+            ? config.websocketUrl
+            : null;
+        this.websocketUrl = websocketUrl;
+        this.hostedAreteUrl = websocketUrl !== null && isHostedAreteWebsocketUrl(websocketUrl);
         this.reconnectIntervals = config.reconnectIntervals ?? DEFAULT_CONFIG.reconnectIntervals;
         this.maxReconnectAttempts =
             config.maxReconnectAttempts ?? DEFAULT_CONFIG.maxReconnectAttempts;
@@ -296,7 +302,7 @@ class ConnectionManager {
     }
     createTokenEndpointRequestBody() {
         return {
-            websocket_url: this.websocketUrl,
+            websocket_url: this.websocketUrl ?? '',
         };
     }
     async fetchTokenFromEndpoint(tokenEndpoint) {
@@ -450,14 +456,21 @@ class ConnectionManager {
         this.ws.close(1000, 'token refresh');
     }
     buildAuthUrl(token) {
+        const websocketUrl = this.requireWebsocketUrl();
         if (this.authConfig?.tokenTransport === 'bearer') {
-            return this.websocketUrl;
+            return websocketUrl;
         }
         if (!token) {
-            return this.websocketUrl;
+            return websocketUrl;
+        }
+        const separator = websocketUrl.includes('?') ? '&' : '?';
+        return `${websocketUrl}${separator}${DEFAULT_QUERY_PARAMETER}=${encodeURIComponent(token)}`;
+    }
+    requireWebsocketUrl() {
+        if (this.websocketUrl === null) {
+            throw new AreteError('WebSocket transport is disabled (client was connected with transport: "http"); views and subscriptions are unavailable', 'WEBSOCKET_DISABLED');
         }
-        const separator = this.websocketUrl.includes('?') ? '&' : '?';
-        return `${this.websocketUrl}${separator}${DEFAULT_QUERY_PARAMETER}=${encodeURIComponent(token)}`;
+        return this.websocketUrl;
     }
     createWebSocket(url, token) {
         if (this.authConfig?.tokenTransport === 'bearer') {
@@ -477,6 +490,12 @@ class ConnectionManager {
     getState() {
         return this.currentState;
     }
+    async getHttpAuthToken(forceRefresh = false) {
+        return this.getOrRefreshToken(forceRefresh);
+    }
+    clearHttpAuthToken() {
+        this.clearTokenState();
+    }
     onFrame(handler) {
         this.frameHandlers.add(handler);
         return () => {
@@ -512,6 +531,7 @@ class ConnectionManager {
         return issue;
     }
     async connect() {
+        this.requireWebsocketUrl();
         if (this.ws?.readyState === WebSocket.OPEN ||
             this.ws?.readyState === WebSocket.CONNECTING ||
             this.currentState === 'connecting') {
@@ -656,6 +676,7 @@ class ConnectionManager {
         }
     }
     subscribe(subscription) {
+        this.requireWebsocketUrl();
         const subKey = this.makeSubKey(subscription);
         if (this.currentState === 'connected' && this.ws?.readyState === WebSocket.OPEN) {
             if (this.activeSubscriptions.has(subKey)) {
@@ -759,16 +780,20 @@ class ConnectionManager {
     }
 }
 
-function isObject$1(item) {
+const INTERNAL_SEQ_FIELD = '__seq';
+function isObject(item) {
     return item !== null && typeof item === 'object' && !Array.isArray(item);
 }
-function deepMergeWithAppend$1(target, source, appendPaths, currentPath = '') {
-    if (!isObject$1(target) || !isObject$1(source)) {
+function deepMergeWithAppend(target, source, appendPaths, currentPath = '') {
+    if (!isObject(target) || !isObject(source)) {
         return source;
     }
     const result = { ...target };
     for (const key in source) {
         const sourceValue = source[key];
+        if (sourceValue === undefined) {
+            continue;
+        }
         const targetValue = result[key];
         const fieldPath = currentPath ? `${currentPath}.${key}` : key;
         if (Array.isArray(sourceValue) && Array.isArray(targetValue)) {
@@ -779,8 +804,8 @@ function deepMergeWithAppend$1(target, source, appendPaths, currentPath = '') {
                 result[key] = sourceValue;
             }
         }
-        else if (isObject$1(sourceValue) && isObject$1(targetValue)) {
-            result[key] = deepMergeWithAppend$1(targetValue, sourceValue, appendPaths, fieldPath);
+        else if (isObject(sourceValue) && isObject(targetValue)) {
+            result[key] = deepMergeWithAppend(targetValue, sourceValue, appendPaths, fieldPath);
         }
         else {
             result[key] = sourceValue;
@@ -788,6 +813,36 @@ function deepMergeWithAppend$1(target, source, appendPaths, currentPath = '') {
     }
     return result;
 }
+function stripUndefinedProperties(value) {
+    if (Array.isArray(value)) {
+        return value.map(item => stripUndefinedProperties(item));
+    }
+    if (!isObject(value)) {
+        return value;
+    }
+    const result = {};
+    for (const [key, nestedValue] of Object.entries(value)) {
+        if (nestedValue === undefined) {
+            continue;
+        }
+        result[key] = stripUndefinedProperties(nestedValue);
+    }
+    return result;
+}
+function toCamelCaseSegment(value) {
+    if (value === '_seq') {
+        return INTERNAL_SEQ_FIELD;
+    }
+    const pascal = value
+        .split(/[_.-]/)
+        .filter(segment => segment.length > 0)
+        .map(segment => segment[0].toUpperCase() + segment.slice(1))
+        .join('');
+    if (pascal.length === 0) {
+        return value;
+    }
+    return pascal[0].toLowerCase() + pascal.slice(1);
+}
 class FrameProcessor {
     constructor(storage, config = {}) {
         this.pendingUpdates = [];
@@ -799,9 +854,10 @@ class FrameProcessor {
             : config.maxEntriesPerView;
         this.flushIntervalMs = config.flushIntervalMs ?? 0;
         this.schemas = config.schemas;
+        this.patchSchemas = config.patchSchemas;
     }
-    getSchema(viewPath) {
-        const schemas = this.schemas;
+    getSchema(viewPath, patch = false) {
+        const schemas = patch ? this.patchSchemas : this.schemas;
         if (!schemas)
             return null;
         const entityName = viewPath.split('/')[0];
@@ -810,19 +866,86 @@ class FrameProcessor {
         const entityKey = entityName;
         return schemas[entityKey] ?? null;
     }
-    validateEntity(viewPath, data) {
-        const schema = this.getSchema(viewPath);
+    normalizeEntity(viewPath, data, patch = false) {
+        const schema = this.getSchema(viewPath, patch)
+            ?? (!patch ? null : this.getSchema(viewPath));
         if (!schema)
-            return true;
+            return data;
         const result = schema.safeParse(data);
         if (!result.success) {
             console.warn('[Arete] Frame validation failed:', {
                 view: viewPath,
                 error: result.error,
             });
-            return false;
+            return null;
         }
-        return true;
+        return stripUndefinedProperties(result.data);
+    }
+    hasSchema(viewPath) {
+        return this.getSchema(viewPath) !== null;
+    }
+    normalizePathSegment(viewPath, segment) {
+        if (!this.hasSchema(viewPath)) {
+            return segment;
+        }
+        return toCamelCaseSegment(segment);
+    }
+    normalizePath(viewPath, path) {
+        if (!this.hasSchema(viewPath)) {
+            return path;
+        }
+        return path
+            .split('.')
+            .filter(segment => segment.length > 0)
+            .map(segment => this.normalizePathSegment(viewPath, segment))
+            .join('.');
+    }
+    normalizeSortConfig(viewPath, sort) {
+        if (!this.hasSchema(viewPath)) {
+            return sort;
+        }
+        return {
+            ...sort,
+            field: sort.field.map(segment => this.normalizePathSegment(viewPath, segment)),
+        };
+    }
+    normalizeAppendPaths(viewPath, append) {
+        if (!append || append.length === 0 || !this.hasSchema(viewPath)) {
+            return append ?? [];
+        }
+        return append.map(path => this.normalizePath(viewPath, path));
+    }
+    extractSeq(data) {
+        if (!isObject(data)) {
+            return undefined;
+        }
+        const seq = data._seq;
+        if (typeof seq === 'string') {
+            return seq;
+        }
+        if (typeof seq === 'number' && Number.isFinite(seq)) {
+            return String(seq);
+        }
+        return undefined;
+    }
+    getInternalSeq(data) {
+        if (!isObject(data)) {
+            return undefined;
+        }
+        const seq = data[INTERNAL_SEQ_FIELD];
+        return typeof seq === 'string' ? seq : undefined;
+    }
+    attachInternalSeq(viewPath, data, seq) {
+        if (!seq || !this.hasSchema(viewPath) || !isObject(data)) {
+            return data;
+        }
+        Object.defineProperty(data, INTERNAL_SEQ_FIELD, {
+            value: seq,
+            enumerable: false,
+            configurable: true,
+            writable: true,
+        });
+        return data;
     }
     handleFrame(frame) {
         if (this.flushIntervalMs === 0) {
@@ -908,7 +1031,9 @@ class FrameProcessor {
     }
     handleSubscribedFrame(frame) {
         if (this.storage.setViewConfig && frame.sort) {
-            this.storage.setViewConfig(frame.view, { sort: frame.sort });
+            this.storage.setViewConfig(frame.view, {
+                sort: this.normalizeSortConfig(frame.view, frame.sort),
+            });
         }
     }
     handleSnapshotFrame(frame) {
@@ -918,17 +1043,19 @@ class FrameProcessor {
     handleSnapshotFrameWithoutEnforce(frame) {
         const viewPath = frame.entity;
         for (const entity of frame.data) {
-            if (!this.validateEntity(viewPath, entity.data)) {
+            const normalized = this.normalizeEntity(viewPath, entity.data);
+            if (normalized === null) {
                 continue;
             }
+            const nextValue = this.attachInternalSeq(viewPath, normalized, this.extractSeq(entity.data));
             const previousValue = this.storage.get(viewPath, entity.key);
-            this.storage.set(viewPath, entity.key, entity.data);
+            this.storage.set(viewPath, entity.key, nextValue);
             this.storage.notifyUpdate(viewPath, entity.key, {
                 type: 'upsert',
                 key: entity.key,
-                data: entity.data,
+                data: nextValue,
             });
-            this.emitRichUpdate(viewPath, entity.key, previousValue, entity.data, 'upsert');
+            this.emitRichUpdate(viewPath, entity.key, previousValue, nextValue, 'upsert');
         }
     }
     handleEntityFrame(frame) {
@@ -941,33 +1068,39 @@ class FrameProcessor {
         switch (frame.op) {
             case 'create':
             case 'upsert':
-                if (!this.validateEntity(viewPath, frame.data)) {
+                {
+                    const normalized = this.normalizeEntity(viewPath, frame.data);
+                    if (normalized === null) {
+                        break;
+                    }
+                    const nextValue = this.attachInternalSeq(viewPath, normalized, frame.seq ?? this.extractSeq(frame.data));
+                    this.storage.set(viewPath, frame.key, nextValue);
+                    this.storage.notifyUpdate(viewPath, frame.key, {
+                        type: 'upsert',
+                        key: frame.key,
+                        data: nextValue,
+                    });
+                    this.emitRichUpdate(viewPath, frame.key, previousValue, nextValue, frame.op);
                     break;
                 }
-                this.storage.set(viewPath, frame.key, frame.data);
-                this.storage.notifyUpdate(viewPath, frame.key, {
-                    type: 'upsert',
-                    key: frame.key,
-                    data: frame.data,
-                });
-                this.emitRichUpdate(viewPath, frame.key, previousValue, frame.data, frame.op);
-                break;
             case 'patch': {
                 const existing = this.storage.get(viewPath, frame.key);
-                const appendPaths = frame.append ?? [];
-                const merged = existing
-                    ? deepMergeWithAppend$1(existing, frame.data, appendPaths)
-                    : frame.data;
-                if (!this.validateEntity(viewPath, merged)) {
+                const normalizedPatch = this.normalizeEntity(viewPath, frame.data, true);
+                if (normalizedPatch === null) {
                     break;
                 }
-                this.storage.set(viewPath, frame.key, merged);
+                const appendPaths = this.normalizeAppendPaths(viewPath, frame.append);
+                const merged = existing
+                    ? deepMergeWithAppend(existing, normalizedPatch, appendPaths)
+                    : normalizedPatch;
+                const nextValue = this.attachInternalSeq(viewPath, merged, frame.seq ?? this.extractSeq(frame.data) ?? this.getInternalSeq(existing));
+                this.storage.set(viewPath, frame.key, nextValue);
                 this.storage.notifyUpdate(viewPath, frame.key, {
                     type: 'patch',
                     key: frame.key,
-                    data: frame.data,
+                    data: normalizedPatch,
                 });
-                this.emitRichUpdate(viewPath, frame.key, previousValue, merged, 'patch', frame.data);
+                this.emitRichUpdate(viewPath, frame.key, previousValue, nextValue, 'patch', normalizedPatch);
                 break;
             }
             case 'delete':
@@ -1000,7 +1133,7 @@ class FrameProcessor {
     }
 }
 
-let ViewData$1 = class ViewData {
+class ViewData {
     constructor() {
         this.entities = new Map();
         this.accessOrder = [];
@@ -1054,7 +1187,7 @@ let ViewData$1 = class ViewData {
         this.entities.clear();
         this.accessOrder = [];
     }
-};
+}
 class MemoryAdapter {
     constructor(_config = {}) {
         this.views = new Map();
@@ -1102,7 +1235,7 @@ class MemoryAdapter {
     set(viewPath, key, data) {
         let view = this.views.get(viewPath);
         if (!view) {
-            view = new ViewData$1();
+            view = new ViewData();
             this.views.set(viewPath, view);
         }
         view.set(key, data);
@@ -1142,7 +1275,7 @@ class MemoryAdapter {
     }
 }
 
-function getNestedValue$1(obj, path) {
+function getNestedValue(obj, path) {
     let current = obj;
     for (const segment of path) {
         if (current === null || current === undefined)
@@ -1153,16 +1286,25 @@ function getNestedValue$1(obj, path) {
     }
     return current;
 }
-function compareSortValues$1(a, b) {
+function compareSortValues(a, b) {
     if (a === b)
         return 0;
     if (a === undefined || a === null)
         return -1;
     if (b === undefined || b === null)
         return 1;
+    if (typeof a === 'bigint' && typeof b === 'bigint') {
+        return a < b ? -1 : 1;
+    }
     if (typeof a === 'number' && typeof b === 'number') {
         return a - b;
     }
+    if (typeof a === 'bigint' && typeof b === 'number' && Number.isInteger(b)) {
+        return a < BigInt(b) ? -1 : 1;
+    }
+    if (typeof a === 'number' && typeof b === 'bigint' && Number.isInteger(a)) {
+        return BigInt(a) < b ? -1 : 1;
+    }
     if (typeof a === 'string' && typeof b === 'string') {
         return a.localeCompare(b);
     }
@@ -1289,7 +1431,7 @@ class SortedStorageDecorator {
         sortedKeys.splice(insertIdx, 0, key);
     }
     binarySearchInsertPosition(viewPath, sortedKeys, sortConfig, newKey, newValue) {
-        const newSortValue = getNestedValue$1(newValue, sortConfig.field);
+        const newSortValue = getNestedValue(newValue, sortConfig.field);
         const isDesc = sortConfig.order === 'desc';
         let low = 0;
         let high = sortedKeys.length;
@@ -1297,8 +1439,8 @@ class SortedStorageDecorator {
             const mid = Math.floor((low + high) / 2);
             const midKey = sortedKeys[mid];
             const midEntity = this.inner.get(viewPath, midKey);
-            const midValue = getNestedValue$1(midEntity, sortConfig.field);
-            let cmp = compareSortValues$1(newSortValue, midValue);
+            const midValue = getNestedValue(midEntity, sortConfig.field);
+            let cmp = compareSortValues(newSortValue, midValue);
             if (isDesc)
                 cmp = -cmp;
             if (cmp === 0) {
@@ -1320,9 +1462,9 @@ class SortedStorageDecorator {
         const isDesc = sortConfig.order === 'desc';
         const entries = allKeys.map(k => [k, this.inner.get(viewPath, k)]);
         entries.sort((a, b) => {
-            const aValue = getNestedValue$1(a[1], sortConfig.field);
-            const bValue = getNestedValue$1(b[1], sortConfig.field);
-            let cmp = compareSortValues$1(aValue, bValue);
+            const aValue = getNestedValue(a[1], sortConfig.field);
+            const bValue = getNestedValue(b[1], sortConfig.field);
+            let cmp = compareSortValues(aValue, bValue);
             if (isDesc)
                 cmp = -cmp;
             if (cmp === 0) {
@@ -1652,6 +1794,160 @@ function createTypedViews(stack, storage, subscriptionRegistry) {
     return views;
 }
 
+class ReadRequestError extends Error {
+    constructor(input) {
+        super(`Read request to '${input.path}' failed (${input.status}): ${input.body}`);
+        this.name = 'ReadRequestError';
+        this.status = input.status;
+        this.path = input.path;
+        this.body = input.body;
+        this.serverErrorCode = input.serverErrorCode;
+    }
+}
+function getServerErrorCode(response, body) {
+    const headerCode = response.headers.get('X-Error-Code');
+    if (headerCode) {
+        return headerCode;
+    }
+    try {
+        const parsed = JSON.parse(body);
+        return typeof parsed.code === 'string' ? parsed.code : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function parseReadResponse(response, path) {
+    if (!response.ok) {
+        const body = await response.text();
+        throw new ReadRequestError({
+            status: response.status,
+            path,
+            body,
+            serverErrorCode: getServerErrorCode(response, body),
+        });
+    }
+    return response.json();
+}
+function programAccountRead(input) {
+    return {
+        account: input.account,
+        path: input.path,
+        schema: input.schema,
+    };
+}
+function programQuery(input) {
+    return {
+        name: input.name,
+        path: input.path,
+        method: input.method,
+        schema: input.schema,
+    };
+}
+function stackQuery(input) {
+    return {
+        name: input.name,
+        path: input.path,
+        method: input.method,
+        schema: input.schema,
+    };
+}
+
+function joinUrl(baseUrl, path) {
+    return `${baseUrl.replace(/\/$/, '')}${path.startsWith('/') ? path : `/${path}`}`;
+}
+function decodeBase64(encoded) {
+    if (typeof atob === 'function') {
+        const binary = atob(encoded);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+            bytes[i] = binary.charCodeAt(i);
+        }
+        return bytes;
+    }
+    const bufferCtor = globalThis.Buffer;
+    if (bufferCtor) {
+        return new Uint8Array(bufferCtor.from(encoded, 'base64'));
+    }
+    throw new Error('No base64 decoder available in this environment');
+}
+function deriveHttpEndpoint(wsUrl) {
+    try {
+        const parsed = new URL(wsUrl);
+        if (parsed.protocol === 'ws:') {
+            parsed.protocol = 'http:';
+        }
+        else if (parsed.protocol === 'wss:') {
+            parsed.protocol = 'https:';
+        }
+        return parsed.toString().replace(/\/$/, '');
+    }
+    catch {
+        return wsUrl.replace(/^wss?:/i, (protocol) => protocol.toLowerCase() === 'wss:' ? 'https:' : 'http:');
+    }
+}
+function createChainClient(httpBaseUrl, fetchImpl) {
+    return {
+        async exists(address) {
+            const path = `/chain/exists/${encodeURIComponent(address)}`;
+            const response = await fetchImpl(joinUrl(httpBaseUrl, path));
+            const body = await parseReadResponse(response, path);
+            return body.exists;
+        },
+        async lamports(address) {
+            const path = `/chain/lamports/${encodeURIComponent(address)}`;
+            const response = await fetchImpl(joinUrl(httpBaseUrl, path));
+            const body = await parseReadResponse(response, path);
+            return body.lamports;
+        },
+        async minimumBalanceForRentExemption(space) {
+            const path = `/chain/rent-exemption/${encodeURIComponent(String(space))}`;
+            const response = await fetchImpl(joinUrl(httpBaseUrl, path));
+            const body = await parseReadResponse(response, path);
+            return body.lamports;
+        },
+        async clock() {
+            const path = '/chain/clock';
+            const response = await fetchImpl(joinUrl(httpBaseUrl, path));
+            return parseReadResponse(response, path);
+        },
+        async account(address) {
+            const path = `/chain/accounts/${encodeURIComponent(address)}`;
+            const response = await fetchImpl(joinUrl(httpBaseUrl, path));
+            const body = await parseReadResponse(response, path);
+            if (!body) {
+                return null;
+            }
+            return {
+                address: body.address,
+                ownerProgram: body.ownerProgram,
+                lamports: body.lamports,
+                executable: body.executable,
+                data: decodeBase64(body.data),
+            };
+        },
+        async mint(address) {
+            const path = `/chain/mints/${encodeURIComponent(address)}`;
+            const response = await fetchImpl(joinUrl(httpBaseUrl, path));
+            return parseReadResponse(response, path);
+        },
+        async tokenAccount(address) {
+            const path = `/chain/token-accounts/${encodeURIComponent(address)}`;
+            const response = await fetchImpl(joinUrl(httpBaseUrl, path));
+            return parseReadResponse(response, path);
+        },
+        async balance(input) {
+            const path = '/chain/balances';
+            const response = await fetchImpl(joinUrl(httpBaseUrl, path), {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify(input),
+            });
+            return parseReadResponse(response, path);
+        },
+    };
+}
+
 /**
  * PDA (Program Derived Address) derivation utilities.
  *
@@ -1666,7 +1962,10 @@ function decodeBase58(str) {
     if (str.length === 0) {
         return new Uint8Array(0);
     }
-    const bytes = [0];
+    // Big-endian byte accumulator (stored little-endian here, reversed at the
+    // end). Must start empty: a leading `[0]` produces a spurious extra byte for
+    // all-zero values such as the System Program ("111...1").
+    const bytes = [];
     for (const char of str) {
         const value = BASE58_ALPHABET.indexOf(char);
         if (value === -1) {
@@ -1698,7 +1997,9 @@ function encodeBase58(bytes) {
     if (bytes.length === 0) {
         return '';
     }
-    const digits = [0];
+    // Must start empty for the same reason as `decodeBase58`: a leading `[0]`
+    // yields an extra '1' character when encoding all-zero inputs.
+    const digits = [];
     for (const byte of bytes) {
         let carry = byte;
         for (let i = 0; i < digits.length; i++) {
@@ -1719,25 +2020,125 @@ function encodeBase58(bytes) {
     }
     return digits.reverse().map(d => BASE58_ALPHABET[d]).join('');
 }
+// SHA-256 round constants (first 32 bits of the fractional parts of the cube
+// roots of the first 64 primes).
+const SHA256_K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+/**
+ * Dependency-free, synchronous SHA-256.
+ *
+ * Used so PDA derivation works identically in browsers, Node (both CJS and
+ * ESM), and bundlers without relying on `require('crypto')` or async WebCrypto.
+ */
+function sha256Pure(data) {
+    const h = new Uint32Array([
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+        0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+    ]);
+    const bitLen = data.length * 8;
+    // Pad: append 0x80, then zeros, until length ≡ 56 (mod 64), then 8-byte length.
+    const paddedLen = ((data.length + 8) >> 6) * 64 + 64;
+    const msg = new Uint8Array(paddedLen);
+    msg.set(data);
+    msg[data.length] = 0x80;
+    // 64-bit big-endian bit length (high 32 bits assumed 0 for our seed sizes).
+    const dv = new DataView(msg.buffer);
+    dv.setUint32(paddedLen - 4, bitLen >>> 0, false);
+    dv.setUint32(paddedLen - 8, Math.floor(bitLen / 0x100000000), false);
+    const w = new Uint32Array(64);
+    for (let offset = 0; offset < paddedLen; offset += 64) {
+        for (let i = 0; i < 16; i++) {
+            w[i] = dv.getUint32(offset + i * 4, false);
+        }
+        for (let i = 16; i < 64; i++) {
+            const w15 = w[i - 15];
+            const w2 = w[i - 2];
+            const s0 = ((w15 >>> 7) | (w15 << 25)) ^ ((w15 >>> 18) | (w15 << 14)) ^ (w15 >>> 3);
+            const s1 = ((w2 >>> 17) | (w2 << 15)) ^ ((w2 >>> 19) | (w2 << 13)) ^ (w2 >>> 10);
+            w[i] = (w[i - 16] + s0 + w[i - 7] + s1) >>> 0;
+        }
+        let a = h[0], b = h[1], c = h[2], d = h[3];
+        let e = h[4], f = h[5], g = h[6], hh = h[7];
+        for (let i = 0; i < 64; i++) {
+            const S1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7));
+            const ch = (e & f) ^ (~e & g);
+            const t1 = (hh + S1 + ch + SHA256_K[i] + w[i]) >>> 0;
+            const S0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10));
+            const maj = (a & b) ^ (a & c) ^ (b & c);
+            const t2 = (S0 + maj) >>> 0;
+            hh = g;
+            g = f;
+            f = e;
+            e = (d + t1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) >>> 0;
+        }
+        h[0] = (h[0] + a) >>> 0;
+        h[1] = (h[1] + b) >>> 0;
+        h[2] = (h[2] + c) >>> 0;
+        h[3] = (h[3] + d) >>> 0;
+        h[4] = (h[4] + e) >>> 0;
+        h[5] = (h[5] + f) >>> 0;
+        h[6] = (h[6] + g) >>> 0;
+        h[7] = (h[7] + hh) >>> 0;
+    }
+    const out = new Uint8Array(32);
+    const outView = new DataView(out.buffer);
+    for (let i = 0; i < 8; i++) {
+        outView.setUint32(i * 4, h[i], false);
+    }
+    return out;
+}
 /**
- * SHA-256 hash function (synchronous, Node.js).
+ * SHA-256 hash function (synchronous).
  */
 function sha256Sync(data) {
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const { createHash } = require('crypto');
-    return new Uint8Array(createHash('sha256').update(Buffer.from(data)).digest());
+    return sha256Pure(data);
 }
 /**
- * SHA-256 hash function (async, works in browser and Node.js).
+ * SHA-256 hash function (async). Uses WebCrypto when available for speed,
+ * otherwise falls back to the pure implementation.
  */
 async function sha256Async(data) {
     if (typeof globalThis !== 'undefined' && globalThis.crypto && globalThis.crypto.subtle) {
-        // Create a copy of the data to ensure we have an ArrayBuffer
         const copy = new Uint8Array(data);
         const hashBuffer = await globalThis.crypto.subtle.digest('SHA-256', copy);
         return new Uint8Array(hashBuffer);
     }
-    return sha256Sync(data);
+    return sha256Pure(data);
+}
+/**
+ * Check if a 32-byte value is a valid point on the ed25519 curve.
+ *
+ * A valid PDA must be OFF the curve (it must NOT correspond to a real
+ * ed25519 public key, so that no private key can ever sign for it).
+ *
+ * We determine on-curve status by attempting to decompress the candidate
+ * as a compressed Edwards point. If decompression succeeds the value lies
+ * on the curve; if it throws, the value is off-curve and is a valid PDA.
+ * This matches the behaviour of `PublicKey.isOnCurve` in @solana/web3.js.
+ */
+function isOnCurve(publicKey) {
+    if (publicKey.length !== 32) {
+        return false;
+    }
+    try {
+        Point.fromHex(publicKey);
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 /**
  * PDA marker bytes appended to seeds before hashing.
@@ -1805,7 +2206,7 @@ async function findProgramAddress(seeds, programId) {
     for (let bump = 255; bump >= 0; bump--) {
         const buffer = buildPdaBuffer(seeds, programIdBytes, bump);
         const hash = await sha256Async(buffer);
-        {
+        if (!isOnCurve(hash)) {
             return [encodeBase58(hash), bump];
         }
     }
@@ -1825,7 +2226,7 @@ function findProgramAddressSync(seeds, programId) {
     for (let bump = 255; bump >= 0; bump--) {
         const buffer = buildPdaBuffer(seeds, programIdBytes, bump);
         const hash = sha256Sync(buffer);
-        {
+        if (!isOnCurve(hash)) {
             return [encodeBase58(hash), bump];
         }
     }
@@ -1874,6 +2275,134 @@ function createPublicKeySeed(address) {
     return decoded;
 }
 
+/**
+ * Typed serialization of PDA seed values.
+ *
+ * Shared by the standalone PDA DSL (`pda-dsl.ts`) and instruction account
+ * resolution (`account-resolver.ts`). When a seed carries a declared type
+ * (from the IDL or the `pdas!` registry), encoding is exact: pubkeys are
+ * base58-decoded to 32 bytes, integers are little-endian at the declared
+ * width. Without a type, legacy heuristics apply for backward compatibility.
+ */
+/**
+ * Normalizes the type-name variants that IDLs and codegen produce
+ * ("Pubkey", "publicKey", "solana_pubkey::Pubkey", "String", ...) to a
+ * canonical seed type. Returns undefined for types that cannot be a seed.
+ */
+function normalizeSeedType(argType) {
+    if (!argType)
+        return undefined;
+    // Strip any path qualifier (e.g. solana_pubkey::Pubkey).
+    const parts = argType.split('::');
+    const t = (parts[parts.length - 1] ?? argType).trim();
+    if (/^[ui](8|16|32|64|128)$/.test(t)) {
+        return t;
+    }
+    switch (t) {
+        case 'pubkey':
+        case 'Pubkey':
+        case 'publicKey':
+        case 'PublicKey':
+            return 'pubkey';
+        case 'string':
+        case 'String':
+        case 'str':
+            return 'string';
+        default:
+            return undefined;
+    }
+}
+/**
+ * Serializes a PDA seed value.
+ *
+ * With a recognized `argType`, encoding is strict and width-exact; an
+ * incompatible value throws rather than deriving a wrong address. Without
+ * one, the legacy heuristics apply: raw bytes pass through, 43/44-character
+ * strings are tried as base58, other strings are utf-8, numbers are 8-byte
+ * little-endian u64.
+ */
+function serializeSeedValue(value, argType) {
+    if (value instanceof Uint8Array) {
+        return value;
+    }
+    const t = normalizeSeedType(argType);
+    if (t === 'pubkey') {
+        if (typeof value !== 'string') {
+            throw new Error(`Pubkey seed requires a base58 string, got ${typeof value}`);
+        }
+        const decoded = decodeBase58(value);
+        if (decoded.length !== 32) {
+            throw new Error(`Pubkey seed '${value}' decoded to ${decoded.length} bytes, expected 32`);
+        }
+        return decoded;
+    }
+    if (t === 'string') {
+        if (typeof value !== 'string') {
+            throw new Error(`String seed requires a string value, got ${typeof value}`);
+        }
+        return new TextEncoder().encode(value);
+    }
+    if (t !== undefined) {
+        // Numeric type at a declared width.
+        if (typeof value !== 'bigint' && typeof value !== 'number') {
+            throw new Error(`Numeric seed of type ${t} requires a number/bigint, got ${typeof value}`);
+        }
+        const bits = parseInt(t.slice(1), 10);
+        return serializeNumber(value, bits / 8, t.startsWith('i'));
+    }
+    // --- Untyped: legacy heuristics. ---
+    if (typeof value === 'string') {
+        if (value.length === 43 || value.length === 44) {
+            try {
+                return decodeBase58(value);
+            }
+            catch {
+                return new TextEncoder().encode(value);
+            }
+        }
+        return new TextEncoder().encode(value);
+    }
+    if (typeof value === 'bigint' || typeof value === 'number') {
+        return serializeNumber(value, 8, true);
+    }
+    throw new Error(`Cannot serialize value for PDA seed: ${typeof value}`);
+}
+/**
+ * Little-endian two's-complement encoding at a fixed byte width, with an
+ * overflow check so out-of-range values fail instead of silently truncating.
+ */
+function serializeNumber(value, size, signed) {
+    const buffer = new Uint8Array(size);
+    let n = typeof value === 'bigint' ? value : BigInt(value);
+    const original = n;
+    for (let i = 0; i < size; i++) {
+        buffer[i] = Number(n & BigInt(0xff));
+        n >>= BigInt(8);
+    }
+    const fits = signed ? n === BigInt(0) || n === BigInt(-1) : n === BigInt(0);
+    if (!fits) {
+        throw new Error(`Seed value ${original} does not fit in ${size * 8} bits`);
+    }
+    return buffer;
+}
+
+function getValueByPath(source, path) {
+    if (!source) {
+        return undefined;
+    }
+    if (Object.prototype.hasOwnProperty.call(source, path)) {
+        return source[path];
+    }
+    let current = source;
+    for (const segment of path.split('.')) {
+        if (current === null || typeof current !== 'object') {
+            return undefined;
+        }
+        current = current[segment];
+    }
+    return current;
+}
+
 /**
  * Topologically sort accounts so that dependencies (accountRef) are resolved first.
  * Non-PDA accounts come first, then PDAs in dependency order.
@@ -1960,13 +2489,32 @@ function resolveAccounts(accountMetas, args, options) {
             missing.push(meta.name);
         }
     }
-    // Return accounts in original order (as defined in accountMetas)
+    // Return accounts in original order (as defined in accountMetas).
+    //
+    // Omitted optional accounts that precede a resolved account cannot simply
+    // be dropped — that would shift every later account into the wrong slot.
+    // Anchor's convention is to pass the program ID as a placeholder; trailing
+    // omitted optionals are dropped as usual.
+    const lastResolvedIndex = accountMetas.reduce((last, meta, index) => (resolvedMap[meta.name] ? index : last), -1);
     const orderedAccounts = [];
-    for (const meta of accountMetas) {
+    for (let i = 0; i < accountMetas.length; i++) {
+        const meta = accountMetas[i];
         const resolved = resolvedMap[meta.name];
         if (resolved) {
             orderedAccounts.push(resolved);
         }
+        else if (meta.isOptional && i < lastResolvedIndex) {
+            if (!options.programId) {
+                throw new Error('Omitted optional account "' + meta.name + '" precedes other accounts and needs ' +
+                    'the program ID as a placeholder, but no programId was provided in options.');
+            }
+            orderedAccounts.push({
+                name: meta.name,
+                address: options.programId,
+                isSigner: false,
+                isWritable: false,
+            });
+        }
     }
     return {
         accounts: orderedAccounts,
@@ -1976,24 +2524,25 @@ function resolveAccounts(accountMetas, args, options) {
 function resolveSingleAccount(meta, args, options, resolvedMap) {
     switch (meta.category) {
         case 'signer':
-            return resolveSignerAccount(meta, options.wallet);
+            return resolveSignerAccount(meta, options.accounts, options.wallet);
         case 'known':
             return resolveKnownAccount(meta);
         case 'pda':
-            return resolvePdaAccount(meta, args, resolvedMap, options.programId);
+            return resolvePdaAccount(meta, args, resolvedMap, options.programId, options.resolve);
         case 'userProvided':
             return resolveUserProvidedAccount(meta, options.accounts);
         default:
             return null;
     }
 }
-function resolveSignerAccount(meta, wallet) {
-    if (!wallet) {
+function resolveSignerAccount(meta, accounts, wallet) {
+    const address = accounts?.[meta.name] ?? wallet?.publicKey;
+    if (!address) {
         return null;
     }
     return {
         name: meta.name,
-        address: wallet.publicKey,
+        address,
         isSigner: true,
         isWritable: meta.isWritable,
     };
@@ -2009,7 +2558,7 @@ function resolveKnownAccount(meta) {
         isWritable: meta.isWritable,
     };
 }
-function resolvePdaAccount(meta, args, resolvedMap, programId) {
+function resolvePdaAccount(meta, args, resolvedMap, programId, resolve) {
     if (!meta.pdaConfig) {
         return null;
     }
@@ -2026,13 +2575,16 @@ function resolvePdaAccount(meta, args, resolvedMap, programId) {
             case 'literal':
                 seeds.push(createSeed(seed.value));
                 break;
+            case 'bytes':
+                seeds.push(Uint8Array.from(seed.value));
+                break;
             case 'argRef': {
-                const argValue = args[seed.argName];
+                const argValue = getValueByPath(args, seed.argName) ?? getValueByPath(resolve, seed.argName);
                 if (argValue === undefined) {
                     throw new Error('PDA seed references missing argument: ' + seed.argName +
                         ' (for account "' + meta.name + '")');
                 }
-                seeds.push(createSeed(argValue));
+                seeds.push(serializeSeedValue(argValue, seed.argType));
                 break;
             }
             case 'accountRef': {
@@ -2100,6 +2652,11 @@ function serializeInstructionData(discriminator, args, schema) {
     const buffers = [Buffer.from(discriminator)];
     for (const field of schema) {
         const value = args[field.name];
+        // Option fields treat undefined as None; everything else must be present
+        // (silently encoding zeros for a missing arg corrupts instruction data).
+        if (value === undefined && !(typeof field.type === 'object' && 'option' in field.type)) {
+            throw new Error(`Missing required argument "${field.name}" (type ${JSON.stringify(field.type)})`);
+        }
         const serialized = serializeValue(value, field.type);
         buffers.push(serialized);
     }
@@ -2118,8 +2675,108 @@ function serializeValue(value, type) {
     if ('array' in type) {
         return serializeArray(value, type.array[0], type.array[1]);
     }
+    if ('hashMap' in type) {
+        return serializeHashMap(value, type.hashMap[0], type.hashMap[1]);
+    }
+    if ('struct' in type) {
+        return serializeStruct(value, type.struct);
+    }
+    if ('enum' in type) {
+        return serializeEnum(value, type.enum);
+    }
     throw new Error(`Unknown type: ${JSON.stringify(type)}`);
 }
+function serializeStruct(value, fields) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new Error(`Struct value must be a plain object, got ${typeof value}`);
+    }
+    const obj = value;
+    const buffers = [];
+    for (const field of fields) {
+        const fieldValue = obj[field.name];
+        if (fieldValue === undefined &&
+            !(typeof field.type === 'object' && 'option' in field.type)) {
+            throw new Error(`Missing required struct field "${field.name}"`);
+        }
+        buffers.push(serializeValue(fieldValue, field.type));
+    }
+    return Buffer.concat(buffers);
+}
+function serializeHashMap(value, keyType, valueType) {
+    if (keyType !== 'string') {
+        throw new Error(`Instruction hashMap keys must use the 'string' schema, got ${JSON.stringify(keyType)}`);
+    }
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new Error(`HashMap value must be a plain object, got ${typeof value}`);
+    }
+    const entries = Object.entries(value).sort(([left], [right]) => 
+    // Rust/Borsh sorts String keys by their UTF-8 bytes before serializing.
+    Buffer.compare(Buffer.from(left, 'utf8'), Buffer.from(right, 'utf8')));
+    const len = Buffer.alloc(4);
+    len.writeUInt32LE(entries.length, 0);
+    const entryBuffers = [];
+    for (const [key, entryValue] of entries) {
+        entryBuffers.push(serializePrimitive(key, 'string'));
+        entryBuffers.push(serializeValue(entryValue, valueType));
+    }
+    return Buffer.concat([len, ...entryBuffers]);
+}
+function variantName(variant) {
+    return typeof variant === 'string' ? variant : variant.name;
+}
+function serializeEnum(value, variants) {
+    // Numeric value: a bare variant index (fieldless variants only).
+    if (typeof value === 'number') {
+        if (!Number.isInteger(value) || value < 0 || value >= variants.length) {
+            throw new Error(`Enum variant index ${value} out of range (0..${variants.length - 1})`);
+        }
+        const variant = variants[value];
+        if (typeof variant !== 'string') {
+            throw new Error(`Enum variant "${variantName(variant)}" carries data; pass { ${variantName(variant)}: ... } instead of an index`);
+        }
+        return Buffer.from([value]);
+    }
+    // String value: a fieldless variant by name.
+    if (typeof value === 'string') {
+        const index = variants.findIndex((v) => variantName(v) === value);
+        if (index === -1) {
+            throw new Error(`Unknown enum variant "${value}". Expected one of: ${variants.map(variantName).join(', ')}`);
+        }
+        const variant = variants[index];
+        if (typeof variant !== 'string') {
+            throw new Error(`Enum variant "${value}" carries data; pass { ${value}: ... } instead of a bare name`);
+        }
+        return Buffer.from([index]);
+    }
+    // Object value: { variantName: payload } for data-carrying variants.
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        const keys = Object.keys(value);
+        if (keys.length !== 1) {
+            throw new Error(`Enum value must be a single-key object ({ variantName: payload }), got keys [${keys.join(', ')}]`);
+        }
+        const key = keys[0];
+        const payload = value[key];
+        const index = variants.findIndex((v) => variantName(v) === key);
+        if (index === -1) {
+            throw new Error(`Unknown enum variant "${key}". Expected one of: ${variants.map(variantName).join(', ')}`);
+        }
+        const variant = variants[index];
+        if (typeof variant === 'string') {
+            throw new Error(`Enum variant "${key}" is fieldless; pass '${key}' instead of an object`);
+        }
+        const prefix = Buffer.from([index]);
+        if ('fields' in variant) {
+            return Buffer.concat([prefix, serializeStruct(payload, variant.fields)]);
+        }
+        const tuple = payload;
+        if (!Array.isArray(tuple) || tuple.length !== variant.tuple.length) {
+            throw new Error(`Enum variant "${key}" expects a tuple of length ${variant.tuple.length}`);
+        }
+        const elements = variant.tuple.map((elementType, i) => serializeValue(tuple[i], elementType));
+        return Buffer.concat([prefix, ...elements]);
+    }
+    throw new Error(`Cannot serialize enum from value of type ${typeof value}`);
+}
 function serializePrimitive(value, type) {
     switch (type) {
         case 'u8':
@@ -2160,21 +2817,60 @@ function serializePrimitive(value, type) {
         case 'i128':
             const i128 = Buffer.alloc(16);
             const bigI128 = BigInt(value);
-            i128.writeBigInt64LE(bigI128 & BigInt('0xFFFFFFFFFFFFFFFF'), 0);
+            // The masked low limb is always non-negative, so it must be written
+            // unsigned; the arithmetic-shifted high limb carries the sign.
+            i128.writeBigUInt64LE(bigI128 & BigInt('0xFFFFFFFFFFFFFFFF'), 0);
             i128.writeBigInt64LE(bigI128 >> BigInt(64), 8);
             return i128;
+        case 'f32': {
+            const f32 = Buffer.alloc(4);
+            f32.writeFloatLE(value, 0);
+            return f32;
+        }
+        case 'f64': {
+            const f64 = Buffer.alloc(8);
+            f64.writeDoubleLE(value, 0);
+            return f64;
+        }
         case 'bool':
             return Buffer.from([value ? 1 : 0]);
+        case 'bytes': {
+            // Borsh bytes: u32 LE length prefix + raw bytes.
+            const raw = value instanceof Uint8Array
+                ? value
+                : Array.isArray(value)
+                    ? Uint8Array.from(value)
+                    : null;
+            if (raw === null) {
+                throw new Error(`Cannot serialize bytes from value of type ${typeof value}`);
+            }
+            const lenPrefix = Buffer.alloc(4);
+            lenPrefix.writeUInt32LE(raw.length, 0);
+            return Buffer.concat([lenPrefix, Buffer.from(raw)]);
+        }
         case 'string':
             const str = value;
             const strBytes = Buffer.from(str, 'utf-8');
             const strLen = Buffer.alloc(4);
             strLen.writeUInt32LE(strBytes.length, 0);
             return Buffer.concat([strLen, strBytes]);
-        case 'pubkey':
-            // Public key is 32 bytes
-            // In production, decode base58 to 32 bytes
-            return Buffer.alloc(32, 0);
+        case 'pubkey': {
+            // Public key is 32 bytes. Accept base58 strings or raw 32-byte buffers.
+            if (value instanceof Uint8Array) {
+                if (value.length !== 32) {
+                    throw new Error(`Invalid pubkey byte length: expected 32, got ${value.length}`);
+                }
+                return Buffer.from(value);
+            }
+            if (typeof value === 'string') {
+                const decoded = decodeBase58(value);
+                if (decoded.length !== 32) {
+                    throw new Error(`Invalid pubkey: '${value}' decoded to ${decoded.length} bytes, expected 32`);
+                }
+                return Buffer.from(decoded);
+            }
+            throw new Error(`Cannot serialize pubkey from value of type ${typeof value}`);
+        }
         default:
             throw new Error(`Unknown primitive type: ${type}`);
     }
@@ -2201,59 +2897,7 @@ function serializeArray(values, elementType, length) {
 }
 
 /**
- * Waits for transaction confirmation.
- *
- * @param signature - Transaction signature
- * @param level - Desired confirmation level
- * @param timeout - Maximum wait time in milliseconds
- * @returns Confirmation result
- */
-async function waitForConfirmation(signature, level = 'confirmed', timeout = 60000) {
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeout) {
-        const status = await checkTransactionStatus();
-        if (status.err) {
-            throw new Error(`Transaction failed: ${JSON.stringify(status.err)}`);
-        }
-        if (isConfirmationLevelSufficient(status.confirmations, level)) {
-            return {
-                level,
-                slot: status.slot,
-            };
-        }
-        await sleep(1000);
-    }
-    throw new Error(`Transaction confirmation timeout after ${timeout}ms`);
-}
-async function checkTransactionStatus(_signature) {
-    // In production, query the Solana RPC
-    return {
-        err: null,
-        confirmations: 32,
-        slot: 123456789,
-    };
-}
-function isConfirmationLevelSufficient(confirmations, level) {
-    if (confirmations === null) {
-        return false;
-    }
-    switch (level) {
-        case 'processed':
-            return confirmations >= 0;
-        case 'confirmed':
-            return confirmations >= 1;
-        case 'finalized':
-            return confirmations >= 32;
-        default:
-            return false;
-    }
-}
-function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-/**
- * Parses and handles instruction errors.
+ * Parses and handles instruction errors.
  */
 /**
  * Parses an error returned from a Solana transaction.
@@ -2311,91 +2955,159 @@ function extractErrorCode(error) {
 function formatProgramError(error) {
     return `${error.name} (${error.code}): ${error.message}`;
 }
-
 /**
- * Converts resolved account array to a map for the builder.
+ * Error thrown when an instruction fails to send and the underlying failure
+ * could be parsed against the handler's IDL error definitions.
  */
-function toResolvedAccountsMap(accounts) {
-    const map = {};
-    for (const account of accounts) {
-        map[account.name] = account.address;
+class InstructionError extends Error {
+    constructor(message, programError, cause) {
+        super(message);
+        this.name = 'InstructionError';
+        this.programError = programError;
+        this.cause = cause;
     }
-    return map;
+}
+
+/**
+ * Creates a data-driven instruction handler.
+ *
+ * The returned handler implements `build()` generically: it serializes args
+ * via the schema-driven serializer and constructs the account key list from
+ * the resolved, ordered accounts. No imperative per-instruction code is
+ * required, which keeps generated SDKs tiny and puts all serialization logic
+ * in one tested place.
+ */
+function createInstructionHandler(config) {
+    const discriminator = config.discriminator instanceof Uint8Array
+        ? config.discriminator
+        : Uint8Array.from(config.discriminator);
+    const argNames = config.args.map((a) => a.name);
+    const errors = config.errors ?? [];
+    return {
+        programId: config.programId,
+        accounts: config.accounts,
+        errors,
+        argNames,
+        build(args, resolved) {
+            const data = serializeInstructionData(discriminator, args, config.args);
+            return {
+                programId: config.programId,
+                keys: resolved.map((r) => ({
+                    pubkey: r.address,
+                    isSigner: r.isSigner,
+                    isWritable: r.isWritable,
+                })),
+                data,
+            };
+        },
+    };
 }
 /**
- * Executes an instruction handler with the given arguments and options.
+ * Splits a merged params object into serialized args and account overrides.
  *
- * 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
+ * Keys matching a declared argument name are args; keys matching a declared
+ * account name (with a string value) are account address overrides. This
+ * applies to signer slots too, allowing explicit signer addresses to override
+ * the wallet fallback. Anything else throws — a typo'd key silently dropped
+ * here would otherwise change the built instruction. `options.accounts` on
+ * {@link BuildOptions} remains an unvalidated escape hatch for advanced callers.
+ */
+function splitParams(handler, params) {
+    const argNameSet = new Set(handler.argNames);
+    const accountNameSet = new Set(handler.accounts.map((a) => a.name));
+    const args = {};
+    const accountOverrides = {};
+    let resolve;
+    for (const [key, value] of Object.entries(params)) {
+        if (argNameSet.has(key)) {
+            args[key] = value;
+        }
+        else if (key === 'resolve' && !accountNameSet.has(key)) {
+            if (value === undefined) {
+                continue;
+            }
+            if (value === null || Array.isArray(value) || typeof value !== 'object') {
+                throw new Error('Parameter "resolve" must be an object when provided');
+            }
+            resolve = value;
+        }
+        else if (accountNameSet.has(key)) {
+            if (typeof value !== 'string') {
+                // Non-string values are not valid account addresses.
+                throw new Error(`Parameter "${key}" is not a known argument and is not a base58 account address`);
+            }
+            accountOverrides[key] = value;
+        }
+        else {
+            throw new Error(`Unknown parameter "${key}". Expected one of args [${[...argNameSet].join(', ')}] ` +
+                `or accounts [${[...accountNameSet].join(', ')}]`);
+        }
+    }
+    return { args, accountOverrides, resolve };
+}
+/**
+ * Builds a {@link BuiltInstruction} from a handler and a merged params object.
  *
- * @param handler - Instruction handler from generated SDK
- * @param args - Instruction arguments
- * @param options - Execution options
- * @returns Execution result with signature
+ * This is a pure function: it performs no network access. It is the unit of
+ * composition for batching (`wallet.signAndSend([a, b, c])`).
  */
-async function executeInstruction(handler, args, options = {}) {
-    // Step 1: Resolve accounts using handler's account metadata
+function buildInstruction(handler, params, options = {}) {
+    const { args, accountOverrides, resolve } = splitParams(handler, params);
     const resolutionOptions = {
-        accounts: options.accounts,
+        accounts: { ...accountOverrides, ...options.accounts },
+        resolve,
         wallet: options.wallet,
-        programId: handler.programId, // Pass programId for PDA derivation
+        programId: handler.programId,
     };
     const resolution = resolveAccounts(handler.accounts, args, resolutionOptions);
     validateAccountResolution(resolution);
-    // Step 2: Call generated build() function
-    const resolvedAccountsMap = toResolvedAccountsMap(resolution.accounts);
-    const instruction = handler.build(args, resolvedAccountsMap);
-    // Step 3: Build transaction from the built instruction
-    const transaction = buildTransaction(instruction);
-    // Step 4: Sign and send
-    if (!options.wallet) {
-        throw new Error('Wallet required to sign transaction');
+    const instruction = handler.build(args, resolution.accounts);
+    if (options.remainingAccounts?.length) {
+        instruction.keys.push(...options.remainingAccounts);
     }
-    const signature = await options.wallet.signAndSend(transaction);
-    // Step 5: Wait for confirmation
-    const confirmationLevel = options.confirmationLevel ?? 'confirmed';
-    const timeout = options.timeout ?? 60000;
-    const confirmation = await waitForConfirmation(signature, confirmationLevel, timeout);
-    return {
-        signature,
-        confirmationLevel: confirmation.level,
-        slot: confirmation.slot,
-    };
+    return instruction;
 }
 /**
- * Creates a transaction object from a built instruction.
+ * Builds, signs, and sends an instruction via the wallet adapter.
  *
- * @param instruction - Built instruction from handler
- * @returns Transaction object ready for signing
+ * 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}.
  */
-function buildTransaction(instruction) {
-    // This returns a framework-agnostic transaction representation.
-    // The wallet adapter is responsible for converting this to the
-    // appropriate format (@solana/web3.js Transaction, etc.)
-    return {
-        instructions: [{
-                programId: instruction.programId,
-                keys: instruction.keys,
-                data: Array.from(instruction.data),
-            }],
+async function executeInstruction(handler, params, options = {}) {
+    const instruction = buildInstruction(handler, params, options);
+    if (!options.wallet) {
+        throw new Error('Wallet required to sign and send transaction');
+    }
+    const sendOptions = {
+        ...options.send,
     };
+    if (options.confirmationLevel !== undefined) {
+        sendOptions.confirmationLevel = options.confirmationLevel;
+    }
+    try {
+        const result = await options.wallet.signAndSend([instruction], sendOptions);
+        return { signature: result.signature, slot: result.slot };
+    }
+    catch (err) {
+        const programError = parseInstructionError(err, handler.errors);
+        if (programError) {
+            throw new InstructionError(`${programError.name} (${programError.code}): ${programError.message}`, programError, err);
+        }
+        throw err;
+    }
 }
 /**
  * Creates an instruction executor bound to a specific wallet.
- *
- * @param wallet - Wallet adapter
- * @returns Bound executor function
  */
 function createInstructionExecutor(wallet) {
     return {
-        execute: async (handler, args, options) => {
-            return executeInstruction(handler, args, {
-                ...options,
-                wallet,
-            });
+        execute: async (handler, params, options) => {
+            return executeInstruction(handler, params, { ...options, wallet });
+        },
+        build: (handler, params, options) => {
+            return buildInstruction(handler, params, { ...options, wallet });
         },
     };
 }
@@ -2420,11 +3132,11 @@ function resolveSeeds(seeds, context) {
             case 'bytes':
                 return seed.value;
             case 'argRef': {
-                const value = context.args?.[seed.argName];
+                const value = getValueByPath(context.args, seed.argName) ?? getValueByPath(context.resolve, seed.argName);
                 if (value === undefined) {
                     throw new Error(`Missing arg for PDA seed: ${seed.argName}`);
                 }
-                return serializeArgForSeed(value, seed.argType);
+                return serializeSeedValue(value, seed.argType);
             }
             case 'accountRef': {
                 const address = context.accounts?.[seed.accountName];
@@ -2436,47 +3148,6 @@ function resolveSeeds(seeds, context) {
         }
     });
 }
-function serializeArgForSeed(value, argType) {
-    if (value instanceof Uint8Array) {
-        return value;
-    }
-    if (typeof value === 'string') {
-        if (value.length === 43 || value.length === 44) {
-            try {
-                return decodeBase58(value);
-            }
-            catch {
-                return new TextEncoder().encode(value);
-            }
-        }
-        return new TextEncoder().encode(value);
-    }
-    if (typeof value === 'bigint' || typeof value === 'number') {
-        const size = getArgSize(argType);
-        return serializeNumber(value, size);
-    }
-    throw new Error(`Cannot serialize value for PDA seed: ${typeof value}`);
-}
-function getArgSize(argType) {
-    if (!argType)
-        return 8;
-    const match = argType.match(/^[ui](\d+)$/);
-    if (match && match[1]) {
-        return parseInt(match[1], 10) / 8;
-    }
-    if (argType === 'pubkey')
-        return 32;
-    return 8;
-}
-function serializeNumber(value, size) {
-    const buffer = new Uint8Array(size);
-    let n = typeof value === 'bigint' ? value : BigInt(value);
-    for (let i = 0; i < size; i++) {
-        buffer[i] = Number(n & BigInt(0xff));
-        n >>= BigInt(8);
-    }
-    return buffer;
-}
 function pda(programId, ...seeds) {
     return {
         seeds,
@@ -2502,530 +3173,1183 @@ function createProgramPdas(pdas) {
     return pdas;
 }
 
-class Arete {
-    constructor(url, options) {
-        this.stack = options.stack;
-        this.storage = new SortedStorageDecorator(options.storage ?? new MemoryAdapter());
-        this.processor = new FrameProcessor(this.storage, {
-            maxEntriesPerView: options.maxEntriesPerView,
-            flushIntervalMs: options.flushIntervalMs,
-            schemas: options.validateFrames ? this.stack.schemas : undefined,
-        });
-        this.connection = new ConnectionManager({
-            websocketUrl: url,
-            reconnectIntervals: options.reconnectIntervals,
-            maxReconnectAttempts: options.maxReconnectAttempts,
-            auth: options.auth,
-        });
-        this.subscriptionRegistry = new SubscriptionRegistry(this.connection);
-        this.connection.onFrame((frame) => {
-            this.processor.handleFrame(frame);
-        });
-        this._views = createTypedViews(this.stack, this.storage, this.subscriptionRegistry);
-        this._instructions = this.buildInstructions();
-    }
-    buildInstructions() {
-        const instructions = {};
-        if (this.stack.instructions) {
-            for (const [name, handler] of Object.entries(this.stack.instructions)) {
-                instructions[name] = (args, options) => {
-                    return executeInstruction(handler, args, options);
-                };
-            }
-        }
-        return instructions;
-    }
-    static async connect(stack, options) {
-        const url = options?.url ?? stack.url;
-        if (!url) {
-            throw new AreteError('URL is required (provide url option or define url in stack)', 'INVALID_CONFIG');
-        }
-        const internalOptions = {
-            stack,
-            storage: options?.storage,
-            maxEntriesPerView: options?.maxEntriesPerView,
-            flushIntervalMs: options?.flushIntervalMs,
-            autoReconnect: options?.autoReconnect,
-            reconnectIntervals: options?.reconnectIntervals,
-            maxReconnectAttempts: options?.maxReconnectAttempts,
-            validateFrames: options?.validateFrames,
-            auth: options?.auth,
-        };
-        const client = new Arete(url, internalOptions);
-        if (options?.autoReconnect !== false) {
-            await client.connection.connect();
+const STACK_RUNTIME_EXTENSIONS = '__areteStackRuntimeExtensions';
+const PROGRAM_OPERATION_EXTENSIONS = '__areteProgramOperationExtensions';
+function defineProgramExtensions() {
+    return (extensions) => extensions;
+}
+function mergeNamespace(base, extension) {
+    if (base && typeof base === 'object' && !Array.isArray(base)
+        && extension && typeof extension === 'object' && !Array.isArray(extension)) {
+        const merged = { ...base };
+        for (const [key, value] of Object.entries(extension)) {
+            merged[key] = key in merged ? mergeNamespace(merged[key], value) : value;
         }
-        return client;
+        return merged;
     }
-    get views() {
-        return this._views;
+    return extension;
+}
+function mergeOperations(base, extension) {
+    return {
+        instructions: mergeNamespace(base?.instructions, extension?.instructions),
+        transactions: mergeNamespace(base?.transactions, extension?.transactions),
+        flows: mergeNamespace(base?.flows, extension?.flows),
+    };
+}
+function extendProgram(program, extensions) {
+    const base = program;
+    const extended = { ...program };
+    for (const key of ['pdas', 'accounts', 'queries', 'addresses', 'constants', 'defaults', 'math']) {
+        const extensionValue = extensions[key];
+        if (extensionValue !== undefined) {
+            extended[key] = mergeNamespace(base[key], extensionValue);
+        }
+    }
+    if (extensions.raw !== undefined) {
+        extended.rawInstructions = mergeNamespace(base.rawInstructions, extensions.raw);
+    }
+    const baseFactory = base[PROGRAM_OPERATION_EXTENSIONS]?.createOperations;
+    const extensionFactory = extensions.createOperations;
+    if (baseFactory || extensionFactory) {
+        Object.defineProperty(extended, PROGRAM_OPERATION_EXTENSIONS, {
+            value: {
+                createOperations(context) {
+                    const baseOperations = baseFactory?.(context);
+                    if (baseOperations) {
+                        const connectedProgram = context.program;
+                        connectedProgram.instructions = mergeNamespace(connectedProgram.instructions, baseOperations.instructions);
+                        connectedProgram.transactions = mergeNamespace(connectedProgram.transactions, baseOperations.transactions);
+                        connectedProgram.flows = mergeNamespace(connectedProgram.flows, baseOperations.flows);
+                    }
+                    return mergeOperations(baseOperations, extensionFactory?.(context));
+                },
+            },
+            enumerable: false,
+            configurable: false,
+            writable: false,
+        });
     }
-    get instructions() {
-        return this._instructions;
+    return extended;
+}
+function extendPrograms(programs, extensions) {
+    const merged = { ...programs };
+    for (const [name, program] of Object.entries(programs)) {
+        const extension = extensions[name];
+        merged[name] = extension
+            ? extendProgram(program, extension)
+            : program;
+    }
+    return merged;
+}
+function getProgramRuntimeExtensions(program) {
+    return program[PROGRAM_OPERATION_EXTENSIONS];
+}
+function defineStackExtensions() {
+    return (extensions) => extensions;
+}
+function extendStack(stack, extensions) {
+    const base = stack;
+    const extended = { ...stack };
+    for (const key of ['addresses', 'constants', 'defaults', 'math']) {
+        if (extensions[key] !== undefined) {
+            extended[key] = mergeNamespace(base[key], extensions[key]);
+        }
+    }
+    const baseRuntime = base[STACK_RUNTIME_EXTENSIONS];
+    if (baseRuntime || extensions.createRead || extensions.createFlows) {
+        Object.defineProperty(extended, STACK_RUNTIME_EXTENSIONS, {
+            value: {
+                createRead: baseRuntime?.createRead && extensions.createRead
+                    ? (client) => mergeNamespace(baseRuntime.createRead(client), extensions.createRead(client))
+                    : extensions.createRead ?? baseRuntime?.createRead,
+                createFlows: baseRuntime?.createFlows && extensions.createFlows
+                    ? (client) => mergeNamespace(baseRuntime.createFlows(client), extensions.createFlows(client))
+                    : extensions.createFlows ?? baseRuntime?.createFlows,
+            },
+            enumerable: false,
+            configurable: false,
+            writable: false,
+        });
     }
-    get connectionState() {
-        return this.connection.getState();
+    return extended;
+}
+function getStackRuntimeExtensions(stack) {
+    return stack[STACK_RUNTIME_EXTENSIONS];
+}
+function defineClientField(target, key, value) {
+    if (value === undefined || key in target) {
+        return;
+    }
+    Object.defineProperty(target, key, {
+        value,
+        enumerable: true,
+        configurable: true,
+        writable: false,
+    });
+}
+function applyConnectedStackExtensions(client, stack) {
+    const extendedStack = stack;
+    defineClientField(client, 'addresses', extendedStack.addresses);
+    defineClientField(client, 'constants', extendedStack.constants);
+    defineClientField(client, 'defaults', extendedStack.defaults);
+    defineClientField(client, 'math', extendedStack.math);
+    const runtime = getStackRuntimeExtensions(stack);
+    defineClientField(client, 'flows', runtime?.createFlows?.(client));
+    defineClientField(client, 'read', runtime?.createRead?.(client));
+    return client;
+}
+
+function isPreparedInstruction(instruction) {
+    return 'kind' in instruction
+        && instruction.kind === 'instruction'
+        && 'instruction' in instruction;
+}
+function nonEmpty(values, label) {
+    if (values.length === 0) {
+        throw new Error(`${label} must contain at least one item`);
     }
-    get stackName() {
-        return this.stack.name;
+    return [...values];
+}
+function dedupe(values) {
+    return [...new Set(values)];
+}
+function inferSignerAddresses(instructions) {
+    return dedupe(instructions.flatMap((instruction) => instruction.keys.filter((key) => key.isSigner).map((key) => key.pubkey)));
+}
+function createPreparedTransactionBody(input) {
+    const instructions = nonEmpty(input.instructions, `Transaction '${input.name}'`);
+    return {
+        name: input.name,
+        instructions,
+        requiredSignerAddresses: dedupe(input.requiredSignerAddresses ?? inferSignerAddresses(instructions)),
+        errors: [...(input.errors ?? [])],
+    };
+}
+function createPlan(name, artifacts, transactions) {
+    return {
+        name,
+        artifacts,
+        transactions: nonEmpty(transactions, `Flow '${name}'`),
+    };
+}
+function createPreparedInstruction(input) {
+    const transaction = createPreparedTransactionBody({
+        name: input.name,
+        instructions: [input.instruction],
+        requiredSignerAddresses: input.requiredSignerAddresses,
+        errors: input.errors,
+    });
+    return {
+        kind: 'instruction',
+        name: input.name,
+        instruction: input.instruction,
+        transaction,
+        plan: createPlan(input.name, input.artifacts, [transaction]),
+        artifacts: input.artifacts,
+    };
+}
+function createPreparedTransaction(input) {
+    const hasInstructions = input.instructions !== undefined;
+    const hasOperations = input.operations !== undefined;
+    if (hasInstructions === hasOperations) {
+        throw new Error(`Transaction '${input.name}' must provide exactly one of instructions or operations`);
+    }
+    const transactionParts = hasOperations
+        ? input.operations.map((operation) => operation.transaction)
+        : input.instructions.map((instruction) => isPreparedInstruction(instruction)
+            ? instruction.transaction
+            : createPreparedTransactionBody({
+                name: input.name,
+                instructions: [instruction],
+            }));
+    const transaction = createPreparedTransactionBody({
+        name: input.name,
+        instructions: transactionParts.flatMap((part) => part.instructions),
+        requiredSignerAddresses: input.requiredSignerAddresses
+            ?? transactionParts.flatMap((part) => part.requiredSignerAddresses),
+        errors: input.errors ?? transactionParts.flatMap((part) => part.errors),
+    });
+    return {
+        kind: 'transaction',
+        name: input.name,
+        transaction,
+        plan: createPlan(input.name, input.artifacts, [transaction]),
+        artifacts: input.artifacts,
+    };
+}
+function createPreparedFlow(input) {
+    const transactions = input.transactions.map((transaction) => createPreparedTransactionBody(transaction));
+    return {
+        kind: 'flow',
+        name: input.name,
+        plan: createPlan(input.name, input.artifacts, transactions),
+        artifacts: input.artifacts,
+    };
+}
+function prependTransactionInstructions(transaction, instructions) {
+    return createPreparedTransactionBody({
+        ...transaction,
+        instructions: [...instructions, ...transaction.instructions],
+        requiredSignerAddresses: [
+            ...inferSignerAddresses(instructions),
+            ...transaction.requiredSignerAddresses,
+        ],
+    });
+}
+function appendTransactionInstructions(transaction, instructions) {
+    return createPreparedTransactionBody({
+        ...transaction,
+        instructions: [...transaction.instructions, ...instructions],
+        requiredSignerAddresses: [
+            ...transaction.requiredSignerAddresses,
+            ...inferSignerAddresses(instructions),
+        ],
+    });
+}
+function appendFlowTransactions(flow, transactions) {
+    return createPreparedFlow({
+        name: flow.name,
+        artifacts: flow.artifacts,
+        transactions: [...flow.plan.transactions, ...transactions],
+    });
+}
+function prependFlowTransactionInstructions(flow, transactionIndex, instructions) {
+    const transaction = flow.plan.transactions[transactionIndex];
+    if (!transaction) {
+        throw new Error(`Flow '${flow.name}' has no transaction at index ${transactionIndex}`);
+    }
+    const transactions = [...flow.plan.transactions];
+    transactions[transactionIndex] = prependTransactionInstructions(transaction, instructions);
+    return createPreparedFlow({
+        name: flow.name,
+        artifacts: flow.artifacts,
+        transactions,
+    });
+}
+function inferSignerAddress(value) {
+    if (typeof value === 'string' && value.length > 0) {
+        return value;
     }
-    get store() {
-        return this.storage;
+    if (!value || typeof value !== 'object') {
+        return null;
     }
-    onConnectionStateChange(callback) {
-        return this.connection.onStateChange(callback);
+    const candidate = value;
+    if (typeof candidate.address === 'string' && candidate.address.length > 0) {
+        return candidate.address;
     }
-    onFrame(callback) {
-        return this.connection.onFrame(callback);
+    if (typeof candidate.publicKey === 'string' && candidate.publicKey.length > 0) {
+        return candidate.publicKey;
     }
-    onSocketIssue(callback) {
-        return this.connection.onSocketIssue(callback);
+    const publicKey = candidate.publicKey;
+    return typeof publicKey?.toBase58 === 'function' ? publicKey.toBase58() : null;
+}
+function validateTransactionSigners(transaction, host, options) {
+    const signerAddresses = (options.signers ?? []).map(inferSignerAddress);
+    const available = new Set(options.availableSignerAddresses ?? []);
+    for (const address of options.signerRegistry?.addresses() ?? []) {
+        available.add(address);
     }
-    async connect() {
-        await this.connection.connect();
+    const wallet = options.wallet ?? host.wallet;
+    for (const address of wallet?.signerAddresses ?? []) {
+        available.add(address);
     }
-    disconnect() {
-        this.subscriptionRegistry.clear();
-        this.connection.disconnect();
+    const walletAddress = wallet?.publicKey ?? host.publicKey;
+    if (walletAddress) {
+        available.add(walletAddress);
     }
-    isConnected() {
-        return this.connection.isConnected();
+    for (const address of signerAddresses) {
+        if (address) {
+            available.add(address);
+        }
     }
-    clearStore() {
-        this.storage.clear();
+    const missing = transaction.requiredSignerAddresses.filter((address) => !available.has(address));
+    if (missing.length > 0) {
+        throw new Error(`Missing signer(s) for ${transaction.name}: ${missing.join(', ')}`);
     }
-    getStore() {
-        return this.storage;
+}
+class OperationExecutionError extends Error {
+    constructor(input) {
+        super(`Operation '${input.operation.name}' failed at transaction ${input.failedTransactionIndex + 1} (${input.failedTransaction.name})`);
+        this.name = 'OperationExecutionError';
+        this.operation = input.operation;
+        this.failedTransaction = input.failedTransaction;
+        this.failedTransactionIndex = input.failedTransactionIndex;
+        this.completedReceipts = [...input.completedReceipts];
+        this.cause = input.cause;
     }
-    getConnection() {
-        return this.connection;
+}
+async function executePreparedOperation(host, operation, options = {}) {
+    const receipts = [];
+    const signers = [
+        ...new Set([
+            ...(options.signerRegistry?.values() ?? []),
+            ...(options.signers ?? []),
+        ]),
+    ];
+    for (const [transactionIndex, transaction] of operation.plan.transactions.entries()) {
+        try {
+            validateTransactionSigners(transaction, host, options);
+            await options.onTransactionStart?.({ operation, transaction, transactionIndex });
+            const result = await host.transaction(transaction.instructions, {
+                wallet: options.wallet,
+                send: options.send,
+                errors: [...transaction.errors],
+                signers: signers.length > 0 ? signers : undefined,
+            });
+            const receipt = {
+                transactionIndex,
+                transactionName: transaction.name,
+                signature: result.signature,
+                slot: result.slot,
+            };
+            receipts.push(receipt);
+            await options.onTransactionSuccess?.({
+                operation,
+                transaction,
+                transactionIndex,
+                receipt,
+            });
+        }
+        catch (cause) {
+            throw new OperationExecutionError({
+                operation,
+                failedTransaction: transaction,
+                failedTransactionIndex: transactionIndex,
+                completedReceipts: receipts,
+                cause,
+            });
+        }
     }
-    getSubscriptionRegistry() {
-        return this.subscriptionRegistry;
+    if (operation.kind === 'flow') {
+        return {
+            kind: 'flow',
+            operationName: operation.name,
+            artifacts: operation.artifacts,
+            signatures: nonEmpty(receipts.map((receipt) => receipt.signature), `Operation '${operation.name}' signatures`),
+            transactions: nonEmpty(receipts, `Operation '${operation.name}' receipts`),
+        };
     }
+    return {
+        kind: operation.kind,
+        operationName: operation.name,
+        artifacts: operation.artifacts,
+        signatures: [receipts[0].signature],
+        transaction: receipts[0],
+    };
 }
-
-function getNestedValue(obj, path) {
-    let current = obj;
-    for (const segment of path) {
-        if (current === null || current === undefined)
-            return undefined;
-        if (typeof current !== 'object')
-            return undefined;
-        current = current[segment];
+function convertToJsonValue(value, ancestors) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean') {
+        return value;
     }
-    return current;
-}
-function compareSortValues(a, b) {
-    if (a === b)
-        return 0;
-    if (a === undefined || a === null)
-        return -1;
-    if (b === undefined || b === null)
-        return 1;
-    if (typeof a === 'number' && typeof b === 'number') {
-        return a - b;
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : null;
     }
-    if (typeof a === 'string' && typeof b === 'string') {
-        return a.localeCompare(b);
+    if (typeof value === 'bigint') {
+        return value.toString();
     }
-    if (typeof a === 'boolean' && typeof b === 'boolean') {
-        return (a ? 1 : 0) - (b ? 1 : 0);
+    if (value === undefined
+        || typeof value === 'function'
+        || typeof value === 'symbol') {
+        return undefined;
     }
-    return String(a).localeCompare(String(b));
-}
-class ViewData {
-    constructor(sortConfig) {
-        this.entities = new Map();
-        this.accessOrder = [];
-        this.sortedKeys = [];
-        this.sortConfig = sortConfig;
+    if (typeof value !== 'object') {
+        return String(value);
     }
-    get(key) {
-        return this.entities.get(key);
+    if (ancestors.has(value)) {
+        throw new Error('Cannot convert a circular value to JSON');
     }
-    set(key, value) {
-        const isNew = !this.entities.has(key);
-        this.entities.set(key, value);
-        if (this.sortConfig) {
-            this.updateSortedPosition(key, value, isNew);
+    ancestors.add(value);
+    try {
+        if (ArrayBuffer.isView(value)) {
+            return Array.from(new Uint8Array(value.buffer, value.byteOffset, value.byteLength));
         }
-        else {
-            if (isNew) {
-                this.accessOrder.push(key);
-            }
-            else {
-                this.touch(key);
-            }
+        if (value instanceof ArrayBuffer) {
+            return Array.from(new Uint8Array(value));
         }
-    }
-    updateSortedPosition(key, value, isNew) {
-        if (!isNew) {
-            const existingIdx = this.sortedKeys.indexOf(key);
-            if (existingIdx !== -1) {
-                this.sortedKeys.splice(existingIdx, 1);
-            }
+        if (Array.isArray(value)) {
+            return value.map((entry) => convertToJsonValue(entry, ancestors) ?? null);
         }
-        const sortValue = getNestedValue(value, this.sortConfig.field);
-        const isDesc = this.sortConfig.order === 'desc';
-        let insertIdx = this.binarySearchInsertPosition(sortValue, key, isDesc);
-        this.sortedKeys.splice(insertIdx, 0, key);
-    }
-    binarySearchInsertPosition(sortValue, key, isDesc) {
-        let low = 0;
-        let high = this.sortedKeys.length;
-        while (low < high) {
-            const mid = Math.floor((low + high) / 2);
-            const midKey = this.sortedKeys[mid];
-            if (midKey === undefined)
-                break;
-            const midEntity = this.entities.get(midKey);
-            const midValue = getNestedValue(midEntity, this.sortConfig.field);
-            let cmp = compareSortValues(sortValue, midValue);
-            if (isDesc)
-                cmp = -cmp;
-            if (cmp === 0) {
-                cmp = key.localeCompare(midKey);
-            }
-            if (cmp < 0) {
-                high = mid;
-            }
-            else {
-                low = mid + 1;
-            }
+        if (value instanceof Set) {
+            return [...value].map((entry) => convertToJsonValue(entry, ancestors) ?? null);
         }
-        return low;
-    }
-    delete(key) {
-        if (this.sortConfig) {
-            const idx = this.sortedKeys.indexOf(key);
-            if (idx !== -1) {
-                this.sortedKeys.splice(idx, 1);
+        if (value instanceof Map) {
+            const result = {};
+            for (const [key, entry] of value) {
+                const converted = convertToJsonValue(entry, ancestors);
+                if (converted !== undefined) {
+                    result[String(key)] = converted;
+                }
             }
+            return result;
         }
-        else {
-            const idx = this.accessOrder.indexOf(key);
-            if (idx !== -1) {
-                this.accessOrder.splice(idx, 1);
+        const toJSON = value.toJSON;
+        if (typeof toJSON === 'function') {
+            return convertToJsonValue(toJSON.call(value), ancestors) ?? null;
+        }
+        const result = {};
+        for (const [key, entry] of Object.entries(value)) {
+            const converted = convertToJsonValue(entry, ancestors);
+            if (converted !== undefined) {
+                result[key] = converted;
             }
         }
-        return this.entities.delete(key);
+        return result;
     }
-    has(key) {
-        return this.entities.has(key);
+    finally {
+        ancestors.delete(value);
     }
-    values() {
-        if (this.sortConfig) {
-            return this.sortedKeys.map(k => this.entities.get(k));
+}
+function toJsonValue(value) {
+    return convertToJsonValue(value, new Set()) ?? null;
+}
+function describePreparedOperation(operation) {
+    return {
+        kind: operation.kind,
+        name: operation.name,
+        artifacts: toJsonValue(operation.artifacts),
+        transactions: operation.plan.transactions.map((transaction) => ({
+            name: transaction.name,
+            requiredSignerAddresses: transaction.requiredSignerAddresses,
+            errors: transaction.errors,
+            instructions: transaction.instructions.map((instruction) => ({
+                programId: instruction.programId,
+                keys: instruction.keys,
+                data: Array.from(instruction.data),
+            })),
+        })),
+    };
+}
+function formatPreparedOperation(operation) {
+    const lines = [
+        `${operation.kind}: ${operation.name}`,
+        `Transactions: ${operation.plan.transactions.length}`,
+    ];
+    for (const [index, transaction] of operation.plan.transactions.entries()) {
+        lines.push(`  ${index + 1}. ${transaction.name} (${transaction.instructions.length} instruction${transaction.instructions.length === 1 ? '' : 's'})`);
+        if (transaction.requiredSignerAddresses.length > 0) {
+            lines.push(`    Signers: ${transaction.requiredSignerAddresses.join(', ')}`);
+        }
+    }
+    return lines.join('\n');
+}
+
+function mergeAttachedPrograms(stack, attachedPrograms) {
+    const merged = { ...(attachedPrograms ?? {}) };
+    for (const [name, definition] of Object.entries(stack.programs ?? {})) {
+        if (name in merged) {
+            console.warn(`Ignoring attached program '${name}' for stack '${stack.name}' because the stack already defines that key`);
         }
-        return Array.from(this.entities.values());
+        merged[name] = definition;
     }
-    keys() {
-        if (this.sortConfig) {
-            return [...this.sortedKeys];
-        }
-        return Array.from(this.entities.keys());
+    return merged;
+}
+function normalizeProgramAccountWireKeys(value) {
+    if (Array.isArray(value)) {
+        return value.map(normalizeProgramAccountWireKeys);
     }
-    get size() {
-        return this.entities.size;
+    if (!value || typeof value !== 'object') {
+        return value;
     }
-    touch(key) {
-        if (this.sortConfig)
-            return;
-        const idx = this.accessOrder.indexOf(key);
-        if (idx !== -1) {
-            this.accessOrder.splice(idx, 1);
-            this.accessOrder.push(key);
-        }
+    return Object.fromEntries(Object.entries(value).map(([key, nestedValue]) => [
+        key.replace(/[A-Z]/g, (letter, index) => `${index === 0 ? '' : '_'}${letter.toLowerCase()}`),
+        normalizeProgramAccountWireKeys(nestedValue),
+    ]));
+}
+function parseProgramAccountValue(definition, value) {
+    const schema = definition.schema;
+    if (!schema) {
+        return value;
     }
-    evictOldest() {
-        if (this.sortConfig) {
-            const oldest = this.sortedKeys.pop();
-            if (oldest !== undefined) {
-                this.entities.delete(oldest);
-            }
-            return oldest;
-        }
-        const oldest = this.accessOrder.shift();
-        if (oldest !== undefined) {
-            this.entities.delete(oldest);
-        }
-        return oldest;
+    const parsed = schema.safeParse(value);
+    if (parsed.success) {
+        return parsed.data;
     }
-    setSortConfig(config) {
-        if (this.sortConfig)
-            return;
-        this.sortConfig = config;
-        this.rebuildSortedKeys();
+    const normalized = schema.safeParse(normalizeProgramAccountWireKeys(value));
+    if (normalized.success) {
+        return normalized.data;
     }
-    rebuildSortedKeys() {
-        if (!this.sortConfig)
-            return;
-        const entries = Array.from(this.entities.entries());
-        const isDesc = this.sortConfig.order === 'desc';
-        entries.sort((a, b) => {
-            const aValue = getNestedValue(a[1], this.sortConfig.field);
-            const bValue = getNestedValue(b[1], this.sortConfig.field);
-            let cmp = compareSortValues(aValue, bValue);
-            if (isDesc)
-                cmp = -cmp;
-            if (cmp === 0) {
-                cmp = a[0].localeCompare(b[0]);
-            }
-            return cmp;
+    throw new Error(`Program account read '${definition.account}' failed schema validation`);
+}
+function cloneStackWithPrograms(stack, programs) {
+    const cloned = Object.create(Object.getPrototypeOf(stack), Object.getOwnPropertyDescriptors(stack));
+    cloned.programs = programs;
+    return cloned;
+}
+function withPrograms(stack, attachedPrograms) {
+    return cloneStackWithPrograms(stack, mergeAttachedPrograms(stack, attachedPrograms));
+}
+let Arete$1 = class Arete {
+    constructor(url, httpBaseUrl, options) {
+        this.stack = options.stack;
+        this._wallet = options.wallet;
+        this.executionDefaults = options.execution;
+        this.httpBaseUrl = httpBaseUrl;
+        this.fetchImpl = options.fetch ?? this.resolveFetchImpl();
+        this.storage = new SortedStorageDecorator(options.storage ?? new MemoryAdapter());
+        this.processor = new FrameProcessor(this.storage, {
+            maxEntriesPerView: options.maxEntriesPerView,
+            flushIntervalMs: options.flushIntervalMs,
+            schemas: this.stack.schemas,
+            patchSchemas: this.stack.patchSchemas,
         });
-        this.sortedKeys = entries.map(([k]) => k);
-        this.accessOrder = [];
+        this.connection = new ConnectionManager({
+            websocketUrl: url,
+            reconnectIntervals: options.reconnectIntervals,
+            maxReconnectAttempts: options.maxReconnectAttempts,
+            auth: options.auth,
+        });
+        this.subscriptionRegistry = new SubscriptionRegistry(this.connection);
+        this.connection.onFrame((frame) => {
+            this.processor.handleFrame(frame);
+        });
+        this._views = createTypedViews(this.stack, this.storage, this.subscriptionRegistry);
+        this._queries = this.buildQueries();
+        this._chain = createChainClient(this.httpBaseUrl, this.authenticatedFetch.bind(this));
+        this._programs = this.buildPrograms();
     }
-    getSortConfig() {
-        return this.sortConfig;
+    resolveFetchImpl() {
+        if (typeof globalThis.fetch !== 'function') {
+            throw new AreteError('A fetch implementation is required for HTTP point reads (provide ConnectOptions.fetch or use an environment with global fetch)', 'INVALID_CONFIG');
+        }
+        return globalThis.fetch.bind(globalThis);
     }
-}
-function isObject(item) {
-    return item !== null && typeof item === 'object' && !Array.isArray(item);
-}
-function deepMergeWithAppend(target, source, appendPaths, currentPath = '') {
-    if (!isObject(target) || !isObject(source)) {
-        return source;
+    buildQueries() {
+        const queries = {};
+        for (const [name, definition] of Object.entries(this.stack.queries ?? {})) {
+            queries[name] = this.createQueryExecutor(definition);
+        }
+        return queries;
     }
-    const result = { ...target };
-    for (const key in source) {
-        const sourceValue = source[key];
-        const targetValue = result[key];
-        const fieldPath = currentPath ? `${currentPath}.${key}` : key;
-        if (Array.isArray(sourceValue) && Array.isArray(targetValue)) {
-            if (appendPaths.includes(fieldPath)) {
-                result[key] = [...targetValue, ...sourceValue];
+    buildPrograms() {
+        const bases = {};
+        for (const [name, definition] of Object.entries(this.stack.programs ?? {})) {
+            const instructions = {};
+            for (const [instructionName, handler] of Object.entries(definition.rawInstructions ?? {})) {
+                instructions[instructionName] = this.createTypedInstruction(handler);
             }
-            else {
-                result[key] = sourceValue;
+            const accounts = {};
+            for (const [accountName, accountDefinition] of Object.entries(definition.accounts ?? {})) {
+                accounts[accountName] = this.createAccountReader(accountDefinition);
             }
+            const queries = {};
+            for (const [queryName, queryDefinition] of Object.entries(definition.queries ?? {})) {
+                queries[queryName] = this.createQueryExecutor(queryDefinition);
+            }
+            bases[name] = {
+                name: definition.name,
+                programId: definition.programId,
+                schemas: definition.schemas,
+                pdas: definition.pdas ?? {},
+                accounts,
+                queries,
+                raw: instructions,
+                addresses: definition.addresses ?? {},
+                constants: definition.constants ?? {},
+                defaults: definition.defaults ?? {},
+                math: definition.math ?? {},
+            };
         }
-        else if (isObject(sourceValue) && isObject(targetValue)) {
-            result[key] = deepMergeWithAppend(targetValue, sourceValue, appendPaths, fieldPath);
-        }
-        else {
-            result[key] = sourceValue;
+        const programs = {};
+        const client = this;
+        for (const [name, definition] of Object.entries(this.stack.programs ?? {})) {
+            const base = bases[name];
+            const connectedProgram = {
+                ...base,
+                instructions: {},
+                transactions: {},
+                flows: {},
+            };
+            const runtime = getProgramRuntimeExtensions(definition);
+            const operations = runtime?.createOperations({
+                chain: this._chain,
+                get wallet() {
+                    return client._wallet;
+                },
+                program: connectedProgram,
+            });
+            connectedProgram.instructions = operations?.instructions ?? {};
+            connectedProgram.transactions = operations?.transactions ?? {};
+            connectedProgram.flows = operations?.flows ?? {};
+            programs[name] = connectedProgram;
         }
+        return programs;
     }
-    return result;
-}
-class EntityStore {
-    constructor(config = {}) {
-        this.views = new Map();
-        this.viewConfigs = new Map();
-        this.updateCallbacks = new Set();
-        this.richUpdateCallbacks = new Set();
-        this.maxEntriesPerView = config.maxEntriesPerView === undefined
-            ? DEFAULT_MAX_ENTRIES_PER_VIEW
-            : config.maxEntriesPerView;
+    createTypedInstruction(handler) {
+        return {
+            build: (params, options) => buildInstruction(handler, params, this.withWallet(options)),
+        };
     }
-    enforceMaxEntries(viewData) {
-        if (this.maxEntriesPerView === null)
-            return;
-        while (viewData.size > this.maxEntriesPerView) {
-            viewData.evictOldest();
-        }
+    createAccountReader(definition) {
+        return {
+            fetch: async (address) => {
+                const result = await this.readJson(`${definition.path}/${encodeURIComponent(address)}`);
+                return result === null ? null : parseProgramAccountValue(definition, result);
+            },
+            fetchMany: async (addresses) => {
+                const result = await this.readJson(definition.path, {
+                    method: 'POST',
+                    body: { addresses },
+                });
+                return result.map((value) => value === null ? null : parseProgramAccountValue(definition, value));
+            },
+            exists: async (address) => {
+                const result = await this.readJson(`${definition.path}/${encodeURIComponent(address)}/exists`);
+                return result.exists;
+            },
+        };
     }
-    handleFrame(frame) {
-        if (isSubscribedFrame(frame)) {
-            this.handleSubscribedFrame(frame);
-            return;
-        }
-        if (isSnapshotFrame(frame)) {
-            this.handleSnapshotFrame(frame);
-            return;
-        }
-        this.handleEntityFrame(frame);
+    createQueryExecutor(definition) {
+        return async (params) => {
+            const result = await this.readJson(definition.path, {
+                method: definition.method ?? 'POST',
+                body: params,
+            });
+            if (!definition.schema) {
+                return result;
+            }
+            const parsed = definition.schema.safeParse(result);
+            if (!parsed.success) {
+                throw new Error(`Query '${definition.name}' failed schema validation`);
+            }
+            return parsed.data;
+        };
     }
-    handleSubscribedFrame(frame) {
-        const viewPath = frame.view;
-        const config = {};
-        if (frame.sort) {
-            config.sort = frame.sort;
-        }
-        this.viewConfigs.set(viewPath, config);
-        const existingView = this.views.get(viewPath);
-        if (existingView && frame.sort) {
-            existingView.setSortConfig(frame.sort);
+    async readJson(path, options) {
+        const response = await this.authenticatedFetch(this.resolveReadUrl(path), {
+            method: options?.method ?? 'GET',
+            headers: options?.body === undefined ? undefined : { 'content-type': 'application/json' },
+            body: options?.body === undefined ? undefined : JSON.stringify(options.body),
+        });
+        return parseReadResponse(response, path);
+    }
+    async authenticatedFetch(input, init) {
+        const attempt = async (forceRefresh = false) => {
+            const token = await this.connection.getHttpAuthToken(forceRefresh);
+            const headers = new Headers(init?.headers ?? undefined);
+            if (token) {
+                headers.set('authorization', `Bearer ${token}`);
+            }
+            return this.fetchImpl(input, {
+                ...init,
+                headers,
+            });
+        };
+        let response = await attempt(false);
+        if (!response.ok) {
+            const wireErrorCode = response.headers.get('X-Error-Code');
+            const errorCode = wireErrorCode ? parseErrorCode(wireErrorCode) : undefined;
+            if (errorCode && shouldRefreshToken(errorCode)) {
+                this.connection.clearHttpAuthToken();
+                response = await attempt(true);
+            }
         }
+        return response;
     }
-    handleSnapshotFrame(frame) {
-        const viewPath = frame.entity;
-        let viewData = this.views.get(viewPath);
-        const viewConfig = this.viewConfigs.get(viewPath);
-        if (!viewData) {
-            viewData = new ViewData(viewConfig?.sort);
-            this.views.set(viewPath, viewData);
+    resolveReadUrl(path) {
+        return `${this.httpBaseUrl.replace(/\/$/, '')}${path.startsWith('/') ? path : `/${path}`}`;
+    }
+    /** Merge the client's default wallet into call options (call options win). */
+    withWallet(options) {
+        const merged = { ...(options ?? {}) };
+        if (!merged.wallet && this._wallet) {
+            merged.wallet = this._wallet;
         }
-        for (const entity of frame.data) {
-            const previousValue = viewData.get(entity.key);
-            viewData.set(entity.key, entity.data);
-            this.notifyUpdate(viewPath, entity.key, {
-                type: 'upsert',
-                key: entity.key,
-                data: entity.data,
-            });
-            this.notifyRichUpdate(viewPath, entity.key, previousValue, entity.data, 'upsert');
+        return merged;
+    }
+    static async connect(stack, options) {
+        const requestedUrl = options?.url ?? stack.endpoints.ws;
+        const autoReconnect = options?.autoReconnect !== false;
+        const httpOnly = options?.transport === 'http' || (!requestedUrl && !autoReconnect);
+        const url = httpOnly ? null : requestedUrl;
+        const httpUrl = options?.httpUrl
+            ?? stack.endpoints.http
+            ?? (requestedUrl ? deriveHttpEndpoint(requestedUrl) : undefined);
+        if (!httpOnly && !url) {
+            throw new AreteError('WebSocket URL is required (provide url option or define endpoints.ws in stack)', 'INVALID_CONFIG');
+        }
+        if (!httpUrl) {
+            throw new AreteError('HTTP endpoint is required for transport: "http" (provide httpUrl option or define endpoints.http in stack)', 'INVALID_CONFIG');
+        }
+        const attachedPrograms = options?.programs;
+        const effectiveStack = withPrograms(stack, attachedPrograms);
+        const internalOptions = {
+            stack: effectiveStack,
+            httpUrl,
+            storage: options?.storage,
+            maxEntriesPerView: options?.maxEntriesPerView,
+            flushIntervalMs: options?.flushIntervalMs,
+            autoReconnect: options?.autoReconnect,
+            reconnectIntervals: options?.reconnectIntervals,
+            maxReconnectAttempts: options?.maxReconnectAttempts,
+            validateFrames: options?.validateFrames,
+            auth: options?.auth,
+            wallet: options?.wallet,
+            fetch: options?.fetch,
+            execution: options?.execution,
+        };
+        const client = new Arete(url, httpUrl, internalOptions);
+        if (!httpOnly && autoReconnect) {
+            await client.connection.connect();
         }
-        this.enforceMaxEntries(viewData);
+        return applyConnectedStackExtensions(client, effectiveStack);
     }
-    handleEntityFrame(frame) {
-        const viewPath = frame.entity;
-        let viewData = this.views.get(viewPath);
-        const viewConfig = this.viewConfigs.get(viewPath);
-        if (!viewData) {
-            viewData = new ViewData(viewConfig?.sort);
-            this.views.set(viewPath, viewData);
+    get views() {
+        return this._views;
+    }
+    get queries() {
+        return this._queries;
+    }
+    get programs() {
+        return this._programs;
+    }
+    get chain() {
+        return this._chain;
+    }
+    /** The default wallet adapter, if one was configured. */
+    get wallet() {
+        return this._wallet;
+    }
+    /** The connected wallet address, if a default wallet was configured. */
+    get publicKey() {
+        return this._wallet?.publicKey;
+    }
+    /**
+     * Set (or clear) the default wallet adapter used for instruction execution.
+     * Useful for connecting/disconnecting a wallet after the client is created.
+     */
+    setWallet(wallet) {
+        this._wallet = wallet;
+    }
+    /**
+     * Sign and send a batch of pre-built instructions as a single transaction.
+     *
+     * Build instructions with `client.programs.<program>.raw.<name>.build(params)`
+     * and compose them here. RPC/compilation/confirmation are owned by the adapter.
+     *
+     * On failure, the error is parsed against `options.errors` when given,
+     * otherwise against error metadata aggregated from all the stack's handlers
+     * (deduped by code, first-wins — if the stack bundles programs with
+     * overlapping error codes, pass `options.errors` or use the per-instruction
+     * call path for precise attribution).
+     */
+    async transaction(instructions, options) {
+        const wallet = options?.wallet ?? this._wallet;
+        if (!wallet) {
+            throw new Error('Wallet required to sign and send transaction');
         }
-        const previousValue = viewData.get(frame.key);
-        switch (frame.op) {
-            case 'create':
-            case 'upsert':
-                viewData.set(frame.key, frame.data);
-                this.enforceMaxEntries(viewData);
-                this.notifyUpdate(viewPath, frame.key, {
-                    type: 'upsert',
-                    key: frame.key,
-                    data: frame.data,
-                });
-                this.notifyRichUpdate(viewPath, frame.key, previousValue, frame.data, frame.op);
-                break;
-            case 'patch': {
-                const existing = viewData.get(frame.key);
-                const appendPaths = frame.append ?? [];
-                const merged = existing
-                    ? deepMergeWithAppend(existing, frame.data, appendPaths)
-                    : frame.data;
-                viewData.set(frame.key, merged);
-                this.enforceMaxEntries(viewData);
-                this.notifyUpdate(viewPath, frame.key, {
-                    type: 'patch',
-                    key: frame.key,
-                    data: frame.data,
-                });
-                this.notifyRichUpdate(viewPath, frame.key, previousValue, merged, 'patch', frame.data);
-                break;
+        try {
+            const sendOptions = {
+                ...(options?.send ?? {}),
+            };
+            if (options?.signers !== undefined) {
+                sendOptions.signers = options.signers;
             }
-            case 'delete':
-                viewData.delete(frame.key);
-                this.notifyUpdate(viewPath, frame.key, {
-                    type: 'delete',
-                    key: frame.key,
-                });
-                if (previousValue !== undefined) {
-                    this.notifyRichDelete(viewPath, frame.key, previousValue);
+            const result = await wallet.signAndSend(instructions, sendOptions);
+            return { signature: result.signature, slot: result.slot };
+        }
+        catch (err) {
+            const programError = parseInstructionError(err, options?.errors ?? this.aggregateErrors());
+            if (programError) {
+                throw new InstructionError(`${programError.name} (${programError.code}): ${programError.message}`, programError, err);
+            }
+            throw err;
+        }
+    }
+    execute(prepared, options) {
+        const defaults = this.executionDefaults;
+        return executePreparedOperation(this, prepared, {
+            wallet: options?.wallet ?? defaults?.wallet,
+            send: defaults?.send || options?.send
+                ? { ...(defaults?.send ?? {}), ...(options?.send ?? {}) }
+                : undefined,
+            signers: options?.signers ?? defaults?.signers,
+            signerRegistry: options?.signerRegistry ?? defaults?.signerRegistry,
+            availableSignerAddresses: options?.availableSignerAddresses ?? defaults?.availableSignerAddresses,
+            onTransactionStart: options?.onTransactionStart ?? defaults?.onTransactionStart,
+            onTransactionSuccess: options?.onTransactionSuccess ?? defaults?.onTransactionSuccess,
+        });
+    }
+    /** Error metadata from every handler in the stack, deduped by code. */
+    aggregateErrors() {
+        if (!this._aggregatedErrors) {
+            const all = [];
+            const seen = new Set();
+            const collect = (handler) => {
+                for (const error of handler.errors ?? []) {
+                    if (!seen.has(error.code)) {
+                        seen.add(error.code);
+                        all.push(error);
+                    }
                 }
-                break;
+            };
+            for (const program of Object.values(this.stack.programs ?? {})) {
+                for (const handler of Object.values(program.rawInstructions ?? {})) {
+                    collect(handler);
+                }
+            }
+            this._aggregatedErrors = all;
         }
+        return this._aggregatedErrors;
     }
-    getAll(viewPath) {
-        const viewData = this.views.get(viewPath);
-        if (!viewData)
-            return [];
-        return viewData.values();
+    get connectionState() {
+        return this.connection.getState();
     }
-    get(viewPath, key) {
-        const viewData = this.views.get(viewPath);
-        if (!viewData)
-            return null;
-        const value = viewData.get(key);
-        return value !== undefined ? value : null;
+    get stackName() {
+        return this.stack.name;
     }
-    getAllSync(viewPath) {
-        const viewData = this.views.get(viewPath);
-        if (!viewData)
-            return undefined;
-        return viewData.values();
+    get store() {
+        return this.storage;
     }
-    getSync(viewPath, key) {
-        const viewData = this.views.get(viewPath);
-        if (!viewData)
-            return undefined;
-        const value = viewData.get(key);
-        return value !== undefined ? value : null;
+    onConnectionStateChange(callback) {
+        return this.connection.onStateChange(callback);
     }
-    keys(viewPath) {
-        const viewData = this.views.get(viewPath);
-        if (!viewData)
-            return [];
-        return viewData.keys();
+    onFrame(callback) {
+        return this.connection.onFrame(callback);
     }
-    size(viewPath) {
-        const viewData = this.views.get(viewPath);
-        return viewData?.size ?? 0;
+    onSocketIssue(callback) {
+        return this.connection.onSocketIssue(callback);
     }
-    clear() {
-        this.views.clear();
+    async connect() {
+        await this.connection.connect();
     }
-    clearView(viewPath) {
-        this.views.delete(viewPath);
-        this.viewConfigs.delete(viewPath);
+    disconnect() {
+        this.subscriptionRegistry.clear();
+        this.connection.disconnect();
     }
-    getViewConfig(viewPath) {
-        return this.viewConfigs.get(viewPath);
+    isConnected() {
+        return this.connection.isConnected();
     }
-    setViewConfig(viewPath, config) {
-        this.viewConfigs.set(viewPath, config);
-        const existingView = this.views.get(viewPath);
-        if (existingView && config.sort) {
-            existingView.setSortConfig(config.sort);
-        }
+    clearStore() {
+        this.storage.clear();
     }
-    onUpdate(callback) {
-        this.updateCallbacks.add(callback);
-        return () => {
-            this.updateCallbacks.delete(callback);
-        };
+    getStore() {
+        return this.storage;
     }
-    onRichUpdate(callback) {
-        this.richUpdateCallbacks.add(callback);
-        return () => {
-            this.richUpdateCallbacks.delete(callback);
-        };
+    getConnection() {
+        return this.connection;
     }
-    subscribe(viewPath, callback) {
-        const handler = (path, _key, update) => {
-            if (path === viewPath) {
-                callback(update);
-            }
-        };
-        this.updateCallbacks.add(handler);
-        return () => {
-            this.updateCallbacks.delete(handler);
-        };
+    getSubscriptionRegistry() {
+        return this.subscriptionRegistry;
     }
-    subscribeToKey(viewPath, key, callback) {
-        const handler = (path, updateKey, update) => {
-            if (path === viewPath && updateKey === key) {
-                callback(update);
+};
+
+function createSignerRegistry(entries = []) {
+    const signers = new Map();
+    for (const [address, signer] of entries) {
+        if (!address) {
+            throw new Error('Signer registry addresses must not be empty');
+        }
+        signers.set(address, signer);
+    }
+    return {
+        register(address, signer) {
+            if (!address) {
+                throw new Error('Signer registry addresses must not be empty');
             }
-        };
-        this.updateCallbacks.add(handler);
-        return () => {
-            this.updateCallbacks.delete(handler);
-        };
+            signers.set(address, signer);
+        },
+        unregister(address) {
+            return signers.delete(address);
+        },
+        get(address) {
+            return signers.get(address);
+        },
+        has(address) {
+            return signers.has(address);
+        },
+        addresses() {
+            return [...signers.keys()];
+        },
+        values() {
+            return [...signers.values()];
+        },
+        entries() {
+            return [...signers.entries()];
+        },
+        clear() {
+            signers.clear();
+        },
+    };
+}
+
+function resolveMemberConnectOptions(stack, member, options, forceHttpOnly) {
+    const transport = member?.transport ?? options?.transport ?? (forceHttpOnly ? 'http' : 'ws');
+    // Resolution order: per-member override → the stack's own endpoints →
+    // session-wide fallback endpoints.
+    const url = member?.url ?? (stack.endpoints.ws || options?.endpoints?.ws);
+    const httpUrl = member?.httpUrl ?? stack.endpoints.http ?? options?.endpoints?.http;
+    return {
+        url,
+        httpUrl,
+        transport,
+        auth: member?.auth ?? options?.auth,
+        storage: member?.storage,
+        autoReconnect: member?.autoReconnect,
+        wallet: options?.wallet,
+        fetch: options?.fetch,
+    };
+}
+function programAsStack(name, program) {
+    return {
+        name,
+        endpoints: { ws: '' },
+        views: {},
+        programs: { [name]: program },
+    };
+}
+async function createSession(definition, options) {
+    const stackEntries = Object.entries(definition.stacks ?? {});
+    const programEntries = Object.entries(definition.programs ?? {});
+    if (stackEntries.length === 0 && programEntries.length === 0) {
+        throw new AreteError('createSession requires at least one stack or program member', 'INVALID_CONFIG');
+    }
+    let wallet = options?.wallet;
+    const signerRegistry = options?.signerRegistry ?? createSignerRegistry();
+    const connectedStacks = await Promise.all(stackEntries.map(async ([key, stack]) => {
+        const memberOptions = options?.stacks?.[key];
+        const effectiveStack = withPrograms(stack, memberOptions?.programs);
+        const connectOptions = resolveMemberConnectOptions(effectiveStack, memberOptions, options, false);
+        const client = await Arete$1.connect(effectiveStack, connectOptions);
+        return [key, client];
+    }));
+    const connectedPrograms = await Promise.all(programEntries.map(async ([key, program]) => {
+        const syntheticStack = programAsStack(key, program);
+        const connectOptions = resolveMemberConnectOptions(syntheticStack, options?.programs?.[key], options, true);
+        const client = await Arete$1.connect(syntheticStack, connectOptions);
+        return [key, client];
+    }));
+    const memberClients = [
+        ...connectedStacks.map(([, client]) => client),
+        ...connectedPrograms.map(([, client]) => client),
+    ];
+    const executionHost = memberClients[0];
+    const stacks = Object.fromEntries(connectedStacks);
+    const explicitProgramKeys = new Set(connectedPrograms.map(([key]) => key));
+    const programOwners = new Map();
+    const connectedProgramEntries = connectedPrograms.map(([key, client]) => [
+        key,
+        client.programs[key],
+    ]);
+    const promotedPrograms = Object.fromEntries(connectedProgramEntries);
+    for (const [stackKey, client] of connectedStacks) {
+        for (const [programKey, program] of Object.entries(client.programs)) {
+            if (explicitProgramKeys.has(programKey)) {
+                continue;
+            }
+            const existingOwner = programOwners.get(programKey);
+            if (existingOwner) {
+                console.warn(`Program '${programKey}' is bundled by stacks '${existingOwner.stack}'` +
+                    ` (${existingOwner.programId ?? 'unknown program ID'}) and '${stackKey}'` +
+                    ` (${program.programId ?? 'unknown program ID'}); session.programs.${programKey}` +
+                    ` uses '${existingOwner.stack}' because it was connected first`);
+                continue;
+            }
+            promotedPrograms[programKey] = program;
+            programOwners.set(programKey, { stack: stackKey, programId: program.programId });
+        }
+    }
+    const programs = promotedPrograms;
+    const chain = options?.chain ?? (options?.endpoints?.http !== undefined
+        ? createChainClient(options.endpoints.http, (options?.fetch ?? globalThis.fetch?.bind(globalThis)))
+        : executionHost.chain);
+    const session = {
+        stacks,
+        programs,
+        get wallet() {
+            return wallet;
+        },
+        signerRegistry,
+        chain,
+        transaction(instructions, transactionOptions) {
+            const defaults = options?.execution;
+            const configuredSigners = transactionOptions?.signers ?? defaults?.signers;
+            const signers = [...new Set([...signerRegistry.values(), ...(configuredSigners ?? [])])];
+            return executionHost.transaction(instructions, {
+                wallet: transactionOptions?.wallet ?? defaults?.wallet,
+                send: defaults?.send || transactionOptions?.send
+                    ? { ...(defaults?.send ?? {}), ...(transactionOptions?.send ?? {}) }
+                    : undefined,
+                errors: transactionOptions?.errors,
+                signers: signers.length > 0 ? signers : undefined,
+            });
+        },
+        execute(prepared, executionOptions) {
+            const defaults = options?.execution;
+            const configuredSigners = executionOptions?.signers ?? defaults?.signers;
+            return executionHost.execute(prepared, {
+                wallet: executionOptions?.wallet ?? defaults?.wallet,
+                send: defaults?.send || executionOptions?.send
+                    ? { ...(defaults?.send ?? {}), ...(executionOptions?.send ?? {}) }
+                    : undefined,
+                signers: configuredSigners,
+                signerRegistry,
+                availableSignerAddresses: executionOptions?.availableSignerAddresses ?? defaults?.availableSignerAddresses,
+                onTransactionStart: executionOptions?.onTransactionStart ?? defaults?.onTransactionStart,
+                onTransactionSuccess: executionOptions?.onTransactionSuccess ?? defaults?.onTransactionSuccess,
+            });
+        },
+        setWallet(nextWallet) {
+            wallet = nextWallet;
+            for (const client of memberClients) {
+                client.setWallet(nextWallet);
+            }
+        },
+        close() {
+            for (const client of memberClients) {
+                client.disconnect();
+            }
+        },
+    };
+    return session;
+}
+
+function instructionOperation(prepare) {
+    return {
+        kind: 'instruction',
+        prepare: async (input) => prepare(input),
+    };
+}
+function transactionOperation(prepare) {
+    return {
+        kind: 'transaction',
+        prepare: async (input) => prepare(input),
+    };
+}
+function flowOperation(prepare) {
+    return {
+        kind: 'flow',
+        prepare: async (input) => prepare(input),
+    };
+}
+
+function chainAccountLoader(chain) {
+    return {
+        async getAccount(address) {
+            const account = await chain.account(address);
+            return account ? { data: account.data } : null;
+        },
+    };
+}
+
+const SPL_TOKEN_PROGRAM_ADDRESS = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA';
+const TOKEN_2022_PROGRAM_ADDRESS = 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb';
+const ASSOCIATED_TOKEN_PROGRAM_ADDRESS = 'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL';
+const SYSTEM_PROGRAM_ADDRESS = '11111111111111111111111111111111';
+async function resolveTokenProgramAddress(chain, mint, override) {
+    if (override) {
+        return override;
+    }
+    const mintAccount = await chain.mint(mint);
+    if (!mintAccount) {
+        throw new Error(`Mint account not found while resolving token program: ${mint}`);
+    }
+    if (mintAccount.ownerProgram !== SPL_TOKEN_PROGRAM_ADDRESS &&
+        mintAccount.ownerProgram !== TOKEN_2022_PROGRAM_ADDRESS) {
+        throw new Error(`Mint ${mint} is owned by unsupported token program ${mintAccount.ownerProgram}`);
+    }
+    return mintAccount.ownerProgram;
+}
+function deriveAssociatedTokenAccount(input) {
+    const [address] = findProgramAddressSync([
+        createPublicKeySeed(input.owner),
+        createPublicKeySeed(input.tokenProgram ?? SPL_TOKEN_PROGRAM_ADDRESS),
+        createPublicKeySeed(input.mint),
+    ], ASSOCIATED_TOKEN_PROGRAM_ADDRESS);
+    return address;
+}
+
+/** Convert a UI amount ("1.5") to raw base units using string math (no float precision loss). */
+function parseUiAmountToRaw(value, decimals) {
+    const trimmed = String(value).trim();
+    if (!/^\d+(?:\.\d+)?$/.test(trimmed)) {
+        throw new Error(`Invalid UI amount: ${value}`);
+    }
+    const [wholePart, fractionPart = ''] = trimmed.split('.');
+    if (fractionPart.length > decimals) {
+        const excess = fractionPart.slice(decimals);
+        if (/[1-9]/.test(excess)) {
+            throw new Error(`UI amount ${value} has more fractional digits than the mint's ${decimals} decimals`);
+        }
+    }
+    const fraction = fractionPart.padEnd(decimals, '0');
+    const whole = BigInt(wholePart || '0') * 10n ** BigInt(decimals);
+    const fractional = BigInt(fraction.slice(0, decimals) || '0');
+    return whole + fractional;
+}
+/** Format raw base units as a UI decimal string (inverse of {@link parseUiAmountToRaw}). */
+function formatRawToUi(raw, decimals) {
+    const value = BigInt(raw);
+    const negative = value < 0n;
+    const magnitude = negative ? -value : value;
+    const scale = 10n ** BigInt(decimals);
+    const whole = magnitude / scale;
+    const fraction = magnitude % scale;
+    const sign = negative ? '-' : '';
+    if (decimals === 0 || fraction === 0n) {
+        return `${sign}${whole.toString()}`;
+    }
+    const fractionText = fraction.toString().padStart(decimals, '0').replace(/0+$/, '');
+    return `${sign}${whole.toString()}.${fractionText}`;
+}
+/** Resolve an {@link AmountInput} to raw base units with known decimals. */
+function toRawAmount(amount, decimals) {
+    if (typeof amount === 'bigint') {
+        return amount;
     }
-    notifyUpdate(viewPath, key, update) {
-        for (const callback of this.updateCallbacks) {
-            callback(viewPath, key, update);
-        }
+    if ('raw' in amount) {
+        return BigInt(amount.raw);
     }
-    notifyRichUpdate(viewPath, key, before, after, _op, patch) {
-        const richUpdate = before === undefined
-            ? { type: 'created', key, data: after }
-            : { type: 'updated', key, before, after, patch };
-        for (const callback of this.richUpdateCallbacks) {
-            callback(viewPath, key, richUpdate);
-        }
+    return parseUiAmountToRaw(amount.ui, decimals);
+}
+/** Fetch a mint's decimals via the chain read endpoint, throwing when unavailable. */
+async function getMintDecimals(chain, mint) {
+    const account = await chain.mint(mint);
+    if (!account || account.decimals == null) {
+        throw new Error(`Mint ${mint} is missing decimals on the configured read endpoint.`);
     }
-    notifyRichDelete(viewPath, key, lastKnown) {
-        const richUpdate = { type: 'deleted', key, lastKnown };
-        for (const callback of this.richUpdateCallbacks) {
-            callback(viewPath, key, richUpdate);
-        }
+    return account.decimals;
+}
+/**
+ * Resolve an {@link AmountInput} to raw base units, fetching the mint's
+ * decimals only when they are unknown and actually needed (a bare bigint or
+ * `{raw}` input with explicit `decimals` never touches the network).
+ */
+async function resolveAmount(chain, input) {
+    const needsDecimalsForParse = typeof input.amount !== 'bigint' && 'ui' in input.amount;
+    if (!needsDecimalsForParse) {
+        const raw = typeof input.amount === 'bigint'
+            ? input.amount
+            : BigInt(input.amount.raw);
+        const decimals = input.decimals ?? await getMintDecimals(chain, input.mint);
+        return { raw, decimals };
+    }
+    const decimals = input.decimals ?? await getMintDecimals(chain, input.mint);
+    return { raw: toRawAmount(input.amount, decimals), decimals };
+}
+/**
+ * Resolve an {@link AmountInput} to raw base units without forcing a decimals
+ * fetch when the input is already expressed in raw units.
+ */
+async function resolveAmountToRaw(chain, input) {
+    if (typeof input.amount === 'bigint') {
+        return input.amount;
+    }
+    if ('raw' in input.amount) {
+        return BigInt(input.amount.raw);
     }
+    const decimals = input.decimals ?? await getMintDecimals(chain, input.mint);
+    return toRawAmount(input.amount, decimals);
 }
+/** Resolve a named set of {@link AmountInput} values to raw base units. */
+async function resolveAmountsToRaw(chain, inputs) {
+    const entries = await Promise.all(Object.entries(inputs).map(async ([name, input]) => {
+        const raw = await resolveAmountToRaw(chain, input);
+        return [name, raw];
+    }));
+    return Object.fromEntries(entries);
+}
+
+const Arete = Object.assign(Arete$1, { session: createSession });
 
-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 { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, Arete, AreteError, ConnectionManager, DEFAULT_CONFIG, DEFAULT_MAX_ENTRIES_PER_VIEW, FrameProcessor, InstructionError, MemoryAdapter, OperationExecutionError, PROGRAM_OPERATION_EXTENSIONS, ReadRequestError, SPL_TOKEN_PROGRAM_ADDRESS, STACK_RUNTIME_EXTENSIONS, SYSTEM_PROGRAM_ADDRESS, SubscriptionRegistry, TOKEN_2022_PROGRAM_ADDRESS, account, appendFlowTransactions, appendTransactionInstructions, applyConnectedStackExtensions, arg, buildInstruction, bytes, chainAccountLoader, createChainClient, createEntityStream, createInstructionExecutor, createInstructionHandler, createPreparedFlow, createPreparedInstruction, createPreparedTransaction, createPreparedTransactionBody, createProgramPdas, createPublicKeySeed, createRichUpdateStream, createSeed, createSession, createSignerRegistry, createTypedListView, createTypedStateView, createTypedViews, createUpdateStream, decodeBase58, defineProgramExtensions, defineStackExtensions, deriveAssociatedTokenAccount, deriveHttpEndpoint, findProgramAddress as derivePda, describePreparedOperation, encodeBase58, executeInstruction, executePreparedOperation, extendProgram, extendPrograms, extendStack, findProgramAddress, findProgramAddressSync, flowOperation, formatPreparedOperation, formatProgramError, formatRawToUi, getMintDecimals, getProgramRuntimeExtensions, getStackRuntimeExtensions, instructionOperation, isEntityFrame, isSnapshotFrame, isSubscribedFrame, isValidFrame, literal, parseFrame, parseFrameFromBlob, parseInstructionError, parseUiAmountToRaw, pda, prependFlowTransactionInstructions, prependTransactionInstructions, programAccountRead, programQuery, resolveAccounts, resolveAmount, resolveAmountToRaw, resolveAmountsToRaw, resolveTokenProgramAddress, serializeInstructionData, stackQuery, toJsonValue, toRawAmount, transactionOperation, validateAccountResolution, withPrograms };
 //# sourceMappingURL=index.esm.js.map