@securitydept/client 0.3.0-beta.3 → 0.3.0-beta.5

package/dist/client-environment-CaumNmir.mjs

@@ -1,812 +0,0 @@
-import { n as createSessionStorageStore, t as createLocalStorageStore } from "./web-DQmMqZnR.mjs";
-//#region src/errors/types.ts
-/** Recovery actions the user might take. Aligned with server-side `UserRecovery`. */
-const UserRecovery = {
-	None: "none",
-	Retry: "retry",
-	RestartFlow: "restart_flow",
-	Reauthenticate: "reauthenticate",
-	ContactSupport: "contact_support"
-};
-const ErrorPresentationTone = {
-	Neutral: "neutral",
-	Warning: "warning",
-	Danger: "danger"
-};
-/** Machine-facing error kind discriminator. */
-const ClientErrorKind = {
-	Authorization: "authorization",
-	Transport: "transport",
-	Server: "server",
-	Protocol: "protocol",
-	Presentation: "presentation",
-	Validation: "validation",
-	Storage: "storage",
-	Scheduler: "scheduler",
-	Configuration: "configuration",
-	Unauthenticated: "unauthenticated",
-	Unauthorized: "unauthorized",
-	RedirectRequired: "redirect_required",
-	Cancelled: "cancelled",
-	Timeout: "timeout",
-	Internal: "internal"
-};
-/** Stable source vocabulary for common client error producers. */
-const ClientErrorSource = {
-	Transport: "transport",
-	Server: "server",
-	ClientEnvironment: "client_environment"
-};
-//#endregion
-//#region src/errors/client-error.ts
-function mapServerErrorKind(kind, status) {
-	switch (kind) {
-		case "unauthenticated": return ClientErrorKind.Unauthenticated;
-		case "unauthorized": return ClientErrorKind.Unauthorized;
-		case "unavailable":
-		case "internal": return ClientErrorKind.Server;
-		case "invalid_request":
-		case "conflict": return ClientErrorKind.Protocol;
-		default: return status === 401 ? ClientErrorKind.Unauthenticated : status === 403 ? ClientErrorKind.Unauthorized : status >= 500 ? ClientErrorKind.Server : ClientErrorKind.Protocol;
-	}
-}
-function readServerErrorBody(body) {
-	if (!body || typeof body !== "object") return void 0;
-	const record = body;
-	const error = record.error && typeof record.error === "object" ? record.error : record;
-	return {
-		kind: typeof error.kind === "string" ? error.kind : void 0,
-		code: typeof error.code === "string" ? error.code : void 0,
-		message: typeof error.message === "string" ? error.message : void 0,
-		recovery: typeof error.recovery === "string" ? error.recovery : void 0,
-		presentation: error.presentation && typeof error.presentation === "object" ? {
-			code: typeof error.presentation.code === "string" ? error.presentation.code : void 0,
-			message: typeof error.presentation.message === "string" ? error.presentation.message : void 0,
-			recovery: typeof error.presentation.recovery === "string" ? error.presentation.recovery : void 0
-		} : void 0
-	};
-}
-/**
-* Base client error carrying both machine-facing context and an optional
-* user-facing presentation layer.
-*
-* Top-level `code` and `recovery` provide stable machine contracts for
-* policy decisions without requiring callers to unwrap `presentation`.
-*/
-var ClientError = class ClientError extends Error {
-	kind;
-	/**
-	* Stable machine-readable error code.
-	* Matches `presentation.code` when present, otherwise a default
-	* derived from `kind`.
-	*/
-	code;
-	/** Recovery hint at the machine level. */
-	recovery;
-	/** Whether this error is safe to retry. */
-	retryable;
-	/** Structured user-facing error presentation from the server. */
-	presentation;
-	/** Source subsystem or component that produced the error. */
-	source;
-	constructor(options) {
-		super(options.message, { cause: options.cause });
-		this.name = "ClientError";
-		this.kind = options.kind;
-		this.code = options.code ?? options.presentation?.code ?? `client.${options.kind}`;
-		this.recovery = options.recovery ?? options.presentation?.recovery ?? UserRecovery.None;
-		this.retryable = options.retryable ?? this.recovery === UserRecovery.Retry;
-		this.presentation = options.presentation;
-		this.source = options.source;
-	}
-	/** Create a `ClientError` from a server error response body. */
-	static fromServerError(body, overrides) {
-		const rawPresentation = body.presentation;
-		const presentation = (rawPresentation?.code ?? body.code) && (rawPresentation?.message ?? body.message) ? {
-			code: rawPresentation?.code ?? body.code ?? "unknown_server_error",
-			message: rawPresentation?.message ?? body.message ?? "Unknown server error",
-			recovery: rawPresentation?.recovery ?? body.recovery ?? UserRecovery.None
-		} : void 0;
-		return new ClientError({
-			kind: overrides?.kind ?? mapServerErrorKind(body.kind, 400),
-			message: presentation?.message ?? body.message ?? "Unknown server error",
-			presentation,
-			source: overrides?.source
-		});
-	}
-	/**
-	* Create a `ClientError` from an HTTP response status and optional body.
-	* Used when a non-success status is unexpected.
-	*/
-	static fromHttpResponse(status, body) {
-		const serverBody = readServerErrorBody(body);
-		const kind = mapServerErrorKind(serverBody?.kind, status);
-		const source = status >= 500 ? ClientErrorSource.Server : ClientErrorSource.ClientEnvironment;
-		if (serverBody?.code && serverBody?.message) return ClientError.fromServerError(serverBody, {
-			kind,
-			source
-		});
-		const recovery = kind === ClientErrorKind.Unauthenticated ? UserRecovery.Reauthenticate : status >= 500 ? UserRecovery.Retry : UserRecovery.None;
-		return new ClientError({
-			kind,
-			message: serverBody?.message ?? `HTTP ${status}`,
-			code: serverBody?.code ?? `http.${status}`,
-			recovery,
-			retryable: status >= 500,
-			source
-		});
-	}
-};
-//#endregion
-//#region src/logging/types.ts
-const LogLevel = {
-	Debug: "debug",
-	Info: "info",
-	Warn: "warn",
-	Error: "error"
-};
-const OperationTraceEventType = {
-	Started: "operation.started",
-	Event: "operation.event",
-	Error: "operation.error",
-	Ended: "operation.ended"
-};
-//#endregion
-//#region src/logging/operation-tracer.ts
-const defaultClock = { now: () => Date.now() };
-function createDefaultOperationId() {
-	return `op_${Math.random().toString(36).slice(2, 10)}`;
-}
-var DefaultOperationScope = class {
-	_name;
-	_clock;
-	_traceSink;
-	_logger;
-	_scope;
-	_source;
-	id;
-	_attributes;
-	_ended = false;
-	constructor(_name, _clock, _traceSink, _logger, _scope, _source, idFactory, attributes) {
-		this._name = _name;
-		this._clock = _clock;
-		this._traceSink = _traceSink;
-		this._logger = _logger;
-		this._scope = _scope;
-		this._source = _source;
-		this.id = idFactory();
-		this._attributes = { ...attributes ?? {} };
-		this._recordTrace(OperationTraceEventType.Started, {
-			operationName: this._name,
-			...this._attributes
-		});
-	}
-	addEvent(type, attributes) {
-		this._recordTrace(OperationTraceEventType.Event, {
-			operationName: this._name,
-			eventType: type,
-			...this._attributes,
-			...attributes ?? {}
-		});
-	}
-	setAttribute(key, value) {
-		this._attributes[key] = value;
-	}
-	recordError(error, attributes) {
-		const errorAttributes = describeError(error);
-		this._recordTrace(OperationTraceEventType.Error, {
-			operationName: this._name,
-			...this._attributes,
-			...errorAttributes,
-			...attributes ?? {}
-		});
-		this._logger?.log({
-			level: LogLevel.Error,
-			message: `Operation failed: ${this._name}`,
-			scope: this._scope,
-			attributes: {
-				operationId: this.id,
-				operationName: this._name,
-				...this._attributes,
-				...errorAttributes,
-				...attributes ?? {}
-			},
-			error,
-			at: this._clock.now()
-		});
-	}
-	end(attributes) {
-		if (this._ended) return;
-		this._ended = true;
-		this._recordTrace(OperationTraceEventType.Ended, {
-			operationName: this._name,
-			...this._attributes,
-			...attributes ?? {}
-		});
-	}
-	_recordTrace(type, attributes) {
-		this._traceSink?.record({
-			type,
-			at: this._clock.now(),
-			scope: this._scope,
-			source: this._source,
-			operationId: this.id,
-			attributes
-		});
-	}
-};
-function createOperationTracer(options = {}) {
-	const clock = options.clock ?? defaultClock;
-	const idFactory = options.idFactory ?? createDefaultOperationId;
-	return { startOperation(name, attributes) {
-		return new DefaultOperationScope(name, clock, options.traceSink, options.logger, options.scope, options.source, idFactory, attributes);
-	} };
-}
-function describeError(error) {
-	if (typeof error === "object" && error !== null && "name" in error && "message" in error) {
-		const genericError = error;
-		return {
-			errorName: genericError.name,
-			errorMessage: genericError.message
-		};
-	}
-	return { errorValue: String(error) };
-}
-//#endregion
-//#region src/scheduling/default-clock.ts
-/** Default clock backed by `Date.now()`. */
-function createDefaultClock() {
-	return { now() {
-		return Date.now();
-	} };
-}
-//#endregion
-//#region src/scheduling/default-scheduler.ts
-/** Default scheduler backed by platform `setTimeout`. */
-function createDefaultScheduler() {
-	return { setTimeout(delayMs, fn) {
-		const id = globalThis.setTimeout(fn, delayMs);
-		return { cancel() {
-			globalThis.clearTimeout(id);
-		} };
-	} };
-}
-//#endregion
-//#region src/runtime/create-runtime.ts
-/**
-* Create a `ClientEnvironment` with non-host-specific defaults filled in for
-* convenience.
-*
-* Host-specific capabilities such as browser `fetch` should be supplied
-* explicitly or composed via adapter-specific helpers such as
-* `@securitydept/client/web`.
-*/
-function createClientEnvironment(overrides) {
-	const clock = overrides.clock ?? createDefaultClock();
-	const traceSink = overrides.traceSink;
-	const logger = overrides.logger;
-	return {
-		transport: overrides.transport,
-		scheduler: overrides.scheduler ?? createDefaultScheduler(),
-		clock,
-		logger,
-		traceSink,
-		operationTracer: overrides.operationTracer ?? createOperationTracer({
-			clock,
-			logger,
-			traceSink
-		}),
-		persistentStore: overrides.persistentStore,
-		sessionStore: overrides.sessionStore
-	};
-}
-//#endregion
-//#region src/scheduling/helpers.ts
-const PromiseSettlementKind = {
-	Fulfilled: "fulfilled",
-	Rejected: "rejected"
-};
-/**
-* Schedule a one-shot callback after a delay.
-*
-* Returns a {@link CancelableHandle} that can cancel the pending timer.
-*
-* @example
-* ```ts
-* const handle = timer({
-*   scheduler: runtime.scheduler,
-*   delayMs: 5000,
-*   callback: () => console.log("fired"),
-* });
-* // Cancel before it fires:
-* handle.cancel();
-* ```
-*/
-function timer(options) {
-	return options.scheduler.setTimeout(options.delayMs, options.callback);
-}
-/**
-* Schedule a repeating callback at a fixed interval.
-*
-* Built on top of `Scheduler.setTimeout` so it works with deterministic
-* test schedulers. Returns a {@link CancelableHandle} to stop the interval.
-*
-* @example
-* ```ts
-* const handle = interval({
-*   scheduler: runtime.scheduler,
-*   periodMs: 30_000,
-*   callback: () => refreshTokens(),
-* });
-* // Stop:
-* handle.cancel();
-* ```
-*/
-function interval(options) {
-	let canceled = false;
-	let currentHandle = null;
-	function tick() {
-		if (canceled) return;
-		options.callback();
-		scheduleNext();
-	}
-	function scheduleNext() {
-		if (canceled) return;
-		currentHandle = options.scheduler.setTimeout(options.periodMs, tick);
-	}
-	scheduleNext();
-	return { cancel() {
-		canceled = true;
-		currentHandle?.cancel();
-		currentHandle = null;
-	} };
-}
-/**
-* Schedule a callback at a specific wall-clock time.
-*
-* Computes the delay from `clock.now()` to `atMs` and delegates to
-* `Scheduler.setTimeout`. If the target time is already in the past,
-* the callback fires on the next scheduler tick (delay 0).
-*
-* @example
-* ```ts
-* const handle = scheduleAt({
-*   scheduler: runtime.scheduler,
-*   clock: runtime.clock,
-*   atMs: tokenExpiresAtMs - 30_000,
-*   callback: () => refreshToken(),
-* });
-* ```
-*/
-function scheduleAt(options) {
-	const delay = Math.max(0, options.atMs - options.clock.now());
-	return options.scheduler.setTimeout(delay, options.callback);
-}
-/**
-* Adapt an SDK signal into the shared {@link Subscription} callback model.
-*
-* @example
-* ```ts
-* const sub = fromSignal({
-*   signal: authState,
-*   callback: (snapshot) => console.log(snapshot),
-* });
-* sub.unsubscribe();
-* ```
-*/
-function fromSignal(options) {
-	if (options.emitInitialValue) options.callback(options.signal.get());
-	const unsubscribe = options.signal.subscribe(() => {
-		options.callback(options.signal.get());
-	});
-	return { unsubscribe() {
-		unsubscribe();
-	} };
-}
-/**
-* Adapt a promise settlement into the shared {@link Subscription} callback model.
-*
-* This helper is intentionally thin: it reports one settlement and lets the
-* consumer decide how to model pending/fulfilled/error state.
-*
-* @example
-* ```ts
-* const sub = fromPromise({
-*   promise: fetchConfig(),
-*   callback: (settlement) => {
-*     if (settlement.kind === PromiseSettlementKind.Fulfilled) {
-*       console.log(settlement.value);
-*     }
-*   },
-* });
-* sub.unsubscribe();
-* ```
-*/
-function fromPromise(options) {
-	let active = true;
-	Promise.resolve(options.promise).then((value) => {
-		if (!active) return;
-		options.callback({
-			kind: PromiseSettlementKind.Fulfilled,
-			value
-		});
-	}, (reason) => {
-		if (!active) return;
-		options.callback({
-			kind: PromiseSettlementKind.Rejected,
-			reason
-		});
-	});
-	return { unsubscribe() {
-		active = false;
-	} };
-}
-/**
-* Adapt an arbitrary add/remove event pattern into a {@link Subscription}.
-*
-* This is a thin bridge between imperative event APIs (e.g. `addEventListener`
-* / `removeEventListener`) and the SDK's subscription model.
-*
-* @example
-* ```ts
-* const sub = fromEventPattern<Event>({
-*   addHandler: (h) => document.addEventListener("visibilitychange", h),
-*   removeHandler: (h) => document.removeEventListener("visibilitychange", h),
-*   callback: () => onVisibilityChange(),
-* });
-* // Cleanup:
-* sub.unsubscribe();
-* ```
-*/
-function fromEventPattern(options) {
-	const handler = (value) => {
-		options.callback(value);
-	};
-	options.addHandler(handler);
-	return { unsubscribe() {
-		options.removeHandler(handler);
-	} };
-}
-//#endregion
-//#region src/web/input-sources.ts
-/**
-* Adapt a browser AbortSignal into the shared Subscription model.
-*/
-function fromAbortSignal(options) {
-	const signal = options.signal;
-	if (!signal) return { unsubscribe() {} };
-	if (options.emitIfAborted && signal.aborted) options.callback(signal.reason);
-	return fromEventPattern({
-		addHandler: (handler) => {
-			signal.addEventListener("abort", handler);
-		},
-		removeHandler: (handler) => {
-			signal.removeEventListener("abort", handler);
-		},
-		callback: () => {
-			options.callback(signal.reason);
-		}
-	});
-}
-/**
-* Adapt browser `storage` events into the shared Subscription model.
-*/
-function fromStorageEvent(options) {
-	const target = options.target ?? globalThis;
-	return fromEventPattern({
-		addHandler: (handler) => {
-			target.addEventListener("storage", handler);
-		},
-		removeHandler: (handler) => {
-			target.removeEventListener("storage", handler);
-		},
-		callback: (event) => {
-			options.callback(event);
-		}
-	});
-}
-//#endregion
-//#region src/web/cancellation.ts
-/**
-* Bridge a web `AbortSignal` back into the foundation cancellation contract.
-*
-* This is the canonical consumer-side path for browser hosts that receive an
-* `AbortSignal` from framework/runtime APIs (for example React Query queryFns)
-* but need to call SDK surfaces that accept `CancellationTokenTrait`.
-*/
-function createCancellationTokenFromAbortSignal(signal) {
-	if (!signal) return;
-	return {
-		get isCancellationRequested() {
-			return signal.aborted;
-		},
-		get reason() {
-			return signal.reason;
-		},
-		onCancellationRequested(listener) {
-			const subscription = fromAbortSignal({
-				signal,
-				callback: listener,
-				emitIfAborted: true
-			});
-			return { dispose() {
-				subscription.unsubscribe();
-			} };
-		},
-		throwIfCancellationRequested() {
-			if (signal.aborted) throw new ClientError({
-				kind: ClientErrorKind.Cancelled,
-				message: "Request was cancelled via AbortSignal",
-				code: "client.cancelled",
-				source: ClientErrorSource.Transport,
-				cause: signal.reason
-			});
-		}
-	};
-}
-/**
-* Bridge foundation cancellation to web `AbortSignal` without exposing
-* `AbortSignal` in core contracts.
-*/
-function createAbortSignalBridge(token) {
-	if (!token) return {
-		signal: void 0,
-		dispose() {}
-	};
-	const controller = new AbortController();
-	let subscription = token.onCancellationRequested((reason) => {
-		controller.abort(reason);
-	});
-	if (token.isCancellationRequested) controller.abort(token.reason);
-	return {
-		signal: controller.signal,
-		dispose() {
-			subscription?.dispose();
-			subscription = null;
-		}
-	};
-}
-function normalizeAbortError(token, error) {
-	if (!isAbortError(error) && !token?.isCancellationRequested) return error;
-	const reason = token?.reason;
-	if (reason instanceof ClientError) return reason;
-	if (reason instanceof Error) return new ClientError({
-		kind: ClientErrorKind.Cancelled,
-		message: reason.message,
-		code: "client.cancelled",
-		source: ClientErrorSource.Transport,
-		cause: reason
-	});
-	return new ClientError({
-		kind: ClientErrorKind.Cancelled,
-		message: "HTTP request was cancelled",
-		code: "client.cancelled",
-		source: ClientErrorSource.Transport,
-		cause: reason ?? error
-	});
-}
-function isAbortError(error) {
-	return typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
-}
-//#endregion
-//#region src/transport/fetch-transport.ts
-const FetchTransportRedirectKind = {
-	Follow: "follow",
-	Manual: "manual"
-};
-/**
-* Default `HttpTransport` backed by the global `fetch` API.
-*
-* The caller is responsible for ensuring `fetch` is available in the runtime.
-* No polyfill is injected — see the polyfill strategy in the design guide.
-*/
-function createFetchTransport(options = {}) {
-	const redirect = options.redirect ?? FetchTransportRedirectKind.Manual;
-	return { async execute(request) {
-		const abortBridge = createAbortSignalBridge(request.cancellationToken);
-		const init = {
-			method: request.method,
-			headers: request.headers,
-			redirect,
-			signal: abortBridge.signal
-		};
-		if (request.body !== void 0 && request.method !== "GET" && request.method !== "HEAD") init.body = typeof request.body === "string" ? request.body : JSON.stringify(request.body);
-		try {
-			const res = await fetch(request.url, init);
-			const responseHeaders = {};
-			res.headers.forEach((value, key) => {
-				responseHeaders[key] = value;
-			});
-			let body;
-			if (res.headers.get("content-type")?.includes("application/json")) body = await res.json();
-			else if (res.status !== 302 && res.status !== 303 && res.status !== 301) body = await res.text();
-			return {
-				status: res.status,
-				headers: responseHeaders,
-				body
-			};
-		} catch (error) {
-			throw normalizeAbortError(request.cancellationToken, error);
-		} finally {
-			abortBridge.dispose();
-		}
-	} };
-}
-//#endregion
-//#region src/web/runtime.ts
-/**
-* Create a `ClientEnvironment` for browser/Web-capable environments.
-*/
-function createWebClientEnvironmentDependencies(overrides = {}) {
-	const { fetchTransport, transport, ...environment } = overrides;
-	return createClientEnvironment({
-		...environment,
-		transport: transport ?? createFetchTransport(fetchTransport)
-	});
-}
-//#endregion
-//#region src/web/client-environment.ts
-const ClientEnvironmentPreset = {
-	BrowserPage: "browser_page",
-	BrowserWorker: "browser_worker",
-	ServiceWorker: "service_worker",
-	BrowserExtensionBackground: "browser_extension_background"
-};
-const PAGE_LOCATION_ERROR_MESSAGE = "browser redirect helpers require a page-like window.location.\nFor extension background or service worker hosts, keep redirects in a real page context or pass explicit location capability.";
-const PAGE_LOCATION_HISTORY_ERROR_MESSAGE = "backend-oidc page callback bootstrap requires a page-like window.location and window.history.\nFor extension background or service worker hosts, use restore-only flow or pass explicit location/history/store capabilities.";
-const EXPLICIT_PAGE_ENVIRONMENT_ERROR_MESSAGE = "page helpers require an explicit page environment.\nCreate one in your composition root with createBrowserPageClientEnvironment(...).\nFor worker, service worker, or extension background hosts, keep page-only redirects and callbacks in a real page context.";
-const EXPLICIT_PAGE_LOCATION_HISTORY_CAPABILITY_ERROR_MESSAGE = "page helpers require an explicit page environment with location and history.\nCreate one in your composition root with createBrowserPageClientEnvironment(...), or pass an explicit pageCapability override.";
-const BROWSER_PERSISTENT_PREFIX = "securitydept.web.client:";
-const BROWSER_SESSION_PREFIX = "securitydept.web.client:";
-function createWebClientEnvironment(options = {}) {
-	const { preset, ...environmentOptions } = options;
-	return {
-		...createWebClientEnvironmentDependencies(environmentOptions),
-		preset
-	};
-}
-function deriveClientEnvironment(environment) {
-	return {
-		transport: environment.transport,
-		scheduler: environment.scheduler,
-		clock: environment.clock,
-		logger: environment.logger,
-		traceSink: environment.traceSink,
-		operationTracer: environment.operationTracer,
-		persistentStore: environment.persistentStore,
-		sessionStore: environment.sessionStore
-	};
-}
-function createBrowserPageClientEnvironment(options = {}) {
-	const pageCapability = options.pageCapability ? assertPageLocationHistoryCapability(options.pageCapability) : requireDefaultPageLocationHistoryCapability();
-	return {
-		...createWebClientEnvironment({
-			...withDefaultBrowserStores(options),
-			preset: ClientEnvironmentPreset.BrowserPage
-		}),
-		...pageCapability
-	};
-}
-function readDefaultPageLocationCapability() {
-	const windowLike = globalThis.window;
-	if (!isObject(windowLike)) return null;
-	const location = windowLike.location;
-	return readPageLocationCapability({ location });
-}
-function requireDefaultPageLocationCapability() {
-	const pageCapability = readDefaultPageLocationCapability();
-	if (!pageCapability) throw new Error(PAGE_LOCATION_ERROR_MESSAGE);
-	return pageCapability;
-}
-function createBrowserWorkerClientEnvironment(options = {}) {
-	return createWebClientEnvironment({
-		...options,
-		preset: ClientEnvironmentPreset.BrowserWorker
-	});
-}
-function createServiceWorkerClientEnvironment(options = {}) {
-	return createWebClientEnvironment({
-		...options,
-		preset: ClientEnvironmentPreset.ServiceWorker
-	});
-}
-function createBrowserExtensionBackgroundClientEnvironment(options = {}) {
-	return createWebClientEnvironment({
-		...options,
-		preset: ClientEnvironmentPreset.BrowserExtensionBackground
-	});
-}
-function assertResolveEnvironment(environment, onResolvingEnvironmentFail) {
-	if (environment === null || environment === void 0) return onResolvingEnvironmentFail();
-	return environment;
-}
-function assertResolveFromEnvironment(environment, select, onResolvingCapabilityFail) {
-	const resolvedValue = select(assertResolveEnvironment(environment, onResolvingCapabilityFail));
-	if (resolvedValue === null || resolvedValue === void 0) return onResolvingCapabilityFail();
-	return resolvedValue;
-}
-function requirePageClientEnvironment(environmentOrOptions) {
-	const options = normalizeRequirePageClientEnvironmentOptions(environmentOrOptions);
-	const environment = assertResolveEnvironment(options.environment, failMissingPageEnvironment);
-	const pageCapability = resolvePageLocationHistoryCapability(options, environment);
-	return {
-		...environment,
-		...pageCapability
-	};
-}
-function readDefaultPageLocationHistoryCapability() {
-	const windowLike = globalThis.window;
-	if (!isObject(windowLike)) return null;
-	const location = windowLike.location;
-	const history = windowLike.history;
-	return readPageLocationHistoryCapability({
-		location,
-		history
-	});
-}
-function requireDefaultPageLocationHistoryCapability() {
-	const pageCapability = readDefaultPageLocationHistoryCapability();
-	if (!pageCapability) throw new Error(PAGE_LOCATION_HISTORY_ERROR_MESSAGE);
-	return pageCapability;
-}
-function readPageLocationCapability(input) {
-	const location = input.location;
-	if (!isPageLocationLike(location)) return null;
-	return { location };
-}
-function readPageLocationHistoryCapability(input) {
-	const pageCapability = readPageLocationCapability(input);
-	const history = input.history;
-	if (!pageCapability || !isPageHistoryLike(history)) return null;
-	return {
-		...pageCapability,
-		history
-	};
-}
-function assertPageLocationCapability(pageCapability, fieldName = "environment") {
-	if (!isObject(pageCapability)) throw new Error(`${fieldName} must include location.href and location.hash.\n${PAGE_LOCATION_ERROR_MESSAGE}`);
-	const normalized = readPageLocationCapability(pageCapability);
-	if (!normalized) throw new Error(`${fieldName} must include location.href and location.hash.\n${PAGE_LOCATION_ERROR_MESSAGE}`);
-	return normalized;
-}
-function assertPageLocationHistoryCapability(pageCapability, fieldName = "pageCapability") {
-	if (!isObject(pageCapability)) throw new Error(`${fieldName} must include location.href, location.hash, and history.replaceState.\n${PAGE_LOCATION_HISTORY_ERROR_MESSAGE}`);
-	const normalized = readPageLocationHistoryCapability(pageCapability);
-	if (!normalized) throw new Error(`${fieldName} must include location.href, location.hash, and history.replaceState.\n${PAGE_LOCATION_HISTORY_ERROR_MESSAGE}`);
-	return normalized;
-}
-function normalizeRequirePageClientEnvironmentOptions(environmentOrOptions) {
-	if (!environmentOrOptions) return {};
-	if ("transport" in environmentOrOptions) return { environment: environmentOrOptions };
-	return environmentOrOptions;
-}
-function resolvePageLocationHistoryCapability(options, environment) {
-	if (options.pageCapability !== void 0) return assertPageLocationHistoryCapability(options.pageCapability, "pageCapability");
-	return assertResolveFromEnvironment(environment, (candidateEnvironment) => readPageLocationHistoryCapability(candidateEnvironment), failMissingPageLocationHistoryCapability);
-}
-function failMissingPageEnvironment() {
-	throw new Error(EXPLICIT_PAGE_ENVIRONMENT_ERROR_MESSAGE);
-}
-function failMissingPageLocationHistoryCapability() {
-	throw new Error(EXPLICIT_PAGE_LOCATION_HISTORY_CAPABILITY_ERROR_MESSAGE);
-}
-function withDefaultBrowserStores(options) {
-	return {
-		...options,
-		persistentStore: options.persistentStore ?? createLocalStorageStore(BROWSER_PERSISTENT_PREFIX),
-		sessionStore: options.sessionStore ?? createSessionStorageStore(BROWSER_SESSION_PREFIX)
-	};
-}
-function isObject(value) {
-	return typeof value === "object" && value !== null;
-}
-function isPageLocationLike(value) {
-	return isObject(value) && typeof value.href === "string" && typeof value.hash === "string";
-}
-function isPageHistoryLike(value) {
-	return isObject(value) && typeof value.replaceState === "function";
-}
-//#endregion
-export { interval as A, ClientErrorKind as B, normalizeAbortError as C, fromEventPattern as D, PromiseSettlementKind as E, createDefaultClock as F, ErrorPresentationTone as H, createOperationTracer as I, LogLevel as L, timer as M, createClientEnvironment as N, fromPromise as O, createDefaultScheduler as P, OperationTraceEventType as R, createCancellationTokenFromAbortSignal as S, fromStorageEvent as T, UserRecovery as U, ClientErrorSource as V, requireDefaultPageLocationHistoryCapability as _, assertResolveFromEnvironment as a, createFetchTransport as b, createBrowserWorkerClientEnvironment as c, deriveClientEnvironment as d, readDefaultPageLocationCapability as f, requireDefaultPageLocationCapability as g, readPageLocationHistoryCapability as h, assertResolveEnvironment as i, scheduleAt as j, fromSignal as k, createServiceWorkerClientEnvironment as l, readPageLocationCapability as m, assertPageLocationCapability as n, createBrowserExtensionBackgroundClientEnvironment as o, readDefaultPageLocationHistoryCapability as p, assertPageLocationHistoryCapability as r, createBrowserPageClientEnvironment as s, ClientEnvironmentPreset as t, createWebClientEnvironment as u, requirePageClientEnvironment as v, fromAbortSignal as w, createAbortSignalBridge as x, FetchTransportRedirectKind as y, ClientError as z };
-
-//# sourceMappingURL=client-environment-CaumNmir.mjs.map