@askrjs/askr 0.0.27 → 0.0.29

package/dist/runtime/scheduler.js

@@ -1 +1,328 @@
-import{assertSchedulingPrecondition as c,invariant as f}from"../dev/invariant.js";import{logger as d}from"../dev/logger.js";function h(){try{const s=globalThis.__ASKR_FASTLANE;return typeof s?.isBulkCommitActive=="function"?!!s.isBulkCommitActive():!1}catch(s){return!1}}class g{constructor(){this.q=[],this.head=0,this.running=!1,this.inHandler=!1,this.depth=0,this.executionDepth=0,this.flushVersion=0,this.kickScheduled=!1,this.allowSyncProgress=!1,this.waiters=[],this.taskCount=0}enqueue(t){c(typeof t=="function","enqueue() requires a function"),!(h()&&!this.allowSyncProgress)&&(this.q.push(t),this.taskCount++,!this.running&&!this.kickScheduled&&!this.inHandler&&!h()&&(this.kickScheduled=!0,queueMicrotask(()=>{if(this.kickScheduled=!1,!this.running&&!h())try{this.flush()}catch(i){setTimeout(()=>{throw i})}})))}flush(){f(!this.running,"[Scheduler] flush() called while already running"),this.running=!0,this.depth=0;let t=null;try{for(;this.head<this.q.length;){this.depth++;const i=this.q[this.head++];try{this.executionDepth++,i(),this.executionDepth--}catch(e){this.executionDepth>0&&(this.executionDepth=0),t=e;break}this.taskCount>0&&this.taskCount--}}finally{if(this.running=!1,this.depth=0,this.executionDepth=0,this.head>=this.q.length)this.q.length=0,this.head=0;else if(this.head>0){const i=this.q.length-this.head;for(let e=0;e<i;e++)this.q[e]=this.q[this.head+e];this.q.length=i,this.head=0}this.flushVersion++,this.resolveWaiters()}if(t)throw t}finalizeFlush(){}runWithSyncProgress(t){const i=this.allowSyncProgress;this.allowSyncProgress=!0;const e=globalThis,l=e.queueMicrotask,o=e.setTimeout,u=this.flushVersion;try{const n=t();return!this.running&&this.q.length-this.head>0&&this.flush(),n}finally{try{this.flushVersion===u&&(this.flushVersion++,this.resolveWaiters())}catch(n){}this.allowSyncProgress=i}}waitForFlush(t,i=2e3){const e=typeof t=="number"?t:this.flushVersion+1;return this.flushVersion>=e?Promise.resolve():new Promise((l,o)=>{const u=setTimeout(()=>{const n=globalThis.__ASKR__||{},a={flushVersion:this.flushVersion,queueLen:this.q.length-this.head,running:this.running,inHandler:this.inHandler,bulk:h(),namespace:n};o(new Error(`waitForFlush timeout ${i}ms: ${JSON.stringify(a)}`))},i);this.waiters.push({target:e,resolve:l,reject:o,timer:u})})}getState(){return{queueLength:this.q.length-this.head,running:this.running,depth:this.depth,executionDepth:this.executionDepth,taskCount:this.taskCount,flushVersion:this.flushVersion,inHandler:this.inHandler,allowSyncProgress:this.allowSyncProgress}}setInHandler(t){this.inHandler=t}isInHandler(){return this.inHandler}isExecuting(){return this.running||this.executionDepth>0}clearPendingSyncTasks(){const t=this.q.length-this.head;return t<=0?0:this.running?(this.q.length=this.head,this.taskCount=Math.max(0,this.taskCount-t),queueMicrotask(()=>{try{this.flushVersion++,this.resolveWaiters()}catch(i){}}),t):(this.q.length=0,this.head=0,this.taskCount=Math.max(0,this.taskCount-t),this.flushVersion++,this.resolveWaiters(),t)}resolveWaiters(){if(this.waiters.length===0)return;const t=[],i=[];for(const e of this.waiters)this.flushVersion>=e.target?(e.timer&&clearTimeout(e.timer),t.push(e.resolve)):i.push(e);this.waiters=i;for(const e of t)e()}}const r=new g;function k(){return r.isExecuting()}function S(s){return t=>{r.setInHandler(!0);try{s.call(null,t)}catch(i){d.error("[Askr] Event handler error:",i)}finally{r.setInHandler(!1);const i=r.getState();(i.queueLength??0)>0&&!i.running&&queueMicrotask(()=>{try{r.isExecuting()||r.flush()}catch(e){setTimeout(()=>{throw e})}})}}}export{g as Scheduler,r as globalScheduler,k as isSchedulerExecuting,S as scheduleEventHandler};
+import { isDevelopmentEnvironment } from "../common/env.js";
+import { assertSchedulingPrecondition, invariant } from "../dev/invariant.js";
+import { logger } from "../dev/logger.js";
+import { recordSchedulerFlushTaskCount } from "./perf-metrics.js";
+//#region src/runtime/scheduler.ts
+/**
+* Serialized update scheduler — safer design (no inline execution, explicit flush)
+*
+* Key ideas:
+* - Never execute a task inline from `enqueue`.
+* - `flush()` is explicit and non-reentrant.
+* - `runWithSyncProgress()` allows enqueues temporarily but does not run tasks
+*   inline; it runs `fn` and then does an explicit `flush()`.
+* - `waitForFlush()` is race-free with a monotonic `flushVersion`.
+*/
+const MAX_FLUSH_DEPTH = 50;
+const SCHEDULER_LANES = [
+	"derived",
+	"component",
+	"reactive",
+	"post"
+];
+function isBulkCommitActive() {
+	try {
+		const fb = globalThis.__ASKR_FASTLANE;
+		return typeof fb?.isBulkCommitActive === "function" ? !!fb.isBulkCommitActive() : false;
+	} catch (e) {
+		return false;
+	}
+}
+var Scheduler = class {
+	constructor() {
+		this.lanes = {
+			derived: {
+				tasks: [],
+				head: 0
+			},
+			component: {
+				tasks: [],
+				head: 0
+			},
+			reactive: {
+				tasks: [],
+				head: 0
+			},
+			post: {
+				tasks: [],
+				head: 0
+			}
+		};
+		this.running = false;
+		this.inHandler = false;
+		this.depth = 0;
+		this.executionDepth = 0;
+		this.flushVersion = 0;
+		this.kickScheduled = false;
+		this.allowSyncProgress = false;
+		this.waiters = [];
+		this.taskCount = 0;
+	}
+	hasPendingTasks() {
+		for (const lane of SCHEDULER_LANES) {
+			const queue = this.lanes[lane];
+			if (queue.head < queue.tasks.length) return true;
+		}
+		return false;
+	}
+	getPendingTaskCount() {
+		let total = 0;
+		for (const lane of SCHEDULER_LANES) {
+			const queue = this.lanes[lane];
+			total += queue.tasks.length - queue.head;
+		}
+		return total;
+	}
+	compactLane(queue) {
+		if (queue.head >= queue.tasks.length) {
+			queue.tasks.length = 0;
+			queue.head = 0;
+			return;
+		}
+		if (queue.head <= 0) return;
+		const remaining = queue.tasks.length - queue.head;
+		for (let i = 0; i < remaining; i++) queue.tasks[i] = queue.tasks[queue.head + i];
+		queue.tasks.length = remaining;
+		queue.head = 0;
+	}
+	scheduleFlushKick() {
+		if (this.running || this.kickScheduled || this.inHandler || isBulkCommitActive() || !this.hasPendingTasks()) return;
+		this.kickScheduled = true;
+		queueMicrotask(() => {
+			this.kickScheduled = false;
+			if (this.running || isBulkCommitActive() || !this.hasPendingTasks()) return;
+			try {
+				this.flush();
+			} catch (err) {
+				setTimeout(() => {
+					throw err;
+				});
+			}
+		});
+	}
+	enqueue(task) {
+		this.enqueueInLane("component", task);
+	}
+	enqueueInLane(lane, task) {
+		assertSchedulingPrecondition(typeof task === "function", "enqueue() requires a function");
+		if (isBulkCommitActive() && !this.allowSyncProgress) {
+			if (isDevelopmentEnvironment()) throw new Error("[Scheduler] enqueue() during bulk commit (not allowed)");
+			return;
+		}
+		this.lanes[lane].tasks.push(task);
+		this.taskCount++;
+		this.scheduleFlushKick();
+	}
+	flush() {
+		invariant(!this.running, "[Scheduler] flush() called while already running");
+		if (isDevelopmentEnvironment()) {
+			if (isBulkCommitActive() && !this.allowSyncProgress) throw new Error("[Scheduler] flush() started during bulk commit (not allowed)");
+		}
+		this.running = true;
+		this.depth = 0;
+		let fatal = null;
+		let executedTaskCount = 0;
+		const checkFlushDepth = isDevelopmentEnvironment();
+		try {
+			while (fatal === null) {
+				let didRunTask = false;
+				for (const lane of SCHEDULER_LANES) {
+					const laneQueue = this.lanes[lane];
+					let executedInLane = 0;
+					while (laneQueue.head < laneQueue.tasks.length) {
+						this.depth++;
+						if (checkFlushDepth && this.depth > MAX_FLUSH_DEPTH) throw new Error(`[Scheduler] exceeded MAX_FLUSH_DEPTH (${MAX_FLUSH_DEPTH}). Likely infinite update loop.`);
+						const task = laneQueue.tasks[laneQueue.head++];
+						try {
+							this.executionDepth++;
+							task();
+							this.executionDepth--;
+							executedTaskCount++;
+							executedInLane++;
+							didRunTask = true;
+						} catch (err) {
+							if (this.executionDepth > 0) this.executionDepth = 0;
+							fatal = err;
+							break;
+						}
+					}
+					if (executedInLane > 0) this.taskCount = Math.max(0, this.taskCount - executedInLane);
+					if (fatal !== null) break;
+				}
+				if (!didRunTask) break;
+			}
+		} finally {
+			this.running = false;
+			this.depth = 0;
+			this.executionDepth = 0;
+			for (const lane of SCHEDULER_LANES) this.compactLane(this.lanes[lane]);
+			this.flushVersion++;
+			this.resolveWaiters();
+			recordSchedulerFlushTaskCount(executedTaskCount);
+		}
+		if (fatal) throw fatal;
+	}
+	finalizeFlush() {}
+	runWithSyncProgress(fn) {
+		const prev = this.allowSyncProgress;
+		this.allowSyncProgress = true;
+		const g = globalThis;
+		const origQueueMicrotask = g.queueMicrotask;
+		const origSetTimeout = g.setTimeout;
+		if (isDevelopmentEnvironment()) {
+			g.queueMicrotask = () => {
+				throw new Error("[Scheduler] queueMicrotask not allowed during runWithSyncProgress");
+			};
+			g.setTimeout = () => {
+				throw new Error("[Scheduler] setTimeout not allowed during runWithSyncProgress");
+			};
+		}
+		const startVersion = this.flushVersion;
+		try {
+			const res = fn();
+			if (!this.running && this.hasPendingTasks()) this.flush();
+			if (isDevelopmentEnvironment()) {
+				if (this.hasPendingTasks()) throw new Error("[Scheduler] tasks remain after runWithSyncProgress flush");
+			}
+			return res;
+		} finally {
+			if (isDevelopmentEnvironment()) {
+				g.queueMicrotask = origQueueMicrotask;
+				g.setTimeout = origSetTimeout;
+			}
+			try {
+				if (this.flushVersion === startVersion) {
+					this.flushVersion++;
+					this.resolveWaiters();
+				}
+			} catch (e) {}
+			this.allowSyncProgress = prev;
+		}
+	}
+	waitForFlush(targetVersion, timeoutMs = 2e3) {
+		const target = typeof targetVersion === "number" ? targetVersion : this.flushVersion + 1;
+		if (this.flushVersion >= target) return Promise.resolve();
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				const ns = globalThis.__ASKR__ || {};
+				const diag = {
+					flushVersion: this.flushVersion,
+					queueLen: this.getPendingTaskCount(),
+					running: this.running,
+					inHandler: this.inHandler,
+					bulk: isBulkCommitActive(),
+					namespace: ns
+				};
+				reject(/* @__PURE__ */ new Error(`waitForFlush timeout ${timeoutMs}ms: ${JSON.stringify(diag)}`));
+			}, timeoutMs);
+			this.waiters.push({
+				target,
+				resolve,
+				reject,
+				timer
+			});
+		});
+	}
+	getState() {
+		return {
+			queueLength: this.getPendingTaskCount(),
+			running: this.running,
+			depth: this.depth,
+			executionDepth: this.executionDepth,
+			taskCount: this.taskCount,
+			flushVersion: this.flushVersion,
+			laneQueues: {
+				derived: this.lanes.derived.tasks.length - this.lanes.derived.head,
+				component: this.lanes.component.tasks.length - this.lanes.component.head,
+				reactive: this.lanes.reactive.tasks.length - this.lanes.reactive.head,
+				post: this.lanes.post.tasks.length - this.lanes.post.head
+			},
+			inHandler: this.inHandler,
+			allowSyncProgress: this.allowSyncProgress
+		};
+	}
+	getFlushVersion() {
+		return this.flushVersion;
+	}
+	flushIfQueued() {
+		if (!this.running && this.hasPendingTasks()) this.flush();
+	}
+	runInHandlerScope(fn, flushMode = "defer") {
+		const prevInHandler = this.inHandler;
+		this.inHandler = true;
+		try {
+			return fn();
+		} finally {
+			this.inHandler = prevInHandler;
+			if (!this.inHandler) if (flushMode === "sync") this.flushIfQueued();
+			else this.scheduleFlushKick();
+		}
+	}
+	setInHandler(v) {
+		this.inHandler = v;
+		if (!v) this.scheduleFlushKick();
+	}
+	isInHandler() {
+		return this.inHandler;
+	}
+	isExecuting() {
+		return this.running || this.executionDepth > 0;
+	}
+	clearPendingSyncTasks() {
+		const remaining = this.getPendingTaskCount();
+		if (remaining <= 0) return 0;
+		if (this.running) {
+			for (const lane of SCHEDULER_LANES) {
+				const queue = this.lanes[lane];
+				queue.tasks.length = queue.head;
+			}
+			this.taskCount = Math.max(0, this.taskCount - remaining);
+			queueMicrotask(() => {
+				try {
+					this.flushVersion++;
+					this.resolveWaiters();
+				} catch (e) {}
+			});
+			return remaining;
+		}
+		for (const lane of SCHEDULER_LANES) {
+			const queue = this.lanes[lane];
+			queue.tasks.length = 0;
+			queue.head = 0;
+		}
+		this.taskCount = Math.max(0, this.taskCount - remaining);
+		this.flushVersion++;
+		this.resolveWaiters();
+		return remaining;
+	}
+	resolveWaiters() {
+		if (this.waiters.length === 0) return;
+		const ready = [];
+		const remaining = [];
+		for (const w of this.waiters) if (this.flushVersion >= w.target) {
+			if (w.timer) clearTimeout(w.timer);
+			ready.push(w.resolve);
+		} else remaining.push(w);
+		this.waiters = remaining;
+		for (const r of ready) r();
+	}
+};
+const globalScheduler = new Scheduler();
+function isSchedulerExecuting() {
+	return globalScheduler.isExecuting();
+}
+function scheduleEventHandler(handler) {
+	return (event) => {
+		try {
+			globalScheduler.runInHandlerScope(() => {
+				handler.call(null, event);
+			});
+		} catch (error) {
+			logger.error("[Askr] Event handler error:", error);
+		}
+	};
+}
+//#endregion
+export { globalScheduler, isSchedulerExecuting, scheduleEventHandler };
+
+//# sourceMappingURL=scheduler.js.map

