@vizejs/composable 0.345.0 → 0.350.2

package/dist/abort-signal.d.mts

@@ -0,0 +1,96 @@
+import { TimeoutScheduler } from "./timeout-scheduler.mjs";
+
+//#region src/abort-signal.d.ts
+/**
+ * Create a signal that aborts when the first input signal aborts.
+ *
+ * The standard `AbortSignal.any()` implementation is used when available.
+ * Older runtimes receive an equivalent listener-based implementation that
+ * removes every retained listener as soon as the result aborts. The first
+ * already-aborted input wins in iteration order, and its exact reason is
+ * forwarded. An empty iterable returns a fresh signal that never aborts.
+ *
+ * This function reads runtime constructors only when called and is safe to
+ * import during server rendering. Materializing the iterable happens before
+ * listeners are attached, so an iterable that throws cannot leak a partial
+ * subscription. If a non-standard signal throws while registering, listeners
+ * already attached to earlier inputs are released before the error propagates.
+ *
+ * @param signals Abort signals to compose; consumed exactly once.
+ * @returns A new first-abort-wins signal.
+ */
+declare function anyAbortSignal(signals: Iterable<AbortSignal>): AbortSignal;
+/** Options for {@link timeoutAbortSignal}. */
+interface TimeoutAbortSignalOptions {
+  /**
+   * Abort the returned signal early when this parent aborts.
+   *
+   * @default undefined
+   */
+  readonly signal?: AbortSignal;
+  /**
+   * Reason used when the timeout elapses. Parent cancellation always forwards
+   * the parent's reason instead.
+   *
+   * @default DOMException("The operation timed out.", "TimeoutError")
+   */
+  readonly reason?: unknown;
+  /**
+   * Deterministic or host-specific single-shot timer implementation. Supplying
+   * a scheduler selects the compatibility implementation.
+   *
+   * @default globalThis timer functions
+   */
+  readonly scheduler?: TimeoutScheduler;
+}
+/** Options for {@link deadlineAbortSignal}. */
+interface DeadlineAbortSignalOptions extends TimeoutAbortSignalOptions {
+  /**
+   * Clock returning Unix epoch milliseconds.
+   *
+   * @default Date.now
+   */
+  readonly now?: () => number;
+}
+/**
+ * Create a signal that aborts after a portable, non-negative delay.
+ *
+ * The native `AbortSignal.timeout()` implementation is used when available
+ * and neither a custom scheduler nor a custom reason is supplied. Older
+ * runtimes use the same owned-timer path as injected schedulers. Parent
+ * cancellation is composed with first-reason-wins semantics. Compatibility
+ * scheduling owns exactly one timer and removes its parent listener whenever
+ * either source aborts. A zero delay remains asynchronous.
+ *
+ * The delay must be an integer from `0` through `2_147_483_647`; this common
+ * signed 32-bit timer ceiling avoids host-specific clamping. The function
+ * accesses timers and abort constructors only when called and is safe to
+ * import during server rendering.
+ *
+ * @param delayMs Delay in milliseconds.
+ * @param options Parent signal, timeout reason, and scheduler.
+ * @default options {}
+ * @throws {RangeError} Tagged `VIZE_COMPOSE_ABORT_TIMEOUT_INVALID_DELAY` when
+ * the delay is fractional, negative, non-finite, or exceeds the portable
+ * timer ceiling.
+ * @returns A new timeout or parent-cancelled signal.
+ */
+declare function timeoutAbortSignal(delayMs: number, options?: TimeoutAbortSignalOptions): AbortSignal;
+/**
+ * Create a timeout signal from an absolute Unix-epoch deadline.
+ *
+ * Fractional positive differences are rounded up so cancellation never occurs
+ * before the requested deadline. Past deadlines become an asynchronous
+ * zero-delay timeout. `Date` and numeric deadlines are both accepted.
+ *
+ * @param deadline Absolute deadline as a `Date` or Unix epoch milliseconds.
+ * @param options Clock, parent signal, timeout reason, and scheduler.
+ * @default options {}
+ * @throws {RangeError} Tagged `VIZE_COMPOSE_ABORT_DEADLINE_INVALID` when the
+ * deadline, current clock value, or their positive difference is non-finite
+ * or cannot fit the portable timeout range.
+ * @returns A new deadline or parent-cancelled signal.
+ */
+declare function deadlineAbortSignal(deadline: Date | number, options?: DeadlineAbortSignalOptions): AbortSignal;
+//#endregion
+export { DeadlineAbortSignalOptions, TimeoutAbortSignalOptions, anyAbortSignal, deadlineAbortSignal, timeoutAbortSignal };

