@warp-drive-mirror/core 5.9.0-alpha.2 → 5.9.0-alpha.21

package/dist/unpkg/dev-deprecated/-private-C1QTxlMX.js

@@ -0,0 +1,1714 @@
+import { a as setTransient, r as peekTransient, t as getOrSetGlobal } from "./-private-9CIgW-DA.js";
+import { f as setPromiseResult, o as DOMError, u as getPromiseResult } from "./request-4Qkr-Uqq.js";
+
+//#region src/signals/reactivity/configure.ts
+const ARRAY_SIGNAL = getOrSetGlobal("#[]", Symbol("#[]"));
+const OBJECT_SIGNAL = getOrSetGlobal("#{}", Symbol("#{}"));
+/**
+* Requirements:
+*
+* Signal:
+*
+* - signal: a way of creating a reference that we can dirty when we desire to notify
+*         - @signal: a way of creating an accessor on an object that subscribes to a signal on access
+*                    and notifies the signal on set, or of upgrading a descriptor to be such an accessor
+*         - defineSignal: a way of creating a signal on an object
+*         - notifySignal: a way of notifying the underlying signal that it has been dirtied
+*         - peekSignal: a way of inspecting the signal without notifying it
+*
+*  - gate: a memoized getter function that re-runs when on access if its signal is dirty
+*          conceptually, a gate is a tightly coupled signal and memo
+*         - @gate: a way of creating a gate on an object or upgrading a descriptor with a getter
+*                  to be a gate
+*         - defineGate: a way of creating a gate on an object
+*         - notifySignal: a way of notifying the signal for a gate that it has been dirtied
+*
+* - memo:
+*        - @memo: a way of creating a memoized getter on an object or upgrading a descriptor with a getter
+*                 to be a memo
+*        - defineMemo: a way of creating a memo on an object
+*
+* - signalStore: storage bucket for signals associated to an object
+*        - withSignalStore: a way of pre-creating a signal store on an object
+*
+*
+* @internal
+*/
+/**
+* An Opaque type that represents a framework specific or TC39 signal.
+*
+* It may be an array of signals or a single signal.
+*
+* @private
+*/
+/**
+* The hooks which MUST be configured in order to use reactive arrays,
+* resources and documents with framework specfic signals or TC39 signals.
+*
+* Support for multiple frameworks simultaneously can be done via
+* this abstraction by returning multiple signals from the `createSignal`
+* method, and consuming the correct one via the correct framework via
+* the `consumeSignal` and `notifySignal` methods.
+*
+* Unlike many signals implementations, WarpDrive does not wrap values as
+* signals directly, but instead uses signals to alert the reactive layer
+* to changes in the underlying cache. E.g. a signal is associated to a value,
+* but does not serve as the cache for that value directly. We refer to this as
+* a "gate", the pattern has also been called "side-signals".
+*
+* A no-op implementation is allowed, though it may lead to performance issues
+* in locations that use createMemo as no memoization would be done. This is
+* typically desirable only when integrating with a framework that does its own
+* memoization and does not integrate with any signals-like primitive. For these
+* scenarios you may also be interested in integrating with the {@link NotificationManager}
+* more directly.
+*
+* @public
+*/
+/**
+* Contains information a {@link SignalHooks} implementation may want
+* to use, such as the specialized key used for the signal
+* representing an array's contents / length.
+*
+* ```ts
+* interface HooksOptions {
+*   wellknown: {
+*     Array: symbol | string;
+*   }
+* }
+* ```
+*
+* @public
+*/
+/**
+* Configures the signals implementation to use. Supports multiple
+* implementations simultaneously.
+*
+* See {@link HooksOptions} for the options passed to the provided function
+* when called.
+*
+* See {@link SignalHooks} for the implementation the callback function should
+* return.
+*
+* @public
+* @param buildConfig - a function that takes options and returns a configuration object
+*/
+function setupSignals(buildConfig) {
+	const hooks = buildConfig({ wellknown: { Array: ARRAY_SIGNAL } });
+	setTransient("signalHooks", hooks);
+}
+/**
+* Internal method for consuming the configured `createSignal` hook
+*
+* @private
+*/
+function createSignal(obj, key) {
+	const signalHooks = peekTransient("signalHooks");
+	((test) => {
+		if (!test) throw new Error(`Signal hooks not configured`);
+	})(signalHooks);
+	return signalHooks.createSignal(obj, key);
+}
+/**
+* Internal method for consuming the configured `consumeSignal` hook
+*
+* @private
+*/
+function consumeSignal(signal) {
+	const signalHooks = peekTransient("signalHooks");
+	((test) => {
+		if (!test) throw new Error(`Signal hooks not configured`);
+	})(signalHooks);
+	return signalHooks.consumeSignal(signal);
+}
+/**
+* Internal method for consuming the configured `notifySignal` hook
+*
+* @private
+*/
+function notifySignal(signal) {
+	const signalHooks = peekTransient("signalHooks");
+	((test) => {
+		if (!test) throw new Error(`Signal hooks not configured`);
+	})(signalHooks);
+	return signalHooks.notifySignal(signal);
+}
+function createMemo(object, key, fn) {
+	const signalHooks = peekTransient("signalHooks");
+	((test) => {
+		if (!test) throw new Error(`Signal hooks not configured`);
+	})(signalHooks);
+	return signalHooks.createMemo(object, key, fn);
+}
+function willSyncFlushWatchers() {
+	const signalHooks = peekTransient("signalHooks");
+	((test) => {
+		if (!test) throw new Error(`Signal hooks not configured`);
+	})(signalHooks);
+	return signalHooks.willSyncFlushWatchers();
+}
+/**
+* Wraps `promise` using the configured {@link SignalHooks.waitFor}, if any,
+* for things like test-waiters. Returns `promise` unchanged if no
+* `waitFor` hook is configured.
+*/
+function waitFor(promise) {
+	const signalHooks = peekTransient("signalHooks");
+	if (signalHooks?.waitFor) return signalHooks.waitFor(promise);
+	return promise;
+}
+
+//#endregion
+//#region src/signals/reactivity/internal.ts
+const INITIALIZER_PROTO = { isInitializer: true };
+/**
+* Wraps `fn` so that a signal can recognize it as a lazy initializer
+* for its value rather than the value itself, deferring the call to
+* `fn` until the signal is first accessed.
+*/
+function makeInitializer(fn) {
+	return Object.assign(Object.create(INITIALIZER_PROTO), { value: fn });
+}
+function isInitializer(obj) {
+	return typeof obj === "object" && obj !== null && Object.getPrototypeOf(obj) === INITIALIZER_PROTO;
+}
+/**
+* A WarpDriveSignal is a wrapper around a framework specific or TC39 signal
+* that enables us to store and manage the signal in a universal way.
+*
+* WarpDrive uses signals to manage three separate concepts:
+*
+* - as a `storage` for a value local to the object that we want to be reactive
+*   (see `@local` schema field for an example)
+* - as a `gate` for a memoized getter that we want to act as a reactive property
+*   but whose value is computed/pulled from a non-reactive source elsewhere
+*   and whose latest value is stored in the signal
+*   (see `field` schema field for an example)
+* - as a `gate` with a manually managed value updated on pull when `isStale` is true
+*
+*
+* It offers
+*
+* - a non-reactive way to access/update the current value
+* - a non-reactive way to mark the signal as dirtied
+* - a non-reactive way to store content for why the signal was dirtied
+* - access to the underlying Signal(s) in-use
+*
+* For debugging:
+* - the "key" or "name" of the signal
+* - the "object identity" or "context" to which the signal is attached
+*
+* @private
+*/
+/**
+* We attach signals to their context object via
+* a Map attached to the object via this symbol.
+*
+* This allows us to store multiple signals
+* on the same object with smaller memory
+* overhead and no WeakMap lookups.
+*
+* Performance sensitive objects should
+* pre-warm their shape by assigning this
+* during initialization.
+*
+* ```ts
+* initializeSignalStore(obj);
+* ```
+*
+* @private
+*/
+const Signals = getOrSetGlobal("Signals", Symbol("Signals"));
+/**
+* A type util to recast the object as having a signal store.
+*
+* @private
+*/
+function upgradeWithSignals(obj) {}
+/**
+* A util that will create a signal store on the object
+* if it does not already exist and returns the associated
+* signal store.
+*
+* @private
+*/
+function withSignalStore(obj) {
+	/* @__PURE__ */ upgradeWithSignals(obj);
+	if (!obj[Signals]) initializeSignalStore(obj);
+	return obj[Signals];
+}
+/**
+* A util that will create a signal store on the object
+* if it does not already exist.
+*
+* Useful for pre-warming the shape of an object to ensure
+* a key-transition to add it is not required later.
+*
+* @private
+*/
+function initializeSignalStore(obj) {
+	/* @__PURE__ */ upgradeWithSignals(obj);
+	((test) => {
+		if (!test) throw new Error(`Signal store already exists on object`);
+	})(!obj[Signals]);
+	obj[Signals] = /* @__PURE__ */ new Map();
+}
+function createInternalSignal(signals, obj, key, initialValue) {
+	const warpDriveSignal = {
+		key,
+		context: obj,
+		signal: createSignal(obj, key),
+		value: isInitializer(initialValue) ? initialValue.value.call(obj) : initialValue,
+		isStale: false
+	};
+	signals.set(key, warpDriveSignal);
+	return warpDriveSignal;
+}
+function getOrCreateInternalSignal(signals, obj, key, initialValue) {
+	let signal = peekInternalSignal(signals, key);
+	if (!signal) signal = createInternalSignal(signals, obj, key, initialValue);
+	return signal;
+}
+function createInternalMemo(signals, object, key, fn) {
+	((test) => {
+		if (!test) throw new Error(`Expected no signal/memo to exist for key "${String(key)}"`);
+	})(!peekInternalSignal(signals, key));
+	return withFrame(signals, object, key, fn);
+}
+/**
+* Looks up the {@link WarpDriveSignal} stored for `key` in `signals`,
+* if one has already been created, without creating or consuming it.
+*/
+function peekInternalSignal(signals, key) {
+	return signals?.get(key);
+}
+function consumeInternalSignal(signal) {
+	TrackingFrame?.signals.add(signal);
+	consumeSignal(signal.signal);
+}
+/**
+* Marks `signal` as stale and notifies its underlying framework/TC39
+* signal, scheduling any of its consumers for re-render/re-computation.
+*/
+function notifyInternalSignal(signal) {
+	if (signal) {
+		signal.isStale = true;
+		notifySignal(signal.signal);
+	}
+}
+let TrackingFrame = null;
+/**
+* This is currently just for signals debugging, but it could be used in production
+* if we wanted to eliminate the need for frameworks to implement createMemo / to
+* allow us to add our own Watcher.
+*
+* @internal
+*/
+function withFrame(signals, object, key, fn) {
+	const frameSignals = /* @__PURE__ */ new Set();
+	const frameFn = () => {
+		if (frameSignals.size) frameSignals.clear();
+		TrackingFrame = {
+			object,
+			key,
+			signals: frameSignals,
+			parent: TrackingFrame
+		};
+		try {
+			return fn();
+		} finally {
+			TrackingFrame = TrackingFrame.parent;
+		}
+	};
+	const memo = createMemo(object, key, frameFn);
+	memo.signals = frameSignals;
+	signals.set(key, memo);
+	return memo;
+}
+function isMemo(obj) {
+	return typeof obj === "function" && obj.signals instanceof Set;
+}
+globalThis.debugWarpDriveSignals = (obj, key) => {
+	/* @__PURE__ */ upgradeWithSignals(obj);
+	const signals = obj[Signals];
+	if (!signals) {
+		log("The object has no associated signals");
+		return false;
+	}
+	if (key) {
+		const signal = signals.get(key);
+		if (!signal) {
+			log(`No signal found for key "${String(key)}"`);
+			return false;
+		}
+		log(signal);
+		if (isMemo(signal)) {
+			colorizeLines(printMemo(signal, key));
+			return true;
+		} else {
+			colorizeLines(printSignal(signal, key));
+			return true;
+		}
+	}
+	const lines = [];
+	for (const [k, signal] of signals) {
+		if (isMemo(signal)) continue;
+		printSignal(signal, k, lines);
+	}
+	for (const [k, signal] of signals) if (isMemo(signal)) printMemo(signal, k, lines);
+	log(signals);
+	colorizeLines(lines);
+	return true;
+};
+const LightColors = {
+	red: "color: red;",
+	green: "color: green;",
+	reset: "color: inherit;"
+};
+const DarkColors = {
+	red: "color: red;",
+	green: "color: lightgreen;",
+	reset: "color: inherit;"
+};
+function isLightMode() {
+	if (window?.matchMedia?.("(prefers-color-scheme: light)").matches) return true;
+	return false;
+}
+const RED = {};
+const GREEN = {};
+const RESET = {};
+const EOL = {};
+function colorizeLines(lines) {
+	const Colors = isLightMode() ? LightColors : DarkColors;
+	const colors = [];
+	let line = "";
+	for (const str of lines) if (str === RED) {
+		colors.push(Colors.red);
+		line += "%c";
+	} else if (str === GREEN) {
+		colors.push(Colors.green);
+		line += "%c";
+	} else if (str === RESET) {
+		colors.push(Colors.reset);
+		line += "%c";
+	} else if (str === EOL) line += "\n";
+	else line += str;
+	log(line, ...colors);
+}
+function log(...args) {
+	console.log(...args);
+}
+function isDirty(signal) {
+	return signal.isStale;
+}
+function isDirtyMemo(memo) {
+	for (const signal of memo.signals) {
+		if (isMemo(signal)) continue;
+		if (isDirty(signal)) return true;
+	}
+	for (const signal of memo.signals) if (isMemo(signal)) return isDirtyMemo(signal);
+	return false;
+}
+function printSignal(signal, key, lines = [], depth = 0) {
+	const _dirty = isDirty(signal);
+	lines.push(`${"".padStart(depth * 2, " ")}${_dirty ? "❌" : "✅"} `, _dirty ? RED : GREEN, `${String(key)}`, RESET, EOL);
+	return lines;
+}
+function printMemo(memo, key, lines = [], depth = 0) {
+	const _dirty = isDirtyMemo(memo);
+	lines.push(`${"".padStart(depth * 2, " ")}${_dirty ? "❌" : "✅"} `, _dirty ? RED : GREEN, `<memo> ${String(key)}`, RESET, `: (consumes ${memo.signals.size} signals)`, EOL);
+	for (const signal of memo.signals) {
+		if (isMemo(signal)) continue;
+		printSignal(signal, signal.key, lines, depth + 1);
+	}
+	for (const signal of memo.signals) if (isMemo(signal)) printMemo(signal, signal.key, lines, depth + 1);
+	return lines;
+}
+
+//#endregion
+//#region src/signals/reactivity/signal.ts
+/**
+* Creates a signal for the key/object pairing and subscribes to the signal.
+*
+* Use when you need to ensure a signal exists and is subscribed to.
+*
+* @private
+*/
+function entangleSignal(signals, obj, key, initialValue) {
+	let internalSignal = peekInternalSignal(signals, key);
+	if (!internalSignal) internalSignal = createInternalSignal(signals, obj, key, initialValue);
+	consumeInternalSignal(internalSignal);
+	return internalSignal;
+}
+function entangleInitiallyStaleSignal(signals, obj, key, initialValue) {
+	let internalSignal = peekInternalSignal(signals, key);
+	if (!internalSignal) {
+		internalSignal = createInternalSignal(signals, obj, key, initialValue);
+		internalSignal.isStale = true;
+	}
+	consumeInternalSignal(internalSignal);
+	return internalSignal;
+}
+function createSignalDescriptor(key, intialValue) {
+	return {
+		enumerable: true,
+		configurable: false,
+		get() {
+			const internalSignal = entangleSignal(withSignalStore(this), this, key, intialValue);
+			internalSignal.isStale = false;
+			return internalSignal.value;
+		},
+		set(value) {
+			const signals = withSignalStore(this);
+			const internalSignal = getOrCreateInternalSignal(signals, this, key, intialValue);
+			if (internalSignal.value !== value) {
+				internalSignal.value = value;
+				notifyInternalSignal(internalSignal);
+			}
+		}
+	};
+}
+/**
+* define an enumerable signal property.
+*
+* Akin to Object.defineProperty.
+*
+* The signal will be lazily created when accessed and scoped to the
+* instance of the object.
+*
+* @private
+*/
+function defineSignal(obj, key, v) {
+	Object.defineProperty(obj, key, createSignalDescriptor(key, v));
+}
+/**
+* Define a non-enumerable signal property.
+*
+* @private
+*/
+function defineNonEnumerableSignal(obj, key, v) {
+	const desc = createSignalDescriptor(key, v);
+	desc.enumerable = false;
+	Object.defineProperty(obj, key, desc);
+}
+/**
+* Decorator version of creating a signal.
+*/
+function signal(target, key, descriptor) {
+	((test) => {
+		if (!test) throw new Error("You attempted to use @signal(), which is not necessary nor supported. Remove the parentheses and you will be good to go!");
+	})(target !== void 0);
+	((test) => {
+		if (!test) throw new Error(`You attempted to use @signal on with ${arguments.length > 1 ? "arguments" : "an argument"} ( @signal(${Array.from(arguments).map((d) => `'${d}'`).join(", ")}) ), which is not supported. Dependencies are automatically tracked, so you can just use \`@signal\``);
+	})(typeof target === "object" && typeof key === "string" && typeof descriptor === "object" && arguments.length === 3);
+	return createSignalDescriptor(key, descriptor.initializer ? makeInitializer(descriptor.initializer) : null);
+}
+/**
+* Decorator version of creating a memoized getter
+*/
+function memoized(target, key, descriptor) {
+	((test) => {
+		if (!test) throw new Error("You attempted to use @memoized(), which is not necessary nor supported. Remove the parentheses and you will be good to go!");
+	})(target !== void 0);
+	((test) => {
+		if (!test) throw new Error(`You attempted to use @memoized on with ${arguments.length > 1 ? "arguments" : "an argument"} ( @memoized(${Array.from(arguments).map((d) => `'${d}'`).join(", ")}), which is not supported. Dependencies are automatically tracked, so you can just use \`@memoized\``);
+	})(typeof target === "object" && typeof key === "string" && typeof descriptor === "object" && arguments.length === 3);
+	((test) => {
+		if (!test) throw new Error(`The @memoized decorator must be applied to getters. '${key}' is not a getter.`);
+	})(typeof descriptor.get === "function");
+	const getter = descriptor.get;
+	descriptor.get = function() {
+		const signals = withSignalStore(this);
+		let memoSignal = signals.get(key);
+		if (!memoSignal) memoSignal = createInternalMemo(signals, this, key, getter.bind(this));
+		return memoSignal();
+	};
+	return descriptor;
+}
+/**
+* Decorator version of creating a gate.
+*
+* @private
+*/
+function gate(_target, key, desc) {
+	const getter = desc.get;
+	const setter = desc.set;
+	const isLocal = desc.isLocal;
+	desc.get = function() {
+		const signals = withSignalStore(this);
+		let internalSignal = peekInternalSignal(signals, key);
+		if (!internalSignal) internalSignal = createInternalSignal(signals, this, key, getter.call(this));
+		else if (internalSignal.isStale) {
+			internalSignal.isStale = false;
+			internalSignal.value = getter.call(this);
+		}
+		consumeInternalSignal(internalSignal);
+		return internalSignal.value;
+	};
+	if (setter) desc.set = function(v) {
+		const signals = withSignalStore(this);
+		let internalSignal = peekInternalSignal(signals, key);
+		if (!internalSignal) {
+			internalSignal = createInternalSignal(signals, this, key, void 0);
+			internalSignal.isStale = true;
+		}
+		setter.call(this, v);
+		if (isLocal) {
+			internalSignal.isStale = true;
+			notifyInternalSignal(internalSignal);
+		}
+	};
+	return desc;
+}
+/**
+* Defines a reactive "gated" property on `obj` using `desc` as its
+* getter/setter descriptor.
+*
+* Unlike a signal defined with {@link defineSignal}, a gated property's
+* consumers are not notified when the property is set, since its update
+* is expected to be controlled externally (for instance, by a signal it
+* derives its value from) unless the descriptor opts into being locally
+* managed.
+*
+* Akin to `Object.defineProperty`.
+*
+* @private
+*/
+function defineGate(obj, key, desc) {
+	const options = Object.assign({
+		enumerable: true,
+		configurable: false
+	}, gate(obj, key, desc));
+	Object.defineProperty(obj, key, options);
+}
+
+//#endregion
+//#region src/signals/request-state.ts
+const RequestCache = /* @__PURE__ */ new WeakMap();
+function isAbortError(error) {
+	return error instanceof DOMError && error.name === "AbortError";
+}
+function upgradeLoadingState(state) {
+	return state;
+}
+async function watchStream(stream, loadingState) {
+	const state = upgradeLoadingState(loadingState);
+	const reader = stream.getReader();
+	let bytesLoaded = 0;
+	let shouldForward = state._stream !== null && state._stream.readable.locked;
+	let isForwarding = shouldForward;
+	let writer = state._stream?.writable.getWriter();
+	const buffer = [];
+	state._isPending = false;
+	state._isStarted = true;
+	state._startTime = performance.now();
+	while (true) {
+		const { value, done } = await reader.read();
+		if (done) break;
+		bytesLoaded += value.byteLength;
+		state._bytesLoaded = bytesLoaded;
+		state._lastPacketTime = performance.now();
+		shouldForward = shouldForward || state._stream !== null && state._stream.readable.locked;
+		if (shouldForward) {
+			if (!isForwarding) {
+				isForwarding = true;
+				writer = state._stream.writable.getWriter();
+				for (const item of buffer) {
+					await writer.ready;
+					await writer.write(item);
+				}
+				buffer.length = 0;
+			}
+			await writer.ready;
+			await writer.write(value);
+		} else buffer.push(value);
+	}
+	if (isForwarding) {
+		await writer.ready;
+		await writer.close();
+	} else if (state._stream) {
+		await state._stream.readable.cancel("The Stream Has Already Ended");
+		state._stream = null;
+	}
+	state._endTime = performance.now();
+	state._isComplete = true;
+	state._isStarted = false;
+}
+/**
+* Lazily consumes the stream of a request, providing a number of
+* reactive properties that can be used to build UIs that respond
+* to the progress of a request.
+*
+* @hideconstructor
+*/
+var RequestLoadingState = class {
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	_stream = null;
+	/** @internal */
+	_future;
+	/** @internal */
+	_triggered = false;
+	/** @internal */
+	_trigger() {
+		if (this._triggered) return;
+		this._triggered = true;
+		const promise = this._future.getStream();
+		if (promise.sizeHint) this._sizeHint = promise.sizeHint;
+		this.promise = promise.then((stream) => {
+			if (!stream) {
+				this._isPending = false;
+				this._isComplete = true;
+				return;
+			}
+			return watchStream(stream, this);
+		}, (error) => {
+			this._isPending = false;
+			this._isStarted = false;
+			if (isAbortError(error)) {
+				this._isCancelled = true;
+				this._isComplete = true;
+			}
+			this._isErrored = true;
+			this._error = error;
+		});
+	}
+	/**
+	* Resolves once the stream has finished being consumed, or rejects
+	* if the request errors. `null` until first accessed.
+	*/
+	promise = null;
+	/**
+	* Whether the stream has not yet started being consumed.
+	*/
+	get isPending() {
+		this._trigger();
+		return this._isPending;
+	}
+	/**
+	* The total size of the response in bytes, if known ahead of time
+	* (via a `Content-Length` header or similar).
+	*/
+	get sizeHint() {
+		this._trigger();
+		return this._sizeHint;
+	}
+	/**
+	* A readable stream of the response content. Accessing this property
+	* begins consumption of the underlying request stream.
+	*/
+	get stream() {
+		this._trigger();
+		if (!this._stream) {
+			if (this._isComplete || this._isCancelled || this._isErrored) return null;
+			this._stream = new TransformStream();
+		}
+		return this._stream.readable;
+	}
+	/**
+	* Whether the stream has started being consumed but has not yet completed.
+	*/
+	get isStarted() {
+		this._trigger();
+		return this._isStarted;
+	}
+	/**
+	* The number of bytes loaded so far.
+	*/
+	get bytesLoaded() {
+		this._trigger();
+		return this._bytesLoaded;
+	}
+	/**
+	* The `performance.now()` timestamp at which the stream started being consumed.
+	*/
+	get startTime() {
+		this._trigger();
+		return this._startTime;
+	}
+	/**
+	* The `performance.now()` timestamp at which the stream finished being consumed.
+	*/
+	get endTime() {
+		this._trigger();
+		return this._endTime;
+	}
+	/**
+	* The `performance.now()` timestamp at which the last chunk of data was received.
+	*/
+	get lastPacketTime() {
+		this._trigger();
+		return this._lastPacketTime;
+	}
+	/**
+	* Whether the stream has finished being consumed.
+	*/
+	get isComplete() {
+		this._trigger();
+		return this._isComplete;
+	}
+	/**
+	* Whether the request was aborted before the stream finished being consumed.
+	*/
+	get isCancelled() {
+		this._trigger();
+		return this._isCancelled;
+	}
+	/**
+	* Whether an error occurred while consuming the stream.
+	*/
+	get isErrored() {
+		this._trigger();
+		return this._isErrored;
+	}
+	/**
+	* The error that occurred while consuming the stream, if any.
+	*/
+	get error() {
+		this._trigger();
+		return this._error;
+	}
+	/**
+	* The number of milliseconds elapsed since the stream started being
+	* consumed, using the last packet time (or end time, once complete)
+	* as the endpoint.
+	*/
+	get elapsedTime() {
+		return (this.endTime || this.lastPacketTime) - this.startTime;
+	}
+	/**
+	* The ratio (0 to 1) of {@link RequestLoadingState.bytesLoaded | bytesLoaded}
+	* to {@link RequestLoadingState.sizeHint | sizeHint}, or `0` if no size hint is available.
+	*/
+	get completedRatio() {
+		return this.sizeHint ? this.bytesLoaded / this.sizeHint : 0;
+	}
+	/**
+	* The inverse of {@link RequestLoadingState.completedRatio | completedRatio}.
+	*/
+	get remainingRatio() {
+		return 1 - this.completedRatio;
+	}
+	/**
+	* The total number of milliseconds elapsed between
+	* {@link RequestLoadingState.startTime | startTime} and {@link RequestLoadingState.endTime | endTime}.
+	*/
+	get duration() {
+		return this.endTime - this.startTime;
+	}
+	/**
+	* The average download speed in bytes per second.
+	*/
+	get speed() {
+		return this.bytesLoaded / (this.elapsedTime / 1e3);
+	}
+	constructor(future) {
+		this._future = future;
+	}
+	/**
+	* Aborts the underlying request.
+	*/
+	abort = () => {
+		this._future.abort();
+	};
+};
+defineNonEnumerableSignal(RequestLoadingState.prototype, "_isPending", true);
+defineNonEnumerableSignal(RequestLoadingState.prototype, "_isStarted", false);
+defineNonEnumerableSignal(RequestLoadingState.prototype, "_isComplete", false);
+defineNonEnumerableSignal(RequestLoadingState.prototype, "_isCancelled", false);
+defineNonEnumerableSignal(RequestLoadingState.prototype, "_isErrored", false);
+defineNonEnumerableSignal(RequestLoadingState.prototype, "_error", null);
+defineNonEnumerableSignal(RequestLoadingState.prototype, "_sizeHint", 0);
+defineNonEnumerableSignal(RequestLoadingState.prototype, "_bytesLoaded", 0);
+defineNonEnumerableSignal(RequestLoadingState.prototype, "_startTime", 0);
+defineNonEnumerableSignal(RequestLoadingState.prototype, "_endTime", 0);
+defineNonEnumerableSignal(RequestLoadingState.prototype, "_lastPacketTime", 0);
+/**
+* The state of a request in the "pending"
+* state. This is the default initial state.
+*
+* Extends the {@link PendingPromise} interface.
+*
+*/
+/**
+* The state of a request in the "fulfilled" state.
+* This is the state of a request that has resolved
+* successfully.
+*
+* Extends the {@link ResolvedPromise} interface.
+*
+*/
+/**
+* The state of a request in the "rejected" state.
+* This is the state of a request that has rejected
+* with an error.
+*
+* Extends the {@link RejectedPromise} interface.
+*
+*/
+/**
+* The state of a request in the "cancelled" state.
+* This is the state of a promise that has been
+* cancelled.
+*
+*/
+/**
+* RequestState extends the concept of {@link PromiseState} to provide a reactive
+* wrapper for a request {@link Future} which allows you write declarative code
+* around a Future's control flow.
+*
+* It is useful in both Template and JavaScript contexts, allowing you
+* to quickly derive behaviors and data from pending, error and success
+* states.
+*
+* The key difference between a {@link Promise} and a Future is that Futures provide
+* access to a {@link ReadableStream | stream} of their content, the {@link RequestKey} of the request (if any)
+* as well as the ability to attempt to {@link Future.abort | abort} the request.
+*
+* ```ts
+* interface Future<T> extends Promise<T>> {
+*   getStream(): Promise<ReadableStream>;
+*   abort(): void;
+*   lid: RequestKey | null;
+* }
+* ```
+*
+* These additional APIs allow us to craft even richer state experiences.
+*
+* To get the state of a request, use {@link getRequestState}.
+*
+* See also:
+* - {@link PendingRequest}
+* - {@link ResolvedRequest}
+* - {@link RejectedRequest}
+* - {@link CancelledRequest}
+*
+*/
+const RequestStateProto = {};
+function performRefresh(requester, request, isReload) {
+	const req = Object.assign({}, request);
+	const cacheOptions = Object.assign({}, req.cacheOptions);
+	if (isReload) cacheOptions.reload = true;
+	else if (isReload === false) {
+		delete cacheOptions.reload;
+		cacheOptions.backgroundReload = true;
+	} else {
+		delete cacheOptions.backgroundReload;
+		delete cacheOptions.reload;
+	}
+	req.cacheOptions = cacheOptions;
+	return requester.request(req);
+}
+defineSignal(RequestStateProto, "reason", null);
+defineSignal(RequestStateProto, "value", null);
+defineSignal(RequestStateProto, "result", null);
+defineSignal(RequestStateProto, "error", null);
+defineSignal(RequestStateProto, "status", "pending");
+defineSignal(RequestStateProto, "isPending", true);
+defineSignal(RequestStateProto, "isLoading", true);
+defineSignal(RequestStateProto, "isSuccess", false);
+defineSignal(RequestStateProto, "isError", false);
+defineSignal(RequestStateProto, "request", null);
+defineSignal(RequestStateProto, "response", null);
+Object.defineProperty(RequestStateProto, "isCancelled", { get() {
+	return this.isError && isAbortError(this.reason);
+} });
+Object.defineProperty(RequestStateProto, "loadingState", { get() {
+	if (!this._loadingState) this._loadingState = new RequestLoadingState(this._request);
+	return this._loadingState;
+} });
+function createRequestState(future) {
+	const state = getPromiseResult(future);
+	const promiseState = Object.create(RequestStateProto);
+	promiseState._request = future;
+	promiseState.reload = () => {
+		((test) => {
+			if (!test) throw new Error(`Cannot reload a request that is still pending. Await or abort the original request first.`);
+		})(!promiseState.isPending);
+		return performRefresh(future.requester, promiseState.request, true);
+	};
+	promiseState.refresh = (usePolicy = false) => {
+		((test) => {
+			if (!test) throw new Error(`Cannot refresh a request that is still pending. Await or abort the original request first.`);
+		})(!promiseState.isPending);
+		return performRefresh(future.requester, promiseState.request, usePolicy === true ? null : false);
+	};
+	if (state) {
+		if (state.isError) {
+			promiseState.error = state.result;
+			promiseState.reason = state.result;
+			promiseState.status = "rejected";
+			promiseState.isError = true;
+			promiseState.isPending = false;
+			promiseState.isLoading = false;
+			promiseState.request = state.result.request;
+			promiseState.response = state.result.response;
+		} else {
+			promiseState.result = state.result.content;
+			promiseState.value = state.result.content;
+			promiseState.status = "fulfilled";
+			promiseState.isSuccess = true;
+			promiseState.isPending = false;
+			promiseState.isLoading = false;
+			promiseState.request = state.result.request;
+			promiseState.response = state.result.response;
+		}
+	} else future.then((result) => {
+		setPromiseResult(future, {
+			isError: false,
+			result
+		});
+		promiseState.result = result.content;
+		promiseState.value = result.content;
+		promiseState.status = "fulfilled";
+		promiseState.isSuccess = true;
+		promiseState.isPending = false;
+		promiseState.isLoading = false;
+		promiseState.request = result.request;
+		promiseState.response = result.response;
+	}, (error) => {
+		setPromiseResult(future, {
+			isError: true,
+			result: error
+		});
+		promiseState.error = error;
+		promiseState.reason = error;
+		promiseState.status = "rejected";
+		promiseState.isError = true;
+		promiseState.isPending = false;
+		promiseState.isLoading = false;
+		promiseState.request = error.request;
+		promiseState.response = error.response;
+	});
+	return promiseState;
+}
+/**
+* `getRequestState` can be used in both JavaScript and Template contexts.
+*
+* ```ts
+* import { getRequestState } from '@warp-drive-mirror/ember';
+*
+* const state = getRequestState(future);
+* ```
+*
+* For instance, we could write a getter on a component that updates whenever
+* the request state advances or the future changes, by combining the function
+* with the use of `@cached`
+*
+* ```ts
+* class Component {
+*   @cached
+*   get title() {
+*     const state = getRequestState(this.args.request);
+*     if (state.isPending) {
+*       return 'loading...';
+*     }
+*     if (state.isError) { return null; }
+*     return state.result.title;
+*   }
+* }
+* ```
+*
+* Or in a template as a helper:
+*
+* ```gjs
+* import { getRequestState } from '@warp-drive-mirror/ember';
+*
+* <template>
+*   {{#let (getRequestState @request) as |state|}}
+*     {{#if state.isPending}}
+*       <Spinner />
+*     {{else if state.isError}}
+*       <ErrorForm @error={{state.error}} />
+*     {{else}}
+*       <h1>{{state.result.title}}</h1>
+*     {{/if}}
+*   {{/let}}
+* </template>
+* ```
+*
+* If looking to use in a template, consider also the `<Request />` component
+* which offers a number of additional capabilities for requests *beyond* what
+* `RequestState` provides.
+*
+*/
+function getRequestState(future) {
+	let state = RequestCache.get(future);
+	if (!state) {
+		state = createRequestState(future);
+		RequestCache.set(future, state);
+	}
+	return state;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/decorat_5005bbc272376d25df08203abab44e2f/node_modules/decorator-transforms/dist/runtime-BPCpkOf1.js
+function decorateMethodV2(prototype, prop, decorators) {
+	let desc = { ...Object.getOwnPropertyDescriptor(prototype, prop) };
+	for (let decorator of decorators) desc = decorator(prototype, prop, desc) || desc;
+	if (desc.initializer !== void 0) {
+		desc.value = desc.initializer ? desc.initializer.call(prototype) : void 0;
+		desc.initializer = void 0;
+	}
+	Object.defineProperty(prototype, prop, desc);
+}
+
+//#endregion
+//#region src/signals/request-subscription.ts
+const DEFAULT_DEADLINE = 3e4;
+/**
+* A symbol used to dispose of a {@link RequestSubscription} when the
+* component or context using it is torn down.
+*/
+const DISPOSE = Symbol.dispose || Symbol.for("dispose");
+function isNeverString(val) {
+	return val;
+}
+/**
+* The individual autorefresh strategies a {@link RequestSubscription}
+* may combine, see {@link AutorefreshBehaviorCombos}.
+*/
+/**
+* The value accepted by {@link SubscriptionArgs.autorefresh}: either a
+* boolean, a single {@link AutorefreshBehaviorType}, or a comma-separated
+* combination of up to three of them.
+*/
+/**
+* Utilities to assist in recovering from the error.
+*/
+/** @deprecated use {@link RecoveryFeatures} */
+/**
+* Utilities for keeping the request fresh
+*/
+/**
+* The args accepted by the `<Request />` component.
+*/
+/**
+* The args accepted by a {@link RequestSubscription}.
+*/
+/**
+* A reactive class
+*
+* @hideconstructor
+*/
+var RequestSubscription = class {
+	/**
+	* Whether the browser reports that the network is online.
+	*/
+	/**
+	* Whether the browser reports that the tab is hidden.
+	*/
+	/**
+	* Whether the component is currently refreshing the request.
+	*/
+	/**
+	* The most recent blocking request that was made, typically
+	* the result of a reload.
+	*
+	* This will never be the original request passed as an arg to
+	* the component.
+	*
+	* @internal
+	*/
+	/**
+	* The most recent request that was made, typically due to either a
+	* reload or a refresh.
+	*
+	* This will never be the original request passed as an arg to
+	* the component.
+	*
+	* @internal
+	*/
+	/**
+	* The time at which the network was reported as offline.
+	*
+	* @internal
+	*/
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/**
+	* The event listener for network status changes,
+	* cached to use the reference for removal.
+	*
+	* @internal
+	*/
+	/**
+	* The event listener for visibility status changes,
+	* cached to use the reference for removal.
+	*
+	* @internal
+	*/
+	/**
+	* The last request passed as an arg to the component,
+	* cached for comparison.
+	*
+	* @internal
+	*/
+	/**
+	* The last query passed as an arg to the component,
+	* cached for comparison.
+	*
+	* @internal
+	*/
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/**
+	* The Store this subscription subscribes to or the RequestManager
+	* which issues this request.
+	*/
+	/**
+	* The Store or RequestManager that the last subscription is attached to.
+	*
+	* This differs from 'store' because a <Request /> may be passed a
+	* request originating from a different store than the <Request />
+	* component would use if it were to issue the request itself.
+	*
+	* @internal
+	*/
+	_requester;
+	constructor(store, args) {
+		this._args = args;
+		this.store = store;
+		this._subscribedTo = null;
+		this._subscription = null;
+		this._intervalStart = null;
+		this._invalidated = false;
+		this._nextInterval = null;
+		this._requester = null;
+		this.isDestroyed = false;
+		this[DISPOSE] = _DISPOSE;
+		this._installListeners();
+		this._beginPolling();
+	}
+	/**
+	* @internal
+	*/
+	async _beginPolling() {
+		try {
+			if (!this.isIdle) await this.request;
+		} catch {} finally {
+			if (!this.isDestroyed) this._scheduleInterval();
+		}
+	}
+	/**
+	* Whether neither a `request` nor a `query` arg was provided, and so
+	* this subscription has nothing to fetch or monitor.
+	*/
+	get isIdle() {
+		const { request, query } = this._args;
+		return Boolean(!request && !query);
+	}
+	/**
+	* The set of {@link AutorefreshBehaviorType}s this subscription is
+	* configured to autorefresh for, derived from {@link SubscriptionArgs.autorefresh}.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "isIdle", [memoized]);
+	}
+	get autorefreshTypes() {
+		const { autorefresh } = this._args;
+		let types;
+		if (autorefresh === true) types = ["online", "invalid"];
+		else if (typeof autorefresh === "string") types = autorefresh.split(",");
+		else types = [];
+		return new Set(types);
+	}
+	/** @internal */
+	static {
+		decorateMethodV2(this.prototype, "autorefreshTypes", [memoized]);
+	}
+	async _scheduleInterval() {
+		const { autorefreshThreshold } = this._args;
+		if (typeof window === "undefined" || !(typeof autorefreshThreshold === "number" && autorefreshThreshold > 0) || !this.autorefreshTypes.has("interval") || this._intervalStart !== null) return;
+		if (this._latestRequest) {
+			try {
+				await this._latestRequest;
+			} catch {}
+			if (this.isDestroyed) return;
+		}
+		this._intervalStart = Date.now();
+		this._nextInterval = setTimeout(() => {
+			this._maybeUpdate();
+		}, autorefreshThreshold);
+	}
+	/** @internal */
+	_clearInterval() {
+		if (this._nextInterval) {
+			clearTimeout(this._nextInterval);
+			this._intervalStart = null;
+		}
+	}
+	/**
+	* @internal
+	*/
+	_updateSubscriptions() {
+		if (this.isIdle) return;
+		const requestId = this._request.lid;
+		if (this._subscribedTo === requestId) return;
+		this._removeSubscriptions();
+		const store = this._getRequester();
+		this._requester = store;
+		if (requestId && isStore(store)) {
+			this._subscribedTo = requestId;
+			this._subscription = store.notifications.subscribe(requestId, (_id, op) => {
+				if (this._isUpdating) return;
+				switch (op) {
+					case "invalidated":
+						if (this.autorefreshTypes.has("invalid")) {
+							this._invalidated = true;
+							this._maybeUpdate();
+						}
+						break;
+					case "state": {
+						const priority = store.requestManager._deduped.get(requestId)?.priority;
+						const state = this.reqState;
+						if (!priority) this.isRefreshing = false;
+						else if (priority.blocking && !state.isLoading) {
+							this.isRefreshing = false;
+							this._maybeUpdate("policy", true);
+						} else this.isRefreshing = true;
+					}
+				}
+			});
+		}
+	}
+	/**
+	* @internal
+	*/
+	_removeSubscriptions() {
+		const store = this._requester;
+		if (this._subscription && store && isStore(store)) {
+			store.notifications.unsubscribe(this._subscription);
+			this._subscribedTo = null;
+			this._subscription = null;
+			this._requester = null;
+		}
+	}
+	/**
+	* Install the event listeners for network and visibility changes.
+	*
+	* This is only done in environments that provide a fully-featured global
+	* `window` and/or `document`. Some non-DOM environments (e.g. React Native,
+	* SSR/Node, workers) may provide a `window` global without the APIs we
+	* rely on here (or no `window`/`document` at all), in which case we skip
+	* attaching the corresponding listeners rather than throwing.
+	*
+	* @internal
+	*/
+	_installListeners() {
+		const hasWindow = typeof window !== "undefined";
+		const hasDocument = typeof document !== "undefined";
+		const hasWindowEvents = hasWindow && typeof window.addEventListener === "function";
+		const hasDocumentEvents = hasDocument && typeof document.addEventListener === "function";
+		this.isOnline = hasWindow && typeof window.navigator?.onLine === "boolean" ? window.navigator.onLine : true;
+		this._unavailableStart = this.isOnline ? null : Date.now();
+		this.isHidden = hasDocument && typeof document.visibilityState === "string" && document.visibilityState === "hidden";
+		if (hasWindowEvents) {
+			this._onlineChanged = (event) => {
+				this.isOnline = event.type === "online";
+				if (event.type === "offline" && this._unavailableStart === null) this._unavailableStart = Date.now();
+				this._maybeUpdate();
+			};
+			window.addEventListener("online", this._onlineChanged, {
+				passive: true,
+				capture: true
+			});
+			window.addEventListener("offline", this._onlineChanged, {
+				passive: true,
+				capture: true
+			});
+		}
+		if (hasDocumentEvents) {
+			this._backgroundChanged = () => {
+				const isHidden = document.visibilityState === "hidden";
+				this.isHidden = isHidden;
+				if (isHidden && this._unavailableStart === null) this._unavailableStart = Date.now();
+				this._maybeUpdate();
+			};
+			document.addEventListener("visibilitychange", this._backgroundChanged, {
+				passive: true,
+				capture: true
+			});
+		}
+	}
+	/**
+	* If the network is online and the tab is visible, either reload or refresh the request
+	* based on the component's configuration and the requested update mode.
+	*
+	* Valid modes are:
+	*
+	* - `'reload'`: Force a reload of the request.
+	* - `'refresh'`: Refresh the request in the background.
+	* - `'policy'`: Make the request, letting the store's configured CachePolicy decide whether to reload, refresh, or do nothing.
+	* - `undefined`: Make the request using the component's autorefreshBehavior setting if the autorefreshThreshold has passed.
+	*
+	* @internal
+	*/
+	_maybeUpdate(mode, silent) {
+		if (this.isIdle) return;
+		const { reqState } = this;
+		if (reqState.isPending) return;
+		if (!Boolean(this.isOnline && !this.isHidden && (mode || this.autorefreshTypes.size))) {
+			if (!silent && mode && mode !== "_invalidated") throw new Error(`Reload not available: the network is not online or the tab is hidden`);
+			return;
+		}
+		const { autorefreshTypes } = this;
+		let shouldAttempt = this._invalidated || Boolean(mode);
+		if (!shouldAttempt && autorefreshTypes.has("online")) {
+			const { _unavailableStart } = this;
+			const { autorefreshThreshold } = this._args;
+			const deadline = typeof autorefreshThreshold === "number" ? autorefreshThreshold : DEFAULT_DEADLINE;
+			shouldAttempt = Boolean(_unavailableStart && Date.now() - _unavailableStart > deadline);
+		}
+		if (!shouldAttempt && autorefreshTypes.has("interval")) {
+			const { _intervalStart } = this;
+			const { autorefreshThreshold } = this._args;
+			if (_intervalStart && typeof autorefreshThreshold === "number" && autorefreshThreshold > 0) shouldAttempt = Boolean(Date.now() - _intervalStart >= autorefreshThreshold);
+		}
+		this._unavailableStart = null;
+		this._invalidated = false;
+		if (shouldAttempt) {
+			this._clearInterval();
+			this._isUpdating = true;
+			const val = (mode === "_invalidated" ? null : mode) ?? this._args.autorefreshBehavior ?? "policy";
+			const requester = this._getRequester();
+			if (!reqState._request.requester) reqState._request.requester = requester;
+			switch (val) {
+				case "reload":
+					this._latestRequest = reqState.reload();
+					break;
+				case "refresh":
+					this._latestRequest = reqState.refresh();
+					break;
+				case "policy":
+					this._latestRequest = reqState.refresh(true);
+					break;
+				default: ((test) => {
+					if (!test) throw new Error(`Invalid ${mode ? "update mode" : "@autorefreshBehavior"} for <Request />: ${isNeverString(val)}`);
+				})(false);
+			}
+			if (val !== "refresh") this._localRequest = this._latestRequest;
+			this._scheduleInterval();
+			this._latestRequest.finally(() => {
+				this._isUpdating = false;
+			});
+		}
+	}
+	/**
+	* @internal
+	*/
+	_getRequester() {
+		if (this._args.request?.requester) return this._args.request.requester;
+		return this.store;
+	}
+	/**
+	* Retry the request, reloading it from the server.
+	*/
+	retry = async () => {
+		this._maybeUpdate("reload");
+		await this._localRequest;
+	};
+	/**
+	* Refresh the request, updating it in the background.
+	*/
+	refresh = async () => {
+		this._maybeUpdate("refresh");
+		await this._latestRequest;
+	};
+	/**
+	* features to yield to the error slot of a component
+	*/
+	get errorFeatures() {
+		return {
+			isHidden: this.isHidden,
+			isOnline: this.isOnline,
+			retry: this.retry
+		};
+	}
+	/**
+	* features to yield to the content slot of a component
+	*/
+	static {
+		decorateMethodV2(this.prototype, "errorFeatures", [memoized]);
+	}
+	get contentFeatures() {
+		const feat = {
+			isHidden: this.isHidden,
+			isOnline: this.isOnline,
+			reload: this.retry,
+			refresh: this.refresh,
+			isRefreshing: this.isRefreshing,
+			latestRequest: this._latestRequest
+		};
+		if (feat.isRefreshing) feat.abort = () => {
+			this._latestRequest?.abort();
+		};
+		return feat;
+	}
+	/**
+	* @internal
+	*/
+	static {
+		decorateMethodV2(this.prototype, "contentFeatures", [memoized]);
+	}
+	get _request() {
+		const { request, query } = this._args;
+		((test) => {
+			if (!test) throw new Error(`Cannot use both @request and @query args with the <Request> component`);
+		})(!request || !query);
+		const { _localRequest, _originalRequest, _originalQuery } = this;
+		if (_localRequest && request === _originalRequest && query === _originalQuery) return _localRequest;
+		this._originalQuery = query;
+		this._originalRequest = request;
+		if (request) return request;
+		((test) => {
+			if (!test) throw new Error(`You must provide either @request or an @query arg with the <Request> component`);
+		})(query);
+		return this.store.request(query);
+	}
+	/**
+	* The {@link Future} this subscription is currently monitoring, and
+	* (re-)subscribes to notifications for as a side effect of access.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "_request", [memoized]);
+	}
+	get request() {
+		try {
+			const request = this._request;
+			this._updateSubscriptions();
+			return request;
+		} catch (e) {
+			console.log(e);
+			throw new Error(`Unable to initialize the request`, { cause: e });
+		}
+	}
+	/**
+	* The {@link RequestState} for {@link RequestSubscription.request | request}.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "request", [memoized]);
+	}
+	get reqState() {
+		return getRequestState(this.request);
+	}
+	/**
+	* The resolved content of the request, once it has succeeded.
+	*/
+	get result() {
+		return this.reqState.result;
+	}
+};
+defineSignal(RequestSubscription.prototype, "isOnline", true);
+defineSignal(RequestSubscription.prototype, "isHidden", false);
+defineSignal(RequestSubscription.prototype, "isRefreshing", false);
+defineSignal(RequestSubscription.prototype, "_localRequest", void 0);
+defineSignal(RequestSubscription.prototype, "_latestRequest", void 0);
+function isStore(store) {
+	return "requestManager" in store;
+}
+/**
+* Creates a {@link RequestSubscription}, the reactive class powering the
+* `<Request />` component's autorefresh, retry, and refresh behaviors.
+*/
+function createRequestSubscription(store, args) {
+	return new RequestSubscription(store, args);
+}
+function upgradeSubscription(sub) {
+	return sub;
+}
+function _DISPOSE() {
+	const self = upgradeSubscription(this);
+	self.isDestroyed = true;
+	self._removeSubscriptions();
+	self._clearInterval();
+	if (self._onlineChanged && typeof window !== "undefined" && typeof window.removeEventListener === "function") {
+		window.removeEventListener("online", self._onlineChanged, {
+			passive: true,
+			capture: true
+		});
+		window.removeEventListener("offline", self._onlineChanged, {
+			passive: true,
+			capture: true
+		});
+	}
+	if (self._backgroundChanged && typeof document !== "undefined" && typeof document.removeEventListener === "function") document.removeEventListener("visibilitychange", self._backgroundChanged, {
+		passive: true,
+		capture: true
+	});
+}
+
+//#endregion
+//#region src/signals/promise-state.ts
+const PromiseCache = /* @__PURE__ */ new WeakMap();
+/**
+* The state of a promise in the "pending"
+* state. This is the default initial state.
+*
+*/
+/**
+* The state of a promise in the "fulfilled" state.
+* This is the state of a promise that has resolved
+* successfully.
+*
+*/
+/**
+* The state of a promise in the "rejected" state.
+* This is the state of a promise that has rejected
+* with an error.
+*
+*/
+/**
+* The state of a promise. This is the type that is returned
+* from `getPromiseState`.
+*
+* See also:
+* - {@link PendingPromise}
+* - {@link ResolvedPromise}
+* - {@link RejectedPromise}
+*
+*/
+const PromiseStateProto = {};
+defineSignal(PromiseStateProto, "reason", null);
+defineSignal(PromiseStateProto, "value", null);
+defineSignal(PromiseStateProto, "result", null);
+defineSignal(PromiseStateProto, "error", null);
+defineSignal(PromiseStateProto, "status", "pending");
+defineSignal(PromiseStateProto, "isPending", true);
+defineSignal(PromiseStateProto, "isLoading", true);
+defineSignal(PromiseStateProto, "isSuccess", false);
+defineSignal(PromiseStateProto, "isError", false);
+function createPromiseState(promise) {
+	const state = getPromiseResult(promise);
+	const promiseState = Object.create(PromiseStateProto);
+	if (state) {
+		if (state.isError) {
+			promiseState.error = state.result;
+			promiseState.reason = state.result;
+			promiseState.status = "rejected";
+			promiseState.isError = true;
+			promiseState.isPending = false;
+			promiseState.isLoading = false;
+		} else {
+			promiseState.result = state.result;
+			promiseState.value = state.result;
+			promiseState.status = "fulfilled";
+			promiseState.isSuccess = true;
+			promiseState.isPending = false;
+			promiseState.isLoading = false;
+		}
+	} else promise.then((result) => {
+		setPromiseResult(promise, {
+			isError: false,
+			result
+		});
+		promiseState.result = result;
+		promiseState.value = result;
+		promiseState.status = "fulfilled";
+		promiseState.isSuccess = true;
+		promiseState.isPending = false;
+		promiseState.isLoading = false;
+	}, (error) => {
+		setPromiseResult(promise, {
+			isError: true,
+			result: error
+		});
+		promiseState.error = error;
+		promiseState.reason = error;
+		promiseState.status = "rejected";
+		promiseState.isError = true;
+		promiseState.isPending = false;
+		promiseState.isLoading = false;
+	});
+	return promiseState;
+}
+const LegacyPromiseProxy = Symbol.for("LegacyPromiseProxy");
+function isLegacyAwaitable(promise) {
+	return LegacyPromiseProxy in promise && "promise" in promise && promise[LegacyPromiseProxy] === true;
+}
+function getPromise(promise) {
+	return isLegacyAwaitable(promise) ? promise.promise : promise;
+}
+/**
+* Returns a reactive state-machine for the provided promise or awaitable.
+*
+* Repeat calls to `getPromiseState` with the same promise will return the same state object
+* making is safe and easy to use in templates and JavaScript code to produce reactive
+* behaviors around promises.
+*
+* `getPromiseState` can be used in both JavaScript and Template contexts.
+*
+* ```ts
+* import { getPromiseState } from '@warp-drive-mirror/ember';
+*
+* const state = getPromiseState(promise);
+* ```
+*
+* For instance, we could write a getter on a component that updates whenever
+* the promise state advances or the promise changes, by combining the function
+* with the use of `@cached`
+*
+* ```ts
+* class Component {
+*   @cached
+*   get title() {
+*     const state = getPromiseState(this.args.request);
+*     if (state.isPending) {
+*       return 'loading...';
+*     }
+*     if (state.isError) { return null; }
+*     return state.result.title;
+*   }
+* }
+* ```
+*
+* Or in a template as a helper:
+*
+* ```gjs
+* import { getPromiseState } from '@warp-drive-mirror/ember';
+*
+* <template>
+*   {{#let (getPromiseState @request) as |state|}}
+*     {{#if state.isPending}} <Spinner />
+*     {{else if state.isError}} <ErrorForm @error={{state.error}} />
+*     {{else}}
+*       <h1>{{state.result.title}}</h1>
+*     {{/if}}
+*   {{/let}}
+* </template>
+* ```
+*
+* If looking to use in a template, consider also the `<Await />` component.
+*
+* See also {@link PromiseState}
+*/
+function getPromiseState(promise) {
+	((test) => {
+		if (!test) throw new Error(`getPromiseState expects to be called with a promise: called with ${String(promise)}`);
+	})(promise);
+	const _promise = getPromise(promise);
+	let state = PromiseCache.get(_promise);
+	if (!state) {
+		state = createPromiseState(_promise);
+		PromiseCache.set(_promise, state);
+	}
+	return state;
+}
+
+//#endregion
+export { ARRAY_SIGNAL as C, willSyncFlushWatchers as D, waitFor as E, withSignalStore as S, setupSignals as T, createInternalSignal as _, createSignalDescriptor as a, notifyInternalSignal as b, defineSignal as c, gate as d, memoized as f, createInternalMemo as g, consumeInternalSignal as h, getRequestState as i, entangleInitiallyStaleSignal as l, Signals as m, DISPOSE as n, defineGate as o, signal as p, createRequestSubscription as r, defineNonEnumerableSignal as s, getPromiseState as t, entangleSignal as u, getOrCreateInternalSignal as v, OBJECT_SIGNAL as w, peekInternalSignal as x, makeInitializer as y };
+//# sourceMappingURL=-private-C1QTxlMX.js.map