@askrjs/askr 0.0.28 → 0.0.29

package/dist/runtime/dev-namespace.js

@@ -1 +1,57 @@
-function r(){return{}}function u(t,e){}function c(t){}function i(t){}function o(t){}export{i as deleteDevValue,r as getDevNamespace,c as getDevValue,o as incDevCounter,u as setDevValue};
+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.
+*/
+/**
+* Get or create the __ASKR__ dev namespace on globalThis.
+* Returns empty object in production to avoid allocations.
+*/
+function getDevNamespace() {
+	if (isProductionEnvironment()) return {};
+	try {
+		const g = globalThis;
+		if (!g.__ASKR__) g.__ASKR__ = {};
+		return g.__ASKR__;
+	} catch {
+		return {};
+	}
+}
+/**
+* Set a value in the dev namespace (no-op in production).
+*/
+function setDevValue(key, value) {
+	if (isProductionEnvironment()) return;
+	try {
+		getDevNamespace()[key] = value;
+	} catch {}
+}
+/**
+* Get a value from the dev namespace (returns undefined in production).
+*/
+function getDevValue(key) {
+	if (isProductionEnvironment()) return void 0;
+	try {
+		return getDevNamespace()[key];
+	} catch {
+		return;
+	}
+}
+/**
+* Increment a counter in the dev namespace (no-op in production).
+* Safely handles non-number values by resetting to 1.
+*/
+function incDevCounter(key) {
+	if (isProductionEnvironment()) return;
+	try {
+		const ns = getDevNamespace();
+		ns[key] = (typeof ns[key] === "number" ? ns[key] : 0) + 1;
+	} catch {}
+}
+//#endregion
+export { getDevNamespace, getDevValue, incDevCounter, setDevValue };
+
+//# sourceMappingURL=dev-namespace.js.map

