@robelest/convex-auth 0.0.4-preview.27 → 0.0.4-preview.28

package/dist/client/index.js

@@ -1,4 +1,5 @@
 import { LOG_LEVELS, logMessage } from "../shared/log.js";
+import { createDeferred } from "./core/types.js";
 import { createHandshakeError } from "./errors.js";
 import { createDeviceClient } from "./factors/device.js";
 import { createTotpClient } from "./factors/totp.js";
@@ -8,10 +9,9 @@ import { isRetriableProxyRefreshError, isTransientNetworkError, parseProxyErrorB
 import { createStorageHelpers } from "./runtime/storage.js";
 import { ClientAdapterFactoriesLive, ClientAdaptersLive } from "./services/adapters.js";
 import { ClientHttpLive } from "./services/http.js";
-import { ClientRuntimeLive } from "./services/runtime.js";
 import { resolveClientServices } from "./services/resolve.js";
+import { ClientRuntimeLive } from "./services/runtime.js";
 import { ConvexError } from "convex/values";
-import { Cause, Deferred, Effect, Exit, Layer, Match, Ref, Schedule } from "effect";
 
 //#region src/client/index.ts
 const VERIFIER_STORAGE_KEY = "__convexAuthOAuthVerifier";
@@ -22,18 +22,16 @@ const INVITE_EMAIL_KEY = "__convexAuthPendingInviteEmail";
 const RETRY_BASE_MS = 500;
 const RETRY_MAX_RETRIES = 2;
 const AUTH_HANDSHAKE_TIMEOUT_MS = 5e3;
-const RETRY_SCHEDULE = Schedule.both(Schedule.jittered(Schedule.exponential(`${RETRY_BASE_MS} millis`)), Schedule.recurs(RETRY_MAX_RETRIES));
-function logClientErrorCause(message, cause) {
-	logMessage("convex-auth/client", LOG_LEVELS.ERROR, [message, Cause.squash(cause)]);
-}
-function runPromiseBoundary(program) {
-	return Effect.runPromiseExit(program).then(Exit.match({
-		onSuccess: (value) => value,
-		onFailure: (cause) => Promise.reject(Cause.squash(cause))
-	}));
-}
-function runDetached(program, message) {
-	Effect.runFork(program.pipe(Effect.catchCause((cause) => Effect.sync(() => logClientErrorCause(message, cause)))));
+async function retryWithJitteredBackoff(fn, shouldRetry) {
+	let attempt = 0;
+	while (true) try {
+		return await fn();
+	} catch (error) {
+		if (attempt >= RETRY_MAX_RETRIES || !shouldRetry(error)) throw error;
+		const jitter = RETRY_BASE_MS * Math.pow(2, attempt) * (.5 + Math.random());
+		await new Promise((resolve) => setTimeout(resolve, jitter));
+		attempt++;
+	}
 }
 /**
 * Resolve the Convex deployment URL from the client.
@@ -104,7 +102,12 @@ function buildSignInRequestKey(provider, params) {
 function client(options) {
 	const { convex, proxyPath, api: apiRefs } = options;
 	const proxy = proxyPath;
-	const services = resolveClientServices(Layer.mergeAll(ClientRuntimeLive(options.runtime ?? {}), ClientAdaptersLive(options.adapters ?? {}), ClientAdapterFactoriesLive(options.adapterFactories ?? {}), ClientHttpLive(proxy ? null : options.httpClient ?? null)));
+	const services = resolveClientServices({
+		runtime: ClientRuntimeLive(options.runtime ?? {}),
+		adapters: ClientAdaptersLive(options.adapters ?? {}),
+		adapterFactories: ClientAdapterFactoriesLive(options.adapterFactories ?? {}),
+		http: ClientHttpLive(proxy ? null : options.httpClient ?? null)
+	});
 	const runtime = services.runtime;
 	const adapters = services.adapters;
 	function requireProxyRuntime() {
@@ -183,7 +186,6 @@ function client(options) {
 		}
 	};
 	const subscribers = /* @__PURE__ */ new Set();
-	const subscribersRef = Ref.makeUnsafe(subscribers);
 	let disposeStorageListener = null;
 	const httpClient = services.httpClient;
 	const serverToken = typeof options.tokenSeed === "string" && options.tokenSeed.trim().length > 0 ? options.tokenSeed : null;
@@ -196,20 +198,20 @@ function client(options) {
 	let destroyed = false;
 	let activeSignIn = null;
 	const handshakeWaiters = /* @__PURE__ */ new Set();
-	const snapshotRef = Ref.makeUnsafe({
+	let snapshot = {
 		phase: hasServerToken ? "authenticated" : isLoading ? "loading" : "unauthenticated",
 		isLoading,
 		isAuthenticated: hasServerToken,
 		token
-	});
+	};
 	let handlingCodeFlow = false;
 	const settleHandshakeWaiters = (epoch, outcome) => {
 		for (const waiter of Array.from(handshakeWaiters)) {
 			if (waiter.epoch !== epoch) continue;
 			clearTimeout(waiter.timeoutId);
 			handshakeWaiters.delete(waiter);
-			if (outcome.type === "resolve") Effect.runSync(Deferred.succeed(waiter.deferred, void 0));
-			else Effect.runSync(Deferred.fail(waiter.deferred, outcome.error));
+			if (outcome.type === "resolve") waiter.deferred.resolve(void 0);
+			else waiter.deferred.reject(outcome.error);
 		}
 	};
 	const rejectObsoleteHandshakeWaiters = (activeEpoch) => {
@@ -217,10 +219,10 @@ function client(options) {
 			if (waiter.epoch >= activeEpoch) continue;
 			clearTimeout(waiter.timeoutId);
 			handshakeWaiters.delete(waiter);
-			Effect.runSync(Deferred.fail(waiter.deferred, createHandshakeError("AUTH_HANDSHAKE_REJECTED", {
+			waiter.deferred.reject(createHandshakeError("AUTH_HANDSHAKE_REJECTED", {
 				...waiter.context,
 				reason: "token_changed"
-			})));
+			}));
 		}
 	};
 	const waitForAuthHandshake = async (context) => {
@@ -231,22 +233,22 @@ function client(options) {
 			reason: "auth_rejected"
 		});
 		const epoch = authEpoch;
-		const deferred = Deferred.makeUnsafe();
+		const deferred = createDeferred();
 		const waiter = {
 			epoch,
 			context,
 			deferred,
 			timeoutId: setTimeout(() => {
 				handshakeWaiters.delete(waiter);
-				Effect.runSync(Deferred.fail(deferred, createHandshakeError("AUTH_HANDSHAKE_TIMEOUT", {
+				deferred.reject(createHandshakeError("AUTH_HANDSHAKE_TIMEOUT", {
 					...context,
 					timeoutMs: AUTH_HANDSHAKE_TIMEOUT_MS
-				})));
+				}));
 			}, AUTH_HANDSHAKE_TIMEOUT_MS)
 		};
 		handshakeWaiters.add(waiter);
 		try {
-			await Effect.runPromise(Deferred.await(deferred));
+			await deferred.promise;
 		} finally {
 			clearTimeout(waiter.timeoutId);
 			handshakeWaiters.delete(waiter);
@@ -262,24 +264,18 @@ function client(options) {
 		if (updateSnapshot()) notify();
 	};
 	const notify = () => {
-		for (const cb of Ref.getUnsafe(subscribersRef)) cb();
+		for (const cb of subscribers) cb();
 	};
 	const updateSnapshot = () => {
-		const phase = {
-			handshake: "handshake",
-			loading: "loading",
-			authenticated: "authenticated",
-			unauthenticated: "unauthenticated"
-		}[{ tag: token !== null && handshakePending ? "handshake" : isLoading ? "loading" : token !== null && authConfirmed ? "authenticated" : "unauthenticated" }.tag];
+		const phase = token !== null && handshakePending ? "handshake" : isLoading ? "loading" : token !== null && authConfirmed ? "authenticated" : "unauthenticated";
 		const next = {
 			phase,
 			isLoading: phase === "loading" || phase === "handshake",
 			isAuthenticated: phase === "authenticated",
 			token
 		};
-		const snapshot = Ref.getUnsafe(snapshotRef);
 		if (snapshot.phase === next.phase && snapshot.isLoading === next.isLoading && snapshot.isAuthenticated === next.isAuthenticated && snapshot.token === next.token) return false;
-		Effect.runSync(Ref.set(snapshotRef, next));
+		snapshot = next;
 		return true;
 	};
 	const finalizeLoadingState = () => {
@@ -357,16 +353,10 @@ function client(options) {
 	};
 	const passkeyAdapter = adapters.passkey ?? services.adapterFactories.passkey?.(adapterDeps);
 	const verifyCode = async (args) => {
-		return runPromiseBoundary(Effect.tryPromise({
-			try: () => requireHttpClient().action(requireApiRefs().signIn, "code" in args ? {
-				params: { code: args.code },
-				verifier: args.verifier
-			} : args),
-			catch: (error) => error
-		}).pipe(Effect.map((result) => result), Effect.retry({
-			schedule: RETRY_SCHEDULE,
-			while: isTransientNetworkError
-		})));
+		return retryWithJitteredBackoff(() => requireHttpClient().action(requireApiRefs().signIn, "code" in args ? {
+			params: { code: args.code },
+			verifier: args.verifier
+		} : args), isTransientNetworkError);
 	};
 	const verifyCodeAndSetToken = async (args, opts) => {
 		const result = await verifyCode(args);
@@ -430,27 +420,28 @@ function client(options) {
 		})() : args ?? {};
 		const flow = typeof params.flow === "string" && params.flow.length > 0 ? params.flow : "signIn";
 		const signInKey = buildSignInRequestKey(provider, params);
-		const handleSignInActionResult = async (result, options$1) => runPromiseBoundary(Match.value(result).pipe(Match.when({ kind: "redirect" }, (redirectResult) => Effect.gen(function* () {
-			const redirectUrl = new URL(redirectResult.redirect);
-			if (options$1.persistVerifier) yield* Effect.promise(() => storageSet(VERIFIER_STORAGE_KEY, redirectResult.verifier));
-			if (runtime.location) yield* Effect.promise(async () => {
-				await runtime.location.redirect(redirectUrl);
-			});
-			return {
-				kind: "redirect",
-				redirect: redirectUrl,
-				verifier: redirectResult.verifier
+		const handleSignInActionResult = async (result, resultOptions) => {
+			if (result.kind === "redirect") {
+				const redirectUrl = new URL(result.redirect);
+				if (resultOptions.persistVerifier) await storageSet(VERIFIER_STORAGE_KEY, result.verifier);
+				if (runtime.location) await runtime.location.redirect(redirectUrl);
+				return {
+					kind: "redirect",
+					redirect: redirectUrl,
+					verifier: result.verifier
+				};
+			}
+			if (result.kind === "totpRequired") return {
+				kind: "totpRequired",
+				verifier: result.verifier
+			};
+			if (result.kind === "deviceCode") return {
+				kind: "deviceCode",
+				deviceCode: normalizeDeviceCodeResult(result.deviceCode)
 			};
-		})), Match.when({ kind: "totpRequired" }, (totpRequiredResult) => Effect.succeed({
-			kind: "totpRequired",
-			verifier: totpRequiredResult.verifier
-		})), Match.when({ kind: "deviceCode" }, (deviceCodeResult) => Effect.succeed({
-			kind: "deviceCode",
-			deviceCode: normalizeDeviceCodeResult(deviceCodeResult.deviceCode)
-		})), Match.when({ kind: "signedIn" }, (signedInResult) => Effect.gen(function* () {
-			return (yield* Effect.promise(() => setTokenAndMaybeWait(options$1.shouldStore ? {
+			if (result.kind === "signedIn") return await setTokenAndMaybeWait(resultOptions.shouldStore ? {
 				shouldStore: true,
-				tokens: signedInResult.tokens,
+				tokens: result.tokens,
 				waitForHandshake: true,
 				context: {
 					provider,
@@ -458,46 +449,41 @@ function client(options) {
 				}
 			} : {
 				shouldStore: false,
-				tokens: signedInResult.tokens === null ? null : { token: signedInResult.tokens.token },
+				tokens: result.tokens === null ? null : { token: result.tokens.token },
 				waitForHandshake: true,
 				context: {
 					provider,
 					flow
 				}
-			}))) ? { kind: "signedIn" } : { kind: "started" };
-		})), Match.when({ kind: "started" }, () => Effect.succeed({ kind: "started" })), Match.when({ kind: "passkeyOptions" }, () => Effect.succeed({ kind: "started" })), Match.when({ kind: "totpSetup" }, () => Effect.succeed({ kind: "started" })), Match.exhaustive));
+			}) ? { kind: "signedIn" } : { kind: "started" };
+			return { kind: "started" };
+		};
 		if (activeSignIn !== null) {
 			if (activeSignIn.key === signInKey) return await activeSignIn.promise;
 			throw new Error("Another sign-in flow is already in progress.");
 		}
-		const signInPromise = runPromiseBoundary(Effect.tryPromise({
-			try: async () => {
-				if (proxy) return await handleSignInActionResult(await proxyFetch({
-					action: "auth:signIn",
-					args: {
-						provider,
-						params
-					}
-				}), {
-					shouldStore: false,
-					persistVerifier: false
-				});
-				const verifier = await storageGet(VERIFIER_STORAGE_KEY) ?? void 0;
-				await storageRemove(VERIFIER_STORAGE_KEY);
-				return await handleSignInActionResult(await convex.action(requireApiRefs().signIn, {
+		const signInPromise = (async () => {
+			if (proxy) return await handleSignInActionResult(await proxyFetch({
+				action: "auth:signIn",
+				args: {
 					provider,
-					params,
-					verifier
-				}), {
-					shouldStore: true,
-					persistVerifier: true
-				});
-			},
-			catch: (error) => error
-		}).pipe(Effect.withSpan("convex-auth.client.signIn", { attributes: {
-			provider: provider ?? "code",
-			proxy: proxy !== void 0
-		} })));
+					params
+				}
+			}), {
+				shouldStore: false,
+				persistVerifier: false
+			});
+			const verifier = await storageGet(VERIFIER_STORAGE_KEY) ?? void 0;
+			await storageRemove(VERIFIER_STORAGE_KEY);
+			return await handleSignInActionResult(await convex.action(requireApiRefs().signIn, {
+				provider,
+				params,
+				verifier
+			}), {
+				shouldStore: true,
+				persistVerifier: true
+			});
+		})();
 		activeSignIn = {
 			key: signInKey,
 			promise: signInPromise
@@ -516,32 +502,28 @@ function client(options) {
 	* signed-out user is a no-op.
 	*/
 	const signOut = async () => {
-		await runPromiseBoundary(Effect.gen(function* () {
-			if (proxy) {
-				yield* Effect.tryPromise({
-					try: () => proxyFetch({
-						action: "auth:signOut",
-						args: {}
-					}),
-					catch: () => void 0
-				}).pipe(Effect.catch(() => Effect.succeed(void 0)));
-				yield* Effect.promise(() => setToken({
-					shouldStore: false,
-					tokens: null
-				}));
-				if (convex.clearAuth) convex.clearAuth();
-				return;
-			}
-			yield* Effect.tryPromise({
-				try: () => convex.action(requireApiRefs().signOut, {}),
-				catch: () => void 0
-			}).pipe(Effect.catch(() => Effect.succeed(void 0)));
-			yield* Effect.promise(() => setToken({
-				shouldStore: true,
+		if (proxy) {
+			try {
+				await proxyFetch({
+					action: "auth:signOut",
+					args: {}
+				});
+			} catch {}
+			await setToken({
+				shouldStore: false,
 				tokens: null
-			}));
+			});
 			if (convex.clearAuth) convex.clearAuth();
-		}).pipe(Effect.withSpan("convex-auth.client.signOut")));
+			return;
+		}
+		try {
+			await convex.action(requireApiRefs().signOut, {});
+		} catch {}
+		await setToken({
+			shouldStore: true,
+			tokens: null
+		});
+		if (convex.clearAuth) convex.clearAuth();
 	};
 	const fetchAccessToken = async ({ forceRefreshToken }) => {
 		if (!forceRefreshToken) return token;
@@ -551,27 +533,25 @@ function client(options) {
 			const tokenBeforeRefresh = token;
 			return await withMutex("__convexAuthProxyRefresh", async () => {
 				if (token !== tokenBeforeRefresh) return token;
-				await runPromiseBoundary(Effect.tryPromise({
-					try: () => proxyFetch({
+				try {
+					const result = await retryWithJitteredBackoff(() => proxyFetch({
 						action: "auth:signIn",
 						args: { refreshToken: true }
-					}),
-					catch: (error) => error
-				}).pipe(Effect.retry({
-					schedule: RETRY_SCHEDULE,
-					while: isRetriableProxyRefreshError
-				}), Effect.flatMap((result) => Effect.promise(() => isSignedInResult(result) && result.tokens ? setToken({
-					shouldStore: false,
-					tokens: { token: result.tokens.token },
-					resyncConvexAuth: false
-				}) : setToken({
-					shouldStore: false,
-					tokens: null,
-					resyncConvexAuth: false
-				}))), Effect.catch((error) => Effect.sync(() => {
+					}), isRetriableProxyRefreshError);
+					if (isSignedInResult(result) && result.tokens) await setToken({
+						shouldStore: false,
+						tokens: { token: result.tokens.token },
+						resyncConvexAuth: false
+					});
+					else await setToken({
+						shouldStore: false,
+						tokens: null,
+						resyncConvexAuth: false
+					});
+				} catch (error) {
 					logMessage("convex-auth/client", LOG_LEVELS.ERROR, ["[convex-auth] Proxy refresh failed:", error]);
 					if (token === null) finalizeLoadingState();
-				}))).pipe(Effect.withSpan("convex-auth.client.refresh.proxy")));
+				}
 				return token;
 			});
 		}
@@ -584,7 +564,7 @@ function client(options) {
 				finalizeLoadingState();
 				return null;
 			}
-			await runPromiseBoundary(Effect.promise(() => verifyCodeAndSetToken({ refreshToken }, { resyncConvexAuth: false })).pipe(Effect.withSpan("convex-auth.client.refresh.local")));
+			await verifyCodeAndSetToken({ refreshToken }, { resyncConvexAuth: false });
 			return token;
 		});
 	};
@@ -595,18 +575,14 @@ function client(options) {
 		const code = location.searchParams.get("code");
 		if (!code) return;
 		handlingCodeFlow = true;
-		await runPromiseBoundary(Effect.tryPromise({
-			try: async () => {
-				await signIn(void 0, { code });
-				const codeUrl = new URL(location.toString());
-				codeUrl.searchParams.delete("code");
-				await replaceUrl(codeUrl.pathname + codeUrl.search + codeUrl.hash);
-			},
-			catch: () => void 0
-		}).pipe(Effect.catch(() => Effect.succeed(void 0)), Effect.ensuring(Effect.sync(() => {
+		try {
+			await signIn(void 0, { code });
+			const codeUrl = new URL(location.toString());
+			codeUrl.searchParams.delete("code");
+			await replaceUrl(codeUrl.pathname + codeUrl.search + codeUrl.hash);
+		} catch {} finally {
 			handlingCodeFlow = false;
-		}))));
-		handlingCodeFlow = false;
+		}
 	};
 	const hydrateFromStorage = async () => {
 		const storedToken = await storageGet(JWT_STORAGE_KEY) ?? null;
@@ -627,32 +603,44 @@ function client(options) {
 	* @returns An unsubscribe function.
 	*/
 	const onChange = (cb) => {
-		cb(Ref.getUnsafe(snapshotRef));
-		const wrapped = () => cb(Ref.getUnsafe(snapshotRef));
-		Ref.getUnsafe(subscribersRef).add(wrapped);
+		cb(snapshot);
+		const wrapped = () => cb(snapshot);
+		subscribers.add(wrapped);
 		return () => {
-			Ref.getUnsafe(subscribersRef).delete(wrapped);
+			subscribers.delete(wrapped);
 		};
 	};
 	if (!proxy && runtime.sync) disposeStorageListener = runtime.sync.subscribe(key(JWT_STORAGE_KEY), (value) => {
-		runDetached(Effect.promise(() => setToken({
+		setToken({
 			shouldStore: false,
 			tokens: value === null ? null : { token: value }
-		})), "[convex-auth] Storage event handler failed:");
+		}).catch((error) => {
+			logMessage("convex-auth/client", LOG_LEVELS.ERROR, ["[convex-auth] Storage event handler failed:", error]);
+		});
 	}) ?? null;
 	bindConvexAuth();
 	if (proxy) {
-		if (!hasServerToken && runtime.environment !== "server") runDetached(Effect.promise(() => fetchAccessToken({ forceRefreshToken: true })), "[convex-auth] Proxy token refresh failed:");
-	} else runDetached(Effect.promise(async () => {
-		await hydrateFromStorage();
-		await handleCodeFlow();
-	}).pipe(Effect.catch(() => Effect.promise(() => setToken({
-		shouldStore: false,
-		tokens: null
-	})).pipe(Effect.catch(() => Effect.succeed(void 0))))), "[convex-auth] SPA initialization failed:");
+		if (!hasServerToken && runtime.environment !== "server") fetchAccessToken({ forceRefreshToken: true }).catch((error) => {
+			logMessage("convex-auth/client", LOG_LEVELS.ERROR, ["[convex-auth] Proxy token refresh failed:", error]);
+		});
+	} else (async () => {
+		try {
+			await hydrateFromStorage();
+			await handleCodeFlow();
+		} catch {
+			try {
+				await setToken({
+					shouldStore: false,
+					tokens: null
+				});
+			} catch {}
+		}
+	})().catch((error) => {
+		logMessage("convex-auth/client", LOG_LEVELS.ERROR, ["[convex-auth] SPA initialization failed:", error]);
+	});
 	return {
 		get state() {
-			return Ref.getUnsafe(snapshotRef);
+			return snapshot;
 		},
 		param,
 		get invite() {
@@ -688,7 +676,7 @@ function client(options) {
 				error: createHandshakeError("AUTH_HANDSHAKE_REJECTED", { reason: "destroyed" })
 			});
 			disposeStorageListener?.();
-			Ref.getUnsafe(subscribersRef).clear();
+			subscribers.clear();
 		},
 		...passkeyAdapter ? { passkey: passkeyAdapter } : {}
 	};

package/dist/client/runtime/proxy.js

@@ -1,12 +1,7 @@
 import { ConvexError } from "convex/values";
-import { Schema } from "effect";
 
 //#region src/client/runtime/proxy.ts
 const NETWORK_ERROR_PATTERN = /(network|fetch|load failed|failed to fetch)/i;
-const ProxyErrorBodySchema = Schema.Struct({
-	error: Schema.optional(Schema.String),
-	authError: Schema.optional(Schema.Unknown)
-});
 /** @internal */
 function isTransientNetworkError(error) {
 	return error instanceof TypeError || error instanceof Error && NETWORK_ERROR_PATTERN.test(error.message || "");
@@ -22,7 +17,12 @@ function isRetriableProxyRefreshError(error) {
 }
 /** @internal */
 function parseProxyErrorBody(value) {
-	return Schema.decodeUnknownSync(ProxyErrorBodySchema)(value);
+	if (typeof value !== "object" || value === null) return {};
+	const obj = value;
+	return {
+		error: typeof obj.error === "string" ? obj.error : void 0,
+		authError: obj.authError
+	};
 }
 
 //#endregion

package/dist/client/services/adapters.js

@@ -1,11 +1,7 @@
-import { Layer, ServiceMap } from "effect";
-
 //#region src/client/services/adapters.ts
-var ClientAdaptersService = class extends ServiceMap.Service()("ClientAdaptersService") {};
-var ClientAdapterFactoriesService = class extends ServiceMap.Service()("ClientAdapterFactoriesService") {};
-const ClientAdaptersLive = (adapters) => Layer.succeed(ClientAdaptersService)(adapters);
-const ClientAdapterFactoriesLive = (adapterFactories) => Layer.succeed(ClientAdapterFactoriesService)(adapterFactories);
+const ClientAdaptersLive = (adapters) => adapters;
+const ClientAdapterFactoriesLive = (adapterFactories) => adapterFactories;
 
 //#endregion
-export { ClientAdapterFactoriesLive, ClientAdapterFactoriesService, ClientAdaptersLive, ClientAdaptersService };
+export { ClientAdapterFactoriesLive, ClientAdaptersLive };
 //# sourceMappingURL=adapters.js.map

package/dist/client/services/http.js

@@ -1,9 +1,6 @@
-import { Layer, ServiceMap } from "effect";
-
 //#region src/client/services/http.ts
-var ClientHttpService = class extends ServiceMap.Service()("ClientHttpService") {};
-const ClientHttpLive = (httpClient) => Layer.succeed(ClientHttpService)({ httpClient });
+const ClientHttpLive = (httpClient) => ({ httpClient });
 
 //#endregion
-export { ClientHttpLive, ClientHttpService };
+export { ClientHttpLive };
 //# sourceMappingURL=http.js.map

package/dist/client/services/resolve.js

@@ -1,16 +1,10 @@
-import { ClientAdapterFactoriesService, ClientAdaptersService } from "./adapters.js";
-import { ClientHttpService } from "./http.js";
-import { ClientRuntimeService } from "./runtime.js";
-import { Effect, Layer, ServiceMap } from "effect";
-
 //#region src/client/services/resolve.ts
-function resolveClientServices(layer) {
-	const context = Effect.runSync(Effect.scoped(Layer.build(layer)));
+function resolveClientServices(input) {
 	return {
-		runtime: ServiceMap.getUnsafe(context, ClientRuntimeService),
-		adapters: ServiceMap.getUnsafe(context, ClientAdaptersService),
-		adapterFactories: ServiceMap.getUnsafe(context, ClientAdapterFactoriesService),
-		httpClient: ServiceMap.getUnsafe(context, ClientHttpService).httpClient
+		runtime: input.runtime,
+		adapters: input.adapters,
+		adapterFactories: input.adapterFactories,
+		httpClient: input.http.httpClient
 	};
 }
 

package/dist/client/services/runtime.js

@@ -1,9 +1,6 @@
-import { Layer, ServiceMap } from "effect";
-
 //#region src/client/services/runtime.ts
-var ClientRuntimeService = class extends ServiceMap.Service()("ClientRuntimeService") {};
-const ClientRuntimeLive = (runtime) => Layer.succeed(ClientRuntimeService)(runtime);
+const ClientRuntimeLive = (runtime) => runtime;
 
 //#endregion
-export { ClientRuntimeLive, ClientRuntimeService };
+export { ClientRuntimeLive };
 //# sourceMappingURL=runtime.js.map