package/dist/abort-signal.mjs

@@ -0,0 +1,203 @@
+//#region src/abort-signal.ts
+/**
+* Create a signal that aborts when the first input signal aborts.
+*
+* The standard `AbortSignal.any()` implementation is used when available.
+* Older runtimes receive an equivalent listener-based implementation that
+* removes every retained listener as soon as the result aborts. The first
+* already-aborted input wins in iteration order, and its exact reason is
+* forwarded. An empty iterable returns a fresh signal that never aborts.
+*
+* This function reads runtime constructors only when called and is safe to
+* import during server rendering. Materializing the iterable happens before
+* listeners are attached, so an iterable that throws cannot leak a partial
+* subscription. If a non-standard signal throws while registering, listeners
+* already attached to earlier inputs are released before the error propagates.
+*
+* @param signals Abort signals to compose; consumed exactly once.
+* @returns A new first-abort-wins signal.
+*/
+function anyAbortSignal(signals) {
+	const inputs = [...signals];
+	const nativeAny = conformantNativeAbortSignalAny();
+	if (nativeAny !== void 0) return nativeAny.call(AbortSignal, inputs);
+	const controller = new AbortController();
+	const listeners = [];
+	const cleanup = () => {
+		for (const [signal, listener] of listeners) signal.removeEventListener("abort", listener);
+		listeners.length = 0;
+	};
+	const abortFrom = (signal) => {
+		if (controller.signal.aborted) return;
+		cleanup();
+		controller.abort(signal.reason);
+	};
+	for (const signal of inputs) {
+		if (signal.aborted) {
+			abortFrom(signal);
+			break;
+		}
+		const listener = () => abortFrom(signal);
+		listeners.push([signal, listener]);
+		try {
+			signal.addEventListener("abort", listener, { once: true });
+		} catch (error) {
+			cleanup();
+			throw error;
+		}
+		if (signal.aborted) {
+			abortFrom(signal);
+			break;
+		}
+	}
+	return controller.signal;
+}
+let probedNativeAny;
+let cachedNativeAny;
+/** Resolve the current native implementation only after its first-reason contract passes. */
+function conformantNativeAbortSignalAny() {
+	let candidate;
+	try {
+		candidate = Reflect.get(AbortSignal, "any");
+	} catch {
+		return;
+	}
+	if (candidate === probedNativeAny) return cachedNativeAny;
+	probedNativeAny = candidate;
+	cachedNativeAny = typeof candidate === "function" && nativeAnyReasonIsStable(candidate) ? candidate : void 0;
+	return cachedNativeAny;
+}
+/**
+* Detect runtimes whose combined reason changes when an earlier array member
+* aborts after the winner. The probe deliberately does not read the reason
+* until both inputs abort, catching lazy native implementations as well.
+*/
+function nativeAnyReasonIsStable(candidate) {
+	try {
+		const late = new AbortController();
+		const winner = new AbortController();
+		const expected = {};
+		const combined = candidate.call(AbortSignal, [late.signal, winner.signal]);
+		winner.abort(expected);
+		late.abort({});
+		return combined.aborted && combined.reason === expected;
+	} catch {
+		return false;
+	}
+}
+/**
+* Create a signal that aborts after a portable, non-negative delay.
+*
+* The native `AbortSignal.timeout()` implementation is used when available
+* and neither a custom scheduler nor a custom reason is supplied. Older
+* runtimes use the same owned-timer path as injected schedulers. Parent
+* cancellation is composed with first-reason-wins semantics. Compatibility
+* scheduling owns exactly one timer and removes its parent listener whenever
+* either source aborts. A zero delay remains asynchronous.
+*
+* The delay must be an integer from `0` through `2_147_483_647`; this common
+* signed 32-bit timer ceiling avoids host-specific clamping. The function
+* accesses timers and abort constructors only when called and is safe to
+* import during server rendering.
+*
+* @param delayMs Delay in milliseconds.
+* @param options Parent signal, timeout reason, and scheduler.
+* @default options {}
+* @throws {RangeError} Tagged `VIZE_COMPOSE_ABORT_TIMEOUT_INVALID_DELAY` when
+* the delay is fractional, negative, non-finite, or exceeds the portable
+* timer ceiling.
+* @returns A new timeout or parent-cancelled signal.
+*/
+function timeoutAbortSignal(delayMs, options = {}) {
+	assertPortableTimeout(delayMs);
+	const parent = options.signal;
+	if (parent?.aborted) {
+		const controller = new AbortController();
+		controller.abort(parent.reason);
+		return controller.signal;
+	}
+	if (options.scheduler === void 0 && options.reason === void 0 && typeof AbortSignal.timeout === "function") {
+		const timeout = AbortSignal.timeout(delayMs);
+		return options.signal === void 0 ? timeout : anyAbortSignal([options.signal, timeout]);
+	}
+	const controller = new AbortController();
+	const scheduler = options.scheduler ?? defaultTimeoutScheduler;
+	let handle;
+	let timerPending = true;
+	let parentListening = false;
+	const stopTimer = () => {
+		if (!timerPending) return;
+		timerPending = false;
+		scheduler.clearTimeout(handle);
+		handle = void 0;
+	};
+	const stopParent = () => {
+		if (!parentListening || parent === void 0) return;
+		parentListening = false;
+		parent.removeEventListener("abort", abortFromParent);
+	};
+	const abort = (reason) => {
+		if (controller.signal.aborted) return;
+		stopTimer();
+		stopParent();
+		controller.abort(reason);
+	};
+	const abortFromParent = () => abort(parent?.reason);
+	const timeoutReason = options.reason === void 0 ? new DOMException("The operation timed out.", "TimeoutError") : options.reason;
+	handle = scheduler.setTimeout(() => {
+		timerPending = false;
+		handle = void 0;
+		abort(timeoutReason);
+	}, delayMs);
+	if (controller.signal.aborted || parent === void 0) return controller.signal;
+	try {
+		parentListening = true;
+		parent.addEventListener("abort", abortFromParent, { once: true });
+		if (controller.signal.aborted) {
+			parent.removeEventListener("abort", abortFromParent);
+			parentListening = false;
+			return controller.signal;
+		}
+		if (parent.aborted) abortFromParent();
+	} catch (error) {
+		stopParent();
+		stopTimer();
+		throw error;
+	}
+	return controller.signal;
+}
+/**
+* Create a timeout signal from an absolute Unix-epoch deadline.
+*
+* Fractional positive differences are rounded up so cancellation never occurs
+* before the requested deadline. Past deadlines become an asynchronous
+* zero-delay timeout. `Date` and numeric deadlines are both accepted.
+*
+* @param deadline Absolute deadline as a `Date` or Unix epoch milliseconds.
+* @param options Clock, parent signal, timeout reason, and scheduler.
+* @default options {}
+* @throws {RangeError} Tagged `VIZE_COMPOSE_ABORT_DEADLINE_INVALID` when the
+* deadline, current clock value, or their positive difference is non-finite
+* or cannot fit the portable timeout range.
+* @returns A new deadline or parent-cancelled signal.
+*/
+function deadlineAbortSignal(deadline, options = {}) {
+	const deadlineMs = deadline instanceof Date ? deadline.getTime() : deadline;
+	const nowMs = (options.now ?? Date.now)();
+	const difference = deadlineMs - nowMs;
+	if (!Number.isFinite(deadlineMs) || !Number.isFinite(nowMs) || !Number.isFinite(difference) || difference > maximumPortableTimeoutMs) throw new RangeError(`[VIZE_COMPOSE_ABORT_DEADLINE_INVALID] deadline and now must produce a finite delay from 0 through ${String(maximumPortableTimeoutMs)} milliseconds; received deadline=${String(deadlineMs)}, now=${String(nowMs)}`);
+	const { now: _now, ...timeoutOptions } = options;
+	return timeoutAbortSignal(Math.ceil(Math.max(0, difference)), timeoutOptions);
+}
+function assertPortableTimeout(delayMs) {
+	if (!Number.isSafeInteger(delayMs) || delayMs < 0 || delayMs > maximumPortableTimeoutMs) throw new RangeError(`[VIZE_COMPOSE_ABORT_TIMEOUT_INVALID_DELAY] delayMs must be an integer from 0 through ${String(maximumPortableTimeoutMs)}; received ${String(delayMs)}`);
+}
+const maximumPortableTimeoutMs = 2147483647;
+const defaultTimeoutScheduler = {
+	setTimeout: (callback, delayMs) => globalThis.setTimeout(callback, delayMs),
+	clearTimeout: (handle) => {
+		globalThis.clearTimeout(handle);
+	}
+};
+//#endregion
+export { anyAbortSignal, deadlineAbortSignal, timeoutAbortSignal };

