@capxul/sdk 4.2.0-rc.7 → 4.2.0-rc.9

package/dist/{production-D-wB2nFa.mjs → production-216hsAKc.mjs}

@@ -1,4 +1,4 @@
-import { $ as toSessionToken, B as toDurationMs, C as ASSET_ID_RE, D as WEI_RE, E as SUPPORTED_CURRENCY_CODES, F as toAuthUserId, G as toJwtToken, H as toEpochMs, I as toBudgetId, J as toPartyId, K as toKycTier, L as toChainId, M as toAddress, N as toAllowedOrigin, O as ZERO_BYTES32, Q as toRoleKey, R as toCountryCode, S as APP_ID_RE, St as redactUrlSecrets, T as EVM_ADDRESS_RE$1, U as toEpochSeconds, V as toEmail, W as toHandle, X as toPayrollRunId, Y as toPayrollGroupId, Z as toPublishableKey, _ as normalizeBindingEmail, _t as isFailureMode, at as CapxulError, bt as isCredentialField, c as AuthCachePortTag, ct as isCapxulError, d as authClientPortFromPromiseAdapter, dt as boundedResponseHeaders, et as toTesterKind, f as AuthClientError, ft as chainCauseProperties, gt as isChainUpstream, h as orgRoleKeyForLabel, ht as failureFingerprint, i as BrowserAuthCacheAdapter, it as CAPXUL_ERROR_CODES, j as toAccountId, l as SystemClockLayer, lt as CHAIN_UPSTREAMS, m as ADMIN_ROLE_LABEL, mt as decodeChainCause, ot as EXPECTED_OPERATION_OUTCOMES, p as AuthClientPortTag, pt as chainEvidenceLabel, q as toOrgId, r as InMemoryAuthCacheAdapter, rt as decodeConvexError, st as Errors, tt as validateHandle, u as ClockPortTag, ut as FAILURE_MODES$1, v as BASE_SEPOLIA_CHAIN_ID, vt as revertSummaryText, w as BYTES32_RE, x as ACCOUNT_ID_RE, xt as redactSecrets, y as deriveCapxulSafeAddress, yt as containsSensitiveMaterial, z as toCurrencyCode } from "./OAuthBearerAuthClient-hPwtSpEf.mjs";
+import { $ as toRoleKey, B as toCurrencyCode, C as ASSET_ID_RE, Ct as redactSecrets, D as WEI_RE, E as SUPPORTED_CURRENCY_CODES, F as toAssetId, G as toHandle, H as toEmail, I as toAuthUserId, J as toOrgId, K as toJwtToken, L as toBudgetId, M as toAddress, N as toAllowedOrigin, O as ZERO_BYTES32, Q as toPublishableKey, R as toChainId, S as APP_ID_RE, St as isCredentialField, T as EVM_ADDRESS_RE$1, U as toEpochMs, V as toDurationMs, W as toEpochSeconds, X as toPayrollGroupId, Y as toPartyId, Z as toPayrollRunId, _ as normalizeBindingEmail, _t as failureFingerprint, at as decodeConvexError, bt as revertSummaryText, c as AuthCachePortTag, ct as EXPECTED_OPERATION_OUTCOMES, d as authClientPortFromPromiseAdapter, dt as CHAIN_UPSTREAMS, et as toSessionToken, f as AuthClientError, ft as FAILURE_MODES$1, gt as decodeChainCause, h as orgRoleKeyForLabel, ht as chainEvidenceLabel, i as BrowserAuthCacheAdapter, j as toAccountId, l as SystemClockLayer, lt as Errors, m as ADMIN_ROLE_LABEL, mt as chainCauseProperties, nt as toTxHash, ot as CAPXUL_ERROR_CODES, p as AuthClientPortTag, pt as boundedResponseHeaders, q as toKycTier, r as InMemoryAuthCacheAdapter, rt as validateHandle, st as CapxulError, tt as toTesterKind, u as ClockPortTag, ut as isCapxulError, v as BASE_SEPOLIA_CHAIN_ID, vt as isChainUpstream, w as BYTES32_RE, wt as redactUrlSecrets, x as ACCOUNT_ID_RE, xt as containsSensitiveMaterial, y as deriveCapxulSafeAddress, yt as isFailureMode, z as toCountryCode } from "./OAuthBearerAuthClient-IB2W1Fzj.mjs";
 import { formatUnits, keccak256, parseUnits, recoverAddress, stringToHex, toBytes } from "viem";
 import { Cause, Clock, Context, Data, Deferred, Duration, Effect, Exit, Fiber, FiberSet, Layer, Option, Queue, Ref, Result, Schedule, Schema, SchemaGetter, SchemaIssue, SchemaParser, Scope, Stream, Tracer } from "effect";
 import { getFunctionName, makeFunctionReference } from "convex/server";
