@usearete/react 0.1.4 → 0.2.0

package/dist/index.js

@@ -1481,7 +1481,7 @@ const BS_FINISH_DONE    = 4; /* finish done, accept no more input or output */
 
 const OS_CODE = 0x03; // Unix :) . Don't detect, use this default.
 
-const err = (strm, errorCode) => {
+const err$1 = (strm, errorCode) => {
   strm.msg = messages[errorCode];
   return errorCode;
 };
@@ -2798,7 +2798,7 @@ const deflateStateCheck = (strm) => {
 const deflateResetKeep = (strm) => {
 
   if (deflateStateCheck(strm)) {
-    return err(strm, Z_STREAM_ERROR$2);
+    return err$1(strm, Z_STREAM_ERROR$2);
   }
 
   strm.total_in = strm.total_out = 0;
@@ -2872,7 +2872,7 @@ const deflateInit2 = (strm, level, method, windowBits, memLevel, strategy) => {
   if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method !== Z_DEFLATED$2 ||
     windowBits < 8 || windowBits > 15 || level < 0 || level > 9 ||
     strategy < 0 || strategy > Z_FIXED || (windowBits === 8 && wrap !== 1)) {
-    return err(strm, Z_STREAM_ERROR$2);
+    return err$1(strm, Z_STREAM_ERROR$2);
   }
 
 
@@ -2977,7 +2977,7 @@ const deflateInit = (strm, level) => {
 const deflate$2 = (strm, flush) => {
 
   if (deflateStateCheck(strm) || flush > Z_BLOCK$1 || flush < 0) {
-    return strm ? err(strm, Z_STREAM_ERROR$2) : Z_STREAM_ERROR$2;
+    return strm ? err$1(strm, Z_STREAM_ERROR$2) : Z_STREAM_ERROR$2;
   }
 
   const s = strm.state;
@@ -2985,7 +2985,7 @@ const deflate$2 = (strm, flush) => {
   if (!strm.output ||
       (strm.avail_in !== 0 && !strm.input) ||
       (s.status === FINISH_STATE && flush !== Z_FINISH$3)) {
-    return err(strm, (strm.avail_out === 0) ? Z_BUF_ERROR$1 : Z_STREAM_ERROR$2);
+    return err$1(strm, (strm.avail_out === 0) ? Z_BUF_ERROR$1 : Z_STREAM_ERROR$2);
   }
 
   const old_flush = s.last_flush;
@@ -3011,12 +3011,12 @@ const deflate$2 = (strm, flush) => {
      */
   } else if (strm.avail_in === 0 && rank(flush) <= rank(old_flush) &&
     flush !== Z_FINISH$3) {
-    return err(strm, Z_BUF_ERROR$1);
+    return err$1(strm, Z_BUF_ERROR$1);
   }
 
   /* User must not provide more input after the first FINISH: */
   if (s.status === FINISH_STATE && strm.avail_in !== 0) {
-    return err(strm, Z_BUF_ERROR$1);
+    return err$1(strm, Z_BUF_ERROR$1);
   }
 
   /* Write the header */
@@ -3338,7 +3338,7 @@ const deflateEnd = (strm) => {
 
   strm.state = null;
 
-  return status === BUSY_STATE ? err(strm, Z_DATA_ERROR$2) : Z_OK$3;
+  return status === BUSY_STATE ? err$1(strm, Z_DATA_ERROR$2) : Z_OK$3;
 };
 
 
@@ -6764,6 +6764,453 @@ var inflate_1$1 = {
 const { Inflate, inflate, inflateRaw, ungzip } = inflate_1$1;
 var inflate_1 = inflate;
 
+/*! noble-ed25519 - MIT License (c) 2019 Paul Miller (paulmillr.com) */
+/**
+ * 4KB JS implementation of ed25519 EdDSA signatures.
+ * Compliant with RFC8032, FIPS 186-5 & ZIP215.
+ * @module
+ * @example
+ * ```js
+import * as ed from '@noble/ed25519';
+(async () => {
+  const privKey = ed.utils.randomPrivateKey();
+  const message = Uint8Array.from([0xab, 0xbc, 0xcd, 0xde]);
+  const pubKey = await ed.getPublicKeyAsync(privKey); // Sync methods are also present
+  const signature = await ed.signAsync(message, privKey);
+  const isValid = await ed.verifyAsync(signature, message, pubKey);
+})();
+```
+ */
+/**
+ * Curve params. ed25519 is twisted edwards curve. Equation is −x² + y² = -a + dx²y².
+ * * P = `2n**255n - 19n` // field over which calculations are done
+ * * N = `2n**252n + 27742317777372353535851937790883648493n` // group order, amount of curve points
+ * * h = 8 // cofactor
+ * * a = `Fp.create(BigInt(-1))` // equation param
+ * * d = -121665/121666 a.k.a. `Fp.neg(121665 * Fp.inv(121666))` // equation param
+ * * Gx, Gy are coordinates of Generator / base point
+ */
+const ed25519_CURVE = {
+    p: 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffedn,
+    n: 0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3edn,
+    h: 8n,
+    a: 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffecn,
+    d: 0x52036cee2b6ffe738cc740797779e89800700a4d4141d8ab75eb4dca135978a3n,
+    Gx: 0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51an,
+    Gy: 0x6666666666666666666666666666666666666666666666666666666666666658n,
+};
+const { p: P, n: N, Gx, Gy, a: _a, d: _d } = ed25519_CURVE;
+const h = 8n; // cofactor
+const L = 32; // field / group byte length
+const L2 = 64;
+// Helpers and Precomputes sections are reused between libraries
+// ## Helpers
+// ----------
+// error helper, messes-up stack trace
+const err = (m = '') => {
+    throw new Error(m);
+};
+const isBig = (n) => typeof n === 'bigint'; // is big integer
+const isStr = (s) => typeof s === 'string'; // is string
+const isBytes = (a) => a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
+/** assert is Uint8Array (of specific length) */
+const abytes = (a, l) => !isBytes(a) || (typeof l === 'number' && l > 0 && a.length !== l)
+    ? err('Uint8Array expected')
+    : a;
+/** create Uint8Array */
+const u8n = (len) => new Uint8Array(len);
+const u8fr = (buf) => Uint8Array.from(buf);
+const padh = (n, pad) => n.toString(16).padStart(pad, '0');
+const bytesToHex = (b) => Array.from(abytes(b))
+    .map((e) => padh(e, 2))
+    .join('');
+const C = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 }; // ASCII characters
+const _ch = (ch) => {
+    if (ch >= C._0 && ch <= C._9)
+        return ch - C._0; // '2' => 50-48
+    if (ch >= C.A && ch <= C.F)
+        return ch - (C.A - 10); // 'B' => 66-(65-10)
+    if (ch >= C.a && ch <= C.f)
+        return ch - (C.a - 10); // 'b' => 98-(97-10)
+    return;
+};
+const hexToBytes = (hex) => {
+    const e = 'hex invalid';
+    if (!isStr(hex))
+        return err(e);
+    const hl = hex.length;
+    const al = hl / 2;
+    if (hl % 2)
+        return err(e);
+    const array = u8n(al);
+    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+        // treat each char as ASCII
+        const n1 = _ch(hex.charCodeAt(hi)); // parse first char, multiply it by 16
+        const n2 = _ch(hex.charCodeAt(hi + 1)); // parse second char
+        if (n1 === undefined || n2 === undefined)
+            return err(e);
+        array[ai] = n1 * 16 + n2; // example: 'A9' => 10*16 + 9
+    }
+    return array;
+};
+/** normalize hex or ui8a to ui8a */
+const toU8 = (a, len) => abytes(isStr(a) ? hexToBytes(a) : u8fr(abytes(a)), len);
+const big = BigInt;
+const arange = (n, min, max, msg = 'bad number: out of range') => isBig(n) && min <= n && n < max ? n : err(msg);
+/** modular division */
+const M = (a, b = P) => {
+    const r = a % b;
+    return r >= 0n ? r : b + r;
+};
+/** Modular inversion using eucledian GCD (non-CT). No negative exponent for now. */
+// prettier-ignore
+const invert = (num, md) => {
+    if (num === 0n || md <= 0n)
+        err('no inverse n=' + num + ' mod=' + md);
+    let a = M(num, md), b = md, x = 0n, u = 1n;
+    while (a !== 0n) {
+        const q = b / a, r = b % a;
+        const m = x - u * q;
+        b = a, a = r, x = u, u = m;
+    }
+    return b === 1n ? M(x, md) : err('no inverse'); // b is gcd at this point
+};
+const apoint = (p) => (p instanceof Point ? p : err('Point expected'));
+// ## End of Helpers
+// -----------------
+const B256 = 2n ** 256n;
+/** Point in XYZT extended coordinates. */
+class Point {
+    static BASE;
+    static ZERO;
+    ex;
+    ey;
+    ez;
+    et;
+    constructor(ex, ey, ez, et) {
+        const max = B256;
+        this.ex = arange(ex, 0n, max);
+        this.ey = arange(ey, 0n, max);
+        this.ez = arange(ez, 1n, max);
+        this.et = arange(et, 0n, max);
+        Object.freeze(this);
+    }
+    static fromAffine(p) {
+        return new Point(p.x, p.y, 1n, M(p.x * p.y));
+    }
+    /** RFC8032 5.1.3: Uint8Array to Point. */
+    static fromBytes(hex, zip215 = false) {
+        const d = _d;
+        // Copy array to not mess it up.
+        const normed = u8fr(abytes(hex, L));
+        // adjust first LE byte = last BE byte
+        const lastByte = hex[31];
+        normed[31] = lastByte & ~0x80;
+        const y = bytesToNumLE(normed);
+        // zip215=true:           0 <= y < 2^256
+        // zip215=false, RFC8032: 0 <= y < 2^255-19
+        const max = zip215 ? B256 : P;
+        arange(y, 0n, max);
+        const y2 = M(y * y); // y²
+        const u = M(y2 - 1n); // u=y²-1
+        const v = M(d * y2 + 1n); // v=dy²+1
+        let { isValid, value: x } = uvRatio(u, v); // (uv³)(uv⁷)^(p-5)/8; square root
+        if (!isValid)
+            err('bad point: y not sqrt'); // not square root: bad point
+        const isXOdd = (x & 1n) === 1n; // adjust sign of x coordinate
+        const isLastByteOdd = (lastByte & 0x80) !== 0; // x_0, last bit
+        if (!zip215 && x === 0n && isLastByteOdd)
+            err('bad point: x==0, isLastByteOdd'); // x=0, x_0=1
+        if (isLastByteOdd !== isXOdd)
+            x = M(-x);
+        return new Point(x, y, 1n, M(x * y)); // Z=1, T=xy
+    }
+    /** Checks if the point is valid and on-curve. */
+    assertValidity() {
+        const a = _a;
+        const d = _d;
+        const p = this;
+        if (p.is0())
+            throw new Error('bad point: ZERO'); // TODO: optimize, with vars below?
+        // Equation in affine coordinates: ax² + y² = 1 + dx²y²
+        // Equation in projective coordinates (X/Z, Y/Z, Z):  (aX² + Y²)Z² = Z⁴ + dX²Y²
+        const { ex: X, ey: Y, ez: Z, et: T } = p;
+        const X2 = M(X * X); // X²
+        const Y2 = M(Y * Y); // Y²
+        const Z2 = M(Z * Z); // Z²
+        const Z4 = M(Z2 * Z2); // Z⁴
+        const aX2 = M(X2 * a); // aX²
+        const left = M(Z2 * M(aX2 + Y2)); // (aX² + Y²)Z²
+        const right = M(Z4 + M(d * M(X2 * Y2))); // Z⁴ + dX²Y²
+        if (left !== right)
+            throw new Error('bad point: equation left != right (1)');
+        // In Extended coordinates we also have T, which is x*y=T/Z: check X*Y == Z*T
+        const XY = M(X * Y);
+        const ZT = M(Z * T);
+        if (XY !== ZT)
+            throw new Error('bad point: equation left != right (2)');
+        return this;
+    }
+    /** Equality check: compare points P&Q. */
+    equals(other) {
+        const { ex: X1, ey: Y1, ez: Z1 } = this;
+        const { ex: X2, ey: Y2, ez: Z2 } = apoint(other); // checks class equality
+        const X1Z2 = M(X1 * Z2);
+        const X2Z1 = M(X2 * Z1);
+        const Y1Z2 = M(Y1 * Z2);
+        const Y2Z1 = M(Y2 * Z1);
+        return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;
+    }
+    is0() {
+        return this.equals(I);
+    }
+    /** Flip point over y coordinate. */
+    negate() {
+        return new Point(M(-this.ex), this.ey, this.ez, M(-this.et));
+    }
+    /** Point doubling. Complete formula. Cost: `4M + 4S + 1*a + 6add + 1*2`. */
+    double() {
+        const { ex: X1, ey: Y1, ez: Z1 } = this;
+        const a = _a;
+        // https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html#doubling-dbl-2008-hwcd
+        const A = M(X1 * X1);
+        const B = M(Y1 * Y1);
+        const C = M(2n * M(Z1 * Z1));
+        const D = M(a * A);
+        const x1y1 = X1 + Y1;
+        const E = M(M(x1y1 * x1y1) - A - B);
+        const G = D + B;
+        const F = G - C;
+        const H = D - B;
+        const X3 = M(E * F);
+        const Y3 = M(G * H);
+        const T3 = M(E * H);
+        const Z3 = M(F * G);
+        return new Point(X3, Y3, Z3, T3);
+    }
+    /** Point addition. Complete formula. Cost: `8M + 1*k + 8add + 1*2`. */
+    add(other) {
+        const { ex: X1, ey: Y1, ez: Z1, et: T1 } = this;
+        const { ex: X2, ey: Y2, ez: Z2, et: T2 } = apoint(other); // doesn't check if other on-curve
+        const a = _a;
+        const d = _d;
+        // https://hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html#addition-add-2008-hwcd-3
+        const A = M(X1 * X2);
+        const B = M(Y1 * Y2);
+        const C = M(T1 * d * T2);
+        const D = M(Z1 * Z2);
+        const E = M((X1 + Y1) * (X2 + Y2) - A - B);
+        const F = M(D - C);
+        const G = M(D + C);
+        const H = M(B - a * A);
+        const X3 = M(E * F);
+        const Y3 = M(G * H);
+        const T3 = M(E * H);
+        const Z3 = M(F * G);
+        return new Point(X3, Y3, Z3, T3);
+    }
+    /**
+     * Point-by-scalar multiplication. Scalar must be in range 1 <= n < CURVE.n.
+     * Uses {@link wNAF} for base point.
+     * Uses fake point to mitigate side-channel leakage.
+     * @param n scalar by which point is multiplied
+     * @param safe safe mode guards against timing attacks; unsafe mode is faster
+     */
+    multiply(n, safe = true) {
+        if (!safe && (n === 0n || this.is0()))
+            return I;
+        arange(n, 1n, N);
+        if (n === 1n)
+            return this;
+        if (this.equals(G))
+            return wNAF(n).p;
+        // init result point & fake point
+        let p = I;
+        let f = G;
+        for (let d = this; n > 0n; d = d.double(), n >>= 1n) {
+            // if bit is present, add to point
+            // if not present, add to fake, for timing safety
+            if (n & 1n)
+                p = p.add(d);
+            else if (safe)
+                f = f.add(d);
+        }
+        return p;
+    }
+    /** Convert point to 2d xy affine point. (X, Y, Z) ∋ (x=X/Z, y=Y/Z) */
+    toAffine() {
+        const { ex: x, ey: y, ez: z } = this;
+        // fast-paths for ZERO point OR Z=1
+        if (this.equals(I))
+            return { x: 0n, y: 1n };
+        const iz = invert(z, P);
+        // (Z * Z^-1) must be 1, otherwise bad math
+        if (M(z * iz) !== 1n)
+            err('invalid inverse');
+        // x = X*Z^-1; y = Y*Z^-1
+        return { x: M(x * iz), y: M(y * iz) };
+    }
+    toBytes() {
+        const { x, y } = this.assertValidity().toAffine();
+        const b = numTo32bLE(y);
+        // store sign in first LE byte
+        b[31] |= x & 1n ? 0x80 : 0;
+        return b;
+    }
+    toHex() {
+        return bytesToHex(this.toBytes());
+    } // encode to hex string
+    clearCofactor() {
+        return this.multiply(big(h), false);
+    }
+    isSmallOrder() {
+        return this.clearCofactor().is0();
+    }
+    isTorsionFree() {
+        // multiply by big number CURVE.n
+        let p = this.multiply(N / 2n, false).double(); // ensures the point is not "bad".
+        if (N % 2n)
+            p = p.add(this); // P^(N+1) // P*N == (P*(N/2))*2+P
+        return p.is0();
+    }
+    static fromHex(hex, zip215) {
+        return Point.fromBytes(toU8(hex), zip215);
+    }
+    get x() {
+        return this.toAffine().x;
+    }
+    get y() {
+        return this.toAffine().y;
+    }
+    toRawBytes() {
+        return this.toBytes();
+    }
+}
+/** Generator / base point */
+const G = new Point(Gx, Gy, 1n, M(Gx * Gy));
+/** Identity / zero point */
+const I = new Point(0n, 1n, 1n, 0n);
+// Static aliases
+Point.BASE = G;
+Point.ZERO = I;
+const numTo32bLE = (num) => hexToBytes(padh(arange(num, 0n, B256), L2)).reverse();
+const bytesToNumLE = (b) => big('0x' + bytesToHex(u8fr(abytes(b)).reverse()));
+const pow2 = (x, power) => {
+    // pow2(x, 4) == x^(2^4)
+    let r = x;
+    while (power-- > 0n) {
+        r *= r;
+        r %= P;
+    }
+    return r;
+};
+// prettier-ignore
+const pow_2_252_3 = (x) => {
+    const x2 = (x * x) % P; // x^2,       bits 1
+    const b2 = (x2 * x) % P; // x^3,       bits 11
+    const b4 = (pow2(b2, 2n) * b2) % P; // x^(2^4-1), bits 1111
+    const b5 = (pow2(b4, 1n) * x) % P; // x^(2^5-1), bits 11111
+    const b10 = (pow2(b5, 5n) * b5) % P; // x^(2^10)
+    const b20 = (pow2(b10, 10n) * b10) % P; // x^(2^20)
+    const b40 = (pow2(b20, 20n) * b20) % P; // x^(2^40)
+    const b80 = (pow2(b40, 40n) * b40) % P; // x^(2^80)
+    const b160 = (pow2(b80, 80n) * b80) % P; // x^(2^160)
+    const b240 = (pow2(b160, 80n) * b80) % P; // x^(2^240)
+    const b250 = (pow2(b240, 10n) * b10) % P; // x^(2^250)
+    const pow_p_5_8 = (pow2(b250, 2n) * x) % P; // < To pow to (p+3)/8, multiply it by x.
+    return { pow_p_5_8, b2 };
+};
+const RM1 = 0x2b8324804fc1df0b2b4d00993dfbd7a72f431806ad2fe478c4ee1b274a0ea0b0n; // √-1
+// for sqrt comp
+// prettier-ignore
+const uvRatio = (u, v) => {
+    const v3 = M(v * v * v); // v³
+    const v7 = M(v3 * v3 * v); // v⁷
+    const pow = pow_2_252_3(u * v7).pow_p_5_8; // (uv⁷)^(p-5)/8
+    let x = M(u * v3 * pow); // (uv³)(uv⁷)^(p-5)/8
+    const vx2 = M(v * x * x); // vx²
+    const root1 = x; // First root candidate
+    const root2 = M(x * RM1); // Second root candidate; RM1 is √-1
+    const useRoot1 = vx2 === u; // If vx² = u (mod p), x is a square root
+    const useRoot2 = vx2 === M(-u); // If vx² = -u, set x <-- x * 2^((p-1)/4)
+    const noRoot = vx2 === M(-u * RM1); // There is no valid root, vx² = -u√-1
+    if (useRoot1)
+        x = root1;
+    if (useRoot2 || noRoot)
+        x = root2; // We return root2 anyway, for const-time
+    if ((M(x) & 1n) === 1n)
+        x = M(-x); // edIsNegative
+    return { isValid: useRoot1 || useRoot2, value: x };
+};
+// ## Precomputes
+// --------------
+const W = 8; // W is window size
+const scalarBits = 256;
+const pwindows = Math.ceil(scalarBits / W) + 1; // 33 for W=8
+const pwindowSize = 2 ** (W - 1); // 128 for W=8
+const precompute = () => {
+    const points = [];
+    let p = G;
+    let b = p;
+    for (let w = 0; w < pwindows; w++) {
+        b = p;
+        points.push(b);
+        for (let i = 1; i < pwindowSize; i++) {
+            b = b.add(p);
+            points.push(b);
+        } // i=1, bc we skip 0
+        p = b.double();
+    }
+    return points;
+};
+let Gpows = undefined; // precomputes for base point G
+// const-time negate
+const ctneg = (cnd, p) => {
+    const n = p.negate();
+    return cnd ? n : p;
+};
+/**
+ * Precomputes give 12x faster getPublicKey(), 10x sign(), 2x verify() by
+ * caching multiples of G (base point). Cache is stored in 32MB of RAM.
+ * Any time `G.multiply` is done, precomputes are used.
+ * Not used for getSharedSecret, which instead multiplies random pubkey `P.multiply`.
+ *
+ * w-ary non-adjacent form (wNAF) precomputation method is 10% slower than windowed method,
+ * but takes 2x less RAM. RAM reduction is possible by utilizing `.subtract`.
+ *
+ * !! Precomputes can be disabled by commenting-out call of the wNAF() inside Point#multiply().
+ */
+const wNAF = (n) => {
+    const comp = Gpows || (Gpows = precompute());
+    let p = I;
+    let f = G; // f must be G, or could become I in the end
+    const pow_2_w = 2 ** W; // 256 for W=8
+    const maxNum = pow_2_w; // 256 for W=8
+    const mask = big(pow_2_w - 1); // 255 for W=8 == mask 0b11111111
+    const shiftBy = big(W); // 8 for W=8
+    for (let w = 0; w < pwindows; w++) {
+        let wbits = Number(n & mask); // extract W bits.
+        n >>= shiftBy; // shift number by W bits.
+        if (wbits > pwindowSize) {
+            wbits -= maxNum;
+            n += 1n;
+        } // split if bits > max: +224 => 256-32
+        const off = w * pwindowSize;
+        const offF = off; // offsets, evaluate both
+        const offP = off + Math.abs(wbits) - 1;
+        const isEven = w % 2 !== 0; // conditions, evaluate both
+        const isNeg = wbits < 0;
+        if (wbits === 0) {
+            // off == I: can't add it. Adding random offF instead.
+            f = f.add(ctneg(isEven, comp[offF])); // bits are 0: add garbage to fake point
+        }
+        else {
+            p = p.add(ctneg(isNeg, comp[offP])); // bits are 1: add to result point
+        }
+    }
+    return { p, f }; // return both real and fake points for JIT
+};
+
 const DEFAULT_MAX_ENTRIES_PER_VIEW = 10000;
 const DEFAULT_CONFIG = {
     reconnectIntervals: [1000, 2000, 4000, 8000, 16000],
@@ -6946,6 +7393,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;
@@ -6961,11 +7413,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;
@@ -7057,7 +7509,7 @@ class ConnectionManager {
     }
     createTokenEndpointRequestBody() {
         return {
-            websocket_url: this.websocketUrl,
+            websocket_url: this.websocketUrl ?? '',
         };
     }
     async fetchTokenFromEndpoint(tokenEndpoint) {
@@ -7211,14 +7663,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') {
@@ -7238,6 +7697,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 () => {
@@ -7273,6 +7738,7 @@ class ConnectionManager {
         return issue;
     }
     async connect() {
+        this.requireWebsocketUrl();
         if (this.ws?.readyState === WebSocket.OPEN ||
             this.ws?.readyState === WebSocket.CONNECTING ||
             this.currentState === 'connecting') {
@@ -7417,6 +7883,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)) {
@@ -7520,16 +7987,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)) {
@@ -7540,8 +8011,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;
@@ -7549,6 +8020,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 = [];
@@ -7560,9 +8061,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];
@@ -7571,19 +8073,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) {
@@ -7669,7 +8238,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) {
@@ -7679,17 +8250,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) {
@@ -7702,33 +8275,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':
@@ -7761,7 +8340,7 @@ class FrameProcessor {
     }
 }
 
-let ViewData$1 = class ViewData {
+class ViewData {
     constructor() {
         this.entities = new Map();
         this.accessOrder = [];
@@ -7815,7 +8394,7 @@ let ViewData$1 = class ViewData {
         this.entities.clear();
         this.accessOrder = [];
     }
-};
+}
 class MemoryAdapter {
     constructor(_config = {}) {
         this.views = new Map();
@@ -7863,7 +8442,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);
@@ -7903,7 +8482,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)
@@ -7914,16 +8493,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);
     }
@@ -8050,7 +8638,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;
@@ -8058,8 +8646,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) {
@@ -8081,9 +8669,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) {
@@ -8413,6 +9001,137 @@ 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 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.
  *
@@ -8427,7 +9146,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) {
@@ -8459,7 +9181,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++) {
@@ -8480,25 +9204,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.
@@ -8566,7 +9390,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];
         }
     }
@@ -8586,7 +9410,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];
         }
     }