package/dist/async-resource.d.mts

@@ -0,0 +1,97 @@
+import { ComputedRef, Ref, ShallowRef } from "vue";
+
+//#region src/async-resource.d.ts
+/** Lifecycle state of an asynchronous resource. */
+type AsyncResourceStatus = "idle" | "pending" | "success" | "error" | "cancelled";
+/** Context supplied to an asynchronous resource loader. */
+interface AsyncResourceContext {
+  /** Signal aborted by cancellation, reset, scope disposal, or a newer execution. */
+  readonly signal: AbortSignal;
+}
+/** Explicit result of one asynchronous resource execution. */
+type AsyncResourceExecution<Data, Failure> = {
+  readonly status: "success";
+  readonly data: Data;
+} | {
+  readonly status: "error";
+  readonly error: Failure;
+} | {
+  readonly status: "cancelled";
+  readonly reason: unknown;
+} | {
+  readonly status: "superseded";
+};
+/** Options for {@link useAsyncResource}. */
+interface UseAsyncResourceOptions<Data> {
+  /**
+   * Initial data restored by {@link AsyncResource.reset}.
+   *
+   * @default undefined
+   */
+  readonly initialData?: Data;
+  /**
+   * Abort the active execution when a newer execution starts.
+   *
+   * @default true
+   */
+  readonly cancelPrevious?: boolean;
+  /**
+   * Retain the current data while a new execution is pending.
+   *
+   * @default true
+   */
+  readonly keepData?: boolean;
+  /**
+   * Cancel an active execution when the current reactive scope is disposed.
+   *
+   * @default true
+   */
+  readonly scope?: boolean;
+}
+/** Reactive state and controls for an asynchronous loader. */
+interface AsyncResource<Data, Arguments extends readonly unknown[], Failure> {
+  /** Data of the newest successful execution, retained according to `keepData`. */
+  readonly data: Readonly<ShallowRef<Data | undefined>>;
+  /** Failure of the newest settled execution, cleared when a new one starts. */
+  readonly error: Readonly<ShallowRef<Failure | undefined>>;
+  /** Current lifecycle status, driven only by the newest execution. */
+  readonly status: Readonly<Ref<AsyncResourceStatus>>;
+  /** Whether an execution is currently pending. */
+  readonly pending: ComputedRef<boolean>;
+  /**
+   * Run the loader. The returned promise never rejects: loader failures,
+   * cancellation, and supersession are reported as the discriminated result,
+   * and stale executions leave the reactive state untouched.
+   */
+  readonly execute: (...arguments_: Arguments) => Promise<AsyncResourceExecution<Data, Failure>>;
+  /**
+   * Abort the active execution and mark the resource cancelled.
+   *
+   * @param reason Abort reason forwarded to the loader's signal.
+   * @default reason DOMException("AbortError")
+   * @returns Whether an active execution was cancelled.
+   */
+  readonly cancel: (reason?: unknown) => boolean;
+  /** Cancel any active execution and restore the initial idle state. */
+  readonly reset: () => void;
+}
+/**
+ * Create a scoped, abortable asynchronous resource with latest-result-wins
+ * state. Every execution returns a discriminated result, so cancellation,
+ * supersession, loader failure, and successful `undefined` data stay distinct.
+ *
+ * When created inside an active reactive scope (and `scope` is enabled), the
+ * active execution is aborted when that scope stops; outside a scope,
+ * cancellation ownership stays with the caller. The execute promise never
+ * rejects — synchronous and asynchronous loader failures both settle into
+ * the `"error"` result. Safe during server rendering: no browser globals are
+ * read and abort reasons use the runtime-native `DOMException`.
+ *
+ * @param loader Asynchronous loader receiving the abort context first.
+ * @param options Data retention, supersession, and scope behavior.
+ * @default options {}
+ * @returns Reactive state and controls for the loader.
+ */
+declare function useAsyncResource<Data, Arguments extends readonly unknown[], Failure = unknown>(loader: (context: AsyncResourceContext, ...arguments_: Arguments) => Promise<Data>, options?: UseAsyncResourceOptions<Data>): AsyncResource<Data, Arguments, Failure>;
+//#endregion
+export { AsyncResource, AsyncResourceContext, AsyncResourceExecution, AsyncResourceStatus, UseAsyncResourceOptions, useAsyncResource };

