@askrjs/askr 0.3.0 → 0.4.0

package/dist/instance-BAnfmXOR.js

@@ -0,0 +1,988 @@
+//#region src/common/env.ts
+function normalizeEnvValue(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "boolean" || typeof value === "number") return String(value);
+}
+function getBuildTimeMetaEnv() {
+	return import.meta.env;
+}
+function getBuildTimeNodeEnv(metaEnv) {
+	const nodeEnv = normalizeEnvValue(metaEnv?.NODE_ENV);
+	if (nodeEnv != null || !metaEnv) return nodeEnv;
+	if (typeof metaEnv.MODE === "string" && metaEnv.MODE.length > 0) return metaEnv.MODE;
+	if (metaEnv.PROD === true || metaEnv.PROD === "true") return "production";
+	if (metaEnv.DEV === true || metaEnv.DEV === "true") return "development";
+}
+function resolveNodeEnv(processNodeEnv, buildNodeEnv) {
+	if (buildNodeEnv === "production") return "production";
+	if (processNodeEnv != null) return processNodeEnv;
+	if (buildNodeEnv === "development") return "development";
+	return buildNodeEnv === "test" ? void 0 : buildNodeEnv;
+}
+/**
+* Resolves one environment variable. Build-time values (`import.meta.env`)
+* take precedence over `process.env`, except that `NODE_ENV` follows
+* `resolveNodeEnv`. Only the requested variable is read: enumerating
+* `process.env` is costly on some hosts (every enumeration copies the
+* environment block on Windows), and these checks run on hot paths such as
+* every component render.
+*/
+function getRuntimeEnvValue(name) {
+	const processValue = globalThis.process?.env?.[name];
+	const metaEnv = getBuildTimeMetaEnv();
+	if (name === "NODE_ENV") return resolveNodeEnv(processValue, getBuildTimeNodeEnv(metaEnv));
+	return normalizeEnvValue(metaEnv?.[name]) ?? processValue;
+}
+function isProductionEnvironment() {
+	return getRuntimeEnvValue("NODE_ENV") === "production";
+}
+function isDevelopmentEnvironment() {
+	return !isProductionEnvironment();
+}
+//#endregion
+//#region src/common/logger.ts
+/**
+* Shared logger interface for runtime and tooling code.
+*
+* Debug, info, and warn stay silent in production. Errors always log.
+*/
+function callConsole(method, args) {
+	const c = typeof console !== "undefined" ? console : void 0;
+	if (!c) return;
+	const fn = c[method];
+	if (typeof fn === "function") try {
+		fn.apply(console, args);
+	} catch {}
+}
+const logger = {
+	debug: (...args) => {
+		if (isProductionEnvironment()) return;
+		callConsole("debug", args);
+	},
+	info: (...args) => {
+		if (isProductionEnvironment()) return;
+		callConsole("info", args);
+	},
+	warn: (...args) => {
+		if (isProductionEnvironment()) return;
+		callConsole("warn", args);
+	},
+	error: (...args) => {
+		callConsole("error", args);
+	}
+};
+//#endregion
+//#region src/core/component/diagnostics.ts
+let settings = {
+	slowRenderWarnings: true,
+	slowRenderThresholdMs: 5
+};
+/** Configure render diagnostics; returns a function restoring the previous settings. */
+function configureRenderDiagnostics(options) {
+	const threshold = options.slowRenderThresholdMs;
+	if (threshold !== void 0 && (!Number.isFinite(threshold) || threshold < 0)) throw new TypeError("configureRenderDiagnostics slowRenderThresholdMs must be a finite, non-negative number.");
+	const previous = settings;
+	settings = {
+		slowRenderWarnings: options.slowRenderWarnings ?? previous.slowRenderWarnings,
+		slowRenderThresholdMs: threshold ?? previous.slowRenderThresholdMs
+	};
+	let restored = false;
+	return () => {
+		if (restored) return;
+		restored = true;
+		settings = previous;
+	};
+}
+const warned = /* @__PURE__ */ new WeakSet();
+function isTimingRenders() {
+	return false;
+}
+function reportRenderTime(instance, name, milliseconds) {
+	if (milliseconds <= settings.slowRenderThresholdMs || warned.has(instance)) return;
+	warned.add(instance);
+	logger.warn(`[askr] Slow render detected in ${name}: ${milliseconds}ms. Consider optimizing component performance.`);
+}
+//#endregion
+//#region src/core/reactive/owner.ts
+var Owner = class {
+	constructor(parent) {
+		this.owned = null;
+		this.ownedHoles = 0;
+		this.ownedIndex = -1;
+		this.cleanups = null;
+		this.context = null;
+		this.disposed = false;
+		this.parent = parent;
+		if (parent) {
+			const owned = parent.owned ??= [];
+			this.ownedIndex = owned.length;
+			owned.push(this);
+		}
+	}
+	onCleanup(fn) {
+		if (this.disposed) {
+			fn();
+			return;
+		}
+		(this.cleanups ??= []).push(fn);
+	}
+	lookup(key) {
+		if (this.context?.has(key)) return this.context.get(key);
+		for (let owner = this.parent; owner; owner = owner.parent) if (owner.context?.has(key)) return owner.context.get(key);
+	}
+	/** Detach from the parent without disposing (the caller disposes). */
+	detach() {
+		const parent = this.parent;
+		const siblings = parent?.owned;
+		if (parent && siblings && siblings[this.ownedIndex] === this) {
+			if (this.ownedIndex === siblings.length - 1) {
+				siblings.pop();
+				while (siblings.length && siblings[siblings.length - 1] === null) {
+					siblings.pop();
+					parent.ownedHoles--;
+				}
+			} else {
+				siblings[this.ownedIndex] = null;
+				parent.ownedHoles++;
+				if (parent.ownedHoles > 16 && parent.ownedHoles * 2 > siblings.length) compactOwned(parent, siblings);
+			}
+		}
+		this.parent = null;
+		this.ownedIndex = -1;
+	}
+	/**
+	* Dispose this owner and everything it owns. Returns the failures instead of
+	* throwing so a caller can decide whether to report or aggregate them.
+	*/
+	dispose(errors = []) {
+		if (this.disposed) return errors;
+		this.detach();
+		disposeTree(this, errors);
+		return errors;
+	}
+	/** Dispose owned children and run cleanups, keeping this owner alive. */
+	reset(errors = []) {
+		disposeChildren(this, errors);
+		runCleanups(this, errors);
+		return errors;
+	}
+	onDispose() {}
+};
+function compactOwned(parent, siblings) {
+	let next = 0;
+	for (const child of siblings) {
+		if (!child) continue;
+		child.ownedIndex = next;
+		siblings[next++] = child;
+	}
+	siblings.length = next;
+	parent.ownedHoles = 0;
+}
+/** Take `owner`'s children, leaving it with none. */
+function takeOwned(owner) {
+	const owned = owner.owned;
+	owner.owned = null;
+	owner.ownedHoles = 0;
+	return owned;
+}
+function disposeChildren(owner, errors) {
+	const owned = takeOwned(owner);
+	if (!owned) return;
+	for (let i = owned.length - 1; i >= 0; i--) {
+		const child = owned[i];
+		if (!child) continue;
+		child.parent = null;
+		disposeTree(child, errors);
+	}
+}
+function runCleanups(owner, errors) {
+	const cleanups = owner.cleanups;
+	if (!cleanups) return;
+	owner.cleanups = null;
+	for (let i = cleanups.length - 1; i >= 0; i--) try {
+		cleanups[i]();
+	} catch (error) {
+		errors.push(error);
+	}
+}
+function disposeTree(owner, errors) {
+	const pending = [{
+		owner,
+		finish: false
+	}];
+	while (pending.length) {
+		const frame = pending.pop();
+		const current = frame.owner;
+		if (frame.finish) {
+			runCleanups(current, errors);
+			try {
+				current.onDispose();
+			} catch (error) {
+				errors.push(error);
+			}
+			continue;
+		}
+		if (frame.detach) current.parent = null;
+		if (current.disposed) continue;
+		current.disposed = true;
+		pending.push({
+			owner: current,
+			finish: true
+		});
+		const children = takeOwned(current);
+		if (!children) continue;
+		for (const child of children) if (child) pending.push({
+			owner: child,
+			finish: false,
+			detach: true
+		});
+	}
+}
+let currentOwner = null;
+function getOwner() {
+	return currentOwner;
+}
+function runWithOwner(owner, fn) {
+	const previous = currentOwner;
+	currentOwner = owner;
+	try {
+		return fn();
+	} finally {
+		currentOwner = previous;
+	}
+}
+//#endregion
+//#region src/core/reactive/graph.ts
+/**
+* Reactive graph.
+*
+* Sources hold values; computations derive values or perform effects from
+* the sources they read. A write marks direct observers DIRTY and everything
+* downstream of them CHECK. A computation that is read (or run by the
+* scheduler) first brings its CHECK sources up to date and only re-runs if
+* one of them actually changed, so updates are glitch-free and unchanged
+* derived values cut propagation off.
+*
+* There is one subscriber kind. `derive()`, `selector()`, fine-grained
+* bindings, `watch()`, and component renders are all computations; they
+* differ only in how they are scheduled when they go stale.
+*/
+const CLEAN = 0;
+const CHECK = 1;
+const DIRTY = 2;
+function unobserve(source, observer) {
+	const observers = source._observers;
+	if (!observers?.delete(observer) || observers.size > 0) return;
+	source._unobserved?.();
+}
+let tracking = null;
+let trackingSources = null;
+function track(source) {
+	if (trackingSources) trackingSources.add(source);
+}
+/** Notify every observer of `source` that its value changed. */
+function notifySource(source, except) {
+	const observers = source._observers;
+	if (!observers) return;
+	for (const observer of observers) if (observer !== except) observer._mark(DIRTY);
+}
+/** Record a read of `source` by the running computation. */
+function trackSource(source) {
+	track(source);
+}
+function isTracking() {
+	return trackingSources !== null;
+}
+function getTrackingComputation() {
+	return tracking;
+}
+function untrack(fn) {
+	const previous = tracking;
+	const previousSources = trackingSources;
+	tracking = null;
+	trackingSources = null;
+	try {
+		return fn();
+	} finally {
+		tracking = previous;
+		trackingSources = previousSources;
+	}
+}
+var Signal = class {
+	constructor(value, equals = Object.is) {
+		this._observers = null;
+		this._value = value;
+		this._equals = equals;
+	}
+	read() {
+		track(this);
+		return this._value;
+	}
+	peek() {
+		return this._value;
+	}
+	/** Returns true when the value changed and observers were notified. */
+	write(value) {
+		if (this._equals(this._value, value)) return false;
+		this._value = value;
+		notifySource(this);
+		return true;
+	}
+};
+var Computation = class Computation extends Owner {
+	constructor(owner, fn, schedule, equals = Object.is, failedRunSources = "union") {
+		super(owner);
+		this._observers = null;
+		this._sources = null;
+		this._state = DIRTY;
+		this._value = void 0;
+		this._error = void 0;
+		this._hasError = false;
+		this._running = false;
+		this._invalidatedWhileRunning = false;
+		this._dropped = false;
+		this._fn = fn;
+		this._schedule = schedule;
+		this._equals = equals;
+		this._failedRunSources = failedRunSources;
+	}
+	/** Read the current value, recomputing if a source changed. */
+	read() {
+		if (this._running) throw new Error("Circular reactive dependency detected.");
+		track(this);
+		this.update();
+		if (this._hasError) throw this._error;
+		return this._value;
+	}
+	get stale() {
+		return this._state !== CLEAN;
+	}
+	/** Bring this computation up to date, running it only if a source changed. */
+	update() {
+		if (this.disposed) return;
+		if (this._state === CHECK) {
+			for (const source of this._sources ?? EMPTY) if (source instanceof Computation) {
+				source.update();
+				if (this._state === DIRTY) break;
+			}
+		}
+		if (this._state === DIRTY) this.run();
+		else this._state = CLEAN;
+	}
+	/** Run unconditionally, tracking the sources read. */
+	run() {
+		if (this.disposed) return;
+		const previous = tracking;
+		const previousSources = trackingSources;
+		const nextSources = /* @__PURE__ */ new Set();
+		tracking = this;
+		trackingSources = nextSources;
+		this._running = true;
+		this._invalidatedWhileRunning = false;
+		this._dropped = false;
+		let value;
+		let error;
+		let failed = false;
+		try {
+			value = this._fn();
+		} catch (caught) {
+			failed = true;
+			error = caught;
+		} finally {
+			this._running = false;
+			tracking = previous;
+			trackingSources = previousSources;
+		}
+		if (this.disposed) return;
+		this._state = this._invalidatedWhileRunning ? DIRTY : CLEAN;
+		this.setSources(failed && this._failedRunSources === "previous" ? new Set(this._sources ?? EMPTY) : nextSources, failed && this._failedRunSources === "union");
+		if (failed) {
+			const changed = !this._hasError || this._error !== error;
+			this._hasError = true;
+			this._error = error;
+			this._value = void 0;
+			if (changed) this.markObserversDirty();
+			if (this._schedule) throw error;
+			return;
+		}
+		const changed = this._hasError || this._equals === null || !this._equals(this._value, value);
+		this._hasError = false;
+		this._error = void 0;
+		this._value = value;
+		if (changed) this.markObserversDirty();
+	}
+	/** Replace the function this computation runs; it runs again on next update. */
+	setFn(fn) {
+		this._fn = fn;
+		this._mark(DIRTY);
+	}
+	/** Restore subscriptions captured before a discarded component pass. */
+	restoreSources(sources) {
+		this.setSources(new Set(sources), false);
+	}
+	/** Force a re-run on the next update, as if a source changed. */
+	invalidate() {
+		this._mark(DIRTY);
+	}
+	/** Retry after a later source change, without rerunning a discarded pass. */
+	deferRetry() {
+		if (this.disposed) return;
+		this._state = DIRTY;
+		this._dropped = true;
+	}
+	markObserversDirty() {
+		const observers = this._observers;
+		if (!observers) return;
+		for (const observer of observers) observer._state = DIRTY;
+	}
+	/**
+	* A failed run keeps its previous subscriptions as well, so a change to
+	* anything either run read retries it.
+	*/
+	setSources(next, keepPrevious) {
+		const previous = this._sources;
+		if (previous) {
+			for (const source of previous) if (keepPrevious) next.add(source);
+			else if (!next.has(source)) unobserve(source, this);
+		}
+		for (const source of next) (source._observers ??= /* @__PURE__ */ new Set()).add(this);
+		this._sources = next.size ? next : null;
+	}
+	/**
+	* The scheduler dropped this computation's pending run (loop guard or
+	* clear). It stays stale, and the next change schedules it again.
+	*/
+	dropScheduled() {
+		if (!this.disposed && this._state !== CLEAN) this._dropped = true;
+	}
+	_mark(state) {
+		if (this.disposed) return;
+		if (this._running && state === DIRTY) {
+			const firstInvalidation = !this._invalidatedWhileRunning;
+			this._invalidatedWhileRunning = true;
+			if (state > this._state) this._state = state;
+			this._dropped = false;
+			this._schedule?.(this);
+			if (firstInvalidation) {
+				const observers = this._observers;
+				if (observers) for (const observer of observers) observer._mark(CHECK);
+			}
+			return;
+		}
+		const dropped = this._dropped;
+		if (this._state >= state && !dropped) return;
+		const wasClean = this._state === CLEAN;
+		if (state > this._state) this._state = state;
+		if (!wasClean && !dropped) return;
+		this._dropped = false;
+		if (this._schedule) this._schedule(this);
+		if (!wasClean) return;
+		const observers = this._observers;
+		if (observers) for (const observer of observers) observer._mark(CHECK);
+	}
+	onDispose() {
+		for (const source of this._sources ?? EMPTY) unobserve(source, this);
+		this._sources = null;
+		this._observers = null;
+	}
+};
+const EMPTY = /* @__PURE__ */ new Set();
+/** FIFO queue with an advancing head, so taking the next job is O(1). */
+var JobQueue = class {
+	constructor() {
+		this.items = [];
+		this.head = 0;
+	}
+	get length() {
+		return this.items.length - this.head;
+	}
+	push(job) {
+		this.items.push(job);
+	}
+	shift() {
+		if (this.head >= this.items.length) return void 0;
+		const job = this.items[this.head];
+		this.items[this.head++] = void 0;
+		if (this.head === this.items.length) {
+			this.items.length = 0;
+			this.head = 0;
+		} else if (this.head > 1024 && this.head * 2 > this.items.length) {
+			this.items = this.items.slice(this.head);
+			this.head = 0;
+		}
+		return job;
+	}
+	clear() {
+		this.items.length = 0;
+		this.head = 0;
+	}
+};
+/**
+* Render lane: a binary min-heap ordered by depth, then by queue order, so the
+* shallowest job runs first and equal depths run in the order they queued.
+*/
+var RenderQueue = class {
+	constructor() {
+		this.heap = [];
+		this.seq = 0;
+	}
+	get length() {
+		return this.heap.length;
+	}
+	push(job) {
+		const heap = this.heap;
+		const entry = {
+			job,
+			depth: job.depth ?? 0,
+			seq: this.seq++
+		};
+		let index = heap.push(entry) - 1;
+		while (index > 0) {
+			const parent = index - 1 >> 1;
+			if (!before(entry, heap[parent])) break;
+			heap[index] = heap[parent];
+			index = parent;
+		}
+		heap[index] = entry;
+	}
+	shift() {
+		const heap = this.heap;
+		if (heap.length === 0) return void 0;
+		const top = heap[0];
+		const last = heap.pop();
+		if (heap.length > 0) {
+			let index = 0;
+			for (;;) {
+				const left = index * 2 + 1;
+				if (left >= heap.length) break;
+				const right = left + 1;
+				const child = right < heap.length && before(heap[right], heap[left]) ? right : left;
+				if (!before(heap[child], last)) break;
+				heap[index] = heap[child];
+				index = child;
+			}
+			heap[index] = last;
+		}
+		if (heap.length === 0) this.seq = 0;
+		return top.job;
+	}
+	clear() {
+		this.heap.length = 0;
+		this.seq = 0;
+	}
+};
+function before(a, b) {
+	return a.depth < b.depth || a.depth === b.depth && a.seq < b.seq;
+}
+const lanes = {
+	render: new RenderQueue(),
+	effect: new JobQueue(),
+	post: new JobQueue()
+};
+const queued = /* @__PURE__ */ new Set();
+let flushing = false;
+let batchDepth = 0;
+let kickScheduled = false;
+let flushVersion = 0;
+let runCounts = null;
+const flushWaiters = [];
+function schedule(job, lane) {
+	if (queued.has(job)) return;
+	queued.add(job);
+	lanes[lane].push(job);
+	kick();
+}
+function queueTask(fn) {
+	const owner = getOwner();
+	schedule({ run: () => runWithOwner(owner, fn) }, "post");
+}
+const computationJobs = /* @__PURE__ */ new WeakMap();
+/**
+* A scheduler for computations that run as effects: when one goes stale it
+* is queued in `lane` and brought up to date (re-running only if a source
+* actually changed) when the flush reaches it.
+*/
+function effectScheduler(lane, depth = 0, onLimit, maxRuns) {
+	return (computation) => {
+		let job = computationJobs.get(computation);
+		if (!job) {
+			job = {
+				depth,
+				run: () => computation.update(),
+				cancel: () => computation.dropScheduled(),
+				onLimit,
+				maxRuns,
+				get skip() {
+					return computation.disposed;
+				}
+			};
+			computationJobs.set(computation, job);
+		}
+		schedule(job, lane);
+	};
+}
+function isFlushing() {
+	return flushing;
+}
+function kick() {
+	if (flushing || batchDepth > 0 || kickScheduled) return;
+	kickScheduled = true;
+	queueMicrotask(() => {
+		kickScheduled = false;
+		if (!flushing && batchDepth === 0 && queued.size > 0) flushSync();
+	});
+}
+/**
+* Run `fn` with scheduling deferred, then flush synchronously when the
+* outermost batch exits. Event handlers run inside a batch.
+*/
+function batch(fn) {
+	batchDepth++;
+	let value;
+	let callbackError;
+	let callbackFailed = false;
+	try {
+		value = fn();
+	} catch (error) {
+		callbackFailed = true;
+		callbackError = error;
+	}
+	batchDepth--;
+	let flushError;
+	let flushFailed = false;
+	if (batchDepth === 0 && !flushing && queued.size > 0) try {
+		flushSync();
+	} catch (error) {
+		flushFailed = true;
+		flushError = error;
+	}
+	if (callbackFailed && flushFailed) throw new AggregateError([callbackError, flushError], "Batch callback and scheduler flush failed");
+	if (callbackFailed) throw callbackError;
+	if (flushFailed) throw flushError;
+	return value;
+}
+function takeNext() {
+	return lanes.render.shift() ?? lanes.effect.shift() ?? lanes.post.shift() ?? null;
+}
+/** Drain every queued job now. Nested calls during a flush are no-ops. */
+function flushSync() {
+	if (flushing) return;
+	flushing = true;
+	runCounts = /* @__PURE__ */ new Map();
+	const failures = [];
+	try {
+		for (let job = takeNext(); job; job = takeNext()) {
+			queued.delete(job);
+			if (job.skip) continue;
+			const count = (runCounts.get(job) ?? 0) + 1;
+			runCounts.set(job, count);
+			if (count > (job.maxRuns ?? 50)) {
+				job.cancel?.();
+				if (job.onLimit) try {
+					job.onLimit();
+				} catch (error) {
+					failures.push(error);
+				}
+				else failures.push(/* @__PURE__ */ new Error(`[Askr] exceeded MAX_FLUSH_DEPTH (50): a scheduled update kept re-queueing itself.`));
+				continue;
+			}
+			try {
+				job.run();
+			} catch (error) {
+				failures.push(error);
+			}
+		}
+	} finally {
+		flushing = false;
+		runCounts = null;
+		flushVersion++;
+		for (const resolve of flushWaiters.splice(0)) resolve();
+	}
+	if (failures.length === 1) throw failures[0];
+	if (failures.length > 1) throw new AggregateError(failures, "Scheduler flush failed");
+}
+function getFlushVersion() {
+	return flushVersion;
+}
+//#endregion
+//#region src/core/component/render-state.ts
+/**
+* Whether a component render or a function child is executing. State writes
+* are rejected while one is, because they would re-trigger the render.
+*/
+let renderDepth = 0;
+function isRendering() {
+	return renderDepth > 0;
+}
+function withRendering(fn) {
+	renderDepth++;
+	try {
+		return fn();
+	} finally {
+		renderDepth--;
+	}
+}
+/** Run `fn` outside any render (event handlers and lifecycle callbacks). */
+function outsideRendering(fn) {
+	const saved = renderDepth;
+	renderDepth = 0;
+	try {
+		return fn();
+	} finally {
+		renderDepth = saved;
+	}
+}
+//#endregion
+//#region src/core/component/journal.ts
+let activeJournal = null;
+function createRenderJournal() {
+	return { entries: [] };
+}
+/** Run synchronous render work with `journal` as its undo destination. */
+function withRenderJournal(journal, render) {
+	const previous = activeJournal;
+	activeJournal = journal;
+	try {
+		return render();
+	} finally {
+		activeJournal = previous;
+	}
+}
+function recordUndo(undo, journal = activeJournal) {
+	journal?.entries.push(undo);
+}
+function journalMark(journal) {
+	return journal.entries.length;
+}
+/** Undo everything recorded after `mark`, most recent first. */
+function rewindJournal(journal, mark, errors) {
+	while (journal.entries.length > mark) try {
+		journal.entries.pop()();
+	} catch (error) {
+		errors.push(error);
+	}
+}
+/** Keep the changes recorded after `mark` (their render committed). */
+function settleJournal(journal, mark) {
+	journal.entries.length = Math.min(journal.entries.length, mark);
+}
+//#endregion
+//#region src/core/component/setup.ts
+const definitions = /* @__PURE__ */ new WeakMap();
+function setupDefinitionFor(component) {
+	return definitions.get(component);
+}
+//#endregion
+//#region src/core/component/instance.ts
+let renderHost = null;
+let nextContextRevision = 0;
+/** Bumped whenever any instance's `contextRevision` changes or is undone. */
+let contextEpoch = 0;
+/** Current context epoch; cached inherited revisions are valid within one. */
+function getContextEpoch() {
+	return contextEpoch;
+}
+function setRenderHost(host) {
+	renderHost = host;
+}
+var ComponentInstance = class extends Owner {
+	get displayName() {
+		return this.name ?? this.fn.name;
+	}
+	constructor(parent, fn, props, onStale) {
+		super(parent);
+		this.propsSource = null;
+		this.hooks = [];
+		this.hookKinds = [];
+		this.hookIndex = 0;
+		this.name = null;
+		this.mounted = false;
+		this.renderCount = 0;
+		this.commitQueue = null;
+		this.commitSyncQueue = null;
+		this.abortController = null;
+		this.setupRender = null;
+		this.setupPhase = null;
+		this.view = null;
+		this.server = false;
+		this.serverResourceKeys = [];
+		this.hydrationResourceKeys = null;
+		this.hydrationResourceIndex = 0;
+		this.serverContext = void 0;
+		this.boundary = null;
+		this.contextRevision = 0;
+		this.seenAncestorContextRevision = 0;
+		this.inheritedContextRevision = 0;
+		this.inheritedContextEpoch = -1;
+		this.fn = fn;
+		this.props = props;
+		this.setupDefinition = setupDefinitionFor(fn);
+		this.depth = depthOf(parent) + 1;
+		this.computation = new Computation(this, () => this.invoke(), onStale ?? renderLaneScheduler(this), null, "previous");
+	}
+	get signal() {
+		return (this.abortController ??= new AbortController()).signal;
+	}
+	/** Run the component function. Called only through `computation`. */
+	invoke() {
+		const previous = enterInstance(this);
+		this.hookIndex = 0;
+		this.hydrationResourceIndex = 0;
+		if (this.server) this.serverResourceKeys = [];
+		this.commitQueue = null;
+		this.commitSyncQueue = null;
+		try {
+			const context = this.server ? {
+				signal: this.signal,
+				ssr: this.serverContext
+			} : { signal: this.signal };
+			const started = !this.server && isTimingRenders() ? Date.now() : 0;
+			const output = withRendering(() => runWithOwner(this, () => {
+				const setup = this.setupDefinition;
+				if (!setup) return this.fn(this.props, context);
+				if (!this.setupRender) {
+					this.setupPhase = "setup";
+					try {
+						this.setupRender = setup(this.props, context, () => (this.propsSource ??= new Signal(this.props)).read());
+					} finally {
+						this.setupPhase = null;
+					}
+					verifyHookCount(this);
+				}
+				this.setupPhase = "render";
+				try {
+					return this.setupRender(this.props, context);
+				} finally {
+					this.setupPhase = null;
+				}
+			}));
+			if (started) reportRenderTime(this, this.displayName || "<anonymous>", Date.now() - started);
+			if (!this.setupDefinition) verifyHookCount(this);
+			this.renderCount++;
+			return output;
+		} finally {
+			enterInstance(previous);
+		}
+	}
+	/** Render now with the current props, tracking reads. Throws on failure. */
+	render(onDiscard) {
+		if (onDiscard && this.mounted) {
+			const sources = new Set(this.computation._sources ?? []);
+			onDiscard(() => this.computation.restoreSources(sources));
+		}
+		this.computation.run();
+		if (this.computation._hasError) throw this.computation._error;
+		return this.computation._value;
+	}
+	/**
+	* Make `value` visible under `key` to everything this instance renders.
+	* Called during render; undone if the render is discarded.
+	*/
+	provide(key, value) {
+		const context = this.context ??= /* @__PURE__ */ new Map();
+		const had = context.has(key);
+		const previous = context.get(key);
+		if (had && Object.is(previous, value)) return;
+		const previousRevision = this.contextRevision;
+		this.contextRevision = ++nextContextRevision;
+		contextEpoch++;
+		context.set(key, value);
+		recordUndo(() => {
+			this.contextRevision = previousRevision;
+			contextEpoch++;
+			if (had) context.set(key, previous);
+			else context.delete(key);
+		});
+	}
+	/** Replace props for the render that follows; undone if it is discarded. */
+	setProps(props) {
+		const previous = this.props;
+		if (previous === props) return;
+		this.props = props;
+		this.propsSource?.write(props);
+		recordUndo(() => {
+			this.props = previous;
+			this.propsSource?.write(previous);
+		});
+	}
+	onCommit(fn) {
+		(this.commitQueue ??= []).push(fn);
+	}
+	onCommitSync(fn) {
+		(this.commitSyncQueue ??= []).push(fn);
+	}
+	isSetupRenderPhase() {
+		return this.setupPhase === "render";
+	}
+	onDispose() {
+		this.abortController?.abort(COMPONENT_ABORT_REASON);
+	}
+};
+const COMPONENT_ABORT_REASON = new DOMException("This operation was aborted", "AbortError");
+function depthOf(owner) {
+	for (let o = owner; o; o = o.parent) {
+		if (o instanceof ComponentInstance) return o.depth;
+		const depth = o.depth;
+		if (typeof depth === "number") return depth;
+	}
+	return 0;
+}
+function renderLaneScheduler(instance) {
+	let job = null;
+	return () => {
+		job ??= {
+			depth: instance.depth,
+			run: () => renderHost?.rerender(instance),
+			cancel: () => instance.computation.dropScheduled(),
+			get skip() {
+				return instance.disposed || !instance.computation.stale;
+			}
+		};
+		schedule(job, "render");
+	};
+}
+let currentInstance = null;
+function enterInstance(instance) {
+	const previous = currentInstance;
+	currentInstance = instance;
+	return previous;
+}
+function getCurrentInstance() {
+	return currentInstance;
+}
+function requireInstance(api) {
+	const instance = currentInstance;
+	if (!instance) throw new Error(`${api} can only be called during component render execution. Move ${api} calls to the top level of your component function.`);
+	return instance;
+}
+/**
+* Claim the next hook slot. Returns the slot index; the caller stores its
+* value in `instance.hooks[index]`.
+*/
+function claimHook(instance, kind) {
+	if (instance.isSetupRenderPhase()) throw new Error(`[Askr] ${kind}() cannot be called during setup component render. Declare lifecycle values in the setup callback.`);
+	const index = instance.hookIndex++;
+	const expected = instance.hookKinds[index];
+	if (expected === void 0) {
+		if (instance.renderCount > 0) throw hookOrderError(instance, index, kind, void 0);
+		instance.hookKinds[index] = kind;
+	} else if (expected !== kind) throw hookOrderError(instance, index, kind, expected);
+	return index;
+}
+function verifyHookCount(instance) {
+	if (instance.renderCount > 0 && instance.hookIndex !== instance.hookKinds.length) throw hookOrderError(instance, instance.hookIndex, void 0, instance.hookKinds[instance.hookIndex]);
+}
+var HookOrderChangeError = class extends Error {
+	constructor(instance, message) {
+		super(message);
+		this.instance = instance;
+	}
+};
+function hookOrderError(instance, index, actual, expected) {
+	return new HookOrderChangeError(instance, `[Askr] Hook order changed in ${instance.displayName || "anonymous component"}: slot ${index} was ${expected ? `${expected}()` : "not claimed"} on the first render but ${actual ? `${actual}()` : "not claimed"} now. Call state(), derive() and other lifecycle APIs unconditionally at the top level of the component, in the same order on every render.`);
+}
+function getRenderHost() {
+	return renderHost;
+}
+//#endregion
+export { untrack as A, schedule as C, isTracking as D, getTrackingComputation as E, logger as F, isDevelopmentEnvironment as I, isProductionEnvironment as L, getOwner as M, runWithOwner as N, notifySource as O, configureRenderDiagnostics as P, queueTask as S, Signal as T, batch as _, getCurrentInstance as a, getFlushVersion as b, setRenderHost as c, recordUndo as d, rewindJournal as f, outsideRendering as g, isRendering as h, getContextEpoch as i, Owner as j, trackSource as k, createRenderJournal as l, withRenderJournal as m, HookOrderChangeError as n, getRenderHost as o, settleJournal as p, claimHook as r, requireInstance as s, ComponentInstance as t, journalMark as u, effectScheduler as v, Computation as w, isFlushing as x, flushSync as y };