@@ -8635,6 +9459,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.
@@ -8721,13 +9673,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,
@@ -8737,24 +9708,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,
     };
@@ -8770,7 +9742,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;
     }
@@ -8787,13 +9759,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': {
@@ -8861,6 +9836,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);
     }
@@ -8879,8 +9859,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':
@@ -8921,21 +10001,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}`);
     }
@@ -8962,59 +10081,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.
@@ -9072,103 +10139,369 @@ 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 });
+        },
+    };
+}
+
+const STACK_RUNTIME_EXTENSIONS = '__areteStackRuntimeExtensions';
+const PROGRAM_OPERATION_EXTENSIONS = '__areteProgramOperationExtensions';
+function getProgramRuntimeExtensions(program) {
+    return program[PROGRAM_OPERATION_EXTENSIONS];
+}
+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 nonEmpty(values, label) {
+    if (values.length === 0) {
+        throw new Error(`${label} must contain at least one item`);
+    }
+    return [...values];
+}
+function inferSignerAddress(value) {
+    if (typeof value === 'string' && value.length > 0) {
+        return value;
+    }
+    if (!value || typeof value !== 'object') {
+        return null;
+    }
+    const candidate = value;
+    if (typeof candidate.address === 'string' && candidate.address.length > 0) {
+        return candidate.address;
+    }
+    if (typeof candidate.publicKey === 'string' && candidate.publicKey.length > 0) {
+        return candidate.publicKey;
+    }
+    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);
+    }
+    const wallet = options.wallet ?? host.wallet;
+    for (const address of wallet?.signerAddresses ?? []) {
+        available.add(address);
+    }
+    const walletAddress = wallet?.publicKey ?? host.publicKey;
+    if (walletAddress) {
+        available.add(walletAddress);
+    }
+    for (const address of signerAddresses) {
+        if (address) {
+            available.add(address);
+        }
+    }
+    const missing = transaction.requiredSignerAddresses.filter((address) => !available.has(address));
+    if (missing.length > 0) {
+        throw new Error(`Missing signer(s) for ${transaction.name}: ${missing.join(', ')}`);
+    }
+}
+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;
+    }
+}
+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,
+            });
+        }
+    }
+    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],
     };
 }
 
-class Arete {
-    constructor(url, options) {
+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`);
+        }
+        merged[name] = definition;
+    }
+    return merged;
+}
+function normalizeProgramAccountWireKeys(value) {
+    if (Array.isArray(value)) {
+        return value.map(normalizeProgramAccountWireKeys);
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    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;
+    }
+    const parsed = schema.safeParse(value);
+    if (parsed.success) {
+        return parsed.data;
+    }
+    const normalized = schema.safeParse(normalizeProgramAccountWireKeys(value));
+    if (normalized.success) {
+        return normalized.data;
+    }
+    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: options.validateFrames ? this.stack.schemas : undefined,
+            schemas: this.stack.schemas,
+            patchSchemas: this.stack.patchSchemas,
         });
         this.connection = new ConnectionManager({
             websocketUrl: url,
@@ -9181,26 +10514,178 @@ class Arete {
             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);
-                };
+        this._queries = this.buildQueries();
+        this._chain = createChainClient(this.httpBaseUrl, this.authenticatedFetch.bind(this));
+        this._programs = this.buildPrograms();
+    }
+    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);
+    }
+    buildQueries() {
+        const queries = {};
+        for (const [name, definition] of Object.entries(this.stack.queries ?? {})) {
+            queries[name] = this.createQueryExecutor(definition);
+        }
+        return queries;
+    }
+    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);
             }
