@capxul/mcp 4.20.0-beta.4 → 4.20.0-beta.40

package/dist/permission-approvals-BNP5hA8b.mjs

@@ -0,0 +1,137 @@
+import { B as abandonPrepared, Kt as CAPXUL_OPERATIONS, Ln as absurd, W as asCapxulError, a as prepareConfiguration, bt as noSessionError, d as verifiedPreparation, f as buildCommand, i as authorInvitation, l as preparePermission, o as verifiedConfiguration, or as CapxulError, p as validateReplacementInput, u as preparedIdentity } from "./organizations-BXC-6y-P.mjs";
+//#region ../../packages/sdk/src/accounts/permission-approvals.ts
+/** Prepare a Permission write or an invitation's configuration for `signerAddress`, checked. */
+function prepareVerifiedPermissionChange(deps, input, signerAddress, signal) {
+	return "permission" in input ? prepareVerifiedPermissionWrite(deps, input, signerAddress, signal) : prepareVerifiedInvitation(deps, input, signerAddress, signal);
+}
+/**
+* Hand the verified identity to the caller before the approval opens. A
+* caller that refuses it has not authorized the command: close the prepared
+* command, so its nonce lane is free again.
+*/
+async function delivered(deps, executionId, deliver) {
+	let refused;
+	try {
+		const result = await deliver();
+		if (result !== void 0 && !result.ok) refused = result;
+	} catch (cause) {
+		refused = {
+			ok: false,
+			error: asCapxulError(cause)
+		};
+	}
+	return refused === void 0 ? {
+		ok: true,
+		value: { executionId }
+	} : abandonPrepared(deps, executionId, "prepared_mismatch", refused);
+}
+/** The command a write sends, decoded exactly as its `org(id).permissions` method decodes it. */
+function command(write) {
+	try {
+		switch (write.operation) {
+			case "create": return {
+				ok: true,
+				value: buildCommand.create(write)
+			};
+			case "change": return {
+				ok: true,
+				value: buildCommand.change(write)
+			};
+			case "assign": return {
+				ok: true,
+				value: buildCommand.assign(write)
+			};
+			case "revoke": return {
+				ok: true,
+				value: buildCommand.revoke(write)
+			};
+			case "replace": return {
+				ok: true,
+				value: {
+					operation: "replace",
+					requestKey: write.requestKey
+				}
+			};
+			default: return absurd(write);
+		}
+	} catch (cause) {
+		return {
+			ok: false,
+			error: asCapxulError(cause)
+		};
+	}
+}
+async function prepareVerifiedPermissionWrite(deps, input, signerAddress, signal) {
+	const session = deps.actor?.authSession() ?? null;
+	if (session === null || deps.chainId === void 0) return {
+		ok: false,
+		error: noSessionError(deps.actor)
+	};
+	const built = command(input.permission);
+	if (!built.ok) return built;
+	const orgId = input.organizationId;
+	const expectedSnapshotHash = input.permission.operation === "replace" ? input.permission.expectedSnapshotHash : void 0;
+	const admitted = validateReplacementInput(orgId, built.value, expectedSnapshotHash);
+	if (!admitted.ok) return admitted;
+	const preparation = {
+		orgId,
+		command: built.value,
+		signerAddress,
+		email: session.email,
+		chainId: deps.chainId,
+		expectedSnapshotHash
+	};
+	const prepared = await preparePermission(deps, preparation, signal, void 0);
+	if (!prepared.ok) return prepared;
+	const executionId = prepared.value.executionId;
+	const verified = verifiedPreparation(prepared.value, preparation);
+	if (!verified.ok) return abandonPrepared(deps, executionId, "prepared_mismatch", verified);
+	const { onPrepared } = input;
+	return onPrepared === void 0 ? {
+		ok: true,
+		value: { executionId }
+	} : delivered(deps, executionId, () => onPrepared(preparedIdentity(verified.value)));
+}
+async function prepareVerifiedInvitation(deps, input, signerAddress, signal) {
+	const session = deps.actor?.authSession() ?? null;
+	if (session === null || deps.chainId === void 0) return {
+		ok: false,
+		error: noSessionError(deps.actor)
+	};
+	const orgId = input.organizationId;
+	const authored = await authorInvitation(deps, orgId, input.invite, signal, void 0);
+	if (!authored.ok) return authored;
+	const view = authored.value;
+	if (view.phase !== "authorizing" || view.commandId === null) return {
+		ok: false,
+		error: new CapxulError("WRONG_STATE", "The invitation's rights are already set up, or it ended: nothing is left to sign.", { details: {
+			method: CAPXUL_OPERATIONS.approvals.prepare,
+			currentState: view.phase,
+			validStates: ["authorizing"],
+			invitationId: view.id
+		} })
+	};
+	const preparation = {
+		orgId,
+		view,
+		commandId: view.commandId,
+		signerAddress,
+		email: session.email,
+		chainId: deps.chainId
+	};
+	const built = await prepareConfiguration(deps, preparation, signal, void 0);
+	if (!built.ok) return built;
+	const { executionId, invitationId, commandId } = built.value;
+	const verified = verifiedConfiguration(built.value, preparation);
+	if (!verified.ok) return abandonPrepared(deps, executionId, "prepared_mismatch", verified);
+	const { onPrepared } = input;
+	return onPrepared === void 0 ? {
+		ok: true,
+		value: { executionId }
+	} : delivered(deps, executionId, () => onPrepared({
+		invitationId,
+		commandId
+	}));
+}
+//#endregion
+export { prepareVerifiedPermissionChange };

