@securitydept/client 0.2.0-beta.1

package/dist/index.mjs

@@ -0,0 +1,661 @@
+import { C as ClientErrorSource, S as ClientErrorKind, T as UserRecovery, _ as createDefaultClock, b as OperationTraceEventType, c as PromiseSettlementKind, d as fromSignal, f as interval, g as createDefaultScheduler, h as createRuntime, l as fromEventPattern, m as timer, p as scheduleAt, t as FetchTransportRedirectKind, u as fromPromise, v as createOperationTracer, w as ErrorPresentationTone, x as ClientError, y as LogLevel } from "./fetch-transport-DtnSRWAH.mjs";
+import { i as createJsonCodec, n as createEphemeralFlowStore, r as createKeyedEphemeralFlowStore, t as createInMemoryRecordStore } from "./persistence-Db2CIFbx.mjs";
+//#region src/cancellation/cancellation-token.ts
+var CancellationToken = class {
+	_isCancelled = false;
+	_reason;
+	_listeners = /* @__PURE__ */ new Set();
+	get isCancellationRequested() {
+		return this._isCancelled;
+	}
+	get reason() {
+		return this._reason;
+	}
+	/** @internal — called by `CancellationTokenSource`. */
+	_cancel(reason) {
+		if (this._isCancelled) return;
+		this._isCancelled = true;
+		this._reason = reason;
+		for (const listener of this._listeners) listener(reason);
+		this._listeners.clear();
+	}
+	onCancellationRequested(listener) {
+		if (this._isCancelled) {
+			listener(this._reason);
+			return { dispose() {} };
+		}
+		this._listeners.add(listener);
+		return { dispose: () => {
+			this._listeners.delete(listener);
+		} };
+	}
+	throwIfCancellationRequested() {
+		if (this._isCancelled) throw new ClientError({
+			kind: ClientErrorKind.Cancelled,
+			message: "Operation was cancelled",
+			cause: this._reason
+		});
+	}
+};
+/**
+* Create a `CancellationTokenSource` that produces a cooperative cancellation token.
+*/
+function createCancellationTokenSource() {
+	const ct = new CancellationToken();
+	let disposed = false;
+	return {
+		get token() {
+			return ct;
+		},
+		cancel(reason) {
+			if (!disposed) ct._cancel(reason);
+		},
+		dispose() {
+			if (!disposed) {
+				disposed = true;
+				ct._cancel(new ClientError({
+					kind: ClientErrorKind.Cancelled,
+					message: "Disposed"
+				}));
+			}
+		}
+	};
+}
+//#endregion
+//#region src/cancellation/linked-cancellation-token.ts
+/**
+* Create a cancellation token that fires when ANY of the given source tokens
+* is cancelled.
+*
+* - Zero sources → returns a token that is never cancelled.
+* - One source   → returns that source directly (no allocation).
+* - N sources    → creates a linked source, subscribes to all, and cleans up
+*   subscriptions once the linked token fires.
+*
+* @example
+* const cts = createCancellationTokenSource();
+* const linked = createLinkedCancellationToken(clientRoot.token, cts.token);
+* await transport.execute({ ..., cancellationToken: linked });
+*/
+function createLinkedCancellationToken(...sources) {
+	if (sources.length === 0) return createCancellationTokenSource().token;
+	if (sources.length === 1) return sources[0];
+	for (const source of sources) if (source.isCancellationRequested) return source;
+	const linked = createCancellationTokenSource();
+	const subscriptions = sources.map((source) => source.onCancellationRequested((reason) => linked.cancel(reason)));
+	linked.token.onCancellationRequested(() => {
+		for (const sub of subscriptions) sub.dispose();
+	});
+	return linked.token;
+}
+//#endregion
+//#region src/errors/presentation-descriptor.ts
+const DEFAULT_RECOVERY_LABELS = {
+	[UserRecovery.None]: "",
+	[UserRecovery.Retry]: "Try again",
+	[UserRecovery.RestartFlow]: "Restart flow",
+	[UserRecovery.Reauthenticate]: "Sign in again",
+	[UserRecovery.ContactSupport]: "Contact support"
+};
+const POPUP_PRESENTATIONS = {
+	"popup.blocked": {
+		title: "Popup was blocked",
+		description: "The browser blocked the popup window before the login flow could start. Allow popups for this site, then try again.",
+		tone: ErrorPresentationTone.Warning
+	},
+	"popup.closed_by_user": {
+		title: "Popup login was closed",
+		description: "The popup window was closed before the OIDC provider returned a callback. Start the login flow again to continue.",
+		tone: ErrorPresentationTone.Warning
+	},
+	"popup.relay_timeout": {
+		title: "Popup relay timed out",
+		description: "The popup callback never relayed back to the opener before the timeout window expired.",
+		tone: ErrorPresentationTone.Warning
+	},
+	"popup.relay_error": {
+		title: "Popup relay failed",
+		description: "The popup callback page returned an error instead of a callback payload.",
+		tone: ErrorPresentationTone.Danger
+	}
+};
+function readErrorPresentationDescriptor(error, options = {}) {
+	if (error instanceof ClientError) return describeClientErrorPresentation(error, options);
+	const clientErrorLike = coerceClientErrorLike(error);
+	if (clientErrorLike) return describeClientErrorLikePresentation(clientErrorLike, options);
+	if (error instanceof Error) return {
+		code: null,
+		kind: null,
+		title: options.fallbackTitle ?? "Operation failed",
+		description: error.message || options.fallbackDescription || "An unexpected error prevented the operation from completing.",
+		recovery: UserRecovery.None,
+		retryable: false,
+		tone: ErrorPresentationTone.Danger,
+		primaryAction: null
+	};
+	return {
+		code: null,
+		kind: null,
+		title: options.fallbackTitle ?? "Operation failed",
+		description: options.fallbackDescription ?? "An unexpected error prevented the operation from completing.",
+		recovery: UserRecovery.None,
+		retryable: false,
+		tone: ErrorPresentationTone.Danger,
+		primaryAction: null
+	};
+}
+function describeClientErrorPresentation(error, options) {
+	return describeClientErrorLikePresentation({
+		code: error.code,
+		kind: error.kind,
+		message: error.message,
+		recovery: error.recovery,
+		retryable: error.retryable,
+		source: error.source,
+		presentation: error.presentation
+	}, options);
+}
+function describeClientErrorLikePresentation(error, options) {
+	const popupPresentation = POPUP_PRESENTATIONS[error.code];
+	const title = popupPresentation?.title ?? readClientErrorTitle(error);
+	const description = popupPresentation?.description ?? error.presentation?.message ?? error.message ?? options.fallbackDescription ?? "The operation could not complete.";
+	return {
+		code: error.code,
+		kind: error.kind,
+		source: error.source,
+		title,
+		description,
+		recovery: error.recovery,
+		retryable: error.retryable,
+		tone: popupPresentation?.tone ?? readClientErrorTone(error),
+		primaryAction: readPrimaryAction(error.recovery, options)
+	};
+}
+function readClientErrorTitle(error) {
+	if (error.kind === ClientErrorKind.Unauthenticated) return "Authentication required";
+	if (error.kind === ClientErrorKind.Unauthorized) return "Access denied";
+	if (error.kind === ClientErrorKind.Cancelled) return "Operation cancelled";
+	if (error.kind === ClientErrorKind.Timeout) return "Request timed out";
+	if (error.kind === ClientErrorKind.Configuration) return "Configuration error";
+	if (error.kind === ClientErrorKind.Validation) return "Validation failed";
+	if (error.kind === ClientErrorKind.Storage) return "Browser storage failed";
+	if (error.kind === ClientErrorKind.Authorization && error.recovery === UserRecovery.RestartFlow) return "Flow needs to restart";
+	if (error.kind === ClientErrorKind.Transport) return "Network request failed";
+	if (error.kind === ClientErrorKind.Server) return "Server request failed";
+	if (error.kind === ClientErrorKind.Protocol) return "Request failed";
+	return "Operation failed";
+}
+function readClientErrorTone(error) {
+	if (error.kind === ClientErrorKind.Cancelled) return ErrorPresentationTone.Neutral;
+	if (error.kind === ClientErrorKind.Unauthenticated || error.kind === ClientErrorKind.Timeout || error.kind === ClientErrorKind.Transport || error.kind === ClientErrorKind.Server || error.recovery === UserRecovery.Retry || error.recovery === UserRecovery.RestartFlow || error.recovery === UserRecovery.Reauthenticate) return ErrorPresentationTone.Warning;
+	return ErrorPresentationTone.Danger;
+}
+function coerceClientErrorLike(error) {
+	if (typeof error !== "object" || error === null) return null;
+	const candidate = error;
+	if (typeof candidate.message !== "string") return null;
+	return {
+		code: typeof candidate.code === "string" ? candidate.code : null,
+		kind: typeof candidate.kind === "string" ? candidate.kind : null,
+		message: candidate.message,
+		recovery: typeof candidate.recovery === "string" ? candidate.recovery : UserRecovery.None,
+		retryable: candidate.retryable === true,
+		source: typeof candidate.source === "string" ? candidate.source : void 0,
+		presentation: isErrorPresentation(candidate.presentation) ? candidate.presentation : void 0
+	};
+}
+function isErrorPresentation(value) {
+	return typeof value === "object" && value !== null && typeof value.code === "string" && typeof value.message === "string" && typeof value.recovery === "string";
+}
+function readPrimaryAction(recovery, options) {
+	if (recovery === UserRecovery.None) return null;
+	const label = options.recoveryLabels?.[recovery] ?? DEFAULT_RECOVERY_LABELS[recovery];
+	if (!label) return null;
+	return {
+		recovery,
+		label,
+		href: options.recoveryLinks?.[recovery] ?? null
+	};
+}
+//#endregion
+//#region src/events/event-stream.ts
+/**
+* Create a new event stream from a producer function.
+*
+* The producer receives an observer and should call `next()` to emit values,
+* `error()` to signal an error, and `complete()` to signal completion.
+* It may return a teardown function that will be called on unsubscribe.
+*/
+function createEventStream(producer) {
+	return { subscribe(observer) {
+		let active = true;
+		const teardown = producer({
+			next(value) {
+				if (active) observer.next?.(value);
+			},
+			error(err) {
+				if (active) {
+					active = false;
+					observer.error?.(err);
+				}
+			},
+			complete() {
+				if (active) {
+					active = false;
+					observer.complete?.();
+				}
+			}
+		});
+		return { unsubscribe() {
+			if (active) {
+				active = false;
+				teardown?.();
+			}
+		} };
+	} };
+}
+//#endregion
+//#region src/events/operators.ts
+function pipe(source, ...operators) {
+	return operators.reduce((acc, op) => op(acc), source);
+}
+function map(fn) {
+	return (source) => createEventStream((observer) => {
+		const sub = source.subscribe({
+			next(value) {
+				observer.next?.(fn(value));
+			},
+			error(err) {
+				observer.error?.(err);
+			},
+			complete() {
+				observer.complete?.();
+			}
+		});
+		return () => sub.unsubscribe();
+	});
+}
+function filter(predicate) {
+	return (source) => createEventStream((observer) => {
+		const sub = source.subscribe({
+			next(value) {
+				if (predicate(value)) observer.next?.(value);
+			},
+			error(err) {
+				observer.error?.(err);
+			},
+			complete() {
+				observer.complete?.();
+			}
+		});
+		return () => sub.unsubscribe();
+	});
+}
+function tap(fn) {
+	return (source) => createEventStream((observer) => {
+		const sub = source.subscribe({
+			next(value) {
+				fn(value);
+				observer.next?.(value);
+			},
+			error(err) {
+				observer.error?.(err);
+			},
+			complete() {
+				observer.complete?.();
+			}
+		});
+		return () => sub.unsubscribe();
+	});
+}
+function takeUntil(notifier) {
+	return (source) => createEventStream((observer) => {
+		const sourceSub = source.subscribe({
+			next(value) {
+				observer.next?.(value);
+			},
+			error(err) {
+				observer.error?.(err);
+			},
+			complete() {
+				observer.complete?.();
+			}
+		});
+		const notifierSub = notifier.subscribe({ next() {
+			observer.complete?.();
+			sourceSub.unsubscribe();
+			notifierSub.unsubscribe();
+		} });
+		return () => {
+			sourceSub.unsubscribe();
+			notifierSub.unsubscribe();
+		};
+	});
+}
+function finalize(fn) {
+	return (source) => createEventStream((observer) => {
+		const sub = source.subscribe({
+			next(value) {
+				observer.next?.(value);
+			},
+			error(err) {
+				observer.error?.(err);
+				fn();
+			},
+			complete() {
+				observer.complete?.();
+				fn();
+			}
+		});
+		return () => {
+			sub.unsubscribe();
+			fn();
+		};
+	});
+}
+function merge(...sources) {
+	return createEventStream((observer) => {
+		let completedCount = 0;
+		const subs = sources.map((source) => source.subscribe({
+			next(value) {
+				observer.next?.(value);
+			},
+			error(err) {
+				observer.error?.(err);
+			},
+			complete() {
+				completedCount++;
+				if (completedCount === sources.length) observer.complete?.();
+			}
+		}));
+		return () => {
+			for (const sub of subs) sub.unsubscribe();
+		};
+	});
+}
+//#endregion
+//#region src/events/types.ts
+const EventSourceKind = {
+	User: "user",
+	Timer: "timer",
+	Http: "http",
+	Storage: "storage",
+	Framework: "framework",
+	System: "system"
+};
+//#endregion
+//#region src/identity/principal.ts
+function readClaimsBag(value) {
+	return typeof value === "object" && value !== null ? value : void 0;
+}
+function readOptionalString(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function resolveDisplayName(displayName, subject) {
+	if (typeof displayName === "string" && displayName.trim().length > 0) return displayName;
+	return subject;
+}
+function normalizeAuthenticatedPrincipal(input) {
+	if (typeof input.subject !== "string" || input.subject.trim().length === 0) return null;
+	return {
+		subject: input.subject,
+		displayName: resolveDisplayName(input.displayName, input.subject),
+		picture: readOptionalString(input.picture),
+		issuer: readOptionalString(input.issuer),
+		claims: readClaimsBag(input.claims)
+	};
+}
+function normalizeAuthenticatedPrincipalWire(input) {
+	if (typeof input.subject !== "string" || input.subject.trim().length === 0) return null;
+	return {
+		subject: input.subject,
+		displayName: resolveDisplayName(input.display_name, input.subject),
+		picture: readOptionalString(input.picture),
+		issuer: readOptionalString(input.issuer),
+		claims: readClaimsBag(input.claims)
+	};
+}
+function projectAuthenticatedPrincipal(options) {
+	const principal = options.principal;
+	const subject = principal?.subject ?? options.fallbackSubject ?? "context.anonymous";
+	return {
+		subject,
+		displayName: principal?.displayName?.trim() || options.fallbackDisplayName || subject,
+		picture: principal?.picture,
+		issuer: principal?.issuer ?? options.fallbackIssuer,
+		claims: principal?.claims ?? options.fallbackClaims
+	};
+}
+//#endregion
+//#region src/logging/console-logger.ts
+/** Simple console-based logger implementation. */
+function createConsoleLogger(scope) {
+	return { log(entry) {
+		const label = `[${entry.scope ?? scope ?? "securitydept"}]`;
+		switch (entry.level) {
+			case "debug":
+				console.debug(label, entry.message, entry.attributes ?? "");
+				break;
+			case "info":
+				console.info(label, entry.message, entry.attributes ?? "");
+				break;
+			case "warn":
+				console.warn(label, entry.message, entry.attributes ?? "");
+				break;
+			case "error":
+				console.error(label, entry.message, entry.error ?? "", entry.attributes ?? "");
+				break;
+		}
+	} };
+}
+//#endregion
+//#region src/logging/noop-logger.ts
+/** No-op logger — default when no logger is provided. */
+function createNoopLogger() {
+	return { log() {} };
+}
+//#endregion
+//#region src/logging/trace-timeline-store.ts
+function createTraceTimelineStore(limit = 200) {
+	let nextId = 1;
+	let entries = [];
+	const listeners = /* @__PURE__ */ new Set();
+	function readRecordedAtIso(at) {
+		if (!Number.isFinite(at)) return "invalid-timestamp";
+		const date = new Date(at);
+		const timestamp = date.getTime();
+		if (!Number.isFinite(timestamp)) return "invalid-timestamp";
+		return date.toISOString();
+	}
+	function notify() {
+		for (const listener of listeners) listener();
+	}
+	return {
+		record(event) {
+			const entry = {
+				...event,
+				id: nextId++,
+				recordedAtIso: readRecordedAtIso(event.at)
+			};
+			entries = [...entries, entry].slice(-limit);
+			notify();
+		},
+		get() {
+			return entries;
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		clear() {
+			if (entries.length === 0) return;
+			entries = [];
+			notify();
+		}
+	};
+}
+//#endregion
+//#region src/signals/computed.ts
+/**
+* Create a computed signal that derives its value from other signals.
+*
+* Semantics: lazy + cached.
+* - The compute function is NOT called at construction time.
+* - `get()` recomputes only when dirty (a dependency changed since last read).
+* - Subscribers are notified only when a dependency changes (dirty-flagged),
+*   and the next `get()` will produce the fresh value.
+*
+* Dependency subscriptions are permanent for the lifetime of the computed signal.
+*/
+function createComputed(compute, deps) {
+	let cached;
+	let dirty = true;
+	const listeners = /* @__PURE__ */ new Set();
+	const markDirty = () => {
+		if (!dirty) {
+			dirty = true;
+			for (const listener of listeners) listener();
+		}
+	};
+	for (const dep of deps) dep.subscribe(markDirty);
+	return {
+		get() {
+			if (dirty) {
+				cached = compute();
+				dirty = false;
+			}
+			return cached;
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+}
+//#endregion
+//#region src/signals/signal.ts
+/**
+* Minimal writable signal implementation.
+* Snapshot-first: values are immutable snapshots, mutations go through `set()`.
+*/
+function createSignal(initial) {
+	let current = initial;
+	const listeners = /* @__PURE__ */ new Set();
+	return {
+		get() {
+			return current;
+		},
+		set(value) {
+			if (Object.is(current, value)) return;
+			current = value;
+			for (const listener of listeners) listener();
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+}
+/**
+* Create a read-only view of a writable signal.
+*/
+function readonlySignal(signal) {
+	return {
+		get: () => signal.get(),
+		subscribe: (listener) => signal.subscribe(listener)
+	};
+}
+//#endregion
+//#region src/validation/index.ts
+/**
+* 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
+	};
+}
+/**
+* Create a minimal `@standard-schema`-compatible schema without requiring
+* an external validation library.
+*
+* This is useful for SDK-internal schemas where pulling in zod/valibot
+* would be excessive. For adopter-facing schemas, prefer a real validation
+* library.
+*
+* @example
+* ```ts
+* import { createSchema, validateWithSchema } from "@securitydept/client";
+*
+* const NameSchema = createSchema<unknown, { name: string }>({
+*   validate(input) {
+*     if (typeof input === "object" && input !== null && "name" in input &&
+*         typeof (input as any).name === "string") {
+*       return { value: { name: (input as any).name } };
+*     }
+*     return { issues: [{ message: "Expected object with string 'name'" }] };
+*   },
+* });
+*
+* const result = await validateWithSchema(NameSchema, { name: "Alice" });
+* ```
+*/
+function createSchema(options) {
+	return { "~standard": {
+		version: 1,
+		vendor: "securitydept",
+		validate: options.validate
+	} };
+}
+//#endregion
+export { ClientError, ClientErrorKind, ClientErrorSource, ErrorPresentationTone, EventSourceKind, FetchTransportRedirectKind, LogLevel, OperationTraceEventType, PromiseSettlementKind, UserRecovery, createCancellationTokenSource, createComputed, createConsoleLogger, createDefaultClock, createDefaultScheduler, createEphemeralFlowStore, createEventStream, createInMemoryRecordStore, createJsonCodec, createKeyedEphemeralFlowStore, createLinkedCancellationToken, createNoopLogger, createOperationTracer, createRuntime, createSchema, createSignal, createTraceTimelineStore, filter, finalize, fromEventPattern, fromPromise, fromSignal, interval, map, merge, normalizeAuthenticatedPrincipal, normalizeAuthenticatedPrincipalWire, pipe, projectAuthenticatedPrincipal, readErrorPresentationDescriptor, readonlySignal, scheduleAt, takeUntil, tap, timer, validateWithSchema, validateWithSchemaSync };
+
+//# sourceMappingURL=index.mjs.map