package/dist/runtime/dev-namespace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev-namespace.js","names":[],"sources":["../../src/runtime/dev-namespace.ts"],"sourcesContent":["/**\n * Dev-only namespace helpers for diagnostics\n *\n * Centralizes the repetitive globalThis.__ASKR__ access pattern\n * used throughout runtime for dev-mode diagnostics.\n */\n\nimport { isProductionEnvironment } from '../common/env';\n\ntype DevNamespace = Record<string, unknown>;\n\n/**\n * Get or create the __ASKR__ dev namespace on globalThis.\n * Returns empty object in production to avoid allocations.\n */\nexport function getDevNamespace(): DevNamespace {\n  if (isProductionEnvironment()) return {};\n  try {\n    const g = globalThis as unknown as Record<string, DevNamespace>;\n    if (!g.__ASKR__) g.__ASKR__ = {};\n    return g.__ASKR__;\n  } catch {\n    return {};\n  }\n}\n\n/**\n * Set a value in the dev namespace (no-op in production).\n */\nexport function setDevValue(key: string, value: unknown): void {\n  if (isProductionEnvironment()) return;\n  try {\n    getDevNamespace()[key] = value;\n  } catch {\n    // ignore\n  }\n}\n\n/**\n * Get a value from the dev namespace (returns undefined in production).\n */\nexport function getDevValue<T>(key: string): T | undefined {\n  if (isProductionEnvironment()) return undefined;\n  try {\n    return getDevNamespace()[key] as T | undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Delete a value from the dev namespace (no-op in production).\n */\nexport function deleteDevValue(key: string): void {\n  if (isProductionEnvironment()) return;\n  try {\n    delete getDevNamespace()[key];\n  } catch {\n    // ignore\n  }\n}\n\n/**\n * Increment a counter in the dev namespace (no-op in production).\n * Safely handles non-number values by resetting to 1.\n */\nexport function incDevCounter(key: string): void {\n  if (isProductionEnvironment()) return;\n  try {\n    const ns = getDevNamespace();\n    const prev = typeof ns[key] === 'number' ? (ns[key] as number) : 0;\n    ns[key] = prev + 1;\n  } catch {\n    // ignore\n  }\n}\n"],"mappings":";;;;;;;;;;;;AAeA,SAAgB,kBAAgC;AAC9C,KAAI,yBAAyB,CAAE,QAAO,EAAE;AACxC,KAAI;EACF,MAAM,IAAI;AACV,MAAI,CAAC,EAAE,SAAU,GAAE,WAAW,EAAE;AAChC,SAAO,EAAE;SACH;AACN,SAAO,EAAE;;;;;;AAOb,SAAgB,YAAY,KAAa,OAAsB;AAC7D,KAAI,yBAAyB,CAAE;AAC/B,KAAI;AACF,mBAAiB,CAAC,OAAO;SACnB;;;;;AAQV,SAAgB,YAAe,KAA4B;AACzD,KAAI,yBAAyB,CAAE,QAAO;AACtC,KAAI;AACF,SAAO,iBAAiB,CAAC;SACnB;AACN;;;;;;;AAoBJ,SAAgB,cAAc,KAAmB;AAC/C,KAAI,yBAAyB,CAAE;AAC/B,KAAI;EACF,MAAM,KAAK,iBAAiB;AAE5B,KAAG,QADU,OAAO,GAAG,SAAS,WAAY,GAAG,OAAkB,KAChD;SACX"}

package/dist/runtime/effect.d.ts

@@ -0,0 +1,32 @@
+import { ReadableSource } from "./readable.js";
+import { SchedulerLane } from "./scheduler.js";
+
+//#region src/runtime/effect.d.ts
+interface FineGrainedEffect<T> {
+  lane: SchedulerLane;
+  compute(): T;
+  commit(value: T, previousValue: T | undefined): void;
+  equals(previousValue: T, nextValue: T): boolean;
+  readSources: Set<ReadableSource<unknown>>;
+  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>;
+//#endregion
+export { FineGrainedEffectHandle };
+//# sourceMappingURL=effect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"effect.d.ts","names":[],"sources":["../../src/runtime/effect.ts"],"mappings":";;;;UA6BiB,iBAAA;EACf,IAAA,EAAM,aAAA;EACN,OAAA,IAAW,CAAA;EACX,MAAA,CAAO,KAAA,EAAO,CAAA,EAAG,aAAA,EAAe,CAAA;EAChC,MAAA,CAAO,aAAA,EAAe,CAAA,EAAG,SAAA,EAAW,CAAA;EACpC,WAAA,EAAa,GAAA,CAAI,cAAA;EACjB,QAAA;EACA,QAAA;EACA,SAAA,EAAW,CAAA;EACX,OAAA,EAAS,KAAA;AAAA;AAAA,UAGM,uBAAA;EACf,OAAA;EACA,aAAA,CAAc,WAAA,QAAmB,CAAA;EACjC,KAAA;AAAA;AAAA,UAGe,8BAAA;EACf,IAAA,EAAM,aAAA;EACN,OAAA,QAAe,CAAA;EACf,MAAA,GAAS,KAAA,EAAO,CAAA,EAAG,aAAA,EAAe,CAAA;EAClC,MAAA,IAAU,aAAA,EAAe,CAAA,EAAG,SAAA,EAAW,CAAA;EACvC,OAAA,IAAW,KAAA;AAAA;AAAA,iBA+JG,iCAAA,CACd,MAAA,EAAQ,cAAA;AAAA,iBAqBM,uBAAA,GAAA,CACd,OAAA,EAAS,8BAAA,CAA+B,CAAA,IACvC,uBAAA,CAAwB,CAAA"}

package/dist/runtime/effect.js

@@ -0,0 +1,146 @@
+import { globalScheduler } from "./scheduler.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 _evalSourceBuffer = /* @__PURE__ */ new Set();
+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) {
+	_evalSourceBuffer.clear();
+	try {
+		incDevCounter("effectRuns");
+		return {
+			value: withFineGrainedReadTracking(_evalSourceBuffer, () => effect.compute()),
+			nextSources: normalizeNextSources(effect.readSources, _evalSourceBuffer)
+		};
+	} finally {
+		_evalSourceBuffer.clear();
+	}
+}
+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 = Array.from(effects);
+	effects.clear();
+	for (const effect of pending) {
+		if (!effect.isActive) continue;
+		try {
+			const { value, nextSources } = evaluateEffect(effect);
+			commitEffectResult(effect, value, nextSources);
+		} catch (error) {
+			effect.onError?.(error);
+		}
+	}
+}
+function scheduleLaneFlush(lane) {
+	if (hasPendingLaneFlush[lane]) return;
+	hasPendingLaneFlush[lane] = true;
+	globalScheduler.enqueueInLane(lane, () => {
+		flushLaneEffects(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;
+	for (const effect of effects) {
+		if (!effect.isActive) continue;
+		dirtyEffectsByLane[effect.lane].add(effect);
+	}
+	for (const lane of Object.keys(hasPendingLaneFlush)) if (dirtyEffectsByLane[lane].size > 0) scheduleLaneFlush(lane);
+}
+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

@@ -0,0 +1 @@
+{"version":3,"file":"effect.js","names":[],"sources":["../../src/runtime/effect.ts"],"sourcesContent":["import { incDevCounter } from './dev-namespace';\nimport { type ReadableSource, withFineGrainedReadTracking } from './readable';\nimport { globalScheduler, 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>;\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 _evalSourceBuffer = new Set<ReadableSource<unknown>>();\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  _evalSourceBuffer.clear();\n\n  try {\n    incDevCounter('effectRuns');\n    const value = withFineGrainedReadTracking(_evalSourceBuffer, () =>\n      effect.compute()\n    );\n    const nextSources = normalizeNextSources(\n      effect.readSources,\n      _evalSourceBuffer\n    );\n    return { value, nextSources };\n  } finally {\n    _evalSourceBuffer.clear();\n  }\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 = Array.from(effects);\n  effects.clear();\n\n  for (const effect of pending) {\n    if (!effect.isActive) {\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}\n\nfunction scheduleLaneFlush(lane: SchedulerLane): void {\n  if (hasPendingLaneFlush[lane]) {\n    return;\n  }\n\n  hasPendingLaneFlush[lane] = true;\n  globalScheduler.enqueueInLane(lane, () => {\n    flushLaneEffects(lane);\n  });\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  for (const effect of effects) {\n    if (!effect.isActive) {\n      continue;\n    }\n    dirtyEffectsByLane[effect.lane].add(effect);\n  }\n\n  for (const lane of Object.keys(hasPendingLaneFlush) as SchedulerLane[]) {\n    if (dirtyEffectsByLane[lane].size > 0) {\n      scheduleLaneFlush(lane);\n    }\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/events.js

@@ -1 +1,162 @@
-import{globalScheduler as M}from"./scheduler.js";import{logger as w}from"../dev/logger.js";import{incrementPerfMetric as H}from"./perf-metrics.js";const h=["click","dblclick","mousedown","mouseup","mouseover","mouseout","mousemove","focus","blur","input","change","keydown","keyup","keypress","submit","scroll","wheel","touchstart","touchend","touchmove","touchcancel"],r=new WeakMap;let u=!1,d=null,g=null;const l=new Map;function G(){return u}function N(){u=!1,L()}function P(e){u=!0,e&&(d=e)}function T(e){g=e}function L(){for(const[e,n]of l)for(const[t,o]of n)e.removeEventListener(t,o);l.clear()}function k(){return g||d||(typeof document<"u"?document.body:null)}function x(e,n,t,o,c,i){l.has(e)||l.set(e,new Map);const p=l.get(e);if(!p.has(t)){const v=f=>{const D=f.target;D&&M.runInHandlerScope(()=>{let s=D;for(;s&&s!==e;){H("delegatedAncestorHops");const a=r.get(s),E=a?a instanceof Map?a.get(t):a.eventName===t?a:void 0:void 0;if(E)try{E.handler(f)}catch(b){w.error("[Askr] Delegated event error:",b)}if(f.cancelBubble)break;s=s.parentElement}})},m=C(t)??i;e.addEventListener(t,v,m),p.set(t,v)}A(n,{handler:o,original:c,element:n,eventName:t,options:i})}function A(e,n){const t=r.get(e);if(!t){r.set(e,n);return}if(t instanceof Map){t.set(n.eventName,n);return}if(t.eventName===n.eventName){r.set(e,n);return}const o=new Map;o.set(t.eventName,t),o.set(n.eventName,n),r.set(e,o)}function C(e){if(e==="wheel"||e==="scroll"||e.startsWith("touch"))return{passive:!0}}function W(e,n,t,o,c){if(!u)return;const i=k();i&&x(i,e,n,t,o,c)}function B(e,n){const t=r.get(e);if(t){if(t instanceof Map){if(t.delete(n),t.size===0){r.delete(e);return}if(t.size===1){const o=t.values().next().value;r.set(e,o)}return}t.eventName===n&&r.delete(e)}}function F(e,n){const t=r.get(e);if(t)return t instanceof Map?t.get(n):t.eventName===n?t:void 0}function I(e){const n=r.get(e);if(n)return n instanceof Map?n:new Map([[n.eventName,n]])}function V(e,n){return F(e,n)!==void 0}function _(e){r.delete(e)}function j(){return h}function q(e){return h.includes(e)}export{W as addDelegatedListener,_ as clearDelegatedHandlersForElement,N as disableEventDelegation,P as enableEventDelegation,j as getDelegatedEventNames,F as getDelegatedHandlerForElement,I as getDelegatedHandlersForElement,V as hasDelegatedHandler,q as isDelegatedEvent,G as isEventDelegationEnabled,B as removeDelegatedListener,T as setGlobalDelegationContainer};
+import { logger } from "../dev/logger.js";
+import { incrementPerfMetric } from "./perf-metrics.js";
+import { globalScheduler } from "./scheduler.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();
+function isEventDelegationEnabled() {
+	return eventDelegationEnabled;
+}
+function getDelegationContainer() {
+	if (typeof document !== "undefined") return document.body;
+	return null;
+}
+function attachDelegatedListener(container, element, eventName, handler, originalHandler, options) {
+	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;
+			globalScheduler.runInHandlerScope(() => {
+				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,
+		eventName,
+		options
+	});
+}
+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;
+	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");
+		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");
+		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 new Map([[store.eventName, store]]);
+}
+function clearDelegatedHandlersForElement(element) {
+	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

@@ -0,0 +1 @@
+{"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 { globalScheduler } from './scheduler';\nimport { logger } from '../dev/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  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>();\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}\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  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      globalScheduler.runInHandlerScope(() => {\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    eventName,\n    options,\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  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    }\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    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  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.js

@@ -1 +1,15 @@
-const t=Symbol.for("__ASKR_EXECUTION_MODEL__");function r(){return globalThis[t]}function c(e){const n=globalThis,o=n[t];if(o&&o!==e)throw new Error(`[Askr] mixing execution models is not allowed (current: ${o}, attempted: ${e}). Choose exactly one: createSPA, createSSR, or createIslands.`);o||(n[t]=e)}export{c as assertExecutionModel,r as getExecutionModel};
+//#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

@@ -0,0 +1 @@
+{"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,2BAA2B;AAElE,SAAgB,oBAAgD;AAE9D,QAAO,WAAE;;AAGX,SAAgB,qBAAqB,OAA6B;CAGhE,MAAM,IAAI;CACV,MAAM,MAAM,EAAE;AACd,KAAI,OAAO,QAAQ,MACjB,OAAM,IAAI,MACR,2DAA2D,IAAI,eAAe,MAAM,gEAErF;AAEH,KAAI,CAAC,IAAK,GAAE,uBAAuB"}