package/dist/runtime/scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.js","names":[],"sources":["../../src/runtime/scheduler.ts"],"sourcesContent":["/**\n * Serialized update scheduler — safer design (no inline execution, explicit flush)\n *\n * Key ideas:\n * - Never execute a task inline from `enqueue`.\n * - `flush()` is explicit and non-reentrant.\n * - `runWithSyncProgress()` allows enqueues temporarily but does not run tasks\n *   inline; it runs `fn` and then does an explicit `flush()`.\n * - `waitForFlush()` is race-free with a monotonic `flushVersion`.\n */\n\nimport { isDevelopmentEnvironment } from '../common/env';\nimport { assertSchedulingPrecondition, invariant } from '../dev/invariant';\nimport { logger } from '../dev/logger';\nimport { recordSchedulerFlushTaskCount } from './perf-metrics';\n\nconst MAX_FLUSH_DEPTH = 50;\n\ntype Task = () => void;\nexport type SchedulerLane = 'derived' | 'component' | 'reactive' | 'post';\n\nconst SCHEDULER_LANES: SchedulerLane[] = [\n  'derived',\n  'component',\n  'reactive',\n  'post',\n];\n\ninterface LaneQueue {\n  tasks: Task[];\n  head: number;\n}\n\nfunction isBulkCommitActive(): boolean {\n  try {\n    const fb = (\n      globalThis as {\n        __ASKR_FASTLANE?: { isBulkCommitActive?: () => boolean };\n      }\n    ).__ASKR_FASTLANE;\n    return typeof fb?.isBulkCommitActive === 'function'\n      ? !!fb.isBulkCommitActive()\n      : false;\n  } catch (e) {\n    void e;\n    return false;\n  }\n}\n\nexport class Scheduler {\n  private lanes: Record<SchedulerLane, LaneQueue> = {\n    derived: { tasks: [], head: 0 },\n    component: { tasks: [], head: 0 },\n    reactive: { tasks: [], head: 0 },\n    post: { tasks: [], head: 0 },\n  };\n\n  private running = false;\n  private inHandler = false;\n  private depth = 0;\n  private executionDepth = 0; // for compat with existing diagnostics\n\n  // Monotonic flush version increments at end of each flush\n  private flushVersion = 0;\n\n  // Best-effort microtask kick scheduling\n  private kickScheduled = false;\n\n  // Escape hatch flag for runWithSyncProgress\n  private allowSyncProgress = false;\n\n  // Waiters waiting for flushVersion >= target\n  private waiters: Array<{\n    target: number;\n    resolve: () => void;\n    reject: (err: unknown) => void;\n    timer?: ReturnType<typeof setTimeout>;\n  }> = [];\n\n  // Keep a lightweight taskCount for compatibility/diagnostics\n  private taskCount = 0;\n\n  private hasPendingTasks(): boolean {\n    for (const lane of SCHEDULER_LANES) {\n      const queue = this.lanes[lane];\n      if (queue.head < queue.tasks.length) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  private getPendingTaskCount(): number {\n    let total = 0;\n    for (const lane of SCHEDULER_LANES) {\n      const queue = this.lanes[lane];\n      total += queue.tasks.length - queue.head;\n    }\n    return total;\n  }\n\n  private compactLane(queue: LaneQueue): void {\n    if (queue.head >= queue.tasks.length) {\n      queue.tasks.length = 0;\n      queue.head = 0;\n      return;\n    }\n\n    if (queue.head <= 0) {\n      return;\n    }\n\n    const remaining = queue.tasks.length - queue.head;\n    for (let i = 0; i < remaining; i++) {\n      queue.tasks[i] = queue.tasks[queue.head + i];\n    }\n    queue.tasks.length = remaining;\n    queue.head = 0;\n  }\n\n  private scheduleFlushKick(): void {\n    if (\n      this.running ||\n      this.kickScheduled ||\n      this.inHandler ||\n      isBulkCommitActive() ||\n      !this.hasPendingTasks()\n    ) {\n      return;\n    }\n\n    this.kickScheduled = true;\n    queueMicrotask(() => {\n      this.kickScheduled = false;\n      if (this.running || isBulkCommitActive() || !this.hasPendingTasks()) {\n        return;\n      }\n      try {\n        this.flush();\n      } catch (err) {\n        setTimeout(() => {\n          throw err;\n        });\n      }\n    });\n  }\n\n  enqueue(task: Task): void {\n    this.enqueueInLane('component', task);\n  }\n\n  enqueueInLane(lane: SchedulerLane, task: Task): void {\n    assertSchedulingPrecondition(\n      typeof task === 'function',\n      'enqueue() requires a function'\n    );\n\n    // Strict rule: during bulk commit, only allow enqueues if runWithSyncProgress enabled\n    if (isBulkCommitActive() && !this.allowSyncProgress) {\n      if (isDevelopmentEnvironment()) {\n        throw new Error(\n          '[Scheduler] enqueue() during bulk commit (not allowed)'\n        );\n      }\n      return;\n    }\n\n    // Enqueue task and account counts\n    this.lanes[lane].tasks.push(task);\n    this.taskCount++;\n\n    this.scheduleFlushKick();\n  }\n\n  flush(): void {\n    invariant(\n      !this.running,\n      '[Scheduler] flush() called while already running'\n    );\n\n    // Dev-only guard: disallow flush during bulk commit unless allowed\n    if (isDevelopmentEnvironment()) {\n      if (isBulkCommitActive() && !this.allowSyncProgress) {\n        throw new Error(\n          '[Scheduler] flush() started during bulk commit (not allowed)'\n        );\n      }\n    }\n\n    this.running = true;\n    this.depth = 0;\n    let fatal: unknown = null;\n    let executedTaskCount = 0;\n    const checkFlushDepth = isDevelopmentEnvironment();\n\n    try {\n      while (fatal === null) {\n        let didRunTask = false;\n\n        for (const lane of SCHEDULER_LANES) {\n          const laneQueue = this.lanes[lane];\n          let executedInLane = 0;\n\n          while (laneQueue.head < laneQueue.tasks.length) {\n            this.depth++;\n            if (checkFlushDepth && this.depth > MAX_FLUSH_DEPTH) {\n              throw new Error(\n                `[Scheduler] exceeded MAX_FLUSH_DEPTH (${MAX_FLUSH_DEPTH}). Likely infinite update loop.`\n              );\n            }\n\n            const task = laneQueue.tasks[laneQueue.head++];\n            try {\n              this.executionDepth++;\n              task();\n              this.executionDepth--;\n              executedTaskCount++;\n              executedInLane++;\n              didRunTask = true;\n            } catch (err) {\n              // ensure executionDepth stays balanced\n              if (this.executionDepth > 0) this.executionDepth = 0;\n              fatal = err;\n              break;\n            }\n          }\n\n          if (executedInLane > 0) {\n            this.taskCount = Math.max(0, this.taskCount - executedInLane);\n          }\n\n          if (fatal !== null) {\n            break;\n          }\n        }\n\n        if (!didRunTask) {\n          break;\n        }\n      }\n    } finally {\n      this.running = false;\n      this.depth = 0;\n      this.executionDepth = 0;\n\n      for (const lane of SCHEDULER_LANES) {\n        this.compactLane(this.lanes[lane]);\n      }\n\n      // Advance flush epoch and resolve waiters\n      this.flushVersion++;\n      this.resolveWaiters();\n      recordSchedulerFlushTaskCount(executedTaskCount);\n    }\n\n    if (fatal) throw fatal;\n  }\n\n  private finalizeFlush(): void {\n    // Not used - finalize happens in finally block above\n  }\n\n  runWithSyncProgress<T>(fn: () => T): T {\n    const prev = this.allowSyncProgress;\n    this.allowSyncProgress = true;\n\n    const g = globalThis as {\n      queueMicrotask?: (...args: unknown[]) => void;\n      setTimeout?: (...args: unknown[]) => unknown;\n    };\n    const origQueueMicrotask = g.queueMicrotask;\n    const origSetTimeout = g.setTimeout;\n\n    if (isDevelopmentEnvironment()) {\n      g.queueMicrotask = () => {\n        throw new Error(\n          '[Scheduler] queueMicrotask not allowed during runWithSyncProgress'\n        );\n      };\n      g.setTimeout = () => {\n        throw new Error(\n          '[Scheduler] setTimeout not allowed during runWithSyncProgress'\n        );\n      };\n    }\n\n    // Snapshot flushVersion so we can ensure we always complete an epoch\n    const startVersion = this.flushVersion;\n\n    try {\n      const res = fn();\n\n      // Flush deterministically if tasks were enqueued (and we're not already running)\n      if (!this.running && this.hasPendingTasks()) {\n        this.flush();\n      }\n\n      if (isDevelopmentEnvironment()) {\n        if (this.hasPendingTasks()) {\n          throw new Error(\n            '[Scheduler] tasks remain after runWithSyncProgress flush'\n          );\n        }\n      }\n\n      return res;\n    } finally {\n      // Restore guarded globals\n      if (isDevelopmentEnvironment()) {\n        g.queueMicrotask = origQueueMicrotask;\n        g.setTimeout = origSetTimeout;\n      }\n\n      // If no flush happened during the protected window, complete an epoch so\n      // observers (tests) see progress even when fast-lane did synchronous work\n      // without enqueuing tasks.\n      try {\n        if (this.flushVersion === startVersion) {\n          this.flushVersion++;\n          this.resolveWaiters();\n        }\n      } catch (e) {\n        void e;\n      }\n\n      this.allowSyncProgress = prev;\n    }\n  }\n\n  waitForFlush(targetVersion?: number, timeoutMs = 2000): Promise<void> {\n    const target =\n      typeof targetVersion === 'number' ? targetVersion : this.flushVersion + 1;\n    if (this.flushVersion >= target) return Promise.resolve();\n\n    return new Promise((resolve, reject) => {\n      const timer = setTimeout(() => {\n        const ns =\n          (\n            globalThis as unknown as Record<string, unknown> & {\n              __ASKR__?: Record<string, unknown>;\n            }\n          ).__ASKR__ || {};\n        const diag = {\n          flushVersion: this.flushVersion,\n          queueLen: this.getPendingTaskCount(),\n          running: this.running,\n          inHandler: this.inHandler,\n          bulk: isBulkCommitActive(),\n          namespace: ns,\n        };\n        reject(\n          new Error(\n            `waitForFlush timeout ${timeoutMs}ms: ${JSON.stringify(diag)}`\n          )\n        );\n      }, timeoutMs);\n\n      this.waiters.push({ target, resolve, reject, timer });\n    });\n  }\n\n  getState() {\n    // Provide the compatibility shape expected by diagnostics/tests\n    return {\n      queueLength: this.getPendingTaskCount(),\n      running: this.running,\n      depth: this.depth,\n      executionDepth: this.executionDepth,\n      taskCount: this.taskCount,\n      flushVersion: this.flushVersion,\n      laneQueues: {\n        derived: this.lanes.derived.tasks.length - this.lanes.derived.head,\n        component:\n          this.lanes.component.tasks.length - this.lanes.component.head,\n        reactive: this.lanes.reactive.tasks.length - this.lanes.reactive.head,\n        post: this.lanes.post.tasks.length - this.lanes.post.head,\n      },\n      // New fields for optional inspection\n      inHandler: this.inHandler,\n      allowSyncProgress: this.allowSyncProgress,\n    };\n  }\n\n  getFlushVersion(): number {\n    return this.flushVersion;\n  }\n\n  flushIfQueued(): void {\n    if (!this.running && this.hasPendingTasks()) {\n      this.flush();\n    }\n  }\n\n  runInHandlerScope<T>(fn: () => T, flushMode: 'defer' | 'sync' = 'defer'): T {\n    const prevInHandler = this.inHandler;\n    this.inHandler = true;\n\n    try {\n      return fn();\n    } finally {\n      this.inHandler = prevInHandler;\n\n      if (!this.inHandler) {\n        if (flushMode === 'sync') {\n          this.flushIfQueued();\n        } else {\n          this.scheduleFlushKick();\n        }\n      }\n    }\n  }\n\n  setInHandler(v: boolean) {\n    this.inHandler = v;\n    if (!v) {\n      this.scheduleFlushKick();\n    }\n  }\n\n  isInHandler(): boolean {\n    return this.inHandler;\n  }\n\n  isExecuting(): boolean {\n    return this.running || this.executionDepth > 0;\n  }\n\n  // Clear pending synchronous tasks (used by fastlane enter/exit)\n  clearPendingSyncTasks(): number {\n    const remaining = this.getPendingTaskCount();\n    if (remaining <= 0) return 0;\n\n    if (this.running) {\n      for (const lane of SCHEDULER_LANES) {\n        const queue = this.lanes[lane];\n        queue.tasks.length = queue.head;\n      }\n      this.taskCount = Math.max(0, this.taskCount - remaining);\n      queueMicrotask(() => {\n        try {\n          this.flushVersion++;\n          this.resolveWaiters();\n        } catch (e) {\n          void e;\n        }\n      });\n      return remaining;\n    }\n\n    for (const lane of SCHEDULER_LANES) {\n      const queue = this.lanes[lane];\n      queue.tasks.length = 0;\n      queue.head = 0;\n    }\n    this.taskCount = Math.max(0, this.taskCount - remaining);\n    this.flushVersion++;\n    this.resolveWaiters();\n    return remaining;\n  }\n\n  private resolveWaiters() {\n    if (this.waiters.length === 0) return;\n    const ready: Array<() => void> = [];\n    const remaining: typeof this.waiters = [];\n\n    for (const w of this.waiters) {\n      if (this.flushVersion >= w.target) {\n        if (w.timer) clearTimeout(w.timer);\n        ready.push(w.resolve);\n      } else {\n        remaining.push(w);\n      }\n    }\n\n    this.waiters = remaining;\n    for (const r of ready) r();\n  }\n}\n\nexport const globalScheduler = new Scheduler();\n\nexport function isSchedulerExecuting(): boolean {\n  return globalScheduler.isExecuting();\n}\n\nexport function scheduleEventHandler(handler: EventListener): EventListener {\n  return (event: Event) => {\n    try {\n      globalScheduler.runInHandlerScope(() => {\n        handler.call(null, event);\n      });\n    } catch (error) {\n      logger.error('[Askr] Event handler error:', error);\n    }\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;AAgBA,MAAM,kBAAkB;AAKxB,MAAM,kBAAmC;CACvC;CACA;CACA;CACA;CACD;AAOD,SAAS,qBAA8B;AACrC,KAAI;EACF,MAAM,KACJ,WAGA;AACF,SAAO,OAAO,IAAI,uBAAuB,aACrC,CAAC,CAAC,GAAG,oBAAoB,GACzB;UACG,GAAG;AAEV,SAAO;;;AAIX,IAAa,YAAb,MAAuB;;eAC6B;GAChD,SAAS;IAAE,OAAO,EAAE;IAAE,MAAM;IAAG;GAC/B,WAAW;IAAE,OAAO,EAAE;IAAE,MAAM;IAAG;GACjC,UAAU;IAAE,OAAO,EAAE;IAAE,MAAM;IAAG;GAChC,MAAM;IAAE,OAAO,EAAE;IAAE,MAAM;IAAG;GAC7B;iBAEiB;mBACE;eACJ;wBACS;sBAGF;uBAGC;2BAGI;iBAQvB,EAAE;mBAGa;;CAEpB,kBAAmC;AACjC,OAAK,MAAM,QAAQ,iBAAiB;GAClC,MAAM,QAAQ,KAAK,MAAM;AACzB,OAAI,MAAM,OAAO,MAAM,MAAM,OAC3B,QAAO;;AAGX,SAAO;;CAGT,sBAAsC;EACpC,IAAI,QAAQ;AACZ,OAAK,MAAM,QAAQ,iBAAiB;GAClC,MAAM,QAAQ,KAAK,MAAM;AACzB,YAAS,MAAM,MAAM,SAAS,MAAM;;AAEtC,SAAO;;CAGT,YAAoB,OAAwB;AAC1C,MAAI,MAAM,QAAQ,MAAM,MAAM,QAAQ;AACpC,SAAM,MAAM,SAAS;AACrB,SAAM,OAAO;AACb;;AAGF,MAAI,MAAM,QAAQ,EAChB;EAGF,MAAM,YAAY,MAAM,MAAM,SAAS,MAAM;AAC7C,OAAK,IAAI,IAAI,GAAG,IAAI,WAAW,IAC7B,OAAM,MAAM,KAAK,MAAM,MAAM,MAAM,OAAO;AAE5C,QAAM,MAAM,SAAS;AACrB,QAAM,OAAO;;CAGf,oBAAkC;AAChC,MACE,KAAK,WACL,KAAK,iBACL,KAAK,aACL,oBAAoB,IACpB,CAAC,KAAK,iBAAiB,CAEvB;AAGF,OAAK,gBAAgB;AACrB,uBAAqB;AACnB,QAAK,gBAAgB;AACrB,OAAI,KAAK,WAAW,oBAAoB,IAAI,CAAC,KAAK,iBAAiB,CACjE;AAEF,OAAI;AACF,SAAK,OAAO;YACL,KAAK;AACZ,qBAAiB;AACf,WAAM;MACN;;IAEJ;;CAGJ,QAAQ,MAAkB;AACxB,OAAK,cAAc,aAAa,KAAK;;CAGvC,cAAc,MAAqB,MAAkB;AACnD,+BACE,OAAO,SAAS,YAChB,gCACD;AAGD,MAAI,oBAAoB,IAAI,CAAC,KAAK,mBAAmB;AACnD,OAAI,0BAA0B,CAC5B,OAAM,IAAI,MACR,yDACD;AAEH;;AAIF,OAAK,MAAM,MAAM,MAAM,KAAK,KAAK;AACjC,OAAK;AAEL,OAAK,mBAAmB;;CAG1B,QAAc;AACZ,YACE,CAAC,KAAK,SACN,mDACD;AAGD,MAAI,0BAA0B,EAC5B;OAAI,oBAAoB,IAAI,CAAC,KAAK,kBAChC,OAAM,IAAI,MACR,+DACD;;AAIL,OAAK,UAAU;AACf,OAAK,QAAQ;EACb,IAAI,QAAiB;EACrB,IAAI,oBAAoB;EACxB,MAAM,kBAAkB,0BAA0B;AAElD,MAAI;AACF,UAAO,UAAU,MAAM;IACrB,IAAI,aAAa;AAEjB,SAAK,MAAM,QAAQ,iBAAiB;KAClC,MAAM,YAAY,KAAK,MAAM;KAC7B,IAAI,iBAAiB;AAErB,YAAO,UAAU,OAAO,UAAU,MAAM,QAAQ;AAC9C,WAAK;AACL,UAAI,mBAAmB,KAAK,QAAQ,gBAClC,OAAM,IAAI,MACR,yCAAyC,gBAAgB,iCAC1D;MAGH,MAAM,OAAO,UAAU,MAAM,UAAU;AACvC,UAAI;AACF,YAAK;AACL,aAAM;AACN,YAAK;AACL;AACA;AACA,oBAAa;eACN,KAAK;AAEZ,WAAI,KAAK,iBAAiB,EAAG,MAAK,iBAAiB;AACnD,eAAQ;AACR;;;AAIJ,SAAI,iBAAiB,EACnB,MAAK,YAAY,KAAK,IAAI,GAAG,KAAK,YAAY,eAAe;AAG/D,SAAI,UAAU,KACZ;;AAIJ,QAAI,CAAC,WACH;;YAGI;AACR,QAAK,UAAU;AACf,QAAK,QAAQ;AACb,QAAK,iBAAiB;AAEtB,QAAK,MAAM,QAAQ,gBACjB,MAAK,YAAY,KAAK,MAAM,MAAM;AAIpC,QAAK;AACL,QAAK,gBAAgB;AACrB,iCAA8B,kBAAkB;;AAGlD,MAAI,MAAO,OAAM;;CAGnB,gBAA8B;CAI9B,oBAAuB,IAAgB;EACrC,MAAM,OAAO,KAAK;AAClB,OAAK,oBAAoB;EAEzB,MAAM,IAAI;EAIV,MAAM,qBAAqB,EAAE;EAC7B,MAAM,iBAAiB,EAAE;AAEzB,MAAI,0BAA0B,EAAE;AAC9B,KAAE,uBAAuB;AACvB,UAAM,IAAI,MACR,oEACD;;AAEH,KAAE,mBAAmB;AACnB,UAAM,IAAI,MACR,gEACD;;;EAKL,MAAM,eAAe,KAAK;AAE1B,MAAI;GACF,MAAM,MAAM,IAAI;AAGhB,OAAI,CAAC,KAAK,WAAW,KAAK,iBAAiB,CACzC,MAAK,OAAO;AAGd,OAAI,0BAA0B,EAC5B;QAAI,KAAK,iBAAiB,CACxB,OAAM,IAAI,MACR,2DACD;;AAIL,UAAO;YACC;AAER,OAAI,0BAA0B,EAAE;AAC9B,MAAE,iBAAiB;AACnB,MAAE,aAAa;;AAMjB,OAAI;AACF,QAAI,KAAK,iBAAiB,cAAc;AACtC,UAAK;AACL,UAAK,gBAAgB;;YAEhB,GAAG;AAIZ,QAAK,oBAAoB;;;CAI7B,aAAa,eAAwB,YAAY,KAAqB;EACpE,MAAM,SACJ,OAAO,kBAAkB,WAAW,gBAAgB,KAAK,eAAe;AAC1E,MAAI,KAAK,gBAAgB,OAAQ,QAAO,QAAQ,SAAS;AAEzD,SAAO,IAAI,SAAS,SAAS,WAAW;GACtC,MAAM,QAAQ,iBAAiB;IAC7B,MAAM,KAEF,WAGA,YAAY,EAAE;IAClB,MAAM,OAAO;KACX,cAAc,KAAK;KACnB,UAAU,KAAK,qBAAqB;KACpC,SAAS,KAAK;KACd,WAAW,KAAK;KAChB,MAAM,oBAAoB;KAC1B,WAAW;KACZ;AACD,2BACE,IAAI,MACF,wBAAwB,UAAU,MAAM,KAAK,UAAU,KAAK,GAC7D,CACF;MACA,UAAU;AAEb,QAAK,QAAQ,KAAK;IAAE;IAAQ;IAAS;IAAQ;IAAO,CAAC;IACrD;;CAGJ,WAAW;AAET,SAAO;GACL,aAAa,KAAK,qBAAqB;GACvC,SAAS,KAAK;GACd,OAAO,KAAK;GACZ,gBAAgB,KAAK;GACrB,WAAW,KAAK;GAChB,cAAc,KAAK;GACnB,YAAY;IACV,SAAS,KAAK,MAAM,QAAQ,MAAM,SAAS,KAAK,MAAM,QAAQ;IAC9D,WACE,KAAK,MAAM,UAAU,MAAM,SAAS,KAAK,MAAM,UAAU;IAC3D,UAAU,KAAK,MAAM,SAAS,MAAM,SAAS,KAAK,MAAM,SAAS;IACjE,MAAM,KAAK,MAAM,KAAK,MAAM,SAAS,KAAK,MAAM,KAAK;IACtD;GAED,WAAW,KAAK;GAChB,mBAAmB,KAAK;GACzB;;CAGH,kBAA0B;AACxB,SAAO,KAAK;;CAGd,gBAAsB;AACpB,MAAI,CAAC,KAAK,WAAW,KAAK,iBAAiB,CACzC,MAAK,OAAO;;CAIhB,kBAAqB,IAAa,YAA8B,SAAY;EAC1E,MAAM,gBAAgB,KAAK;AAC3B,OAAK,YAAY;AAEjB,MAAI;AACF,UAAO,IAAI;YACH;AACR,QAAK,YAAY;AAEjB,OAAI,CAAC,KAAK,UACR,KAAI,cAAc,OAChB,MAAK,eAAe;OAEpB,MAAK,mBAAmB;;;CAMhC,aAAa,GAAY;AACvB,OAAK,YAAY;AACjB,MAAI,CAAC,EACH,MAAK,mBAAmB;;CAI5B,cAAuB;AACrB,SAAO,KAAK;;CAGd,cAAuB;AACrB,SAAO,KAAK,WAAW,KAAK,iBAAiB;;CAI/C,wBAAgC;EAC9B,MAAM,YAAY,KAAK,qBAAqB;AAC5C,MAAI,aAAa,EAAG,QAAO;AAE3B,MAAI,KAAK,SAAS;AAChB,QAAK,MAAM,QAAQ,iBAAiB;IAClC,MAAM,QAAQ,KAAK,MAAM;AACzB,UAAM,MAAM,SAAS,MAAM;;AAE7B,QAAK,YAAY,KAAK,IAAI,GAAG,KAAK,YAAY,UAAU;AACxD,wBAAqB;AACnB,QAAI;AACF,UAAK;AACL,UAAK,gBAAgB;aACd,GAAG;KAGZ;AACF,UAAO;;AAGT,OAAK,MAAM,QAAQ,iBAAiB;GAClC,MAAM,QAAQ,KAAK,MAAM;AACzB,SAAM,MAAM,SAAS;AACrB,SAAM,OAAO;;AAEf,OAAK,YAAY,KAAK,IAAI,GAAG,KAAK,YAAY,UAAU;AACxD,OAAK;AACL,OAAK,gBAAgB;AACrB,SAAO;;CAGT,iBAAyB;AACvB,MAAI,KAAK,QAAQ,WAAW,EAAG;EAC/B,MAAM,QAA2B,EAAE;EACnC,MAAM,YAAiC,EAAE;AAEzC,OAAK,MAAM,KAAK,KAAK,QACnB,KAAI,KAAK,gBAAgB,EAAE,QAAQ;AACjC,OAAI,EAAE,MAAO,cAAa,EAAE,MAAM;AAClC,SAAM,KAAK,EAAE,QAAQ;QAErB,WAAU,KAAK,EAAE;AAIrB,OAAK,UAAU;AACf,OAAK,MAAM,KAAK,MAAO,IAAG;;;AAI9B,MAAa,kBAAkB,IAAI,WAAW;AAE9C,SAAgB,uBAAgC;AAC9C,QAAO,gBAAgB,aAAa;;AAGtC,SAAgB,qBAAqB,SAAuC;AAC1E,SAAQ,UAAiB;AACvB,MAAI;AACF,mBAAgB,wBAAwB;AACtC,YAAQ,KAAK,MAAM,MAAM;KACzB;WACK,OAAO;AACd,UAAO,MAAM,+BAA+B,MAAM"}

package/dist/runtime/selector.d.ts

@@ -0,0 +1,11 @@
+//#region src/runtime/selector.d.ts
+interface Selector<T> {
+  (candidate: T): boolean;
+}
+type SelectorEquals<T> = {
+  bivarianceHack(a: T, b: T): boolean;
+}['bivarianceHack'];
+declare function selector<T>(source: () => T, equals?: SelectorEquals<T>): Selector<T>;
+//#endregion
+export { Selector, selector };
+//# sourceMappingURL=selector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selector.d.ts","names":[],"sources":["../../src/runtime/selector.ts"],"mappings":";UA6BiB,QAAA;EAAA,CACd,SAAA,EAAW,CAAA;AAAA;AAAA,KAOT,cAAA;EACH,cAAA,CAAe,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA;AAAA;AAAA,iBAwRV,QAAA,GAAA,CACd,MAAA,QAAc,CAAA,EACd,MAAA,GAAQ,cAAA,CAAe,CAAA,IACtB,QAAA,CAAS,CAAA"}

package/dist/runtime/selector.js

@@ -0,0 +1,188 @@
+import { incrementPerfMetric } from "./perf-metrics.js";
+import { globalScheduler } from "./scheduler.js";
+import { clearDerivedDependencySubscriptions, markReactivePropsDirtySource, markReadableDerivedSubscribersDirty, markReadableUsage, notifyReadableReaders, recordReadableRead, syncDerivedDependencySubscriptions, withDerivedReadTracking } from "./readable.js";
+import { claimHookIndex, getCurrentInstance } from "./component.js";
+//#region src/runtime/selector.ts
+const selectorCells = /* @__PURE__ */ new WeakMap();
+const dirtySelectorCells = /* @__PURE__ */ new Set();
+let hasPendingSelectorFlush = false;
+function getSelectorStore(instance) {
+	let store = selectorCells.get(instance);
+	if (!store) {
+		store = /* @__PURE__ */ new Map();
+		selectorCells.set(instance, store);
+	}
+	return store;
+}
+function scheduleSelectorFlush() {
+	if (hasPendingSelectorFlush) return;
+	hasPendingSelectorFlush = true;
+	globalScheduler.enqueueInLane("derived", flushDirtySelectorCells);
+}
+function markSelectorCellDirty(cell) {
+	cell._dirty = true;
+	if (cell._scheduled) return;
+	cell._scheduled = true;
+	dirtySelectorCells.add(cell);
+	scheduleSelectorFlush();
+}
+function flushDirtySelectorCells() {
+	hasPendingSelectorFlush = false;
+	if (dirtySelectorCells.size === 0) return;
+	const pending = Array.from(dirtySelectorCells);
+	dirtySelectorCells.clear();
+	for (const cell of pending) {
+		cell._scheduled = false;
+		if (!cell._dirty) continue;
+		recomputeSelectorCell(cell, true);
+	}
+}
+function isObjectCandidate(value) {
+	return typeof value === "object" && value !== null || typeof value === "function";
+}
+function isDefaultSelectorEquals(equals) {
+	return equals === Object.is;
+}
+function createCandidateSource(candidate) {
+	const source = (() => false);
+	source._candidate = candidate;
+	return source;
+}
+function getCandidateSource(cell, candidate) {
+	if (isObjectCandidate(candidate)) {
+		const cached = cell._objectCandidates.get(candidate);
+		if (cached) return cached;
+		const created = createCandidateSource(candidate);
+		created._candidate = candidate;
+		cell._objectCandidates.set(candidate, created);
+		cell._objectCandidateSources.add(created);
+		return created;
+	}
+	const key = candidate;
+	const cached = cell._primitiveCandidates.get(key);
+	if (cached) return cached;
+	const created = createCandidateSource(candidate);
+	created._candidate = candidate;
+	cell._primitiveCandidates.set(key, created);
+	return created;
+}
+function notifySelectorSource(source) {
+	incrementPerfMetric("selectorInvalidations");
+	markReadableDerivedSubscribersDirty(source);
+	markReactivePropsDirtySource(source);
+	notifyReadableReaders(source);
+}
+function notifyAllSelectorSources(cell) {
+	for (const source of cell._primitiveCandidates.values()) notifySelectorSource(source);
+	for (const source of cell._objectCandidateSources) notifySelectorSource(source);
+}
+function notifySelectorValueChange(cell, prevValue, nextValue) {
+	if (!isDefaultSelectorEquals(cell._equals)) {
+		notifyAllSelectorSources(cell);
+		return;
+	}
+	if (!Object.is(prevValue, nextValue)) {
+		notifySelectorSource(getCandidateSource(cell, prevValue));
+		notifySelectorSource(getCandidateSource(cell, nextValue));
+	}
+}
+function recomputeSelectorCell(cell, notifyDownstream) {
+	if (!cell._dirty && cell._hasValue) return cell._value;
+	if (cell._evaluating) throw new Error("selector() cannot read itself recursively");
+	cell._evaluating = true;
+	cell._dirty = false;
+	cell._pendingDependencySources = /* @__PURE__ */ new Set();
+	const prevSources = cell._sources;
+	const hadValue = cell._hasValue;
+	const prevValue = cell._value;
+	let nextValue;
+	try {
+		nextValue = withDerivedReadTracking(cell, cell._source);
+	} catch (error) {
+		cell._dirty = true;
+		cell._pendingDependencySources = void 0;
+		throw error;
+	} finally {
+		cell._evaluating = false;
+	}
+	const nextSources = cell._pendingDependencySources ?? /* @__PURE__ */ new Set();
+	cell._pendingDependencySources = void 0;
+	syncDerivedDependencySubscriptions(cell, prevSources, nextSources);
+	cell._sources = nextSources;
+	const valueChanged = !cell._hasValue || !cell._equals(prevValue, nextValue);
+	cell._hasValue = true;
+	cell._value = nextValue;
+	if (valueChanged && notifyDownstream && hadValue) notifySelectorValueChange(cell, prevValue, nextValue);
+	return cell._value;
+}
+function createSelectorCell(instance, hookIndex, source, equals) {
+	const cell = function selectorPredicate(candidate) {
+		recordReadableRead(getCandidateSource(cell, candidate));
+		incrementPerfMetric("selectorCandidateReads");
+		const current = recomputeSelectorCell(cell, cell._scheduled);
+		return cell._equals(current, candidate);
+	};
+	cell._owner = instance;
+	cell._hookIndex = hookIndex;
+	cell._source = source;
+	cell._equals = equals;
+	cell._value = void 0;
+	cell._hasValue = false;
+	cell._dirty = true;
+	cell._scheduled = false;
+	cell._evaluating = false;
+	cell._sources = /* @__PURE__ */ new Set();
+	cell._primitiveCandidates = /* @__PURE__ */ new Map();
+	cell._objectCandidates = /* @__PURE__ */ new WeakMap();
+	cell._objectCandidateSources = /* @__PURE__ */ new Set();
+	cell._markDirty = () => {
+		markSelectorCellDirty(cell);
+	};
+	cell._cleanup = () => {
+		cell._scheduled = false;
+		cell._dirty = false;
+		cell._hasValue = false;
+		dirtySelectorCells.delete(cell);
+		clearDerivedDependencySubscriptions(cell, cell._sources);
+		for (const sourceRef of cell._primitiveCandidates.values()) {
+			sourceRef._readers?.clear();
+			sourceRef._derivedSubscribers?.clear();
+		}
+		for (const sourceRef of cell._objectCandidateSources) {
+			sourceRef._readers?.clear();
+			sourceRef._derivedSubscribers?.clear();
+		}
+		cell._primitiveCandidates.clear();
+		cell._objectCandidateSources.clear();
+	};
+	(instance.cleanupFns ??= []).push(() => {
+		cell._cleanup();
+		selectorCells.get(instance)?.delete(hookIndex);
+	});
+	return cell;
+}
+function getOrCreateSelectorCell(instance, hookIndex, source, equals) {
+	const store = getSelectorStore(instance);
+	const existing = store.get(hookIndex);
+	if (existing) {
+		existing._source = source;
+		existing._equals = equals;
+		existing._dirty = true;
+		return existing;
+	}
+	const created = createSelectorCell(instance, hookIndex, source, equals);
+	store.set(hookIndex, created);
+	return created;
+}
+function selector(source, equals = Object.is) {
+	markReadableUsage(source);
+	const instance = getCurrentInstance();
+	if (!instance) throw new Error("selector() can only be called during component render execution. Move selector() calls to the top level of your component function.");
+	const cell = getOrCreateSelectorCell(instance, claimHookIndex(instance, "selector"), source, equals);
+	recomputeSelectorCell(cell, false);
+	return cell;
+}
+//#endregion
+export { selector };
+
+//# sourceMappingURL=selector.js.map

package/dist/runtime/selector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selector.js","names":[],"sources":["../../src/runtime/selector.ts"],"sourcesContent":["import {\n  claimHookIndex,\n  getCurrentInstance,\n  type ComponentInstance,\n} from './component';\nimport { globalScheduler } from './scheduler';\nimport {\n  clearDerivedDependencySubscriptions,\n  markReadableDerivedSubscribersDirty,\n  markReadableUsage,\n  markReactivePropsDirtySource,\n  notifyReadableReaders,\n  recordReadableRead,\n  syncDerivedDependencySubscriptions,\n  withDerivedReadTracking,\n  type DerivedSubscriber,\n  type ReadableSource,\n} from './readable';\nimport { incrementPerfMetric } from './perf-metrics';\n\ntype PrimitiveKey =\n  | string\n  | number\n  | boolean\n  | symbol\n  | bigint\n  | null\n  | undefined;\n\nexport interface Selector<T> {\n  (candidate: T): boolean;\n}\n\ninterface SelectorCandidateSource<T> extends ReadableSource<boolean> {\n  _candidate: T;\n}\n\ntype SelectorEquals<T> = {\n  bivarianceHack(a: T, b: T): boolean;\n}['bivarianceHack'];\n\ninterface SelectorCell<T> extends Selector<T>, DerivedSubscriber {\n  _owner: ComponentInstance;\n  _hookIndex: number;\n  _source: () => T;\n  _equals: SelectorEquals<T>;\n  _value: T;\n  _hasValue: boolean;\n  _dirty: boolean;\n  _scheduled: boolean;\n  _evaluating: boolean;\n  _sources: Set<ReadableSource<unknown>>;\n  _pendingDependencySources?: Set<ReadableSource<unknown>>;\n  _primitiveCandidates: Map<PrimitiveKey, SelectorCandidateSource<T>>;\n  _objectCandidates: WeakMap<object, SelectorCandidateSource<T>>;\n  _objectCandidateSources: Set<SelectorCandidateSource<T>>;\n  _cleanup(): void;\n}\n\nconst selectorCells = new WeakMap<\n  ComponentInstance,\n  Map<number, SelectorCell<unknown>>\n>();\nconst dirtySelectorCells = new Set<SelectorCell<unknown>>();\nlet hasPendingSelectorFlush = false;\n\nfunction getSelectorStore(\n  instance: ComponentInstance\n): Map<number, SelectorCell<unknown>> {\n  let store = selectorCells.get(instance);\n  if (!store) {\n    store = new Map();\n    selectorCells.set(instance, store);\n  }\n  return store;\n}\n\nfunction scheduleSelectorFlush(): void {\n  if (hasPendingSelectorFlush) {\n    return;\n  }\n  hasPendingSelectorFlush = true;\n  globalScheduler.enqueueInLane('derived', flushDirtySelectorCells);\n}\n\nfunction markSelectorCellDirty(cell: SelectorCell<unknown>): void {\n  cell._dirty = true;\n  if (cell._scheduled) {\n    return;\n  }\n\n  cell._scheduled = true;\n  dirtySelectorCells.add(cell);\n  scheduleSelectorFlush();\n}\n\nfunction flushDirtySelectorCells(): void {\n  hasPendingSelectorFlush = false;\n\n  if (dirtySelectorCells.size === 0) {\n    return;\n  }\n\n  const pending = Array.from(dirtySelectorCells);\n  dirtySelectorCells.clear();\n\n  for (const cell of pending) {\n    cell._scheduled = false;\n    if (!cell._dirty) {\n      continue;\n    }\n    recomputeSelectorCell(cell, true);\n  }\n}\n\nfunction isObjectCandidate(value: unknown): value is object {\n  return (\n    (typeof value === 'object' && value !== null) || typeof value === 'function'\n  );\n}\n\nfunction isDefaultSelectorEquals<T>(equals: SelectorEquals<T>): boolean {\n  return equals === Object.is;\n}\n\nfunction createCandidateSource<T>(candidate: T): SelectorCandidateSource<T> {\n  const source = (() => false) as SelectorCandidateSource<T>;\n  source._candidate = candidate;\n  return source;\n}\n\nfunction getCandidateSource<T>(\n  cell: SelectorCell<T>,\n  candidate: T\n): SelectorCandidateSource<T> {\n  if (isObjectCandidate(candidate)) {\n    const cached = cell._objectCandidates.get(candidate);\n    if (cached) {\n      return cached;\n    }\n\n    const created = createCandidateSource(candidate);\n    created._candidate = candidate;\n    cell._objectCandidates.set(candidate, created);\n    cell._objectCandidateSources.add(created);\n    return created;\n  }\n\n  const key = candidate as PrimitiveKey;\n  const cached = cell._primitiveCandidates.get(key);\n  if (cached) {\n    return cached;\n  }\n\n  const created = createCandidateSource(candidate);\n  created._candidate = candidate;\n  cell._primitiveCandidates.set(key, created);\n  return created;\n}\n\nfunction notifySelectorSource(source: SelectorCandidateSource<unknown>): void {\n  incrementPerfMetric('selectorInvalidations');\n  markReadableDerivedSubscribersDirty(source);\n  markReactivePropsDirtySource(source);\n  notifyReadableReaders(source);\n}\n\nfunction notifyAllSelectorSources<T>(cell: SelectorCell<T>): void {\n  for (const source of cell._primitiveCandidates.values()) {\n    notifySelectorSource(source);\n  }\n  for (const source of cell._objectCandidateSources) {\n    notifySelectorSource(source);\n  }\n}\n\nfunction notifySelectorValueChange<T>(\n  cell: SelectorCell<T>,\n  prevValue: T,\n  nextValue: T\n): void {\n  if (!isDefaultSelectorEquals(cell._equals)) {\n    notifyAllSelectorSources(cell);\n    return;\n  }\n\n  if (!Object.is(prevValue, nextValue)) {\n    notifySelectorSource(getCandidateSource(cell, prevValue));\n    notifySelectorSource(getCandidateSource(cell, nextValue));\n  }\n}\n\nfunction recomputeSelectorCell<T>(\n  cell: SelectorCell<T>,\n  notifyDownstream: boolean\n): T {\n  if (!cell._dirty && cell._hasValue) {\n    return cell._value;\n  }\n\n  if (cell._evaluating) {\n    throw new Error('selector() cannot read itself recursively');\n  }\n\n  cell._evaluating = true;\n  cell._dirty = false;\n  cell._pendingDependencySources = new Set();\n\n  const prevSources = cell._sources;\n  const hadValue = cell._hasValue;\n  const prevValue = cell._value;\n  let nextValue: T;\n\n  try {\n    nextValue = withDerivedReadTracking(cell, cell._source);\n  } catch (error) {\n    cell._dirty = true;\n    cell._pendingDependencySources = undefined;\n    throw error;\n  } finally {\n    cell._evaluating = false;\n  }\n\n  const nextSources = cell._pendingDependencySources ?? new Set();\n  cell._pendingDependencySources = undefined;\n  syncDerivedDependencySubscriptions(cell, prevSources, nextSources);\n  cell._sources = nextSources;\n\n  const valueChanged = !cell._hasValue || !cell._equals(prevValue, nextValue);\n  cell._hasValue = true;\n  cell._value = nextValue;\n\n  if (valueChanged && notifyDownstream && hadValue) {\n    notifySelectorValueChange(cell, prevValue, nextValue);\n  }\n\n  return cell._value;\n}\n\nfunction createSelectorCell<T>(\n  instance: ComponentInstance,\n  hookIndex: number,\n  source: () => T,\n  equals: SelectorEquals<T>\n): SelectorCell<T> {\n  const cell = function selectorPredicate(candidate: T): boolean {\n    const sourceRef = getCandidateSource(cell as SelectorCell<T>, candidate);\n    recordReadableRead(sourceRef);\n    incrementPerfMetric('selectorCandidateReads');\n    const current = recomputeSelectorCell(\n      cell as SelectorCell<T>,\n      (cell as SelectorCell<T>)._scheduled\n    );\n    return (cell as SelectorCell<T>)._equals(current, candidate);\n  } as SelectorCell<T>;\n\n  cell._owner = instance;\n  cell._hookIndex = hookIndex;\n  cell._source = source;\n  cell._equals = equals;\n  cell._value = undefined as T;\n  cell._hasValue = false;\n  cell._dirty = true;\n  cell._scheduled = false;\n  cell._evaluating = false;\n  cell._sources = new Set();\n  cell._primitiveCandidates = new Map();\n  cell._objectCandidates = new WeakMap();\n  cell._objectCandidateSources = new Set();\n  cell._markDirty = () => {\n    markSelectorCellDirty(cell as unknown as SelectorCell<unknown>);\n  };\n  cell._cleanup = () => {\n    cell._scheduled = false;\n    cell._dirty = false;\n    cell._hasValue = false;\n    dirtySelectorCells.delete(cell as unknown as SelectorCell<unknown>);\n    clearDerivedDependencySubscriptions(cell, cell._sources);\n    for (const sourceRef of cell._primitiveCandidates.values()) {\n      sourceRef._readers?.clear();\n      sourceRef._derivedSubscribers?.clear();\n    }\n    for (const sourceRef of cell._objectCandidateSources) {\n      sourceRef._readers?.clear();\n      sourceRef._derivedSubscribers?.clear();\n    }\n    cell._primitiveCandidates.clear();\n    cell._objectCandidateSources.clear();\n  };\n\n  (instance.cleanupFns ??= []).push(() => {\n    cell._cleanup();\n    selectorCells.get(instance)?.delete(hookIndex);\n  });\n\n  return cell;\n}\n\nfunction getOrCreateSelectorCell<T>(\n  instance: ComponentInstance,\n  hookIndex: number,\n  source: () => T,\n  equals: SelectorEquals<T>\n): SelectorCell<T> {\n  const store = getSelectorStore(instance);\n  const existing = store.get(hookIndex) as SelectorCell<T> | undefined;\n  if (existing) {\n    existing._source = source;\n    existing._equals = equals;\n    existing._dirty = true;\n    return existing;\n  }\n\n  const created = createSelectorCell(instance, hookIndex, source, equals);\n  store.set(hookIndex, created as unknown as SelectorCell<unknown>);\n  return created;\n}\n\nexport function selector<T>(\n  source: () => T,\n  equals: SelectorEquals<T> = Object.is\n): Selector<T> {\n  markReadableUsage(source);\n\n  const instance = getCurrentInstance();\n  if (!instance) {\n    throw new Error(\n      'selector() can only be called during component render execution. ' +\n        'Move selector() calls to the top level of your component function.'\n    );\n  }\n\n  const hookIndex = claimHookIndex(instance, 'selector');\n  const cell = getOrCreateSelectorCell(instance, hookIndex, source, equals);\n  recomputeSelectorCell(cell, false);\n  return cell;\n}\n"],"mappings":"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"}

package/dist/runtime/ssr-bridge.js

@@ -1 +1,24 @@
-const t={getCurrentSSRContext(){return null},throwSSRDataMissing(){throw new Error("[Askr] SSR data missing (SSR bridge not installed). If you are rendering on the server, ensure you are using the askr SSR entrypoints.")},getCurrentRenderData(){return null},getNextKey(){throw new Error("[Askr] getNextKey() called outside SSR render phase (SSR bridge not installed).")}};let e=t;function n(r){e=r}function i(){return e}export{i as getSSRBridge,n as installSSRBridge};
+let bridge = {
+	getCurrentSSRContext() {
+		return null;
+	},
+	throwSSRDataMissing() {
+		throw new Error("[Askr] SSR data missing (SSR bridge not installed). If you are rendering on the server, ensure you are using the askr SSR entrypoints.");
+	},
+	getCurrentRenderData() {
+		return null;
+	},
+	getNextKey() {
+		throw new Error("[Askr] getNextKey() called outside SSR render phase (SSR bridge not installed).");
+	}
+};
+function installSSRBridge(next) {
+	bridge = next;
+}
+function getSSRBridge() {
+	return bridge;
+}
+//#endregion
+export { getSSRBridge, installSSRBridge };
+
+//# sourceMappingURL=ssr-bridge.js.map

package/dist/runtime/ssr-bridge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssr-bridge.js","names":[],"sources":["../../src/runtime/ssr-bridge.ts"],"sourcesContent":["import type { RenderContext } from '../common/ssr';\n\nexport type SSRBridge = {\n  getCurrentSSRContext(): RenderContext | null;\n  throwSSRDataMissing(): never;\n\n  // Deterministic SSR render-phase data lookup\n  getCurrentRenderData(): Record<string, unknown> | null;\n  getNextKey(): string;\n};\n\nconst defaultBridge: SSRBridge = {\n  getCurrentSSRContext() {\n    return null;\n  },\n  throwSSRDataMissing() {\n    throw new Error(\n      '[Askr] SSR data missing (SSR bridge not installed). ' +\n        'If you are rendering on the server, ensure you are using the askr SSR entrypoints.'\n    );\n  },\n  getCurrentRenderData() {\n    return null;\n  },\n  getNextKey() {\n    throw new Error(\n      '[Askr] getNextKey() called outside SSR render phase (SSR bridge not installed).'\n    );\n  },\n};\n\nlet bridge: SSRBridge = defaultBridge;\n\nexport function installSSRBridge(next: SSRBridge): void {\n  bridge = next;\n}\n\nexport function getSSRBridge(): SSRBridge {\n  return bridge;\n}\n"],"mappings":"AA+BA,IAAI,SAAoB;CAnBtB,uBAAuB;AACrB,SAAO;;CAET,sBAAsB;AACpB,QAAM,IAAI,MACR,yIAED;;CAEH,uBAAuB;AACrB,SAAO;;CAET,aAAa;AACX,QAAM,IAAI,MACR,kFACD;;CAImB;AAExB,SAAgB,iBAAiB,MAAuB;AACtD,UAAS;;AAGX,SAAgB,eAA0B;AACxC,QAAO"}