@@ -448,6 +448,8 @@ const CAPXUL_OPERATIONS = {
 		emitAnnotationSaved: "activity.emitAnnotationSaved",
 		get: "activity.get",
 		list: "activity.list",
+		/** The SDK's live Activity read over the indexer's SSE stream. */
+		subscribe: "activity.subscribe",
 		summary: "activity.summary"
 	},
 	addressBook: {
@@ -946,6 +948,17 @@ const AuthFailedProps = Schema.Struct({
 	auth_type: OptionalString,
 	reason: OptionalString
 });
+const IdentityRefusedProps = Schema.Struct({
+	...TelemetryEnvelopeProps,
+	/** The refused identity event tag, for example CreateOrganization. */
+	event: OptionalString,
+	/** The machine's refusal code: WRONG_STATE, SUPERSEDED or STALE_EPOCH. */
+	refusal_code: OptionalString,
+	/** The machine slot the request targeted, for example identity:org. */
+	slot: OptionalString,
+	/** The machine state at refusal, for example authenticated:claiming. */
+	state: OptionalString
+});
 const AuthSignedOutProps = Schema.Struct(TelemetryEnvelopeProps);
 const ProvisioningSafeCreatedProps = Schema.Struct({
 	...TelemetryEnvelopeProps,
@@ -1396,6 +1409,10 @@ Schema.Struct({
 	name: Schema.Literal("auth_failed"),
 	props: AuthFailedProps
 });
+Schema.Struct({
+	name: Schema.Literal("identity_refused"),
+	props: IdentityRefusedProps
+});
 Schema.Struct({
 	name: Schema.Literal("auth_signed_out"),
 	props: AuthSignedOutProps
@@ -2212,6 +2229,10 @@ const BootstrapEnvelope = Schema.Struct({
 		siteBaseUrl: Schema.String,
 		openfortPublishableKey: Schema.String,
 		shieldPublishableKey: Schema.String,
+		/** Which Openfort third-party auth provider the signer presents; absent means better-auth. */
+		openfortAuthProvider: Schema.optional(Schema.Literals(["better-auth", "oidc"])),
+		/** Origin of the Ponder indexer the SDK reads directly; absent means no indexer reads. */
+		indexerUrl: Schema.optional(Schema.String),
 		engineeringTelemetry: Schema.optional(EngineeringTelemetryBootstrapPolicy)
 	})
 });
@@ -2286,6 +2307,7 @@ const CAPXUL_FUNCTIONS = {
 		prepareOrganizationPaymentExecution: "moneyExecution/paymentCommandActions:prepareOrganizationPaymentExecution",
 		submitPaymentCommandExecution: "moneyExecution/paymentCommandActions:submitPaymentCommandExecution"
 	},
+	"moneyExecution/providerSendWitness": { read: "moneyExecution/providerSendWitness:read" },
 	media: {
 		generateUploadUrl: "media:generateUploadUrl",
 		setOrgLogo: "media:setOrgLogo",
@@ -2334,8 +2356,7 @@ const CAPXUL_FUNCTIONS = {
 		listMine: "org/queries:listMine",
 		listRolesByOrgId: "org/queries:listRolesByOrgId",
 		loadByOrgId: "org/queries:loadByOrgId",
-		me: "org/queries:me",
-		pendingSetup: "org/queries:pendingSetup"
+		me: "org/queries:me"
 	},
 	"smartAccount/actions": {
 		claim: "smartAccount/actions:claim",
@@ -2346,6 +2367,11 @@ const CAPXUL_FUNCTIONS = {
 		loadByAuthUserId: "smartAccount/queries:loadByAuthUserId",
 		loadBySmartAccountAddress: "smartAccount/queries:loadBySmartAccountAddress"
 	},
+	e2eControls: {
+		holdUserOperationReceipt: "e2eControls:holdUserOperationReceipt",
+		isUserOperationReceiptHeld: "e2eControls:isUserOperationReceiptHeld",
+		releaseUserOperationReceipt: "e2eControls:releaseUserOperationReceipt"
+	},
 	system: { health: "system:health" }
 };
 //#endregion
@@ -5657,7 +5683,7 @@ const moneyExecutionContract = {
 };
 //#endregion
 //#region package.json
-var version = "4.2.0-rc.7";
+var version = "4.2.0-rc.9";
 //#endregion
 //#region src/telemetry/exception-projection.ts
 /** Fixed fallback for failures that have no safe message. */
@@ -5850,6 +5876,17 @@ function observeFailedResult(result, adapter, operation, origin) {
 	return result;
 }
 /**
+* @internal Reports a failure that can never become a method result.
+*
+* A reactive stream is torn down after its call already returned, so nothing
+* downstream observes it. `captureException` is the right kind: the caller did
+* not ask for the end, so it is not an expected product outcome.
+*/
+function observeStreamFailure(adapter, operation, cause) {
+	if (adapter === void 0) return;
+	report(adapter, "exception", operation, cause, resolveAdapterSnapshot(adapter));
+}
+/**
 * One failure, one event. The identity machine reports a failed transition
 * first; when the same `CapxulError` then surfaces as a public method result
 * (directly or down its `cause` chain), the boundary drops that second report.
@@ -8673,7 +8710,7 @@ function isTransientBootstrapFailure(error) {
 	const status = error.details?.httpStatus;
 	return typeof status === "number" && isTransientHttpStatus(status);
 }
-async function safeText(res) {
+async function safeText$1(res) {
 	try {
 		return await res.text();
 	} catch {
@@ -8746,6 +8783,8 @@ var HttpBootstrapAdapter = class {
 					siteBaseUrl: normalizeRuntimeUrl("siteBaseUrl", decodedState.siteBaseUrl),
 					openfortPublishableKey: decodedState.openfortPublishableKey,
 					shieldPublishableKey: decodedState.shieldPublishableKey,
+					...decodedState.openfortAuthProvider === void 0 ? {} : { openfortAuthProvider: decodedState.openfortAuthProvider },
+					...decodedState.indexerUrl === void 0 ? {} : { indexerUrl: decodedState.indexerUrl },
 					...decodedEngineeringTelemetry !== void 0 && Result.isSuccess(decodedEngineeringTelemetry) ? { engineeringTelemetry: decodedEngineeringTelemetry.success } : {}
 				};
 			},
@@ -8754,7 +8793,7 @@ var HttpBootstrapAdapter = class {
 				return bootstrapErrorFromCapxul("malformedBody", Errors.providerError("convex", "bootstrap", cause instanceof Error ? cause : new Error(String(cause))));
 			}
 		});
-		return Effect.promise(() => safeText(res)).pipe(Effect.flatMap((body) => {
+		return Effect.promise(() => safeText$1(res)).pipe(Effect.flatMap((body) => {
 			if (res.status === 401 || body.startsWith("NOT_AUTHENTICATED")) return Effect.fail(bootstrapErrorFromCapxul("notAuthenticated", Errors.notAuthenticated()));
 			if (res.status === 400 || body.startsWith("INVALID_INPUT")) return Effect.fail(bootstrapErrorFromCapxul("invalidInput", Errors.invalidInput("publishableKey", "rejected by bootstrap")));
 			const responseBody = body.slice(0, 300);
@@ -8984,6 +9023,12 @@ function makeConnectionId() {
 }
 //#endregion
 //#region src/adapters/convex-call/ConvexCallAdapter.ts
+/**
+* A socket that has not emitted `close` within this window is not going to.
+* ponytail: one fixed bound; `closeTimeoutMs` is the knob if a slow runtime
+* ever needs a different one.
+*/
+const DEFAULT_CLOSE_TIMEOUT_MS = 5e3;
 /** Exact floor-first allowlist; every additional handler must migrate its validator first. */
 const OBSERVED_CONVEX_ACTIONS = /* @__PURE__ */ new Set([
 	"payroll/actions:authorizeRun",
@@ -9052,7 +9097,9 @@ var ConvexCallAdapter = class {
 	#applicationId;
 	#observation;
 	#connectionMonitor;
+	#closeTimeoutMs;
 	constructor(deps) {
+		this.#closeTimeoutMs = deps.closeTimeoutMs ?? DEFAULT_CLOSE_TIMEOUT_MS;
 		this.#connectionMonitor = new ConvexConnectionMonitor();
 		const webSocketConstructor = this.#connectionMonitor.observedWebSocketConstructor();
 		this.#client = deps.client ?? new ConvexClient(deps.convexUrl, webSocketConstructor === void 0 ? {} : { webSocketConstructor });
@@ -9151,11 +9198,33 @@ var ConvexCallAdapter = class {
 			callback({ status: "loading" });
 		})));
 	}
+	/**
+	* Teardown always completes. `ConvexClient.close()` resolves only when the
+	* socket emits `close`, and `WebSocketManager.close()` in the `connecting`
+	* state arms `ws.onopen = () => ws.close()` without ever closing the socket
+	* itself — so a handshake that stalls right after a server-initiated close
+	* (code 1012, which is what a Convex deploy sends) leaves that promise
+	* pending for as long as the page lives. Convex marks the client closed and
+	* terminates the socket manager synchronously before returning it, so
+	* abandoning it drops nothing. A rejection is dropped for the same reason —
+	* the layer release turns it into a defect that fails the whole scope close,
+	* and teardown has no caller who can act on it.
+	*/
 	async close() {
 		this.#connectionMonitor.close();
-		await this.#client.close();
+		await settledWithin(this.#client.close(), this.#closeTimeoutMs);
 	}
 };
+function settledWithin(promise, timeoutMs) {
+	return new Promise((resolve) => {
+		const timer = setTimeout(resolve, timeoutMs);
+		const finish = () => {
+			clearTimeout(timer);
+			resolve();
+		};
+		promise.then(finish, finish);
+	});
+}
 function ConvexCallLayer(deps) {
 	return Layer.effect(ConvexCallPortTag, Effect.acquireRelease(Effect.sync(() => new ConvexCallAdapter(deps)), (adapter) => Effect.promise(() => adapter.close()).pipe(Effect.orDie)));
 }
@@ -10265,8 +10334,9 @@ function createOpenfortBrowserSignerFromBootstrap(bootstrap, options = {}) {
 		});
 		throw failOpenfort("configure", "no-secure-context", /* @__PURE__ */ new Error("Web Crypto unavailable: browser is not a secure context"));
 	}
-	function betterAuthSessionUrl() {
-		return `${authBaseUrl}/get-session`;
+	const authProvider = bootstrap.openfortAuthProvider ?? "better-auth";
+	function accessTokenUrl() {
+		return authProvider === "oidc" ? `${authBaseUrl}/convex/token` : `${authBaseUrl}/get-session`;
 	}
 	function encryptionSessionUrl() {
 		return `${authBaseUrl}/encryption-session`;
@@ -10289,7 +10359,7 @@ function createOpenfortBrowserSignerFromBootstrap(bootstrap, options = {}) {
 		tokenCalls += 1;
 		const tokenStartedAt = Date.now();
 		try {
-			const response = await fetch(betterAuthSessionUrl(), {
+			const response = await fetch(accessTokenUrl(), {
 				credentials: "include",
 				cache: "no-store"
 			});
@@ -10302,7 +10372,8 @@ function createOpenfortBrowserSignerFromBootstrap(bootstrap, options = {}) {
 				});
 				return null;
 			}
-			const token = (await response.json()).session?.token?.trim();
+			const body = await response.json();
+			const token = (authProvider === "oidc" ? body.token : body.session?.token)?.trim();
 			if (token === void 0 || token.length === 0) {
 				diagnostic?.trace("openfort.token", {
 					ok: false,
@@ -10314,6 +10385,7 @@ function createOpenfortBrowserSignerFromBootstrap(bootstrap, options = {}) {
 			diagnostic?.trace("openfort.token", {
 				ok: true,
 				tokenPresent: true,
+				provider: authProvider,
 				call: tokenCalls,
 				duration_ms: Date.now() - tokenStartedAt,
 				elapsed_ms: sinceCycleStart()
@@ -10332,7 +10404,7 @@ function createOpenfortBrowserSignerFromBootstrap(bootstrap, options = {}) {
 		baseConfiguration: { publishableKey: bootstrap.openfortPublishableKey },
 		shieldConfiguration: { shieldPublishableKey: bootstrap.shieldPublishableKey },
 		thirdPartyAuth: {
-			provider: ThirdPartyOAuthProvider.BETTER_AUTH,
+			provider: authProvider === "oidc" ? ThirdPartyOAuthProvider.OIDC : ThirdPartyOAuthProvider.BETTER_AUTH,
 			getAccessToken: fetchBetterAuthAccessToken
 		}
 	});
@@ -13333,11 +13405,28 @@ const authFailure = (record, reason, mode) => ({
 		...linkage(record)
 	}
 });
+const REFUSAL_EVENTS = /* @__PURE__ */ new Set([
+	"ClaimAccount",
+	"RetryAccount",
+	"CreateOrganization",
+	"AttachOrganization",
+	"RetryOrganization"
+]);
 function mapIdentityProductObservation(record, state) {
 	if (record.machine !== "identity" || !IDENTITY_EVENT_TAG_SET.has(record.event)) return NONE;
 	if (record.outcome === "cancelled") return NONE;
 	if (record.slot === "identity:auth" && record.outcome === "refused") return authFailure(record, record.refusal_code, void 0);
 	if (record.slot === "identity:auth" && record.outcome === "failed") return authFailure(record, record.error_code, record.failure?.mode);
+	if (record.outcome === "refused" && REFUSAL_EVENTS.has(record.event)) return {
+		name: "identity_refused",
+		props: {
+			event: record.event,
+			refusal_code: record.refusal_code,
+			slot: record.slot,
+			state: record.state,
+			...linkage(record)
+		}
+	};
 	if (record.outcome !== "applied") return NONE;
 	switch (APPLIED_ACTION_BY_EVENT[record.event]) {
 		case "none": return NONE;
@@ -13663,6 +13752,7 @@ function assembleCapxulClient(input) {
 			identity: identityRuntime,
 			bootstrap: input.bootstrap,
 			accounts: { fund: accounts.fund },
+			...input.ports.indexerRead === void 0 ? {} : { indexer: input.ports.indexerRead },
 			organizationSetup: { getProofReceipt: (orgId) => runPortEffect(input.ports.convexCall.query(organizationSetupProofReceiptQuery, { orgId })) },
 			telemetry: input.ports.telemetry,
 			captureExternalAddressAcknowledged: (address, organizationId) => {
@@ -13864,6 +13954,382 @@ function snapshotHostObservability(observability) {
 function isPromiseLike(value) {
 	return (typeof value === "object" && value !== null || typeof value === "function") && "then" in value;
 }
+//#endregion
+//#region src/ports/indexer-read.ts
+/** The indexer's own page bound. Exceeding it is a caller defect, not a refusal. */
+const INDEXER_MAX_LIMIT = 1e3;
+const LOWER_CASE_ADDRESS = /^0x[0-9a-f]{40}$/;
+/**
+* Refuse a page the indexer would refuse, before any implementation spends a
+* round trip on it. Every implementation calls this, so a consumer test written
+* against the hermetic adapter cannot pass on input production rejects. Throws
+* a `CapxulError`; callers convert it to an `IndexerReadError`.
+*/
+function assertIndexerPage(input) {
+	const safe = String(input.safe).toLowerCase();
+	if (!LOWER_CASE_ADDRESS.test(safe)) throw Errors.invalidInput("safe", "must be a lower-case EVM address");
+	if (!Number.isSafeInteger(input.limit) || input.limit < 1 || input.limit > 1e3) throw Errors.invalidInput("limit", `must be an integer from 1 to ${INDEXER_MAX_LIMIT}`);
+	const offset = input.offset ?? 0;
+	if (!Number.isSafeInteger(offset) || offset < 0) throw Errors.invalidInput("offset", "must be a non-negative integer");
+	return safe;
+}
+var IndexerReadError = class extends Data.TaggedError("IndexerReadError") {};
+function indexerReadErrorFromCapxul(operation, error, cause = error) {
+	return new IndexerReadError({
+		operation,
+		publicCode: error.code,
+		publicError: error,
+		cause,
+		...error.details === void 0 ? {} : { details: error.details }
+	});
+}
+Context.Service()("@capxul/sdk/ports/IndexerReadPort");
+//#endregion
+//#region src/adapters/ponder/decode.ts
+/**
+* Decode the indexer's rows at the trust boundary.
+*
+* Ponder returns the raw PostgreSQL result: `integer` arrives as a number,
+* `numeric(78)` and `text` arrive as strings. Amounts, block numbers and
+* timestamps are `numeric(78)`, so they become `bigint` here and never pass
+* through `Number`. Every decoder throws a `CapxulError`; the adapter turns
+* that into a typed `IndexerReadError`.
+*/
+const HEX = /^0x[0-9a-fA-F]+$/;
+function field(row, key) {
+	if (!(key in row)) throw Errors.invalidInput(key, "missing from the indexer row");
+	return row[key];
+}
+function text(row, key) {
+	const value = field(row, key);
+	if (typeof value !== "string") throw Errors.invalidInput(key, "must be a string");
+	return value;
+}
+function hex(row, key) {
+	const value = text(row, key);
+	if (!HEX.test(value)) throw Errors.invalidInput(key, "must be a hex string");
+	return value.toLowerCase();
+}
+function integer(row, key) {
+	const value = field(row, key);
+	const parsed = typeof value === "string" ? Number(value) : value;
+	if (typeof parsed !== "number" || !Number.isSafeInteger(parsed)) throw Errors.invalidInput(key, "must be an integer");
+	return parsed;
+}
+/** `numeric(78)` crosses the wire as a decimal string; keep every digit. */
+function big(row, key) {
+	const value = field(row, key);
+	if (typeof value === "bigint") return value;
+	const raw = typeof value === "number" ? String(value) : value;
+	if (typeof raw !== "string" || !/^-?[0-9]+$/.test(raw)) throw Errors.invalidInput(key, "must be an exact integer amount");
+	return BigInt(raw);
+}
+function asRow(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw Errors.invalidInput("row", "must be an object");
+	return value;
+}
+function identity(row) {
+	return {
+		id: text(row, "id"),
+		chainId: toChainId(integer(row, "chain_id")),
+		txHash: toTxHash(hex(row, "tx_hash")),
+		transactionLogOrdinal: integer(row, "transaction_log_ordinal"),
+		blockNumber: big(row, "block_number"),
+		blockHash: hex(row, "block_hash"),
+		timestamp: big(row, "timestamp")
+	};
+}
+function decodeTransfer(value) {
+	const row = asRow(value);
+	return {
+		...identity(row),
+		assetId: toAssetId(text(row, "asset_id")),
+		token: toAddress(hex(row, "token")),
+		from: toAddress(hex(row, "from")),
+		to: toAddress(hex(row, "to")),
+		amount: big(row, "amount")
+	};
+}
+function decodePayment(value) {
+	const row = asRow(value);
+	return {
+		...identity(row),
+		contract: toAddress(hex(row, "contract")),
+		settlementId: hex(row, "settlement_id"),
+		sender: toAddress(hex(row, "sender")),
+		recipient: toAddress(hex(row, "recipient")),
+		assetId: toAssetId(text(row, "asset_id")),
+		token: toAddress(hex(row, "token")),
+		amount: big(row, "amount"),
+		kind: integer(row, "kind"),
+		documentHash: hex(row, "document_hash")
+	};
+}
+/** The `balance` view exposes the signed sum under the underlying column name `to`. */
+function decodeBalance(value) {
+	const row = asRow(value);
+	return {
+		chainId: toChainId(integer(row, "chain_id")),
+		assetId: toAssetId(text(row, "asset_id")),
+		address: toAddress(hex(row, "to")),
+		amount: big(row, "amount")
+	};
+}
+const DECODERS = {
+	transfer: decodeTransfer,
+	payment: decodePayment,
+	balance: decodeBalance
+};
+/** Decode one `/sql/db` or `/sql/live` payload. Ponder returns `{ rows: [...] }`. */
+function decodeRows(table, body) {
+	const rows = asRow(body).rows;
+	if (!Array.isArray(rows)) throw Errors.invalidInput("rows", "must be an array");
+	const decode = DECODERS[table];
+	return rows.map(decode);
+}
+/** Decode Ponder's native `/status`: `{ [chainName]: { id, block: { number, timestamp } } }`. */
+function decodeStatus(body) {
+	const chains = asRow(body);
+	return Object.entries(chains).map(([chain, value]) => {
+		const entry = asRow(value);
+		const block = asRow(field(entry, "block"));
+		return {
+			chain,
+			chainId: toChainId(integer(entry, "id")),
+			blockNumber: big(block, "number"),
+			blockTimestamp: big(block, "timestamp")
+		};
+	});
+}
+//#endregion
+//#region src/adapters/ponder/statements.ts
+/**
+* The exact statements the indexer accepts.
+*
+* `apps/indexer/src/queries.ts` compiles its allowlist with `@ponder/client`
+* and compares `sql`, `params` and `typings` byte for byte against the caller's
+* statement. Anything else gets 403. The SDK therefore reproduces the compiled
+* text here rather than pulling Ponder and Drizzle into a published browser
+* bundle to regenerate three fixed statements.
+*
+* `statements.test.ts` pins the text. When the indexer schema or a query in
+* that allowlist changes, this file changes with it or every read fails 403.
+*/
+const HEADS = {
+	transfer: "select \"id\", \"chain_id\", \"tx_hash\", \"transaction_log_ordinal\", \"block_number\", \"block_hash\", \"timestamp\", \"asset_id\", \"token\", \"from\", \"to\", \"amount\" from \"transfer\" where (\"transfer\".\"from\" = $1 or \"transfer\".\"to\" = $2) order by \"transfer\".\"block_number\" desc, \"transfer\".\"id\" desc",
+	payment: "select \"id\", \"chain_id\", \"tx_hash\", \"transaction_log_ordinal\", \"block_number\", \"block_hash\", \"timestamp\", \"contract\", \"settlement_id\", \"sender\", \"recipient\", \"asset_id\", \"token\", \"amount\", \"kind\", \"document_hash\" from \"payment\" where (\"payment\".\"sender\" = $1 or \"payment\".\"recipient\" = $2) order by \"payment\".\"block_number\" desc, \"payment\".\"id\" desc",
+	balance: "select \"chain_id\", \"asset_id\", \"to\", \"amount\" from \"balance\" where \"balance\".\"to\" = $1"
+};
+/** How many times the statement binds the Safe address. */
+const ACTOR_PARAMS = {
+	transfer: 2,
+	payment: 2,
+	balance: 1
+};
+/**
+* Build the compiled query for one table and page. Throws a `CapxulError` for
+* a page or address the indexer would refuse, so the caller never spends a
+* round trip to learn it built the request wrong.
+*/
+function ponderQuery(table, input) {
+	const safe = assertIndexerPage(input);
+	const offset = input.offset ?? 0;
+	const actors = ACTOR_PARAMS[table];
+	const params = [];
+	for (let i = 0; i < actors; i++) params.push(safe);
+	params.push(input.limit);
+	let sql = `${HEADS[table]} limit $${actors + 1}`;
+	if (offset > 0) {
+		params.push(offset);
+		sql = `${sql} offset $${actors + 2}`;
+	}
+	return {
+		sql,
+		params,
+		typings: params.map(() => "none")
+	};
+}
+/**
+* The `?sql=` value. `@ponder/client` sends `superjson.stringify(query)`; for a
+* payload of strings and numbers superjson emits no `meta`, so the wire form is
+* exactly this envelope.
+*/
+function ponderQueryParam(query) {
+	return JSON.stringify({ json: query });
+}
+//#endregion
+//#region src/adapters/ponder/sse.ts
+/**
+* The smallest SSE reader that can carry an `Authorization` header.
+*
+* `@ponder/client` opens its live query with `EventSource`, which accepts no
+* headers, so it cannot reach the guarded indexer at all. The indexer's CORS
+* policy allows exactly one request header (`Authorization`), so this reader
+* sends nothing else. Ponder writes one `data:` line per frame.
+*/
+async function readEventStream(body, onData, stopped) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done || stopped()) return;
+			buffer += decoder.decode(value, { stream: true });
+			let split = buffer.indexOf("\n\n");
+			while (split !== -1) {
+				const frame = buffer.slice(0, split);
+				buffer = buffer.slice(split + 2);
+				const data = frameData(frame);
+				if (data !== void 0) onData(data);
+				if (stopped()) return;
+				split = buffer.indexOf("\n\n");
+			}
+		}
+	} finally {
+		await reader.cancel().catch(() => void 0);
+	}
+}
+function frameData(frame) {
+	const lines = [];
+	for (const line of frame.split("\n")) {
+		if (!line.startsWith("data:")) continue;
+		lines.push(line.slice(line.startsWith("data: ") ? 6 : 5));
+	}
+	return lines.length === 0 ? void 0 : lines.join("\n");
+}
+//#endregion
+//#region src/adapters/ponder/PonderIndexerAdapter.ts
+var PonderIndexerAdapter = class {
+	#baseUrl;
+	#token;
+	#fetch;
+	#observation;
+	constructor(deps) {
+		this.#baseUrl = deps.baseUrl.replace(/\/$/, "");
+		this.#token = deps.token;
+		this.#observation = deps.observation;
+		this.#fetch = deps.fetch ?? ((input, init) => globalThis.fetch(input, init));
+	}
+	read(table, input) {
+		const operation = `indexer.read.${table}`;
+		return Effect.tryPromise({
+			try: async () => {
+				return decodeRows(table, await (await this.#request("db", table, input, operation)).json());
+			},
+			catch: (cause) => toIndexerReadError(operation, cause)
+		});
+	}
+	subscribe(table, input, callback) {
+		const operation = CAPXUL_OPERATIONS.activity.subscribe;
+		return Effect.sync(() => {
+			let stopped = false;
+			const unsubscribe = () => {
+				stopped = true;
+			};
+			callback({ status: "loading" });
+			this.#stream(table, input, operation, callback, () => stopped).catch(() => void 0);
+			return unsubscribe;
+		});
+	}
+	status = Effect.tryPromise({
+		try: async () => {
+			const response = await this.#fetch(`${this.#baseUrl}/status`, { method: "GET" });
+			if (!response.ok) throw httpError("indexer.status", response.status, await safeText(response));
+			return decodeStatus(await response.json());
+		},
+		catch: (cause) => toIndexerReadError("indexer.status", cause)
+	});
+	/** One authenticated `/sql/:method` call. Throws a `CapxulError` on refusal. */
+	async #request(method, table, input, operation) {
+		const query = ponderQuery(table, input);
+		const token = await this.#token({ forceRefreshToken: false });
+		if (token === null || token === "") throw Errors.notAuthenticated();
+		const url = `${this.#baseUrl}/sql/${method}?sql=${encodeURIComponent(ponderQueryParam(query))}`;
+		const headers = { authorization: `Bearer ${token}` };
+		if (method === "live") headers.accept = "text/event-stream";
+		let response;
+		try {
+			response = await this.#fetch(url, {
+				method: "GET",
+				headers
+			});
+		} catch (cause) {
+			throw Errors.networkError(operation, cause, {
+				provider: "indexer",
+				failure_mode: "upstream-down"
+			});
+		}
+		if (!response.ok) throw httpError(operation, response.status, await safeText(response));
+		return response;
+	}
+	/**
+	* Follow the live stream until the caller unsubscribes or the indexer closes
+	* it. The indexer closes the stream on token expiry or revoked authority
+	* with no frame, so any end the caller did not ask for is a teardown: it
+	* reaches `captureException` under `activity.subscribe` and the caller sees
+	* one `error` snapshot.
+	*/
+	async #stream(table, input, operation, callback, stopped) {
+		let failure;
+		try {
+			const response = await this.#request("live", table, input, operation);
+			if (response.body === null) throw Errors.providerError("indexer", operation, "empty stream");
+			await readEventStream(response.body, (data) => {
+				try {
+					callback({
+						status: "ok",
+						value: decodeRows(table, JSON.parse(data))
+					});
+				} catch (cause) {
+					failure = toPublicError$1(operation, cause);
+				}
+			}, () => stopped() || failure !== void 0);
+		} catch (cause) {
+			failure = toPublicError$1(operation, cause);
+		}
+		if (stopped()) return;
+		const error = failure ?? Errors.capabilityUnavailable("indexer", operation);
+		observeStreamFailure(this.#observation, CAPXUL_OPERATIONS.activity.subscribe, error);
+		callback({
+			status: "error",
+			error
+		});
+	}
+};
+/**
+* Map an indexer refusal into the shared error vocabulary.
+*
+* 401 is the expected outcome of an expired or revoked session. 403 is not:
+* the indexer accepts only its own compiled statements for a Safe in the
+* claim, so a refusal means this SDK and that deployment disagree, or the
+* session gained a Safe and still holds the older token. Both must be loud.
+*/
+function httpError(operation, status, body) {
+	if (status === 401) return Errors.notAuthenticated();
+	if (status === 429) return Errors.rateLimited({ resource: "indexer" });
+	if (status === 503) return Errors.capabilityUnavailable("indexer", operation);
+	return Errors.providerError("indexer", operation, body, {
+		httpStatus: status,
+		...status >= 500 ? { failure_mode: "upstream-down" } : {},
+		details: { reason: status === 403 ? "scope-refused" : "http-status" }
+	});
+}
+function toPublicError$1(operation, cause) {
+	if (cause instanceof CapxulError) return cause;
+	return Errors.providerError("indexer", operation, cause);
+}
+function toIndexerReadError(operation, cause) {
+	if (cause instanceof IndexerReadError) return cause;
+	return indexerReadErrorFromCapxul(operation, toPublicError$1(operation, cause), cause);
+}
+async function safeText(response) {
+	try {
+		return await response.text();
+	} catch {
+		return "";
+	}
+}
 const SDK_VERSION = version;
 /**
 * Project the built graph into the flat `FlowPorts` record the method bundles
@@ -14113,7 +14579,16 @@ async function createProductionAdapters(input) {
 		}));
 		const applicationLayer = Layer.merge(portsLayer, optionalEngineeringTelemetryLayer(bootstrapResult.value.engineeringTelemetry, resolvedInput.value.runtime));
 		const context = await Effect.runPromise(Layer.buildWithScope(applicationLayer, scope));
-		const ports = await Effect.runPromise(collectProductionFlowPorts.pipe(Effect.provide(context)));
+		const collected = await Effect.runPromise(collectProductionFlowPorts.pipe(Effect.provide(context)));
+		const indexerUrl = input.indexerUrl ?? bootstrapResult.value.indexerUrl;
+		const indexerRead = productionIndexerReadPort(indexerUrl === void 0 ? input : {
+			...input,
+			indexerUrl
+		}, collected, observation);
+		const ports = indexerRead === void 0 ? collected : {
+			...collected,
+			indexerRead
+		};
 		const stopConnectionObservation = observeProductionConvexConnection(ports.convexCall, context);
 		const close = idempotentClose(async () => {
 			try {
@@ -14445,5 +14920,27 @@ function idempotentClose(close) {
 		await close();
 	};
 }
+/**
+* Build the Ponder read port for this client, or `undefined` when no indexer
+* origin was supplied. The token provider is the same
+* `AuthClientPort.getConvexJwt` closure `ConvexCallPort` uses, so the indexer
+* and Convex see one session with one scope.
+*/
+function productionIndexerReadPort(input, ports, observation) {
+	if (input.indexerUrl === void 0 || input.indexerUrl === "") return void 0;
+	return new PonderIndexerAdapter({
+		baseUrl: normalizeHttpUrl("indexerUrl", input.indexerUrl),
+		token: async ({ forceRefreshToken }) => {
+			const token = await Effect.runPromise(Effect.result(ports.authClient.getConvexJwt({
+				forceRefresh: forceRefreshToken,
+				...input.signal === void 0 ? {} : { signal: input.signal }
+			})));
+			if (Result.isFailure(token)) return null;
+			return String(token.success.token);
+		},
+		...input.fetch === void 0 ? {} : { fetch: input.fetch },
+		...observation === void 0 ? {} : { observation }
+	});
+}
 //#endregion
 export { signerFailure as A, isRestoring as B, normalizeExceptionErrorKind as C, fromWei as D, safeExceptionLabel as E, CAPXUL_OPERATIONS as F, isCapxulOperation as I, normalizeCapxulOperation as L, PAYMENT_DIRECTIONS as M, PAYMENT_STATUSES as N, isSettingUpLifecycle as O, redactTelemetryEvent as P, destination as R, SDK_VERSION$1 as S, projectSdkException as T, fingerprintPaymentIntent as _, smartAccountErrorFromCapxul as a, failureDetail as b, identityErrorFromCapxul as c, embeddedSigner as d, openfortEmbeddedSigner as f, devPrivateKeySigner as g, deriveDevPrivateKey as h, assembleCapxulClient as i, resolveFailureMode as j, injectedWalletSigner as k, convexCallErrorFromCapxul as l, openfortEmbeddedWalletPort as m, createCapxulClientWithSignerControls as n, accountReadErrorFromCapxul as o, openfortEmbeddedSignerFromWallet as p, postHogObservability as r, wireChainId as s, createCapxulClient as t, bootstrapErrorFromCapxul as u, toWei as v, normalizeExceptionOperation as w, EXCEPTION_MESSAGE as x, CAPXUL_SDK_EXPECTED_OUTCOME_EVENT as y, isClaimed as z };