@askrjs/askr 0.0.85 → 0.0.87

package/dist/{deferred-vUOy-awa.js → resolution-BRmiFYvw.js}

@@ -1,23 +1,10 @@
-import { d as getCurrentAppRenderRuntime } from "./component-scope-DzJEbYGE.js";
 import { n as Fragment, t as ELEMENT_TYPE } from "./jsx-C3IECePB.js";
-import { g as readScope, u as defineScope } from "./component-internal-DcrLymUJ.js";
+import { g as readScope, u as defineScope } from "./component-internal-uVCJAre6.js";
 import { p as isPromiseLike } from "./lifecycle-batch-Dfpid9-A.js";
-import { n as getActiveRenderContext, r as getCurrentRenderData } from "./render-context-D-DFk2WN.js";
-import { A as getDefaultRouteBasePath, B as setDefaultRouteBasePath, F as insertRecordSorted, G as resource, M as getRouteRecords, R as restoreRouteState, V as snapshotRouteState, _ as clearRouteState, c as removeRouteBasePath, h as addRouteToStores, i as getMatchingRouteRecord, j as getRouteList, k as getDefaultRouteAuthOptions, l as buildRouteContext, o as addRouteBasePath, s as normalizeRouteBasePath, u as buildRouteContextBase, v as getActiveRouteAuthOptions, z as setDefaultRouteAuthOptions } from "./route-matching-DHduNiGk.js";
-import { i as ROUTE_ROOT_COMPONENT } from "./csp-nonce-Bc52OIVc.js";
-import { c as withTelemetry, t as createQueryPrefetchContext } from "./query-registry-BL6rjGsO.js";
-//#region src/runtime/execution-model.ts
-const EXECUTION_MODEL_KEY = Symbol.for("__ASKR_EXECUTION_MODEL__");
-function getExecutionModel() {
-	return globalThis[EXECUTION_MODEL_KEY];
-}
-function assertExecutionModel(model) {
-	const g = globalThis;
-	const cur = g[EXECUTION_MODEL_KEY];
-	if (cur && cur !== model) throw new Error(`[Askr] mixing execution models is not allowed (current: ${cur}, attempted: ${model}). Choose exactly one: createSPA, createSSR, or createIslands.`);
-	if (!cur) g[EXECUTION_MODEL_KEY] = model;
-}
-//#endregion
+import { b as withPageFramework, n as getActiveRenderContext, y as replacePageRoute } from "./render-context-D0Hoj9dW.js";
+import { i as ROUTE_ROOT_COMPONENT } from "./csp-nonce-CUscoNF1.js";
+import { c as withTelemetry, t as createQueryPrefetchContext } from "./query-registry-p_0kkieE.js";
+import { c as removeRouteBasePath, i as getMatchingRouteRecord, l as buildRouteContext, o as addRouteBasePath, s as normalizeRouteBasePath, u as buildRouteContextBase, v as getActiveRouteAuthOptions } from "./route-matching-DqULzZtC.js";
 //#region src/router/lazy.ts
 const pendingLazy = /* @__PURE__ */ new Set();
 const lazyStates = /* @__PURE__ */ new WeakMap();
@@ -140,57 +127,68 @@ function setCurrentAuth(context) {
 	if (render) render.authContext = context;
 }
 //#endregion
