@askrjs/askr 0.0.51 → 0.0.53

package/dist/runtime/effect.js

@@ -1,177 +0,0 @@
-import { enqueueRuntimeLane } from "./access.js";
-import { withFineGrainedReadTracking } from "./readable.js";
-import { incDevCounter } from "./dev-namespace.js";
-//#region src/runtime/effect.ts
-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 registerEffectSource(source, effect) {
-	let effects = effectSources.get(source);
-	if (!effects) {
-		effects = /* @__PURE__ */ new Set();
-		effectSources.set(source, effects);
-	}
-	effects.add(effect);
-}
-function unregisterEffectSource(source, effect) {
-	effectSources.get(source)?.delete(effect);
-}
-function clearEffectSubscriptions(effect) {
-	for (const source of effect.readSources) unregisterEffectSource(source, effect);
-	effect.readSources.clear();
-}
-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;
-	}
-	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) {
-	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);
-	effect.readSources = nextSources;
-}
-function commitEffectResult(effect, value, nextSources) {
-	const previousValue = effect.lastValue;
-	if (!effect.hasValue || !effect.equals(previousValue, value)) effect.commit(value, effect.hasValue ? previousValue : void 0);
-	commitEffectSubscriptions(effect, nextSources);
-	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 {
-			const { value, nextSources } = evaluateEffect(effect);
-			commitEffectResult(effect, value, nextSources);
-		} 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) {
-	const { value, nextSources } = evaluateEffect(effect);
-	commitEffectResult(effect, value, nextSources);
-}
-function markFineGrainedEffectsDirtySource(source) {
-	const effects = effectSources.get(source);
-	if (!effects || effects.size === 0) return;
-	dirtyLaneState.derived = false;
-	dirtyLaneState.component = false;
-	dirtyLaneState.reactive = false;
-	dirtyLaneState.post = false;
-	for (const effect of effects) {
-		if (!effect.isActive) continue;
-		const lane = effect.lane;
-		dirtyEffectsByLane[lane].add(effect);
-		dirtyLaneState[lane] = true;
-	}
-	if (dirtyLaneState.derived) scheduleLaneFlush("derived");
-	if (dirtyLaneState.component) scheduleLaneFlush("component");
-	if (dirtyLaneState.reactive) scheduleLaneFlush("reactive");
-	if (dirtyLaneState.post) scheduleLaneFlush("post");
-}
-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
-	};
-	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);
-		}
-	};
-}
-//#endregion
-export { createFineGrainedEffect, markFineGrainedEffectsDirtySource };
-
-//# sourceMappingURL=effect.js.map