+            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 ?? {},
+            };
+        }
+        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 instructions;
+        return programs;
     }
-    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');
+    createTypedInstruction(handler) {
+        return {
+            build: (params, options) => buildInstruction(handler, params, this.withWallet(options)),
+        };
+    }
+    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;
+            },
+        };
+    }
+    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;
+        };
+    }
+    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;
+    }
+    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;
+        }
+        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,
+            stack: effectiveStack,
+            httpUrl,
             storage: options?.storage,
             maxEntriesPerView: options?.maxEntriesPerView,
             flushIntervalMs: options?.flushIntervalMs,
@@ -9209,18 +10694,113 @@ class Arete {
             maxReconnectAttempts: options?.maxReconnectAttempts,
             validateFrames: options?.validateFrames,
             auth: options?.auth,
+            wallet: options?.wallet,
+            fetch: options?.fetch,
+            execution: options?.execution,
         };
-        const client = new Arete(url, internalOptions);
-        if (options?.autoReconnect !== false) {
+        const client = new Arete(url, httpUrl, internalOptions);
+        if (!httpOnly && autoReconnect) {
             await client.connection.connect();
         }
-        return client;
+        return applyConnectedStackExtensions(client, effectiveStack);
     }
     get views() {
         return this._views;
     }
-    get instructions() {
-        return this._instructions;
+    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');
+        }
+        try {
+            const sendOptions = {
+                ...(options?.send ?? {}),
+            };
+            if (options?.signers !== undefined) {
+                sendOptions.signers = options.signers;
+            }
+            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);
+                    }
+                }
+            };
+            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;
     }
     get connectionState() {
         return this.connection.getState();
@@ -9262,8 +10842,180 @@ class Arete {
     getSubscriptionRegistry() {
         return this.subscriptionRegistry;
     }
+};
+
+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');
+            }
+            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;
+}
+
+const Arete = Object.assign(Arete$1, { session: createSession });
+
 const DEFAULT_FLUSH_INTERVAL_MS = 16;
 
 class ZustandAdapter {
@@ -9432,11 +11184,52 @@ class ZustandAdapter {
     }
 }
 
