@askrjs/askr 0.0.50 → 0.0.52

package/dist/router/resolution.js

@@ -1,167 +1,11 @@
 import { isPromiseLike } from "../common/promise.js";
-import { computeRank, matchSegments, parseSegments, splitPathSegments } from "./match.js";
+import { getActiveRenderContext } from "../common/render-context.js";
 import { compileNodePolicies } from "./access.js";
 import { getRenderHandler } from "./rendering.js";
-import { getActiveRenderContext } from "../common/render-context.js";
-import { getActiveRouteAuthOptions, getActiveRoutes, getRouteRecords, isRouteStoreRoutes } from "./store.js";
-import { buildRouteContext, buildRouteContextBase, deepFreeze, parseLocation } from "./route-context.js";
+import { getActiveRouteAuthOptions, getRouteRecords } from "./store.js";
+import { buildRouteContext, buildRouteContextBase } from "./route-context.js";
+import { computeMatchesFromRoutes, computeRouteActivityMatches, getMatchingRouteRecord, resolveRouteFromRoutes } from "./route-matching.js";
 //#region src/router/resolution.ts
-const routeSegsCache = /* @__PURE__ */ new WeakMap();
-const routeRankCache = /* @__PURE__ */ new WeakMap();
-const sortedListCache = /* @__PURE__ */ new WeakMap();
-function cachedSegs(route) {
-	let segments = routeSegsCache.get(route);
-	if (!segments) {
-		segments = parseSegments(route.path);
-		routeSegsCache.set(route, segments);
-	}
-	return segments;
-}
-function cachedRank(route) {
-	let rank = routeRankCache.get(route);
-	if (rank === void 0) {
-		rank = computeRank(cachedSegs(route));
-		routeRankCache.set(route, rank);
-	}
-	return rank;
-}
-function cachedSortedList(routeList) {
-	let sorted = sortedListCache.get(routeList);
-	if (!sorted) {
-		sorted = [...routeList].sort((a, b) => cachedRank(b) - cachedRank(a));
-		sortedListCache.set(routeList, sorted);
-	}
-	return sorted;
-}
-function matchFallbackPrefix(pathname, fallbackPrefix) {
-	const normalizedPath = pathname.endsWith("/") && pathname !== "/" ? pathname.slice(0, -1) : pathname;
-	const normalizedPrefix = fallbackPrefix.endsWith("/") && fallbackPrefix !== "/" ? fallbackPrefix.slice(0, -1) : fallbackPrefix;
-	if (normalizedPrefix === "/") {
-		const urlParts = splitPathSegments(normalizedPath);
-		return { "*": urlParts.length === 0 ? "/" : urlParts.length === 1 ? urlParts[0] : "/" + urlParts.join("/") };
-	}
-	if (normalizedPath !== normalizedPrefix && !normalizedPath.startsWith(`${normalizedPrefix}/`)) return null;
-	const remainderParts = splitPathSegments(normalizedPath === normalizedPrefix ? "/" : normalizedPath.slice(normalizedPrefix.length));
-	return { "*": remainderParts.length === 0 ? "/" : remainderParts.length === 1 ? remainderParts[0] : "/" + remainderParts.join("/") };
-}
-function findBestResolvedRouteFromRoutes(pathname, routeList) {
-	const normalized = pathname.endsWith("/") && pathname !== "/" ? pathname.slice(0, -1) : pathname;
-	const urlParts = splitPathSegments(normalized);
-	const sorted = cachedSortedList(routeList);
-	let bestRoute = null;
-	let bestParams = {};
-	let bestRank = -Infinity;
-	for (const route of sorted) {
-		if (route.fallbackPrefix) continue;
-		const rank = cachedRank(route);
-		if (rank < bestRank) break;
-		if (bestRoute !== null && rank === bestRank) continue;
-		const params = matchSegments(urlParts, cachedSegs(route));
-		if (params !== null) {
-			bestRoute = route;
-			bestParams = params;
-			bestRank = rank;
-		}
-	}
-	if (bestRoute !== null) return {
-		route: bestRoute,
-		params: bestParams
-	};
-	let bestFallback = null;
-	let bestFallbackParams = null;
-	let bestPrefixLength = -1;
-	for (const route of routeList) {
-		const internalRoute = route;
-		if (!internalRoute.fallbackPrefix) continue;
-		const params = matchFallbackPrefix(normalized, internalRoute.fallbackPrefix);
-		if (params === null) continue;
-		if (internalRoute.fallbackPrefix.length > bestPrefixLength) {
-			bestFallback = internalRoute;
-			bestFallbackParams = params;
-			bestPrefixLength = internalRoute.fallbackPrefix.length;
-		}
-	}
-	return bestFallback && bestFallbackParams ? {
-		route: bestFallback,
-		params: bestFallbackParams
-	} : null;
-}
-function findBestScopedFallbackRecord(pathname, routeRecords) {
-	let bestRecord = null;
-	let bestParams = null;
-	let bestPrefixLength = -1;
-	for (const routeRecord of routeRecords) {
-		const record = routeRecord;
-		if (!record.fallbackPrefix) continue;
-		const params = matchFallbackPrefix(pathname, record.fallbackPrefix);
-		if (params === null) continue;
-		if (record.fallbackPrefix.length > bestPrefixLength) {
-			bestRecord = record;
-			bestParams = params;
-			bestPrefixLength = record.fallbackPrefix.length;
-		}
-	}
-	return bestRecord && bestParams ? {
-		record: bestRecord,
-		params: bestParams
-	} : null;
-}
-function getMatchingRecord(target, routeRecords) {
-	const location = parseLocation(target);
-	const normalized = location.pathname.endsWith("/") && location.pathname !== "/" ? location.pathname.slice(0, -1) : location.pathname;
-	const urlParts = splitPathSegments(normalized);
-	for (const record of routeRecords) {
-		if (record.fallbackPrefix) continue;
-		const params = matchSegments(urlParts, record.segments);
-		if (params !== null) return {
-			record,
-			params
-		};
-	}
-	return findBestScopedFallbackRecord(normalized, routeRecords);
-}
-function computeMatchesFromRoutes(pathname, routesList) {
-	const bestMatch = isRouteStoreRoutes(routesList) ? getMatchingRecord(pathname, getRouteRecords()) : findBestResolvedRouteFromRoutes(pathname, routesList);
-	if (!bestMatch) return [];
-	return [{
-		path: "route" in bestMatch ? bestMatch.route.path : bestMatch.record.path,
-		params: deepFreeze({ ...bestMatch.params }),
-		name: "route" in bestMatch ? bestMatch.route.name : void 0,
-		namespace: "route" in bestMatch ? bestMatch.route.namespace : bestMatch.record.options.namespace
-	}];
-}
-function computeMatchesFromRouteRecords(pathname, routeRecords) {
-	const bestMatch = getMatchingRecord(pathname, routeRecords);
-	if (!bestMatch) return [];
-	return [{
-		path: bestMatch.record.path,
-		params: deepFreeze({ ...bestMatch.params }),
-		namespace: bestMatch.record.options.namespace
-	}];
-}
-function computeRouteActivityMatches(pathname, options = {}) {
-	if (options.manifest) return computeMatchesFromRouteRecords(pathname, options.manifest.records);
-	if (options.routes) return computeMatchesFromRoutes(pathname, options.routes);
-	return computeMatchesFromRoutes(pathname, getActiveRoutes());
-}
-function resolveRoute(pathname) {
-	const normalized = pathname.endsWith("/") && pathname !== "/" ? pathname.slice(0, -1) : pathname;
-	const urlParts = splitPathSegments(normalized);
-	const records = getRouteRecords();
-	for (const record of records) {
-		if (record.fallbackPrefix) continue;
-		const params = matchSegments(urlParts, record.segments);
-		if (params !== null) return {
-			handler: record.handler,
-			params
-		};
-	}
-	const fallbackMatch = findBestScopedFallbackRecord(normalized, records);
-	return fallbackMatch ? {
-		handler: fallbackMatch.record.handler,
-		params: fallbackMatch.params
-	} : null;
-}
 function getRoutePolicies(options) {
 	if (!options) return [];
 	if (options.policies?.length) return options.policies;
@@ -209,7 +53,7 @@ function continueRoutePolicies(policies, context, record, params, startIndex = 0
 	return buildRenderResult(record, params, context.mode);
 }
 function resolveRouteRequest(target, options = {}) {
-	const match = getMatchingRecord(target, options.manifest?.records ?? getRouteRecords());
+	const match = getMatchingRouteRecord(target, options.manifest?.records ?? getRouteRecords());
 	if (!match) return null;
 	const { record, params } = match;
 	const policies = getRoutePolicies(record.options);
@@ -236,18 +80,5 @@ function resolveRouteRequest(target, options = {}) {
 	if (isPromiseLike(authState)) return Promise.resolve(authState).then((next) => finalize(next));
 	return finalize(authState);
 }
-function resolveRouteFromRoutes(pathname, routeList) {
-	if (isRouteStoreRoutes(routeList)) return resolveRoute(pathname);
-	const match = findBestResolvedRouteFromRoutes(pathname, routeList);
-	return match ? {
-		handler: match.route.handler,
-		params: match.params
-	} : null;
-}
-function _resolveRouteMatchFromRoutes(pathname, routeList) {
-	return findBestResolvedRouteFromRoutes(pathname, routeList);
-}
 //#endregion
-export { _resolveRouteMatchFromRoutes, computeMatchesFromRouteRecords, computeMatchesFromRoutes, computeRouteActivityMatches, resolveRoute, resolveRouteFromRoutes, resolveRouteRequest };
-
-//# sourceMappingURL=resolution.js.map
+export { computeMatchesFromRoutes, computeRouteActivityMatches, resolveRouteFromRoutes, resolveRouteRequest };

package/dist/router/route-context.js

@@ -75,5 +75,3 @@ function buildRouteContext(target, params, options) {
 }
 //#endregion
 export { buildRouteContext, buildRouteContextBase, deepFreeze, makeQuery, parseLocation };
-
-//# sourceMappingURL=route-context.js.map

package/dist/router/route-matching.d.ts

@@ -0,0 +1,19 @@
+import { ResolvedRoute, Route, RouteManifest, RouteMatch, RouteRecord } from "../common/router.js";
+
+//#region src/router/route-matching.d.ts
+declare function getMatchingRouteRecord(target: string, routeRecords: readonly RouteRecord[]): {
+  record: RouteRecord;
+  params: Record<string, string>;
+} | null;
+declare function computeMatchesFromRoutes(pathname: string, routesList: readonly Route[]): RouteMatch[];
+declare function computeMatchesFromRouteRecords(pathname: string, routeRecords: readonly RouteRecord[]): RouteMatch[];
+declare function computeRouteActivityMatches(pathname: string, options?: {
+  manifest?: RouteManifest;
+  routes?: readonly Route[];
+}): RouteMatch[];
+declare function resolveRoute(pathname: string): ResolvedRoute | null;
+declare function resolveRouteFromRoutes(pathname: string, routeList: readonly Route[]): ResolvedRoute | null;
+declare function _resolveRouteMatchFromRoutes(pathname: string, routeList: readonly Route[]): {
+  route: Route;
+  params: Record<string, string>;
+} | null;

package/dist/router/route-matching.js

@@ -0,0 +1,173 @@
+import { computeRank, matchSegments, parseSegments, splitPathSegments } from "./match.js";
+import { getActiveRoutes, getRouteRecords, isRouteStoreRoutes } from "./store.js";
+import { deepFreeze, parseLocation } from "./route-context.js";
+//#region src/router/route-matching.ts
+const routeSegsCache = /* @__PURE__ */ new WeakMap();
+const routeRankCache = /* @__PURE__ */ new WeakMap();
+const sortedListCache = /* @__PURE__ */ new WeakMap();
+function cachedSegs(route) {
+	let segments = routeSegsCache.get(route);
+	if (!segments) {
+		segments = parseSegments(route.path);
+		routeSegsCache.set(route, segments);
+	}
+	return segments;
+}
+function cachedRank(route) {
+	let rank = routeRankCache.get(route);
+	if (rank === void 0) {
+		rank = computeRank(cachedSegs(route));
+		routeRankCache.set(route, rank);
+	}
+	return rank;
+}
+function cachedSortedList(routeList) {
+	let sorted = sortedListCache.get(routeList);
+	if (!sorted) {
+		sorted = [...routeList].sort((a, b) => cachedRank(b) - cachedRank(a));
+		sortedListCache.set(routeList, sorted);
+	}
+	return sorted;
+}
+function matchFallbackPrefix(pathname, fallbackPrefix) {
+	const normalizedPath = pathname.endsWith("/") && pathname !== "/" ? pathname.slice(0, -1) : pathname;
+	const normalizedPrefix = fallbackPrefix.endsWith("/") && fallbackPrefix !== "/" ? fallbackPrefix.slice(0, -1) : fallbackPrefix;
+	if (normalizedPrefix === "/") {
+		const urlParts = splitPathSegments(normalizedPath);
+		return { "*": urlParts.length === 0 ? "/" : urlParts.length === 1 ? urlParts[0] : "/" + urlParts.join("/") };
+	}
+	if (normalizedPath !== normalizedPrefix && !normalizedPath.startsWith(`${normalizedPrefix}/`)) return null;
+	const remainderParts = splitPathSegments(normalizedPath === normalizedPrefix ? "/" : normalizedPath.slice(normalizedPrefix.length));
+	return { "*": remainderParts.length === 0 ? "/" : remainderParts.length === 1 ? remainderParts[0] : "/" + remainderParts.join("/") };
+}
+function findBestResolvedRouteFromRoutes(pathname, routeList) {
+	const normalized = pathname.endsWith("/") && pathname !== "/" ? pathname.slice(0, -1) : pathname;
+	const urlParts = splitPathSegments(normalized);
+	const sorted = cachedSortedList(routeList);
+	let bestRoute = null;
+	let bestParams = {};
+	let bestRank = -Infinity;
+	for (const route of sorted) {
+		if (route.fallbackPrefix) continue;
+		const rank = cachedRank(route);
+		if (rank < bestRank) break;
+		if (bestRoute !== null && rank === bestRank) continue;
+		const params = matchSegments(urlParts, cachedSegs(route));
+		if (params !== null) {
+			bestRoute = route;
+			bestParams = params;
+			bestRank = rank;
+		}
+	}
+	if (bestRoute !== null) return {
+		route: bestRoute,
+		params: bestParams
+	};
+	let bestFallback = null;
+	let bestFallbackParams = null;
+	let bestPrefixLength = -1;
+	for (const route of routeList) {
+		const internalRoute = route;
+		if (!internalRoute.fallbackPrefix) continue;
+		const params = matchFallbackPrefix(normalized, internalRoute.fallbackPrefix);
+		if (params === null) continue;
+		if (internalRoute.fallbackPrefix.length > bestPrefixLength) {
+			bestFallback = internalRoute;
+			bestFallbackParams = params;
+			bestPrefixLength = internalRoute.fallbackPrefix.length;
+		}
+	}
+	return bestFallback && bestFallbackParams ? {
+		route: bestFallback,
+		params: bestFallbackParams
+	} : null;
+}
+function findBestScopedFallbackRecord(pathname, routeRecords) {
+	let bestRecord = null;
+	let bestParams = null;
+	let bestPrefixLength = -1;
+	for (const routeRecord of routeRecords) {
+		const record = routeRecord;
+		if (!record.fallbackPrefix) continue;
+		const params = matchFallbackPrefix(pathname, record.fallbackPrefix);
+		if (params === null) continue;
+		if (record.fallbackPrefix.length > bestPrefixLength) {
+			bestRecord = record;
+			bestParams = params;
+			bestPrefixLength = record.fallbackPrefix.length;
+		}
+	}
+	return bestRecord && bestParams ? {
+		record: bestRecord,
+		params: bestParams
+	} : null;
+}
+function getMatchingRouteRecord(target, routeRecords) {
+	const location = parseLocation(target);
+	const normalized = location.pathname.endsWith("/") && location.pathname !== "/" ? location.pathname.slice(0, -1) : location.pathname;
+	const urlParts = splitPathSegments(normalized);
+	for (const record of routeRecords) {
+		if (record.fallbackPrefix) continue;
+		const params = matchSegments(urlParts, record.segments);
+		if (params !== null) return {
+			record,
+			params
+		};
+	}
+	return findBestScopedFallbackRecord(normalized, routeRecords);
+}
+function computeMatchesFromRoutes(pathname, routesList) {
+	const bestMatch = isRouteStoreRoutes(routesList) ? getMatchingRouteRecord(pathname, getRouteRecords()) : findBestResolvedRouteFromRoutes(pathname, routesList);
+	if (!bestMatch) return [];
+	return [{
+		path: "route" in bestMatch ? bestMatch.route.path : bestMatch.record.path,
+		params: deepFreeze({ ...bestMatch.params }),
+		name: "route" in bestMatch ? bestMatch.route.name : void 0,
+		namespace: "route" in bestMatch ? bestMatch.route.namespace : bestMatch.record.options.namespace
+	}];
+}
+function computeMatchesFromRouteRecords(pathname, routeRecords) {
+	const bestMatch = getMatchingRouteRecord(pathname, routeRecords);
+	if (!bestMatch) return [];
+	return [{
+		path: bestMatch.record.path,
+		params: deepFreeze({ ...bestMatch.params }),
+		namespace: bestMatch.record.options.namespace
+	}];
+}
+function computeRouteActivityMatches(pathname, options = {}) {
+	if (options.manifest) return computeMatchesFromRouteRecords(pathname, options.manifest.records);
+	if (options.routes) return computeMatchesFromRoutes(pathname, options.routes);
+	return computeMatchesFromRoutes(pathname, getActiveRoutes());
+}
+function resolveRoute(pathname) {
+	const normalized = pathname.endsWith("/") && pathname !== "/" ? pathname.slice(0, -1) : pathname;
+	const urlParts = splitPathSegments(normalized);
+	const records = getRouteRecords();
+	for (const record of records) {
+		if (record.fallbackPrefix) continue;
+		const params = matchSegments(urlParts, record.segments);
+		if (params !== null) return {
+			handler: record.handler,
+			params
+		};
+	}
+	const fallbackMatch = findBestScopedFallbackRecord(normalized, records);
+	return fallbackMatch ? {
+		handler: fallbackMatch.record.handler,
+		params: fallbackMatch.params
+	} : null;
+}
+function resolveRouteFromRoutes(pathname, routeList) {
+	if (isRouteStoreRoutes(routeList)) return resolveRoute(pathname);
+	const match = findBestResolvedRouteFromRoutes(pathname, routeList);
+	return match ? {
+		handler: match.route.handler,
+		params: match.params
+	} : null;
+}
+function _resolveRouteMatchFromRoutes(pathname, routeList) {
+	return findBestResolvedRouteFromRoutes(pathname, routeList);
+}
+//#endregion
+export { _resolveRouteMatchFromRoutes, computeMatchesFromRouteRecords, computeMatchesFromRoutes, computeRouteActivityMatches, getMatchingRouteRecord, resolveRoute, resolveRouteFromRoutes };

package/dist/router/route-query.d.ts

@@ -13,5 +13,4 @@ type UpdateRouteQueryOptions = {
 };
 declare function updateRouteQuery(updates: RouteQueryUpdates | RouteQueryUpdater, options?: UpdateRouteQueryOptions): void;
 //#endregion
-export { RouteQueryParamInput, RouteQueryParamValue, RouteQueryUpdater, RouteQueryUpdates, UpdateRouteQueryOptions, updateRouteQuery };
-//# sourceMappingURL=route-query.d.ts.map
+export { RouteQueryParamInput, RouteQueryParamValue, RouteQueryUpdater, RouteQueryUpdates, UpdateRouteQueryOptions, updateRouteQuery };

package/dist/router/route-query.js

@@ -1,5 +1,5 @@
-import { saveScrollPosition } from "./navigation-scroll.js";
 import { getCurrentHref, getRegisteredAppsSnapshot, getWindowHref, parseTargetUrl, setCurrentRouteLocation, syncAppRegistrationLocation, syncRegisteredRouteSnapshot } from "./navigation-registry.js";
+import { saveScrollPosition } from "./navigation-scroll.js";
 //#region src/router/route-query.ts
 function getRouteQueryHistoryMode(options) {
 	if (options.history) return options.history;
@@ -43,5 +43,3 @@ function updateRouteQuery(updates, options = {}) {
 }
 //#endregion
 export { updateRouteQuery };
-
-//# sourceMappingURL=route-query.js.map

package/dist/router/route.js

@@ -1,8 +1,10 @@
+import { _getBuiltInRoutePolicy } from "./policy.js";
 import { Outlet } from "./rendering.js";
 import { _setActiveRouteAuthOptions, getRoutes, hasRegisteredRoutes, lockRouteRegistration } from "./store.js";
 import { fallback, group, index, page, registerRoutes, route } from "./authoring.js";
-import { computeRouteActivityMatches, resolveRouteFromRoutes, resolveRouteRequest } from "./resolution.js";
+import { computeRouteActivityMatches, resolveRouteFromRoutes } from "./route-matching.js";
+import { resolveRouteRequest } from "./resolution.js";
 import { currentRoute, setServerLocation, syncCurrentRouteSnapshot } from "./activity.js";
 import { _drainLazy, _snapshotLazy, _snapshotRouteSourceLazy, lazy } from "./lazy.js";
 import { _applyManifest, clearRoutes, createRouteRegistry, getManifest } from "./manifest.js";
-export { Outlet, _applyManifest, _drainLazy, _setActiveRouteAuthOptions, _snapshotLazy, _snapshotRouteSourceLazy, clearRoutes, computeRouteActivityMatches, createRouteRegistry, currentRoute, fallback, getManifest, getRoutes, group, hasRegisteredRoutes, index, lazy, lockRouteRegistration, page, registerRoutes, resolveRouteFromRoutes, resolveRouteRequest, route, setServerLocation, syncCurrentRouteSnapshot };
+export { Outlet, _applyManifest, _drainLazy, _getBuiltInRoutePolicy, _setActiveRouteAuthOptions, _snapshotLazy, _snapshotRouteSourceLazy, clearRoutes, computeRouteActivityMatches, createRouteRegistry, currentRoute, fallback, getManifest, getRoutes, group, hasRegisteredRoutes, index, lazy, lockRouteRegistration, page, registerRoutes, resolveRouteFromRoutes, resolveRouteRequest, route, setServerLocation, syncCurrentRouteSnapshot };

package/dist/router/store.d.ts

@@ -46,5 +46,4 @@ declare function clearRouteState(): void;
 declare function snapshotRouteState(): RouteStateSnapshot;
 declare function restoreRouteState(snapshot: RouteStateSnapshot): void;
 //#endregion
-export { getRoutes };
-//# sourceMappingURL=store.d.ts.map
+export { getRoutes };

package/dist/router/store.js

@@ -167,5 +167,3 @@ function restoreRouteState(snapshot) {
 }
 //#endregion
 export { _setActiveRouteAuthOptions, addRouteToStores, assertRouteRegistrationUnlocked, clearRouteState, getActiveRouteAuthOptions, getActiveRoutes, getCurrentAccessScopeState, getCurrentInheritedPolicies, getCurrentLayoutChain, getCurrentPageChain, getCurrentPageScope, getCurrentPathPrefix, getCurrentRegistrationSession, getCurrentScopeKind, getDefaultRouteAuthOptions, getRouteRecords, getRoutes, hasActivePageScope, hasRegisteredRoutes, insertRecordSorted, isRouteStoreRoutes, lockRouteRegistration, pushRegistrationScope, pushRegistrationSession, restoreRouteState, setDefaultRouteAuthOptions, snapshotRouteState };
-
-//# sourceMappingURL=store.js.map

package/dist/router/testing.js

@@ -0,0 +1,4 @@
+import { parseSegments } from "./match.js";
+import { computeRouteActivityMatches } from "./route-matching.js";
+import "./route.js";
+export { computeRouteActivityMatches, parseSegments };

package/dist/runtime/access.d.ts

@@ -0,0 +1,19 @@
+import { ReadableSource } from "./readable.js";
+import { Scheduler, SchedulerLane } from "./scheduler.js";
+import { AskrRuntime, RuntimeRendererHost } from "./runtime.js";
+
+//#region src/runtime/access.d.ts
+type RuntimeTask = () => void;
+declare function getRuntimeScheduler(): Scheduler;
+declare function getDefaultRuntimeInstance(): AskrRuntime;
+declare function getRuntimeRenderer(): RuntimeRendererHost;
+declare function enqueueRuntimeTask(task: RuntimeTask): void;
+declare function enqueueRuntimeLane(lane: SchedulerLane, task: RuntimeTask): void;
+declare function runRuntimeHandlerScope<T>(fn: () => T, flushMode?: 'defer' | 'sync'): T;
+declare function runRuntimeWithSyncProgress<T>(fn: () => T): T;
+declare function getRuntimeSchedulerState(): ReturnType<Scheduler['getState']>;
+declare function isRuntimeSchedulerExecuting(): boolean;
+declare function getRuntimeFlushVersion(): number;
+declare function flushRuntimeScheduler(): void;
+declare function setRuntimeBulkCommitProbe(probe: () => boolean): void;
+declare function markRuntimeReactivePropsDirtySource(source: ReadableSource<unknown>): void;

package/dist/runtime/access.js

@@ -41,5 +41,3 @@ function markRuntimeReactivePropsDirtySource(source) {
 }
 //#endregion
 export { enqueueRuntimeLane, enqueueRuntimeTask, flushRuntimeScheduler, getDefaultRuntimeInstance, getRuntimeFlushVersion, getRuntimeRenderer, getRuntimeScheduler, getRuntimeSchedulerState, isRuntimeSchedulerExecuting, markRuntimeReactivePropsDirtySource, runRuntimeHandlerScope, runRuntimeWithSyncProgress, setRuntimeBulkCommitProbe };
-
-//# sourceMappingURL=access.js.map

package/dist/runtime/child-scope.d.ts

@@ -1,4 +1,5 @@
 import { ComponentInstance } from "./component-internal.js";
+import { DOMRange } from "../common/dom-range.js";
 import { VNode } from "../common/vnode.js";
 
 //#region src/runtime/child-scope.d.ts
@@ -8,15 +9,33 @@ interface ChildScope {
   previousVnode: VNode | undefined;
   vnode: VNode | undefined;
   dom?: Node;
+  /** @internal Fast singleton node plus an anchor-backed multi-node range. */
+  range?: DOMRange;
   needsDomUpdate: boolean;
   hydrationPending: boolean;
+  /** @internal Stable owner for validated intrinsic blueprints in list items. */
+  blueprintOwner?: object;
   render(renderFn: () => VNode): VNode;
   markDirty(): void;
   dispose(): void;
 }
+/** @internal Snapshot used to restore a child scope after a failed commit. */
+interface ChildScopeTransactionSnapshot {
+  previousVnode: VNode | undefined;
+  vnode: VNode | undefined;
+  dom: Node | undefined;
+  range: DOMRange | undefined;
+  domTextData: string | undefined;
+  needsDomUpdate: boolean;
+  hydrationPending: boolean;
+  renderFn: (() => VNode) | undefined;
+}
 declare function rerenderChildScope(scope: ChildScope): VNode | undefined;
+/** @internal */
+declare function captureChildScopeTransactionSnapshot(scope: ChildScope): ChildScopeTransactionSnapshot;
+/** @internal */
+declare function restoreChildScopeTransactionSnapshot(scope: ChildScope, snapshot: ChildScopeTransactionSnapshot): void;
 declare function disposeChildScope(scope: ChildScope): void;
 declare function createChildScope(parent: ComponentInstance | null, key: string | number, onDirty?: () => void): ChildScope;
 //#endregion
-export { ChildScope };
-//# sourceMappingURL=child-scope.d.ts.map
+export { ChildScope, ChildScopeTransactionSnapshot };