@askrjs/askr 0.0.52 → 0.0.54

package/dist/runtime/derive.js

@@ -1,140 +0,0 @@
-import { enqueueRuntimeLane, getRuntimeFlushVersion } from "./access.js";
-import { clearDerivedDependencySubscriptions, markReactivePropsDirtySource, markReadableDerivedSubscribersDirty, notifyReadableReaders, recordReadableRead, syncDerivedDependencySubscriptions, withDerivedReadTracking } from "./readable.js";
-import { claimHookIndex, getCurrentInstance } from "./component-scope.js";
-import "./component.js";
-import { isSnapshotSource } from "./snapshot-source.js";
-//#region src/runtime/derive.ts
-const deriveCells = /* @__PURE__ */ new WeakMap();
-const dirtyDerivedCells = /* @__PURE__ */ new Set();
-let hasPendingDerivedFlush = false;
-function getDeriveStore(instance) {
-	let store = deriveCells.get(instance);
-	if (!store) {
-		store = /* @__PURE__ */ new Map();
-		deriveCells.set(instance, store);
-	}
-	return store;
-}
-function markDerivedCellDirty(cell) {
-	cell._dirty = true;
-	if (cell._scheduled) return;
-	cell._scheduled = true;
-	dirtyDerivedCells.add(cell);
-	if (!hasPendingDerivedFlush) {
-		hasPendingDerivedFlush = true;
-		enqueueRuntimeLane("derived", flushDirtyDerivedCells);
-	}
-}
-function flushDirtyDerivedCells() {
-	hasPendingDerivedFlush = false;
-	if (dirtyDerivedCells.size === 0) return;
-	const pending = dirtyDerivedCells.values();
-	let next = pending.next();
-	while (!next.done) {
-		const cell = next.value;
-		dirtyDerivedCells.delete(cell);
-		cell._scheduled = false;
-		if (!cell._dirty) {
-			next = pending.next();
-			continue;
-		}
-		recomputeDerivedCell(cell, true);
-		next = pending.next();
-	}
-}
-function recomputeDerivedCell(cell, notifyDownstream) {
-	if (!cell._dirty && cell._hasValue) return cell._value;
-	if (cell._evaluating) throw new Error("derive() cannot read itself recursively");
-	cell._evaluating = true;
-	cell._dirty = false;
-	cell._pendingDependencySources = /* @__PURE__ */ new Set();
-	const prevSources = cell._sources;
-	let nextValue;
-	try {
-		nextValue = withDerivedReadTracking(cell, cell._compute);
-	} catch (error) {
-		cell._dirty = true;
-		cell._pendingDependencySources = void 0;
-		throw error;
-	} finally {
-		cell._evaluating = false;
-	}
-	const nextSources = cell._pendingDependencySources ?? /* @__PURE__ */ new Set();
-	cell._pendingDependencySources = void 0;
-	syncDerivedDependencySubscriptions(cell, prevSources, nextSources);
-	cell._sources = nextSources;
-	const valueChanged = !cell._hasValue || !Object.is(cell._value, nextValue);
-	cell._hasValue = true;
-	cell._value = nextValue;
-	cell._lastRecomputeFlushVersion = getRuntimeFlushVersion();
-	if (valueChanged && notifyDownstream) {
-		markReadableDerivedSubscribersDirty(cell);
-		markReactivePropsDirtySource(cell);
-		notifyReadableReaders(cell);
-	}
-	return cell._value;
-}
-function createDerivedCell(instance, hookIndex, compute) {
-	const cell = function derivedGetter() {
-		recordReadableRead(cell);
-		return recomputeDerivedCell(cell, cell._scheduled);
-	};
-	cell._owner = instance;
-	cell._hookIndex = hookIndex;
-	cell._compute = compute;
-	cell._value = void 0;
-	cell._hasValue = false;
-	cell._dirty = true;
-	cell._scheduled = false;
-	cell._evaluating = false;
-	cell._lastRecomputeFlushVersion = -1;
-	cell._sources = /* @__PURE__ */ new Set();
-	cell._markDirty = () => {
-		markDerivedCellDirty(cell);
-	};
-	cell._cleanup = () => {
-		cell._scheduled = false;
-		cell._dirty = false;
-		cell._hasValue = false;
-		dirtyDerivedCells.delete(cell);
-		clearDerivedDependencySubscriptions(cell, cell._sources);
-		cell._derivedSubscribers?.clear();
-		cell._readers?.clear();
-	};
-	(instance.cleanupFns ??= []).push(() => {
-		cell._cleanup();
-		deriveCells.get(instance)?.delete(hookIndex);
-	});
-	return cell;
-}
-function getOrCreateDerivedCell(instance, hookIndex, compute) {
-	const store = getDeriveStore(instance);
-	const existing = store.get(hookIndex);
-	if (existing) {
-		existing._compute = compute;
-		if (existing._lastRecomputeFlushVersion !== getRuntimeFlushVersion()) existing._dirty = true;
-		return existing;
-	}
-	const created = createDerivedCell(instance, hookIndex, compute);
-	store.set(hookIndex, created);
-	return created;
-}
-function createMappedSelector(source, map) {
-	return () => {
-		let value;
-		if (typeof source === "function") value = source();
-		else if (isSnapshotSource(source)) value = source.value ?? source;
-		else value = source;
-		if (value == null) return null;
-		return map(value);
-	};
-}
-function derive(source, map) {
-	const instance = getCurrentInstance();
-	if (!instance) throw new Error("derive() can only be called during component render execution. Move derive() calls to the top level of your component function.");
-	const cell = getOrCreateDerivedCell(instance, claimHookIndex(instance, "derive"), map === void 0 ? () => source() : createMappedSelector(source, map));
-	recomputeDerivedCell(cell, false);
-	return cell;
-}
-//#endregion
-export { derive };

