@capxul/sdk 1.0.0-alpha.15 → 1.0.0-alpha.17

package/dist/index.mjs

@@ -1600,7 +1600,7 @@ async function recoverRawDigestSigner(input) {
 }
 //#endregion
 //#region package.json
-var version = "1.0.0-alpha.15";
+var version = "1.0.0-alpha.17";
 //#endregion
 //#region src/ports/auth-client.ts
 var AuthClientError = class extends Data.TaggedError("AuthClientError") {};
@@ -1627,11 +1627,11 @@ function fromResult(operation, run) {
 		})
 	}).pipe(Effect.flatMap((result) => result.ok ? Effect.succeed(result.value) : Effect.fail(new AuthClientError({
 		operation,
-		kind: errorKind(result.error),
+		kind: errorKind$1(result.error),
 		cause: result.error
 	}))));
 }
-function errorKind(error) {
+function errorKind$1(error) {
 	if (error.code === "CANCELLED") return "cancelled";
 	if (error.code === "NETWORK_ERROR") return "network";
 	if (error.code === "INVALID_INPUT" || error.code === "OTP_EXPIRED") return "validation";
@@ -1646,6 +1646,85 @@ function resolveAuthClientUrl(authBaseUrl, path) {
 	return `${base}${path}`;
 }
 //#endregion
+//#region ../wire/src/observation-context.ts
+/** Single bounded HTTP carrier used before a Convex action envelope exists. */
+const OBSERVATION_CONTEXT_HEADER = "x-capxul-observation-context";
+const FIELD_RULES = {
+	application: {
+		maxLength: 64,
+		pattern: /^[A-Za-z0-9][A-Za-z0-9._-]*$/u
+	},
+	applicationId: {
+		maxLength: 30,
+		pattern: APP_ID_RE
+	},
+	release: {
+		maxLength: 128,
+		pattern: /^[A-Za-z0-9][A-Za-z0-9._+@:/-]*$/u
+	},
+	sessionId: {
+		maxLength: 128,
+		pattern: /^[A-Za-z0-9][A-Za-z0-9._:-]*$/u
+	},
+	organizationId: {
+		maxLength: 128,
+		pattern: /^[A-Za-z0-9][A-Za-z0-9._:-]*$/u
+	},
+	correlationId: {
+		maxLength: 128,
+		pattern: /^[A-Za-z0-9][A-Za-z0-9._:-]*$/u
+	},
+	anonymousId: {
+		maxLength: 128,
+		pattern: /^anon_[A-Za-z0-9-]+$/u
+	}
+};
+const EMBEDDED_WALLET_MATERIAL = /0x[a-fA-F0-9]{40,}/u;
+const RAW_PRIVATE_KEY_MATERIAL = /(?:^|[^a-fA-F0-9])[a-fA-F0-9]{64}(?:$|[^a-fA-F0-9])/u;
+const COMPACT_JWT = /eyJ[A-Za-z0-9_-]*\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/u;
+const KNOWN_CREDENTIAL_PREFIX = /(?:(?:sk|pk|rk)_(?:live|test)|(?:phc|phx|ghp|gho|ghu|ghs|ghr|whsec)_|github_pat_|xox[baprs]-|AKIA[0-9A-Z]{16}|AIza)[A-Za-z0-9_-]*/iu;
+/**
+* Copy only the canonical allowlist and silently omit malformed/sensitive
+* values. Observation metadata is best effort and may never reject a domain
+* operation.
+*/
+function sanitizeObservationContext(input) {
+	if (typeof input !== "object" || input === null || Array.isArray(input)) return void 0;
+	const source = input;
+	const sanitized = {};
+	for (const field of Object.keys(FIELD_RULES)) {
+		const value = source[field];
+		if (!isSafeField(field, value)) continue;
+		sanitized[field] = value;
+	}
+	return Object.keys(sanitized).length === 0 ? void 0 : sanitized;
+}
+/** Encode only the sanitized allowlist; absence stays absence. */
+function encodeObservationContextHeader(input) {
+	const sanitized = sanitizeObservationContext(input);
+	return sanitized === void 0 ? void 0 : JSON.stringify(sanitized);
+}
+function isSafeField(field, value) {
+	if (typeof value !== "string") return false;
+	const rule = FIELD_RULES[field];
+	return value.length > 0 && value.length <= rule.maxLength && value === value.trim() && !value.includes("://") && !containsSensitiveMaterial(value) && rule.pattern.test(value);
+}
+function containsSensitiveMaterial(value) {
+	return EMBEDDED_WALLET_MATERIAL.test(value) || RAW_PRIVATE_KEY_MATERIAL.test(value) || COMPACT_JWT.test(value) || KNOWN_CREDENTIAL_PREFIX.test(value);
+}
+//#endregion
+//#region src/internal/observation-http.ts
+/** Resolve one bounded pre-auth snapshot for an outbound SDK HTTP request. */
+function observationRequestHeaders(adapter) {
+	if (adapter === void 0) return {};
+	try {
+		const encoded = encodeObservationContextHeader(adapter.resolveContext?.());
+		return encoded === void 0 ? {} : { [OBSERVATION_CONTEXT_HEADER]: encoded };
+	} catch {
+		return {};
+	}
+}
+//#endregion
 //#region src/adapters/auth-client/BetterAuthBrowserAdapter.ts
 function withSignal$1(init, signal) {
 	return signal === void 0 ? init : {
@@ -1703,8 +1782,10 @@ function mapFetchError$1(operation, err, signal) {
 var BetterAuthBrowserAdapter = class {
 	authBaseUrl;
 	fetchImpl;
+	observation;
 	constructor(deps) {
 		this.authBaseUrl = deps.authBaseUrl.replace(/\/$/, "");
+		this.observation = deps.observation;
 		this.fetchImpl = deps.fetch ?? ((input, init) => globalThis.fetch(input, init));
 	}
 	url(path) {
@@ -1731,7 +1812,10 @@ var BetterAuthBrowserAdapter = class {
 		try {
 			const res = await this.fetchImpl(this.url("/api/auth/email-otp/send-verification-otp"), withSignal$1({
 				method: "POST",
-				headers: { "Content-Type": "application/json" },
+				headers: {
+					"Content-Type": "application/json",
+					...observationRequestHeaders(this.observation)
+				},
 				body: JSON.stringify({
 					email: input.email,
 					type: "sign-in"
@@ -2105,12 +2189,14 @@ var BetterAuthNodeAdapter = class {
 	origin;
 	cookieJar;
 	fetchImpl;
+	observation;
 	constructor(deps) {
 		this.authBaseUrl = deps.authBaseUrl.replace(/\/$/, "");
 		this.host = hostFromBaseUrl(this.authBaseUrl);
 		this.origin = deps.origin?.replace(/\/$/, "");
 		this.cookieJar = deps.cookieJar ?? new CookieJar();
 		this.fetchImpl = deps.fetch ?? fetch;
+		this.observation = deps.observation;
 	}
 	url(path) {
 		return resolveAuthClientUrl(this.authBaseUrl, path);
@@ -2145,7 +2231,8 @@ var BetterAuthNodeAdapter = class {
 				method: "POST",
 				headers: {
 					"content-type": "application/json",
-					...this.origin ? { origin: this.origin } : {}
+					...this.origin ? { origin: this.origin } : {},
+					...observationRequestHeaders(this.observation)
 				},
 				body: JSON.stringify({
 					email: input.email,
@@ -2757,8 +2844,10 @@ async function safeText(res) {
 var HttpBootstrapAdapter = class {
 	bootstrapBaseUrl;
 	fetchImpl;
+	observation;
 	constructor(deps) {
 		this.bootstrapBaseUrl = deps.bootstrapBaseUrl.replace(/\/$/, "");
+		this.observation = deps.observation;
 		this.fetchImpl = deps.fetch ?? ((input, init) => globalThis.fetch(input, init));
 	}
 	resolve(input) {
@@ -2766,7 +2855,8 @@ var HttpBootstrapAdapter = class {
 			try: () => {
 				const headers = {
 					"content-type": "application/json",
-					...input.origin === void 0 ? {} : { origin: input.origin }
+					...input.origin === void 0 ? {} : { origin: input.origin },
+					...observationRequestHeaders(this.observation)
 				};
 				return this.fetchImpl(`${this.bootstrapBaseUrl}/v1/client/bootstrap`, {
 					method: "POST",
@@ -2860,13 +2950,58 @@ function convexCallErrorFromCapxul(operation, error) {
 }
 var ConvexCallPortTag = class extends Context.Tag("@capxul/sdk/ports/ConvexCallPort")() {};
 //#endregion
+//#region src/internal/invocation-observation.ts
+const INVOCATION_OBSERVATION = Symbol("capxul.invocation-observation");
+const FAILURE_INVOCATION_SNAPSHOT = Symbol("capxul.failure-invocation-snapshot");
+/** @internal Attach one immutable, non-wire invocation snapshot to an SDK-owned object. */
+function attachInvocationObservation(target, context) {
+	const snapshot = Object.freeze(context === void 0 ? {} : { context: Object.freeze({ ...context }) });
+	Object.defineProperty(target, INVOCATION_OBSERVATION, {
+		configurable: false,
+		enumerable: false,
+		value: snapshot,
+		writable: false
+	});
+	return target;
+}
+/** @internal Read the snapshot without exposing its symbol or adding a wire field. */
+function readInvocationObservation(source) {
+	if (typeof source !== "object" || source === null) return void 0;
+	return source[INVOCATION_OBSERVATION];
+}
+/** @internal Carry a snapshot across an SDK adapter projection without resolving again. */
+function copyInvocationObservation(source, target) {
+	const snapshot = readInvocationObservation(source);
+	return snapshot === void 0 ? target : attachInvocationObservation(target, snapshot.context);
+}
+/** @internal Mark a failure envelope as already resolved at the public invocation boundary. */
+function markFailureInvocationSnapshot(failure) {
+	Object.defineProperty(failure, FAILURE_INVOCATION_SNAPSHOT, {
+		configurable: false,
+		enumerable: false,
+		value: true,
+		writable: false
+	});
+	return failure;
+}
+/** @internal Distinguish public-boundary failures from direct adapter calls. */
+function hasFailureInvocationSnapshot(failure) {
+	return typeof failure === "object" && failure !== null && failure[FAILURE_INVOCATION_SNAPSHOT] === true;
+}
+//#endregion
 //#region src/adapters/convex-call/ConvexCallAdapter.ts
+/** Exact floor-first allowlist; every additional handler must migrate its validator first. */
+const OBSERVED_CONVEX_ACTIONS = new Set(["subAccount/actions:transfer"]);
 var ConvexCallAdapter = class {
 	#client;
 	#tokenProvider;
+	#applicationId;
+	#observation;
 	constructor(deps) {
 		this.#client = deps.client ?? new ConvexClient(deps.convexUrl);
 		this.#tokenProvider = deps.tokenProvider;
+		this.#applicationId = deps.applicationId;
+		this.#observation = deps.observation;
 		if (this.#tokenProvider) this.#client.setAuth(this.#tokenProvider);
 	}
 	refreshAuth() {
@@ -2885,11 +3020,37 @@ var ConvexCallAdapter = class {
 		});
 	}
 	action(fn, args) {
+		const path = getFunctionName(fn);
 		return Effect.tryPromise({
-			try: () => this.#client.action(fn, args),
-			catch: (cause) => mapToConvexCallError(getFunctionName(fn), cause)
+			try: () => this.#client.action(fn, this.#observedActionArgs(path, args)),
+			catch: (cause) => mapToConvexCallError(path, cause)
 		});
 	}
+	#observedActionArgs(path, args) {
+		if (!OBSERVED_CONVEX_ACTIONS.has(path)) return args;
+		let hostContext;
+		const invocationSnapshot = readInvocationObservation(args);
+		if (invocationSnapshot !== void 0) hostContext = invocationSnapshot.context;
+		else {
+			const resolveContext = this.#observation?.resolveContext;
+			if (resolveContext === void 0) return args;
+			try {
+				hostContext = resolveContext();
+			} catch {
+				return args;
+			}
+		}
+		if (hostContext === void 0) return args;
+		hostContext = sanitizeObservationContext({
+			...hostContext,
+			...this.#applicationId === void 0 ? {} : { applicationId: this.#applicationId }
+		});
+		if (hostContext === void 0) return args;
+		return {
+			...args,
+			observationContext: hostContext
+		};
+	}
 	subscribe(fn, args, callback) {
 		return Effect.try({
 			try: () => {
@@ -3661,12 +3822,12 @@ var ConvexSubAccountAdapter = class {
 		const operation = "transfer";
 		return Effect.suspend(() => {
 			const rawAmount = toWei(input.amount);
-			return this.#convex.action(this.#fns.transfer, {
+			return this.#convex.action(this.#fns.transfer, copyInvocationObservation(input, {
 				chainId: this.#chainId,
 				from: input.from,
 				to: input.to,
 				rawAmount
-			});
+			}));
 		}).pipe(Effect.mapError((error) => subAccountErrorFromCapxul(operation, error.publicError, error)), Effect.map((wire) => brandTransferResult(wire)), Effect.catchAllDefect((cause) => Effect.fail(subAccountErrorFromUnknown(operation, cause))));
 	}
 	#runMutation(operation, ref, args) {
@@ -3963,6 +4124,10 @@ const TransferRequestedProps = Schema.Struct({
 	amount: OptionalWeiAmount,
 	direction: OptionalTransferDirection
 });
+const TransferBackendReceivedProps = Schema.Struct({
+	...TelemetryEnvelopeProps,
+	direction: OptionalTransferDirection
+});
 const TransferConfirmedProps = Schema.Struct({
 	...TelemetryEnvelopeProps,
 	amount: OptionalWeiAmount,
@@ -4179,6 +4344,10 @@ Schema.Struct({
 	name: Schema.Literal("transfer_requested"),
 	props: Schema.optional(TransferRequestedProps)
 });
+Schema.Struct({
+	name: Schema.Literal("transfer_backend_received"),
+	props: Schema.optional(TransferBackendReceivedProps)
+});
 Schema.Struct({
 	name: Schema.Literal("transfer_confirmed"),
 	props: Schema.optional(TransferConfirmedProps)
@@ -7854,6 +8023,271 @@ function assembleCapxulClient(input) {
 		}
 	};
 }
+//#endregion
+//#region src/observation.ts
+const SDK_VERSION$1 = version;
+/** Stable PostHog event used for typed failures that are expected product outcomes. */
+const CAPXUL_SDK_EXPECTED_OUTCOME_EVENT = "capxul_sdk_expected_outcome";
+const EXPECTED_OPERATION_OUTCOMES = new Set([
+	"INVALID_INPUT",
+	"NOT_AUTHENTICATED",
+	"CANCELLED",
+	"SIGNER_REJECTED",
+	"VERIFICATION_REQUIRED",
+	"INSUFFICIENT_BALANCE",
+	"INVALID_RECIPIENT",
+	"ROLE_PERMISSION_DENIED",
+	"RATE_LIMITED",
+	"OTP_EXPIRED",
+	"WRONG_STATE"
+]);
+/**
+* Adapt the host's already-initialized PostHog-like client. This function does
+* not import, initialize, configure, or own PostHog.
+*/
+function fromPostHog(client, options = {}) {
+	const prepare = (failure) => {
+		if (!isEnabled(options.enabled)) return;
+		if (client === null || client === void 0) return;
+		const safeFailure = sanitizeFailureObservation(failure);
+		return [safeFailure, postHogProperties(safeFailure, hasFailureInvocationSnapshot(failure) ? void 0 : resolveContext(options.context))];
+	};
+	const captureOperationFailure = (failure) => {
+		const prepared = prepare(failure);
+		if (prepared === void 0 || client === null || client === void 0) return;
+		const [safeFailure, properties] = prepared;
+		if (classifyOperationOutcome(safeFailure.errorKind) === "expected") {
+			if (typeof client.capture !== "function") return;
+			deliver(() => client.capture(CAPXUL_SDK_EXPECTED_OUTCOME_EVENT, {
+				...properties,
+				outcome_class: "expected"
+			}));
+			return;
+		}
+		if (typeof client.captureException !== "function") return;
+		deliver(() => client.captureException(safeFailure.exception, properties));
+	};
+	const captureException = (failure) => {
+		const prepared = prepare(failure);
+		if (prepared === void 0 || client === null || client === void 0) return;
+		if (typeof client.captureException !== "function") return;
+		const [safeFailure, properties] = prepared;
+		deliver(() => client.captureException(safeFailure.exception, properties));
+	};
+	return {
+		resolveContext: () => {
+			if (!isEnabled(options.enabled) || client === null || client === void 0) return void 0;
+			return resolveContext(options.context) ?? {};
+		},
+		captureOperationFailure,
+		captureException
+	};
+}
+function classifyOperationOutcome(kind) {
+	return EXPECTED_OPERATION_OUTCOMES.has(kind) ? "expected" : "unexpected";
+}
+function deliver(capture) {
+	try {
+		ignoreDeliveryFailure(capture());
+	} catch {}
+}
+/** @internal Decorates public client method bundles at the owning SDK boundary. */
+function observeSdkClient(client, adapter) {
+	if (adapter === void 0) return client;
+	const objectProxies = /* @__PURE__ */ new WeakMap();
+	const functionWrappers = /* @__PURE__ */ new WeakMap();
+	const wrapObject = (target, path, internal = false) => {
+		const cacheKey = `${internal ? "internal" : "public"}:${path.join(".")}`;
+		let targetProxies = objectProxies.get(target);
+		const cached = targetProxies?.get(cacheKey);
+		if (cached !== void 0) return cached;
+		const proxy = new Proxy(target, { get(currentTarget, property, receiver) {
+			const value = Reflect.get(currentTarget, property, receiver);
+			if (typeof property !== "string") return value;
+			if (path.length === 0 && property === "_internal" && isPlainObject(value)) return wrapInternal(value);
+			if (internal && property !== "accounts") return value;
+			return wrapValue(value, [...path, property], currentTarget);
+		} });
+		if (targetProxies === void 0) {
+			targetProxies = /* @__PURE__ */ new Map();
+			objectProxies.set(target, targetProxies);
+		}
+		targetProxies.set(cacheKey, proxy);
+		return proxy;
+	};
+	const wrapInternal = (target) => wrapObject(target, ["_internal"], true);
+	const wrapValue = (value, path, owner) => {
+		if (typeof value === "function") {
+			const callable = value;
+			const operation = path.join(".");
+			let ownerWrappers = functionWrappers.get(owner);
+			if (ownerWrappers === void 0) {
+				ownerWrappers = /* @__PURE__ */ new Map();
+				functionWrappers.set(owner, ownerWrappers);
+			}
+			const cached = ownerWrappers.get(operation);
+			if (cached !== void 0) return cached;
+			const wrapped = new Proxy(callable, {
+				apply(currentTarget, _thisArg, args) {
+					const invocationContext = resolveAdapterContext(adapter);
+					const invocationArgs = carryInvocationContext(operation, args, invocationContext);
+					let output;
+					try {
+						output = Reflect.apply(currentTarget, owner, invocationArgs);
+					} catch (cause) {
+						report(adapter, "exception", operation, cause, invocationContext);
+						throw cause;
+					}
+					if (isPromiseLike(output)) return Promise.resolve(output).then((result) => processOutput(result, path, invocationContext), (cause) => {
+						report(adapter, "exception", operation, cause, invocationContext);
+						throw cause;
+					});
+					return processOutput(output, path, invocationContext);
+				},
+				get(currentTarget, property) {
+					const attached = Reflect.get(currentTarget, property, currentTarget);
+					if (typeof property !== "string") return attached;
+					return wrapValue(attached, [...path, property], currentTarget);
+				}
+			});
+			ownerWrappers.set(operation, wrapped);
+			return wrapped;
+		}
+		return isPlainObject(value) ? wrapObject(value, path) : value;
+	};
+	const processOutput = (output, path, invocationContext) => {
+		if (isFailedResult(output)) {
+			report(adapter, "operation", path.join("."), output.error, invocationContext);
+			return output;
+		}
+		if (isCapxulResult(output)) return output;
+		return isPlainObject(output) ? wrapObject(output, path) : output;
+	};
+	return wrapObject(client, []);
+}
+function carryInvocationContext(operation, args, context) {
+	if (operation !== "subAccounts.transfer" || !isPlainObject(args[0])) return args;
+	return [attachInvocationObservation({ ...args[0] }, context), ...args.slice(1)];
+}
+/** @internal Reports a factory-level typed failure without changing its identity. */
+function observeFailedResult(result, adapter, operation) {
+	if (adapter !== void 0 && isFailedResult(result)) report(adapter, "operation", operation, result.error, resolveAdapterContext(adapter));
+	return result;
+}
+function report(adapter, kind, operation, cause, invocationContext) {
+	const operationName = normalizeOperation(operation);
+	const kindName = normalizeErrorKind(errorKind(cause));
+	const context = sanitizeObservationContext({
+		...invocationContext,
+		...isCapxulError(cause) && cause.correlationId !== void 0 ? { correlationId: cause.correlationId } : {}
+	});
+	const failure = markFailureInvocationSnapshot({
+		exception: syntheticException(operationName, kindName),
+		sdkVersion: SDK_VERSION$1,
+		operation: operationName,
+		errorKind: kindName,
+		...context === void 0 ? {} : { context }
+	});
+	try {
+		ignoreDeliveryFailure(kind === "operation" ? adapter.captureOperationFailure(failure) : adapter.captureException(failure));
+	} catch {}
+}
+function resolveAdapterContext(adapter) {
+	try {
+		return sanitizeObservationContext(adapter.resolveContext?.());
+	} catch {
+		return;
+	}
+}
+function ignoreDeliveryFailure(delivery) {
+	if (!isPromiseLike(delivery)) return;
+	try {
+		Promise.resolve(delivery).catch(() => void 0);
+	} catch {}
+}
+function postHogProperties(failure, context) {
+	const properties = {
+		sdk_version: failure.sdkVersion,
+		operation: failure.operation,
+		error_kind: failure.errorKind,
+		handled: true
+	};
+	const merged = sanitizeObservationContext({
+		...context,
+		...failure.context
+	});
+	if (merged?.application !== void 0) properties.application = merged.application;
+	if (merged?.release !== void 0) properties.release = merged.release;
+	if (merged?.sessionId !== void 0) properties.session_id = merged.sessionId;
+	if (merged?.organizationId !== void 0) properties.organization_id = merged.organizationId;
+	if (merged?.correlationId !== void 0) properties.correlation_id = merged.correlationId;
+	if (merged?.anonymousId !== void 0) properties.anonymous_id = merged.anonymousId;
+	return properties;
+}
+function resolveContext(context) {
+	try {
+		return sanitizeObservationContext(typeof context === "function" ? context() : context);
+	} catch {
+		return;
+	}
+}
+function isEnabled(enabled) {
+	try {
+		return typeof enabled === "function" ? enabled() : enabled ?? true;
+	} catch {
+		return false;
+	}
+}
+function errorKind(cause) {
+	try {
+		if (isCapxulError(cause)) return normalizeErrorKind(cause.code);
+		if (cause instanceof Error) return normalizeErrorKind(cause.name);
+		return "UnknownFailure";
+	} catch {
+		return "Error";
+	}
+}
+function sanitizeFailureObservation(failure) {
+	const operation = normalizeOperation(failure.operation);
+	const kind = normalizeErrorKind(failure.errorKind);
+	const context = sanitizeObservationContext(failure.context);
+	return {
+		exception: syntheticException(operation, kind),
+		sdkVersion: normalizeSdkVersion(failure.sdkVersion),
+		operation,
+		errorKind: kind,
+		...context === void 0 ? {} : { context }
+	};
+}
+function normalizeSdkVersion(value) {
+	return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9.+_-]{0,127}$/u.test(value) ? value : "unknown";
+}
+function normalizeOperation(value) {
+	return typeof value === "string" && /^[A-Za-z0-9_][A-Za-z0-9_.-]{0,255}$/u.test(value) ? value : "unknown";
+}
+function normalizeErrorKind(value) {
+	return typeof value === "string" && /^[A-Za-z][A-Za-z0-9_.-]{0,63}$/u.test(value) ? value : "Error";
+}
+function syntheticException(operation, kind) {
+	const error = /* @__PURE__ */ new Error("Capxul SDK operation failed");
+	error.name = kind;
+	error.stack = `${kind}: ${error.message}\n    at CapxulSdkBoundary.${operation} (capxul-sdk-observation://boundary/${operation}:1:1)`;
+	return error;
+}
+function isPromiseLike(value) {
+	return (typeof value === "object" || typeof value === "function") && value !== null && typeof value.then === "function";
+}
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+function isCapxulResult(value) {
+	return isPlainObject(value) && typeof value.ok === "boolean";
+}
+function isFailedResult(value) {
+	return isCapxulResult(value) && value.ok === false && "error" in value;
+}
 const SDK_VERSION = version;
 const collectProductionFlowPorts = Effect.gen(function* () {
 	const authClient = yield* AuthClientPortTag;
@@ -7961,11 +8395,13 @@ function productionBootstrapPortLayer(bootstrap) {
 function productionAuthClientLayer(input, refreshConvexAuthRef) {
 	return (input.runtime === "browser" ? BetterAuthBrowserLayer({
 		authBaseUrl: input.runtimeUrls.authBaseUrl,
-		...input.fetch === void 0 ? {} : { fetch: input.fetch }
+		...input.fetch === void 0 ? {} : { fetch: input.fetch },
+		...input.observation === void 0 ? {} : { observation: input.observation }
 	}) : BetterAuthNodeLayer({
 		authBaseUrl: input.runtimeUrls.authBaseUrl,
 		...input.origin === void 0 ? {} : { origin: input.origin },
-		...input.fetch === void 0 ? {} : { fetch: input.fetch }
+		...input.fetch === void 0 ? {} : { fetch: input.fetch },
+		...input.observation === void 0 ? {} : { observation: input.observation }
 	})).pipe(Layer.map((context) => {
 		const authClient = Context.get(context, AuthClientPortTag);
 		return Context.make(AuthClientPortTag, refreshConvexAuthOnSession(authClient, () => {
@@ -7984,6 +8420,8 @@ function productionAuthCacheLayer(input) {
 function productionConvexCallLayer(input, refreshConvexAuthRef) {
 	return Layer.unwrapEffect(Effect.map(AuthClientPortTag, (authClient) => ConvexCallLayer({
 		convexUrl: input.runtimeUrls.convexUrl,
+		...input.applicationId === void 0 ? {} : { applicationId: input.applicationId },
+		...input.observation === void 0 ? {} : { observation: input.observation },
 		...input.convexClient === void 0 ? {} : { client: input.convexClient },
 		tokenProvider: async ({ forceRefreshToken }) => {
 			const tokenResult = await Effect.runPromise(Effect.either(authClient.getConvexJwt({
@@ -8015,7 +8453,8 @@ async function createProductionAdapters(input) {
 	const closeScope = idempotentClose(() => Effect.runPromise(Scope.close(scope, Exit.void)));
 	const bootstrapLayer = HttpBootstrapLayer({
 		bootstrapBaseUrl: resolvedInput.value.bootstrapBaseUrl,
-		...input.fetch === void 0 ? {} : { fetch: input.fetch }
+		...input.fetch === void 0 ? {} : { fetch: input.fetch },
+		...input.observation === void 0 ? {} : { observation: input.observation }
 	});
 	try {
 		const bootstrapContext = await Effect.runPromise(Layer.buildWithScope(bootstrapLayer, scope));
@@ -8073,6 +8512,8 @@ async function createProductionAdapters(input) {
 			...resolvedInput.value.origin === void 0 ? {} : { origin: resolvedInput.value.origin },
 			runtimeUrls: runtimeUrls.value,
 			chainId: bootstrapResult.value.chainId,
+			applicationId: bootstrapResult.value.applicationId,
+			...input.observation === void 0 ? {} : { observation: input.observation },
 			...input.authCache === void 0 ? {} : { authCache: input.authCache },
 			...input.telemetry === void 0 ? {} : { telemetry: input.telemetry },
 			...injectedClient === void 0 ? {} : { convexClient: injectedClient },
@@ -8123,9 +8564,9 @@ function wireOpenfortSignerLifecycle(client, signer) {
 }
 async function createCapxulClient$1(input) {
 	const validation = validateCreateCapxulClientInput(input);
-	if (!validation.ok) return validation;
+	if (!validation.ok) return observeFailedResult(validation, input.observation, "createCapxulClient");
 	const adapters = await createProductionAdapters(input);
-	if (!adapters.ok) return adapters;
+	if (!adapters.ok) return observeFailedResult(adapters, input.observation, "createCapxulClient");
 	try {
 		const runtime = input.runtime ?? detectRuntime();
 		const resolvedAuthBaseUrl = resolveBrowserAuthBaseUrl({
@@ -8151,7 +8592,7 @@ async function createCapxulClient$1(input) {
 		const upstreamClose = adapters.value.close;
 		return {
 			ok: true,
-			value: {
+			value: observeSdkClient({
 				...client,
 				_internal: {
 					...client._internal,
@@ -8160,14 +8601,14 @@ async function createCapxulClient$1(input) {
 						await upstreamClose();
 					}
 				}
-			}
+			}, input.observation)
 		};
 	} catch (cause) {
 		await adapters.value.close().catch(() => void 0);
-		return {
+		return observeFailedResult({
 			ok: false,
 			error: toPublicError(cause, "createCapxulClient")
-		};
+		}, input.observation, "createCapxulClient");
 	}
 }
 function validateCreateCapxulClientInput(input) {
@@ -8309,6 +8750,6 @@ async function createCapxulClient(input) {
 	return createCapxulClient$1(input);
 }
 //#endregion
-export { CapxulError, captureException, captureExceptionSync, createCapxulClient, deriveDevPrivateKey, devPrivateKeySigner, eip1193AccountProvider, embeddedSigner, injectedWalletSigner, isCapxulError, isSettingUpLifecycle, localPrivateKeyAccountProvider, openfortEmbeddedSigner, openfortEmbeddedSignerFromWallet, openfortEmbeddedWalletPort };
+export { CAPXUL_SDK_EXPECTED_OUTCOME_EVENT, CapxulError, captureException, captureExceptionSync, createCapxulClient, deriveDevPrivateKey, devPrivateKeySigner, eip1193AccountProvider, embeddedSigner, fromPostHog, injectedWalletSigner, isCapxulError, isSettingUpLifecycle, localPrivateKeyAccountProvider, openfortEmbeddedSigner, openfortEmbeddedSignerFromWallet, openfortEmbeddedWalletPort };
 
 //# sourceMappingURL=index.mjs.map