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

package/dist/testing/index.mjs

@@ -1,7 +1,6 @@
-import { D as fromWei, P as redactTelemetryEvent, a as smartAccountErrorFromCapxul, c as identityErrorFromCapxul, i as assembleCapxulClient, l as convexCallErrorFromCapxul, n as createCapxulClientWithSignerControls, o as accountReadErrorFromCapxul, s as wireChainId, u as bootstrapErrorFromCapxul, v as toWei } from "../production-BMfmzwHq.mjs";
-import { B as toAuthUserId, F as toAccountId, G as toDurationMs, H as toChainId, I as toAddress, J as toEpochSeconds, K as toEmail, L as toAllowedOrigin, R as toAppId, U as toCountryCode, X as toJwtToken, Y as toHandle, Z as toKycTier, ct as validateHandle, d as authClientPortFromPromiseAdapter, ft as CapxulError, it as toSessionToken, mt as Errors, n as readClockNow, nt as toPublishableKey, q as toEpochMs, r as InMemoryAuthCacheAdapter, y as deriveCapxulSafeAddress } from "../OAuthBearerAuthClient-DWkofxdZ.mjs";
-import { keccak256 } from "viem";
-import { Effect, Result, Semaphore } from "effect";
+import { $r as toAccountId, Bi as InMemoryAuthCacheAdapter, Ci as toAddress, Ei as absurd, Fi as authClientPortFromPromiseAdapter, Gi as toEpochMs, Gn as ClockError, Ji as toEmail, Jn as readClockNow, Ki as toEpochSeconds, Kn as ClockPortTag, Lt as CONFIGURED_MONEY_ASSETS, M as wireChainId, Mi as toAllowedOrigin, Ni as toAppId, O as convexCallErrorFromCapxul, Ot as deriveCapxulSafeAddress, Pi as toPublishableKey, Q as assetAmountFromRaw, Sn as toHandle, Ti as toWeiAmount, Wi as toDurationMs, Xi as toSessionToken, Yi as toJwtToken, Zi as Errors, _ as accountFromAccountPositions, f as smartAccountErrorFromCapxul, na as CapxulError, nr as redactTelemetryEvent, qi as toAuthUserId, qn as clockFailure, rt as toRaw, vn as toCountryCode, w as accountReadErrorFromCapxul, wi as toChainId, wn as validateHandle, yn as toKycTier, zr as toOrgId } from "../access-6VLRaqRP.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-Dy8n4ZBY.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. */
@@ -100,7 +99,123 @@ function armSignerFaults(plan = {}) {
 	};
 }
 //#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;
@@ -108,26 +223,29 @@ var InMemoryAccountReadAdapter = class {
 		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 decimals = this.#deps.decimals ?? 6;
-		const currency = this.#deps.currency ?? "USD";
-		const money = fromWei(this.#rawBalance, decimals, currency);
-		return Effect.succeed({
-			id: toAccountId(this.#deps.accountId ?? "account_01TEST000000000000000000"),
-			balance: money,
-			available: money
-		});
+		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 expectedDecimals = this.#deps.decimals ?? 6;
-		const expectedCurrency = this.#deps.currency ?? "USD";
-		if (input.amount.decimals !== expectedDecimals || String(input.amount.currency) !== expectedCurrency) return Effect.fail(accountReadErrorFromCapxul("fundFromFaucet", Errors.invalidInput("amount", "decimals/currency must match adapter config")));
-		const minted = BigInt(toWei(input.amount));
+		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) });
 	}