package/dist/runtime/dev-namespace.d.ts

@@ -1,30 +0,0 @@
-//#region src/runtime/dev-namespace.d.ts
-/**
- * Dev-only namespace helpers for diagnostics
- *
- * Centralizes the repetitive globalThis.__ASKR__ access pattern
- * used throughout runtime for dev-mode diagnostics.
- */
-type DevNamespace = Record<string, unknown>;
-/**
- * Get or create the __ASKR__ dev namespace on globalThis.
- * Returns empty object in production to avoid allocations.
- */
-declare const getDevNamespace: () => DevNamespace;
-/**
- * Set a value in the dev namespace (no-op in production).
- */
-declare const setDevValue: (key: string, value: unknown) => void;
-/**
- * Get a value from the dev namespace (returns undefined in production).
- */
-declare const getDevValue: <T>(key: string) => T | undefined;
-/**
- * Delete a value from the dev namespace (no-op in production).
- */
-declare const deleteDevValue: (key: string) => void;
-/**
- * Increment a counter in the dev namespace (no-op in production).
- * Safely handles non-number values by resetting to 1.
- */
-declare const incDevCounter: (key: string) => void;

package/dist/runtime/dev-namespace.js

@@ -1,64 +0,0 @@
-import { isProductionEnvironment } from "../common/env.js";
-//#region src/runtime/dev-namespace.ts
-/**
-* Dev-only namespace helpers for diagnostics
-*
-* Centralizes the repetitive globalThis.__ASKR__ access pattern
-* used throughout runtime for dev-mode diagnostics.
-*/
-const PRODUCTION_BUILD_ENABLED = isProductionEnvironment();
-const EMPTY_DEV_NAMESPACE = {};
-function getOrCreateDevNamespace() {
-	try {
-		const g = globalThis;
-		if (!g.__ASKR__) g.__ASKR__ = {};
-		return g.__ASKR__;
-	} catch {
-		return EMPTY_DEV_NAMESPACE;
-	}
-}
-function getDevNamespaceLive() {
-	if (isProductionEnvironment()) return EMPTY_DEV_NAMESPACE;
-	return getOrCreateDevNamespace();
-}
-function setDevValueLive(key, value) {
-	if (isProductionEnvironment()) return;
-	try {
-		getOrCreateDevNamespace()[key] = value;
-	} catch {}
-}
-function getDevValueLive(key) {
-	if (isProductionEnvironment()) return void 0;
-	try {
-		return getOrCreateDevNamespace()[key];
-	} catch {
-		return;
-	}
-}
-function incDevCounterLive(key) {
-	if (isProductionEnvironment()) return;
-	try {
-		const ns = getOrCreateDevNamespace();
-		ns[key] = (typeof ns[key] === "number" ? ns[key] : 0) + 1;
-	} catch {}
-}
-/**
-* Get or create the __ASKR__ dev namespace on globalThis.
-* Returns empty object in production to avoid allocations.
-*/
-const getDevNamespace = PRODUCTION_BUILD_ENABLED ? () => EMPTY_DEV_NAMESPACE : getDevNamespaceLive;
-/**
-* Set a value in the dev namespace (no-op in production).
-*/
-const setDevValue = PRODUCTION_BUILD_ENABLED ? () => {} : setDevValueLive;
-/**
-* Get a value from the dev namespace (returns undefined in production).
-*/
-const getDevValue = PRODUCTION_BUILD_ENABLED ? () => void 0 : getDevValueLive;
-/**
-* Increment a counter in the dev namespace (no-op in production).
-* Safely handles non-number values by resetting to 1.
-*/
-const incDevCounter = PRODUCTION_BUILD_ENABLED ? () => {} : incDevCounterLive;
-//#endregion
-export { getDevNamespace, getDevValue, incDevCounter, setDevValue };

