@warp-drive/core 5.9.0-beta.1 → 5.9.0-beta.3

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

@@ -0,0 +1,3519 @@
+import { a as setTransient, r as peekTransient, t as getOrSetGlobal } from "./-private-DhiS6yOR.js";
+import { f as setPromiseResult, o as DOMError, u as getPromiseResult } from "./request-BbbzRou7.js";
+
+//#region src/signals/reactivity/configure.ts
+const ARRAY_SIGNAL = getOrSetGlobal("#[]", Symbol("#[]"));
+const OBJECT_SIGNAL = getOrSetGlobal("#{}", Symbol("#{}"));
+/**
+* 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/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/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_5d4eca388601a94e7fbc656401b751d1/node_modules/decorator-transforms/dist/runtime--fcdnjmJ.js
+const deferred = /* @__PURE__ */ new WeakMap();
+function deferDecorator(proto, prop, desc) {
+	let map = deferred.get(proto);
+	if (!map) {
+		map = /* @__PURE__ */ new Map();
+		deferred.set(proto, map);
+	}
+	map.set(prop, desc);
+}
+function findDeferredDecorator(target, prop) {
+	var _a;
+	let cursor = target.prototype;
+	while (cursor) {
+		let desc = (_a = deferred.get(cursor)) == null ? void 0 : _a.get(prop);
+		if (desc) return desc;
+		cursor = Object.getPrototypeOf(cursor);
+	}
+}
+function decorateFieldV2(prototype, prop, decorators, initializer) {
+	let desc = {
+		configurable: true,
+		enumerable: true,
+		writable: true,
+		initializer: null
+	};
+	if (initializer) desc.initializer = initializer;
+	for (let decorator of decorators) desc = decorator(prototype, prop, desc) || desc;
+	if (desc.initializer === void 0) Object.defineProperty(prototype, prop, desc);
+	else deferDecorator(prototype, prop, desc);
+}
+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);
+}
+function initializeDeferredDecorator(target, prop) {
+	let desc = findDeferredDecorator(target.constructor, prop);
+	if (desc) Object.defineProperty(target, prop, {
+		enumerable: desc.enumerable,
+		configurable: desc.configurable,
+		writable: desc.writable,
+		value: desc.initializer ? desc.initializer.call(target) : void 0
+	});
+}
+
+//#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$2;
+		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$2(sub) {
+	return sub;
+}
+function _DISPOSE$2() {
+	const self = upgradeSubscription$2(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/page-cache.ts
+const { abs } = Math;
+/**
+* Extracts the `data` member of a document type, or the document type itself
+* when it has no `data` member.
+*/
+/**
+* The element type of a collection document's `data` array — the item type an
+* infinite view renders. See {@link PaginationState.data}.
+*/
+/** @internal */
+function getHref(link) {
+	if (!link) return null;
+	if (typeof link === "string") return link;
+	return link.href;
+}
+/**
+* A single page of a paginated collection: its request, its loaded document, and
+* its links to neighboring pages in the shared page graph.
+*
+* Pages are yielded to consumers as `Readonly<PageCache>` — through
+* {@link PaginationState.activePage}, {@link PaginationState.pages}, and the
+* relational getters below — to read a page's data and request status when
+* building pagination UIs:
+*
+* ```ts
+* const page = paginationState.activePage;
+*
+* if (page?.isLoading) {
+*   // show a spinner
+* } else if (page?.isError) {
+*   // show page.reason
+* } else {
+*   // render page.data
+* }
+* ```
+*
+* @since 5.9.0
+* @public
+* @hideconstructor
+*/
+var PageCache = class {
+	static {
+		decorateFieldV2(this.prototype, "request", [signal]);
+	}
+	#request = (initializeDeferredDecorator(this, "request"), void 0);
+	/** @internal */
+	/**
+	* The request that loaded (or is loading) this page, or `null` if the page is
+	* known from links but was never requested. Wrap it in a `<Request>` component
+	* to render the page's loading, error, and content states.
+	*/
+	static {
+		decorateFieldV2(this.prototype, "state", [signal]);
+	}
+	#state = (initializeDeferredDecorator(this, "state"), void 0);
+	/** @internal */
+	static {
+		decorateFieldV2(this.prototype, "selfLink", [signal]);
+	}
+	#selfLink = (initializeDeferredDecorator(this, "selfLink"), void 0);
+	/** The `self` link of this page — the URL that identifies it in the collection. */
+	static {
+		decorateFieldV2(this.prototype, "prevLink", [signal]);
+	}
+	#prevLink = (initializeDeferredDecorator(this, "prevLink"), void 0);
+	/** The `prev` link of this page, or `null` at the start of the collection. */
+	static {
+		decorateFieldV2(this.prototype, "nextLink", [signal]);
+	}
+	#nextLink = (initializeDeferredDecorator(this, "nextLink"), void 0);
+	/** The `next` link of this page, or `null` at the end of the collection. */
+	static {
+		decorateFieldV2(this.prototype, "firstLink", [signal]);
+	}
+	#firstLink = (initializeDeferredDecorator(this, "firstLink"), void 0);
+	/** The `first` link of the collection, when the response exposed one. */
+	static {
+		decorateFieldV2(this.prototype, "lastLink", [signal]);
+	}
+	#lastLink = (initializeDeferredDecorator(this, "lastLink"), void 0);
+	/** The `last` link of the collection, when the response exposed one. */
+	static {
+		decorateFieldV2(this.prototype, "pageNumber", [signal]);
+	}
+	#pageNumber = (initializeDeferredDecorator(this, "pageNumber"), void 0);
+	/**
+	* The 1-based page number, or `0` when unknown (for example cursor-based
+	* pagination, where pages have no ordinal position). Derived from the
+	* collection's {@link PageHints}.
+	*/
+	static {
+		decorateFieldV2(this.prototype, "before", [signal]);
+	}
+	#before = (initializeDeferredDecorator(this, "before"), void 0);
+	/** @internal */
+	static {
+		decorateFieldV2(this.prototype, "after", [signal]);
+	}
+	#after = (initializeDeferredDecorator(this, "after"), void 0);
+	/** @internal */
+	constructor(manager, url) {
+		this.manager = manager;
+		this.pageNumber = 0;
+		this.selfLink = url;
+	}
+	/**
+	* The document this page's request resolved to, or `null` while it has not
+	* resolved.
+	*/
+	get value() {
+		return this.state?.value;
+	}
+	/**
+	* The `data` member of the loaded document — the page's items — or `null`
+	* while the page has not loaded.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "value", [memoized]);
+	}
+	get data() {
+		return this.value?.data ?? null;
+	}
+	/**
+	* Whether a request has ever been issued for this page. `false` for pages that
+	* are known only from links.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "data", [memoized]);
+	}
+	get isRequested() {
+		return Boolean(this.state);
+	}
+	/** Whether this page's request has settled (successfully or with an error). */
+	static {
+		decorateMethodV2(this.prototype, "isRequested", [memoized]);
+	}
+	get isLoaded() {
+		return this.isSuccess || this.isError;
+	}
+	/** Whether this page's request is currently in flight. */
+	static {
+		decorateMethodV2(this.prototype, "isLoaded", [memoized]);
+	}
+	get isLoading() {
+		return Boolean(this.state?.isLoading);
+	}
+	/** Whether this page's request resolved successfully. */
+	static {
+		decorateMethodV2(this.prototype, "isLoading", [memoized]);
+	}
+	get isSuccess() {
+		return Boolean(this.state?.isSuccess);
+	}
+	/** Whether this page's request was cancelled (aborted). */
+	static {
+		decorateMethodV2(this.prototype, "isSuccess", [memoized]);
+	}
+	get isCancelled() {
+		return Boolean(this.state?.isCancelled);
+	}
+	/** Whether this page's request rejected with an error. */
+	static {
+		decorateMethodV2(this.prototype, "isCancelled", [memoized]);
+	}
+	get isError() {
+		return Boolean(this.state?.isError);
+	}
+	/** The error this page's request rejected with, or `null` if it did not reject. */
+	static {
+		decorateMethodV2(this.prototype, "isError", [memoized]);
+	}
+	get reason() {
+		return this.state?.reason ?? null;
+	}
+	/** The page at this page's `prev` link, or `null` at the start of the collection. */
+	static {
+		decorateMethodV2(this.prototype, "reason", [memoized]);
+	}
+	get prev() {
+		const url = this.prevLink;
+		return url ? this.manager.getPageCache(url) : null;
+	}
+	/** The page at this page's `next` link, or `null` at the end of the collection. */
+	static {
+		decorateMethodV2(this.prototype, "prev", [memoized]);
+	}
+	get next() {
+		const url = this.nextLink;
+		return url ? this.manager.getPageCache(url) : null;
+	}
+	/** The first page of the collection, when the response exposed a `first` link. */
+	static {
+		decorateMethodV2(this.prototype, "next", [memoized]);
+	}
+	get first() {
+		const url = this.firstLink;
+		return url ? this.manager.getPageCache(url) : null;
+	}
+	/** The last page of the collection, when the response exposed a `last` link. */
+	static {
+		decorateMethodV2(this.prototype, "first", [memoized]);
+	}
+	get last() {
+		const url = this.lastLink;
+		return url ? this.manager.getPageCache(url) : null;
+	}
+	/** @internal */
+	static {
+		decorateMethodV2(this.prototype, "last", [memoized]);
+	}
+	get isLinked() {
+		return Boolean(this.before || this.after);
+	}
+	/** @internal */
+	static {
+		decorateMethodV2(this.prototype, "isLinked", [memoized]);
+	}
+	async load(request) {
+		try {
+			this.request = request;
+			this.state = getRequestState(this.request);
+			const content = (await this.request).content;
+			const self = getHref(content?.links?.self);
+			const first = getHref(content?.links?.first);
+			const last = getHref(content?.links?.last);
+			const next = getHref(content?.links?.next);
+			const prev = getHref(content?.links?.prev);
+			((test) => {
+				if (!test) throw new Error("Expected the page to have a self link");
+			})(self);
+			const pageNumber = this.getPageNumber(content);
+			if (pageNumber) this.pageNumber = pageNumber;
+			const firstPage = first ? this.manager.getPageCache(first) : null;
+			const lastPage = last ? this.manager.getPageCache(last) : null;
+			const prevPage = prev ? this.manager.getPageCache(prev) : null;
+			const nextPage = next ? this.manager.getPageCache(next) : null;
+			if (firstPage) {
+				this.firstLink = first;
+				firstPage.setPageNumber(1);
+				if (!firstPage.after) firstPage.updateLinkage({ after: this });
+			}
+			if (lastPage) {
+				this.lastLink = last;
+				lastPage.setPageNumber(this.manager.totalPages);
+				if (!lastPage.before) lastPage.updateLinkage({ before: this });
+			}
+			if (nextPage) {
+				this.nextLink = next;
+				nextPage.setPageNumber(this.pageNumber + 1);
+				nextPage.updateLinks({ prev: self });
+			}
+			if (prevPage) {
+				this.prevLink = prev;
+				prevPage.setPageNumber(this.pageNumber - 1);
+				prevPage.updateLinks({ next: self });
+			}
+			if (this.isLinked) {
+				if (prevPage) prevPage.updateLinkage({ after: this });
+				if (nextPage) nextPage.updateLinkage({ before: this });
+			} else if (prevPage?.isLinked) {
+				this.updateLinkage({ before: prevPage });
+				if (nextPage) nextPage.updateLinkage({ before: this });
+			} else if (nextPage?.isLinked) {
+				this.updateLinkage({ after: nextPage });
+				if (prevPage) prevPage.updateLinkage({ after: this });
+			} else if ((prevPage || nextPage) && (firstPage || lastPage)) this.lookupLinkage(firstPage, lastPage);
+			else if (prevPage || nextPage) this.updateLinkage({
+				before: prevPage,
+				after: nextPage
+			});
+			return content;
+		} catch {}
+		return null;
+	}
+	/** @internal */
+	updateLinkage({ before, after }) {
+		((test) => {
+			if (!test) throw new Error("Expected at least one of before or after page states to link to this page");
+		})(before || after);
+		const leftSide = before ?? after?.before;
+		const rightSide = after ?? before?.after;
+		if (leftSide && leftSide !== this) {
+			leftSide.setAfter(this);
+			this.setBefore(leftSide);
+		}
+		if (rightSide && rightSide !== this) {
+			rightSide.setBefore(this);
+			this.setAfter(rightSide);
+		}
+	}
+	/** @internal */
+	lookupLinkage(firstPage, lastPage) {
+		((test) => {
+			if (!test) throw new Error("Expected at least one of firstPage or lastPage to lookup linkage against");
+		})(firstPage || lastPage);
+		if (firstPage && lastPage) {
+			if (abs(this.pageNumber - firstPage.pageNumber) <= abs(this.pageNumber - lastPage.pageNumber)) this.lookupLinkageForward(firstPage);
+			else this.lookupLinkageBackwards(lastPage);
+		} else if (firstPage) this.lookupLinkageForward(firstPage);
+		else if (lastPage) this.lookupLinkageBackwards(lastPage);
+	}
+	/** @internal */
+	lookupLinkageForward(page) {
+		while (page.after && page.after.pageNumber < this.pageNumber) page = page.after;
+		this.updateLinkage({ before: page });
+	}
+	/** @internal */
+	lookupLinkageBackwards(page) {
+		while (page.before && page.before.pageNumber > this.pageNumber) page = page.before;
+		this.updateLinkage({ after: page });
+	}
+	/** @internal */
+	setBefore(page) {
+		((test) => {
+			if (!test) throw new Error("Expected the before page to be a different page, got the same page");
+		})(page !== this);
+		this.before = page;
+	}
+	/** @internal */
+	setAfter(page) {
+		((test) => {
+			if (!test) throw new Error("Expected the after page to be a different page, got the same page");
+		})(page !== this);
+		this.after = page;
+	}
+	/** @internal */
+	getPageNumber(document) {
+		return this.manager.readPageHints(document).currentPage;
+	}
+	/** @internal */
+	updateLinks = ({ prev, next, first, last }) => {
+		if (prev) this.prevLink = prev;
+		if (next) this.nextLink = next;
+		if (first) this.firstLink = first;
+		if (last) this.lastLink = last;
+	};
+	/** @internal */
+	setPageNumber = (pageNumber) => {
+		if (!this.pageNumber) this.pageNumber = pageNumber;
+	};
+};
+
+//#endregion
+//#region src/signals/pagination-cache.ts
+const PaginationCacheMap = /* @__PURE__ */ new Map();
+/**
+* A hint function for extracting the `currentPage` and `totalPages` from a loaded
+* document, for when the response does not expose these values through the
+* default `meta` locations. Provided by the consumer via `<Paginate />`'s
+* `@pageHints` arg:
+*
+* ```gts
+* <Paginate @pageHints={{...}} />
+* ```
+*
+* Since these values are attached to the shared {@link PaginationCache}, the hint is
+* a property of the *collection*, not the component. Every `<Paginate />` sharing a
+* collection must provide the same function reference — define it once at module
+* scope and import it everywhere.
+*
+* @since 5.9.0
+* @public
+*/
+/**
+* The default {@link PageHints}. Reads `currentPage`/`page` and `totalPages` from the
+* document `meta`, matching the behavior used before `pageHints` was configurable.
+* Used whenever the consumer does not provide a `pageHints` function.
+*
+* @since 5.9.0
+* @public
+*/
+const defaultPageHints = (document) => {
+	return {
+		currentPage: document.meta?.page ?? document.meta?.currentPage ?? 0,
+		totalPages: document.meta?.totalPages ?? 0
+	};
+};
+/**
+* The global, shared cache for a paginated collection. Keyed by the collection's
+* `first` (or `self`) link, so that multiple components paging the same collection
+* share loaded pages, the page graph, and `totalPages`.
+*
+* This holds only shared, request-agnostic data. Per-component state (the active
+* page, navigation) lives on {@link PaginationState}, which is the API consumers
+* interact with — the cache itself is plumbing shared between the pagination
+* classes.
+*
+* @since 5.9.0
+* @public
+* @hideconstructor
+*/
+var PaginationCache = class {
+	static {
+		decorateFieldV2(this.prototype, "firstPage", [signal]);
+	}
+	#firstPage = (initializeDeferredDecorator(this, "firstPage"), void 0);
+	/**
+	* The cache key this collection is stored under in the module-level cache —
+	* its `first` (or `self`) link. This is the collection's identity: two
+	* requests whose documents resolve to the same key are pages of the same
+	* collection.
+	*
+	* @internal
+	*/
+	/** @internal */
+	static {
+		decorateFieldV2(this.prototype, "totalPages", [signal]);
+	}
+	#totalPages = (initializeDeferredDecorator(this, "totalPages"), void 0);
+	/**
+	* The total number of pages in the collection, or `0` when unknown. Consumers
+	* should read this via {@link PaginationState.totalPages}.
+	*/
+	static {
+		decorateFieldV2(this.prototype, "isNumbered", [signal]);
+	}
+	#isNumbered = (initializeDeferredDecorator(this, "isNumbered"), void 0);
+	/**
+	* Whether this collection has server-known page numbers. Stays `false` for
+	* cursor-based collections (opaque `prev`/`next`, no index/total), which drives
+	* whether numbered links are produced. Set once a {@link PageHints} yields a real
+	* `currentPage`/`totalPages`.
+	*
+	* @internal
+	*/
+	/** @internal */
+	/** @internal */
+	pageHints = defaultPageHints;
+	constructor(key) {
+		this.key = key;
+		this.pagesCache = /* @__PURE__ */ new Map();
+		this.firstPage = null;
+		this.totalPages = 0;
+		this.isNumbered = false;
+	}
+	/**
+	* Installs the consumer-provided {@link PageHints} onto the shared cache. The first
+	* explicit hint wins; passing `undefined` (no hint) is a no-op that preserves the
+	* default. In dev, asserts that components sharing a collection do not provide
+	* diverging hint functions.
+	*
+	* @internal
+	*/
+	installPageHints(pageHints) {
+		if (!pageHints) return;
+		if (this.pageHints === defaultPageHints) {
+			this.pageHints = pageHints;
+			return;
+		}
+		((test) => {
+			if (!test) throw new Error("Received diverging `pageHints` functions for the same paginated collection. Provide the same function reference to every <Paginate /> sharing a collection (define it once at module scope).");
+		})(this.pageHints === pageHints);
+	}
+	/**
+	* Runs the active {@link PageHints} against a document.
+	*
+	* Both values are *hints*, not requirements. A value of `0` means "unknown" —
+	* the response did not expose it and no `pageHints` function derived it. When a
+	* value is present (`> 0`) it is relied upon (numbered links, total, sparse
+	* placement of jumped-to pages); when absent the page graph falls back to pure
+	* `prev`/`next` adjacency (as in cursor/infinite streams).
+	*
+	* @internal
+	*/
+	readPageHints(document) {
+		const { currentPage, totalPages } = this.pageHints(document);
+		if (currentPage > 0 || totalPages > 0) this.isNumbered = true;
+		return {
+			currentPage,
+			totalPages
+		};
+	}
+	/** @internal */
+	getPageCache(url) {
+		let page = this.pagesCache.get(url);
+		if (!page) {
+			page = new PageCache(this, url);
+			this.pagesCache.set(url, page);
+		}
+		return page;
+	}
+	/** @internal */
+	loadPage(url, request) {
+		const page = this.getPageCache(url);
+		if ((!page.isLoaded || page.isError) && request) {
+			((test) => {
+				if (!test) throw new Error("Expected a request to a load a page");
+			})(request);
+			page.load(request).then((document) => {
+				this.updateFirstPage(page);
+				if (document) this.totalPages = this.getTotalPages(document);
+			});
+		}
+		return page;
+	}
+	/** @internal */
+	updateFirstPage(page) {
+		let maybeFirstPage = page;
+		while (maybeFirstPage.before) maybeFirstPage = maybeFirstPage.before;
+		if (!this.firstPage || this.firstPage.pageNumber > maybeFirstPage.pageNumber) this.firstPage = maybeFirstPage;
+	}
+	/** @internal */
+	getTotalPages(document) {
+		return this.readPageHints(document).totalPages;
+	}
+	/**
+	* Every page known to the shared graph, in order — loaded pages and pages
+	* known only from links — across all components sharing the collection.
+	*
+	* This is the whole-collection view. For the run a single component is
+	* viewing, use {@link PaginationState.pages}.
+	*
+	* ```ts
+	* const cache = getPaginationCache(firstLink);
+	* for (const page of cache.pages) {
+	*   // page.isLoaded, page.pageNumber, page.data, ...
+	* }
+	* ```
+	*/
+	get pages() {
+		const self = this;
+		return { *[Symbol.iterator]() {
+			let page = self.firstPage;
+			while (page) {
+				yield page;
+				page = page.after;
+			}
+		} };
+	}
+	/**
+	* The items of every loaded page in the shared graph, flattened into one
+	* contiguous iterable in page order. Pages that are known but not loaded
+	* contribute nothing.
+	*
+	* This is the whole-collection view. For the run a single component is
+	* viewing, use {@link PaginationState.data}.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "pages", [memoized]);
+	}
+	get data() {
+		const self = this;
+		return { *[Symbol.iterator]() {
+			for (const page of self.pages) if (page.data) yield* page.data;
+		} };
+	}
+	static {
+		decorateMethodV2(this.prototype, "data", [memoized]);
+	}
+};
+/**
+* Get the shared {@link PaginationCache} for a given cache key (the collection's
+* `first` or `self` link). Returns the same instance for the same key for the
+* lifetime of the module.
+*
+* @since 5.9.0
+* @public
+*/
+function getPaginationCache(key) {
+	let cache = PaginationCacheMap.get(key);
+	if (!cache) {
+		cache = new PaginationCache(key);
+		PaginationCacheMap.set(key, cache);
+	}
+	return cache;
+}
+/**
+* Clears the module-level pagination cache used by {@link getPaginationCache}.
+* Primarily intended for test isolation, since the cache is keyed by url and
+* otherwise persists for the lifetime of the module.
+*
+* @since 5.9.0
+* @public
+*/
+function clearPaginationCache() {
+	PaginationCacheMap.clear();
+}
+
+//#endregion
+//#region src/signals/pagination-state.ts
+/**
+* The two navigation surfaces a `<Paginate />` component can drive. Selecting
+* one (via the component's `@mode` arg) narrows the yielded state so the two
+* APIs cannot be mixed:
+*
+* - `'paged'` — single-page view, see {@link PagedPaginationState}.
+* - `'infinite'` — accumulated view, see {@link InfinitePaginationState}.
+*/
+/**
+* The part of a {@link PaginationState} available to both navigation surfaces.
+*/
+/**
+* The paged (single-page view) surface of a {@link PaginationState}: render
+* {@link PaginationState.activePageRequest | activePageRequest}, navigate with
+* {@link PaginationState.loadPage | loadPage}. This is what the `<Paginate />`
+* component yields in `'paged'` mode (the default).
+*/
+/**
+* The infinite (accumulated view) surface of a {@link PaginationState}: render
+* {@link PaginationState.data | data}, grow it with
+* {@link PaginationState.loadNext | loadNext}/{@link PaginationState.loadPrev | loadPrev}.
+* This is what the `<Paginate />` component yields in `'infinite'` mode.
+*/
+/**
+* Resolves a {@link PaginateMode} to the surface it exposes, so a component
+* generic over the mode can yield only that surface.
+*/
+/**
+* The per-component, local pagination state. It houses the state that is unique
+* to a single component instance — the active page and navigation — while
+* referencing a shared {@link PaginationCache} for the page graph and data.
+*
+* This is the object yielded by the `<Paginate />` component, narrowed by the
+* component's `@mode` arg to one of its two navigation surfaces so the two
+* APIs cannot be mixed:
+*
+* - **Paged** (`@mode="paged"`, the default): {@link PagedPaginationState} —
+*   render {@link activePageRequest}, navigate with {@link loadPage} (what the
+*   numbered/relational links call). Reads {@link activePage}.
+* - **Infinite** (`@mode="infinite"`): {@link InfinitePaginationState} — render
+*   {@link data}, wrap {@link nextRequest}/{@link previousRequest} in `<Request>`
+*   for loading state, and grow the view with {@link loadNext}/{@link loadPrev}.
+*
+* Both surfaces read the same shared page graph; the mode only selects which
+* API is exposed.
+*
+* Instances are created via {@link getPaginationState} (or by the `<Paginate />`
+* component on your behalf), never constructed directly.
+*
+* @since 5.9.0
+* @public
+* @hideconstructor
+*/
+var PaginationState = class {
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/**
+	* The shared page graph and data this component reads from.
+	*
+	* @internal
+	*/
+	/**
+	* The page the paged surface is currently showing. Starts at the page this
+	* component first loaded and moves whenever {@link loadPage} runs (for
+	* example a numbered link is clicked).
+	*/
+	/**
+	* The page this component first loaded, used to seed the active page and frontier.
+	*
+	* @internal
+	*/
+	/**
+	* The first and last loaded pages of the contiguous run this component is
+	* viewing. Drives the infinite surface — {@link data} walks from
+	* `frontierStart` to `frontierEnd`, and {@link loadPrev}/{@link loadNext} extend
+	* them backward/forward. Both seed to {@link initialPage}; a purely paged
+	* consumer never extends them, so they stay put and are effectively unused.
+	*
+	* @internal
+	*/
+	/** @internal */
+	/**
+	* The request of the latest {@link adoptPage} call — only that call may
+	* commit. Later calls (or a {@link loadPage} navigation) claim the slot,
+	* superseding in-flight adoptions so the newest navigation always wins.
+	* Untracked bookkeeping.
+	*
+	* @internal
+	*/
+	constructor(request, pageHints) {
+		this.store = request.requester;
+		this.request = request;
+		this.pageHints = pageHints;
+		this._adoptTarget = null;
+		this.setup();
+	}
+	/**
+	* The request for the {@link activePage}, for the paged surface to render. This
+	* is what a single-page view wraps in a `<Request>` to show the active page's
+	* loading, error, and content states:
+	*
+	* ```gts
+	* <Paginate @request={{this.request}}>
+	*   <:content as |pages|>
+	*     <Request @request={{pages.activePageRequest}}>
+	*       <:content as |result|>
+	*         {{#each result.data as |item|}}...{{/each}}
+	*       </:content>
+	*     </Request>
+	*   </:content>
+	* </Paginate>
+	* ```
+	*/
+	get activePageRequest() {
+		return this.activePage?.request ?? null;
+	}
+	/**
+	* The total number of pages in the collection, or `0` when it is unknown (for
+	* example a cursor-based collection that reports no total).
+	*
+	* ```gts
+	* <p>Page {{pages.activePage.pageNumber}} of {{pages.totalPages}}</p>
+	* ```
+	*/
+	static {
+		decorateMethodV2(this.prototype, "activePageRequest", [memoized]);
+	}
+	get totalPages() {
+		return this.paginationCache?.totalPages ?? 0;
+	}
+	/**
+	* The pages of the run this component is viewing, from the backward frontier
+	* to the forward frontier inclusive, in order. Part of the infinite surface:
+	* it is the same run as {@link data}, yielding the {@link PageCache} objects
+	* instead of their flattened items — use it when the UI needs per-page
+	* boundaries or request states.
+	*
+	* Grows as {@link loadNext}/{@link loadPrev} extend the frontier. Scoped to
+	* this component's frontier (not the shared cache), so components paging the
+	* same collection to different extents each see only what they have scrolled
+	* through. For every page known to the whole collection, see
+	* {@link PaginationCache.pages}.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "totalPages", [memoized]);
+	}
+	get pages() {
+		const self = this;
+		return { *[Symbol.iterator]() {
+			const end = self.frontierEnd;
+			let page = self.frontierStart;
+			while (page) {
+				yield page;
+				if (page === end) break;
+				page = page.after;
+			}
+		} };
+	}
+	/**
+	* The accumulated items across the loaded run, from the backward frontier to
+	* the forward frontier inclusive — the single set an infinite collection renders.
+	* Grows as {@link loadNext}/{@link loadPrev} extend the frontier. Scoped to this
+	* component's frontier (not the shared cache), so components paging the same
+	* collection to different extents each see only what they have scrolled through.
+	*
+	* The flattened items of {@link pages}, as one contiguous iterable. For the
+	* items of every loaded page in the whole collection, see
+	* {@link PaginationCache.data}.
+	*
+	* ```gts
+	* <Paginate @request={{this.request}} @mode="infinite">
+	*   <:content as |pages features|>
+	*     {{#each pages.data as |item|}}...{{/each}}
+	*     {{#if pages.hasNext}}
+	*       <button {{on "click" features.loadNext}}>Load more</button>
+	*     {{/if}}
+	*   </:content>
+	* </Paginate>
+	* ```
+	*/
+	static {
+		decorateMethodV2(this.prototype, "pages", [memoized]);
+	}
+	get data() {
+		const self = this;
+		return { *[Symbol.iterator]() {
+			for (const page of self.pages) if (page.data) yield* page.data;
+		} };
+	}
+	/**
+	* Whether a page exists after the forward frontier — i.e. there is more to load
+	* going forward. Use to hide the trailing load-more sentinel at end-of-list:
+	*
+	* ```gts
+	* {{#if pages.hasNext}}
+	*   <button {{on "click" features.loadNext}}>Load more</button>
+	* {{/if}}
+	* ```
+	*/
+	static {
+		decorateMethodV2(this.prototype, "data", [memoized]);
+	}
+	get hasNext() {
+		return Boolean(this.frontierEnd?.nextLink);
+	}
+	/**
+	* Whether a page exists before the backward frontier.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "hasNext", [memoized]);
+	}
+	get hasPrevious() {
+		return Boolean(this.frontierStart?.prevLink);
+	}
+	/**
+	* The request for the page just after the forward frontier, for the infinite
+	* surface. `null` until {@link loadNext} fires it (so a `<Request>` wrapping it
+	* renders its idle block), the in-flight `Future` while that page loads, then
+	* `null` again once the frontier advances onto it. Also `null` at end-of-list.
+	*
+	* ```gts
+	* {{#if pages.hasNext}}
+	*   <Request @request={{pages.nextRequest}}>
+	*     <:idle><button {{on "click" features.loadNext}}>Load more</button></:idle>
+	*     <:loading><Spinner /></:loading>
+	*   </Request>
+	* {{/if}}
+	* ```
+	*/
+	static {
+		decorateMethodV2(this.prototype, "hasPrevious", [memoized]);
+	}
+	get nextRequest() {
+		const url = this.frontierEnd?.nextLink;
+		if (!url) return null;
+		return this.paginationCache?.getPageCache(url).request ?? null;
+	}
+	/**
+	* The request for the page just before the backward frontier. Mirror of
+	* {@link nextRequest} for {@link loadPrev}.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "nextRequest", [memoized]);
+	}
+	get previousRequest() {
+		const url = this.frontierStart?.prevLink;
+		if (!url) return null;
+		return this.paginationCache?.getPageCache(url).request ?? null;
+	}
+	/** @internal */
+	static {
+		decorateMethodV2(this.prototype, "previousRequest", [memoized]);
+	}
+	async setup() {
+		let document;
+		try {
+			document = await this.request;
+		} catch {
+			return;
+		}
+		const content = document.content;
+		const selfLink = getHref(content.links?.self);
+		const firstLink = getHref(content.links?.first);
+		((test) => {
+			if (!test) throw new Error("Expected the initial document to have a self link");
+		})(selfLink);
+		const cache = getPaginationCache(firstLink ?? selfLink ?? "");
+		cache.installPageHints(this.pageHints);
+		this.paginationCache = cache;
+		cache.totalPages = cache.getTotalPages(content);
+		this.activePage = this.initialPage = cache.loadPage(selfLink, this.request);
+		this.frontierStart = this.frontierEnd = this.initialPage;
+	}
+	/**
+	* Commits a resolved, membership-proven page into this state, making it the
+	* {@link activePage}. The synchronous commit step under {@link adoptPage},
+	* which is where the resolution and membership verification live.
+	*
+	* It only activates the page and keeps the infinite surface's frontier
+	* coherent — a page already inside the run leaves the frontier untouched,
+	* an adjacent page extends it, and a disjoint page resets the run to the
+	* adopted page (jump semantics).
+	*
+	* @internal
+	*/
+	_activate(page, url) {
+		this.activePage = page;
+		for (const existing of this.pages) if (existing === page) return;
+		if (this.frontierEnd?.nextLink === url) this.frontierEnd = page;
+		else if (this.frontierStart?.prevLink === url) this.frontierStart = page;
+		else this.frontierStart = this.frontierEnd = page;
+	}
+	/**
+	* Adopts an externally-issued request into this pagination, making its page
+	* the {@link activePage} — the programmatic entry point for route-driven
+	* navigation when managing a `PaginationState` directly (the `<Paginate />`
+	* component uses the same mechanism for a changed `@request` arg).
+	*
+	* Awaits the request and verifies that its document is a page of this
+	* state's collection (same `first` — or `self` — link). On a match, the
+	* page is loaded (a page already in the shared cache is reused) and — once
+	* its request settles — committed: it becomes the active page, and the
+	* infinite surface's run is kept coherent (a page already inside the run
+	* leaves it untouched, an adjacent page extends it, a disjoint page resets
+	* the run to the adopted page). The commit happens only after the page has
+	* loaded, so the previous page stays active — and rendered — while the
+	* adoption resolves. Returns the page's document.
+	*
+	* Concurrent calls race safely: the latest call wins. An earlier in-flight
+	* adoption is superseded and commits nothing, and a {@link loadPage}
+	* navigation also supersedes a pending adoption (the user's click is the
+	* newer intent).
+	*
+	* Returns `null` — leaving the state untouched — whenever the adoption does
+	* not commit:
+	*
+	* - the request (or its page's load) rejected
+	* - the document is a page of a *different* collection
+	* - this state has not finished setting up its own collection yet
+	* - the call was superseded by a newer navigation
+	*
+	* ```ts
+	* const pages = getPaginationState(initialRequest);
+	* // later, e.g. in a route model hook reacting to a ?page= param:
+	* const adopted = await pages.adoptPage(store.request(query));
+	* if (adopted === null) {
+	*   // not part of this collection — start a fresh pagination
+	* }
+	* ```
+	*
+	* It is a stable reference, so it is safe to pass around as an "action" or
+	* "event" handler.
+	*/
+	adoptPage = async (request) => {
+		this._adoptTarget = request;
+		let content;
+		try {
+			content = (await request).content;
+		} catch {
+			return null;
+		}
+		if (this._adoptTarget !== request) return null;
+		const cache = this.paginationCache;
+		if (!cache) return null;
+		const selfLink = getHref(content.links?.self);
+		const firstLink = getHref(content.links?.first);
+		((test) => {
+			if (!test) throw new Error("Expected the adopted document to have a self link");
+		})(selfLink);
+		if (!selfLink || (firstLink ?? selfLink) !== cache.key) return null;
+		const page = cache.loadPage(selfLink, request);
+		try {
+			await page.request;
+		} catch {
+			return null;
+		}
+		if (this._adoptTarget !== request) return null;
+		this._activate(page, selfLink);
+		return page.value;
+	};
+	/**
+	* Extends the backward frontier by one page, prepending it to {@link data}.
+	* The frontier advances only once the page has loaded, so
+	* {@link previousRequest} tracks the in-flight page meanwhile. Returns the
+	* loaded value, or `null` when there is no previous page or the load fails.
+	*
+	* On failure the frontier stays put and {@link previousRequest} keeps
+	* resolving to the failed page, so a wrapping `<Request>` renders its error
+	* block. Calling again retries: the failed page is re-requested with a
+	* forced reload.
+	*
+	* In templates it is also available as the `loadPrev` content feature
+	* ({@link InfinitePaginationContentFeatures.loadPrev}) yielded by
+	* `<Paginate />`; the two are the same function.
+	*
+	* It is a stable reference, so it is safe to pass around as an "action" or
+	* "event" handler.
+	*/
+	loadPrev = async () => {
+		return this._extend("prev");
+	};
+	/**
+	* Extends the forward frontier by one page, appending it to {@link data}.
+	* Mirror of {@link loadPrev}.
+	*
+	* In templates it is also available as the `loadNext` content feature
+	* ({@link InfinitePaginationContentFeatures.loadNext}) yielded by
+	* `<Paginate />`; the two are the same function.
+	*
+	* ```gts
+	* <button {{on "click" pages.loadNext}}>Load more</button>
+	* ```
+	*/
+	loadNext = async () => {
+		return this._extend("next");
+	};
+	/** @internal */
+	_extend = async (dir) => {
+		const cache = this.paginationCache;
+		((test) => {
+			if (!test) throw new Error("Expected the pagination cache to be set up before loading a page");
+		})(cache);
+		const frontier = dir === "next" ? this.frontierEnd : this.frontierStart;
+		const url = dir === "next" ? frontier?.nextLink : frontier?.prevLink;
+		if (!url) return null;
+		const page = cache.getPageCache(url);
+		if (!page.isRequested || page.isError) {
+			const request = this.store.request(page.isError ? {
+				method: "GET",
+				url,
+				cacheOptions: { reload: true }
+			} : {
+				method: "GET",
+				url
+			});
+			cache.loadPage(url, request);
+		}
+		try {
+			await page.request;
+		} catch {
+			return null;
+		}
+		if (dir === "next") this.frontierEnd = page;
+		else this.frontierStart = page;
+		return page.value;
+	};
+	/**
+	* Loads a specific page by its URL and makes it the {@link activePage},
+	* requesting it first if it is not already loaded. This is the paged surface's
+	* navigation entry point, called by the numbered and relational links.
+	*
+	* In templates it is also available as the `loadPage` content feature
+	* ({@link PagedPaginationContentFeatures.loadPage}) yielded by `<Paginate />`;
+	* the two are the same function.
+	*
+	* It is a stable reference, so it is safe to pass around as an "action" or
+	* "event" handler. Returns the page's value, or `null` if it has none or
+	* the load fails.
+	*
+	* On failure the page stays active and {@link activePageRequest} resolves to
+	* it, so a wrapping `<Request>` renders its error block. Calling again (for
+	* example clicking the page's link a second time) retries: the failed page
+	* is re-requested with a forced reload.
+	*
+	* ```gts
+	* <EachLink @pages={{pages}}>
+	*   <:link as |link|>
+	*     <button {{on "click" (fn features.loadPage link.url)}}>{{link.text}}</button>
+	*   </:link>
+	* </EachLink>
+	* ```
+	*/
+	loadPage = async (url) => {
+		const cache = this.paginationCache;
+		((test) => {
+			if (!test) throw new Error("Expected the pagination cache to be set up before loading a page");
+		})(cache);
+		this._adoptTarget = null;
+		const page = cache.getPageCache(url);
+		this.activePage = page;
+		if (!page.isLoaded || page.isError) {
+			const request = this.store.request(page.isError ? {
+				method: "GET",
+				url,
+				cacheOptions: { reload: true }
+			} : {
+				method: "GET",
+				url
+			});
+			cache.loadPage(url, request);
+			try {
+				await page.request;
+			} catch {
+				return null;
+			}
+		}
+		return page.value;
+	};
+};
+defineSignal(PaginationState.prototype, "paginationCache", null);
+defineSignal(PaginationState.prototype, "activePage", null);
+defineSignal(PaginationState.prototype, "initialPage", null);
+defineSignal(PaginationState.prototype, "frontierStart", null);
+defineSignal(PaginationState.prototype, "frontierEnd", null);
+const PaginationStateCache = /* @__PURE__ */ new WeakMap();
+/**
+* Get the {@link PaginationState} for a given request. Returns the same instance
+* for the same request future, so that repeated calls (e.g. in a template, or
+* alongside the `<Paginate />` component using the same request) share the same
+* local pagination state. Keyed by request identity, just like
+* {@link getRequestState}.
+*
+* ```ts
+* const future = store.request(query);
+* const pages = getPaginationState(future);
+*
+* await future;
+* pages.totalPages; // now known, if the response exposed it
+* await pages.loadNext();
+* ```
+*
+* @since 5.9.0
+* @public
+*/
+function getPaginationState(request, pageHints) {
+	let state = PaginationStateCache.get(request);
+	if (!state) {
+		state = new PaginationState(request, pageHints);
+		PaginationStateCache.set(request, state);
+	}
+	return state;
+}
+
+//#endregion
+//#region src/signals/pagination-links.ts
+const PaginationLinksCache = /* @__PURE__ */ new WeakMap();
+/**
+* A single numbered link, e.g. page `3`. Loads its page and makes it active when
+* {@link setActive} runs. Carries its {@link index} and its
+* {@link distanceFromActiveIndex} so a UI can style links by how far they sit
+* from the current page.
+*
+* ```gts
+* <EachLink @pages={{pages}} as |state|>
+*   {{#each state.links as |link|}}
+*     {{#if link.isReal}}
+*       <button class={{if link.isCurrent "active"}} {{on "click" link.setActive}}>
+*         {{link.text}}
+*       </button>
+*     {{/if}}
+*   {{/each}}
+* </EachLink>
+* ```
+*
+* @since 5.9.0
+* @public
+* @hideconstructor
+*/
+var RealPaginationLink = class {
+	isReal = true;
+	url;
+	index;
+	isCurrent;
+	distanceFromActiveIndex;
+	/** @internal */
+	constructor(url, index, activeIndex, loadPage) {
+		this.url = url;
+		this.index = index;
+		this.isCurrent = index === activeIndex;
+		this.distanceFromActiveIndex = Math.abs(index - activeIndex);
+		this._loadPage = loadPage;
+	}
+	get text() {
+		return `${this.index}`;
+	}
+	/**
+	* Loads this link's page and makes it the active page on the associated
+	* {@link PaginationState}. It is a stable reference, so it is safe to pass
+	* around as an "action" or "event" handler:
+	*
+	* ```gts
+	* <button {{on "click" link.setActive}}>{{link.text}}</button>
+	* ```
+	*/
+	setActive = () => {
+		return this._loadPage(this.url);
+	};
+};
+/**
+* A stand-in for a run of pages that have not been loaded yet, rendered as an
+* ellipsis between numbered links. It covers an {@link indexRange} rather than a
+* single page and has no page to navigate to.
+*
+* ```gts
+* <EachLink @pages={{pages}} as |state|>
+*   {{#each state.links as |link|}}
+*     {{#unless link.isReal}}
+*       <span title="{{link.rangeSize}} more pages">{{link.text}}</span>
+*     {{/unless}}
+*   {{/each}}
+* </EachLink>
+* ```
+*
+* @since 5.9.0
+* @public
+* @hideconstructor
+*/
+var PlaceholderPaginationLink = class {
+	isReal = false;
+	/**
+	* The inclusive `[start, end]` page-number range of not-yet-loaded pages this
+	* placeholder stands in for.
+	*/
+	indexRange;
+	/** @internal */
+	activeIndex;
+	text = ".";
+	constructor(index, activeIndex) {
+		this.indexRange = index;
+		this.activeIndex = activeIndex;
+	}
+	/** The number of pages this placeholder covers. */
+	get rangeSize() {
+		return this.indexRange[1] - this.indexRange[0] + 1;
+	}
+	/**
+	* The distance between the active page and the nearest edge of this
+	* placeholder's index range.
+	*/
+	get distanceFromActiveIndex() {
+		const [start, end] = this.indexRange;
+		return Math.min(Math.abs(start - this.activeIndex), Math.abs(end - this.activeIndex));
+	}
+	/** @internal */
+	_mergeRange(newRange) {
+		const [oldStart, oldEnd] = this.indexRange;
+		const [newStart, newEnd] = newRange;
+		const mergedRange = [Math.min(oldStart, newStart), Math.max(oldEnd, newEnd)];
+		this.indexRange = mergedRange;
+	}
+};
+/**
+* A relational (`first`/`prev`/`next`/`last`) navigation link, relative to the
+* active page. Unlike {@link RealPaginationLink} these carry no ordinal index —
+* they are the only links available for cursor-based pagination, where pages are
+* chained purely by opaque relational links with no page number or total. They
+* are also available in numbered pagination as a convenience.
+*
+* ```gts
+* <EachLink @pages={{pages}} as |state|>
+*   {{#if state.prev}}<button {{on "click" state.prev.setActive}}>Previous</button>{{/if}}
+*   {{#if state.next}}<button {{on "click" state.next.setActive}}>Next</button>{{/if}}
+* </EachLink>
+* ```
+*
+* @since 5.9.0
+* @public
+* @hideconstructor
+*/
+var RelationalPaginationLink = class {
+	isReal = true;
+	rel;
+	url;
+	/**
+	* Whether this link points at the page that is already active — for example
+	* the `first` link while the first page is being viewed. Useful for
+	* disabling the control.
+	*/
+	isCurrent;
+	/** @internal */
+	constructor(rel, url, isCurrent, loadPage) {
+		this.rel = rel;
+		this.url = url;
+		this.isCurrent = isCurrent;
+		this._loadPage = loadPage;
+	}
+	get text() {
+		return this.rel;
+	}
+	/**
+	* Loads this link's page and makes it the active page on the associated
+	* {@link PaginationState}. It is a stable reference, so it is safe to pass
+	* around as an "action" or "event" handler:
+	*
+	* ```gts
+	* <button {{on "click" link.setActive}}>{{link.text}}</button>
+	* ```
+	*/
+	setActive = () => {
+		return this._loadPage(this.url);
+	};
+};
+/**
+* A member of {@link PaginationLinks.links}: either a numbered
+* {@link RealPaginationLink} or a {@link PlaceholderPaginationLink} standing in
+* for a gap. Discriminate with {@link RealPaginationLink.isReal | isReal}:
+*
+* ```ts
+* for (const link of links.links) {
+*   if (link.isReal) {
+*     // numbered link: link.index, link.setActive
+*   } else {
+*     // gap: link.indexRange
+*   }
+* }
+* ```
+*/
+/**
+* The reactive set of navigation links derived from a {@link PaginationState}.
+* Where `PaginationState` tracks which pages are loaded and which one is active,
+* `PaginationLinks` turns that page graph into the links a UI renders to move
+* between pages.
+*
+* It provides two kinds of link:
+*
+* - {@link links}: the numbered links, with {@link PlaceholderPaginationLink}
+*   placeholders standing in for gaps of not-yet-loaded pages. Only numbered
+*   collections (where the server exposes page numbers) produce these.
+* - {@link prev} and {@link next}: the relational links for the active page.
+*   Available in both numbered and cursor-based pagination, and the only links a
+*   cursor-based collection has.
+* - {@link first} and {@link last}: the relational links to the collection's
+*   edges, when the response exposes them. Usually present on every page —
+*   including the edge page itself, where the link's
+*   {@link RelationalPaginationLink.isCurrent | isCurrent} is `true`.
+*
+* Every link updates as pages load and as the active page changes, since they
+* read straight from the state's shared page graph. To get the links for a
+* state, use {@link getPaginationLinks}.
+*
+* See also:
+* - {@link RealPaginationLink}
+* - {@link PlaceholderPaginationLink}
+* - {@link RelationalPaginationLink}
+*
+* @since 5.9.0
+* @public
+* @hideconstructor
+*/
+var PaginationLinks = class {
+	/** @internal */
+	constructor(paginationState) {
+		this.paginationState = paginationState;
+	}
+	/**
+	* The relational `first` link of the collection, or `null` when the active
+	* page's response did not expose one. Unlike {@link prev}/{@link next} it is
+	* usually present on every page — including the first page itself, where the
+	* link's {@link RelationalPaginationLink.isCurrent | isCurrent} is `true`
+	* (useful for disabling the control).
+	*/
+	get first() {
+		const activePage = this.paginationState.activePage;
+		const url = activePage?.firstLink;
+		return url ? new RelationalPaginationLink("first", url, url === activePage?.selfLink, this.paginationState.loadPage) : null;
+	}
+	/**
+	* The relational `prev` link for the active page, or `null` at the start of the
+	* collection. Available in both numbered and cursor pagination.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "first", [memoized]);
+	}
+	get prev() {
+		const activePage = this.paginationState.activePage;
+		const url = activePage?.prevLink;
+		return url ? new RelationalPaginationLink("prev", url, url === activePage?.selfLink, this.paginationState.loadPage) : null;
+	}
+	/**
+	* The relational `next` link for the active page, or `null` at the end of the
+	* collection. Available in both numbered and cursor pagination.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "prev", [memoized]);
+	}
+	get next() {
+		const activePage = this.paginationState.activePage;
+		const url = activePage?.nextLink;
+		return url ? new RelationalPaginationLink("next", url, url === activePage?.selfLink, this.paginationState.loadPage) : null;
+	}
+	/**
+	* The relational `last` link of the collection, or `null` when the active
+	* page's response did not expose one. Mirror of {@link first} for the end of
+	* the collection.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "next", [memoized]);
+	}
+	get last() {
+		const activePage = this.paginationState.activePage;
+		const url = activePage?.lastLink;
+		return url ? new RelationalPaginationLink("last", url, url === activePage?.selfLink, this.paginationState.loadPage) : null;
+	}
+	/**
+	* The numbered links and placeholders, derived from the shared page graph.
+	*
+	* Only produced for numbered pagination (where the server exposes page numbers).
+	* Cursor-based collections have no page numbers, so this is empty — use
+	* {@link prev}/{@link next} for cursor navigation.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "last", [memoized]);
+	}
+	get links() {
+		const links = [];
+		const cache = this.paginationState.paginationCache;
+		if (!cache || !cache.isNumbered) return links;
+		const { firstPage, totalPages } = cache;
+		const activeIndex = this.paginationState.activePage?.pageNumber ?? 0;
+		if (firstPage) {
+			let previousPage = null;
+			let currentPage = firstPage;
+			while (currentPage) {
+				if (previousPage && currentPage.pageNumber - previousPage.pageNumber > 1) links.push(new PlaceholderPaginationLink([previousPage.pageNumber + 1, currentPage.pageNumber - 1], activeIndex));
+				links.push(new RealPaginationLink(currentPage.selfLink ?? "", currentPage.pageNumber, activeIndex, this.paginationState.loadPage));
+				previousPage = currentPage;
+				currentPage = currentPage.after;
+			}
+			if (previousPage && previousPage.pageNumber < totalPages) links.push(new PlaceholderPaginationLink([previousPage.pageNumber + 1, totalPages], activeIndex));
+		}
+		return links;
+	}
+	static {
+		decorateMethodV2(this.prototype, "links", [memoized]);
+	}
+};
+/**
+* Get the {@link PaginationLinks} for a given {@link PaginationState}. Returns
+* the same instance for the same state, so repeated calls (for example a
+* `<Paginate />` component and a separate links component reading the same state)
+* share one set of links. Keyed by state identity, the same way
+* {@link getPaginationState} is keyed by request and {@link getRequestState} by
+* future.
+*
+* ```ts
+* const links = getPaginationLinks(paginationState);
+*
+* for (const link of links.links) {
+*   if (link.isReal) {
+*     // render a numbered link, using link.setActive as the click handler
+*   } else {
+*     // render an ellipsis for the gap link.indexRange covers
+*   }
+* }
+* ```
+*
+* @since 5.9.0
+* @public
+*/
+function getPaginationLinks(state) {
+	let links = PaginationLinksCache.get(state);
+	if (!links) {
+		links = new PaginationLinks(state);
+		PaginationLinksCache.set(state, links);
+	}
+	return links;
+}
+
+//#endregion
+//#region src/signals/pagination-subscription.ts
+/**
+* The content features available in both pagination modes: the state and
+* controls of the initial request.
+*/
+/**
+* The content features yielded in `'paged'` mode: navigation happens by
+* loading a specific page.
+*/
+/**
+* The content features yielded in `'infinite'` mode: navigation happens by
+* extending the loaded run at either end.
+*/
+/**
+* The full set of content features a {@link PaginationSubscription} builds —
+* both modes' surfaces. The `<Paginate />` component narrows this to one mode
+* via {@link PaginationContentFeaturesFor} before yielding.
+*/
+/**
+* Resolves a {@link PaginateMode} to the content features it exposes. Mirror of
+* {@link PaginationStateFor}.
+*/
+/**
+* Lifecycle glue for the `<Paginate />` component. Owns the initial
+* {@link RequestSubscription} (loading/error state, autorefresh, disposal) and
+* the per-component {@link PaginationState} that it hands to the component.
+*
+* @since 5.9.0
+* @public
+* @hideconstructor
+*/
+var PaginationSubscription = class {
+	/** @internal */
+	/** @internal */
+	/** @internal */
+	/**
+	* The Store this subscription subscribes to or the RequestManager
+	* which issues this request.
+	*/
+	/**
+	* The wrapped {@link RequestSubscription} monitoring the initial request.
+	* Created eagerly: constructing one consumes reactive state (its own
+	* signals), so building it lazily inside a tracked getter would cause the
+	* getter to invalidate — and the subscription to be recreated, losing its
+	* reloaded request — whenever `retry`/`reload` runs.
+	*
+	* @internal
+	*/
+	/**
+	* The first request this subscription saw — the one that keys the
+	* {@link PaginationState} until a navigation resolves to a different
+	* collection. Plain (untracked) because it is written during the first
+	* computation of {@link paginationState}.
+	*
+	* @internal
+	*/
+	/**
+	* The request a resolved navigation swapped the {@link PaginationState} to,
+	* when the navigation turned out to target a different collection. A signal:
+	* writing it (always outside of render, from {@link _resolveNavigation})
+	* invalidates {@link paginationState} so the fresh state takes over.
+	*
+	* @internal
+	*/
+	/**
+	* The changed request currently being resolved by {@link _resolveNavigation},
+	* both to avoid kicking the same navigation twice and as the latest-wins
+	* guard when several changes race. Untracked bookkeeping.
+	*
+	* @internal
+	*/
+	constructor(store, args) {
+		this._args = args;
+		this.store = store;
+		this.isDestroyed = false;
+		this._seedRequest = null;
+		this._navTarget = null;
+		this[DISPOSE] = _DISPOSE$1;
+		this._requestSubscription = createRequestSubscription(store, args);
+	}
+	/**
+	* The per-component pagination state yielded to the component.
+	*
+	* Keyed to the request that started the collection, not the current
+	* `@request` arg: when the arg changes, the existing state keeps rendering
+	* while {@link _resolveNavigation} resolves the new request in the
+	* background. A request that resolves to a page of the same collection is
+	* adopted into this state as the new active page (route-driven navigation,
+	* e.g. the browser back button); one that resolves to a different
+	* collection swaps in a fresh state (a true reset).
+	*
+	* A background `refresh` does not swap the request, so the pagination
+	* state is stable across refreshes.
+	*/
+	get paginationState() {
+		const request = this._requestSubscription.request;
+		const active = this._navRequest ?? this._seedRequest;
+		if (!active) {
+			this._seedRequest = request;
+			return getPaginationState(request, this._args.pageHints);
+		}
+		if (request !== active && request !== this._navTarget) {
+			this._navTarget = request;
+			this._resolveNavigation(request);
+		}
+		return getPaginationState(active, this._args.pageHints);
+	}
+	/**
+	* Resolves a changed `@request` arg against the current collection via
+	* {@link PaginationState.adoptPage}: a request that resolves to a page of
+	* the same collection is adopted into the existing state; one that resolves
+	* to a different collection (or arrives before a collection is loaded) swaps
+	* the state for a fresh one keyed to this request.
+	*
+	* A rejected request changes nothing here — the request subscription
+	* already surfaces the failure (error/cancelled states), and the existing
+	* pagination state is kept for recovery. The request is awaited before
+	* `adoptPage` so that rejection and the latest-wins guard are handled
+	* before anything is adopted.
+	*
+	* @internal
+	*/
+	static {
+		decorateMethodV2(this.prototype, "paginationState", [memoized]);
+	}
+	async _resolveNavigation(request) {
+		try {
+			await request;
+		} catch {
+			return;
+		}
+		if (this.isDestroyed || this._navTarget !== request) return;
+		const adopted = await this.paginationState.adoptPage(request);
+		if (this.isDestroyed || this._navTarget !== request) return;
+		if (adopted === null) this._navRequest = request;
+	}
+	/**
+	* Whether there is no request or query to monitor, so the component has
+	* nothing to load.
+	*/
+	get isIdle() {
+		return this._requestSubscription.isIdle;
+	}
+	/**
+	* Whether the collection is still blocking-loading: no {@link PaginationState}
+	* has finished setting up yet. Only the very first page load (or the reset
+	* to a different collection) blocks here — extending the collection with
+	* `loadNext`/`loadPrev` does not, and neither does a changed `@request` arg
+	* while a collection is already on screen (that is {@link isNavigating}).
+	*
+	* Remains `true` for the moment between the request resolving and the
+	* {@link paginationState} finishing its setup from the response, so that
+	* {@link isSuccess} consumers never see a success state with an empty
+	* pagination surface.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "isIdle", [memoized]);
+	}
+	get isLoading() {
+		const { reqState } = this._requestSubscription;
+		return this.paginationState.paginationCache === null && (reqState.isLoading || reqState.isSuccess);
+	}
+	/**
+	* Whether a changed `@request` arg is resolving while a collection is
+	* already on screen — route-driven navigation, e.g. the browser back
+	* button. The content stays rendered (see {@link isSuccess}); consumers can
+	* use this to show a lightweight navigation indicator, the same way a
+	* `loadPage` call surfaces through the active page's request state.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "isLoading", [memoized]);
+	}
+	get isNavigating() {
+		return this.paginationState.paginationCache !== null && this._requestSubscription.reqState.isLoading;
+	}
+	/**
+	* The {@link RequestLoadingState} for the initial request, for building UIs
+	* that respond to download progress.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "isNavigating", [memoized]);
+	}
+	get loadingState() {
+		return this._requestSubscription.reqState.loadingState;
+	}
+	/**
+	* Whether the component has a set-up {@link paginationState} to render and
+	* the current request did not fail. Stays `true` while a changed `@request`
+	* arg resolves ({@link isNavigating}), so the existing content keeps
+	* rendering instead of falling back to a blocking loading state.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "loadingState", [memoized]);
+	}
+	get isSuccess() {
+		const { reqState } = this._requestSubscription;
+		return this.paginationState.paginationCache !== null && !reqState.isError && !reqState.isCancelled;
+	}
+	/**
+	* Whether the initial request was cancelled (aborted).
+	*/
+	static {
+		decorateMethodV2(this.prototype, "isSuccess", [memoized]);
+	}
+	get isCancelled() {
+		return this._requestSubscription.reqState.isCancelled;
+	}
+	/**
+	* Whether the initial request rejected with an error.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "isCancelled", [memoized]);
+	}
+	get isError() {
+		return this._requestSubscription.reqState.isError;
+	}
+	/**
+	* The error the initial request rejected with, or `null` if it did not reject.
+	*/
+	static {
+		decorateMethodV2(this.prototype, "isError", [memoized]);
+	}
+	get reason() {
+		return this._requestSubscription.reqState.reason;
+	}
+	/**
+	* Error features to yield to the error slot of a component
+	*/
+	static {
+		decorateMethodV2(this.prototype, "reason", [memoized]);
+	}
+	get errorFeatures() {
+		return {
+			isHidden: this._requestSubscription.isHidden,
+			isOnline: this._requestSubscription.isOnline,
+			retry: this._requestSubscription.retry
+		};
+	}
+	/**
+	* Content features to yield to the content slot of a component
+	*/
+	static {
+		decorateMethodV2(this.prototype, "errorFeatures", [memoized]);
+	}
+	get contentFeatures() {
+		const contentFeatures = this._requestSubscription.contentFeatures;
+		const { paginationState } = this;
+		const feat = {
+			...contentFeatures,
+			isNavigating: this.isNavigating,
+			loadPrev: paginationState.loadPrev,
+			loadNext: paginationState.loadNext,
+			loadPage: paginationState.loadPage
+		};
+		if (feat.isRefreshing) feat.abort = () => {
+			contentFeatures.latestRequest?.abort();
+		};
+		return feat;
+	}
+	/**
+	* The initial request `Future` this subscription is monitoring, i.e. the first
+	* page load. This is the future the {@link paginationState} is built from.
+	*
+	* @internal
+	*/
+	static {
+		decorateMethodV2(this.prototype, "contentFeatures", [memoized]);
+	}
+	get request() {
+		return this._requestSubscription.request;
+	}
+	static {
+		decorateMethodV2(this.prototype, "request", [memoized]);
+	}
+};
+defineSignal(PaginationSubscription.prototype, "_navRequest", null);
+/**
+* Creates the {@link PaginationSubscription} a `<Paginate />` component uses to
+* manage its request lifecycle and pagination state. Pass the result back into
+* the component via `@subscription` to manage the lifecycle externally.
+*
+* ```ts
+* const subscription = createPaginationSubscription(store, { request });
+*
+* subscription.paginationState; // the per-component PaginationState
+* subscription[DISPOSE](); // tear down when the owning component unmounts
+* ```
+*
+* @since 5.9.0
+* @public
+*/
+function createPaginationSubscription(store, args) {
+	return new PaginationSubscription(store, args);
+}
+function upgradeSubscription$1(sub) {
+	return sub;
+}
+function _DISPOSE$1() {
+	const self = upgradeSubscription$1(this);
+	self.isDestroyed = true;
+	self._requestSubscription?.[DISPOSE]?.();
+}
+
+//#endregion
+//#region src/signals/pagination-links-subscription.ts
+/**
+* The framework-agnostic core of a pagination links component (for example the
+* `<EachLink />` component of `@warp-drive/ember`): it owns the component
+* lifecycle, while the links themselves live on the {@link PaginationLinks}
+* it exposes.
+*
+* Given the {@link PagedPaginationState} a `<Paginate />` component is driving,
+* {@link paginationLinks} derives that state's `PaginationLinks` — the numbered
+* links (with placeholders for gaps) and the relational
+* `first`/`prev`/`next`/`last` links a component yields for the consumer to
+* render. All of them read from the same shared page graph as the
+* `<Paginate />` component, so they stay in sync as pages load and the active
+* page changes.
+*
+* @since 5.9.0
+* @public
+* @hideconstructor
+*/
+var PaginationLinksSubscription = class {
+	/** @internal */
+	/** @internal */
+	constructor(args) {
+		this._args = args;
+		this.isDestroyed = false;
+		this[DISPOSE] = _DISPOSE;
+	}
+	/**
+	* The {@link PaginationLinks} derived from the {@link PagedPaginationState}
+	* passed as an arg — the surface a links component yields to its consumer:
+	* the numbered {@link PaginationLinks.links | links} (empty for cursor-based
+	* collections) and the relational {@link PaginationLinks.first | first}/
+	* {@link PaginationLinks.prev | prev}/{@link PaginationLinks.next | next}/
+	* {@link PaginationLinks.last | last} links.
+	*
+	* Recomputes when the `pages` arg changes, so a component whose pagination
+	* resets to a different collection derives fresh links automatically.
+	*/
+	get paginationLinks() {
+		return getPaginationLinks(this._args.pages);
+	}
+	static {
+		decorateMethodV2(this.prototype, "paginationLinks", [memoized]);
+	}
+};
+/**
+* Creates the {@link PaginationLinksSubscription} a links component (such as
+* `<EachLink />`) uses to derive its links from a {@link PagedPaginationState}.
+*
+* ```ts
+* const subscription = createPaginationLinksSubscription({ pages: paginationState });
+*
+* subscription.paginationLinks; // the derived PaginationLinks
+* subscription[DISPOSE](); // tear down when the owning component unmounts
+* ```
+*
+* @since 5.9.0
+* @public
+*/
+function createPaginationLinksSubscription(args) {
+	return new PaginationLinksSubscription(args);
+}
+function upgradeSubscription(sub) {
+	return sub;
+}
+function _DISPOSE() {
+	const self = upgradeSubscription(this);
+	self.isDestroyed = 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/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/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 A, createInternalMemo as C, notifyInternalSignal as D, makeInitializer as E, setupSignals as M, waitFor as N, peekInternalSignal as O, willSyncFlushWatchers as P, consumeInternalSignal as S, getOrCreateInternalSignal as T, entangleSignal as _, getPaginationState as a, signal as b, getPaginationCache as c, getRequestState as d, createSignalDescriptor as f, entangleInitiallyStaleSignal as g, defineSignal as h, getPaginationLinks as i, OBJECT_SIGNAL as j, withSignalStore as k, DISPOSE as l, defineNonEnumerableSignal as m, createPaginationLinksSubscription as n, clearPaginationCache as o, defineGate as p, createPaginationSubscription as r, defaultPageHints as s, getPromiseState as t, createRequestSubscription as u, gate as v, createInternalSignal as w, Signals as x, memoized as y };
+//# sourceMappingURL=-private-pNQae3qH.js.map