package/dist/runtime/effect.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"effect.js","names":[],"sources":["../../src/runtime/effect.ts"],"sourcesContent":["import { incDevCounter } from './dev-namespace';\nimport { type ReadableSource, withFineGrainedReadTracking } from './readable';\nimport { enqueueRuntimeLane } from './access';\nimport type { SchedulerLane } from './scheduler';\n\ntype EffectRegistry = WeakMap<\n  ReadableSource<unknown>,\n  Set<FineGrainedEffect<unknown>>\n>;\n\ntype EffectFlushSets = Record<SchedulerLane, Set<FineGrainedEffect<unknown>>>;\n\ntype EffectPendingFlushState = Record<SchedulerLane, boolean>;\ntype EffectLaneDirtyState = Record<SchedulerLane, boolean>;\n\nconst effectSources: EffectRegistry = new WeakMap();\nconst dirtyEffectsByLane: EffectFlushSets = {\n  derived: new Set(),\n  component: new Set(),\n  reactive: new Set(),\n  post: new Set(),\n};\nconst hasPendingLaneFlush: EffectPendingFlushState = {\n  derived: false,\n  component: false,\n  reactive: false,\n  post: false,\n};\n\nconst dirtyLaneState: EffectLaneDirtyState = {\n  derived: false,\n  component: false,\n  reactive: false,\n  post: false,\n};\n\nconst MAX_EFFECT_RUNS_PER_FLUSH = 50;\nconst LANE_FLUSH_TASKS: Record<SchedulerLane, () => void> = {\n  derived: () => flushLaneEffects('derived'),\n  component: () => flushLaneEffects('component'),\n  reactive: () => flushLaneEffects('reactive'),\n  post: () => flushLaneEffects('post'),\n};\n\nexport interface FineGrainedEffect<T> {\n  lane: SchedulerLane;\n  compute(): T;\n  commit(value: T, previousValue: T | undefined): void;\n  equals(previousValue: T, nextValue: T): boolean;\n  readSources: Set<ReadableSource<unknown>>;\n  isActive: boolean;\n  hasValue: boolean;\n  lastValue: T | undefined;\n  onError?(error: unknown): void;\n}\n\nexport interface FineGrainedEffectHandle<T> {\n  cleanup(): void;\n  updateCompute(nextCompute: () => T): void;\n  flush(): void;\n}\n\nexport interface CreateFineGrainedEffectOptions<T> {\n  lane: SchedulerLane;\n  compute: () => T;\n  commit: (value: T, previousValue: T | undefined) => void;\n  equals?: (previousValue: T, nextValue: T) => boolean;\n  onError?: (error: unknown) => void;\n}\n\nfunction registerEffectSource(\n  source: ReadableSource<unknown>,\n  effect: FineGrainedEffect<unknown>\n): void {\n  let effects = effectSources.get(source);\n  if (!effects) {\n    effects = new Set();\n    effectSources.set(source, effects);\n  }\n  effects.add(effect);\n}\n\nfunction unregisterEffectSource(\n  source: ReadableSource<unknown>,\n  effect: FineGrainedEffect<unknown>\n): void {\n  effectSources.get(source)?.delete(effect);\n}\n\nfunction clearEffectSubscriptions(effect: FineGrainedEffect<unknown>): void {\n  for (const source of effect.readSources) {\n    unregisterEffectSource(source, effect);\n  }\n  effect.readSources.clear();\n}\n\nfunction normalizeNextSources(\n  previousSources: Set<ReadableSource<unknown>>,\n  pendingSources: Set<ReadableSource<unknown>>\n): Set<ReadableSource<unknown>> {\n  if (previousSources.size === pendingSources.size) {\n    let same = true;\n    for (const source of previousSources) {\n      if (!pendingSources.has(source)) {\n        same = false;\n        break;\n      }\n    }\n\n    if (same) {\n      return previousSources;\n    }\n  }\n\n  return new Set(pendingSources);\n}\n\nfunction evaluateEffect<T>(effect: FineGrainedEffect<T>): {\n  value: T;\n  nextSources: Set<ReadableSource<unknown>>;\n} {\n  const pendingSources = new Set<ReadableSource<unknown>>();\n\n  incDevCounter('effectRuns');\n  const value = withFineGrainedReadTracking(pendingSources, () =>\n    effect.compute()\n  );\n  const nextSources = normalizeNextSources(effect.readSources, pendingSources);\n  return { value, nextSources };\n}\n\nfunction commitEffectSubscriptions(\n  effect: FineGrainedEffect<unknown>,\n  nextSources: Set<ReadableSource<unknown>>\n): void {\n  const previousSources = effect.readSources;\n\n  if (previousSources === nextSources) {\n    return;\n  }\n\n  for (const source of previousSources) {\n    if (!nextSources.has(source)) {\n      unregisterEffectSource(source, effect);\n    }\n  }\n\n  for (const source of nextSources) {\n    if (!previousSources.has(source)) {\n      registerEffectSource(source, effect);\n    }\n  }\n\n  effect.readSources = nextSources;\n}\n\nfunction commitEffectResult<T>(\n  effect: FineGrainedEffect<T>,\n  value: T,\n  nextSources: Set<ReadableSource<unknown>>\n): void {\n  const previousValue = effect.lastValue;\n  const shouldCommit =\n    !effect.hasValue || !effect.equals(previousValue as T, value);\n\n  if (shouldCommit) {\n    effect.commit(value, effect.hasValue ? previousValue : undefined);\n  }\n\n  commitEffectSubscriptions(effect, nextSources);\n  effect.lastValue = value;\n  effect.hasValue = true;\n}\n\nfunction flushLaneEffects(lane: SchedulerLane): void {\n  hasPendingLaneFlush[lane] = false;\n\n  const effects = dirtyEffectsByLane[lane];\n  if (effects.size === 0) {\n    return;\n  }\n\n  const pending = effects.values();\n  const effectRuns = new Map<FineGrainedEffect<unknown>, number>();\n  let next = pending.next();\n\n  while (!next.done) {\n    const effect = next.value as FineGrainedEffect<unknown>;\n    effects.delete(effect);\n    if (!effect.isActive) {\n      next = pending.next();\n      continue;\n    }\n\n    const runCount = (effectRuns.get(effect) ?? 0) + 1;\n    effectRuns.set(effect, runCount);\n    if (runCount > MAX_EFFECT_RUNS_PER_FLUSH) {\n      const error = new Error(\n        `[Askr] fine-grained effect exceeded ${MAX_EFFECT_RUNS_PER_FLUSH} runs in one flush. Likely reactive cycle.`\n      );\n      if (effect.onError) {\n        effect.onError(error);\n      } else {\n        throw error;\n      }\n      next = pending.next();\n      continue;\n    }\n\n    try {\n      const { value, nextSources } = evaluateEffect(effect);\n      commitEffectResult(effect, value, nextSources);\n    } catch (error) {\n      effect.onError?.(error);\n    }\n\n    next = pending.next();\n  }\n}\n\nfunction scheduleLaneFlush(lane: SchedulerLane): void {\n  if (hasPendingLaneFlush[lane]) {\n    return;\n  }\n\n  hasPendingLaneFlush[lane] = true;\n  enqueueRuntimeLane(lane, LANE_FLUSH_TASKS[lane]);\n}\n\nfunction unscheduleEffect(effect: FineGrainedEffect<unknown>): void {\n  dirtyEffectsByLane[effect.lane].delete(effect);\n}\n\nfunction recomputeEffectNow<T>(effect: FineGrainedEffect<T>): void {\n  const { value, nextSources } = evaluateEffect(effect);\n  commitEffectResult(effect, value, nextSources);\n}\n\nexport function markFineGrainedEffectsDirtySource(\n  source: ReadableSource<unknown>\n): void {\n  const effects = effectSources.get(source);\n  if (!effects || effects.size === 0) {\n    return;\n  }\n\n  dirtyLaneState.derived = false;\n  dirtyLaneState.component = false;\n  dirtyLaneState.reactive = false;\n  dirtyLaneState.post = false;\n\n  for (const effect of effects) {\n    if (!effect.isActive) {\n      continue;\n    }\n    const lane = effect.lane;\n    dirtyEffectsByLane[lane].add(effect);\n    dirtyLaneState[lane] = true;\n  }\n\n  if (dirtyLaneState.derived) {\n    scheduleLaneFlush('derived');\n  }\n  if (dirtyLaneState.component) {\n    scheduleLaneFlush('component');\n  }\n  if (dirtyLaneState.reactive) {\n    scheduleLaneFlush('reactive');\n  }\n  if (dirtyLaneState.post) {\n    scheduleLaneFlush('post');\n  }\n}\n\nexport function createFineGrainedEffect<T>(\n  options: CreateFineGrainedEffectOptions<T>\n): FineGrainedEffectHandle<T> {\n  const effect: FineGrainedEffect<T> = {\n    lane: options.lane,\n    compute: options.compute,\n    commit: options.commit,\n    equals: options.equals ?? Object.is,\n    readSources: new Set(),\n    isActive: true,\n    hasValue: false,\n    lastValue: undefined,\n    onError: options.onError,\n  };\n\n  recomputeEffectNow(effect);\n\n  return {\n    cleanup(): void {\n      if (!effect.isActive) {\n        return;\n      }\n\n      effect.isActive = false;\n      unscheduleEffect(effect);\n      clearEffectSubscriptions(effect);\n    },\n\n    updateCompute(nextCompute: () => T): void {\n      if (!effect.isActive) {\n        return;\n      }\n\n      effect.compute = nextCompute;\n      unscheduleEffect(effect);\n      recomputeEffectNow(effect);\n    },\n\n    flush(): void {\n      if (!effect.isActive) {\n        return;\n      }\n\n      unscheduleEffect(effect);\n      recomputeEffectNow(effect);\n    },\n  };\n}\n"],"mappings":"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"}

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