package/dist/runtime/effect.d.ts

@@ -1,35 +0,0 @@
-import { FineGrainedReadCollector, ReadableSource } from "./readable.js";
-import { SchedulerLane } from "./scheduler.js";
-
-//#region src/runtime/effect.d.ts
-type EffectReadSources = ReadableSource<unknown> | ReadableSource<unknown>[] | Set<ReadableSource<unknown>> | null;
-interface FineGrainedEffect<T> extends FineGrainedReadCollector {
-  lane: SchedulerLane;
-  compute(): T;
-  commit(value: T, previousValue: T | undefined): void;
-  equals(previousValue: T, nextValue: T): boolean;
-  readSources: EffectReadSources;
-  readSource2: ReadableSource<unknown> | null;
-  isActive: boolean;
-  hasValue: boolean;
-  lastValue: T | undefined;
-  onError?(error: unknown): void;
-}
-interface FineGrainedEffectHandle<T> {
-  cleanup(): void;
-  updateCompute(nextCompute: () => T): void;
-  flush(): void;
-}
-interface CreateFineGrainedEffectOptions<T> {
-  lane: SchedulerLane;
-  compute: () => T;
-  commit: (value: T, previousValue: T | undefined) => void;
-  equals?: (previousValue: T, nextValue: T) => boolean;
-  onError?: (error: unknown) => void;
-}
-declare function markFineGrainedEffectsDirtySource(source: ReadableSource<unknown>): void;
-declare function createFineGrainedEffect<T>(options: CreateFineGrainedEffectOptions<T>): FineGrainedEffectHandle<T>;
-/** @internal Allocation-sensitive variant for shared renderer callbacks. */
-declare function createOwnedFineGrainedEffect<T>(lane: SchedulerLane, compute: () => T, commit: (value: T, previousValue: T | undefined) => void, equals: (previousValue: T, nextValue: T) => boolean, onError: ((error: unknown) => void) | undefined, owner: unknown): FineGrainedEffectHandle<T>;
-//#endregion
-export { CreateFineGrainedEffectOptions, FineGrainedEffectHandle };

package/dist/runtime/error-boundary.d.ts

@@ -1,4 +0,0 @@
-import { ComponentInstance } from "./component-internal.js";
-//#region src/runtime/error-boundary.d.ts
-declare function createBoundaryReset(instance: ComponentInstance): () => void;
-declare function reportBoundaryError(instance: ComponentInstance, error: unknown, onError?: (error: unknown) => void): void;

package/dist/runtime/error-boundary.js

@@ -1,29 +0,0 @@
-import { logger } from "../common/logger.js";
-//#region src/runtime/error-boundary.ts
-function createBoundaryReset(instance) {
-	return () => {
-		const boundaryState = instance.errorBoundaryState;
-		if (!boundaryState) return;
-		boundaryState.error = null;
-		boundaryState.notified = false;
-		queueMicrotask(() => {
-			instance._enqueueRun?.();
-		});
-	};
-}
-function reportBoundaryError(instance, error, onError) {
-	const boundaryState = instance.errorBoundaryState;
-	if (boundaryState && Object.is(boundaryState.error, error) && boundaryState.notified) return;
-	if (boundaryState) {
-		boundaryState.error = error;
-		boundaryState.notified = true;
-	}
-	try {
-		onError?.(error);
-	} catch (hookError) {
-		logger.error("[Askr] ErrorBoundary onError handler threw:", hookError);
-	}
-	logger.error("[Askr] ErrorBoundary caught render error:", error);
-}
-//#endregion
-export { createBoundaryReset, reportBoundaryError };