package/dist/async-resource.mjs

@@ -0,0 +1,99 @@
+import { tryOnScopeDispose } from "./scope.mjs";
+import { computed, shallowRef } from "vue";
+//#region src/async-resource.ts
+/**
+* Create a scoped, abortable asynchronous resource with latest-result-wins
+* state. Every execution returns a discriminated result, so cancellation,
+* supersession, loader failure, and successful `undefined` data stay distinct.
+*
+* When created inside an active reactive scope (and `scope` is enabled), the
+* active execution is aborted when that scope stops; outside a scope,
+* cancellation ownership stays with the caller. The execute promise never
+* rejects — synchronous and asynchronous loader failures both settle into
+* the `"error"` result. Safe during server rendering: no browser globals are
+* read and abort reasons use the runtime-native `DOMException`.
+*
+* @param loader Asynchronous loader receiving the abort context first.
+* @param options Data retention, supersession, and scope behavior.
+* @default options {}
+* @returns Reactive state and controls for the loader.
+*/
+function useAsyncResource(loader, options = {}) {
+	const data = shallowRef(options.initialData);
+	const error = shallowRef(void 0);
+	const status = shallowRef("idle");
+	const pending = computed(() => status.value === "pending");
+	let generation = 0;
+	let active;
+	const cancel = (reason = createAbortReason("The execution was cancelled.")) => {
+		if (active === void 0) return false;
+		generation += 1;
+		active.controller.abort(reason);
+		active = void 0;
+		status.value = "cancelled";
+		return true;
+	};
+	const execute = async (...arguments_) => {
+		if ((options.cancelPrevious ?? true) && active !== void 0) {
+			active.superseded = true;
+			active.controller.abort(createAbortReason("A newer execution started."));
+		}
+		const record = {
+			generation: ++generation,
+			controller: new AbortController(),
+			superseded: false
+		};
+		active = record;
+		error.value = void 0;
+		status.value = "pending";
+		if (!(options.keepData ?? true)) data.value = void 0;
+		try {
+			const result = await loader({ signal: record.controller.signal }, ...arguments_);
+			if (record.generation !== generation) return executionAfterInvalidation(record);
+			data.value = result;
+			status.value = "success";
+			return {
+				status: "success",
+				data: result
+			};
+		} catch (cause) {
+			if (record.generation !== generation || record.controller.signal.aborted) return executionAfterInvalidation(record);
+			error.value = cause;
+			status.value = "error";
+			return {
+				status: "error",
+				error: cause
+			};
+		} finally {
+			if (active === record) active = void 0;
+		}
+	};
+	const reset = () => {
+		cancel(createAbortReason("The resource was reset."));
+		data.value = options.initialData;
+		error.value = void 0;
+		status.value = "idle";
+	};
+	if (options.scope ?? true) tryOnScopeDispose(() => cancel(createAbortReason("The reactive scope was disposed.")));
+	return {
+		data,
+		error,
+		status,
+		pending,
+		execute,
+		cancel,
+		reset
+	};
+}
+function executionAfterInvalidation(execution) {
+	if (execution.superseded || !execution.controller.signal.aborted) return { status: "superseded" };
+	return {
+		status: "cancelled",
+		reason: execution.controller.signal.reason
+	};
+}
+function createAbortReason(message) {
+	return new DOMException(message, "AbortError");
+}
+//#endregion
+export { useAsyncResource };