-//#region src/common/page-render-envelope.ts
-const PAGE_RENDER_ENVELOPE_VERSION = 1;
-function ownedRecord(value) {
-	return Object.freeze({ ...value });
-}
-function createPageRenderEnvelope(input = {}) {
-	return Object.freeze({
-		version: PAGE_RENDER_ENVELOPE_VERSION,
-		resources: ownedRecord(input.resources),
-		route: input.route,
-		framework: ownedRecord(input.framework)
-	});
-}
-function isPageRenderEnvelope(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-	const candidate = value;
-	return candidate.version === PAGE_RENDER_ENVELOPE_VERSION && Boolean(candidate.resources && typeof candidate.resources === "object" && !Array.isArray(candidate.resources)) && Boolean(candidate.framework && typeof candidate.framework === "object" && !Array.isArray(candidate.framework));
-}
-function pageRenderEnvelope(value, fallback = {}) {
-	if (isPageRenderEnvelope(value)) return value;
-	return createPageRenderEnvelope({
-		...fallback,
-		route: value ?? fallback.route
-	});
-}
-function replacePageRoute(value, route) {
-	const current = pageRenderEnvelope(value);
-	return createPageRenderEnvelope({
-		resources: current.resources,
-		route,
-		framework: current.framework
+//#region src/common/deferred-value.ts
+const DEFERRED_VALUE = Symbol.for("@askrjs/askr/deferred-value");
+const DEFERRED_BOUNDARY = Symbol.for("@askrjs/askr/deferred-boundary");
+function defer(promise) {
+	let state = "pending";
+	let value;
+	let error;
+	const normalized = Promise.resolve(promise);
+	normalized.then((resolved) => {
+		state = "fulfilled";
+		value = resolved;
+	}, (reason) => {
+		state = "rejected";
+		error = reason;
 	});
+	return Object.freeze(Object.defineProperties({}, {
+		state: {
+			enumerable: true,
+			get: () => state
+		},
+		value: {
+			enumerable: true,
+			get: () => value
+		},
+		error: {
+			enumerable: true,
+			get: () => error
+		},
+		promise: { value: normalized },
+		[DEFERRED_VALUE]: { value: true }
+	}));
 }
-function withPageFramework(value, framework) {
-	const current = pageRenderEnvelope(value);
-	return createPageRenderEnvelope({
-		resources: current.resources,
-		route: current.route,
-		framework
-	});
+function isDeferred(value) {
+	if (!value || typeof value !== "object") return false;
+	const marker = Object.getOwnPropertyDescriptor(value, DEFERRED_VALUE);
+	return Boolean(marker && "value" in marker && marker.value === true);
 }
-function isEmptyPageRenderEnvelope(value) {
-	return value.route === void 0 && Object.keys(value.resources).length === 0 && Object.keys(value.framework).length === 0;
+/** @internal Reconstruct settled server data without importing deferred rendering. */
+function reviveDeferredValue(state, value, error) {
+	const promise = state === "fulfilled" ? Promise.resolve(value) : Promise.reject(error);
+	if (state === "rejected") promise.catch(() => void 0);
+	return Object.freeze(Object.defineProperties({}, {
+		state: {
+			enumerable: true,
+			value: state
+		},
+		value: {
+			enumerable: true,
+			value
+		},
+		error: {
+			enumerable: true,
+			value: error
+		},
+		promise: { value: promise },
+		[DEFERRED_VALUE]: { value: true }
+	}));
 }
 //#endregion
 //#region src/router/route-hydration.ts
-const DEFERRED_VALUE$1 = Symbol.for("@askrjs/askr/deferred-value");
 function isDeferredHydrationValue(value) {
-	if (!value || typeof value !== "object") return false;
-	const marker = Object.getOwnPropertyDescriptor(value, DEFERRED_VALUE$1);
-	return Boolean(marker && "value" in marker && marker.value === true);
+	return isDeferred(value);
 }
 const omissionGuards = /* @__PURE__ */ new WeakMap();
 function propertyPath(parent, key) {
@@ -513,172 +511,4 @@ function resolveRouteRequest(target, options) {
 	});
 }
 //#endregion
-//#region src/router/manifest.ts
-function createRouteManifest() {
-	const auth = getDefaultRouteAuthOptions();
-	return {
-		records: [...getRouteRecords()],
-		...auth ? { auth } : {},
-		...getDefaultRouteBasePath() ? { basePath: getDefaultRouteBasePath() } : {}
-	};
-}
-function _applyManifest(manifest) {
-	setDefaultRouteAuthOptions(manifest.auth);
-	setDefaultRouteBasePath(normalizeRouteBasePath(manifest.basePath));
-	for (const record of manifest.records) {
-		insertRecordSorted(record);
-		addRouteToStores({
-			path: record.path,
-			handler: record.handler,
-			namespace: record.options.namespace,
-			..."fallbackPrefix" in record && typeof record.fallbackPrefix === "string" ? { fallbackPrefix: record.fallbackPrefix } : {}
-		});
-	}
-}
-function createRouteRegistry(definition, options = {}) {
-	const previous = snapshotRouteState();
-	clearRouteState();
-	try {
-		setDefaultRouteAuthOptions(options.auth);
-		setDefaultRouteBasePath(normalizeRouteBasePath(options.basePath));
-		definition();
-		const manifest = createRouteManifest();
-		return Object.freeze({
-			manifest,
-			routes: getRouteList()
-		});
-	} finally {
-		restoreRouteState(previous);
-	}
-}
-//#endregion
-//#region src/router/deferred.tsx
-const DEFERRED_VALUE = Symbol.for("@askrjs/askr/deferred-value");
-const DEFERRED_BOUNDARY = Symbol.for("@askrjs/askr/deferred-boundary");
-function defer(promise) {
-	let state = "pending";
-	let value;
-	let error;
-	const normalized = Promise.resolve(promise);
-	normalized.then((resolved) => {
-		state = "fulfilled";
-		value = resolved;
-	}, (reason) => {
-		state = "rejected";
-		error = reason;
-	});
-	return Object.freeze(Object.defineProperties({}, {
-		state: {
-			enumerable: true,
-			get: () => state
-		},
-		value: {
-			enumerable: true,
-			get: () => value
-		},
-		error: {
-			enumerable: true,
-			get: () => error
-		},
-		promise: { value: normalized },
-		[DEFERRED_VALUE]: { value: true }
-	}));
-}
-function isDeferred(value) {
-	return Boolean(value && typeof value === "object" && value[DEFERRED_VALUE] === true);
-}
-/** @internal Reconstruct settled server data without starting loader work. */
-function reviveDeferredValue(state, value, error) {
-	const promise = state === "fulfilled" ? Promise.resolve(value) : Promise.reject(error);
-	if (state === "rejected") promise.catch(() => void 0);
-	return Object.freeze(Object.defineProperties({}, {
-		state: {
-			enumerable: true,
-			value: state
-		},
-		value: {
-			enumerable: true,
-			value
-		},
-		error: {
-			enumerable: true,
-			value: error
-		},
-		promise: { value: promise },
-		[DEFERRED_VALUE]: { value: true }
-	}));
-}
-function abortError() {
-	const error = /* @__PURE__ */ new Error("Deferred route data was aborted.");
-	error.name = "AbortError";
-	return error;
-}
-function awaitWithSignal(promise, signal) {
-	if (!signal) return promise;
-	if (signal.aborted) return Promise.reject(abortError());
-	return new Promise((resolve, reject) => {
-		const abort = () => reject(abortError());
-		signal.addEventListener("abort", abort, { once: true });
-		promise.then((value) => {
-			signal.removeEventListener("abort", abort);
-			resolve(value);
-		}, (error) => {
-			signal.removeEventListener("abort", abort);
-			reject(error);
-		});
-	});
-}
-async function resolveDeferredValues(input, signal) {
-	const seen = /* @__PURE__ */ new Set();
-	const visit = async (value) => {
-		if (!value || typeof value !== "object") return;
-		if (isDeferred(value)) {
-			const resolved = await awaitWithSignal(value.promise, signal);
-			await visit(resolved);
-			return;
-		}
-		if (seen.has(value)) return;
-		seen.add(value);
-		const children = Array.isArray(value) ? value : Object.values(value);
-		await Promise.all(children.map(visit));
-	};
-	await visit(input);
-	return input;
-}
-function routeData() {
-	const envelope = getCurrentRenderData();
-	if (envelope) return guardHydratedRouteData(envelope.route, envelope.framework);
-	const runtime = getCurrentAppRenderRuntime();
-	if (!runtime?.hasRoute) throw new Error("routeData() can only be read while rendering a route with loader data.");
-	return guardHydratedRouteData(runtime.route, runtime.framework);
-}
-function rejectedChild(props, error) {
-	return typeof props.rejected === "function" ? props.rejected(error) : props.rejected ?? null;
-}
-function Resolve(props) {
-	if (props.value.state === "fulfilled") return props.children(props.value.value);
-	if (props.value.state === "rejected") return rejectedChild(props, props.value.error);
-	const renderContext = getActiveRenderContext();
-	if (renderContext) {
-		const id = `d:${renderContext.deferredBoundaries.length}`;
-		renderContext.deferredBoundaries.push({
-			id,
-			promise: props.value.promise,
-			fulfilled: (value) => props.children(value),
-			rejected: (error) => rejectedChild(props, error)
-		});
-		return {
-			type: DEFERRED_BOUNDARY,
-			props: {
-				id,
-				pending: props.pending ?? null
-			}
-		};
-	}
-	const result = resource(() => props.value.promise, [props.value]);
-	if (result.error) return rejectedChild(props, result.error);
-	if (result.pending || result.value === null) return props.pending ?? null;
-	return props.children(result.value);
-}
-//#endregion
-export { getExecutionModel as A, currentAuth as C, _preloadRouteHandler as D, getRenderHandler as E, lazy as O, pageRenderEnvelope as S, createRouteHandler as T, validateRouteHydrationData as _, resolveDeferredValues as a, isEmptyPageRenderEnvelope as b, _applyManifest as c, getRouteRenderContext as d, getRouteRenderData as f, prepareRouteHydrationData as g, getRouteHydrationMetadata as h, isDeferred as i, assertExecutionModel as k, createRouteRegistry as l, resolveRouteRequest as m, Resolve as n, reviveDeferredValue as o, hasRouteRenderData as p, defer as r, routeData as s, DEFERRED_BOUNDARY as t, bindResolvedRouteData as u, withoutRouteHydrationMetadata as v, Outlet as w, isPageRenderEnvelope as x, createPageRenderEnvelope as y };
+export { createRouteHandler as _, resolveRouteRequest as a, lazy as b, prepareRouteHydrationData as c, DEFERRED_BOUNDARY as d, defer as f, Outlet as g, currentAuth as h, hasRouteRenderData as i, validateRouteHydrationData as l, reviveDeferredValue as m, getRouteRenderContext as n, getRouteHydrationMetadata as o, isDeferred as p, getRouteRenderData as r, guardHydratedRouteData as s, bindResolvedRouteData as t, withoutRouteHydrationMetadata as u, getRenderHandler as v, _preloadRouteHandler as y };

package/dist/resource-operation-B94oj6xT.js

@@ -0,0 +1,304 @@
+import { t as enqueueRuntimeLane, v as logger } from "./access-Dpfoi4cA.js";
+import { f as getCurrentComponentInstance } from "./component-scope-DzJEbYGE.js";
+import { c as registerCommitOperationForInstance, d as getCurrentContextFrame, v as withAsyncResourceContext } from "./component-internal-uVCJAre6.js";
+import { p as isPromiseLike } from "./lifecycle-batch-Dfpid9-A.js";
+import { t as brandSnapshotSource } from "./snapshot-source-BB42xgwb.js";
+import { a as getResourceVerificationSnapshot, i as getNextRenderKey, n as getActiveRenderContext, o as isHydrationVerificationRender, p as throwSSRDataMissing, r as getCurrentRenderData, s as recordResourceVerificationSnapshot, x as SSRDataMissingError } from "./render-context-D0Hoj9dW.js";
+import { t as state } from "./state-DCjONcHK.js";
+//#region src/runtime/resource-cell.ts
+/**
+* Pure, component-agnostic ResourceCell state machine.
+* - Holds value/pending/error/generation/controller
+* - Exposes a stable `snapshot` object: { value, pending, error, refresh }
+* - Uses `withAsyncResourceContext` to bind the synchronous execution step
+*   to a captured frame. Continuations after await do not see the frame.
+*/
+var ResourceCell = class {
+	constructor(fn, deps, resourceFrame) {
+		this.value = null;
+		this.pending = true;
+		this.error = null;
+		this.generation = 0;
+		this.controller = null;
+		this.deps = null;
+		this.resourceFrame = null;
+		this.subscribers = /* @__PURE__ */ new Set();
+		this.disposed = false;
+		this.fn = fn;
+		this.deps = deps ? deps.slice() : null;
+		this.resourceFrame = resourceFrame;
+		this.snapshot = brandSnapshotSource({
+			value: null,
+			pending: true,
+			error: null,
+			refresh: () => this.refresh()
+		});
+	}
+	setLoader(fn) {
+		this.fn = fn;
+	}
+	subscribe(cb) {
+		this.subscribers.add(cb);
+		return () => this.subscribers.delete(cb);
+	}
+	notifySubscribers() {
+		this.snapshot.value = this.value;
+		this.snapshot.pending = this.pending;
+		this.snapshot.error = this.error;
+		for (const cb of this.subscribers) cb();
+	}
+	start(ssr = false, notify = true) {
+		if (this.disposed) return;
+		const generation = this.generation;
+		this.controller?.abort();
+		const controller = new AbortController();
+		this.controller = controller;
+		this.pending = true;
+		this.error = null;
+		if (notify) this.notifySubscribers();
+		let result;
+		try {
+			result = withAsyncResourceContext(this.resourceFrame, () => this.fn({ signal: controller.signal }));
+		} catch (err) {
+			this.pending = false;
+			this.error = err instanceof Error ? err : new Error(String(err));
+			if (notify) this.notifySubscribers();
+			return;
+		}
+		if (!isPromiseLike(result)) {
+			this.value = result;
+			this.pending = false;
+			this.error = null;
+			if (notify) this.notifySubscribers();
+			return;
+		}
+		if (ssr) throwSSRDataMissing();
+		Promise.resolve(result).then((val) => {
+			if (this.generation !== generation) return;
+			if (this.controller !== controller) return;
+			if (controller.signal.aborted) return;
+			this.value = val;
+			this.pending = false;
+			this.error = null;
+			this.notifySubscribers();
+		}).catch((err) => {
+			if (this.generation !== generation) return;
+			if (this.controller !== controller) return;
+			if (controller.signal.aborted || err instanceof Error && err.name === "AbortError" || typeof DOMException !== "undefined" && err instanceof DOMException && err.name === "AbortError") return;
+			this.pending = false;
+			this.error = err instanceof Error ? err : new Error(String(err));
+			try {
+				if (this.ownerName) logger.error(`[Askr] Async resource error in ${this.ownerName}:`, err);
+				else logger.error("[Askr] Async resource error:", err);
+			} catch {}
+			this.notifySubscribers();
+		});
+	}
+	refresh() {
+		if (this.disposed) return;
+		this.generation++;
+		this.controller?.abort();
+		this.start();
+	}
+	abort() {
+		this.controller?.abort();
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.controller?.abort();
+		this.subscribers.clear();
+	}
+};
+//#endregion
+//#region src/runtime/resource-operation.ts
+function hydrationVerificationSnapshot() {
+	return brandSnapshotSource({
+		value: null,
+		pending: true,
+		error: null,
+		refresh: () => {}
+	});
+}
+/**
+* Resource primitive — simple, deterministic async primitive
+* Usage: resource(fn, deps)
+* - fn receives { signal }
+* - captures execution context once at creation (synchronous step only)
+* - executes at most once per generation; stale async results are ignored
+* - refresh() cancels in-flight execution, increments generation and re-runs
+* - exposes { value, pending, error, refresh }
+* - during SSR, async results are disallowed and will throw synchronously
+*/
+function resource(fn, deps = []) {
+	const instance = getCurrentComponentInstance();
+	const inst = instance;
+	if (!instance) {
+		const renderData = getCurrentRenderData()?.resources;
+		if (renderData && (getActiveRenderContext()?.resourceDataProvided || Object.keys(renderData).some((key) => key.startsWith("r:")))) {
+			const key = getNextRenderKey();
+			if (!(key in renderData)) throwSSRDataMissing();
+			const val = renderData[key];
+			return brandSnapshotSource({
+				value: val,
+				pending: false,
+				error: null,
+				refresh: () => {}
+			});
+		}
+		if (getActiveRenderContext()) throwSSRDataMissing();
+		throw new Error("[Askr] resource() must be called during component render inside an app. Do not create resources at module scope or outside render.");
+	}
+	const renderData = getCurrentRenderData()?.resources;
+	const hasPreloadedResourceData = Boolean(renderData && (getActiveRenderContext()?.resourceDataProvided || Object.keys(renderData).some((key) => key.startsWith("r:"))));
+	const renderKey = inst.ssr || hasPreloadedResourceData ? getNextRenderKey() : null;
+	const verificationSnapshot = renderKey ? getResourceVerificationSnapshot(renderKey) : null;
+	if (renderData && hasPreloadedResourceData && renderKey && renderKey in renderData) {
+		const val = renderData[renderKey];
+		const h = state({
+			cell: void 0,
+			snapshot: brandSnapshotSource({
+				value: val,
+				pending: false,
+				error: null,
+				refresh: () => {}
+			})
+		})();
+		h.snapshot.value = val;
+		h.snapshot.pending = false;
+		h.snapshot.error = null;
+		return h.snapshot;
+	}
+	if (isHydrationVerificationRender() && verificationSnapshot) {
+		const result = hydrationVerificationSnapshot();
+		result.value = verificationSnapshot.value;
+		result.pending = verificationSnapshot.pending;
+		return result;
+	}
+	if (renderData && hasPreloadedResourceData && renderKey && (inst.ssr || !verificationSnapshot)) throwSSRDataMissing();
+	const ssrRenderKey = inst.ssr ? renderKey : null;
+	const clientHydrationSnapshot = inst.ssr ? null : verificationSnapshot;
+	const holder = state({
+		cell: void 0,
+		snapshot: brandSnapshotSource({
+			value: clientHydrationSnapshot ? clientHydrationSnapshot.value : null,
+			pending: clientHydrationSnapshot?.pending ?? true,
+			error: null,
+			refresh: () => {}
+		})
+	});
+	const h = holder();
+	if (!h.cell) {
+		const cell = new ResourceCell(fn, deps, getCurrentContextFrame());
+		if (clientHydrationSnapshot) {
+			cell.value = clientHydrationSnapshot.value;
+			cell.pending = clientHydrationSnapshot.pending;
+			cell.snapshot.value = clientHydrationSnapshot.value;
+			cell.snapshot.pending = clientHydrationSnapshot.pending;
+		}
+		cell.ownerName = inst.fn?.name || "<anonymous>";
+		h.cell = cell;
+		h.snapshot = cell.snapshot;
+		const unsubscribe = cell.subscribe(() => {
+			const cur = holder();
+			cur.snapshot.value = cell.snapshot.value;
+			cur.snapshot.pending = cell.snapshot.pending;
+			cur.snapshot.error = cell.snapshot.error;
+			holder.set(cur);
+			try {
+				inst.notifyUpdate?.();
+			} catch {}
+		});
+		(inst.cleanupFns ??= []).push(() => {
+			unsubscribe();
+			cell.dispose();
+		});
+		if (inst.ssr) {
+			cell.start(true, false);
+			if (!cell.pending) {
+				const cur = holder();
+				cur.snapshot.value = cell.value;
+				cur.snapshot.pending = cell.pending;
+				cur.snapshot.error = cell.error;
+			}
+			if (ssrRenderKey && cell.value === null && cell.error === null) recordResourceVerificationSnapshot(ssrRenderKey, {
+				value: null,
+				pending: cell.pending
+			});
+		} else {
+			const scheduledGeneration = cell.generation;
+			registerCommitOperationForInstance(inst, () => {
+				enqueueRuntimeLane("post", () => {
+					if (!inst.notifyUpdate || cell.generation !== scheduledGeneration) return;
+					try {
+						cell.start(false, false);
+					} catch (err) {
+						const cur = holder();
+						cur.snapshot.value = cell.value;
+						cur.snapshot.pending = cell.pending;
+						cur.snapshot.error = err ?? null;
+						holder.set(cur);
+						inst.notifyUpdate?.();
+						return;
+					}
+					if (!cell.pending) {
+						const cur = holder();
+						cur.snapshot.value = cell.value;
+						cur.snapshot.pending = cell.pending;
+						cur.snapshot.error = cell.error;
+						holder.set(cur);
+						inst.notifyUpdate?.();
+					}
+				});
+			});
+		}
+	}
+	const cell = h.cell;
+	cell.setLoader(fn);
+	if (!cell.deps || cell.deps.length !== deps.length || cell.deps.some((d, i) => !Object.is(d, deps[i]))) {
+		cell.deps = deps.slice();
+		cell.generation++;
+		cell.pending = true;
+		cell.error = null;
+		h.snapshot.pending = true;
+		h.snapshot.error = null;
+		try {
+			if (inst.ssr) {
+				cell.start(true, false);
+				if (!cell.pending) {
+					const cur = holder();
+					cur.snapshot.value = cell.value;
+					cur.snapshot.pending = cell.pending;
+					cur.snapshot.error = cell.error;
+				}
+			} else {
+				const scheduledGeneration = cell.generation;
+				registerCommitOperationForInstance(inst, () => {
+					enqueueRuntimeLane("post", () => {
+						if (!inst.notifyUpdate || cell.generation !== scheduledGeneration) return;
+						cell.start(false, false);
+						if (!cell.pending) {
+							const cur = holder();
+							cur.snapshot.value = cell.value;
+							cur.snapshot.pending = cell.pending;
+							cur.snapshot.error = cell.error;
+							holder.set(cur);
+							inst.notifyUpdate?.();
+						}
+					});
+				});
+			}
+		} catch (err) {
+			if (err instanceof SSRDataMissingError) throw err;
+			cell.error = err;
+			cell.pending = false;
+			const cur = holder();
+			cur.snapshot.value = cell.value;
+			cur.snapshot.pending = cell.pending;
+			cur.snapshot.error = cell.error;
+		}
+	}
+	return h.snapshot;
+}
+//#endregion
+export { resource as t };

package/dist/resources/index.d.ts

@@ -1,5 +1,5 @@
-import { ut as getSignal } from "../index-pIgGaXvS.js";
-import { i as onRouteChange, n as RouteChangeOptions, t as RouteChangeCleanup } from "../activity-B1I5HJQI.js";
+import { ut as getSignal } from "../index-BvNkcegT.js";
+import { i as onRouteChange, n as RouteChangeOptions, t as RouteChangeCleanup } from "../activity-DNYL__cW.js";
 //#region src/runtime/resource-operation.d.ts
 interface ResourceResult<T> {
   value: T | null;

package/dist/resources/index.js

@@ -1,9 +1,9 @@
 import { t as enqueueRuntimeLane } from "../access-Dpfoi4cA.js";
 import { f as getCurrentComponentInstance, g as getSignal, i as claimHookIndex } from "../component-scope-DzJEbYGE.js";
-import { a as registerCommitOperation } from "../component-internal-DcrLymUJ.js";
-import { G as resource } from "../route-matching-DHduNiGk.js";
-import { a as task, i as routeActive, n as documentVisible, o as timer, r as on, s as windowFocused, t as capture } from "../lifecycle-operations-BrYrBsXY.js";
-import { n as onRouteChange } from "../activity-Jd9CgEa3.js";
+import { a as registerCommitOperation } from "../component-internal-uVCJAre6.js";
+import { t as resource } from "../resource-operation-B94oj6xT.js";
+import { a as task, i as routeActive, n as documentVisible, o as timer, r as on, s as windowFocused, t as capture } from "../lifecycle-operations-DTO93Hrl.js";
+import { n as onRouteChange } from "../activity-BnkhdIXm.js";
 //#region src/runtime/stream-operation.ts
 function toError(value) {
 	return value instanceof Error ? value : new Error(String(value));