package/dist/runtime/events.d.ts

@@ -1,58 +0,0 @@
-//#region src/runtime/events.d.ts
-/**
- * Event delegation system for Askr
- *
- * Provides efficient event handling by attaching listeners to a container
- * instead of individual elements. This significantly reduces memory usage
- * and improves performance when many elements have the same event type.
- *
- * Delegated handling is enabled by default. Tests and internal runtime code
- * can still disable or re-enable it when they need to exercise both modes.
- */
-interface DelegatedEventMap {
-  click: MouseEvent;
-  dblclick: MouseEvent;
-  mousedown: MouseEvent;
-  mouseup: MouseEvent;
-  mouseover: MouseEvent;
-  mouseout: MouseEvent;
-  mousemove: MouseEvent;
-  focus: FocusEvent;
-  blur: FocusEvent;
-  input: InputEvent;
-  change: Event;
-  keydown: KeyboardEvent;
-  keyup: KeyboardEvent;
-  keypress: KeyboardEvent;
-  submit: Event;
-  scroll: Event;
-  wheel: WheelEvent;
-  touchstart: TouchEvent;
-  touchend: TouchEvent;
-  touchmove: TouchEvent;
-  touchcancel: TouchEvent;
-}
-interface DelegatedHandler {
-  handler: EventListener;
-  original: EventListener;
-  container: Element;
-  eventName: string;
-  options?: AddEventListenerOptions;
-}
-declare function isEventDelegationEnabled(): boolean;
-declare function disableEventDelegation(): void;
-declare function enableEventDelegation(container?: Element): void;
-declare function setGlobalDelegationContainer(container: Element): void;
-declare function addDelegatedListener(element: Element, eventName: string, handler: EventListener, originalHandler: EventListener, options?: AddEventListenerOptions): void;
-/** @internal Attach a delegated handler to a newly cloned element. */
-declare function addFreshDelegatedListener(element: Element, eventName: string, handler: EventListener, originalHandler: EventListener, options?: AddEventListenerOptions): void;
-declare function updateDelegatedListener(element: Element, eventName: string, handler: EventListener, originalHandler: EventListener, options?: AddEventListenerOptions): boolean;
-declare function removeDelegatedListener(element: Element, eventName: string): void;
-declare function getDelegatedHandlerForElement(element: Element, eventName: string): DelegatedHandler | undefined;
-declare function getDelegatedHandlersForElement(element: Element): Map<string, DelegatedHandler> | undefined;
-declare function hasDelegatedHandler(element: Element, eventName: string): boolean;
-declare function clearDelegatedHandlersForElement(element: Element): void;
-declare function getDelegatedEventNames(): readonly (keyof DelegatedEventMap)[];
-declare function isDelegatedEvent(eventName: string): boolean;
-//#endregion
-export { DelegatedEventMap };

package/dist/runtime/events.js

