@askrjs/askr 0.0.51 → 0.0.53

package/dist/deferred-lKE8uR0z.js

@@ -0,0 +1,386 @@
+import { n as Fragment, t as ELEMENT_TYPE } from "./jsx-CUpRxrLH.js";
+import { h as readScope, u as defineScope } from "./component-internal-B3z7GXlD.js";
+import { d as getCurrentAppRenderRuntime } from "./component-scope-CC3cojX9.js";
+import { m as isPromiseLike } from "./component-lifecycle-CO4hXlP4.js";
+import { n as getActiveRenderContext, r as getCurrentRenderData } from "./render-context-Clw3rFiO.js";
+import { t as resource } from "./resource-operation-CEzfpnDk.js";
+import { t as ROUTE_ROOT_COMPONENT } from "./router-internal-BC0w1_xk.js";
+import { c as withTelemetry, t as createQueryPrefetchContext } from "./query-registry-CQIT4mXr.js";
+import { E as getRouteRecords, h as getActiveRouteAuthOptions, i as getMatchingRouteRecord, o as buildRouteContext, s as buildRouteContextBase } from "./route-matching-vJpvLVbX.js";
+//#region src/router/rendering.ts
+const outletScope = defineScope(null);
+function Outlet() {
+	return {
+		$$typeof: ELEMENT_TYPE,
+		type: Fragment,
+		props: { children: readScope(outletScope) },
+		key: null
+	};
+}
+function applyPageChain(pageChain, params, content, deferComponents = false) {
+	let nextContent = content;
+	for (let i = pageChain.length - 1; i >= 0; i--) nextContent = outletScope({
+		value: nextContent,
+		children: deferComponents ? createRouteComponentVNode(pageChain[i].component, params) : pageChain[i].component(params)
+	});
+	return nextContent;
+}
+function createRouteComponentVNode(component, params, routeRoot = false) {
+	return {
+		$$typeof: ELEMENT_TYPE,
+		type: component,
+		props: params,
+		key: null,
+		...routeRoot ? { [ROUTE_ROOT_COMPONENT]: true } : {}
+	};
+}
+function createRouteHandler(component, pageChain, layoutChain, deferComponents = false) {
+	return (params) => {
+		let content = deferComponents ? createRouteComponentVNode(component, params, true) : component(params);
+		content = applyPageChain(pageChain, params, content, deferComponents);
+		for (let i = layoutChain.length - 1; i >= 0; i--) {
+			const layout = layoutChain[i].component;
+			content = layout({ children: content });
+		}
+		return content;
+	};
+}
+function getRenderHandler(record) {
+	return record.renderHandler ?? createRouteHandler(record.component, record.pageChain, record.layoutChain, true);
+}
+//#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
+	});
+}
+function isEmptyPageRenderEnvelope(value) {
+	return value.route === void 0 && Object.keys(value.resources).length === 0 && Object.keys(value.framework).length === 0;
+}
+//#endregion
+//#region src/router/auth.ts
+let clientAuth = Object.freeze({
+	authenticated: false,
+	principal: null,
+	session: null,
+	tenant: null
+});
+/** Return the identity resolved for the route currently being rendered. */
+function currentAuth() {
+	return getActiveRenderContext()?.authContext ?? clientAuth;
+}
+/** @internal Updated atomically with route resolution. */
+function setCurrentAuth(context) {
+	clientAuth = context;
+	const render = getActiveRenderContext();
+	if (render) render.authContext = context;
+}
+//#endregion
+//#region src/router/resolution.ts
+const anonymous = () => ({
+	authenticated: false,
+	principal: null,
+	session: null,
+	tenant: null
+});
+const routeRenderContexts = /* @__PURE__ */ new WeakMap();
+const routeRenderData = /* @__PURE__ */ new WeakMap();
+function getRouteRenderContext(result) {
+	return routeRenderContexts.get(result);
+}
+function getRouteRenderData(result) {
+	return routeRenderData.get(result);
+}
+function createRouteRenderResult(record, params, context, handler) {
+	const result = {
+		kind: "render",
+		handler,
+		params
+	};
+	Object.defineProperty(result, "record", {
+		value: record,
+		enumerable: false
+	});
+	routeRenderContexts.set(result, context);
+	return result;
+}
+function getDefaultRouteMode() {
+	return typeof window !== "undefined" ? "spa" : "ssr";
+}
+/** @internal Bind resolved loader output to one route subtree and its hydration envelope. */
+function bindResolvedRouteData(handler, data) {
+	return (params, context) => {
+		const renderContext = getActiveRenderContext();
+		if (renderContext) {
+			const envelope = replacePageRoute(renderContext.renderData, data);
+			renderContext.renderData = envelope;
+			renderContext.hydrationData = envelope;
+		}
+		return handler(params, context);
+	};
+}
+function hasRouteRenderData(result) {
+	return routeRenderData.has(result);
+}
+function buildRenderResult(record, params, context, request, telemetry, load) {
+	const renderHandler = getRenderHandler(record);
+	const loader = context.mode !== "ssg" && load ? record.options?.loader : void 0;
+	const preload = record.options?.preload;
+	const active = getActiveRenderContext();
+	const prefetch = active?.queryPrefetch ?? createQueryPrefetchContext({
+		mode: context.mode === "ssg" ? "ssr" : context.mode,
+		request,
+		signal: context.signal,
+		runtime: active?.dataRuntime,
+		telemetry
+	});
+	const runPreload = preload ? Promise.resolve(preload({
+		...context,
+		params,
+		request,
+		data: prefetch
+	})).then(() => void 0) : void 0;
+	if (loader) {
+		const load = () => withTelemetry(telemetry?.loader, { route: record.path }, () => loader({
+			...context,
+			params,
+			request
+		}));
+		const loaded = runPreload ? runPreload.then(load) : load();
+		const finalize = (data) => {
+			const result = createRouteRenderResult(record, params, context, bindResolvedRouteData(renderHandler, data));
+			routeRenderData.set(result, data);
+			return result;
+		};
+		return isPromiseLike(loaded) ? Promise.resolve(loaded).then(finalize) : finalize(loaded);
+	}
+	if (runPreload) return runPreload.then(() => createRouteRenderResult(record, params, context, renderHandler));
+	return createRouteRenderResult(record, params, context, renderHandler);
+}
+function runPolicies(policies, context, record, params, request, telemetry, load, start = 0) {
+	for (let index = start; index < policies.length; index += 1) {
+		const result = policies[index](context);
+		if (isPromiseLike(result)) return Promise.resolve(result).then((decision) => decision.kind === "allow" ? runPolicies(policies, context, record, params, request, telemetry, load, index + 1) : decision);
+		if (result.kind !== "allow") return result;
+	}
+	return buildRenderResult(record, params, context, request, telemetry, load);
+}
+function resolvePath(value, fallback, context) {
+	return typeof value === "function" ? value(context) : value ?? fallback;
+}
+function appendNext(path, href) {
+	const target = new URL(path, "http://localhost");
+	target.searchParams.set("next", href);
+	return `${target.pathname}${target.search}${target.hash}`;
+}
+function mapAuthDecision(decision, context, options) {
+	if (decision.allowed) return { kind: "allow" };
+	if (decision.reason === "forbidden") return {
+		kind: "deny",
+		status: 403
+	};
+	const target = resolvePath(decision.reason === "unauthenticated" ? options?.loginPath : options?.authenticatedRedirectTo, decision.reason === "unauthenticated" ? "/login" : "/", context);
+	const finalize = (path) => ({
+		kind: "redirect",
+		to: decision.reason === "unauthenticated" ? appendNext(path, context.href) : path,
+		replace: decision.reason === "unauthenticated" ? context.mode === "spa" : true
+	});
+	return isPromiseLike(target) ? Promise.resolve(target).then(finalize) : finalize(target);
+}
+function resolveMatchedRoute(record, params, context, authOptions, request, telemetry, load) {
+	const continueResolution = (decision) => {
+		if (decision) {
+			const access = mapAuthDecision(decision, context, authOptions);
+			if (isPromiseLike(access)) return Promise.resolve(access).then((next) => next.kind === "allow" ? runPolicies(record.options.policies ?? [], context, record, params, request, telemetry, load) : next);
+			if (access.kind !== "allow") return access;
+		}
+		return runPolicies(record.options.policies ?? [], context, record, params, request, telemetry, load);
+	};
+	if (!record.options.auth) return continueResolution();
+	const decision = record.options.auth(context.auth);
+	return isPromiseLike(decision) ? Promise.resolve(decision).then(continueResolution) : continueResolution(decision);
+}
+function resolveRouteRequest(target, options = {}) {
+	return withTelemetry(options.telemetry?.routeMatch, {}, () => {
+		const match = getMatchingRouteRecord(target, options.manifest?.records ?? getRouteRecords());
+		if (!match) return null;
+		const mode = options.mode ?? getDefaultRouteMode();
+		const signal = options.signal ?? getActiveRenderContext()?.signal ?? new AbortController().signal;
+		const authOptions = getActiveRouteAuthOptions(options.auth ?? options.manifest?.auth);
+		const base = buildRouteContextBase(target, match.params, {
+			mode,
+			signal
+		});
+		const finalize = (authContext) => {
+			setCurrentAuth(authContext);
+			return resolveMatchedRoute(match.record, match.params, buildRouteContext(target, match.params, {
+				mode,
+				signal,
+				authContext
+			}), authOptions, options.request, options.telemetry, options.load !== false);
+		};
+		if (options.authContext) return finalize(options.authContext);
+		if (!authOptions?.resolve) return finalize(anonymous());
+		const resolved = authOptions.resolve(base);
+		return isPromiseLike(resolved) ? Promise.resolve(resolved).then(finalize) : finalize(resolved);
+	});
+}
+//#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 envelope.route;
+	const runtime = getCurrentAppRenderRuntime();
+	if (!runtime?.hasRoute) throw new Error("routeData() can only be read while rendering a route with loader data.");
+	return runtime.route;
+}
+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 { pageRenderEnvelope as _, resolveDeferredValues as a, getRenderHandler as b, bindResolvedRouteData as c, hasRouteRenderData as d, resolveRouteRequest as f, isPageRenderEnvelope as g, isEmptyPageRenderEnvelope as h, isDeferred as i, getRouteRenderContext as l, createPageRenderEnvelope as m, Resolve as n, reviveDeferredValue as o, currentAuth as p, defer as r, routeData as s, DEFERRED_BOUNDARY as t, getRouteRenderData as u, Outlet as v, createRouteHandler as y };