@@ -1,5 +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;
-//# sourceMappingURL=error-boundary.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"error-boundary.d.ts","names":[],"sources":["../../src/runtime/error-boundary.ts"],"mappings":";;iBAGgB,mBAAA,CAAoB,QAA2B,EAAjB,iBAAiB;AAAA,iBAc/C,mBAAA,CACd,QAAA,EAAU,iBAAiB,EAC3B,KAAA,WACA,OAAA,IAAW,KAAA"}

package/dist/runtime/error-boundary.js

@@ -1,31 +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 };
-
-//# sourceMappingURL=error-boundary.js.map

package/dist/runtime/error-boundary.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"error-boundary.js","names":[],"sources":["../../src/runtime/error-boundary.ts"],"sourcesContent":["import { logger } from '../common/logger';\nimport type { ComponentInstance } from './component';\n\nexport function createBoundaryReset(instance: ComponentInstance): () => void {\n  return () => {\n    const boundaryState = instance.errorBoundaryState;\n    if (!boundaryState) {\n      return;\n    }\n    boundaryState.error = null;\n    boundaryState.notified = false;\n    queueMicrotask(() => {\n      instance._enqueueRun?.();\n    });\n  };\n}\n\nexport function reportBoundaryError(\n  instance: ComponentInstance,\n  error: unknown,\n  onError?: (error: unknown) => void\n): void {\n  const boundaryState = instance.errorBoundaryState;\n  if (\n    boundaryState &&\n    Object.is(boundaryState.error, error) &&\n    boundaryState.notified\n  ) {\n    return;\n  }\n\n  if (boundaryState) {\n    boundaryState.error = error;\n    boundaryState.notified = true;\n  }\n\n  try {\n    onError?.(error);\n  } catch (hookError) {\n    logger.error('[Askr] ErrorBoundary onError handler threw:', hookError);\n  }\n\n  logger.error('[Askr] ErrorBoundary caught render error:', error);\n}\n"],"mappings":";;AAGA,SAAgB,oBAAoB,UAAyC;CAC3E,aAAa;EACX,MAAM,gBAAgB,SAAS;EAC/B,IAAI,CAAC,eACH;EAEF,cAAc,QAAQ;EACtB,cAAc,WAAW;EACzB,qBAAqB;GACnB,SAAS,cAAc;EACzB,CAAC;CACH;AACF;AAEA,SAAgB,oBACd,UACA,OACA,SACM;CACN,MAAM,gBAAgB,SAAS;CAC/B,IACE,iBACA,OAAO,GAAG,cAAc,OAAO,KAAK,KACpC,cAAc,UAEd;CAGF,IAAI,eAAe;EACjB,cAAc,QAAQ;EACtB,cAAc,WAAW;CAC3B;CAEA,IAAI;EACF,UAAU,KAAK;CACjB,SAAS,WAAW;EAClB,OAAO,MAAM,+CAA+C,SAAS;CACvE;CAEA,OAAO,MAAM,6CAA6C,KAAK;AACjE"}

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;
-  element: Element;
-  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;
-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 };
-//# sourceMappingURL=events.d.ts.map