@@ -1,201 +0,0 @@
-import { logger } from "../common/logger.js";
-import "./perf-metrics.js";
-import { runRuntimeHandlerScope } from "./access.js";
-import "./dev-namespace.js";
-const DELEGATED_EVENTS = [
-	"click",
-	"dblclick",
-	"mousedown",
-	"mouseup",
-	"mouseover",
-	"mouseout",
-	"mousemove",
-	"focus",
-	"blur",
-	"input",
-	"change",
-	"keydown",
-	"keyup",
-	"keypress",
-	"submit",
-	"scroll",
-	"wheel",
-	"touchstart",
-	"touchend",
-	"touchmove",
-	"touchcancel"
-];
-const DELEGATED_HANDLERS = Symbol("askr.delegated-handlers");
-const delegatedHandlerFallback = /* @__PURE__ */ new WeakMap();
-function getDelegatedHandlerStore(element) {
-	return element[DELEGATED_HANDLERS] ?? delegatedHandlerFallback.get(element);
-}
-function setDelegatedHandlerStore(element, store) {
-	const host = element;
-	try {
-		host[DELEGATED_HANDLERS] = store;
-		if (host[DELEGATED_HANDLERS] === store) return;
-	} catch {}
-	delegatedHandlerFallback.set(element, store);
-}
-function deleteDelegatedHandlerStore(element) {
-	const host = element;
-	if (host[DELEGATED_HANDLERS] !== void 0) try {
-		delete host[DELEGATED_HANDLERS];
-		return;
-	} catch {}
-	delegatedHandlerFallback.delete(element);
-}
-let eventDelegationEnabled = true;
-const containerDelegatedListeners = /* @__PURE__ */ new Map();
-function isEventDelegationEnabled() {
-	return eventDelegationEnabled;
-}
-function decrementContainerListenerUsage(entry) {
-	const listeners = containerDelegatedListeners.get(entry.container);
-	const listener = listeners?.get(entry.eventName);
-	if (!listener) return;
-	listener.usage -= 1;
-	if (listener.usage > 0) return;
-	entry.container.removeEventListener(entry.eventName, listener.handler);
-	listeners?.delete(entry.eventName);
-	if (listeners?.size === 0) containerDelegatedListeners.delete(entry.container);
-}
-function getDelegationContainer() {
-	if (typeof document !== "undefined") return document.body;
-	return null;
-}
-function attachDelegatedListener(container, element, eventName, handler, originalHandler, options, fresh = false) {
-	const existingStore = fresh ? void 0 : getDelegatedHandlerStore(element);
-	const hadHandler = existingStore instanceof Map ? existingStore.has(eventName) : existingStore?.eventName === eventName;
-	let containerListeners = containerDelegatedListeners.get(container);
-	if (!containerListeners) {
-		containerListeners = /* @__PURE__ */ new Map();
-		containerDelegatedListeners.set(container, containerListeners);
-	}
-	let containerListener = containerListeners.get(eventName);
-	if (!containerListener) {
-		const delegatedHandler = (e) => {
-			const target = e.target;
-			if (!target) return;
-			runRuntimeHandlerScope(() => {
-				let current = target;
-				while (current && current !== container) {
-					const store = getDelegatedHandlerStore(current);
-					const entry = !store ? void 0 : store instanceof Map ? store.get(eventName) : store.eventName === eventName ? store : void 0;
-					if (entry) try {
-						entry.handler(e);
-					} catch (error) {
-						logger.error("[Askr] Delegated event error:", error);
-					}
-					if (e.cancelBubble) break;
-					current = current.parentElement;
-				}
-			}, "sync");
-		};
-		const listenerOptions = getPassiveOptions(eventName) ?? options;
-		container.addEventListener(eventName, delegatedHandler, listenerOptions);
-		containerListener = {
-			handler: delegatedHandler,
-			usage: 0
-		};
-		containerListeners.set(eventName, containerListener);
-	}
-	setDelegatedHandlerForElement(element, {
-		handler,
-		original: originalHandler,
-		container,
-		eventName,
-		options
-	}, existingStore);
-	if (!hadHandler) containerListener.usage += 1;
-}
-function setDelegatedHandlerForElement(element, entry, existing = getDelegatedHandlerStore(element)) {
-	if (!existing) {
-		setDelegatedHandlerStore(element, entry);
-		return;
-	}
-	if (existing instanceof Map) {
-		existing.set(entry.eventName, entry);
-		return;
-	}
-	if (existing.eventName === entry.eventName) {
-		setDelegatedHandlerStore(element, entry);
-		return;
-	}
-	const next = /* @__PURE__ */ new Map();
-	next.set(existing.eventName, existing);
-	next.set(entry.eventName, entry);
-	setDelegatedHandlerStore(element, next);
-}
-function getPassiveOptions(eventName) {
-	if (eventName === "wheel" || eventName === "scroll" || eventName.startsWith("touch")) return { passive: true };
-}
-function addDelegatedListener(element, eventName, handler, originalHandler, options) {
-	const container = getDelegationContainer();
-	if (!container) return;
-	attachDelegatedListener(container, element, eventName, handler, originalHandler, options);
-}
-/** @internal Attach a delegated handler to a newly cloned element. */
-function addFreshDelegatedListener(element, eventName, handler, originalHandler, options) {
-	const container = getDelegationContainer();
-	if (!container) return;
-	attachDelegatedListener(container, element, eventName, handler, originalHandler, options, true);
-}
-function updateDelegatedListener(element, eventName, handler, originalHandler, options) {
-	const existing = getDelegatedHandlerForElement(element, eventName);
-	if (!existing) return false;
-	const container = getDelegationContainer();
-	if (!container || existing.container !== container || !containerDelegatedListeners.get(existing.container)?.has(eventName)) {
-		removeDelegatedListener(element, eventName);
-		return false;
-	}
-	existing.handler = handler;
-	existing.original = originalHandler;
-	existing.options = options;
-	return true;
-}
-function removeDelegatedListener(element, eventName) {
-	const existing = getDelegatedHandlerStore(element);
-	if (!existing) return;
-	if (existing instanceof Map) {
-		if (existing.has(eventName)) decrementContainerListenerUsage(existing.get(eventName));
-		existing.delete(eventName);
-		if (existing.size === 0) {
-			deleteDelegatedHandlerStore(element);
-			return;
-		}
-		if (existing.size === 1) {
-			const only = existing.values().next().value;
-			setDelegatedHandlerStore(element, only);
-		}
-		return;
-	}
-	if (existing.eventName === eventName) {
-		decrementContainerListenerUsage(existing);
-		deleteDelegatedHandlerStore(element);
-	}
-}
-function getDelegatedHandlerForElement(element, eventName) {
-	const store = getDelegatedHandlerStore(element);
-	if (!store) return void 0;
-	if (store instanceof Map) return store.get(eventName);
-	return store.eventName === eventName ? store : void 0;
-}
-function getDelegatedHandlersForElement(element) {
-	const store = getDelegatedHandlerStore(element);
-	if (!store) return void 0;
-	if (store instanceof Map) return store;
-	return /* @__PURE__ */ new Map([[store.eventName, store]]);
-}
-function clearDelegatedHandlersForElement(element) {
-	const existing = getDelegatedHandlerStore(element);
-	if (existing instanceof Map) for (const entry of existing.values()) decrementContainerListenerUsage(entry);
-	else if (existing) decrementContainerListenerUsage(existing);
-	deleteDelegatedHandlerStore(element);
-}
-function isDelegatedEvent(eventName) {
-	return DELEGATED_EVENTS.includes(eventName);
-}
-//#endregion
-export { addDelegatedListener, addFreshDelegatedListener, clearDelegatedHandlersForElement, getDelegatedHandlerForElement, getDelegatedHandlersForElement, isDelegatedEvent, isEventDelegationEnabled, removeDelegatedListener, updateDelegatedListener };

