@capxul/sdk 0.0.0-rc-2cdddbb91

package/dist/testing/index.mjs

@@ -0,0 +1,1159 @@
+import { D as convexCallErrorFromCapxul, Di as InMemoryAuthCacheAdapter, Et as deriveCapxulSafeAddress, Fi as toEmail, Fr as toChainId, Ft as CONFIGURED_MONEY_ASSETS, Ii as toJwtToken, Ir as toWeiAmount, Li as toSessionToken, Lr as absurd, Mi as toEpochMs, Ni as toEpochSeconds, Pi as toAuthUserId, Pr as toAddress, Qn as toOrgId, Ri as Errors, Si as authClientPortFromPromiseAdapter, X as assetAmountFromRaw, _ as accountFromAccountPositions, bi as toAppId, ci as readClockNow, f as smartAccountErrorFromCapxul, fn as toCountryCode, fr as toAccountId, gn as toHandle, j as wireChainId, ji as toDurationMs, oi as ClockError, pn as toKycTier, si as ClockPortTag, tt as toRaw, vn as validateHandle, w as accountReadErrorFromCapxul, xi as toPublishableKey, yi as toAllowedOrigin, yn as redactTelemetryEvent, zi as CapxulError } from "../access-CNha7G9T.mjs";
+import { a as cloneTelemetryEvent, c as identityErrorFromCapxul, l as bootstrapErrorFromCapxul, n as createCapxulClientWithSignerControls, o as cloneTelemetryProps, r as assembleCapxulClient, s as IdentityPortTag } from "../production-Bcjowmxk.mjs";
+import { Effect, Layer, Result, Semaphore } from "effect";
+import { getFunctionName } from "convex/server";
+//#region src/testing/production-client.ts
+/** Create the one production client with per-client controls at its signing boundaries. */
+function createCapxulProductionTestClient(input, controls) {
+	return createCapxulClientWithSignerControls(input, controls);
+}
+//#endregion
+//#region src/testing/signer-faults.ts
+const FAULT_CODES = {
+	"missing-signer": "MISSING_SIGNER",
+	"user-rejected": 4001,
+	unexpected: void 0
+};
+/** The value a controlled fault throws. Named so a test can assert its origin. */
+var ControlledSignerFault = class extends Error {
+	kind;
+	/** Provider code the SDK classifiers read; absent for `unexpected`. */
+	code;
+	constructor(kind) {
+		super(`controlled signer fault (${kind})`);
+		this.name = "ControlledSignerFault";
+		this.kind = kind;
+		this.code = FAULT_CODES[kind];
+	}
+};
+/** Build one fault value without the harness, for a caller that writes its own control. */
+function signerFaultCause(kind) {
+	return new ControlledSignerFault(kind);
+}
+/**
+* Arm one-shot faults on the production embedded signer.
+*
+* ```ts
+* const seam = armSignerFaults({ signOnce: "user-rejected" });
+* const client = await createCapxulProductionTestClient(input, seam.controls);
+* const result = await client.org(orgId).permissions.create(command);
+* // result.error.code === "SIGNER_REJECTED"; nothing was submitted.
+* // seam.records() names the boundary that refused.
+* ```
+*
+* An empty plan installs no controls, which composes the ordinary client.
+*/
+function armSignerFaults(plan = {}) {
+	const records = [];
+	let pendingFault = plan.signOnce;
+	let pendingReset = plan.resetSessionBeforeNextSign === true;
+	let resetCalls = 0;
+	let embeddedCalls = 0;
+	function record(entry) {
+		records.push({
+			...entry,
+			atMs: Date.now()
+		});
+	}
+	const resetThenSign = async (hash, signer) => {
+		if (pendingReset) {
+			pendingReset = false;
+			resetCalls += 1;
+			if (signer.resetSession === void 0) throw new Error("armSignerFaults: resetSessionBeforeNextSign needs the embedded browser signer; this client composed a signer with no session");
+			signer.resetSession();
+			record({
+				boundary: "reset-session",
+				attempt: resetCalls,
+				hash
+			});
+		}
+		return signer.signUserOpHash(hash);
+	};
+	const faultThenDelegate = async (hash, delegate) => {
+		embeddedCalls += 1;
+		const fault = pendingFault;
+		if (fault === void 0) {
+			record({
+				boundary: "embedded-sign",
+				attempt: embeddedCalls,
+				hash
+			});
+			return delegate(hash);
+		}
+		pendingFault = void 0;
+		record({
+			boundary: "embedded-sign",
+			attempt: embeddedCalls,
+			hash,
+			fault
+		});
+		throw signerFaultCause(fault);
+	};
+	return {
+		controls: {
+			...plan.resetSessionBeforeNextSign === true ? { signUserOpHash: resetThenSign } : {},
+			...plan.signOnce === void 0 ? {} : { signEmbeddedUserOpHash: faultThenDelegate }
+		},
+		records: () => records.slice(),
+		spent: () => pendingFault === void 0 && !pendingReset
+	};
+}
+//#endregion
+//#region src/testing/organization-setup.ts
+/** Exact backend setup shape for SDK tests. */
+function organizationSetupFixture(orgId, status = "ready", overrides = {}) {
+	return {
+		orgId: toOrgId(orgId),
+		status,
+		completedAt: status === "ready" || status === "rechecking" ? 100 : null,
+		lastCheckedAt: null,
+		nextCheckAt: null,
+		issue: null,
+		lastSendIssue: null,
+		recovery: status === "awaitingAuthorization" ? "authorize" : "none",
+		...overrides
+	};
+}
+/** In-memory setup transport for packed consumer tests. */
+function createTestOrganizationSetup() {
+	const rows = /* @__PURE__ */ new Map();
+	const handles = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Map();
+	const set = (setup) => {
+		rows.set(String(setup.orgId), setup);
+		for (const listener of listeners.get(String(setup.orgId)) ?? []) listener({
+			status: "value",
+			value: setup
+		});
+	};
+	const get = async (orgId) => {
+		const value = rows.get(String(orgId));
+		return value === void 0 ? {
+			ok: false,
+			error: Errors.invalidInput("orgId", "Organization setup was not found")
+		} : {
+			ok: true,
+			value
+		};
+	};
+	return {
+		set,
+		ops: {
+			listMine: async (input = {}) => {
+				const all = [...rows.values()].filter((row) => row.completedAt === null);
+				const offset = input.cursor === void 0 ? 0 : Number(input.cursor);
+				const limit = input.limit ?? 50;
+				if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(limit) || limit < 1 || limit > 50) return {
+					ok: false,
+					error: Errors.invalidInput("organizationSetupPage", "Invalid cursor or limit")
+				};
+				const page = all.slice(offset, offset + limit);
+				const next = offset + page.length;
+				return {
+					ok: true,
+					value: {
+						items: page,
+						nextCursor: next < all.length ? String(next) : null
+					}
+				};
+			},
+			begin: async (draft) => {
+				const orgId = handles.get(draft.handle) ?? toOrgId(`org_test_${draft.handle}`);
+				handles.set(draft.handle, orgId);
+				const setup = rows.get(String(orgId)) ?? organizationSetupFixture(orgId, "awaitingAuthorization");
+				set(setup);
+				return {
+					ok: true,
+					value: {
+						orgId,
+						setup
+					}
+				};
+			},
+			get,
+			resume: get,
+			authorize: async (orgId) => {
+				const current = await get(orgId);
+				if (!current.ok || current.value.status !== "awaitingAuthorization") return current;
+				const setup = organizationSetupFixture(orgId, "processing", { nextCheckAt: 1 });
+				set(setup);
+				return {
+					ok: true,
+					value: setup
+				};
+			},
+			subscribe: async (orgId, listener) => {
+				const key = String(orgId);
+				const group = listeners.get(key) ?? /* @__PURE__ */ new Set();
+				listeners.set(key, group);
+				group.add(listener);
+				listener({ status: "loading" });
+				const current = rows.get(key);
+				if (current !== void 0) listener({
+					status: "value",
+					value: current
+				});
+				let active = true;
+				return {
+					ok: true,
+					value: () => {
+						if (!active) return;
+						active = false;
+						group.delete(listener);
+					}
+				};
+			},
+			invalidateSubscriptions: () => {
+				for (const group of listeners.values()) group.clear();
+			}
+		}
+	};
+}
+//#endregion
+//#region src/testing/account/InMemoryAccountReadAdapter.ts
+function fixtureAsset(symbol) {
+	const asset = CONFIGURED_MONEY_ASSETS.find((row) => row.symbol === symbol);
+	if (asset === void 0) throw new Error(`no configured settlement asset ${symbol}`);
+	return asset;
+}
+var InMemoryAccountReadAdapter = class {
+	#deps;
+	#rawBalance;
+	constructor(deps = {}) {
+		this.#deps = deps;
+		this.#rawBalance = deps.rawBalance ?? "0";
+	}
+	#asset() {
+		return fixtureAsset(this.#deps.assetSymbol ?? "USDC");
+	}
+	readBalance(_input) {
+		const scriptedFailure = this.#deps.failures?.readBalance;
+		if (scriptedFailure !== void 0) return Effect.fail(accountReadErrorFromCapxul("readBalance", scriptedFailure));
+		if (this.#deps.account !== void 0) return Effect.succeed(cloneAccount(this.#deps.account));
+		const asset = this.#asset();
+		const balance = assetAmountFromRaw(toWeiAmount(this.#rawBalance), asset).value;
+		return Effect.succeed(accountFromAccountPositions(toAccountId(this.#deps.accountId ?? "account_01TEST000000000000000000"), [{
+			asset: asset.assetId,
+			symbol: asset.symbol,
+			decimals: asset.decimals,
+			balance,
+			available: balance
+		}]));
+	}
+	fundFromFaucet(input) {
+		const scriptedFailure = this.#deps.failures?.fundFromFaucet;
+		if (scriptedFailure !== void 0) return Effect.fail(accountReadErrorFromCapxul("fundFromFaucet", scriptedFailure));
+		const asset = this.#asset();
+		if (input.amount.asset !== asset.assetId) return Effect.fail(accountReadErrorFromCapxul("fundFromFaucet", Errors.invalidInput("amount.asset", "must match adapter config")));
+		const minted = toRaw(input.amount, asset);
+		this.#rawBalance = (BigInt(this.#rawBalance) + minted).toString();
+		return Effect.succeed({ txHash: "0x" + "f".repeat(64) });
+	}
+};
+function cloneAccount(account) {
+	return {
+		id: account.id,
+		balances: account.balances.map((position) => ({ ...position })),
+		balance: account.balance === null ? null : { ...account.balance },
+		available: account.available === null ? null : { ...account.available }
+	};
+}
+//#endregion
+//#region src/testing/clock/sleep-queue.ts
+var SleepQueueClock = class {
+	currentTime = 0;
+	pending = [];
+	seqCounter = 0;
+	now = Effect.sync(() => toEpochMs(this.currentTime));
+	sleep(duration) {
+		return Effect.promise(() => new Promise((resolve) => {
+			this.enqueue({
+				deadline: this.currentTime + duration,
+				resolve,
+				seq: this.seqCounter++
+			});
+		}));
+	}
+	/** Move time forward by `ms`, releasing every sleep that falls due. */
+	advance(ms) {
+		return Effect.runPromise(this.advanceEffect(toDurationMs(ms)));
+	}
+	/** This clock as the cross-adapter conformance harness drives it. */
+	underTest() {
+		return {
+			clock: this,
+			advance: (ms) => this.advance(ms)
+		};
+	}
+	enqueue(entry) {
+		this.pending.push(entry);
+	}
+};
+/** The clock in context when it is a `kind`; otherwise a ClockError naming the layer `helper` needs. */
+function requireClock(kind, helper, layer) {
+	return Effect.gen(function* () {
+		const clock = yield* ClockPortTag;
+		if (clock instanceof kind) return clock;
+		return yield* new ClockError({
+			operation: "sleep",
+			cause: /* @__PURE__ */ new Error(`${helper} requires ${layer}`)
+		});
+	});
+}
+//#endregion
+//#region src/testing/clock/ManualClockAdapter.ts
+/**
+* Event-discipline test clock. Time moves only when a release primitive is
+* invoked. `tickOne()` releases EXACTLY ONE pending sleep (the earliest
+* deadline, FIFO at ties) and snaps `now()` to that deadline. `advance(ms)`
+* composes repeated `tickOne()` calls over the resulting window — used to
+* keep the cross-adapter conformance harness uniform with the distance model
+* of `VirtualClockAdapter`. See `packages/sdk/docs/architecture.md` and the
+* slice spec `docs/slices/clock-adapters.md`.
+*/
+var ManualClockAdapter = class ManualClockAdapter extends SleepQueueClock {
+	constructor(deps) {
+		super();
+	}
+	/**
+	* Release exactly one pending sleep — the earliest deadline, FIFO at ties.
+	* Snaps `now()` forward to that sleep's deadline. No-op if the queue is
+	* empty (preserves the empty-tick safety property).
+	*/
+	tickOne() {
+		return Effect.runPromise(this.tickOneEffect());
+	}
+	tickOneEffect() {
+		return Effect.gen({ self: this }, function* () {
+			if (this.pending.length === 0) return;
+			const next = this.pending.splice(this.findEarliestIndex(), 1)[0];
+			if (next.deadline > this.currentTime) this.currentTime = next.deadline;
+			next.resolve();
+			yield* Effect.yieldNow;
+		});
+	}
+	/**
+	* Releases every sleep whose deadline falls inside
+	* `[currentTime, currentTime + ms]` via repeated `tickOne()`, then snaps
+	* `now()` to `currentTime + ms`. The composition is the seam that lets the
+	* harness drive Manual and Virtual identically.
+	*/
+	advanceEffect(duration) {
+		return Effect.gen({ self: this }, function* () {
+			yield* Effect.yieldNow;
+			const target = this.currentTime + duration;
+			while (this.pending.length > 0 && this.earliestDeadline() <= target) yield* this.tickOneEffect();
+			this.currentTime = target;
+		});
+	}
+	findEarliestIndex() {
+		let bestIndex = 0;
+		let best = this.pending[0];
+		for (let i = 1; i < this.pending.length; i++) {
+			const candidate = this.pending[i];
+			if (candidate.deadline < best.deadline || candidate.deadline === best.deadline && candidate.seq < best.seq) {
+				best = candidate;
+				bestIndex = i;
+			}
+		}
+		return bestIndex;
+	}
+	earliestDeadline() {
+		return this.pending[this.findEarliestIndex()].deadline;
+	}
+	static forConformance() {
+		return new ManualClockAdapter({}).underTest();
+	}
+};
+Layer.sync(ClockPortTag, () => new ManualClockAdapter({}));
+requireClock(ManualClockAdapter, "tickManualClockOnce", "ManualClockLayer").pipe(Effect.flatMap((clock) => clock.tickOneEffect()));
+//#endregion
+//#region src/testing/auth-client/InMemoryAuthClientAdapter.ts
+const DEFAULT_OTP_TTL_MS = toDurationMs(3e5);
+const DEFAULT_SESSION_TTL_MS = toDurationMs(864e5);
+const DEFAULT_JWT_TTL_MS = toDurationMs(9e5);
+/**
+* Hermetic OTP + session state machine implementing `AuthClientPort`. Wires
+* through `AuthCachePort` for persistence (clause A11) and `ClockPort`
+* for TTL + expiry math. OTPs are deterministic per-email counters (`"000000"`,
+* `"000001"`, …) so test assertions remain stable. Session tokens are
+* deterministic per-adapter counters (`"tok_0"`, `"tok_1"`, …). Returning users
+* (same email post-signOut) get the same `AuthUserId`.
+*
+* Never throws — every failure path returns `{ ok: false, error: CapxulError }`.
+* Honors `options.signal` via a pre-check (clause A10): an aborted controller
+* before method entry yields `{ ok: false, error: Errors.cancelled({ operation }) }`
+* without any state change.
+*/
+var InMemoryAuthClientAdapter = class {
+	#pendingOtps = /* @__PURE__ */ new Map();
+	#otpCountersByEmail = /* @__PURE__ */ new Map();
+	#authUserIdByEmail = /* @__PURE__ */ new Map();
+	#allocatedAuthUserIds = /* @__PURE__ */ new Set();
+	#authCache;
+	#clock;
+	#otpTtlMs;
+	#failures;
+	#authUserIdCounter = 0;
+	#tokenCounter = 0;
+	#jwtCounter = 0;
+	constructor(deps) {
+		this.#authCache = deps.authCache;
+		this.#clock = deps.clock;
+		this.#otpTtlMs = deps.otpTtlMs ?? DEFAULT_OTP_TTL_MS;
+		this.#failures = deps.failures ?? {};
+	}
+	/** Test affordance: peek the OTP for an email, simulating "user reads email." */
+	peekOtpForTesting(email) {
+		return this.#pendingOtps.get(email)?.otp;
+	}
+	/** Test affordance: make a seeded identity own the session minted for its email. */
+	bindAuthUserIdForTesting(email, authUserId) {
+		this.#authUserIdByEmail.set(email, authUserId);
+		this.#allocatedAuthUserIds.add(authUserId);
+	}
+	async canSendOtp(input, options) {
+		if (options?.signal?.aborted) return {
+			ok: false,
+			error: Errors.cancelled({ operation: "canSendOtp" })
+		};
+		if (this.#failures.canSendOtp !== void 0) return {
+			ok: false,
+			error: this.#failures.canSendOtp
+		};
+		const pending = this.#pendingOtps.get(input.email);
+		if (pending === void 0) return {
+			ok: true,
+			value: {
+				allowed: true,
+				cooldownMs: toDurationMs(0)
+			}
+		};
+		const nowResult = await readClockNow(this.#clock);
+		if (!nowResult.ok) return nowResult;
+		const elapsedMs = nowResult.value - pending.issuedAt;
+		const cooldownMs = Math.max(0, this.#otpTtlMs - elapsedMs);
+		if (cooldownMs === 0) {
+			this.#pendingOtps.delete(input.email);
+			return {
+				ok: true,
+				value: {
+					allowed: true,
+					cooldownMs: toDurationMs(0)
+				}
+			};
+		}
+		return {
+			ok: true,
+			value: {
+				allowed: false,
+				cooldownMs: toDurationMs(cooldownMs)
+			}
+		};
+	}
+	async sendOtp(input, options) {
+		if (options?.signal?.aborted) return {
+			ok: false,
+			error: Errors.cancelled({ operation: "sendOtp" })
+		};
+		if (this.#failures.sendOtp !== void 0) return {
+			ok: false,
+			error: this.#failures.sendOtp
+		};
+		const issuedAt = await readClockNow(this.#clock);
+		if (!issuedAt.ok) return issuedAt;
+		const counter = this.#otpCountersByEmail.get(input.email) ?? 0;
+		this.#otpCountersByEmail.set(input.email, counter + 1);
+		const otp = counter.toString().padStart(6, "0");
+		this.#pendingOtps.set(input.email, {
+			otp,
+			issuedAt: issuedAt.value
+		});
+		return {
+			ok: true,
+			value: void 0
+		};
+	}
+	async verifyOtp(input, options) {
+		if (options?.signal?.aborted) return {
+			ok: false,
+			error: Errors.cancelled({ operation: "verifyOtp" })
+		};
+		if (this.#failures.verifyOtp !== void 0) return {
+			ok: false,
+			error: this.#failures.verifyOtp
+		};
+		const pending = this.#pendingOtps.get(input.email);
+		if (pending === void 0) return {
+			ok: false,
+			error: Errors.invalidInput("email", "no OTP issued for this email")
+		};
+		const nowResult = await readClockNow(this.#clock);
+		if (!nowResult.ok) return nowResult;
+		const now = nowResult.value;
+		if (now - pending.issuedAt > this.#otpTtlMs) {
+			this.#pendingOtps.delete(input.email);
+			return {
+				ok: false,
+				error: Errors.otpExpired()
+			};
+		}
+		if (input.otp !== pending.otp) return {
+			ok: false,
+			error: Errors.invalidInput("otp", "incorrect OTP")
+		};
+		const authUserId = this.#getOrIssueAuthUserId(input.email);
+		const token = toSessionToken(`tok_${this.#tokenCounter++}`);
+		const expiresAt = toEpochMs(now + DEFAULT_SESSION_TTL_MS);
+		const session = {
+			authUserId,
+			email: input.email,
+			token,
+			expiresAt
+		};
+		const cacheWrite = await runAuthCacheEffect(this.#authCache.setSession(session), "setSession");
+		if (!cacheWrite.ok) return cacheWrite;
+		this.#pendingOtps.delete(input.email);
+		return {
+			ok: true,
+			value: session
+		};
+	}
+	async getSession(options) {
+		if (options?.signal?.aborted) return {
+			ok: false,
+			error: Errors.cancelled({ operation: "getSession" })
+		};
+		if (this.#failures.getSession !== void 0) return {
+			ok: false,
+			error: this.#failures.getSession
+		};
+		const cacheRead = await runAuthCacheEffect(this.#authCache.getSession, "getSession");
+		if (!cacheRead.ok) return cacheRead;
+		const persisted = cacheRead.value;
+		if (persisted === null) return {
+			ok: true,
+			value: null
+		};
+		const nowResult = await readClockNow(this.#clock);
+		if (!nowResult.ok) return nowResult;
+		const now = nowResult.value;
+		if (persisted.expiresAt <= now) {
+			const cacheClear = await runAuthCacheEffect(this.#authCache.clearSession, "clearSession");
+			if (!cacheClear.ok) return cacheClear;
+			return {
+				ok: true,
+				value: null
+			};
+		}
+		return {
+			ok: true,
+			value: persisted
+		};
+	}
+	async signOut(options) {
+		if (options?.signal?.aborted) return {
+			ok: false,
+			error: Errors.cancelled({ operation: "signOut" })
+		};
+		if (this.#failures.signOut !== void 0) return {
+			ok: false,
+			error: this.#failures.signOut
+		};
+		return runAuthCacheEffect(this.#authCache.clearSession, "clearSession");
+	}
+	async getConvexJwt(options) {
+		if (options?.signal?.aborted) return {
+			ok: false,
+			error: Errors.cancelled({ operation: "getConvexJwt" })
+		};
+		if (this.#failures.getConvexJwt !== void 0) return {
+			ok: false,
+			error: this.#failures.getConvexJwt
+		};
+		if (options?.forceRefresh !== true) {
+			const cacheRead = await runAuthCacheEffect(this.#authCache.getJwt, "getJwt");
+			if (!cacheRead.ok) return cacheRead;
+			if (cacheRead.value !== null) return {
+				ok: true,
+				value: cacheRead.value
+			};
+		}
+		const now = await readClockNow(this.#clock);
+		if (!now.ok) return now;
+		const jwt = {
+			token: toJwtToken(`in-memory-jwt-${this.#jwtCounter++}`),
+			expEpochSeconds: toEpochSeconds(Math.floor(now.value / 1e3 + DEFAULT_JWT_TTL_MS / 1e3))
+		};
+		const cacheWrite = await runAuthCacheEffect(this.#authCache.setJwt(jwt), "setJwt");
+		if (!cacheWrite.ok) return cacheWrite;
+		return {
+			ok: true,
+			value: jwt
+		};
+	}
+	#getOrIssueAuthUserId(email) {
+		const existing = this.#authUserIdByEmail.get(email);
+		if (existing !== void 0) return existing;
+		let fresh;
+		do
+			fresh = toAuthUserId(`user_${this.#authUserIdCounter++}`);
+		while (this.#allocatedAuthUserIds.has(fresh));
+		this.#authUserIdByEmail.set(email, fresh);
+		this.#allocatedAuthUserIds.add(fresh);
+		return fresh;
+	}
+};
+async function runAuthCacheEffect(effect, operation) {
+	const result = await Effect.runPromise(Effect.result(effect));
+	if (Result.isFailure(result)) return {
+		ok: false,
+		error: Errors.providerError("auth-cache", operation, result.failure)
+	};
+	return {
+		ok: true,
+		value: result.success
+	};
+}
+//#endregion
+//#region src/testing/bootstrap/BootstrapStubAdapter.ts
+var BootstrapStubAdapter = class {
+	#script;
+	constructor(deps) {
+		this.#script = deps.script;
+	}
+	resolve(input) {
+		const key = bootstrapStubScriptKey(input);
+		const failure = this.#script.failures?.get(key);
+		if (failure !== void 0) return fail$2(kindFromCapxulError(failure), failure);
+		const resolution = this.#script.resolutions?.get(key);
+		if (resolution !== void 0) return Effect.succeed(resolution);
+		const defaultFailure = this.#script.defaultFailure ?? Errors.notAuthenticated();
+		return fail$2(kindFromCapxulError(defaultFailure), defaultFailure);
+	}
+};
+function bootstrapStubScriptKey(input) {
+	return `${String(input.publishableKey)}::${input.origin ?? ""}`;
+}
+function kindFromCapxulError(error) {
+	if (error.code === "NOT_AUTHENTICATED") return "notAuthenticated";
+	if (error.code === "NETWORK_ERROR") return "network";
+	if (error.code === "RATE_LIMITED") return "rateLimited";
+	if (error.code === "INVALID_INPUT") return "invalidInput";
+	return "provider";
+}
+function fail$2(kind, error) {
+	return Effect.fail(bootstrapErrorFromCapxul(kind, error));
+}
+//#endregion
+//#region src/testing/convex-call/subscribers.ts
+/**
+* Register `subscriber` under `path` and return its unsubscribe, which removes
+* it once (a second call does nothing) and drops a path left with no one.
+*/
+function subscribeAt(subscribers, path, subscriber) {
+	let subs = subscribers.get(path);
+	if (subs === void 0) {
+		subs = /* @__PURE__ */ new Set();
+		subscribers.set(path, subs);
+	}
+	subs.add(subscriber);
+	let active = true;
+	return () => {
+		if (!active) return;
+		active = false;
+		const live = subscribers.get(path);
+		if (live === void 0) return;
+		live.delete(subscriber);
+		if (live.size === 0) subscribers.delete(path);
+	};
+}
+//#endregion
+//#region src/testing/convex-call/wire-reply.ts
+/**
+* The Convex wire, as the in-memory test doubles stand in for it. A scripted or
+* registered value crosses where a real reply would, and the caller's function
+* reference names its type, exactly as `ConvexClient` types a reply it cannot
+* check. These are the only places the doubles make that claim.
+*/
+function wireReply(_fn, value) {
+	return value;
+}
+/** A scripted snapshot for a subscription on `fn`: only an `ok` value carries the reply type. */
+function wireSnapshot(fn, snapshot) {
+	return snapshot.status === "ok" ? {
+		status: "ok",
+		value: wireReply(fn, snapshot.value)
+	} : snapshot;
+}
+//#endregion
+//#region src/testing/convex-call/ConvexCallStubAdapter.ts
+var ConvexCallStubAdapter = class {
+	#script;
+	#subscribers = /* @__PURE__ */ new Map();
+	constructor(deps) {
+		this.#script = deps.script;
+	}
+	query(fn, _args) {
+		return this.#resolve(fn);
+	}
+	mutation(fn, _args) {
+		return this.#resolve(fn);
+	}
+	action(fn, _args) {
+		return this.#resolve(fn);
+	}
+	subscribe(fn, _args, callback) {
+		return Effect.sync(() => {
+			const path = getFunctionName(fn);
+			const cb = (snapshot) => callback(wireSnapshot(fn, snapshot));
+			cb({ status: "loading" });
+			const sequence = this.#script.subscriptions?.get(path);
+			const subscriber = {
+				callback: cb,
+				cursor: 0
+			};
+			const unsubscribe = subscribeAt(this.#subscribers, path, subscriber);
+			if (sequence !== void 0 && sequence.length > 0) {
+				cb(sequence[0]);
+				subscriber.cursor = 1;
+			}
+			return unsubscribe;
+		});
+	}
+	advanceSubscription(path) {
+		const sequence = this.#script.subscriptions?.get(path);
+		if (sequence === void 0) return;
+		const subs = this.#subscribers.get(path);
+		if (subs === void 0) return;
+		for (const sub of subs) {
+			if (sub.cursor >= sequence.length) continue;
+			const next = sequence[sub.cursor];
+			sub.cursor += 1;
+			sub.callback(next);
+		}
+	}
+	#resolve(fn) {
+		const path = getFunctionName(fn);
+		const failure = this.#script.failures?.get(path);
+		if (failure !== void 0) return Effect.fail(mapFailure(path, failure));
+		if (this.#script.responses?.has(path)) return Effect.succeed(wireReply(fn, this.#script.responses.get(path)));
+		return Effect.fail(convexCallErrorFromCapxul(path, Errors.providerError("convex", path, "unknown function")));
+	}
+};
+function mapFailure(operation, failure) {
+	if (failure instanceof CapxulError) return convexCallErrorFromCapxul(operation, failure);
+	if (failure instanceof Error) return convexCallErrorFromCapxul(operation, Errors.providerError("convex", operation, failure));
+	return convexCallErrorFromCapxul(operation, Errors.providerError("convex", operation, new Error(String(failure))));
+}
+//#endregion
+//#region src/testing/identity/InMemoryIdentityAdapter.ts
+var InMemoryIdentityAdapter = class {
+	#identities = /* @__PURE__ */ new Map();
+	#clock;
+	constructor(deps) {
+		this.#clock = deps.clock;
+		for (const [authUserId, profile] of deps.profiles ?? []) this.#identities.set(authUserId, cloneProfile(profile));
+	}
+	loadByAuthUserId(authUserId) {
+		return Effect.sync(() => cloneProfileOrNull(this.#identities.get(authUserId) ?? null));
+	}
+	create(input) {
+		return Effect.gen({ self: this }, function* () {
+			if (this.#identities.has(input.authUserId)) return yield* fail$1("create", Errors.invalidInput("authUserId", "already exists"));
+			const now = yield* this.#now("create.clock");
+			const profile = {
+				authUserId: input.authUserId,
+				email: input.email,
+				displayName: input.displayName ?? null,
+				country: input.country ?? null,
+				onboarded: false,
+				withdrawalAddress: null,
+				handle: null,
+				imageUrl: null,
+				kycTier: toKycTier(0),
+				createdAt: now,
+				updatedAt: now
+			};
+			this.#identities.set(input.authUserId, cloneProfile(profile));
+			return cloneProfile(profile);
+		});
+	}
+	update(input) {
+		return Effect.gen({ self: this }, function* () {
+			const existing = this.#identities.get(input.authUserId);
+			if (existing === void 0) return yield* fail$1("update", Errors.profileNotFound(input.authUserId));
+			const now = yield* this.#now("update.clock");
+			const updated = {
+				authUserId: existing.authUserId,
+				email: existing.email,
+				kycTier: existing.kycTier,
+				createdAt: existing.createdAt,
+				displayName: input.displayName !== void 0 ? input.displayName : existing.displayName,
+				country: input.country !== void 0 ? input.country : existing.country,
+				onboarded: existing.onboarded,
+				withdrawalAddress: existing.withdrawalAddress,
+				handle: existing.handle,
+				imageUrl: existing.imageUrl,
+				updatedAt: now
+			};
+			this.#identities.set(input.authUserId, cloneProfile(updated));
+			return cloneProfile(updated);
+		});
+	}
+	completeOnboarding(input) {
+		return Effect.gen({ self: this }, function* () {
+			const now = yield* this.#now("completeOnboarding.clock");
+			const existing = this.#identities.get(input.authUserId);
+			const profile = {
+				authUserId: input.authUserId,
+				email: existing?.email ?? input.email,
+				displayName: input.displayName,
+				country: input.country,
+				onboarded: true,
+				withdrawalAddress: input.withdrawalAddress ?? existing?.withdrawalAddress ?? null,
+				handle: toHandle(validateHandle(input.handle)),
+				imageUrl: existing?.imageUrl ?? null,
+				kycTier: existing?.kycTier ?? toKycTier(0),
+				createdAt: existing?.createdAt ?? now,
+				updatedAt: now
+			};
+			this.#identities.set(input.authUserId, cloneProfile(profile));
+			return cloneProfile(profile);
+		});
+	}
+	#now(operation) {
+		if (this.#clock === void 0) return Effect.succeed(toEpochMs(0));
+		return this.#clock.now.pipe(Effect.mapError((cause) => identityErrorFromCapxul(operation, Errors.providerError("clock", "now", cause), cause)));
+	}
+};
+Layer.effect(IdentityPortTag, Effect.map(ClockPortTag, (clock) => new InMemoryIdentityAdapter({ clock })));
+function fail$1(operation, error) {
+	return Effect.fail(identityErrorFromCapxul(operation, error));
+}
+function cloneProfile(profile) {
+	return {
+		authUserId: profile.authUserId,
+		email: profile.email,
+		displayName: profile.displayName,
+		country: profile.country,
+		onboarded: profile.onboarded,
+		withdrawalAddress: profile.withdrawalAddress,
+		handle: profile.handle,
+		imageUrl: profile.imageUrl,
+		kycTier: profile.kycTier,
+		createdAt: profile.createdAt,
+		updatedAt: profile.updatedAt
+	};
+}
+function cloneProfileOrNull(profile) {
+	return profile === null ? null : cloneProfile(profile);
+}
+//#endregion
+//#region src/testing/smart-account/smart-account-derivation.ts
+const SUPPORTED_CHAIN_IDS = /* @__PURE__ */ new Set([84532, 8453]);
+function isSupportedSmartAccountChain(chainId) {
+	return SUPPORTED_CHAIN_IDS.has(wireChainId(chainId));
+}
+//#endregion
+//#region src/testing/smart-account/InMemorySmartAccountAdapter.ts
+/**
+* Hermetic backend stand-in (PRD #462 / derivation v2): `provision` derives
+* the Safe from the authenticated email via the REAL canonical derivation
+* (`deriveCapxulSafeAddress({ email })` — owner is the pinned bootstrap
+* constant). No signer exists at provision; `claim` installs the signer and
+* marks the row deployed, mirroring the backend's one-userOp claim lane.
+*/
+var InMemorySmartAccountAdapter = class {
+	#accounts = /* @__PURE__ */ new Map();
+	#clock;
+	#failures;
+	#provisionMutex = Semaphore.makeUnsafe(1);
+	constructor(deps) {
+		this.#clock = deps.clock;
+		this.#failures = deps.failures;
+		for (const [authUserId, account] of deps.accounts ?? []) this.#accounts.set(authUserId, cloneSmartAccount(account));
+	}
+	loadByAuthUserId(authUserId) {
+		const scriptedFailure = this.#failures?.loadByAuthUserId;
+		if (scriptedFailure !== void 0) return fail("loadByAuthUserId", scriptedFailure);
+		return Effect.sync(() => cloneSmartAccountOrNull(this.#accounts.get(authUserId) ?? null));
+	}
+	loadBySmartAccountAddress(address) {
+		const scriptedFailure = this.#failures?.loadBySmartAccountAddress;
+		if (scriptedFailure !== void 0) return fail("loadBySmartAccountAddress", scriptedFailure);
+		return Effect.sync(() => {
+			const needle = toAddress(address);
+			for (const account of this.#accounts.values()) if (account.smartAccountAddress === needle) return cloneSmartAccount(account);
+			return null;
+		});
+	}
+	provision(input) {
+		const scriptedFailure = this.#failures?.provision;
+		if (scriptedFailure !== void 0) return fail("provision", scriptedFailure);
+		return Effect.gen({ self: this }, function* () {
+			if (!isSupportedSmartAccountChain(input.chainId)) return yield* fail("provision", Errors.invalidInput("chainId", `unsupported chainId ${String(input.chainId)}`));
+			const existing = this.#accounts.get(input.authUserId);
+			if (existing !== void 0) return cloneSmartAccount(existing);
+			const now = yield* this.#now("provision.clock");
+			const account = {
+				authUserId: input.authUserId,
+				signerAddress: null,
+				smartAccountAddress: toAddress(deriveCapxulSafeAddress({ email: input.email })),
+				chainId: input.chainId,
+				deployedAt: null,
+				claimedAt: null,
+				createdAt: now
+			};
+			this.#accounts.set(input.authUserId, cloneSmartAccount(account));
+			return cloneSmartAccount(account);
+		}).pipe(this.#provisionMutex.withPermits(1));
+	}
+	promoteDeployedAt(authUserId, deployedAt) {
+		const existing = this.#accounts.get(authUserId);
+		if (existing === void 0) return;
+		if (existing.deployedAt !== null) return;
+		this.#accounts.set(authUserId, {
+			...existing,
+			deployedAt
+		});
+	}
+	confirmDeployment(input) {
+		const scriptedFailure = this.#failures?.confirmDeployment;
+		if (scriptedFailure !== void 0) return fail("confirmDeployment", scriptedFailure);
+		return Effect.gen({ self: this }, function* () {
+			const existing = this.#accounts.get(input.authUserId);
+			if (existing === void 0) return yield* fail("confirmDeployment", Errors.profileNotFound(String(input.authUserId)));
+			if (existing.smartAccountAddress !== toAddress(input.safeAddress)) return yield* fail("confirmDeployment", Errors.invalidInput("safeAddress", "does not match backend smart-account row"));
+			if (existing.deployedAt !== null) return cloneSmartAccount(existing);
+			const now = yield* this.#now("confirmDeployment.clock");
+			const updated = {
+				...existing,
+				deployedAt: now
+			};
+			this.#accounts.set(input.authUserId, cloneSmartAccount(updated));
+			return cloneSmartAccount(updated);
+		}).pipe(this.#provisionMutex.withPermits(1));
+	}
+	claim(input) {
+		const scriptedFailure = this.#failures?.claim;
+		if (scriptedFailure !== void 0) return fail("claim", scriptedFailure);
+		return Effect.gen({ self: this }, function* () {
+			const existing = this.#accounts.get(input.authUserId);
+			if (existing === void 0) return yield* fail("claim", Errors.invalidInput("account", "no provisioned smart account for this user"));
+			if (existing.chainId !== input.chainId) return yield* fail("claim", Errors.invalidInput("chainId", "does not match backend smart-account row"));
+			const newOwner = toAddress(input.signerAddress);
+			if (existing.claimedAt !== null) {
+				if (existing.signerAddress !== newOwner) return yield* fail("claim", Errors.invalidInput("signerAddress", "account already claimed by a different signer"));
+				return cloneSmartAccount(existing);
+			}
+			const now = yield* this.#now("claim.clock");
+			const updated = {
+				...existing,
+				signerAddress: newOwner,
+				claimedAt: now,
+				deployedAt: existing.deployedAt ?? now
+			};
+			this.#accounts.set(input.authUserId, cloneSmartAccount(updated));
+			return cloneSmartAccount(updated);
+		}).pipe(this.#provisionMutex.withPermits(1));
+	}
+	#now(operation) {
+		if (this.#clock === void 0) return Effect.succeed(toEpochMs(0));
+		return this.#clock.now.pipe(Effect.mapError((cause) => smartAccountErrorFromCapxul(operation, Errors.providerError("clock", "now", cause), cause)));
+	}
+};
+function fail(operation, error) {
+	return Effect.fail(smartAccountErrorFromCapxul(operation, error));
+}
+function cloneSmartAccount(account) {
+	return {
+		authUserId: account.authUserId,
+		signerAddress: account.signerAddress,
+		smartAccountAddress: account.smartAccountAddress,
+		chainId: account.chainId,
+		deployedAt: account.deployedAt,
+		claimedAt: account.claimedAt,
+		createdAt: account.createdAt
+	};
+}
+function cloneSmartAccountOrNull(account) {
+	return account === null ? null : cloneSmartAccount(account);
+}
+//#endregion
+//#region src/testing/telemetry/RecordingTelemetryAdapter.ts
+var RecordingTelemetryAdapter = class {
+	#events = [];
+	#operations = [];
+	#rawMode;
+	constructor(options = {}) {
+		this.#rawMode = options.rawMode === true;
+	}
+	get events() {
+		return this.#events.map(cloneTelemetryEvent);
+	}
+	get operations() {
+		return this.#operations.map(cloneOperation);
+	}
+	emit(event) {
+		return Effect.sync(() => {
+			const recorded = redactTelemetryEvent(event, { rawMode: this.#rawMode });
+			this.#events.push(recorded);
+			this.#operations.push({
+				type: "emit",
+				event: cloneTelemetryEvent(recorded)
+			});
+		});
+	}
+	identify(input) {
+		return Effect.sync(() => {
+			this.#operations.push({
+				type: "identify",
+				input: cloneIdentifyInput(input)
+			});
+		});
+	}
+	group(input) {
+		return Effect.sync(() => {
+			this.#operations.push({
+				type: "group",
+				input: cloneGroupInput(input)
+			});
+		});
+	}
+	reset() {
+		return Effect.sync(() => {
+			this.#operations.push({ type: "reset" });
+		});
+	}
+	clear() {
+		this.#events.length = 0;
+		this.#operations.length = 0;
+	}
+};
+function cloneOperation(operation) {
+	switch (operation.type) {
+		case "emit": return {
+			type: "emit",
+			event: cloneTelemetryEvent(operation.event)
+		};
+		case "identify": return {
+			type: "identify",
+			input: cloneIdentifyInput(operation.input)
+		};
+		case "group": return {
+			type: "group",
+			input: cloneGroupInput(operation.input)
+		};
+		case "reset": return { type: "reset" };
+		default: return absurd(operation);
+	}
+}
+function cloneIdentifyInput(input) {
+	return {
+		distinctId: input.distinctId,
+		...input.anonDistinctId === void 0 ? {} : { anonDistinctId: input.anonDistinctId },
+		...input.traits === void 0 ? {} : { traits: cloneTelemetryProps(input.traits) },
+		...input.properties === void 0 ? {} : { properties: cloneTelemetryProps(input.properties) }
+	};
+}
+function cloneGroupInput(input) {
+	return input.properties === void 0 ? {
+		groupType: input.groupType,
+		groupKey: input.groupKey
+	} : {
+		groupType: input.groupType,
+		groupKey: input.groupKey,
+		properties: cloneTelemetryProps(input.properties)
+	};
+}
+//#endregion
+//#region src/testing/index.ts
+const TEST_BOOTSTRAP = {
+	applicationId: toAppId("app_01HX0000000000000000000000"),
+	chainId: toChainId(84532),
+	sessionToken: toSessionToken("bootstrap-test-token"),
+	issuedAt: toEpochMs(0),
+	expiresIn: toDurationMs(6e4),
+	authBaseUrl: "https://auth.example.test",
+	convexUrl: "https://convex.example.test",
+	siteBaseUrl: "https://example.test",
+	openfortPublishableKey: "pk_test_openfort_fixture",
+	shieldPublishableKey: "shield_pk_test_fixture"
+};
+/**
+* Assemble the real public client over deterministic in-memory ports.
+* Unconfigured backend calls fail locally; no adapter owns a network exit.
+*/
+function createCapxulTestClient(options = {}) {
+	const clock = new ManualClockAdapter({});
+	const authCache = new InMemoryAuthCacheAdapter();
+	const authClient = new InMemoryAuthClientAdapter({
+		authCache,
+		clock
+	});
+	const identity = new InMemoryIdentityAdapter({ clock });
+	const telemetry = new RecordingTelemetryAdapter();
+	const organizationSetup = createTestOrganizationSetup();
+	const ports = {
+		authClient: authClientPortFromPromiseAdapter(authClient),
+		authCache,
+		identity,
+		smartAccount: new InMemorySmartAccountAdapter({ clock }),
+		accountRead: new InMemoryAccountReadAdapter({ rawBalance: "0" }),
+		bootstrap: new BootstrapStubAdapter({ script: { resolutions: /* @__PURE__ */ new Map([[`${toPublishableKey("cap_pk_test_0123456789ABCDEFGHJKMNPQRSTVWXYZ")}::${toAllowedOrigin("https://example.test")}`, TEST_BOOTSTRAP]]) } }),
+		clock,
+		telemetry,
+		convexCall: new ConvexCallStubAdapter({ script: {} })
+	};
+	const client = assembleCapxulClient({
+		ports,
+		bootstrap: TEST_BOOTSTRAP,
+		authCache,
+		requirement: options.requirement ?? "none",
+		organizationSetup: organizationSetup.ops,
+		...options.failureObservation === void 0 ? {} : { failureObservation: options.failureObservation }
+	});
+	const transitions = [];
+	const unsubscribe = client._internal.identity.subscribeTransitions((record) => {
+		transitions.push(record);
+	});
+	let closed = false;
+	return {
+		client,
+		clock: Object.freeze({ advance: (ms) => clock.advance(ms) }),
+		observation: {
+			emit: (event) => Effect.runPromise(telemetry.emit(event)),
+			identify: (input) => Effect.runPromise(telemetry.identify(input)),
+			group: (input) => Effect.runPromise(telemetry.group(input)),
+			reset: () => Effect.runPromise(telemetry.reset())
+		},
+		get transitions() {
+			return transitions.slice();
+		},
+		get observations() {
+			return telemetry.operations;
+		},
+		peekOtp: (email) => authClient.peekOtpForTesting(toEmail(email)),
+		organizationSetup: { set: organizationSetup.set },
+		seedIdentity: async (input) => {
+			const authUserId = toAuthUserId(input.authUserId);
+			const email = toEmail(input.email);
+			await Effect.runPromise(identity.create({
+				authUserId,
+				email,
+				...input.displayName === void 0 ? {} : { displayName: input.displayName },
+				...input.country === void 0 ? {} : { country: toCountryCode(input.country) }
+			}));
+			authClient.bindAuthUserIdForTesting(email, authUserId);
+		},
+		close: async () => {
+			if (closed) return;
+			closed = true;
+			unsubscribe();
+			await client._internal.close?.();
+		}
+	};
+}
+//#endregion
+export { ControlledSignerFault, armSignerFaults, createCapxulProductionTestClient, createCapxulTestClient, organizationSetupFixture, signerFaultCause };