package/dist/capability-Ptkjr_sD.d.mts

@@ -0,0 +1,93 @@
+//#region src/capability.d.ts
+/** Runtime families understood by composable capability metadata and adapters. */
+type CapabilityTarget = "web" | "server" | "worker" | "native" | "desktop" | "terminal";
+/** Built-in origins from which a capability value can be resolved. */
+type CapabilitySource = "runtime" | "adapter" | "fallback";
+/**
+ * Standard reasons why a capability cannot currently provide a value.
+ *
+ * Adapters may extend this vocabulary with a narrower string-literal union;
+ * consumers should preserve unknown extension reasons when crossing process
+ * or version boundaries.
+ */
+type CapabilityUnavailableReason = "unsupported" | "unavailable" | "permission-denied" | "insecure-context" | "not-active" | "not-ready" | "cancelled" | "adapter-missing" | "adapter-error";
+/** A capability value that is ready for use. */
+interface AvailableCapability<Value, Source extends string = CapabilitySource> {
+  /** Stable discriminant for serialization and exhaustive matching. */
+  readonly status: "available";
+  /** Boolean discriminant for ergonomic guards in templates and JavaScript. */
+  readonly available: true;
+  /** Resolved capability implementation or value. */
+  readonly value: Value;
+  /** Origin that supplied the value, preserved as a string literal. */
+  readonly source: Source;
+}
+/** A capability that cannot currently provide a value. */
+interface UnavailableCapability<Reason extends string = CapabilityUnavailableReason, Details = undefined> {
+  /** Stable discriminant for serialization and exhaustive matching. */
+  readonly status: "unavailable";
+  /** Boolean discriminant for ergonomic guards in templates and JavaScript. */
+  readonly available: false;
+  /** Typed, machine-readable explanation of the unavailable state. */
+  readonly reason: Reason;
+  /** Structured diagnostic or recovery information supplied by the adapter. */
+  readonly details: Details;
+}
+/** Explicit result of capability discovery or adapter negotiation. */
+type CapabilityResult<Value, Reason extends string = CapabilityUnavailableReason, Details = undefined, Source extends string = CapabilitySource> = AvailableCapability<Value, Source> | UnavailableCapability<Reason, Details>;
+/**
+ * Create an available capability supplied directly by the current runtime.
+ *
+ * The value and source retain literal types. The helper performs no global
+ * access and is safe during server rendering and module evaluation.
+ *
+ * @param value Resolved capability implementation or value.
+ * @returns An available result whose source is `"runtime"`.
+ */
+declare function availableCapability<const Value>(value: Value): AvailableCapability<Value, "runtime">;
+/**
+ * Create an available capability with an explicit, literal-preserving source.
+ *
+ * @param value Resolved capability implementation or value.
+ * @param source Runtime, adapter, fallback, or adapter-specific source name.
+ * @returns An available capability result.
+ */
+declare function availableCapability<const Value, const Source extends string>(value: Value, source: Source): AvailableCapability<Value, Source>;
+/**
+ * Create an unavailable capability without additional details.
+ *
+ * The reason retains its string-literal type. Capability absence is returned
+ * as data rather than thrown, making unsupported server, worker, native,
+ * desktop, and terminal environments deterministic.
+ *
+ * @param reason Machine-readable unavailability reason.
+ * @returns An unavailable result with `undefined` details.
+ */
+declare function unavailableCapability<const Reason extends string>(reason: Reason): UnavailableCapability<Reason, undefined>;
+/**
+ * Create an unavailable capability with typed recovery or diagnostic details.
+ *
+ * Passing `undefined` explicitly is distinct at the call boundary and still
+ * preserves the exact `undefined` details type.
+ *
+ * @param reason Machine-readable unavailability reason.
+ * @param details Structured diagnostic or recovery information.
+ * @returns An unavailable capability result.
+ */
+declare function unavailableCapability<const Reason extends string, const Details>(reason: Reason, details: Details): UnavailableCapability<Reason, Details>;
+/**
+ * Narrow a capability result to its available branch.
+ *
+ * @param result Capability discovery or negotiation result.
+ * @returns Whether `result.value` is ready for use.
+ */
+declare function isCapabilityAvailable<Value, Reason extends string, Details, Source extends string>(result: CapabilityResult<Value, Reason, Details, Source>): result is AvailableCapability<Value, Source>;
+/**
+ * Narrow a capability result to its unavailable branch.
+ *
+ * @param result Capability discovery or negotiation result.
+ * @returns Whether the capability has a typed unavailability reason.
+ */
+declare function isCapabilityUnavailable<Value, Reason extends string, Details, Source extends string>(result: CapabilityResult<Value, Reason, Details, Source>): result is UnavailableCapability<Reason, Details>;
+//#endregion
+export { CapabilityUnavailableReason as a, isCapabilityAvailable as c, CapabilityTarget as i, isCapabilityUnavailable as l, CapabilityResult as n, UnavailableCapability as o, CapabilitySource as r, availableCapability as s, AvailableCapability as t, unavailableCapability as u };