package/dist/runtime/execution-model.d.ts

@@ -1,6 +0,0 @@
-//#region src/runtime/execution-model.d.ts
-type ExecutionModel = 'spa' | 'islands' | 'ssr';
-declare function getExecutionModel(): ExecutionModel | undefined;
-declare function assertExecutionModel(model: ExecutionModel): void;
-//#endregion
-export { ExecutionModel };

package/dist/runtime/execution-model.js

@@ -1,13 +0,0 @@
-//#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
-export { assertExecutionModel, getExecutionModel };

package/dist/runtime/fastlane.d.ts

@@ -1,33 +0,0 @@
-import { ComponentInstance } from "./component-internal.js";
-//#region src/runtime/fastlane.d.ts
-declare function enterBulkCommit(): void;
-declare function exitBulkCommit(): void;
-declare function isBulkCommitActive(): boolean;
-declare function markFastPathApplied(parent: Element): void;
-declare function isFastPathApplied(parent: Element): boolean;
-declare function classifyUpdate(instance: ComponentInstance, result: unknown): {
-  useFastPath: boolean;
-  reason: string;
-} | {
-  useFastPath: boolean;
-  reason: string;
-  totalKeyed: number;
-  totalChildren: number;
-  currentKeyCount: number;
-  moveCount: number;
-  lisLen: number;
-  hasPropChanges: boolean;
-  isWholeKeyedList: boolean;
-} | {
-  readonly useFastPath: true;
-  readonly totalKeyed: number;
-  readonly totalChildren: number;
-  readonly currentKeyCount: number;
-  readonly moveCount: number;
-  readonly lisLen: number;
-  readonly hasPropChanges: boolean;
-  readonly isWholeKeyedList: boolean;
-  reason?: undefined;
-};
-declare function commitReorderOnly(instance: ComponentInstance, result: unknown): boolean;
-declare function tryRuntimeFastLaneSync(instance: ComponentInstance, result: unknown): boolean;