+function syncClientWallets(entries, wallet) {
+    for (const entry of entries) {
+        entry.client.setWallet(wallet);
+    }
+}
+function initializeConnectedClient(client, adapter, wallet) {
+    client.setWallet(wallet);
+    client.onConnectionStateChange((state) => {
+        adapter.setConnectionState(state);
+    });
+    adapter.setConnectionState(client.connectionState);
+}
+
+const objectKeys = new WeakMap();
+let nextObjectKey = 0;
+function getObjectKey(value, prefix) {
+    const existing = objectKeys.get(value);
+    if (existing) {
+        return existing;
+    }
+    const key = `${prefix}-${++nextObjectKey}`;
+    objectKeys.set(value, key);
+    return key;
+}
+function createClientCacheKey(stack, options) {
+    if (!stack) {
+        return null;
+    }
+    return [
+        getObjectKey(stack, 'stack'),
+        options?.transport ?? 'ws',
+        options?.url ?? stack.endpoints.ws,
+        options?.httpUrl ?? stack.endpoints.http ?? '',
+        options?.programs
+            ? getObjectKey(options.programs, 'programs')
+            : 'programs-none',
+    ].join(':');
+}
+
 const AreteContext = React.createContext(null);
 function AreteProvider({ children, fallback = null, ...config }) {
     const clientsRef = React.useRef(new Map());
     const connectingRef = React.useRef(new Map());
     const clientChangeListenersRef = React.useRef(new Set());
+    const latestWalletRef = React.useRef(config.wallet);
+    latestWalletRef.current = config.wallet;
     const notifyClientChange = React.useCallback(() => {
         clientChangeListenersRef.current.forEach(cb => { cb(); });
     }, []);
@@ -9446,8 +11239,11 @@ function AreteProvider({ children, fallback = null, ...config }) {
             clientChangeListenersRef.current.delete(callback);
         };
     }, []);