package/dist/runtime/events.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"events.d.ts","names":[],"sources":["../../src/runtime/events.ts"],"mappings":";;AAgBA;;;;;;;;;UAAiB,iBAAA;EACf,KAAA,EAAO,UAAA;EACP,QAAA,EAAU,UAAA;EACV,SAAA,EAAW,UAAA;EACX,OAAA,EAAS,UAAA;EACT,SAAA,EAAW,UAAA;EACX,QAAA,EAAU,UAAA;EACV,SAAA,EAAW,UAAA;EACX,KAAA,EAAO,UAAA;EACP,IAAA,EAAM,UAAA;EACN,KAAA,EAAO,UAAA;EACP,MAAA,EAAQ,KAAA;EACR,OAAA,EAAS,aAAA;EACT,KAAA,EAAO,aAAA;EACP,QAAA,EAAU,aAAA;EACV,MAAA,EAAQ,KAAA;EACR,MAAA,EAAQ,KAAA;EACR,KAAA,EAAO,UAAA;EACP,UAAA,EAAY,UAAA;EACZ,QAAA,EAAU,UAAA;EACV,SAAA,EAAW,UAAA;EACX,WAAA,EAAa,UAAA;AAAA;AAAA,UA2BL,gBAAA;EACR,OAAA,EAAS,aAAA;EACT,QAAA,EAAU,aAAA;EACV,OAAA,EAAS,OAAA;EACT,SAAA,EAAW,OAAA;EACX,SAAA;EACA,OAAA,GAAU,uBAAA;AAAA;AAAA,iBAgBI,wBAAA;AAAA,iBAIA,sBAAA;AAAA,iBAKA,qBAAA,CAAsB,SAAmB,GAAP,OAAO;AAAA,iBAOzC,4BAAA,CAA6B,SAAkB,EAAP,OAAO;AAAA,iBAyK/C,oBAAA,CACd,OAAA,EAAS,OAAA,EACT,SAAA,UACA,OAAA,EAAS,aAAA,EACT,eAAA,EAAiB,aAAA,EACjB,OAAA,GAAU,uBAAA;AAAA,iBAmBI,uBAAA,CACd,OAAA,EAAS,OAAA,EACT,SAAA,UACA,OAAA,EAAS,aAAA,EACT,eAAA,EAAiB,aAAA,EACjB,OAAA,GAAU,uBAAA;AAAA,iBAuBI,uBAAA,CACd,OAAA,EAAS,OAAO,EAChB,SAAA;AAAA,iBA+Bc,6BAAA,CACd,OAAA,EAAS,OAAA,EACT,SAAA,WACC,gBAAgB;AAAA,iBAOH,8BAAA,CACd,OAAA,EAAS,OAAA,GACR,GAAA,SAAY,gBAAA;AAAA,iBAOC,mBAAA,CACd,OAAA,EAAS,OAAO,EAChB,SAAA;AAAA,iBAKc,gCAAA,CAAiC,OAAgB,EAAP,OAAO;AAAA,iBAYjD,sBAAA,oBAA0C,iBAAiB;AAAA,iBAI3D,gBAAA,CAAiB,SAAiB"}

