@securitydept/client 0.3.0-beta.1 → 0.3.0-beta.10

package/dist/create-i5VyYgN6.mjs

@@ -0,0 +1,989 @@
+import { A as RxEventSubject, F as SYMBOL_DISPOSE, H as ClientError, K as UserRecovery, M as isInteropObservableTrait, U as ClientErrorKind, W as ClientErrorSource, j as SYMBOL_OBSERVABLE, k as RxEventStream } from "./rx-DM6Ouv-m.mjs";
+import { v7 } from "uuid";
+import { InjectionToken, Injector, Optional, ReflectiveInjector } from "injection-js";
+import { EMPTY, from, fromEventPattern, map, merge, of } from "rxjs";
+import { type } from "arktype";
+//#region src/injection/types.ts
+var SecuritydeptInjectionToken = class extends InjectionToken {};
+const SecurityDeptOptional = Optional;
+function getSecuritydeptProviderToken(provider) {
+	if (typeof provider === "function") return provider;
+	return provider.provide;
+}
+function createProviderIfTokenMissing(providedTokens, token, createProvider) {
+	return providedTokens.has(token) ? null : createProvider();
+}
+function notMissingProvider(provider) {
+	return provider !== null;
+}
+//#endregion
+//#region src/injection/injector.ts
+var SecuritydeptInjector = class SecuritydeptInjector {
+	runtimeInjector;
+	static resolveAndCreate(providers) {
+		const normalized = normalizeProviders([...providers, createInjectorSelfProvider()]);
+		return getSecuritydeptInjectorFromRuntime(ReflectiveInjector.resolveAndCreate(normalized.providers));
+	}
+	static fromParentInjector(parent, providers) {
+		const normalized = normalizeProviders([
+			{
+				provide: PARENT_INJECTOR_TOKEN,
+				useValue: parent
+			},
+			...providers,
+			createInjectorSelfProvider()
+		]);
+		return getSecuritydeptInjectorFromRuntime(ReflectiveInjector.resolveAndCreate(normalized.providers, toRuntimeInjector(parent)));
+	}
+	static fromRuntimeInjector(runtimeInjector) {
+		return new SecuritydeptInjector(runtimeInjector);
+	}
+	constructor(runtimeInjector) {
+		this.runtimeInjector = runtimeInjector;
+	}
+	get(token, notFoundValue) {
+		try {
+			if (arguments.length === 1) return this.runtimeInjector.get(token);
+			return this.runtimeInjector.get(token, notFoundValue);
+		} catch (error) {
+			throw createInjectorResolutionError(token, error);
+		}
+	}
+};
+const INJECTOR_TOKEN = new SecuritydeptInjectionToken("INJECTOR_TOKEN");
+const PARENT_INJECTOR_TOKEN = new SecuritydeptInjectionToken("PARENT_INJECTOR_TOKEN");
+function normalizeProviders(providers) {
+	return { providers: providers.map((provider) => {
+		if (typeof provider === "function") return provider;
+		if ("useValue" in provider) return {
+			provide: provider.provide,
+			useValue: provider.useValue
+		};
+		if ("useClass" in provider) return {
+			provide: provider.provide,
+			useFactory: (...deps) => new provider.useClass(...deps),
+			deps: provider.deps ? [...provider.deps] : void 0
+		};
+		if ("useExisting" in provider) return {
+			provide: provider.provide,
+			useExisting: provider.useExisting
+		};
+		return {
+			provide: provider.provide,
+			useFactory: provider.useFactory,
+			deps: provider.deps ? [...provider.deps] : void 0
+		};
+	}) };
+}
+function createInjectorSelfProvider() {
+	return {
+		provide: INJECTOR_TOKEN,
+		useFactory: (runtimeInjector) => SecuritydeptInjector.fromRuntimeInjector(runtimeInjector),
+		deps: [Injector]
+	};
+}
+function getSecuritydeptInjectorFromRuntime(runtimeInjector) {
+	return runtimeInjector.get(INJECTOR_TOKEN);
+}
+var SecuritydeptRuntimeParentAdapter = class extends Injector {
+	parent;
+	constructor(parent) {
+		super();
+		this.parent = parent;
+	}
+	get(token, notFoundValue) {
+		if (arguments.length === 1) return this.parent.get(token);
+		return this.parent.get(token, notFoundValue);
+	}
+};
+function toRuntimeInjector(parent) {
+	return new SecuritydeptRuntimeParentAdapter(parent);
+}
+function createInjectorResolutionError(token, error) {
+	const tokenLabel = describeDependencyToken(token);
+	const originalMessage = error instanceof Error ? error.message : String(error);
+	const message = /No provider/i.test(originalMessage) ? `[SecuritydeptInjector] No provider found for ${tokenLabel}.` : `[SecuritydeptInjector] Failed to resolve ${tokenLabel}: ${originalMessage}`;
+	return new Error(message, { cause: error instanceof Error ? error : void 0 });
+}
+function describeDependencyToken(token) {
+	if (token instanceof InjectionToken) return token.toString().replace(/^InjectionToken\s+/, "Token ");
+	if (typeof token === "function" && token.name) return token.name;
+	return String(token);
+}
+//#endregion
+//#region src/events/types.ts
+const EventStreamTraitSchema = type({ subscribe: "Function" });
+const EventSourceKind = {
+	User: "user",
+	Timer: "timer",
+	Http: "http",
+	Storage: "storage",
+	Framework: "framework",
+	System: "system"
+};
+function isEventStreamTrait(value) {
+	return typeof value === "object" && value !== null && typeof value.subscribe === "function" && isInteropObservableTrait(value);
+}
+//#endregion
+//#region src/page/index.ts
+const PageLifecycleTraitSchema = type({ resume: EventStreamTraitSchema });
+const PAGE_LIFECYCLE_TRAIT_TOKEN = new SecuritydeptInjectionToken("PAGE_LIFECYCLE_TRAIT_TOKEN");
+//#endregion
+//#region src/validation/validator.ts
+function formatValidationFailure(failure) {
+	if (!failure) return null;
+	const summary = failure.issues.map((issue) => issue.path && issue.path.length > 0 ? `${issue.path.join(".")}: ${issue.message}` : issue.message).join("; ");
+	return summary.length > 0 ? summary : null;
+}
+function throwValidationClientError(options) {
+	const issueSummary = formatValidationFailure(options.failure);
+	throw new ClientError({
+		kind: ClientErrorKind.Configuration,
+		code: options.code,
+		message: issueSummary ? `${options.messagePrefix}: ${issueSummary}.` : `${options.messagePrefix}.`,
+		recovery: UserRecovery.RestartFlow,
+		source: options.source,
+		cause: options.failure?.issues
+	});
+}
+/**
+* Validate an unknown input against a `@standard-schema`-compatible schema.
+*
+* This is the foundation-level entry point for SDK validation. It accepts
+* any schema implementing `StandardSchemaV1` and returns a discriminated
+* `ValidationResult`.
+*
+* @example
+* ```ts
+* import { validateWithSchema } from "@securitydept/client";
+* import { z } from "zod";
+*
+* const UserSchema = z.object({ name: z.string() });
+* const result = await validateWithSchema(UserSchema, { name: "Alice" });
+* if (result.success) {
+*   console.log(result.value.name);
+* } else {
+*   console.error(result.issues);
+* }
+* ```
+*/
+async function validateWithSchema(schema, input) {
+	const result = await schema["~standard"].validate(input);
+	if ("value" in result) return {
+		success: true,
+		value: result.value
+	};
+	return {
+		success: false,
+		issues: result.issues
+	};
+}
+/**
+* Validate an unknown input synchronously against a `@standard-schema`-compatible schema.
+*
+* Only use this when you know the schema's validate function returns synchronously.
+* Throws if the schema returns a Promise.
+*/
+function validateWithSchemaSync(schema, input) {
+	const result = schema["~standard"].validate(input);
+	if (result instanceof Promise) throw new Error("validateWithSchemaSync: schema returned a Promise. Use validateWithSchema instead.");
+	if ("value" in result) return {
+		success: true,
+		value: result.value
+	};
+	return {
+		success: false,
+		issues: result.issues
+	};
+}
+function validateTraitInput(options) {
+	if (options.optional === true && (options.value === void 0 || options.value === null)) return;
+	const result = validateWithSchemaSync(options.validator ?? options.bundledSchema, options.value);
+	if (result.success) return;
+	options.onInvalid(result);
+}
+//#endregion
+//#region src/popup/index.ts
+const PopupAttachFailureReason = {
+	MissingOpener: "missing_opener",
+	MissingOrigin: "missing_origin"
+};
+const PopupTraitSchema = type({
+	open: "Function",
+	attach: "Function"
+});
+const POPUP_TRAIT_TOKEN = new SecuritydeptInjectionToken("POPUP_TRAIT_TOKEN");
+//#endregion
+//#region src/protocol/compat-fragment.ts
+const SECURITYDEPT_COMPAT_FRAGMENT_VERSION = "v1";
+function appendOrReplaceCompatFragment(input, options, update) {
+	const blocks = splitFragmentBlocks(readUriFragmentHash(input));
+	if (isCompatFragmentBlock(blocks.at(-1) ?? "")) blocks.pop();
+	blocks.push(buildCompatFragmentBlock(options));
+	const fragment = joinFragmentBlocks(blocks);
+	return {
+		fragment,
+		url: update(input, fragment)
+	};
+}
+function parseCompatFragment(input) {
+	const block = splitFragmentBlocks(readUriFragmentHash(input)).at(-1);
+	if (!block || !isCompatFragmentBlock(block)) return null;
+	const blockParameters = new URLSearchParams(block);
+	blockParameters.delete("securitydept");
+	const parameters = {};
+	blockParameters.forEach((value, key) => {
+		parameters[key] = value;
+	});
+	return {
+		payload: blockParameters.toString(),
+		parameters
+	};
+}
+function takeCompatFragment(input, options) {
+	const currentFragment = readUriFragmentHash(input);
+	const blocks = splitFragmentBlocks(currentFragment);
+	const block = blocks.at(-1);
+	if (!block || !isCompatFragmentBlock(block)) return {
+		compatFragment: null,
+		fragment: currentFragment,
+		url: input
+	};
+	const compatFragment = parseCompatFragment(block);
+	if (!compatFragment || options.condition && !options.condition(compatFragment)) return {
+		compatFragment: null,
+		fragment: currentFragment,
+		url: input
+	};
+	blocks.pop();
+	const fragment = joinFragmentBlocks(blocks);
+	return {
+		compatFragment,
+		fragment,
+		url: options.update(input, fragment)
+	};
+}
+function isCompatFragmentBlock(block) {
+	return new URLSearchParams(block.startsWith("#") ? block.slice(1) : block).get("securitydept") === "v1";
+}
+function readUriFragmentHash(input) {
+	if (typeof input === "string") return input.startsWith("#") ? input : `#${input}`;
+	return input.hash;
+}
+function joinFragmentBlocks(blocks) {
+	return blocks.length > 0 ? `#${blocks.join("#")}` : "";
+}
+function splitFragmentBlocks(fragment) {
+	if (fragment === "#") return [""];
+	const normalized = fragment.startsWith("#") ? fragment.slice(1) : fragment;
+	return normalized ? normalized.split("#") : [];
+}
+function buildCompatFragmentBlock(options) {
+	const block = new URLSearchParams();
+	block.set("securitydept", "v1");
+	const payload = typeof options.payload === "string" ? new URLSearchParams(options.payload.startsWith("#") ? options.payload.slice(1) : options.payload) : new URLSearchParams(options.payload);
+	for (const [key, value] of payload) if (key !== "securitydept") block.append(key, value);
+	return block.toString();
+}
+//#endregion
+//#region src/router/router.ts
+const RouterNavigationIntent = {
+	AuthRedirect: "auth_redirect",
+	PostAuthRedirect: "post_auth_redirect",
+	CallbackCleanup: "callback_cleanup",
+	ExternalOpen: "external_open"
+};
+const RouterNavigationMode = {
+	Push: "push",
+	Replace: "replace",
+	External: "external"
+};
+async function takeCompatFragmentFromRouter(router, options = {}) {
+	const currentUrl = router.currentUrl();
+	if (!currentUrl) return null;
+	const { compatFragment, url: cleanedUrl } = takeCompatFragment(currentUrl, {
+		condition: options.condition,
+		update: (ref, hash) => ref.setHash(hash)
+	});
+	if (!compatFragment) return null;
+	await router.navigate({
+		url: cleanedUrl,
+		intent: RouterNavigationIntent.CallbackCleanup,
+		mode: RouterNavigationMode.Replace
+	});
+	return compatFragment;
+}
+const RouterTraitSchema = type({
+	currentUrl: "Function",
+	navigate: "Function"
+});
+const ROUTER_TRAIT_TOKEN = new SecuritydeptInjectionToken("ROUTER_TRAIT_TOKEN");
+//#endregion
+//#region src/scheduling/types.ts
+const TimeTraitSchema = type({
+	now: "Function",
+	setTimeout: "Function",
+	clearTimeout: "Function"
+});
+const TIME_TRAIT_TOKEN = new SecuritydeptInjectionToken("TIME_TRAIT_TOKEN");
+const IDLE_CALLBACK_TRAIT_TOKEN = new SecuritydeptInjectionToken("IDLE_CALLBACK_TRAIT_TOKEN");
+const IdleCallbackTraitSchema = type({
+	requestIdleCallback: "Function",
+	cancelIdleCallback: "Function"
+});
+//#endregion
+//#region src/span/types.ts
+const SpanCreateOptionsSchema = type({
+	idFactory: "Function",
+	attributes: "object"
+});
+const SpanTraitSchema = type({
+	id: "string",
+	fork: "Function",
+	getAttributes: "Function",
+	getRootToNodePath: "Function",
+	getRootToNodeAttributes: "Function"
+});
+const SPAN_TRAIT_TOKEN = new SecuritydeptInjectionToken("SPAN_TRAIT_TOKEN");
+//#endregion
+//#region src/span/span.ts
+function createDefaultSpanId() {
+	return `span_${v7()}`;
+}
+var DefaultSpan = class DefaultSpan {
+	id;
+	parent;
+	_sharedAttributes;
+	_providerAttributes = /* @__PURE__ */ new Map();
+	_idFactory;
+	constructor(parent, idFactory, attributes) {
+		this._idFactory = idFactory;
+		this.id = idFactory();
+		this.parent = parent;
+		this._sharedAttributes = attributes;
+	}
+	static root(options = {}) {
+		return new DefaultSpan(void 0, options.idFactory ?? createDefaultSpanId, { ...options.attributes ?? {} });
+	}
+	fork(options = {}) {
+		return new DefaultSpan(this, options.idFactory ?? this._idFactory, { ...options.attributes });
+	}
+	getAttributes(options) {
+		if (!options) return this._sharedAttributes;
+		const providerAttributes = this._providerAttributes.get(options.providerId) ?? {};
+		if (options.withShared === false) return providerAttributes;
+		return {
+			...this._sharedAttributes,
+			...providerAttributes
+		};
+	}
+	getRootToNodePath(options = {}) {
+		const path = [];
+		let current = options.skipSelf ? this.parent : this;
+		while (current) {
+			path.push(current);
+			current = current.parent;
+		}
+		return path.reverse();
+	}
+	getRootToNodeAttributes(options = {}) {
+		const path = this.getRootToNodePath({ skipSelf: options.skipSelf });
+		const frames = [];
+		for (const span of path) {
+			const attributes = options.providerId !== void 0 ? span.getAttributes({ providerId: options.providerId }) : span.getAttributes();
+			if (Object.keys(attributes).length === 0) continue;
+			frames.push({
+				spanId: span.id,
+				...span.parent ? { parentSpanId: span.parent.id } : {},
+				attributes
+			});
+		}
+		return frames;
+	}
+	setAttributes(attributes, options = {}) {
+		if (options.providerId === void 0) {
+			this._sharedAttributes = {
+				...this._sharedAttributes,
+				...attributes
+			};
+			return;
+		}
+		this._providerAttributes.set(options.providerId, {
+			...this._providerAttributes.get(options.providerId),
+			...attributes
+		});
+	}
+};
+function createRootSpan(options = {}) {
+	const { validators, ...resolvedOptions } = options;
+	const resolvedCreateOptions = {
+		idFactory: resolvedOptions.idFactory ?? createDefaultSpanId,
+		attributes: resolvedOptions.attributes ?? {}
+	};
+	validateTraitInput({
+		value: resolvedCreateOptions,
+		bundledSchema: SpanCreateOptionsSchema,
+		validator: validators,
+		onInvalid: (failure) => throwValidationClientError({
+			code: "span.invalid_options",
+			source: "span",
+			messagePrefix: "createRootSpan could not validate spanCreateOptions",
+			failure
+		})
+	});
+	return DefaultSpan.root(resolvedCreateOptions);
+}
+//#endregion
+//#region src/std/events/from-abort.ts
+/**
+* Adapt an `AbortSignal`-like source into an event stream of abort reasons.
+*/
+function abortSignalToEventStream(signal) {
+	return RxEventStream.fromObservableInput(merge(signal.aborted ? of(signal.reason) : EMPTY, fromEventPattern((handler) => {
+		signal.addEventListener?.("abort", handler);
+	}, (handler) => {
+		signal.removeEventListener?.("abort", handler);
+	}).pipe(map(() => signal.reason))));
+}
+//#endregion
+//#region src/std/cancellation/abort-signal.ts
+function abortSignalToCancellationToken(signal) {
+	if (!signal) return;
+	return {
+		get isCancellationRequested() {
+			return signal.aborted;
+		},
+		get reason() {
+			return signal.reason;
+		},
+		get cancellationError() {
+			return signal.aborted ? new ClientError({
+				kind: ClientErrorKind.Cancelled,
+				message: "Request was cancelled via AbortSignal",
+				code: "client.cancelled",
+				source: ClientErrorSource.Transport,
+				cause: signal.reason
+			}) : void 0;
+		},
+		onCancellationRequested(listener) {
+			const subscription = abortSignalToEventStream(signal).subscribe({ next: (reason) => listener({
+				reason,
+				cancellationError: new ClientError({
+					kind: ClientErrorKind.Cancelled,
+					message: "Request was cancelled via AbortSignal",
+					code: "client.cancelled",
+					source: ClientErrorSource.Transport,
+					cause: reason
+				})
+			}) });
+			return {
+				dispose() {
+					subscription.unsubscribe();
+				},
+				[SYMBOL_DISPOSE]: () => {
+					subscription.unsubscribe();
+				}
+			};
+		},
+		[SYMBOL_OBSERVABLE]() {
+			return from(abortSignalToEventStream(signal)).pipe(map((reason) => ({
+				reason,
+				cancellationError: new ClientError({
+					kind: ClientErrorKind.Cancelled,
+					message: "Request was cancelled via AbortSignal",
+					code: "client.cancelled",
+					source: ClientErrorSource.Transport,
+					cause: reason
+				})
+			})));
+		},
+		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
+			});
+		}
+	};
+}
+function cancellationTokenToAbortSignal(token) {
+	if (!token) return;
+	const controller = new AbortController();
+	if (token.isCancellationRequested) controller.abort(token.reason);
+	let subscription = token.onCancellationRequested(({ reason }) => {
+		controller.abort(reason);
+	});
+	const dispose = () => {
+		if (subscription) {
+			subscription.dispose();
+			subscription = null;
+		}
+	};
+	return {
+		signal: controller.signal,
+		dispose,
+		[SYMBOL_DISPOSE]: dispose
+	};
+}
+function normalizeAbortError(token, error) {
+	if (!isAbortError(error) && !token?.isCancellationRequested) return error;
+	if (token?.cancellationError) return token.cancellationError;
+	return new ClientError({
+		kind: ClientErrorKind.Cancelled,
+		message: "HTTP request was cancelled",
+		code: "client.cancelled",
+		source: ClientErrorSource.Transport,
+		cause: token?.reason ?? error
+	});
+}
+function isAbortError(error) {
+	return typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
+}
+//#endregion
+//#region src/std/time.ts
+const TimeTraitStdHostSchema = type({
+	Date: type({ now: "Function" }),
+	setTimeout: "Function",
+	clearTimeout: "Function"
+});
+const TimeForStdCreateOptionsSchema = type({ host: TimeTraitStdHostSchema });
+function createTimeForStd(options = {}) {
+	const { validators, ...createOptions } = options;
+	const resolvedCreateOptions = { host: createOptions.host ?? globalThis };
+	validateTraitInput({
+		value: resolvedCreateOptions,
+		bundledSchema: TimeForStdCreateOptionsSchema,
+		validator: validators,
+		onInvalid: (failure) => throwValidationClientError({
+			code: "time.invalid_std_options",
+			source: "time",
+			messagePrefix: "createTimeForStd could not validate timeForStdCreateOptions",
+			failure
+		})
+	});
+	const host = resolvedCreateOptions.host;
+	return {
+		now: () => host.Date.now(),
+		setTimeout: (handler, delayMs) => host.setTimeout(handler, delayMs),
+		clearTimeout: (handle) => host.clearTimeout(handle)
+	};
+}
+//#endregion
+//#region src/transport/types.ts
+const TransportErrorCode = {
+	RequestFailed: "transport.request_failed",
+	ResponseDecodeFailed: "transport.response_decode_failed",
+	InvalidStdFetchOptions: "transport.invalid_std_fetch_options",
+	InvalidAngularOptions: "transport.invalid_angular_options"
+};
+const BaseTransportTraitSchema = type({ execute: "Function" });
+const TRANSPORT_TRAIT_TOKEN = new SecuritydeptInjectionToken("TRANSPORT_TRAIT_TOKEN");
+//#endregion
+//#region src/std/transport/base-transport.ts
+const FetchTransportRedirectKind = {
+	Follow: "follow",
+	Manual: "manual"
+};
+const BaseTransportForStdFetchCreateOptionsSchema = type({
+	redirect: "\"follow\" | \"manual\"",
+	fetch: "Function",
+	baseUrl: "unknown"
+});
+/**
+* Default `BaseTransportTrait` backed by the global `fetch` API.
+*
+* The caller is responsible for ensuring `fetch` is available in the runtime.
+* No polyfill is injected.
+*/
+function createBaseTransportForStdFetch(options = {}) {
+	const { validators, ...createOptions } = options;
+	const resolvedCreateOptions = {
+		redirect: createOptions.redirect ?? FetchTransportRedirectKind.Manual,
+		fetch: createOptions.fetch ?? fetch,
+		baseUrl: createOptions.baseUrl
+	};
+	validateTraitInput({
+		value: resolvedCreateOptions,
+		bundledSchema: BaseTransportForStdFetchCreateOptionsSchema,
+		validator: validators,
+		onInvalid: (failure) => throwValidationClientError({
+			code: TransportErrorCode.InvalidStdFetchOptions,
+			source: "transport",
+			messagePrefix: "createBaseTransportForStdFetch could not validate transportForStdFetchCreateOptions",
+			failure
+		})
+	});
+	const redirect = resolvedCreateOptions.redirect;
+	const fetchImpl = resolvedCreateOptions.fetch;
+	const baseUrl = resolvedCreateOptions.baseUrl;
+	return { async execute(request) {
+		const requestUrl = baseUrl ? new URL(request.url, baseUrl).toString() : request.url;
+		const abortBridge = cancellationTokenToAbortSignal(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 {
+			let res;
+			try {
+				res = await fetchImpl(requestUrl, init);
+			} catch (error) {
+				const normalized = normalizeAbortError(request.cancellationToken, error);
+				if (normalized instanceof ClientError) throw normalized;
+				throw new ClientError({
+					kind: ClientErrorKind.Transport,
+					message: "The HTTP request could not reach the remote service",
+					code: TransportErrorCode.RequestFailed,
+					source: ClientErrorSource.Transport,
+					retryable: true,
+					cause: error
+				});
+			}
+			const responseHeaders = {};
+			res.headers.forEach((value, key) => {
+				responseHeaders[key] = value;
+			});
+			let body;
+			try {
+				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();
+			} catch (error) {
+				throw new ClientError({
+					kind: ClientErrorKind.Protocol,
+					message: "The HTTP response body could not be decoded",
+					code: TransportErrorCode.ResponseDecodeFailed,
+					source: ClientErrorSource.Transport,
+					cause: error
+				});
+			}
+			return {
+				status: res.status,
+				headers: responseHeaders,
+				body
+			};
+		} finally {
+			abortBridge?.dispose();
+		}
+	} };
+}
+//#endregion
+//#region src/storage/types.ts
+const StorageChangeEventOrigin = {
+	Local: "local",
+	External: "external"
+};
+const StorageTraitSchema = type({
+	"storageEvent?": { subscribe: "Function" },
+	get: "Function",
+	set: "Function",
+	take: "Function?",
+	remove: "Function"
+});
+const REALM_STORAGE_TRAIT_TOKEN = new SecuritydeptInjectionToken("REALM_STORAGE_TRAIT_TOKEN");
+const PERSISTENT_STORAGE_TRAIT_TOKEN = new SecuritydeptInjectionToken("PERSISTENT_STORAGE_TRAIT_TOKEN");
+const SESSION_STORAGE_TRAIT_TOKEN = new SecuritydeptInjectionToken("SESSION_STORAGE_TRAIT_TOKEN");
+//#endregion
+//#region src/storage/memory-store.ts
+/** In-memory `SyncStorageTrait` — useful for realm state, tests, and SSR. */
+function createInMemoryRecordStore() {
+	const store = /* @__PURE__ */ new Map();
+	const storageEvent = new RxEventSubject();
+	return {
+		storageEvent,
+		get(key) {
+			return store.get(key) ?? null;
+		},
+		set(key, value) {
+			const oldValue = store.get(key) ?? null;
+			store.set(key, value);
+			storageEvent.next({
+				origin: StorageChangeEventOrigin.Local,
+				key,
+				oldValue,
+				newValue: value
+			});
+		},
+		take(key) {
+			const value = store.get(key) ?? null;
+			if (value !== null) {
+				store.delete(key);
+				storageEvent.next({
+					origin: StorageChangeEventOrigin.Local,
+					key,
+					oldValue: value,
+					newValue: null
+				});
+			}
+			return value;
+		},
+		remove(key) {
+			const oldValue = store.get(key) ?? null;
+			if (oldValue !== null) {
+				store.delete(key);
+				storageEvent.next({
+					origin: StorageChangeEventOrigin.Local,
+					key,
+					oldValue,
+					newValue: null
+				});
+			}
+		}
+	};
+}
+//#endregion
+//#region src/tracing/subscriber/types.ts
+const TracingSubscriberTraitSchema = type({ record: "Function" });
+//#endregion
+//#region src/tracing/create.ts
+const TracingCreateOptionsSchema = type({ subscribers: TracingSubscriberTraitSchema.array() });
+function createTracing(options) {
+	const { validators, ...resolvedOptions } = options ?? {};
+	const resolvedCreateOptions = { subscribers: resolvedOptions.subscribers ?? [] };
+	validateTraitInput({
+		value: resolvedCreateOptions,
+		bundledSchema: TracingCreateOptionsSchema,
+		validator: validators,
+		onInvalid: (failure) => throwValidationClientError({
+			code: "tracing.invalid_options",
+			source: "tracing",
+			messagePrefix: "createTracing could not validate tracingCreateOptions",
+			failure
+		})
+	});
+	const subject = new RxEventSubject();
+	let subscribers = resolvedCreateOptions.subscribers;
+	return {
+		record(event) {
+			for (const subscriber of subscribers) subscriber.record(event);
+			subject.next(event);
+		},
+		events: subject,
+		dispose() {
+			subscribers = [];
+		},
+		[SYMBOL_DISPOSE]() {
+			this.dispose();
+		}
+	};
+}
+//#endregion
+//#region src/tracing/types.ts
+const TracingLevel = {
+	Debug: "debug",
+	Info: "info",
+	Warn: "warn",
+	Error: "error"
+};
+const OperationTraceEventType = {
+	Started: "operation.started",
+	Event: "operation.event",
+	Error: "operation.error",
+	Ended: "operation.ended"
+};
+const TRACING_SPAN_ATTRIBUTE_PROVIDER_ID = "@securitydept/client/tracing";
+const TracingTraitSchema = type({
+	record: "Function",
+	dispose: "Function",
+	events: EventStreamTraitSchema
+});
+const TRACING_TRAIT_TOKEN = new SecuritydeptInjectionToken("TRACING_TRAIT_TOKEN");
+//#endregion
+//#region src/environment/types.ts
+const ENVIRONMENT_TOKEN = new SecuritydeptInjectionToken("ENVIRONMENT_TOKEN");
+//#endregion
+//#region src/environment/create.ts
+/**
+* Create a `FoundationEnvironment` from explicit trait units and defaults.
+*
+* This helper owns foundation-wide baseline resolution and trait-graph wiring.
+*
+* It may resolve:
+*   - public std adapters such as
+*     `transportForStdFetchCreateOptions -> transport` and `timeForStdCreateOptions -> time`
+*   - public hostless baseline constructors such as
+*     `spanCreateOptions -> span` and `tracingCreateOptions -> tracing`
+*
+* Host-material discovery such as resolving `window`, `location`, `history`,
+* or browser storage handles belongs to explicit host adapters such as
+* `@securitydept/client/web`, which must first resolve those inputs into
+* concrete traits before calling this helper.
+*/
+function createFoundationEnvironment(overrides) {
+	const providers = overrides.providers ?? [];
+	const externalProviderTokens = new Set(providers.map((provider) => getSecuritydeptProviderToken(provider)));
+	if (externalProviderTokens.has(ENVIRONMENT_TOKEN)) throwValidationClientError({
+		code: "environment.foundation_provider_reserved",
+		source: "environment",
+		messagePrefix: "createFoundationEnvironment does not allow overriding ENVIRONMENT_TOKEN"
+	});
+	return SecuritydeptInjector.resolveAndCreate([
+		...createBuiltInTraitUnits(overrides, externalProviderTokens),
+		...providers,
+		createFoundationEnvironmentUnit()
+	]).get(ENVIRONMENT_TOKEN);
+}
+function createBuiltInTraitUnits(overrides, externalProviderTokens) {
+	return [
+		createProviderIfTokenMissing(externalProviderTokens, TRANSPORT_TRAIT_TOKEN, () => createBuiltInTraitUnit({
+			token: TRANSPORT_TRAIT_TOKEN,
+			traitName: "transport",
+			bundledSchema: BaseTransportTraitSchema,
+			validator: overrides.validators?.transport,
+			createValue: () => overrides.transport ?? createBaseTransportForStdFetch({
+				...overrides.transportForStdFetchCreateOptions,
+				validators: overrides.validators?.transportForStdFetchCreateOptions
+			})
+		})),
+		createProviderIfTokenMissing(externalProviderTokens, TIME_TRAIT_TOKEN, () => createBuiltInTraitUnit({
+			token: TIME_TRAIT_TOKEN,
+			traitName: "time",
+			bundledSchema: TimeTraitSchema,
+			validator: overrides.validators?.time,
+			createValue: () => overrides.time ?? createTimeForStd({
+				...overrides.timeForStdCreateOptions,
+				validators: overrides.validators?.timeForStdCreateOptions
+			})
+		})),
+		createProviderIfTokenMissing(externalProviderTokens, REALM_STORAGE_TRAIT_TOKEN, () => createBuiltInTraitUnit({
+			token: REALM_STORAGE_TRAIT_TOKEN,
+			traitName: "realmStorage",
+			bundledSchema: StorageTraitSchema,
+			validator: overrides.validators?.realmStorage,
+			createValue: () => overrides.realmStorage ?? createInMemoryRecordStore()
+		})),
+		createProviderIfTokenMissing(externalProviderTokens, SPAN_TRAIT_TOKEN, () => createBuiltInTraitUnit({
+			token: SPAN_TRAIT_TOKEN,
+			traitName: "span",
+			bundledSchema: SpanTraitSchema,
+			validator: overrides.validators?.span,
+			createValue: () => overrides.span ?? createRootSpan({
+				...overrides.spanCreateOptions,
+				validators: overrides.validators?.spanCreateOptions
+			})
+		})),
+		createProviderIfTokenMissing(externalProviderTokens, TRACING_TRAIT_TOKEN, () => createBuiltInTraitUnit({
+			token: TRACING_TRAIT_TOKEN,
+			traitName: "tracing",
+			bundledSchema: TracingTraitSchema,
+			validator: overrides.validators?.tracing,
+			createValue: () => overrides.tracing ?? createTracing({
+				...overrides.tracingCreateOptions,
+				validators: overrides.validators?.tracingCreateOptions
+			})
+		})),
+		createProviderIfTokenMissing(externalProviderTokens, IDLE_CALLBACK_TRAIT_TOKEN, () => createBuiltInTraitUnit({
+			token: IDLE_CALLBACK_TRAIT_TOKEN,
+			traitName: "idleCallback",
+			bundledSchema: IdleCallbackTraitSchema,
+			validator: overrides.validators?.idleCallback,
+			optional: true,
+			createValue: () => overrides.idleCallback ?? null
+		})),
+		createProviderIfTokenMissing(externalProviderTokens, PERSISTENT_STORAGE_TRAIT_TOKEN, () => createBuiltInTraitUnit({
+			token: PERSISTENT_STORAGE_TRAIT_TOKEN,
+			traitName: "persistentStorage",
+			bundledSchema: StorageTraitSchema,
+			validator: overrides.validators?.persistentStorage,
+			optional: true,
+			createValue: () => overrides.persistentStorage ?? null
+		})),
+		createProviderIfTokenMissing(externalProviderTokens, SESSION_STORAGE_TRAIT_TOKEN, () => createBuiltInTraitUnit({
+			token: SESSION_STORAGE_TRAIT_TOKEN,
+			traitName: "sessionStorage",
+			bundledSchema: StorageTraitSchema,
+			validator: overrides.validators?.sessionStorage,
+			optional: true,
+			createValue: () => overrides.sessionStorage ?? null
+		})),
+		createProviderIfTokenMissing(externalProviderTokens, ROUTER_TRAIT_TOKEN, () => createBuiltInTraitUnit({
+			token: ROUTER_TRAIT_TOKEN,
+			traitName: "router",
+			bundledSchema: RouterTraitSchema,
+			validator: overrides.validators?.router,
+			optional: true,
+			createValue: () => overrides.router ?? null
+		})),
+		createProviderIfTokenMissing(externalProviderTokens, PAGE_LIFECYCLE_TRAIT_TOKEN, () => createBuiltInTraitUnit({
+			token: PAGE_LIFECYCLE_TRAIT_TOKEN,
+			traitName: "pageLifecycle",
+			bundledSchema: PageLifecycleTraitSchema,
+			validator: overrides.validators?.pageLifecycle,
+			optional: true,
+			createValue: () => overrides.pageLifecycle ?? null
+		})),
+		createProviderIfTokenMissing(externalProviderTokens, POPUP_TRAIT_TOKEN, () => createBuiltInTraitUnit({
+			token: POPUP_TRAIT_TOKEN,
+			traitName: "popup",
+			bundledSchema: PopupTraitSchema,
+			validator: overrides.validators?.popup,
+			optional: true,
+			createValue: () => overrides.popup ?? null
+		}))
+	].filter(notMissingProvider);
+}
+function createBuiltInTraitUnit(options) {
+	return {
+		provide: options.token,
+		useFactory: ((...deps) => {
+			const value = options.createValue(...deps);
+			validateTraitInput({
+				value,
+				bundledSchema: options.bundledSchema,
+				validator: options.validator,
+				optional: options.optional,
+				onInvalid: (failure) => throwValidationClientError({
+					code: "environment.trait_validation_failed",
+					source: "environment",
+					messagePrefix: `createFoundationEnvironment could not validate ${options.traitName}`,
+					failure
+				})
+			});
+			return value;
+		}),
+		deps: options.deps
+	};
+}
+function createFoundationEnvironmentUnit() {
+	return {
+		provide: ENVIRONMENT_TOKEN,
+		useFactory: ((injector, transport, time, realmStorage, span, tracing, idleCallback, persistentStorage, sessionStorage, router, pageLifecycle, popup) => {
+			return {
+				injector,
+				transport,
+				time,
+				realmStorage,
+				idleCallback: idleCallback ?? void 0,
+				persistentStorage: persistentStorage ?? void 0,
+				sessionStorage: sessionStorage ?? void 0,
+				span,
+				tracing,
+				router: router ?? void 0,
+				pageLifecycle: pageLifecycle ?? void 0,
+				popup: popup ?? void 0
+			};
+		}),
+		deps: [
+			INJECTOR_TOKEN,
+			TRANSPORT_TRAIT_TOKEN,
+			TIME_TRAIT_TOKEN,
+			REALM_STORAGE_TRAIT_TOKEN,
+			SPAN_TRAIT_TOKEN,
+			TRACING_TRAIT_TOKEN,
+			IDLE_CALLBACK_TRAIT_TOKEN,
+			PERSISTENT_STORAGE_TRAIT_TOKEN,
+			SESSION_STORAGE_TRAIT_TOKEN,
+			ROUTER_TRAIT_TOKEN,
+			PAGE_LIFECYCLE_TRAIT_TOKEN,
+			POPUP_TRAIT_TOKEN
+		]
+	};
+}
+//#endregion
+export { notMissingProvider as $, SECURITYDEPT_COMPAT_FRAGMENT_VERSION as A, validateWithSchema as B, SPAN_TRAIT_TOKEN as C, RouterNavigationIntent as D, ROUTER_TRAIT_TOKEN as E, POPUP_TRAIT_TOKEN as F, INJECTOR_TOKEN as G, PAGE_LIFECYCLE_TRAIT_TOKEN as H, PopupAttachFailureReason as I, toRuntimeInjector as J, PARENT_INJECTOR_TOKEN as K, formatValidationFailure as L, isCompatFragmentBlock as M, parseCompatFragment as N, RouterNavigationMode as O, takeCompatFragment as P, getSecuritydeptProviderToken as Q, throwValidationClientError as R, createRootSpan as S, TIME_TRAIT_TOKEN as T, EventSourceKind as U, validateWithSchemaSync as V, isEventStreamTrait as W, SecuritydeptInjectionToken as X, SecurityDeptOptional as Y, createProviderIfTokenMissing as Z, createTimeForStd as _, TRACING_TRAIT_TOKEN as a, normalizeAbortError as b, createInMemoryRecordStore as c, SESSION_STORAGE_TRAIT_TOKEN as d, StorageChangeEventOrigin as f, TransportErrorCode as g, TRANSPORT_TRAIT_TOKEN as h, TRACING_SPAN_ATTRIBUTE_PROVIDER_ID as i, appendOrReplaceCompatFragment as j, takeCompatFragmentFromRouter as k, PERSISTENT_STORAGE_TRAIT_TOKEN as l, createBaseTransportForStdFetch as m, ENVIRONMENT_TOKEN as n, TracingLevel as o, FetchTransportRedirectKind as p, SecuritydeptInjector as q, OperationTraceEventType as r, createTracing as s, createFoundationEnvironment as t, REALM_STORAGE_TRAIT_TOKEN as u, abortSignalToCancellationToken as v, IDLE_CALLBACK_TRAIT_TOKEN as w, abortSignalToEventStream as x, cancellationTokenToAbortSignal as y, validateTraitInput as z };
+
+//# sourceMappingURL=create-i5VyYgN6.mjs.map