-    const getOrCreateClient = React.useCallback(async (stack, urlOverride) => {
-        const cacheKey = urlOverride ? `${stack.name}:${urlOverride}` : stack.name;
+    const getOrCreateClient = React.useCallback(async (stack, options) => {
+        const cacheKey = createClientCacheKey(stack, options);
+        if (!cacheKey) {
+            throw new Error('Stack is required to create an Arete client');
+        }
         const existing = clientsRef.current.get(cacheKey);
         if (existing) {
             return existing.client;
@@ -9458,21 +11254,24 @@ function AreteProvider({ children, fallback = null, ...config }) {
         }
         const adapter = new ZustandAdapter();
         const connectionPromise = Arete.connect(stack, {
-            url: urlOverride,
+            url: options?.url,
+            httpUrl: options?.httpUrl,
+            transport: options?.transport,
+            programs: options?.programs,
             storage: adapter,
             autoReconnect: config.autoConnect,
             reconnectIntervals: config.reconnectIntervals,
             maxReconnectAttempts: config.maxReconnectAttempts,
             maxEntriesPerView: config.maxEntriesPerView,
             flushIntervalMs: config.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS,
+            fetch: config.fetch,
+            validateFrames: config.validateFrames,
             auth: config.auth,
+            wallet: latestWalletRef.current,
         }).then((client) => {
-            client.onConnectionStateChange((state, error) => {
-                adapter.setConnectionState(state, error);
-            });
-            adapter.setConnectionState(client.connectionState);
+            initializeConnectedClient(client, adapter, latestWalletRef.current);
             clientsRef.current.set(cacheKey, {
-                client,
+                client: client,
                 disconnect: () => client.disconnect()
             });
             connectingRef.current.delete(cacheKey);
@@ -9481,8 +11280,8 @@ function AreteProvider({ children, fallback = null, ...config }) {
         });
         connectingRef.current.set(cacheKey, connectionPromise);
         return connectionPromise;
-    }, [config.autoConnect, config.reconnectIntervals, config.maxReconnectAttempts, config.maxEntriesPerView, config.flushIntervalMs, config.auth, notifyClientChange]);
-    const getClient = React.useCallback((stack) => {
+    }, [config.autoConnect, config.reconnectIntervals, config.maxReconnectAttempts, config.maxEntriesPerView, config.flushIntervalMs, config.fetch, config.validateFrames, config.auth, notifyClientChange]);
+    const getClient = React.useCallback((stack, options) => {
         if (!stack) {
             if (clientsRef.current.size === 1) {
                 const firstEntry = clientsRef.current.values().next().value;
@@ -9490,9 +11289,17 @@ function AreteProvider({ children, fallback = null, ...config }) {
             }
             return null;
         }
-        const entry = clientsRef.current.get(stack.name);
+        const cacheKey = createClientCacheKey(stack, options);
+        if (!cacheKey) {
+            return null;
+        }
+        const entry = clientsRef.current.get(cacheKey);
         return entry ? entry.client : null;
     }, []);
+    React.useEffect(() => {
+        syncClientWallets(clientsRef.current.values(), config.wallet);
+        notifyClientChange();
+    }, [config.wallet, notifyClientChange]);
     React.useEffect(() => {
         return () => {
             clientsRef.current.forEach((entry) => {
@@ -9517,10 +11324,10 @@ function useAreteContext() {
     }
     return context;
 }
-function useConnectionState(stack) {
+function useConnectionState(stack, options) {
     const { getClient, subscribeToClientChanges } = useAreteContext();
     const [state, setState] = React.useState(() => {
-        const client = getClient(stack);
+        const client = getClient(stack, options);
         return client?.connectionState ?? 'disconnected';
     });
     const unsubscribeRef = React.useRef(undefined);
@@ -9529,7 +11336,7 @@ function useConnectionState(stack) {
         const setupClientSubscription = () => {
             unsubscribeRef.current?.();
             unsubscribeRef.current = undefined;
-            const client = getClient(stack);
+            const client = getClient(stack, options);
             if (client && mounted) {
                 setState(client.connectionState);
                 unsubscribeRef.current = client.onConnectionStateChange((newState) => {
@@ -9548,12 +11355,12 @@ function useConnectionState(stack) {
             unsubscribeFromClientChanges();
             unsubscribeRef.current?.();
         };
-    }, [getClient, subscribeToClientChanges, stack]);
+    }, [getClient, subscribeToClientChanges, stack, options]);
     return state;
 }
-function useView(stack, viewPath) {
+function useView(stack, viewPath, options) {
     const { getClient } = useAreteContext();
-    const client = getClient(stack);
+    const client = getClient(stack, options);
     return React.useSyncExternalStore((callback) => {
         if (!client)
             return () => { };
@@ -9565,9 +11372,9 @@ function useView(stack, viewPath) {
         return data;
     });
 }
-function useEntity(stack, viewPath, key) {
+function useEntity(stack, viewPath, key, options) {
     const { getClient } = useAreteContext();
-    const client = getClient(stack);
+    const client = getClient(stack, options);
     return React.useSyncExternalStore((callback) => {
         if (!client)
             return () => { };
@@ -9580,6 +11387,84 @@ function useEntity(stack, viewPath, key) {
     });
 }
 
+function wrapRawInstruction(instruction, client, createMutationHook) {
+    const execute = async (input, options) => {
+        if (!client) {
+            throw new Error('Arete client is not connected');
+        }
+        return client.transaction([instruction.build(input)], options);
+    };
+    return {
+        execute,
+        build: instruction.build,
+        useMutation: () => createMutationHook(execute),
+    };
+}
+function isConnectedOperation(value) {
+    return Boolean(value && typeof value === 'object' && typeof value.prepare === 'function');
+}
+function wrapOperation(operation, client, createMutationHook) {
+    const execute = async (input, options) => {
+        if (!client) {
+            throw new Error('Arete client is not connected');
+        }
+        const prepared = await operation.prepare(input);
+        return client.execute(prepared, options);
+    };
+    return {
+        prepare: operation.prepare.bind(operation),
+        execute,
+        useMutation: () => createMutationHook(execute),
+    };
+}
+function wrapOperationNamespace(namespace, client, createMutationHook) {
+    const wrapped = {};
+    for (const [name, value] of Object.entries(namespace)) {
+        if (isConnectedOperation(value)) {
+            wrapped[name] = wrapOperation(value, client, createMutationHook);
+            continue;
+        }
+        if (value && typeof value === 'object') {
+            wrapped[name] = wrapOperationNamespace(value, client, createMutationHook);
+        }
+    }
+    return wrapped;
+}
+function wrapMaybeOperationNamespace(namespace, client, createMutationHook) {
+    return namespace
+        ? wrapOperationNamespace(namespace, client, createMutationHook)
+        : {};
+}
+function buildProgramHookInterfaces(programs, client, createMutationHook) {
+    const wrappedPrograms = {};
+    if (!programs) {
+        return wrappedPrograms;
+    }
+    for (const [name, program] of Object.entries(programs)) {
+        const raw = {};
+        for (const [instructionName, instruction] of Object.entries(program.raw)) {
+            raw[instructionName] = wrapRawInstruction(instruction, client, createMutationHook);
+        }
+        wrappedPrograms[name] = {
+            name: program.name,
+            programId: program.programId,
+            schemas: program.schemas,
+            pdas: program.pdas,
+            accounts: program.accounts,
+            queries: program.queries,
+            addresses: program.addresses,
+            constants: program.constants,
+            defaults: program.defaults,
+            math: program.math,
+            raw: raw,
+            instructions: wrapMaybeOperationNamespace(program.instructions, client, createMutationHook),
+            transactions: wrapMaybeOperationNamespace(program.transactions, client, createMutationHook),
+            flows: wrapMaybeOperationNamespace(program.flows, client, createMutationHook),
+        };
+    }
+    return wrappedPrograms;
+}
+
 function shallowArrayEqual(a, b) {
     if (a === b)
         return true;
@@ -9593,6 +11478,34 @@ function shallowArrayEqual(a, b) {
     }
     return true;
 }
+function compareNumericValues(value, condition, op) {
+    if (typeof value === 'bigint' || typeof condition === 'bigint') {
+        const left = typeof value === 'bigint' ? value : BigInt(value);
+        const right = typeof condition === 'bigint' ? condition : BigInt(condition);
+        switch (op) {
+            case 'gte':
+                return left >= right;
+            case 'lte':
+                return left <= right;
+            case 'gt':
+                return left > right;
+            case 'lt':
+                return left < right;
+        }
+    }
+    const left = value;
+    const right = condition;
+    switch (op) {
+        case 'gte':
+            return left >= right;
+        case 'lte':
+            return left <= right;
+        case 'gt':
+            return left > right;
+        case 'lt':
+            return left < right;
+    }
+}
 function useStateView(viewDef, client, key, options) {
     const [isLoading, setIsLoading] = React.useState(!options?.initialData && options?.withSnapshot !== false);
     const [error, setError] = React.useState();
@@ -9677,7 +11590,10 @@ function useStateView(viewDef, client, key, options) {
             ? clientRef.current.store.get(viewDef.view, keyString)
             : clientRef.current.store.getAll(viewDef.view)[0];
         const validated = entity && schema
-            ? (schema.safeParse(entity).success ? entity : undefined)
+            ? (() => {
+                const parsed = schema.safeParse(entity);
+                return parsed.success ? parsed.data : undefined;
+            })()
             : entity;
         if (validated !== cachedSnapshotRef.current) {
             cachedSnapshotRef.current = validated;
@@ -9803,20 +11719,23 @@ function useListView(viewDef, client, params, options) {
                     if (typeof condition === 'object' && condition !== null) {
                         const cond = condition;
                         if ('gte' in cond)
-                            return value >= cond.gte;
+                            return compareNumericValues(value, cond.gte, 'gte');
                         if ('lte' in cond)
-                            return value <= cond.lte;
+                            return compareNumericValues(value, cond.lte, 'lte');
                         if ('gt' in cond)
-                            return value > cond.gt;
+                            return compareNumericValues(value, cond.gt, 'gt');
                         if ('lt' in cond)
-                            return value < cond.lt;
+                            return compareNumericValues(value, cond.lt, 'lt');
                     }
                     return value === condition;
                 });
             });
         }
         if (schema) {
-            items = items.filter((item) => schema.safeParse(item).success);
+            items = items.flatMap((item) => {
+                const parsed = schema.safeParse(item);
+                return parsed.success ? [parsed.data] : [];
+            });
         }
         if (limit) {
             items = items.slice(0, limit);
@@ -9876,30 +11795,42 @@ function createListViewHook(viewDef, client) {
 function useInstructionMutation(execute) {
     const [status, setStatus] = React.useState('idle');
     const [error, setError] = React.useState(null);
+    const [signatures, setSignatures] = React.useState([]);
     const [signature, setSignature] = React.useState(null);
     const submit = React.useCallback(async (args, options) => {
         setStatus('pending');
         setError(null);
+        setSignatures([]);
         setSignature(null);
+        const { onSuccess, onError, ...executionOptions } = options ?? {};
         try {
-            const result = await execute(args, options);
+            const result = await execute(args, executionOptions);
+            const resultSignatures = typeof result === 'object' && result !== null && 'signatures' in result
+                && Array.isArray(result.signatures)
+                ? result.signatures.map(String)
+                : typeof result === 'object' && result !== null && 'signature' in result
+                    ? [String(result.signature)]
+                    : [];
             setStatus('success');
-            setSignature(result.signature);
-            if (options?.onSuccess) {
-                options.onSuccess(result);
+            setSignatures(resultSignatures);
+            setSignature(resultSignatures.length === 1 ? resultSignatures[0] : null);
+            if (onSuccess) {
+                onSuccess(result);
             }
             return result;
         }
         catch (err) {
-            const errorMessage = err instanceof Error ? err.message : String(err);
-            const programError = parseInstructionError(err, []);
-            const displayError = programError
-                ? `${programError.name}: ${programError.message}`
-                : errorMessage;
+            // The core executor already parses program errors against the handler's
+            // IDL error definitions and throws an InstructionError.
+            const displayError = err instanceof InstructionError && err.programError
+                ? `${err.programError.name}: ${err.programError.message}`
+                : err instanceof Error
+                    ? err.message
+                    : String(err);
             setStatus('error');
             setError(displayError);
-            if (options?.onError && err instanceof Error) {
-                options.onError(err);
+            if (onError && err instanceof Error) {
+                onError(err);
             }
             throw err;
         }
@@ -9907,12 +11838,14 @@ function useInstructionMutation(execute) {
     const reset = React.useCallback(() => {
         setStatus('idle');
         setError(null);
+        setSignatures([]);
         setSignature(null);
     }, []);
     return {
         submit,
         status,
         error,
+        signatures,
         signature,
         isLoading: status === 'pending',
         reset,
@@ -9921,21 +11854,25 @@ function useInstructionMutation(execute) {
 
 function useArete(stack, options) {
     const { getOrCreateClient, getClient } = useAreteContext();
-    const urlOverride = options?.url;
-    const [client, setClient] = React.useState(getClient(stack));
+    const url = options?.url;
+    const httpUrl = options?.httpUrl;
+    const transport = options?.transport;
+    const attachedPrograms = options?.programs;
+    const lookupOptions = React.useMemo(() => ({ url, httpUrl, transport, programs: attachedPrograms }), [url, httpUrl, transport, attachedPrograms]);
+    const [client, setClient] = React.useState(getClient(stack, lookupOptions));
     const [isLoading, setIsLoading] = React.useState(!client);
     const [error, setError] = React.useState(null);
     const [connectionState, setConnectionState] = React.useState(() => client?.connectionState ?? 'disconnected');
     React.useEffect(() => {
-        const existingClient = getClient(stack);
-        if (existingClient && !urlOverride) {
+        const existingClient = getClient(stack, lookupOptions);
+        if (existingClient) {
             setClient(existingClient);
             setIsLoading(false);
             return;
         }
         setIsLoading(true);
         setError(null);
-        getOrCreateClient(stack, urlOverride)
+        getOrCreateClient(stack, lookupOptions)
             .then((newClient) => {
             setClient(newClient);
             setIsLoading(false);
@@ -9944,7 +11881,7 @@ function useArete(stack, options) {
             setError(err instanceof Error ? err : new Error(String(err)));
             setIsLoading(false);
         });
-    }, [stack, getOrCreateClient, getClient, urlOverride]);
+    }, [stack, getOrCreateClient, getClient, lookupOptions]);
     React.useEffect(() => {
         if (!client) {
             setConnectionState('disconnected');
@@ -9975,21 +11912,14 @@ function useArete(stack, options) {
         }
         return result;
     }, [stack, client]);
-    const instructions = React.useMemo(() => {
-        const result = {};
-        if (client?.instructions) {
-            for (const [instructionName, executeFn] of Object.entries(client.instructions)) {
-                result[instructionName] = {
-                    execute: executeFn,
-                    useMutation: () => useInstructionMutation(executeFn)
-                };
-            }
-        }
-        return result;
+    const programs = React.useMemo(() => {
+        return buildProgramHookInterfaces(client?.programs, client, useInstructionMutation);
     }, [client]);
     return {
         views: views,
-        instructions: instructions,
+        queries: (client?.queries ?? {}),
+        programs: programs,
+        chain: client?.chain,
         zustandStore: client?.store?.store,
         client: client,
         connectionState,
@@ -10006,10 +11936,14 @@ exports.ConnectionManager = ConnectionManager;
 exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
 exports.DEFAULT_MAX_ENTRIES_PER_VIEW = DEFAULT_MAX_ENTRIES_PER_VIEW;
 exports.FrameProcessor = FrameProcessor;
+exports.InstructionError = InstructionError;
 exports.MemoryAdapter = MemoryAdapter;
+exports.ReadRequestError = ReadRequestError;
 exports.SubscriptionRegistry = SubscriptionRegistry;
 exports.ZustandAdapter = ZustandAdapter;
+exports.buildInstruction = buildInstruction;
 exports.createInstructionExecutor = createInstructionExecutor;
+exports.createInstructionHandler = createInstructionHandler;
 exports.createPublicKeySeed = createPublicKeySeed;
 exports.createSeed = createSeed;
 exports.derivePda = findProgramAddress;
@@ -10029,5 +11963,5 @@ exports.useEntity = useEntity;
 exports.useInstructionMutation = useInstructionMutation;
 exports.useView = useView;
 exports.validateAccountResolution = validateAccountResolution;
-exports.waitForConfirmation = waitForConfirmation;
+exports.withPrograms = withPrograms;
 //# sourceMappingURL=index.js.map