package/dist/runtime/events.js

@@ -1,204 +0,0 @@
-import { logger } from "../common/logger.js";
-import { incrementPerfMetric } from "./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.
-*/
-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 delegatedHandlers = /* @__PURE__ */ new WeakMap();
-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 (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)) {
-		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 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);
-		containerListeners.set(eventName, delegatedHandler);
-	}
-	setDelegatedHandlerForElement(element, {
-		handler,
-		original: originalHandler,
-		element,
-		container,
-		eventName,
-		options
-	});
-	if (!hadHandler) incrementContainerListenerUsage(container, eventName);
-}
-function setDelegatedHandlerForElement(element, entry) {
-	const existing = delegatedHandlers.get(element);
-	if (!existing) {
-		delegatedHandlers.set(element, entry);
-		return;
-	}
-	if (existing instanceof Map) {
-		existing.set(entry.eventName, entry);
-		return;
-	}
-	if (existing.eventName === entry.eventName) {
-		delegatedHandlers.set(element, entry);
-		return;
-	}
-	const next = /* @__PURE__ */ new Map();
-	next.set(existing.eventName, existing);
-	next.set(entry.eventName, entry);
-	delegatedHandlers.set(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;
-	incDevCounter("listenerAdds");
-	attachDelegatedListener(container, element, eventName, handler, originalHandler, options);
-}
-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 = delegatedHandlers.get(element);
-	if (!existing) return;
-	if (existing instanceof Map) {
-		if (existing.has(eventName)) {
-			incDevCounter("listenerRemoves");
-			decrementContainerListenerUsage(existing.get(eventName));
-		}
-		existing.delete(eventName);
-		if (existing.size === 0) {
-			delegatedHandlers.delete(element);
-			return;
-		}
-		if (existing.size === 1) {
-			const only = existing.values().next().value;
-			delegatedHandlers.set(element, only);
-		}
-		return;
-	}
-	if (existing.eventName === eventName) {
-		incDevCounter("listenerRemoves");
-		decrementContainerListenerUsage(existing);
-		delegatedHandlers.delete(element);
-	}
-}
-function getDelegatedHandlerForElement(element, eventName) {
-	const store = delegatedHandlers.get(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);
-	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);
-	if (existing instanceof Map) for (const entry of existing.values()) decrementContainerListenerUsage(entry);
-	else if (existing) decrementContainerListenerUsage(existing);
-	delegatedHandlers.delete(element);
-}
-function isDelegatedEvent(eventName) {
-	return DELEGATED_EVENTS.includes(eventName);
-}
-//#endregion
-export { addDelegatedListener, clearDelegatedHandlersForElement, getDelegatedHandlerForElement, getDelegatedHandlersForElement, isDelegatedEvent, isEventDelegationEnabled, removeDelegatedListener, updateDelegatedListener };
-
-//# sourceMappingURL=events.js.map