package/dist/secp256k1-CLeVBma1.mjs

@@ -0,0 +1,2 @@
+import { t as secp256k1 } from "./secp256k1-vkvPWdOZ.mjs";
+export { secp256k1 };

package/dist/{secp256k1-oe2FO-K6.mjs → secp256k1-vkvPWdOZ.mjs}

@@ -1,424 +1,4 @@
-import * as nc from "node:crypto";
-//#region ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/cryptoNode.js
-/**
-* Internal webcrypto alias.
-* We prefer WebCrypto aka globalThis.crypto, which exists in node.js 16+.
-* Falls back to Node.js built-in crypto for Node.js <=v14.
-* See utils.ts for details.
-* @module
-*/
-const crypto = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : nc && typeof nc === "object" && "randomBytes" in nc ? nc : void 0;
-//#endregion
-//#region ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/utils.js
-/**
-* Utilities for hex, bytes, CSPRNG.
-* @module
-*/
-/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
-function isBytes$1(a) {
-	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
-}
-/** Asserts something is positive integer. */
-function anumber(n) {
-	if (!Number.isSafeInteger(n) || n < 0) throw new Error("positive integer expected, got " + n);
-}
-/** Asserts something is Uint8Array. */
-function abytes$1(b, ...lengths) {
-	if (!isBytes$1(b)) throw new Error("Uint8Array expected");
-	if (lengths.length > 0 && !lengths.includes(b.length)) throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
-}
-/** Asserts something is hash */
-function ahash(h) {
-	if (typeof h !== "function" || typeof h.create !== "function") throw new Error("Hash should be wrapped by utils.createHasher");
-	anumber(h.outputLen);
-	anumber(h.blockLen);
-}
-/** Asserts a hash instance has not been destroyed / finished */
-function aexists(instance, checkFinished = true) {
-	if (instance.destroyed) throw new Error("Hash instance has been destroyed");
-	if (checkFinished && instance.finished) throw new Error("Hash#digest() has already been called");
-}
-/** Asserts output is properly-sized byte array */
-function aoutput(out, instance) {
-	abytes$1(out);
-	const min = instance.outputLen;
-	if (out.length < min) throw new Error("digestInto() expects output buffer of length at least " + min);
-}
-/** Cast u8 / u16 / u32 to u32. */
-function u32(arr) {
-	return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
-}
-/** Zeroize a byte array. Warning: JS provides no guarantees. */
-function clean(...arrays) {
-	for (let i = 0; i < arrays.length; i++) arrays[i].fill(0);
-}
-/** Create DataView of an array for easy byte-level manipulation. */
-function createView(arr) {
-	return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-}
-/** The rotate right (circular right shift) operation for uint32 */
-function rotr(word, shift) {
-	return word << 32 - shift | word >>> shift;
-}
-/** Is current platform little-endian? Most are. Big-Endian platform: IBM */
-const isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
-/** The byte swap operation for uint32 */
-function byteSwap(word) {
-	return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
-}
-/** In place byte swap for Uint32Array */
-function byteSwap32(arr) {
-	for (let i = 0; i < arr.length; i++) arr[i] = byteSwap(arr[i]);
-	return arr;
-}
-const swap32IfBE = isLE ? (u) => u : byteSwap32;
-/**
-* Converts string to bytes using UTF8 encoding.
-* @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
-*/
-function utf8ToBytes(str) {
-	if (typeof str !== "string") throw new Error("string expected");
-	return new Uint8Array(new TextEncoder().encode(str));
-}
-/**
-* Normalizes (non-hex) string or Uint8Array to Uint8Array.
-* Warning: when Uint8Array is passed, it would NOT get copied.
-* Keep in mind for future mutable operations.
-*/
-function toBytes(data) {
-	if (typeof data === "string") data = utf8ToBytes(data);
-	abytes$1(data);
-	return data;
-}
-/** Copies several Uint8Arrays into one. */
-function concatBytes$1(...arrays) {
-	let sum = 0;
-	for (let i = 0; i < arrays.length; i++) {
-		const a = arrays[i];
-		abytes$1(a);
-		sum += a.length;
-	}
-	const res = new Uint8Array(sum);
-	for (let i = 0, pad = 0; i < arrays.length; i++) {
-		const a = arrays[i];
-		res.set(a, pad);
-		pad += a.length;
-	}
-	return res;
-}
-/** For runtime check if class implements interface */
-var Hash = class {};
-/** Wraps hash function, creating an interface on top of it */
-function createHasher(hashCons) {
-	const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
-	const tmp = hashCons();
-	hashC.outputLen = tmp.outputLen;
-	hashC.blockLen = tmp.blockLen;
-	hashC.create = () => hashCons();
-	return hashC;
-}
-/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */
-function randomBytes(bytesLength = 32) {
-	if (crypto && typeof crypto.getRandomValues === "function") return crypto.getRandomValues(new Uint8Array(bytesLength));
-	if (crypto && typeof crypto.randomBytes === "function") return Uint8Array.from(crypto.randomBytes(bytesLength));
-	throw new Error("crypto.getRandomValues must be defined");
-}
-//#endregion
-//#region ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/_md.js
-/**
-* Internal Merkle-Damgard hash utils.
-* @module
-*/
-/** Polyfill for Safari 14. https://caniuse.com/mdn-javascript_builtins_dataview_setbiguint64 */
-function setBigUint64(view, byteOffset, value, isLE) {
-	if (typeof view.setBigUint64 === "function") return view.setBigUint64(byteOffset, value, isLE);
-	const _32n = BigInt(32);
-	const _u32_max = BigInt(4294967295);
-	const wh = Number(value >> _32n & _u32_max);
-	const wl = Number(value & _u32_max);
-	const h = isLE ? 4 : 0;
-	const l = isLE ? 0 : 4;
-	view.setUint32(byteOffset + h, wh, isLE);
-	view.setUint32(byteOffset + l, wl, isLE);
-}
-/** Choice: a ? b : c */
-function Chi(a, b, c) {
-	return a & b ^ ~a & c;
-}
-/** Majority function, true if any two inputs is true. */
-function Maj(a, b, c) {
-	return a & b ^ a & c ^ b & c;
-}
-/**
-* Merkle-Damgard hash construction base class.
-* Could be used to create MD5, RIPEMD, SHA1, SHA2.
-*/
-var HashMD = class extends Hash {
-	constructor(blockLen, outputLen, padOffset, isLE) {
-		super();
-		this.finished = false;
-		this.length = 0;
-		this.pos = 0;
-		this.destroyed = false;
-		this.blockLen = blockLen;
-		this.outputLen = outputLen;
-		this.padOffset = padOffset;
-		this.isLE = isLE;
-		this.buffer = new Uint8Array(blockLen);
-		this.view = createView(this.buffer);
-	}
-	update(data) {
-		aexists(this);
-		data = toBytes(data);
-		abytes$1(data);
-		const { view, buffer, blockLen } = this;
-		const len = data.length;
-		for (let pos = 0; pos < len;) {
-			const take = Math.min(blockLen - this.pos, len - pos);
-			if (take === blockLen) {
-				const dataView = createView(data);
-				for (; blockLen <= len - pos; pos += blockLen) this.process(dataView, pos);
-				continue;
-			}
-			buffer.set(data.subarray(pos, pos + take), this.pos);
-			this.pos += take;
-			pos += take;
-			if (this.pos === blockLen) {
-				this.process(view, 0);
-				this.pos = 0;
-			}
-		}
-		this.length += data.length;
-		this.roundClean();
-		return this;
-	}
-	digestInto(out) {
-		aexists(this);
-		aoutput(out, this);
-		this.finished = true;
-		const { buffer, view, blockLen, isLE } = this;
-		let { pos } = this;
-		buffer[pos++] = 128;
-		clean(this.buffer.subarray(pos));
-		if (this.padOffset > blockLen - pos) {
-			this.process(view, 0);
-			pos = 0;
-		}
-		for (let i = pos; i < blockLen; i++) buffer[i] = 0;
-		setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
-		this.process(view, 0);
-		const oview = createView(out);
-		const len = this.outputLen;
-		if (len % 4) throw new Error("_sha2: outputLen should be aligned to 32bit");
-		const outLen = len / 4;
-		const state = this.get();
-		if (outLen > state.length) throw new Error("_sha2: outputLen bigger than state");
-		for (let i = 0; i < outLen; i++) oview.setUint32(4 * i, state[i], isLE);
-	}
-	digest() {
-		const { buffer, outputLen } = this;
-		this.digestInto(buffer);
-		const res = buffer.slice(0, outputLen);
-		this.destroy();
-		return res;
-	}
-	_cloneInto(to) {
-		to || (to = new this.constructor());
-		to.set(...this.get());
-		const { blockLen, buffer, length, finished, destroyed, pos } = this;
-		to.destroyed = destroyed;
-		to.finished = finished;
-		to.length = length;
-		to.pos = pos;
-		if (length % blockLen) to.buffer.set(buffer);
-		return to;
-	}
-	clone() {
-		return this._cloneInto();
-	}
-};
-/**
-* Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.
-* Check out `test/misc/sha2-gen-iv.js` for recomputation guide.
-*/
-/** Initial SHA256 state. Bits 0..32 of frac part of sqrt of primes 2..19 */
-const SHA256_IV = /* @__PURE__ */ Uint32Array.from([
-	1779033703,
-	3144134277,
-	1013904242,
-	2773480762,
-	1359893119,
-	2600822924,
-	528734635,
-	1541459225
-]);
-//#endregion
-//#region ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/sha2.js
-/**
-* SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.
-* SHA256 is the fastest hash implementable in JS, even faster than Blake3.
-* Check out [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and
-* [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
-* @module
-*/
-/**
-* Round constants:
-* First 32 bits of fractional parts of the cube roots of the first 64 primes 2..311)
-*/
-const SHA256_K = /* @__PURE__ */ Uint32Array.from([
-	1116352408,
-	1899447441,
-	3049323471,
-	3921009573,
-	961987163,
-	1508970993,
-	2453635748,
-	2870763221,
-	3624381080,
-	310598401,
-	607225278,
-	1426881987,
-	1925078388,
-	2162078206,
-	2614888103,
-	3248222580,
-	3835390401,
-	4022224774,
-	264347078,
-	604807628,
-	770255983,
-	1249150122,
-	1555081692,
-	1996064986,
-	2554220882,
-	2821834349,
-	2952996808,
-	3210313671,
-	3336571891,
-	3584528711,
-	113926993,
-	338241895,
-	666307205,
-	773529912,
-	1294757372,
-	1396182291,
-	1695183700,
-	1986661051,
-	2177026350,
-	2456956037,
-	2730485921,
-	2820302411,
-	3259730800,
-	3345764771,
-	3516065817,
-	3600352804,
-	4094571909,
-	275423344,
-	430227734,
-	506948616,
-	659060556,
-	883997877,
-	958139571,
-	1322822218,
-	1537002063,
-	1747873779,
-	1955562222,
-	2024104815,
-	2227730452,
-	2361852424,
-	2428436474,
-	2756734187,
-	3204031479,
-	3329325298
-]);
-/** Reusable temporary buffer. "W" comes straight from spec. */
-const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
-var SHA256 = class extends HashMD {
-	constructor(outputLen = 32) {
-		super(64, outputLen, 8, false);
-		this.A = SHA256_IV[0] | 0;
-		this.B = SHA256_IV[1] | 0;
-		this.C = SHA256_IV[2] | 0;
-		this.D = SHA256_IV[3] | 0;
-		this.E = SHA256_IV[4] | 0;
-		this.F = SHA256_IV[5] | 0;
-		this.G = SHA256_IV[6] | 0;
-		this.H = SHA256_IV[7] | 0;
-	}
-	get() {
-		const { A, B, C, D, E, F, G, H } = this;
-		return [
-			A,
-			B,
-			C,
-			D,
-			E,
-			F,
-			G,
-			H
-		];
-	}
-	set(A, B, C, D, E, F, G, H) {
-		this.A = A | 0;
-		this.B = B | 0;
-		this.C = C | 0;
-		this.D = D | 0;
-		this.E = E | 0;
-		this.F = F | 0;
-		this.G = G | 0;
-		this.H = H | 0;
-	}
-	process(view, offset) {
-		for (let i = 0; i < 16; i++, offset += 4) SHA256_W[i] = view.getUint32(offset, false);
-		for (let i = 16; i < 64; i++) {
-			const W15 = SHA256_W[i - 15];
-			const W2 = SHA256_W[i - 2];
-			const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
-			const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
-			SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
-		}
-		let { A, B, C, D, E, F, G, H } = this;
-		for (let i = 0; i < 64; i++) {
-			const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
-			const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
-			const T2 = (rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22)) + Maj(A, B, C) | 0;
-			H = G;
-			G = F;
-			F = E;
-			E = D + T1 | 0;
-			D = C;
-			C = B;
-			B = A;
-			A = T1 + T2 | 0;
-		}
-		A = A + this.A | 0;
-		B = B + this.B | 0;
-		C = C + this.C | 0;
-		D = D + this.D | 0;
-		E = E + this.E | 0;
-		F = F + this.F | 0;
-		G = G + this.G | 0;
-		H = H + this.H | 0;
-		this.set(A, B, C, D, E, F, G, H);
-	}
-	roundClean() {
-		clean(SHA256_W);
-	}
-	destroy() {
-		this.set(0, 0, 0, 0, 0, 0, 0, 0);
-		clean(this.buffer);
-	}
-};
-/**
-* SHA2-256 hash function from RFC 4634.
-*
-* It is the fastest JS hash, even faster than Blake3.
-* To break sha256 using birthday attack, attackers need to try 2^128 hashes.
-* BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
-*/
-const sha256 = /* @__PURE__ */ createHasher(() => new SHA256());
-//#endregion
+import { a as ahash, c as clean, d as randomBytes, i as aexists, l as concatBytes$1, n as Hash, o as anumber, p as toBytes, r as abytes$1, t as sha256 } from "./sha2-D5rBHwg7.mjs";
 //#region ../../node_modules/.pnpm/@noble+curves@1.9.1/node_modules/@noble/curves/esm/abstract/utils.js
 /**
 * Hex, bytes and number utilities.
@@ -563,8 +143,8 @@ function aInRange(title, n, min, max) {
 * TODO: merge with nLength in modular
 */
 function bitLen(n) {
-	let len;
-	for (len = 0; n > _0n$4; n >>= _1n$4, len += 1);
+	let len = 0;
+	for (; n > _0n$4; n >>= _1n$4, len += 1);
 	return len;
 }
 /**
@@ -2340,4 +1920,4 @@ const secp256k1 = createCurve({
 	}
 }, sha256);
 //#endregion
-export { aexists as a, clean as c, toBytes as d, u32 as f, abytes$1 as i, createHasher as l, sha256 as n, anumber as o, Hash as r, aoutput as s, secp256k1 as t, swap32IfBE as u };
+export { secp256k1 as t };

package/dist/{esm-DUNJOL6b.mjs → sentryClient-CN-gBjYx.mjs}

@@ -2620,6 +2620,13 @@ function setupIntegration(client, integration, integrationIndex) {
 	}
 	DEBUG_BUILD$1 && debug.log(`Integration installed: ${integration.name}`);
 }
+/**
+* Define an integration function that can be used to create an integration instance.
+* Note that this by design hides the implementation details of the integration, as they are considered internal.
+*/
+function defineIntegration(fn) {
+	return fn;
+}
 //#endregion
 //#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/clientreport.js
 /**
@@ -3619,6 +3626,61 @@ function applySdkMetadata(options, name, names = [name], source = "npm") {
 	options._metadata = metadata;
 }
 //#endregion
+//#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/aggregate-errors.js
+/**
+* Creates exceptions inside `event.exception.values` for errors that are nested on properties based on the `key` parameter.
+*/
+function applyAggregateErrorsToEvent(exceptionFromErrorImplementation, parser, key, limit, event, hint) {
+	if (!event.exception?.values || !hint || !isInstanceOf(hint.originalException, Error)) return;
+	const originalException = event.exception.values.length > 0 ? event.exception.values[event.exception.values.length - 1] : void 0;
+	if (originalException) event.exception.values = aggregateExceptionsFromError(exceptionFromErrorImplementation, parser, limit, hint.originalException, key, event.exception.values, originalException, 0);
+}
+function aggregateExceptionsFromError(exceptionFromErrorImplementation, parser, limit, error, key, prevExceptions, exception, exceptionId) {
+	if (prevExceptions.length >= limit + 1) return prevExceptions;
+	let newExceptions = [...prevExceptions];
+	if (isInstanceOf(error[key], Error)) {
+		applyExceptionGroupFieldsForParentException(exception, exceptionId);
+		const newException = exceptionFromErrorImplementation(parser, error[key]);
+		const newExceptionId = newExceptions.length;
+		applyExceptionGroupFieldsForChildException(newException, key, newExceptionId, exceptionId);
+		newExceptions = aggregateExceptionsFromError(exceptionFromErrorImplementation, parser, limit, error[key], key, [newException, ...newExceptions], newException, newExceptionId);
+	}
+	if (Array.isArray(error.errors)) error.errors.forEach((childError, i) => {
+		if (isInstanceOf(childError, Error)) {
+			applyExceptionGroupFieldsForParentException(exception, exceptionId);
+			const newException = exceptionFromErrorImplementation(parser, childError);
+			const newExceptionId = newExceptions.length;
+			applyExceptionGroupFieldsForChildException(newException, `errors[${i}]`, newExceptionId, exceptionId);
+			newExceptions = aggregateExceptionsFromError(exceptionFromErrorImplementation, parser, limit, childError, key, [newException, ...newExceptions], newException, newExceptionId);
+		}
+	});
+	return newExceptions;
+}
+function applyExceptionGroupFieldsForParentException(exception, exceptionId) {
+	exception.mechanism = exception.mechanism || {
+		type: "generic",
+		handled: true
+	};
+	exception.mechanism = {
+		...exception.mechanism,
+		...exception.type === "AggregateError" && { is_exception_group: true },
+		exception_id: exceptionId
+	};
+}
+function applyExceptionGroupFieldsForChildException(exception, source, exceptionId, parentId) {
+	exception.mechanism = exception.mechanism || {
+		type: "generic",
+		handled: true
+	};
+	exception.mechanism = {
+		...exception.mechanism,
+		type: "chained",
+		source,
+		exception_id: exceptionId,
+		parent_id: parentId
+	};
+}
+//#endregion
 //#region ../../node_modules/.pnpm/@sentry+core@9.47.1/node_modules/@sentry/core/build/esm/utils/supports.js
 /**
 * isNative checks if the given function is a native implementation
@@ -4087,4 +4149,39 @@ const extractSafariExtensionDetails = (func, filename) => {
 	return isSafariExtension || isSafariWebExtension ? [func.indexOf("@") !== -1 ? func.split("@")[0] : "?", isSafariExtension ? `safari-extension:${filename}` : `safari-web-extension:${filename}`] : [func, filename];
 };
 //#endregion
-export { BrowserClient, defaultStackParser, makeFetchTransport };
+//#region ../../node_modules/.pnpm/@sentry+browser@9.47.1/node_modules/@sentry/browser/build/npm/esm/integrations/linkederrors.js
+const DEFAULT_KEY = "cause";
+const DEFAULT_LIMIT = 5;
+const INTEGRATION_NAME = "LinkedErrors";
+const _linkedErrorsIntegration = ((options = {}) => {
+	const limit = options.limit || DEFAULT_LIMIT;
+	const key = options.key || DEFAULT_KEY;
+	return {
+		name: INTEGRATION_NAME,
+		preprocessEvent(event, hint, client) {
+			applyAggregateErrorsToEvent(exceptionFromError, client.getOptions().stackParser, key, limit, event, hint);
+		}
+	};
+});
+/**
+* Aggregrate linked errors in an event.
+*/
+const linkedErrorsIntegration = defineIntegration(_linkedErrorsIntegration);
+//#endregion
+//#region ../../node_modules/.pnpm/@openfort+openfort-js@2.6.1_@typescript+typescript6@6.0.2/node_modules/@openfort/openfort-js/dist/sdk/src/core/errors/sentryClient.js
+/**
+* The only pieces of `@sentry/browser` the SDK uses, imported by name so
+* bundlers drop the rest (Replay, Feedback, …). Loaded lazily by
+* `InternalSentry.init` — never import this module statically.
+*/
+function createSentryClient(options) {
+	return new BrowserClient({
+		...options,
+		integrations: [linkedErrorsIntegration()],
+		stackParser: defaultStackParser,
+		transport: makeFetchTransport,
+		sendDefaultPii: false
+	});
+}
+//#endregion
+export { createSentryClient };