@askrjs/askr 0.0.50 → 0.0.52

package/dist/runtime/effect.js

@@ -1,7 +1,7 @@
 import { enqueueRuntimeLane } from "./access.js";
 import { withFineGrainedReadTracking } from "./readable.js";
-import { incDevCounter } from "./dev-namespace.js";
-//#region src/runtime/effect.ts
+import "./dev-namespace.js";
+const SOURCE_EFFECTS = Symbol("askr.source-effects");
 const effectSources = /* @__PURE__ */ new WeakMap();
 const dirtyEffectsByLane = {
 	derived: /* @__PURE__ */ new Set(),
@@ -28,51 +28,124 @@ const LANE_FLUSH_TASKS = {
 	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) {
-	let effects = effectSources.get(source);
-	if (!effects) {
-		effects = /* @__PURE__ */ new Set();
-		effectSources.set(source, effects);
+	const registered = getRegisteredEffects(source);
+	if (!registered) {
+		setRegisteredEffects(source, effect);
+		return;
+	}
+	if (registered instanceof Set) {
+		registered.add(effect);
+		return;
 	}
-	effects.add(effect);
+	if (registered === effect) return;
+	setRegisteredEffects(source, /* @__PURE__ */ new Set([registered, effect]));
 }
 function unregisterEffectSource(source, effect) {
-	effectSources.get(source)?.delete(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) {
-	for (const source of effect.readSources) unregisterEffectSource(source, effect);
-	effect.readSources.clear();
+	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 normalizeNextSources(previousSources, pendingSources) {
-	if (previousSources.size === pendingSources.size) {
-		let same = true;
-		for (const source of previousSources) if (!pendingSources.has(source)) {
-			same = false;
-			break;
-		}
-		if (same) return previousSources;
+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;
 	}
-	return new Set(pendingSources);
-}
-function evaluateEffect(effect) {
-	const pendingSources = /* @__PURE__ */ new Set();
-	incDevCounter("effectRuns");
-	return {
-		value: withFineGrainedReadTracking(pendingSources, () => effect.compute()),
-		nextSources: normalizeNextSources(effect.readSources, pendingSources)
-	};
 }
-function commitEffectSubscriptions(effect, nextSources) {
+function commitEffectSubscriptions(effect, nextSources, nextSource2) {
 	const previousSources = effect.readSources;
-	if (previousSources === nextSources) return;
-	for (const source of previousSources) if (!nextSources.has(source)) unregisterEffectSource(source, effect);
-	for (const source of nextSources) if (!previousSources.has(source)) registerEffectSource(source, effect);
+	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) {
+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);
+	commitEffectSubscriptions(effect, nextSources, nextSource2);
 	effect.lastValue = value;
 	effect.hasValue = true;
 }
@@ -100,8 +173,7 @@ function flushLaneEffects(lane) {
 			continue;
 		}
 		try {
-			const { value, nextSources } = evaluateEffect(effect);
-			commitEffectResult(effect, value, nextSources);
+			evaluateAndCommitEffect(effect);
 		} catch (error) {
 			effect.onError?.(error);
 		}
@@ -117,61 +189,72 @@ function unscheduleEffect(effect) {
 	dirtyEffectsByLane[effect.lane].delete(effect);
 }
 function recomputeEffectNow(effect) {
-	const { value, nextSources } = evaluateEffect(effect);
-	commitEffectResult(effect, value, nextSources);
+	evaluateAndCommitEffect(effect);
 }
 function markFineGrainedEffectsDirtySource(source) {
-	const effects = effectSources.get(source);
-	if (!effects || effects.size === 0) return;
+	const registered = getRegisteredEffects(source);
+	if (!registered) return;
 	dirtyLaneState.derived = false;
 	dirtyLaneState.component = false;
 	dirtyLaneState.reactive = false;
 	dirtyLaneState.post = false;
-	for (const effect of effects) {
-		if (!effect.isActive) continue;
+	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 = {
-		lane: options.lane,
-		compute: options.compute,
-		commit: options.commit,
-		equals: options.equals ?? Object.is,
-		readSources: /* @__PURE__ */ new Set(),
-		isActive: true,
-		hasValue: false,
-		lastValue: void 0,
-		onError: options.onError
-	};
+	const effect = new FineGrainedEffectImpl(options.lane, options.compute, options.commit, options.equals ?? Object.is, options.onError, options._owner);
 	recomputeEffectNow(effect);
-	return {
-		cleanup() {
-			if (!effect.isActive) return;
-			effect.isActive = false;
-			unscheduleEffect(effect);
-			clearEffectSubscriptions(effect);
-		},
-		updateCompute(nextCompute) {
-			if (!effect.isActive) return;
-			effect.compute = nextCompute;
-			unscheduleEffect(effect);
-			recomputeEffectNow(effect);
-		},
-		flush() {
-			if (!effect.isActive) return;
-			unscheduleEffect(effect);
-			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 { createFineGrainedEffect, markFineGrainedEffectsDirtySource };
-
-//# sourceMappingURL=effect.js.map
+export { createFineGrainedEffect, createOwnedFineGrainedEffect, markFineGrainedEffectsDirtySource };

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,58 @@
+//#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,18 +1,7 @@
-import { logger } from "../dev/logger.js";
-import { incrementPerfMetric } from "./perf-metrics.js";
+import { logger } from "../common/logger.js";
+import "./perf-metrics.js";
 import { runRuntimeHandlerScope } from "./access.js";
-import { incDevCounter } from "./dev-namespace.js";
-//#region src/runtime/events.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.
-*/
+import "./dev-namespace.js";
 const DELEGATED_EVENTS = [
 	"click",
 	"dblclick",
@@ -36,56 +25,63 @@ const DELEGATED_EVENTS = [
 	"touchmove",
 	"touchcancel"
 ];
-const delegatedHandlers = /* @__PURE__ */ new WeakMap();
+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();
-const containerDelegatedListenerUsage = /* @__PURE__ */ new Map();
 function isEventDelegationEnabled() {
 	return eventDelegationEnabled;
 }
-function incrementContainerListenerUsage(container, eventName) {
-	let usage = containerDelegatedListenerUsage.get(container);
-	if (!usage) {
-		usage = /* @__PURE__ */ new Map();
-		containerDelegatedListenerUsage.set(container, usage);
-	}
-	usage.set(eventName, (usage.get(eventName) ?? 0) + 1);
-}
 function decrementContainerListenerUsage(entry) {
-	const usage = containerDelegatedListenerUsage.get(entry.container);
-	if (!usage) return;
-	const nextCount = (usage.get(entry.eventName) ?? 0) - 1;
-	if (nextCount > 0) {
-		usage.set(entry.eventName, nextCount);
-		return;
-	}
-	usage.delete(entry.eventName);
 	const listeners = containerDelegatedListeners.get(entry.container);
 	const listener = listeners?.get(entry.eventName);
-	if (listener) {
-		entry.container.removeEventListener(entry.eventName, listener);
-		listeners?.delete(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);
-	if (usage.size === 0) containerDelegatedListenerUsage.delete(entry.container);
 }
 function getDelegationContainer() {
 	if (typeof document !== "undefined") return document.body;
 	return null;
 }
-function attachDelegatedListener(container, element, eventName, handler, originalHandler, options) {
-	const hadHandler = !!getDelegatedHandlerForElement(element, eventName);
-	if (!containerDelegatedListeners.has(container)) containerDelegatedListeners.set(container, /* @__PURE__ */ new Map());
-	const containerListeners = containerDelegatedListeners.get(container);
-	if (!containerListeners.has(eventName)) {
+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) {
-					incrementPerfMetric("delegatedAncestorHops");
-					const store = delegatedHandlers.get(current);
+					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);
@@ -99,22 +95,24 @@ function attachDelegatedListener(container, element, eventName, handler, origina
 		};
 		const listenerOptions = getPassiveOptions(eventName) ?? options;
 		container.addEventListener(eventName, delegatedHandler, listenerOptions);
-		containerListeners.set(eventName, delegatedHandler);
+		containerListener = {
+			handler: delegatedHandler,
+			usage: 0
+		};
+		containerListeners.set(eventName, containerListener);
 	}
 	setDelegatedHandlerForElement(element, {
 		handler,
 		original: originalHandler,
-		element,
 		container,
 		eventName,
 		options
-	});
-	if (!hadHandler) incrementContainerListenerUsage(container, eventName);
+	}, existingStore);
+	if (!hadHandler) containerListener.usage += 1;
 }
-function setDelegatedHandlerForElement(element, entry) {
-	const existing = delegatedHandlers.get(element);
+function setDelegatedHandlerForElement(element, entry, existing = getDelegatedHandlerStore(element)) {
 	if (!existing) {
-		delegatedHandlers.set(element, entry);
+		setDelegatedHandlerStore(element, entry);
 		return;
 	}
 	if (existing instanceof Map) {
@@ -122,13 +120,13 @@ function setDelegatedHandlerForElement(element, entry) {
 		return;
 	}
 	if (existing.eventName === entry.eventName) {
-		delegatedHandlers.set(element, entry);
+		setDelegatedHandlerStore(element, entry);
 		return;
 	}
 	const next = /* @__PURE__ */ new Map();
 	next.set(existing.eventName, existing);
 	next.set(entry.eventName, entry);
-	delegatedHandlers.set(element, next);
+	setDelegatedHandlerStore(element, next);
 }
 function getPassiveOptions(eventName) {
 	if (eventName === "wheel" || eventName === "scroll" || eventName.startsWith("touch")) return { passive: true };
@@ -136,9 +134,14 @@ function getPassiveOptions(eventName) {
 function addDelegatedListener(element, eventName, handler, originalHandler, options) {
 	const container = getDelegationContainer();
 	if (!container) return;
-	incDevCounter("listenerAdds");
 	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;
@@ -153,52 +156,46 @@ function updateDelegatedListener(element, eventName, handler, originalHandler, o
 	return true;
 }
 function removeDelegatedListener(element, eventName) {
-	const existing = delegatedHandlers.get(element);
+	const existing = getDelegatedHandlerStore(element);
 	if (!existing) return;
 	if (existing instanceof Map) {
-		if (existing.has(eventName)) {
-			incDevCounter("listenerRemoves");
-			decrementContainerListenerUsage(existing.get(eventName));
-		}
+		if (existing.has(eventName)) decrementContainerListenerUsage(existing.get(eventName));
 		existing.delete(eventName);
 		if (existing.size === 0) {
-			delegatedHandlers.delete(element);
+			deleteDelegatedHandlerStore(element);
 			return;
 		}
 		if (existing.size === 1) {
 			const only = existing.values().next().value;
-			delegatedHandlers.set(element, only);
+			setDelegatedHandlerStore(element, only);
 		}
 		return;
 	}
 	if (existing.eventName === eventName) {
-		incDevCounter("listenerRemoves");
 		decrementContainerListenerUsage(existing);
-		delegatedHandlers.delete(element);
+		deleteDelegatedHandlerStore(element);
 	}
 }
 function getDelegatedHandlerForElement(element, eventName) {
-	const store = delegatedHandlers.get(element);
+	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 = delegatedHandlers.get(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 = delegatedHandlers.get(element);
+	const existing = getDelegatedHandlerStore(element);
 	if (existing instanceof Map) for (const entry of existing.values()) decrementContainerListenerUsage(entry);
 	else if (existing) decrementContainerListenerUsage(existing);
-	delegatedHandlers.delete(element);
+	deleteDelegatedHandlerStore(element);
 }
 function isDelegatedEvent(eventName) {
 	return DELEGATED_EVENTS.includes(eventName);
 }
 //#endregion
-export { addDelegatedListener, clearDelegatedHandlersForElement, getDelegatedHandlerForElement, getDelegatedHandlersForElement, isDelegatedEvent, isEventDelegationEnabled, removeDelegatedListener, updateDelegatedListener };
-
-//# sourceMappingURL=events.js.map
+export { addDelegatedListener, addFreshDelegatedListener, clearDelegatedHandlersForElement, getDelegatedHandlerForElement, getDelegatedHandlersForElement, isDelegatedEvent, isEventDelegationEnabled, removeDelegatedListener, updateDelegatedListener };

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

@@ -0,0 +1,6 @@
+//#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

@@ -11,5 +11,3 @@ function assertExecutionModel(model) {
 }
 //#endregion
 export { assertExecutionModel, getExecutionModel };
-
-//# sourceMappingURL=execution-model.js.map

package/dist/runtime/fastlane.d.ts

@@ -0,0 +1,33 @@
+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;