package/dist/runtime/events.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"events.js","names":[],"sources":["../../src/runtime/events.ts"],"sourcesContent":["/**\n * Event delegation system for Askr\n *\n * Provides efficient event handling by attaching listeners to a container\n * instead of individual elements. This significantly reduces memory usage\n * and improves performance when many elements have the same event type.\n *\n * Delegated handling is enabled by default. Tests and internal runtime code\n * can still disable or re-enable it when they need to exercise both modes.\n */\n\nimport { runRuntimeHandlerScope } from './access';\nimport { logger } from '../common/logger';\nimport { incrementPerfMetric } from './perf-metrics';\nimport { incDevCounter } from './dev-namespace';\n\nexport interface DelegatedEventMap {\n  click: MouseEvent;\n  dblclick: MouseEvent;\n  mousedown: MouseEvent;\n  mouseup: MouseEvent;\n  mouseover: MouseEvent;\n  mouseout: MouseEvent;\n  mousemove: MouseEvent;\n  focus: FocusEvent;\n  blur: FocusEvent;\n  input: InputEvent;\n  change: Event;\n  keydown: KeyboardEvent;\n  keyup: KeyboardEvent;\n  keypress: KeyboardEvent;\n  submit: Event;\n  scroll: Event;\n  wheel: WheelEvent;\n  touchstart: TouchEvent;\n  touchend: TouchEvent;\n  touchmove: TouchEvent;\n  touchcancel: TouchEvent;\n}\n\nconst DELEGATED_EVENTS: (keyof DelegatedEventMap)[] = [\n  'click',\n  'dblclick',\n  'mousedown',\n  'mouseup',\n  'mouseover',\n  'mouseout',\n  'mousemove',\n  'focus',\n  'blur',\n  'input',\n  'change',\n  'keydown',\n  'keyup',\n  'keypress',\n  'submit',\n  'scroll',\n  'wheel',\n  'touchstart',\n  'touchend',\n  'touchmove',\n  'touchcancel',\n];\n\ninterface DelegatedHandler {\n  handler: EventListener;\n  original: EventListener;\n  element: Element;\n  container: Element;\n  eventName: string;\n  options?: AddEventListenerOptions;\n}\n\ntype DelegatedHandlerStore = DelegatedHandler | Map<string, DelegatedHandler>;\n\nconst delegatedHandlers = new WeakMap<Element, DelegatedHandlerStore>();\n\nlet eventDelegationEnabled = true;\nlet defaultContainer: Element | null = null;\nlet globalDelegationContainer: Element | null = null;\nconst containerDelegatedListeners = new Map<\n  Element,\n  Map<string, EventListener>\n>();\nconst containerDelegatedListenerUsage = new Map<Element, Map<string, number>>();\n\nexport function isEventDelegationEnabled(): boolean {\n  return eventDelegationEnabled;\n}\n\nexport function disableEventDelegation(): void {\n  eventDelegationEnabled = false;\n  cleanupAllDelegatedListeners();\n}\n\nexport function enableEventDelegation(container?: Element): void {\n  eventDelegationEnabled = true;\n  if (container) {\n    defaultContainer = container;\n  }\n}\n\nexport function setGlobalDelegationContainer(container: Element): void {\n  globalDelegationContainer = container;\n}\n\nfunction cleanupAllDelegatedListeners(): void {\n  for (const [container, listeners] of containerDelegatedListeners) {\n    for (const [eventName, handler] of listeners) {\n      container.removeEventListener(eventName, handler);\n    }\n  }\n  containerDelegatedListeners.clear();\n  containerDelegatedListenerUsage.clear();\n}\n\nfunction incrementContainerListenerUsage(\n  container: Element,\n  eventName: string\n): void {\n  let usage = containerDelegatedListenerUsage.get(container);\n  if (!usage) {\n    usage = new Map();\n    containerDelegatedListenerUsage.set(container, usage);\n  }\n  usage.set(eventName, (usage.get(eventName) ?? 0) + 1);\n}\n\nfunction decrementContainerListenerUsage(entry: DelegatedHandler): void {\n  const usage = containerDelegatedListenerUsage.get(entry.container);\n  if (!usage) {\n    return;\n  }\n\n  const nextCount = (usage.get(entry.eventName) ?? 0) - 1;\n  if (nextCount > 0) {\n    usage.set(entry.eventName, nextCount);\n    return;\n  }\n\n  usage.delete(entry.eventName);\n  const listeners = containerDelegatedListeners.get(entry.container);\n  const listener = listeners?.get(entry.eventName);\n  if (listener) {\n    entry.container.removeEventListener(entry.eventName, listener);\n    listeners?.delete(entry.eventName);\n  }\n\n  if (listeners?.size === 0) {\n    containerDelegatedListeners.delete(entry.container);\n  }\n  if (usage.size === 0) {\n    containerDelegatedListenerUsage.delete(entry.container);\n  }\n}\n\nfunction getDelegationContainer(): Element | null {\n  if (globalDelegationContainer) return globalDelegationContainer;\n  if (defaultContainer) return defaultContainer;\n  if (typeof document !== 'undefined') return document.body;\n  return null;\n}\n\nfunction attachDelegatedListener(\n  container: Element,\n  element: Element,\n  eventName: string,\n  handler: EventListener,\n  originalHandler: EventListener,\n  options?: AddEventListenerOptions\n): void {\n  const hadHandler = !!getDelegatedHandlerForElement(element, eventName);\n\n  if (!containerDelegatedListeners.has(container)) {\n    containerDelegatedListeners.set(container, new Map());\n  }\n  const containerListeners = containerDelegatedListeners.get(container)!;\n\n  if (!containerListeners.has(eventName)) {\n    const delegatedHandler = (e: Event) => {\n      const target = e.target as Element;\n      if (!target) return;\n\n      runRuntimeHandlerScope(() => {\n        let current: Element | null = target;\n        while (current && current !== container) {\n          incrementPerfMetric('delegatedAncestorHops');\n          const store = delegatedHandlers.get(current);\n          const entry = !store\n            ? undefined\n            : store instanceof Map\n              ? store.get(eventName)\n              : store.eventName === eventName\n                ? store\n                : undefined;\n          if (entry) {\n            try {\n              entry.handler(e);\n            } catch (error) {\n              logger.error('[Askr] Delegated event error:', error);\n            }\n          }\n\n          if (e.cancelBubble) {\n            break;\n          }\n\n          current = current.parentElement;\n        }\n      }, 'sync');\n    };\n\n    const passiveOptions = getPassiveOptions(eventName);\n    const listenerOptions = passiveOptions ?? options;\n\n    container.addEventListener(eventName, delegatedHandler, listenerOptions);\n    containerListeners.set(eventName, delegatedHandler);\n  }\n\n  setDelegatedHandlerForElement(element, {\n    handler,\n    original: originalHandler,\n    element,\n    container,\n    eventName,\n    options,\n  });\n  if (!hadHandler) {\n    incrementContainerListenerUsage(container, eventName);\n  }\n}\n\nfunction setDelegatedHandlerForElement(\n  element: Element,\n  entry: DelegatedHandler\n): void {\n  const existing = delegatedHandlers.get(element);\n  if (!existing) {\n    delegatedHandlers.set(element, entry);\n    return;\n  }\n\n  if (existing instanceof Map) {\n    existing.set(entry.eventName, entry);\n    return;\n  }\n\n  if (existing.eventName === entry.eventName) {\n    delegatedHandlers.set(element, entry);\n    return;\n  }\n\n  const next = new Map<string, DelegatedHandler>();\n  next.set(existing.eventName, existing);\n  next.set(entry.eventName, entry);\n  delegatedHandlers.set(element, next);\n}\n\nfunction getPassiveOptions(\n  eventName: string\n): AddEventListenerOptions | undefined {\n  if (\n    eventName === 'wheel' ||\n    eventName === 'scroll' ||\n    eventName.startsWith('touch')\n  ) {\n    return { passive: true };\n  }\n  return undefined;\n}\n\nexport function addDelegatedListener(\n  element: Element,\n  eventName: string,\n  handler: EventListener,\n  originalHandler: EventListener,\n  options?: AddEventListenerOptions\n): void {\n  if (!eventDelegationEnabled) return;\n\n  const container = getDelegationContainer();\n  if (!container) return;\n\n  incDevCounter('listenerAdds');\n\n  attachDelegatedListener(\n    container,\n    element,\n    eventName,\n    handler,\n    originalHandler,\n    options\n  );\n}\n\nexport function updateDelegatedListener(\n  element: Element,\n  eventName: string,\n  handler: EventListener,\n  originalHandler: EventListener,\n  options?: AddEventListenerOptions\n): boolean {\n  const existing = getDelegatedHandlerForElement(element, eventName);\n  if (!existing) {\n    return false;\n  }\n\n  const container = getDelegationContainer();\n  if (\n    !container ||\n    existing.container !== container ||\n    !containerDelegatedListeners.get(existing.container)?.has(eventName)\n  ) {\n    removeDelegatedListener(element, eventName);\n    return false;\n  }\n\n  existing.handler = handler;\n  existing.original = originalHandler;\n  existing.options = options;\n  return true;\n}\n\nexport function removeDelegatedListener(\n  element: Element,\n  eventName: string\n): void {\n  const existing = delegatedHandlers.get(element);\n  if (!existing) {\n    return;\n  }\n\n  if (existing instanceof Map) {\n    if (existing.has(eventName)) {\n      incDevCounter('listenerRemoves');\n      decrementContainerListenerUsage(existing.get(eventName)!);\n    }\n    existing.delete(eventName);\n    if (existing.size === 0) {\n      delegatedHandlers.delete(element);\n      return;\n    }\n    if (existing.size === 1) {\n      const only = existing.values().next().value as DelegatedHandler;\n      delegatedHandlers.set(element, only);\n    }\n    return;\n  }\n\n  if (existing.eventName === eventName) {\n    incDevCounter('listenerRemoves');\n    decrementContainerListenerUsage(existing);\n    delegatedHandlers.delete(element);\n  }\n}\n\nexport function getDelegatedHandlerForElement(\n  element: Element,\n  eventName: string\n): DelegatedHandler | undefined {\n  const store = delegatedHandlers.get(element);\n  if (!store) return undefined;\n  if (store instanceof Map) return store.get(eventName);\n  return store.eventName === eventName ? store : undefined;\n}\n\nexport function getDelegatedHandlersForElement(\n  element: Element\n): Map<string, DelegatedHandler> | undefined {\n  const store = delegatedHandlers.get(element);\n  if (!store) return undefined;\n  if (store instanceof Map) return store;\n  return new Map([[store.eventName, store]]);\n}\n\nexport function hasDelegatedHandler(\n  element: Element,\n  eventName: string\n): boolean {\n  return getDelegatedHandlerForElement(element, eventName) !== undefined;\n}\n\nexport function clearDelegatedHandlersForElement(element: Element): void {\n  const existing = delegatedHandlers.get(element);\n  if (existing instanceof Map) {\n    for (const entry of existing.values()) {\n      decrementContainerListenerUsage(entry);\n    }\n  } else if (existing) {\n    decrementContainerListenerUsage(existing);\n  }\n  delegatedHandlers.delete(element);\n}\n\nexport function getDelegatedEventNames(): readonly (keyof DelegatedEventMap)[] {\n  return DELEGATED_EVENTS;\n}\n\nexport function isDelegatedEvent(eventName: string): boolean {\n  return DELEGATED_EVENTS.includes(eventName as keyof DelegatedEventMap);\n}\n"],"mappings":"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"}

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