@@ -135,36 +253,68 @@ var InMemoryAccountReadAdapter = class {
 function cloneAccount(account) {
 	return {
 		id: account.id,
-		balance: { ...account.balance },
-		available: { ...account.available }
+		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/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 {
+//#region src/testing/clock/sleep-queue.ts
+var SleepQueueClock = class {
 	currentTime = 0;
-	queue = [];
+	pending = [];
 	seqCounter = 0;
-	constructor(deps) {}
 	now = Effect.sync(() => toEpochMs(this.currentTime));
 	sleep(duration) {
 		return Effect.promise(() => new Promise((resolve) => {
-			this.queue.push({
+			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
@@ -174,39 +324,33 @@ var ManualClockAdapter = class ManualClockAdapter {
 		return Effect.runPromise(this.tickOneEffect());
 	}
 	tickOneEffect() {
-		const self = this;
-		return Effect.gen(function* () {
-			if (self.queue.length === 0) return;
-			const nextIndex = self.findEarliestIndex();
-			const next = self.queue.splice(nextIndex, 1)[0];
-			if (next.deadline > self.currentTime) self.currentTime = next.deadline;
+		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;
 		});
 	}
 	/**
-	* Cross-adapter harness affordance. 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.
+	* 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.
 	*/
-	advance(ms) {
-		return Effect.runPromise(this.advanceEffect(toDurationMs(ms)));
-	}
 	advanceEffect(duration) {
-		const self = this;
-		return Effect.gen(function* () {
+		return Effect.gen({ self: this }, function* () {
 			yield* Effect.yieldNow;
-			const target = self.currentTime + duration;
-			while (self.queue.length > 0 && self.earliestDeadline() <= target) yield* self.tickOneEffect();
-			self.currentTime = target;
+			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.queue[0];
-		for (let i = 1; i < this.queue.length; i++) {
-			const candidate = this.queue[i];
+		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;
@@ -215,21 +359,14 @@ var ManualClockAdapter = class ManualClockAdapter {
 		return bestIndex;
 	}
 	earliestDeadline() {
-		return this.queue[this.findEarliestIndex()].deadline;
+		return this.pending[this.findEarliestIndex()].deadline;
 	}
 	static forConformance() {
-		return new ManualClockUnderTest(new ManualClockAdapter({}));
-	}
-};
-var ManualClockUnderTest = class {
-	clock;
-	constructor(clock) {
-		this.clock = clock;
-	}
-	advance(ms) {
-		return this.clock.advance(ms);
+		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);
@@ -471,7 +608,12 @@ 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)
+		error: Errors.providerUnavailable({
+			provider: "auth-cache",
+			operation,
+			mode: "unknown",
+			cause: result.failure
+		})
 	};
 	return {
 		ok: true,
@@ -509,6 +651,47 @@ 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;
@@ -517,43 +700,30 @@ var ConvexCallStubAdapter = class {
 		this.#script = deps.script;
 	}
 	query(fn, _args) {
-		return this.#resolve(getFunctionName(fn));
+		return this.#resolve(fn);
 	}
 	mutation(fn, _args) {
-		return this.#resolve(getFunctionName(fn));
+		return this.#resolve(fn);
 	}
 	action(fn, _args) {
-		return this.#resolve(getFunctionName(fn));
+		return this.#resolve(fn);
 	}
 	subscribe(fn, _args, callback) {
 		return Effect.sync(() => {
 			const path = getFunctionName(fn);
-			const cb = callback;
+			const cb = (snapshot) => callback(wireSnapshot(fn, snapshot));
 			cb({ status: "loading" });
 			const sequence = this.#script.subscriptions?.get(path);
 			const subscriber = {
 				callback: cb,
 				cursor: 0
 			};
-			let subs = this.#subscribers.get(path);
-			if (subs === void 0) {
-				subs = /* @__PURE__ */ new Set();
-				this.#subscribers.set(path, subs);
-			}
-			subs.add(subscriber);
+			const unsubscribe = subscribeAt(this.#subscribers, path, subscriber);
 			if (sequence !== void 0 && sequence.length > 0) {
 				cb(sequence[0]);
 				subscriber.cursor = 1;
 			}
-			let active = true;
-			return () => {
-				if (!active) return;
-				active = false;
-				const liveSubs = this.#subscribers.get(path);
-				if (liveSubs === void 0) return;
-				liveSubs.delete(subscriber);
-				if (liveSubs.size === 0) this.#subscribers.delete(path);
-			};
+			return unsubscribe;
 		});
 	}
 	advanceSubscription(path) {
@@ -568,17 +738,26 @@ var ConvexCallStubAdapter = class {
 			sub.callback(next);
 		}
 	}
-	#resolve(path) {
+	#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(this.#script.responses.get(path));
-		return Effect.fail(convexCallErrorFromCapxul(path, Errors.providerError("convex", path, "unknown function")));
+		if (this.#script.responses?.has(path)) return Effect.succeed(wireReply(fn, this.#script.responses.get(path)));
+		return Effect.fail(convexCallErrorFromCapxul(path, Errors.providerUnavailable({
+			provider: "convex",
+			operation: path,
+			mode: "unknown"
+		})));
 	}
 };
 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))));
+	return convexCallErrorFromCapxul(operation, Errors.providerUnavailable({
+		provider: "convex",
+		operation,
+		mode: "unknown",
+		cause: failure
+	}));
 }
 //#endregion
 //#region src/testing/identity/InMemoryIdentityAdapter.ts
@@ -587,15 +766,15 @@ var InMemoryIdentityAdapter = class {
 	#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) {
-		const self = this;
-		return Effect.gen(function* () {
-			if (self.#identities.has(input.authUserId)) return yield* fail$1("create", Errors.invalidInput("authUserId", "already exists"));
-			const now = yield* self.#now("create.clock");
+		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,
@@ -609,16 +788,15 @@ var InMemoryIdentityAdapter = class {
 				createdAt: now,
 				updatedAt: now
 			};
-			self.#identities.set(input.authUserId, cloneProfile(profile));
+			this.#identities.set(input.authUserId, cloneProfile(profile));
 			return cloneProfile(profile);
 		});
 	}
 	update(input) {
-		const self = this;
-		return Effect.gen(function* () {
-			const existing = self.#identities.get(input.authUserId);
+		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* self.#now("update.clock");
+			const now = yield* this.#now("update.clock");
 			const updated = {
 				authUserId: existing.authUserId,
 				email: existing.email,
@@ -632,15 +810,14 @@ var InMemoryIdentityAdapter = class {
 				imageUrl: existing.imageUrl,
 				updatedAt: now
 			};
-			self.#identities.set(input.authUserId, cloneProfile(updated));
+			this.#identities.set(input.authUserId, cloneProfile(updated));
 			return cloneProfile(updated);
 		});
 	}
 	completeOnboarding(input) {
-		const self = this;
-		return Effect.gen(function* () {
-			const now = yield* self.#now("completeOnboarding.clock");
-			const existing = self.#identities.get(input.authUserId);
+		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,
@@ -654,14 +831,16 @@ var InMemoryIdentityAdapter = class {
 				createdAt: existing?.createdAt ?? now,
 				updatedAt: now
 			};
-			self.#identities.set(input.authUserId, cloneProfile(profile));
+			this.#identities.set(input.authUserId, cloneProfile(profile));
 			return cloneProfile(profile);
 		});
 	}
 	#now(operation) {
-		return this.#clock.now.pipe(Effect.mapError((cause) => identityErrorFromCapxul(operation, Errors.providerError("clock", "now", cause), cause)));
+		if (this.#clock === void 0) return Effect.succeed(toEpochMs(0));
+		return this.#clock.now.pipe(Effect.mapError((cause) => identityErrorFromCapxul(operation, clockFailure(cause), cause)));
 	}
 };
+Layer.effect(IdentityPortTag, Effect.map(ClockPortTag, (clock) => new InMemoryIdentityAdapter({ clock })));
 function fail$1(operation, error) {
 	return Effect.fail(identityErrorFromCapxul(operation, error));
 }
@@ -686,8 +865,6 @@ function cloneProfileOrNull(profile) {
 //#endregion
 //#region src/testing/smart-account/smart-account-derivation.ts
 const SUPPORTED_CHAIN_IDS = /* @__PURE__ */ new Set([84532, 8453]);
-toAddress("0xa6b71e26c5e0845f74c812102ca7114b6a896ab2");
-keccak256("0x");
 function isSupportedSmartAccountChain(chainId) {
 	return SUPPORTED_CHAIN_IDS.has(wireChainId(chainId));
 }
@@ -708,6 +885,7 @@ var InMemorySmartAccountAdapter = class {
 	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;
@@ -726,12 +904,11 @@ var InMemorySmartAccountAdapter = class {
 	provision(input) {
 		const scriptedFailure = this.#failures?.provision;
 		if (scriptedFailure !== void 0) return fail("provision", scriptedFailure);
-		const self = this;
-		return Effect.gen(function* () {
+		return Effect.gen({ self: this }, function* () {
 			if (!isSupportedSmartAccountChain(input.chainId)) return yield* fail("provision", Errors.invalidInput("chainId", `unsupported chainId ${String(input.chainId)}`));
-			const existing = self.#accounts.get(input.authUserId);
+			const existing = this.#accounts.get(input.authUserId);
 			if (existing !== void 0) return cloneSmartAccount(existing);
-			const now = yield* self.#now("provision.clock");
+			const now = yield* this.#now("provision.clock");
 			const account = {
 				authUserId: input.authUserId,
 				signerAddress: null,
@@ -741,9 +918,9 @@ var InMemorySmartAccountAdapter = class {
 				claimedAt: null,
 				createdAt: now
 			};
-			self.#accounts.set(input.authUserId, cloneSmartAccount(account));
+			this.#accounts.set(input.authUserId, cloneSmartAccount(account));
 			return cloneSmartAccount(account);
-		}).pipe(self.#provisionMutex.withPermits(1));
+		}).pipe(this.#provisionMutex.withPermits(1));
 	}
 	promoteDeployedAt(authUserId, deployedAt) {
 		const existing = this.#accounts.get(authUserId);
@@ -755,27 +932,27 @@ var InMemorySmartAccountAdapter = class {
 		});
 	}
 	confirmDeployment(input) {
-		const self = this;
-		return Effect.gen(function* () {
-			const existing = self.#accounts.get(input.authUserId);
+		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* self.#now("confirmDeployment.clock");
+			const now = yield* this.#now("confirmDeployment.clock");
 			const updated = {
 				...existing,
 				deployedAt: now
 			};
-			self.#accounts.set(input.authUserId, cloneSmartAccount(updated));
+			this.#accounts.set(input.authUserId, cloneSmartAccount(updated));
 			return cloneSmartAccount(updated);
-		}).pipe(self.#provisionMutex.withPermits(1));
+		}).pipe(this.#provisionMutex.withPermits(1));
 	}
 	claim(input) {
 		const scriptedFailure = this.#failures?.claim;
 		if (scriptedFailure !== void 0) return fail("claim", scriptedFailure);
-		const self = this;
-		return Effect.gen(function* () {
-			const existing = self.#accounts.get(input.authUserId);
+		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);
@@ -783,19 +960,20 @@ var InMemorySmartAccountAdapter = class {
 				if (existing.signerAddress !== newOwner) return yield* fail("claim", Errors.invalidInput("signerAddress", "account already claimed by a different signer"));
 				return cloneSmartAccount(existing);
 			}
-			const now = yield* self.#now("claim.clock");
+			const now = yield* this.#now("claim.clock");
 			const updated = {
 				...existing,
 				signerAddress: newOwner,
 				claimedAt: now,
 				deployedAt: existing.deployedAt ?? now
 			};
-			self.#accounts.set(input.authUserId, cloneSmartAccount(updated));
+			this.#accounts.set(input.authUserId, cloneSmartAccount(updated));
 			return cloneSmartAccount(updated);
-		}).pipe(self.#provisionMutex.withPermits(1));
+		}).pipe(this.#provisionMutex.withPermits(1));
 	}
 	#now(operation) {
-		return this.#clock.now.pipe(Effect.mapError((cause) => smartAccountErrorFromCapxul(operation, Errors.providerError("clock", "now", cause), cause)));
+		if (this.#clock === void 0) return Effect.succeed(toEpochMs(0));
+		return this.#clock.now.pipe(Effect.mapError((cause) => smartAccountErrorFromCapxul(operation, clockFailure(cause), cause)));
 	}
 };
 function fail(operation, error) {
@@ -825,7 +1003,7 @@ var RecordingTelemetryAdapter = class {
 		this.#rawMode = options.rawMode === true;
 	}
 	get events() {
-		return this.#events.map(cloneEvent);
+		return this.#events.map(cloneTelemetryEvent);
 	}
 	get operations() {
 		return this.#operations.map(cloneOperation);
@@ -836,7 +1014,7 @@ var RecordingTelemetryAdapter = class {
 			this.#events.push(recorded);
 			this.#operations.push({
 				type: "emit",
-				event: cloneEvent(recorded)
+				event: cloneTelemetryEvent(recorded)
 			});
 		});
 	}
@@ -866,17 +1044,11 @@ var RecordingTelemetryAdapter = class {
 		this.#operations.length = 0;
 	}
 };
-function cloneEvent(event) {
-	return event.props === void 0 ? { name: event.name } : {
-		name: event.name,
-		props: cloneProps(event.props)
-	};
-}
 function cloneOperation(operation) {
 	switch (operation.type) {
 		case "emit": return {
 			type: "emit",
-			event: cloneEvent(operation.event)
+			event: cloneTelemetryEvent(operation.event)
 		};
 		case "identify": return {
 			type: "identify",
@@ -887,14 +1059,15 @@ function cloneOperation(operation) {
 			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: cloneProps(input.traits) },
-		...input.properties === void 0 ? {} : { properties: cloneProps(input.properties) }
+		...input.traits === void 0 ? {} : { traits: cloneTelemetryProps(input.traits) },
+		...input.properties === void 0 ? {} : { properties: cloneTelemetryProps(input.properties) }
 	};
 }
 function cloneGroupInput(input) {
@@ -904,22 +1077,9 @@ function cloneGroupInput(input) {
 	} : {
 		groupType: input.groupType,
 		groupKey: input.groupKey,
-		properties: cloneProps(input.properties)
+		properties: cloneTelemetryProps(input.properties)
 	};
 }
-function cloneProps(props) {
-	const cloned = {};
-	for (const [key, value] of Object.entries(props)) cloned[key] = cloneTelemetryValue(value);
-	return cloned;
-}
-function cloneTelemetryValue(value) {
-	if (Array.isArray(value)) return value.map(cloneTelemetryValue);
-	if (value === null || typeof value !== "object") return value;
-	if (Object.getPrototypeOf(value) !== Object.prototype) return value;
-	const cloned = {};
-	for (const [key, nested] of Object.entries(value)) cloned[key] = cloneTelemetryValue(nested);
-	return cloned;
-}
 //#endregion
 //#region src/testing/index.ts
 const TEST_BOOTSTRAP = {
@@ -947,6 +1107,7 @@ function createCapxulTestClient(options = {}) {
 	});
 	const identity = new InMemoryIdentityAdapter({ clock });
 	const telemetry = new RecordingTelemetryAdapter();
+	const organizationSetup = createTestOrganizationSetup();
 	const ports = {
 		authClient: authClientPortFromPromiseAdapter(authClient),
 		authCache,
@@ -963,6 +1124,7 @@ function createCapxulTestClient(options = {}) {
 		bootstrap: TEST_BOOTSTRAP,
 		authCache,
 		requirement: options.requirement ?? "none",
+		organizationSetup: organizationSetup.ops,
 		...options.failureObservation === void 0 ? {} : { failureObservation: options.failureObservation }
 	});
 	const transitions = [];
@@ -986,6 +1148,7 @@ function createCapxulTestClient(options = {}) {
 			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);
@@ -1006,4 +1169,4 @@ function createCapxulTestClient(options = {}) {
 	};
 }
 //#endregion
-export { ControlledSignerFault, armSignerFaults, createCapxulProductionTestClient, createCapxulTestClient, signerFaultCause };
+export { ControlledSignerFault, armSignerFaults, createCapxulProductionTestClient, createCapxulTestClient, organizationSetupFixture, signerFaultCause };