package/dist/effect-BwnIvLah.js

@@ -0,0 +1,260 @@
+import { t as enqueueRuntimeLane } from "./access-Bg4RJNC8.js";
+import { _ as withFineGrainedReadTracking } from "./fastlane-Dw8SOBr9.js";
+//#region src/runtime/effect.ts
+const SOURCE_EFFECTS = Symbol("askr.source-effects");
+const effectSources = /* @__PURE__ */ new WeakMap();
+const dirtyEffectsByLane = {
+	derived: /* @__PURE__ */ new Set(),
+	component: /* @__PURE__ */ new Set(),
+	reactive: /* @__PURE__ */ new Set(),
+	post: /* @__PURE__ */ new Set()
+};
+const hasPendingLaneFlush = {
+	derived: false,
+	component: false,
+	reactive: false,
+	post: false
+};
+const dirtyLaneState = {
+	derived: false,
+	component: false,
+	reactive: false,
+	post: false
+};
+const MAX_EFFECT_RUNS_PER_FLUSH = 50;
+const LANE_FLUSH_TASKS = {
+	derived: () => flushLaneEffects("derived"),
+	component: () => flushLaneEffects("component"),
+	reactive: () => flushLaneEffects("reactive"),
+	post: () => flushLaneEffects("post")
+};
+function isEffectReadSourceCollection(sources) {
+	return Array.isArray(sources) || sources instanceof Set;
+}
+function effectReadSourceCollectionHas(sources, source) {
+	return Array.isArray(sources) ? sources.includes(source) : sources.has(source);
+}
+function getRegisteredEffects(source) {
+	return source[SOURCE_EFFECTS] ?? effectSources.get(source);
+}
+function setRegisteredEffects(source, registered) {
+	const effectSource = source;
+	try {
+		effectSource[SOURCE_EFFECTS] = registered;
+		if (effectSource[SOURCE_EFFECTS] === registered) return;
+	} catch {}
+	effectSources.set(source, registered);
+}
+function deleteRegisteredEffects(source) {
+	const effectSource = source;
+	if (effectSource[SOURCE_EFFECTS] !== void 0) try {
+		delete effectSource[SOURCE_EFFECTS];
+		return;
+	} catch {}
+	effectSources.delete(source);
+}
+function registerEffectSource(source, effect) {
+	const registered = getRegisteredEffects(source);
+	if (!registered) {
+		setRegisteredEffects(source, effect);
+		return;
+	}
+	if (registered instanceof Set) {
+		registered.add(effect);
+		return;
+	}
+	if (registered === effect) return;
+	setRegisteredEffects(source, /* @__PURE__ */ new Set([registered, effect]));
+}
+function unregisterEffectSource(source, effect) {
+	const registered = getRegisteredEffects(source);
+	if (!registered) return;
+	if (!(registered instanceof Set)) {
+		if (registered === effect) deleteRegisteredEffects(source);
+		return;
+	}
+	registered.delete(effect);
+	if (registered.size === 0) deleteRegisteredEffects(source);
+	else if (registered.size === 1) setRegisteredEffects(source, registered.values().next().value);
+}
+function clearEffectSubscriptions(effect) {
+	const sources = effect.readSources;
+	if (isEffectReadSourceCollection(sources)) {
+		for (const source of sources) unregisterEffectSource(source, effect);
+		if (sources instanceof Set) sources.clear();
+		else sources.length = 0;
+	} else if (sources) unregisterEffectSource(sources, effect);
+	if (effect.readSource2) unregisterEffectSource(effect.readSource2, effect);
+	effect.readSources = null;
+	effect.readSource2 = null;
+}
+function evaluateAndCommitEffect(effect) {
+	effect._pendingFineGrainedReadSource = null;
+	effect._pendingFineGrainedReadSources = null;
+	try {
+		const value = withFineGrainedReadTracking(effect, effect.compute);
+		const pendingAdditionalSources = effect._pendingFineGrainedReadSources;
+		const hasPendingCollection = isEffectReadSourceCollection(pendingAdditionalSources);
+		commitEffectResult(effect, value, hasPendingCollection ? pendingAdditionalSources : effect._pendingFineGrainedReadSource, pendingAdditionalSources && !hasPendingCollection ? pendingAdditionalSources : null);
+	} finally {
+		effect._pendingFineGrainedReadSource = null;
+		effect._pendingFineGrainedReadSources = null;
+	}
+}
+function commitEffectSubscriptions(effect, nextSources, nextSource2) {
+	const previousSources = effect.readSources;
+	const previousSource2 = effect.readSource2;
+	if (previousSources === nextSources && previousSource2 === nextSource2) return;
+	const previousCollection = isEffectReadSourceCollection(previousSources);
+	const nextCollection = isEffectReadSourceCollection(nextSources);
+	if (!previousCollection && !nextCollection) {
+		if (previousSources && previousSources !== nextSources && previousSources !== nextSource2) unregisterEffectSource(previousSources, effect);
+		if (previousSource2 && previousSource2 !== nextSources && previousSource2 !== nextSource2) unregisterEffectSource(previousSource2, effect);
+		if (nextSources && nextSources !== previousSources && nextSources !== previousSource2) registerEffectSource(nextSources, effect);
+		if (nextSource2 && nextSource2 !== previousSources && nextSource2 !== previousSource2) registerEffectSource(nextSource2, effect);
+		effect.readSources = nextSources;
+		effect.readSource2 = nextSource2;
+		return;
+	}
+	const stateHas = (sources, source2, source) => isEffectReadSourceCollection(sources) ? effectReadSourceCollectionHas(sources, source) : sources === source || source2 === source;
+	if ((previousCollection ? Array.isArray(previousSources) ? previousSources.length : previousSources.size : (previousSources ? 1 : 0) + (previousSource2 ? 1 : 0)) === (nextCollection ? Array.isArray(nextSources) ? nextSources.length : nextSources.size : (nextSources ? 1 : 0) + (nextSource2 ? 1 : 0))) {
+		let same = true;
+		if (previousCollection) {
+			for (const source of previousSources) if (!stateHas(nextSources, nextSource2, source)) {
+				same = false;
+				break;
+			}
+		} else same = (!previousSources || stateHas(nextSources, nextSource2, previousSources)) && (!previousSource2 || stateHas(nextSources, nextSource2, previousSource2));
+		if (same) return;
+	}
+	if (previousCollection) {
+		for (const source of previousSources) if (!stateHas(nextSources, nextSource2, source)) unregisterEffectSource(source, effect);
+	} else {
+		if (previousSources && !stateHas(nextSources, nextSource2, previousSources)) unregisterEffectSource(previousSources, effect);
+		if (previousSource2 && !stateHas(nextSources, nextSource2, previousSource2)) unregisterEffectSource(previousSource2, effect);
+	}
+	if (nextCollection) {
+		for (const source of nextSources) if (!stateHas(previousSources, previousSource2, source)) registerEffectSource(source, effect);
+	} else {
+		if (nextSources && !stateHas(previousSources, previousSource2, nextSources)) registerEffectSource(nextSources, effect);
+		if (nextSource2 && !stateHas(previousSources, previousSource2, nextSource2)) registerEffectSource(nextSource2, effect);
+	}
+	effect.readSources = nextSources;
+	effect.readSource2 = nextSource2;
+}
+function commitEffectResult(effect, value, nextSources, nextSource2) {
+	const previousValue = effect.lastValue;
+	if (!effect.hasValue || !effect.equals(previousValue, value)) effect.commit(value, effect.hasValue ? previousValue : void 0);
+	commitEffectSubscriptions(effect, nextSources, nextSource2);
+	effect.lastValue = value;
+	effect.hasValue = true;
+}
+function flushLaneEffects(lane) {
+	hasPendingLaneFlush[lane] = false;
+	const effects = dirtyEffectsByLane[lane];
+	if (effects.size === 0) return;
+	const pending = effects.values();
+	const effectRuns = /* @__PURE__ */ new Map();
+	let next = pending.next();
+	while (!next.done) {
+		const effect = next.value;
+		effects.delete(effect);
+		if (!effect.isActive) {
+			next = pending.next();
+			continue;
+		}
+		const runCount = (effectRuns.get(effect) ?? 0) + 1;
+		effectRuns.set(effect, runCount);
+		if (runCount > MAX_EFFECT_RUNS_PER_FLUSH) {
+			const error = /* @__PURE__ */ new Error(`[Askr] fine-grained effect exceeded ${MAX_EFFECT_RUNS_PER_FLUSH} runs in one flush. Likely reactive cycle.`);
+			if (effect.onError) effect.onError(error);
+			else throw error;
+			next = pending.next();
+			continue;
+		}
+		try {
+			evaluateAndCommitEffect(effect);
+		} catch (error) {
+			effect.onError?.(error);
+		}
+		next = pending.next();
+	}
+}
+function scheduleLaneFlush(lane) {
+	if (hasPendingLaneFlush[lane]) return;
+	hasPendingLaneFlush[lane] = true;
+	enqueueRuntimeLane(lane, LANE_FLUSH_TASKS[lane]);
+}
+function unscheduleEffect(effect) {
+	dirtyEffectsByLane[effect.lane].delete(effect);
+}
+function recomputeEffectNow(effect) {
+	evaluateAndCommitEffect(effect);
+}
+function markFineGrainedEffectsDirtySource(source) {
+	const registered = getRegisteredEffects(source);
+	if (!registered) return;
+	dirtyLaneState.derived = false;
+	dirtyLaneState.component = false;
+	dirtyLaneState.reactive = false;
+	dirtyLaneState.post = false;
+	const markDirty = (effect) => {
+		if (!effect.isActive) return;
+		const lane = effect.lane;
+		dirtyEffectsByLane[lane].add(effect);
+		dirtyLaneState[lane] = true;
+	};
+	if (registered instanceof Set) for (const effect of registered) markDirty(effect);
+	else markDirty(registered);
+	if (dirtyLaneState.derived) scheduleLaneFlush("derived");
+	if (dirtyLaneState.component) scheduleLaneFlush("component");
+	if (dirtyLaneState.reactive) scheduleLaneFlush("reactive");
+	if (dirtyLaneState.post) scheduleLaneFlush("post");
+}
+var FineGrainedEffectImpl = class {
+	constructor(lane, compute, commit, equals, onError, owner) {
+		this.readSources = null;
+		this.readSource2 = null;
+		this._pendingFineGrainedReadSource = null;
+		this._pendingFineGrainedReadSources = null;
+		this.isActive = true;
+		this.hasValue = false;
+		this.lastValue = void 0;
+		this._owner = owner;
+		this.lane = lane;
+		this.compute = compute;
+		this.commit = commit;
+		this.equals = equals;
+		this.onError = onError;
+	}
+	cleanup() {
+		if (!this.isActive) return;
+		this.isActive = false;
+		unscheduleEffect(this);
+		clearEffectSubscriptions(this);
+	}
+	updateCompute(nextCompute) {
+		if (!this.isActive) return;
+		this.compute = nextCompute;
+		unscheduleEffect(this);
+		recomputeEffectNow(this);
+	}
+	flush() {
+		if (!this.isActive) return;
+		unscheduleEffect(this);
+		recomputeEffectNow(this);
+	}
+};
+function createFineGrainedEffect(options) {
+	const effect = new FineGrainedEffectImpl(options.lane, options.compute, options.commit, options.equals ?? Object.is, options.onError, options._owner);
+	recomputeEffectNow(effect);
+	return effect;
+}
+/** @internal Allocation-sensitive variant for shared renderer callbacks. */
+function createOwnedFineGrainedEffect(lane, compute, commit, equals, onError, owner) {
+	const effect = new FineGrainedEffectImpl(lane, compute, commit, equals, onError, owner);
+	recomputeEffectNow(effect);
+	return effect;
+}
+//#endregion
+export { createOwnedFineGrainedEffect as n, markFineGrainedEffectsDirtySource as r, createFineGrainedEffect as t };