@@ -1,7 +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 };
-//# sourceMappingURL=execution-model.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"execution-model.d.ts","names":[],"sources":["../../src/runtime/execution-model.ts"],"mappings":";KAAY,cAAA;AAAA,iBAII,iBAAA,IAAqB,cAAc;AAAA,iBAKnC,oBAAA,CAAqB,KAAqB,EAAd,cAAc"}

package/dist/runtime/execution-model.js

@@ -1,15 +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 };
-
-//# sourceMappingURL=execution-model.js.map

package/dist/runtime/execution-model.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"execution-model.js","names":[],"sources":["../../src/runtime/execution-model.ts"],"sourcesContent":["export type ExecutionModel = 'spa' | 'islands' | 'ssr';\n\nconst EXECUTION_MODEL_KEY = Symbol.for('__ASKR_EXECUTION_MODEL__');\n\nexport function getExecutionModel(): ExecutionModel | undefined {\n  const g = globalThis as unknown as Record<string | symbol, unknown>;\n  return g[EXECUTION_MODEL_KEY] as ExecutionModel | undefined;\n}\n\nexport function assertExecutionModel(model: ExecutionModel): void {\n  // Mixing execution models is forbidden: once an app starts in one model,\n  // attempting to start another is an invariant violation.\n  const g = globalThis as unknown as Record<string | symbol, unknown>;\n  const cur = g[EXECUTION_MODEL_KEY] as ExecutionModel | undefined;\n  if (cur && cur !== model) {\n    throw new Error(\n      `[Askr] mixing execution models is not allowed (current: ${cur}, attempted: ${model}). ` +\n        `Choose exactly one: createSPA, createSSR, or createIslands.`\n    );\n  }\n  if (!cur) g[EXECUTION_MODEL_KEY] = model;\n}\n"],"mappings":";AAEA,MAAM,sBAAsB,OAAO,IAAI,0BAA0B;AAEjE,SAAgB,oBAAgD;CAE9D,OAAO,WAAE;AACX;AAEA,SAAgB,qBAAqB,OAA6B;CAGhE,MAAM,IAAI;CACV,MAAM,MAAM,EAAE;CACd,IAAI,OAAO,QAAQ,OACjB,MAAM,IAAI,MACR,2DAA2D,IAAI,eAAe,MAAM,+DAEtF;CAEF,IAAI,CAAC,KAAK,EAAE,uBAAuB;AACrC"}

package/dist/runtime/fastlane.d.ts

@@ -1,34 +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;
-//# sourceMappingURL=fastlane.d.ts.map

package/dist/runtime/fastlane.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fastlane.d.ts","names":[],"sources":["../../src/runtime/fastlane.ts"],"mappings":";;iBAegB,eAAA;AAAA,iBAOA,cAAA;AAAA,iBAMA,kBAAA;AAAA,iBAMA,mBAAA,CAAoB,MAAe,EAAP,OAAO;AAAA,iBASnC,iBAAA,CAAkB,MAAe,EAAP,OAAO;AAAA,iBAgDjC,cAAA,CAAe,QAAA,EAAU,iBAAiB,EAAE,MAAA;;;;;;;;;;;;;;;;;;;;;;;;iBA2E5C,iBAAA,CACd,QAAA,EAAU,iBAAiB,EAC3B,MAAA;AAAA,iBAyGc,sBAAA,CACd,QAAA,EAAU,iBAAiB,EAC3B,MAAA"}