@securitydept/client 0.2.0 → 0.3.0-beta.10

package/dist/rx-DM6Ouv-m.mjs

@@ -0,0 +1,1119 @@
+import { BehaviorSubject, EMPTY, NEVER, Observable, ReplaySubject, Subject, animationFrameScheduler, asapScheduler, audit, auditTime, catchError, concat, concatAll, defer, distinctUntilChanged, filter, finalize, firstValueFrom, from, fromEventPattern, lastValueFrom, map, merge, of, share, shareReplay, switchMap, take, takeLast, takeUntil, takeWhile, toArray } from "rxjs";
+import { AsyncAction } from "rxjs/internal/scheduler/AsyncAction";
+import { AsyncScheduler } from "rxjs/internal/scheduler/AsyncScheduler";
+import { BehaviorSubject as BehaviorSubject$1 } from "rxjs/internal/BehaviorSubject";
+//#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",
+	Storage: "storage",
+	Configuration: "configuration",
+	Unauthenticated: "unauthenticated",
+	Unauthorized: "unauthorized",
+	Cancelled: "cancelled",
+	Timeout: "timeout",
+	Internal: "internal"
+};
+/** Stable source vocabulary for common client error producers. */
+const ClientErrorSource = {
+	Transport: "transport",
+	Server: "server",
+	Client: "client"
+};
+//#endregion
+//#region src/errors/client-error.ts
+const CLIENT_ERROR_SPAN_ATTRIBUTE_PROVIDER_ID = "@securitydept/client/error";
+const userRecoveryValues = new Set(Object.values(UserRecovery));
+function readUserRecovery(value) {
+	return typeof value === "string" && userRecoveryValues.has(value) ? value : void 0;
+}
+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 === 408 ? ClientErrorKind.Timeout : status >= 500 ? ClientErrorKind.Server : ClientErrorKind.Protocol;
+	}
+}
+function readServerErrorBody(body) {
+	if (!body || typeof body !== "object") return;
+	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 {
+	_spanContext;
+	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;
+	get spanContext() {
+		return this._spanContext;
+	}
+	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;
+		if (options.span) this.captureSpanContext(options.span);
+	}
+	captureSpanContext(span) {
+		this._spanContext ??= span.getRootToNodeAttributes({ providerId: CLIENT_ERROR_SPAN_ATTRIBUTE_PROVIDER_ID });
+		return this;
+	}
+	/** Create a `ClientError` from a server error response body. */
+	static fromServerError(body, overrides) {
+		const rawPresentation = body.presentation;
+		const recovery = readUserRecovery(body.recovery) ?? readUserRecovery(rawPresentation?.recovery) ?? UserRecovery.None;
+		const presentation = rawPresentation?.code && rawPresentation.message ? {
+			code: rawPresentation.code,
+			message: rawPresentation.message,
+			recovery: readUserRecovery(rawPresentation.recovery) ?? recovery
+		} : void 0;
+		return new ClientError({
+			kind: overrides?.kind ?? mapServerErrorKind(body.kind, 400),
+			message: body.message ?? presentation?.message ?? "Unknown server error",
+			code: body.code ?? presentation?.code,
+			recovery,
+			retryable: recovery === UserRecovery.Retry,
+			presentation,
+			source: overrides?.source,
+			span: overrides?.span
+		});
+	}
+	static fromUnknown(error, options) {
+		if (error instanceof ClientError) return options.span ? error.captureSpanContext(options.span) : error;
+		return new ClientError({
+			kind: ClientErrorKind.Internal,
+			message: options.message,
+			code: options.code,
+			source: options.source,
+			cause: error,
+			span: options.span
+		});
+	}
+	/**
+	* Create a `ClientError` from an HTTP response status and optional body.
+	* Used when a non-success status is unexpected.
+	*/
+	static fromHttpResponse(options) {
+		const { status, body } = options;
+		const serverBody = readServerErrorBody(body);
+		const kind = mapServerErrorKind(serverBody?.kind, status);
+		const source = options.source ?? ClientErrorSource.Server;
+		const fallbackRecovery = kind === ClientErrorKind.Unauthenticated ? UserRecovery.Reauthenticate : status === 408 || status >= 500 ? UserRecovery.Retry : UserRecovery.None;
+		if (serverBody?.code && serverBody?.message) {
+			const recovery = readUserRecovery(serverBody.presentation?.recovery) ?? readUserRecovery(serverBody.recovery) ?? fallbackRecovery;
+			return ClientError.fromServerError({
+				...serverBody,
+				recovery,
+				presentation: serverBody.presentation ? {
+					...serverBody.presentation,
+					recovery
+				} : void 0
+			}, {
+				kind,
+				source,
+				span: options.span
+			});
+		}
+		return new ClientError({
+			kind,
+			message: serverBody?.message ?? `HTTP ${status}`,
+			code: serverBody?.code ?? `http.${status}`,
+			recovery: fallbackRecovery,
+			retryable: status === 408 || status >= 500,
+			source,
+			span: options.span
+		});
+	}
+};
+//#endregion
+//#region src/compat/disposable.ts
+const SYMBOL_DISPOSE = typeof Symbol !== "undefined" && Symbol.dispose ? Symbol.dispose : "@@dispose";
+const SYMBOL_ASYNC_DISPOSE = typeof Symbol !== "undefined" && Symbol.asyncDispose ? Symbol.asyncDispose : "@@asyncDispose";
+const SYMBOL_DISPOSABLE_STACK = "@@disposableStack";
+function injectDisposableStackFrom(arg, isOptions = false) {
+	return isOptions && typeof arg === "object" && arg !== null ? arg[SYMBOL_DISPOSABLE_STACK] : arg;
+}
+var SimpleDisposableStack = class {
+	stack = [];
+	disposed = false;
+	use(disposable) {
+		if (this.disposed) throw new ReferenceError("Disposable stack is already disposed");
+		this.stack.push(disposable);
+		return disposable;
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		const errors = [];
+		for (let disposable = this.stack.pop(); disposable; disposable = this.stack.pop()) try {
+			disposable.dispose();
+		} catch (error) {
+			errors.push(error);
+		}
+		if (errors.length === 1) throw errors[0];
+		if (errors.length > 1) throw new AggregateError(errors, "Failed to dispose disposable stack");
+	}
+	[SYMBOL_DISPOSE]() {
+		this.dispose();
+	}
+};
+var StdDisposableStack = class {
+	stack;
+	constructor(Stack = globalThis.DisposableStack) {
+		this.stack = new Stack();
+	}
+	get disposed() {
+		return this.stack.disposed;
+	}
+	use(disposable) {
+		return this.stack.use(disposable);
+	}
+	dispose() {
+		this.stack.dispose();
+	}
+	[SYMBOL_DISPOSE]() {
+		this.dispose();
+	}
+};
+function createDisposableStack() {
+	const Stack = globalThis.DisposableStack;
+	return typeof Stack === "function" ? new StdDisposableStack(Stack) : new SimpleDisposableStack();
+}
+function withDisposableStack(index, isOptions = false) {
+	return (target, _context) => function(...args) {
+		const disposableStack = createDisposableStack();
+		const injectedArgs = [...args];
+		if (isOptions) {
+			const value = injectedArgs[index];
+			injectedArgs[index] = Object.assign({}, typeof value === "object" && value !== null ? value : void 0, { [SYMBOL_DISPOSABLE_STACK]: disposableStack });
+		} else injectedArgs[index] = disposableStack;
+		let result;
+		try {
+			result = target.call(this, ...injectedArgs);
+		} catch (error) {
+			disposableStack.dispose();
+			throw error;
+		}
+		if (typeof result === "object" && result !== null && "then" in result && typeof result.then === "function") return Promise.resolve(result).finally(() => {
+			disposableStack.dispose();
+		});
+		disposableStack.dispose();
+		return result;
+	};
+}
+//#endregion
+//#region src/compat/observable.ts
+const SYMBOL_OBSERVABLE = typeof Symbol !== "undefined" && Symbol.observable ? Symbol.observable : "@@observable";
+function isInteropObservableTrait(value) {
+	return typeof value === "object" && value !== null && SYMBOL_OBSERVABLE in value && typeof value[SYMBOL_OBSERVABLE] === "function";
+}
+//#endregion
+//#region src/rx/event.ts
+var RxEventStream = class RxEventStream extends Observable {
+	constructor(source) {
+		super((subscriber) => {
+			if (typeof source === "function") return source(subscriber);
+			if (isInteropObservableTrait(source)) {
+				const subscription = source[SYMBOL_OBSERVABLE]().subscribe(subscriber);
+				return () => {
+					subscription.unsubscribe();
+				};
+			}
+			if (typeof source === "object" && source !== null && "subscribe" in source && typeof source.subscribe === "function") {
+				const subscription = source.subscribe(subscriber);
+				return () => {
+					subscription.unsubscribe();
+				};
+			}
+			const subscription = from(source).subscribe(subscriber);
+			return () => {
+				subscription.unsubscribe();
+			};
+		});
+	}
+	[SYMBOL_OBSERVABLE]() {
+		return this;
+	}
+	static fromObservableInput(input) {
+		if (input instanceof RxEventStream) return input;
+		return new RxEventStream(input);
+	}
+	pipe(...args) {
+		const piped = super.pipe(...args);
+		return RxEventStream.fromObservableInput(piped);
+	}
+};
+var RxEventSubject = class extends Subject {
+	[SYMBOL_OBSERVABLE]() {
+		return this.asObservable();
+	}
+	asObservable() {
+		return RxEventStream.fromObservableInput(super.asObservable());
+	}
+};
+var RxEventReplaySubject = class extends ReplaySubject {
+	[SYMBOL_OBSERVABLE]() {
+		return this.asObservable();
+	}
+	asObservable() {
+		return RxEventStream.fromObservableInput(super.asObservable());
+	}
+};
+//#endregion
+//#region src/rx/signal.ts
+function watchOptionsToAuditOperator(options) {
+	if (options.schedule === globalThis.queueMicrotask) return auditTime(0, asapScheduler);
+	if (options.schedule === globalThis.requestAnimationFrame && options.cancel === globalThis.cancelAnimationFrame) return auditTime(0, animationFrameScheduler);
+	return audit(() => fromEventPattern((handler) => options.schedule(() => handler()), (_handler, handle) => {
+		if (options.cancel) options.cancel(handle);
+		else if (typeof handle === "function") handle();
+	}));
+}
+var RxSignal = class {
+	static globalEpoch = 0;
+	static currentContext = null;
+	valueEqVersion = 0;
+	equals;
+	constructor(options) {
+		this.equals = options?.equals ?? Object.is;
+	}
+	watchStream(options = { schedule: globalThis.queueMicrotask }) {
+		return RxEventStream.fromObservableInput(this.dirtyObservable().pipe(watchOptionsToAuditOperator(options), map(() => void 0), shareReplay({
+			bufferSize: 1,
+			refCount: true
+		})));
+	}
+	[SYMBOL_OBSERVABLE]() {
+		return RxEventStream.fromObservableInput(defer(() => concat(of(this.get()), this.dirtyObservable().pipe(map(() => this.get())))));
+	}
+};
+var RxStateSignal = class RxStateSignal extends RxSignal {
+	dirtySubject = new Subject();
+	value;
+	constructor(initialValue, options) {
+		super(options);
+		this.value = new BehaviorSubject(initialValue);
+	}
+	set(input) {
+		const changed = !this.equals(this.value.getValue(), input);
+		this.value.next(input);
+		if (changed) this.valueEqVersion += 1;
+		RxSignal.globalEpoch += 1;
+		this.dirtySubject.next({
+			epoch: RxSignal.globalEpoch,
+			signal: this
+		});
+	}
+	static fromInitialValue(initialValue, options) {
+		return new RxStateSignal(initialValue, options);
+	}
+	get() {
+		const value = this.value.getValue();
+		RxSignal.currentContext?.markDependency(this);
+		return value;
+	}
+	validateForEpoch() {}
+	dirtyObservable() {
+		return this.dirtySubject.asObservable();
+	}
+	[SYMBOL_OBSERVABLE]() {
+		return RxEventStream.fromObservableInput(this.value.asObservable());
+	}
+};
+function haveSameSourceKeys(left, right) {
+	if (left.size !== right.size) return false;
+	const leftSources = left.keys();
+	const rightSources = right.keys();
+	while (true) {
+		const leftSource = leftSources.next();
+		const rightSource = rightSources.next();
+		if (leftSource.done || rightSource.done) return leftSource.done === rightSource.done;
+		if (leftSource.value !== rightSource.value) return false;
+	}
+}
+var RxComputedSignal = class RxComputedSignal extends RxSignal {
+	computeFn;
+	cacheState = { kind: "empty" };
+	sources = /* @__PURE__ */ new Map();
+	sourcesSubject = new BehaviorSubject(this.sources);
+	validatedEpoch = -1;
+	isComputing = false;
+	collectingSources = null;
+	dirty$;
+	constructor(computeFn, options) {
+		super(options);
+		this.computeFn = computeFn;
+	}
+	markDependency(signal) {
+		const source = signal;
+		this.collectingSources?.set(source, source.valueEqVersion);
+	}
+	cacheStatesEqual(left, right) {
+		if (left.kind !== right.kind) return false;
+		if (left.kind === "empty" || right.kind === "empty") return false;
+		if (left.kind === "value" && right.kind === "value") return this.equals(left.value, right.value);
+		if (left.kind === "error" && right.kind === "error") return Object.is(left.error, right.error);
+		return false;
+	}
+	recompute() {
+		if (this.isComputing) throw new Error("Circular computed dependency detected");
+		const prevContext = RxSignal.currentContext;
+		const prevCollectingSources = this.collectingSources;
+		const nextSources = /* @__PURE__ */ new Map();
+		RxSignal.currentContext = this;
+		this.collectingSources = nextSources;
+		this.isComputing = true;
+		let nextCacheState;
+		try {
+			nextCacheState = {
+				kind: "value",
+				value: this.computeFn()
+			};
+		} catch (error) {
+			nextCacheState = {
+				kind: "error",
+				error
+			};
+		} finally {
+			this.collectingSources = prevCollectingSources;
+			RxSignal.currentContext = prevContext;
+			this.isComputing = false;
+		}
+		const sourcesChanged = !haveSameSourceKeys(this.sources, nextSources);
+		let cacheStateChanged;
+		try {
+			cacheStateChanged = !this.cacheStatesEqual(this.cacheState, nextCacheState);
+		} catch (error) {
+			nextCacheState = {
+				kind: "error",
+				error
+			};
+			cacheStateChanged = !this.cacheStatesEqual(this.cacheState, nextCacheState);
+		}
+		if (cacheStateChanged) this.valueEqVersion += 1;
+		this.cacheState = nextCacheState;
+		this.sources = nextSources;
+		if (sourcesChanged) this.sourcesSubject.next(nextSources);
+		if (nextCacheState.kind === "error") throw nextCacheState.error;
+	}
+	validateForEpoch(epoch) {
+		if (this.validatedEpoch === epoch) return;
+		try {
+			if (this.cacheState.kind === "empty") {
+				this.recompute();
+				return;
+			}
+			for (const [source, version] of this.sources) {
+				try {
+					source.validateForEpoch(epoch);
+				} catch {
+					this.recompute();
+					break;
+				}
+				if (source.valueEqVersion !== version) {
+					this.recompute();
+					break;
+				}
+			}
+		} finally {
+			this.validatedEpoch = epoch;
+		}
+	}
+	get() {
+		this.validateForEpoch(RxSignal.globalEpoch);
+		RxSignal.currentContext?.markDependency(this);
+		switch (this.cacheState.kind) {
+			case "value": return this.cacheState.value;
+			case "error": throw this.cacheState.error;
+			case "empty": throw new Error("Computed signal has not been initialized");
+		}
+	}
+	dirtyObservable() {
+		if (!this.dirty$) this.dirty$ = defer(() => {
+			this.validateForEpoch(RxSignal.globalEpoch);
+			return this.sourcesSubject.asObservable().pipe(switchMap((sources) => sources.size === 0 ? EMPTY : merge(...[...sources.keys()].map((source) => source.dirtyObservable())).pipe(distinctUntilChanged((left, right) => left.epoch === right.epoch), map((dirtyDepEvent) => {
+				return {
+					epoch: dirtyDepEvent.epoch,
+					signal: this
+				};
+			}))));
+		}).pipe(share());
+		return this.dirty$;
+	}
+	static computed(fn, options) {
+		return new RxComputedSignal(fn, options);
+	}
+};
+//#endregion
+//#region src/rx/command.ts
+/** biome-ignore-all lint/complexity/noBannedTypes: false negative */
+const CommandResponseType = {
+	Data: "data",
+	Success: "success",
+	Error: "error",
+	Cancel: "cancel",
+	Rejected: "rejected"
+};
+function createCommandCancellationError(command) {
+	return new ClientError({
+		kind: ClientErrorKind.Cancelled,
+		message: "Command was cancelled before completion",
+		cause: { command }
+	});
+}
+function createCommandRejectedError(command, reason) {
+	return new ClientError({
+		kind: ClientErrorKind.Cancelled,
+		message: `Command was rejected before execution: ${reason}`,
+		cause: {
+			command,
+			reason
+		}
+	});
+}
+function isCommandDataResponse(response) {
+	return response.type === CommandResponseType.Data;
+}
+function isCommandTerminalResponse(response) {
+	return response.type !== CommandResponseType.Data;
+}
+function dispatchCommand(dispatch, matches) {
+	return (source$) => new Observable((subscriber) => {
+		const subscription = source$.pipe(filter(matches), takeWhile(isCommandDataResponse, true)).subscribe(subscriber);
+		if (subscription.closed) return subscription;
+		try {
+			dispatch();
+		} catch (error) {
+			if (!subscription.closed) subscriber.error(error);
+		}
+		return subscription;
+	});
+}
+function unwrapCommandTerminalResponse(response) {
+	switch (response.type) {
+		case CommandResponseType.Success: return;
+		case CommandResponseType.Error: throw response.error;
+		case CommandResponseType.Cancel: throw createCommandCancellationError(response.command);
+		case CommandResponseType.Rejected: throw createCommandRejectedError(response.command, response.reason);
+	}
+}
+function commandResponseData() {
+	return (source$) => source$.pipe(filter((response) => {
+		if (isCommandDataResponse(response)) return true;
+		unwrapCommandTerminalResponse(response);
+		return false;
+	}), map((response) => response.data));
+}
+function dispatchCommandLocallyToStream(options) {
+	const command = {
+		payload: options.payload,
+		...options.createCommandExtra?.(options.payload) ?? {}
+	};
+	return from(options.responseStream).pipe(dispatchCommand(() => {
+		options.requestStream.next(command);
+	}, (response) => response.command === command));
+}
+function dispatchCommandByIdToStream(options) {
+	const areIdsEqual = options.areIdsEqual ?? Object.is;
+	const commandId = options.selectCommandId(options.command);
+	return from(options.responseStream).pipe(dispatchCommand(() => {
+		options.requestStream.next(options.command);
+	}, (response) => areIdsEqual(options.selectCommandId(response.command), commandId)));
+}
+async function dispatchCommandLocallyToPromise(options) {
+	const [data, terminal] = await lastValueFrom(dispatchCommandLocallyToStream(options).pipe(takeLast(2), toArray()), { defaultValue: [] });
+	if (data === void 0) throw new ClientError({
+		kind: ClientErrorKind.Configuration,
+		message: "the executor configuration of dispatchCommandLocallyToPromise should produce a valid data response."
+	});
+	if (!isCommandDataResponse(data)) throw new ClientError({
+		kind: ClientErrorKind.Configuration,
+		message: "the executor configuration of dispatchCommandLocallyToPromise should produce a valid data response."
+	});
+	if (terminal === void 0) throw new ClientError({
+		kind: ClientErrorKind.Internal,
+		message: "the execution of dispatchCommandLocallyToPromise must produce a valid terminal response."
+	});
+	if (!isCommandTerminalResponse(terminal)) throw new ClientError({
+		kind: ClientErrorKind.Internal,
+		message: "the execution of dispatchCommandLocallyToPromise must produce a valid terminal response."
+	});
+	unwrapCommandTerminalResponse(terminal);
+	return data;
+}
+async function dispatchCommandByIdToPromise(options) {
+	const [data, terminal] = await lastValueFrom(dispatchCommandByIdToStream(options).pipe(takeLast(2), toArray()), { defaultValue: [] });
+	if (data === void 0) throw new ClientError({
+		kind: ClientErrorKind.Configuration,
+		message: "the executor configuration of dispatchCommandLocallyToPromise should produce a valid data response."
+	});
+	if (!isCommandDataResponse(data)) throw new ClientError({
+		kind: ClientErrorKind.Configuration,
+		message: "the executor configuration of dispatchCommandLocallyToPromise should produce a valid data response."
+	});
+	if (terminal === void 0) throw new ClientError({
+		kind: ClientErrorKind.Internal,
+		message: "the execution of dispatchCommandLocallyToPromise must produce a valid terminal response."
+	});
+	if (!isCommandTerminalResponse(terminal)) throw new ClientError({
+		kind: ClientErrorKind.Internal,
+		message: "the execution of dispatchCommandLocallyToPromise must produce a valid terminal response."
+	});
+	unwrapCommandTerminalResponse(terminal);
+	return data;
+}
+function createCommandExecutionStream(options) {
+	return new Observable((subscriber) => {
+		let didEmitTerminal = false;
+		const emitTerminal = (response) => {
+			if (didEmitTerminal) return;
+			didEmitTerminal = true;
+			subscriber.next(response);
+			subscriber.complete();
+		};
+		const subscription = from(options.execute(options.command)).subscribe({
+			next: (data) => {
+				subscriber.next({
+					type: CommandResponseType.Data,
+					command: options.command,
+					data
+				});
+			},
+			error: (error) => {
+				emitTerminal({
+					type: CommandResponseType.Error,
+					command: options.command,
+					error
+				});
+			},
+			complete: () => {
+				emitTerminal({
+					type: CommandResponseType.Success,
+					command: options.command
+				});
+			}
+		});
+		return () => {
+			const wasTerminalEmitted = didEmitTerminal;
+			subscription.unsubscribe();
+			options.onStateEnd?.(options.command);
+			if (!wasTerminalEmitted) subscriber.next({
+				type: CommandResponseType.Cancel,
+				command: options.command
+			});
+		};
+	});
+}
+function switchCommand(execute) {
+	return (source$) => new Observable((destination) => {
+		let innerSubscription = null;
+		let currentCommand = null;
+		let isComplete = false;
+		const checkComplete = () => {
+			if (isComplete && !innerSubscription) destination.complete();
+		};
+		const sourceSubscription = source$.subscribe({
+			next: (command) => {
+				const cancelledCommand = currentCommand;
+				innerSubscription?.unsubscribe();
+				innerSubscription = null;
+				currentCommand = null;
+				if (cancelledCommand) destination.next({
+					type: CommandResponseType.Cancel,
+					command: cancelledCommand
+				});
+				currentCommand = command;
+				let didCompleteSynchronously = false;
+				const nextInnerSubscription = createCommandExecutionStream({
+					command,
+					execute
+				}).subscribe({
+					next: (response) => {
+						destination.next(response);
+					},
+					error: (error) => {
+						destination.error(error);
+					},
+					complete: () => {
+						didCompleteSynchronously = true;
+						innerSubscription = null;
+						currentCommand = null;
+						checkComplete();
+					}
+				});
+				if (!didCompleteSynchronously) innerSubscription = nextInnerSubscription;
+			},
+			error: (error) => {
+				destination.error(error);
+			},
+			complete: () => {
+				isComplete = true;
+				checkComplete();
+			}
+		});
+		return () => {
+			sourceSubscription.unsubscribe();
+			innerSubscription?.unsubscribe();
+		};
+	});
+}
+function concatCommand(execute) {
+	return (source$) => source$.pipe(map((command) => createCommandExecutionStream({
+		command,
+		execute
+	})), concatAll());
+}
+const exhaustCommand = (execute) => (source$) => new Observable((destination) => {
+	let innerSubscription = null;
+	let isComplete = false;
+	const checkComplete = () => {
+		if (isComplete && !innerSubscription) destination.complete();
+	};
+	const sourceSubscription = source$.subscribe({
+		next: (command) => {
+			if (innerSubscription) {
+				destination.next({
+					type: CommandResponseType.Rejected,
+					command,
+					reason: "Pessimistic lock active."
+				});
+				return;
+			}
+			let didCompleteSynchronously = false;
+			const nextInnerSubscription = createCommandExecutionStream({
+				command,
+				execute
+			}).subscribe({
+				next: (response) => {
+					destination.next(response);
+				},
+				error: (error) => {
+					destination.error(error);
+				},
+				complete: () => {
+					didCompleteSynchronously = true;
+					innerSubscription = null;
+					checkComplete();
+				}
+			});
+			if (!didCompleteSynchronously) innerSubscription = nextInnerSubscription;
+		},
+		error: (error) => {
+			destination.error(error);
+		},
+		complete: () => {
+			isComplete = true;
+			checkComplete();
+		}
+	});
+	return () => {
+		sourceSubscription.unsubscribe();
+		innerSubscription?.unsubscribe();
+	};
+});
+//#endregion
+//#region src/rx/environment.ts
+function createAsyncSchedulerWithTimestampProvider(time) {
+	class TimeTraitAsyncAction extends AsyncAction {
+		requestAsyncId(scheduler, _id, delay = 0) {
+			return time.setTimeout(() => {
+				scheduler.flush(this);
+			}, delay);
+		}
+		recycleAsyncId(_scheduler, id, delay = 0) {
+			if (delay != null && this.delay === delay && this.pending === false) return id;
+			if (id !== void 0) time.clearTimeout(id);
+		}
+	}
+	return new AsyncScheduler(TimeTraitAsyncAction, time.now);
+}
+//#endregion
+//#region src/cancellation/create.ts
+var CancellationToken = class {
+	cancellationState = new BehaviorSubject$1(void 0);
+	get isCancellationRequested() {
+		return this.cancellationState.getValue()?.isCancelled === true;
+	}
+	get reason() {
+		return this.cancellationState.getValue()?.reason;
+	}
+	/** @internal — called by `CancellationTokenSource`. */
+	_cancel(reason) {
+		if (this.isCancellationRequested) return;
+		this.cancellationState.next({
+			isCancelled: true,
+			reason,
+			cancellationError: new ClientError({
+				kind: ClientErrorKind.Cancelled,
+				message: "Operation was cancelled",
+				code: "client.cancelled",
+				source: ClientErrorSource.Client,
+				cause: reason
+			})
+		});
+	}
+	onCancellationRequested(listener) {
+		const cancellationState = this.cancellationState.getValue();
+		if (cancellationState?.isCancelled) {
+			listener({
+				cancellationError: cancellationState.cancellationError,
+				reason: cancellationState.reason
+			});
+			return {
+				dispose() {},
+				[SYMBOL_DISPOSE]() {}
+			};
+		}
+		const subscription = this.asObservable().subscribe((errorData) => {
+			listener(errorData);
+		});
+		return {
+			dispose() {
+				subscription.unsubscribe();
+			},
+			[SYMBOL_DISPOSE]: () => {
+				subscription.unsubscribe();
+			}
+		};
+	}
+	throwIfCancellationRequested() {
+		const cancellationState = this.cancellationState.getValue();
+		if (cancellationState?.cancellationError) throw cancellationState.cancellationError;
+	}
+	get cancellationError() {
+		return this.cancellationState.getValue()?.cancellationError;
+	}
+	asObservable() {
+		return this.cancellationState.pipe(filter((state) => !!state?.isCancelled), take(1), map((state) => ({
+			cancellationError: state.cancellationError,
+			reason: state.reason
+		})));
+	}
+	[SYMBOL_OBSERVABLE]() {
+		return this.asObservable();
+	}
+};
+var CancellationTokenSource = class {
+	token = new CancellationToken();
+	cancel(reason) {
+		this.token._cancel(reason);
+	}
+};
+/**
+* Create a `CancellationTokenSource` that produces a cooperative cancellation token.
+*/
+function createCancellationTokenSource() {
+	return new CancellationTokenSource();
+}
+function isCancellationTokenTrait(obj) {
+	return typeof obj === "object" && obj !== null && typeof obj.isCancellationRequested === "boolean" && typeof obj.onCancellationRequested === "function" && typeof obj.throwIfCancellationRequested === "function" && isInteropObservableTrait(obj);
+}
+//#endregion
+//#region src/signals/error.ts
+const ResourceErrorCode = { ValueUnavailable: "resource.value_unavailable" };
+var ResourceError = class ResourceError extends Error {
+	name = "ResourceError";
+	code;
+	status;
+	constructor(message, options) {
+		super(message);
+		this.code = options.code;
+		this.status = options.status;
+	}
+	static valueUnavailable(options) {
+		return new ResourceError(`Resource value is not available while status is "${options.status}".`, {
+			code: ResourceErrorCode.ValueUnavailable,
+			status: options.status
+		});
+	}
+};
+//#endregion
+//#region src/signals/types.ts
+const ResourceStatus = {
+	Idle: "idle",
+	Loading: "loading",
+	LoadingError: "loading_error",
+	Reloading: "reloading",
+	Resolved: "resolved",
+	Error: "error"
+};
+//#endregion
+//#region src/signals/resource-snapshot.ts
+async function whenResourceSnapshotValue(snapshotSignal, options) {
+	options?.cancellationToken?.throwIfCancellationRequested();
+	const staleValueWhenError = options?.staleValueWhenError ?? true;
+	const current = snapshotSignal.get();
+	if (current.status === ResourceStatus.Resolved || current.status === ResourceStatus.Reloading || current.status === ResourceStatus.Error && staleValueWhenError) return current.value;
+	if (current.status === ResourceStatus.LoadingError || current.status === ResourceStatus.Error) throw current.error;
+	const snapshot = await firstValueFrom(merge(from(snapshotSignal).pipe(filter((snapshot) => snapshot.status === ResourceStatus.Resolved || snapshot.status === ResourceStatus.Reloading || snapshot.status === ResourceStatus.LoadingError || snapshot.status === ResourceStatus.Error)), (options?.cancellationToken ? from(options.cancellationToken) : NEVER).pipe(map(({ cancellationError }) => {
+		throw cancellationError;
+	}))));
+	if (snapshot.status === ResourceStatus.LoadingError) throw snapshot.error;
+	if (snapshot.status === ResourceStatus.Error && !staleValueWhenError) throw snapshot.error;
+	return snapshot.value;
+}
+/**
+* Flatten nested resource snapshots while tracking each selected snapshot signal.
+* Ancestor reload and error states remain visible whenever the final snapshot has
+* a value; an ancestor error without a final value becomes a loading error.
+*/
+function flattenResourceSnapshot(sourceSnapshot, ...selectors) {
+	let snapshot = sourceSnapshot;
+	let reloading = false;
+	let hasError = false;
+	let error;
+	for (const select of selectors) switch (snapshot.status) {
+		case ResourceStatus.Idle:
+		case ResourceStatus.Loading: return hasError ? {
+			status: ResourceStatus.LoadingError,
+			error
+		} : snapshot;
+		case ResourceStatus.LoadingError: return hasError ? {
+			status: ResourceStatus.LoadingError,
+			error
+		} : snapshot;
+		case ResourceStatus.Reloading:
+			reloading = true;
+			snapshot = select(snapshot.value).get();
+			break;
+		case ResourceStatus.Resolved:
+			snapshot = select(snapshot.value).get();
+			break;
+		case ResourceStatus.Error:
+			if (!hasError) {
+				hasError = true;
+				error = snapshot.error;
+			}
+			snapshot = select(snapshot.value).get();
+	}
+	switch (snapshot.status) {
+		case ResourceStatus.Idle:
+		case ResourceStatus.Loading:
+		case ResourceStatus.LoadingError: return hasError ? {
+			status: ResourceStatus.LoadingError,
+			error
+		} : snapshot;
+		case ResourceStatus.Reloading: return hasError ? {
+			status: ResourceStatus.Error,
+			value: snapshot.value,
+			error
+		} : snapshot;
+		case ResourceStatus.Resolved: return hasError ? {
+			status: ResourceStatus.Error,
+			value: snapshot.value,
+			error
+		} : reloading ? {
+			status: ResourceStatus.Reloading,
+			value: snapshot.value
+		} : snapshot;
+		case ResourceStatus.Error: return hasError ? {
+			status: ResourceStatus.Error,
+			value: snapshot.value,
+			error
+		} : snapshot;
+	}
+}
+const ResourceSnapshotUpdateKind = {
+	Load: "load",
+	Resolve: "resolve",
+	Fail: "fail",
+	FailWithValue: "fail_with_value"
+};
+function reduceResourceSnapshot(previous, update) {
+	switch (update.kind) {
+		case ResourceSnapshotUpdateKind.Load: return previous.status === ResourceStatus.Reloading || previous.status === ResourceStatus.Resolved || previous.status === ResourceStatus.Error ? {
+			status: ResourceStatus.Reloading,
+			value: previous.value
+		} : { status: ResourceStatus.Loading };
+		case ResourceSnapshotUpdateKind.Resolve: return {
+			status: ResourceStatus.Resolved,
+			value: update.value
+		};
+		case ResourceSnapshotUpdateKind.Fail: return previous.status === ResourceStatus.Reloading || previous.status === ResourceStatus.Resolved || previous.status === ResourceStatus.Error ? {
+			status: ResourceStatus.Error,
+			value: previous.value,
+			error: update.error
+		} : {
+			status: ResourceStatus.LoadingError,
+			error: update.error
+		};
+		case ResourceSnapshotUpdateKind.FailWithValue: return {
+			status: ResourceStatus.Error,
+			value: update.value,
+			error: update.error
+		};
+	}
+}
+//#endregion
+//#region src/rx/resource.ts
+var RxResourceBase = class {
+	value;
+	status;
+	error;
+	isLoading;
+	destroyed = RxStateSignal.fromInitialValue(false);
+	destroyed$ = from(this.destroyed).pipe(filter((value) => value), take(1));
+	constructor() {
+		this.value = RxComputedSignal.computed(() => {
+			const snapshot = this.snapshot.get();
+			if (snapshot.status === ResourceStatus.Resolved || snapshot.status === ResourceStatus.Reloading) return snapshot.value;
+			if (snapshot.status === ResourceStatus.LoadingError || snapshot.status === ResourceStatus.Error) throw snapshot.error;
+			throw ResourceError.valueUnavailable({ status: snapshot.status });
+		});
+		this.status = RxComputedSignal.computed(() => this.snapshot.get().status);
+		this.error = RxComputedSignal.computed(() => {
+			const snapshot = this.snapshot.get();
+			return snapshot.status === ResourceStatus.LoadingError || snapshot.status === ResourceStatus.Error ? snapshot.error : void 0;
+		});
+		this.isLoading = RxComputedSignal.computed(() => {
+			const status = this.snapshot.get().status;
+			return status === ResourceStatus.Loading || status === ResourceStatus.Reloading;
+		});
+	}
+	hasValue() {
+		const status = this.snapshot.get().status;
+		return status === ResourceStatus.Resolved || status === ResourceStatus.Reloading;
+	}
+	async whenValue(options) {
+		return whenResourceSnapshotValue(this.snapshot, options);
+	}
+	dispose() {
+		this.destroyed.set(true);
+	}
+	[SYMBOL_DISPOSE]() {
+		this.dispose();
+	}
+	[SYMBOL_OBSERVABLE]() {
+		return this.snapshot[SYMBOL_OBSERVABLE]();
+	}
+};
+var RxResource = class RxResource extends RxResourceBase {
+	options;
+	snapshot;
+	constructor(options) {
+		super();
+		this.options = options;
+		this.snapshot = RxStateSignal.fromInitialValue({ status: ResourceStatus.Idle });
+		this.destroyed$.subscribe(() => {
+			this.snapshot.set({ status: ResourceStatus.Idle });
+		});
+		this.connect();
+	}
+	connect() {
+		const configuredRequest = this.options.request;
+		const requestObservable = configuredRequest && typeof configuredRequest !== "function" ? from(configuredRequest).pipe(distinctUntilChanged(configuredRequest.equals)) : of(configuredRequest && typeof configuredRequest === "function" ? configuredRequest() : void 0);
+		const requestControlsLoading = configuredRequest !== void 0;
+		requestObservable.pipe(switchMap((request) => {
+			if (requestControlsLoading && request === void 0) return of({ status: ResourceStatus.Idle });
+			const previous = this.snapshot.get();
+			const loadingSnapshot = reduceResourceSnapshot(previous, { kind: ResourceSnapshotUpdateKind.Load });
+			this.snapshot.set(loadingSnapshot);
+			const loadCancellation = createCancellationTokenSource();
+			return from(this.options.stream({
+				request,
+				previous,
+				cancellationToken: loadCancellation.token
+			})).pipe(map((value) => reduceResourceSnapshot(loadingSnapshot, {
+				kind: ResourceSnapshotUpdateKind.Resolve,
+				value
+			})), catchError((error) => of(reduceResourceSnapshot(loadingSnapshot, {
+				kind: ResourceSnapshotUpdateKind.Fail,
+				error
+			}))), finalize(() => loadCancellation.cancel()));
+		}), takeUntil(this.destroyed$)).subscribe((snapshot) => this.snapshot.set(snapshot));
+	}
+	static create(options) {
+		return new RxResource(options);
+	}
+};
+var RxSnapshotResource = class extends RxResourceBase {
+	snapshot;
+	constructor(source) {
+		super();
+		this.snapshot = RxComputedSignal.computed(() => this.destroyed.get() ? { status: ResourceStatus.Idle } : source());
+	}
+};
+function resourceFromSnapshots(source) {
+	return new RxSnapshotResource(source);
+}
+function mapResource(source, mapValue) {
+	return resourceFromSnapshots(() => {
+		const snapshot = source.snapshot.get();
+		switch (snapshot.status) {
+			case ResourceStatus.Idle:
+			case ResourceStatus.Loading:
+			case ResourceStatus.LoadingError: return snapshot;
+			case ResourceStatus.Reloading:
+			case ResourceStatus.Resolved: return {
+				status: snapshot.status,
+				value: mapValue(snapshot.value)
+			};
+			case ResourceStatus.Error: return {
+				status: ResourceStatus.Error,
+				value: mapValue(snapshot.value),
+				error: snapshot.error
+			};
+		}
+	});
+}
+function rxResource(options) {
+	return new RxResource(options);
+}
+//#endregion
+export { RxEventSubject as A, withDisposableStack as B, exhaustCommand as C, RxStateSignal as D, RxComputedSignal as E, SYMBOL_DISPOSE as F, ErrorPresentationTone as G, ClientError as H, SimpleDisposableStack as I, UserRecovery as K, StdDisposableStack as L, isInteropObservableTrait as M, SYMBOL_ASYNC_DISPOSE as N, RxEventReplaySubject as O, SYMBOL_DISPOSABLE_STACK as P, createDisposableStack as R, dispatchCommandLocallyToStream as S, unwrapCommandTerminalResponse as T, ClientErrorKind as U, CLIENT_ERROR_SPAN_ATTRIBUTE_PROVIDER_ID as V, ClientErrorSource as W, commandResponseData as _, ResourceSnapshotUpdateKind as a, dispatchCommandByIdToStream as b, whenResourceSnapshotValue as c, ResourceErrorCode as d, CancellationToken as f, CommandResponseType as g, createAsyncSchedulerWithTimestampProvider as h, rxResource as i, SYMBOL_OBSERVABLE as j, RxEventStream as k, ResourceStatus as l, isCancellationTokenTrait as m, mapResource as n, flattenResourceSnapshot as o, createCancellationTokenSource as p, resourceFromSnapshots as r, reduceResourceSnapshot as s, RxResource as t, ResourceError as u, concatCommand as v, switchCommand as w, dispatchCommandLocallyToPromise as x, dispatchCommandByIdToPromise as y, injectDisposableStackFrom as z };
+
+//# sourceMappingURL=rx-DM6Ouv-m.mjs.map