package/dist/capability.d.mts

@@ -0,0 +1,2 @@
+import { a as CapabilityUnavailableReason, c as isCapabilityAvailable, i as CapabilityTarget, l as isCapabilityUnavailable, n as CapabilityResult, o as UnavailableCapability, r as CapabilitySource, s as availableCapability, t as AvailableCapability, u as unavailableCapability } from "./capability-Ptkjr_sD.mjs";
+export { AvailableCapability, CapabilityResult, CapabilitySource, CapabilityTarget, CapabilityUnavailableReason, UnavailableCapability, availableCapability, isCapabilityAvailable, isCapabilityUnavailable, unavailableCapability };

package/dist/capability.mjs

@@ -0,0 +1,37 @@
+//#region src/capability.ts
+function availableCapability(value, source) {
+	return {
+		status: "available",
+		available: true,
+		value,
+		source: source ?? "runtime"
+	};
+}
+function unavailableCapability(reason, details) {
+	return {
+		status: "unavailable",
+		available: false,
+		reason,
+		details
+	};
+}
+/**
+* Narrow a capability result to its available branch.
+*
+* @param result Capability discovery or negotiation result.
+* @returns Whether `result.value` is ready for use.
+*/
+function isCapabilityAvailable(result) {
+	return result.available;
+}
+/**
+* Narrow a capability result to its unavailable branch.
+*
+* @param result Capability discovery or negotiation result.
+* @returns Whether the capability has a typed unavailability reason.
+*/
+function isCapabilityUnavailable(result) {
+	return !result.available;
+}
+//#endregion
+export { availableCapability, isCapabilityAvailable, isCapabilityUnavailable, unavailableCapability };