@askrjs/askr 0.2.3 → 0.3.0

package/dist/access-CEA2pOry.js

@@ -0,0 +1,1046 @@
+import { a as clearCurrentComponentScope, s as endComponentScope } from "./scope-Cq_iYbTR.js";
+//#region src/common/env.ts
+function normalizeEnv(source) {
+	if (!source) return {};
+	const normalized = {};
+	for (const [key, value] of Object.entries(source)) if (typeof value === "string") normalized[key] = value;
+	else if (typeof value === "boolean" || typeof value === "number") normalized[key] = String(value);
+	return normalized;
+}
+function getBuildTimeEnv() {
+	const metaEnv = import.meta.env;
+	const normalized = normalizeEnv(metaEnv);
+	if (normalized.NODE_ENV == null && metaEnv) {
+		if (typeof metaEnv.MODE === "string" && metaEnv.MODE.length > 0) normalized.NODE_ENV = metaEnv.MODE;
+		else if (metaEnv.PROD === true || metaEnv.PROD === "true") normalized.NODE_ENV = "production";
+		else if (metaEnv.DEV === true || metaEnv.DEV === "true") normalized.NODE_ENV = "development";
+	}
+	return normalized;
+}
+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;
+}
+function getRuntimeEnv() {
+	const processEnv = globalThis.process?.env ?? {};
+	const buildTimeEnv = getBuildTimeEnv();
+	return {
+		...processEnv,
+		...buildTimeEnv,
+		NODE_ENV: resolveNodeEnv(processEnv.NODE_ENV, buildTimeEnv.NODE_ENV)
+	};
+}
+function isProductionEnvironment() {
+	return getRuntimeEnv().NODE_ENV === "production";
+}
+function isDevelopmentEnvironment() {
+	return !isProductionEnvironment();
+}
+//#endregion
+//#region src/common/invariant.ts
+/**
+* Invariant assertions shared by production runtime code.
+*/
+function invariant(condition, message, context) {
+	if (!condition) {
+		const contextStr = context ? "\n" + JSON.stringify(context, null, 2) : "";
+		throw new Error(`[Askr Invariant] ${message}${contextStr}`);
+	}
+}
+function assertSchedulingPrecondition(condition, violationMessage) {
+	invariant(condition, `[Scheduler Precondition] ${violationMessage}`);
+}
+//#endregion
+//#region src/runtime/diagnostics/perf-metrics.ts
+const incrementPerfMetric = () => {};
+const addPerfDuration = () => {};
+//#endregion
+//#region src/runtime/scheduler-scopes.ts
+var SchedulerScopes = class {
+	constructor() {
+		this.handlerScopes = 0;
+		this.handlerFlag = false;
+		this.progressScopes = 0;
+	}
+	get inHandler() {
+		return this.handlerFlag || this.handlerScopes > 0;
+	}
+	get allowSyncProgress() {
+		return this.progressScopes > 0;
+	}
+	canKick(running) {
+		return !running && !this.inHandler && !this.allowSyncProgress;
+	}
+	adjustHandler(delta) {
+		this.handlerScopes += delta;
+	}
+	setHandlerFlag(value) {
+		this.handlerFlag = value;
+	}
+	adjustProgress(delta) {
+		this.progressScopes += delta;
+	}
+};
+//#endregion
+//#region src/runtime/scheduled-work.ts
+const workByTask = /* @__PURE__ */ new WeakMap();
+var ScheduledWork = class {
+	constructor(run) {
+		this.pending = false;
+		this.task = () => {
+			this.pending = false;
+			run();
+		};
+		workByTask.set(this.task, this);
+	}
+	request(scheduler, lane) {
+		if (this.pending) return;
+		this.pending = true;
+		try {
+			scheduler.enqueueInLane(lane, this.task);
+		} catch (error) {
+			this.cancel();
+			throw error;
+		}
+	}
+	cancel() {
+		this.pending = false;
+	}
+	static release(task) {
+		workByTask.get(task)?.cancel();
+	}
+};
+//#endregion
+//#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"
+];
+var Scheduler = class {
+	constructor() {
+		this.bulkCommitProbe = () => false;
+		this.lanes = {
+			derived: {
+				tasks: [],
+				head: 0
+			},
+			component: {
+				tasks: [],
+				head: 0
+			},
+			reactive: {
+				tasks: [],
+				head: 0
+			},
+			post: {
+				tasks: [],
+				head: 0
+			}
+		};
+		this.scopes = new SchedulerScopes();
+		this.running = false;
+		this.depth = 0;
+		this.executionDepth = 0;
+		this.flushVersion = 0;
+		this.kickScheduled = false;
+		this.waiters = [];
+		this.taskCount = 0;
+	}
+	setBulkCommitProbe(probe) {
+		this.bulkCommitProbe = probe;
+	}
+	isBulkCommitActive() {
+		try {
+			return this.bulkCommitProbe();
+		} catch (e) {
+			return false;
+		}
+	}
+	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.kickScheduled || !this.scopes.canKick(this.running) || this.isBulkCommitActive() || !this.hasPendingTasks()) return;
+		this.kickScheduled = true;
+		queueMicrotask(() => {
+			this.kickScheduled = false;
+			if (!this.scopes.canKick(this.running) || this.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 (this.isBulkCommitActive() && !this.scopes.allowSyncProgress) {
+			ScheduledWork.release(task);
+			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 (this.isBulkCommitActive() && !this.scopes.allowSyncProgress) throw new Error("[Scheduler] flush() started during bulk commit (not allowed)");
+		}
+		this.running = true;
+		this.depth = 0;
+		const failures = [];
+		let executedTaskCount = 0;
+		const executionsByTask = isDevelopmentEnvironment() ? /* @__PURE__ */ new Map() : null;
+		try {
+			while (true) {
+				let didRunTask = false;
+				for (const lane of SCHEDULER_LANES) {
+					const laneQueue = this.lanes[lane];
+					let executedInLane = 0;
+					while (laneQueue.head < laneQueue.tasks.length) {
+						const task = laneQueue.tasks[laneQueue.head++];
+						if (executionsByTask) {
+							const taskExecutions = (executionsByTask.get(task) ?? 0) + 1;
+							executionsByTask.set(task, taskExecutions);
+							this.depth = Math.max(this.depth, taskExecutions);
+							if (taskExecutions > MAX_FLUSH_DEPTH) throw new Error(`[Scheduler] exceeded MAX_FLUSH_DEPTH (${MAX_FLUSH_DEPTH}). Likely infinite update loop.`);
+						}
+						try {
+							this.executionDepth++;
+							task();
+						} catch (err) {
+							failures.push(err);
+						} finally {
+							if (this.executionDepth > 0) this.executionDepth--;
+							executedTaskCount++;
+							executedInLane++;
+							didRunTask = true;
+						}
+					}
+					if (executedInLane > 0) this.taskCount = Math.max(0, this.taskCount - executedInLane);
+				}
+				if (!didRunTask) break;
+			}
+		} finally {
+			this.running = false;
+			this.depth = 0;
+			this.executionDepth = 0;
+			for (const lane of SCHEDULER_LANES) {
+				const queue = this.lanes[lane];
+				if (queue.head > 0) this.compactLane(queue);
+			}
+			this.completeEpoch();
+		}
+		if (failures.length === 1) throw failures[0];
+		if (failures.length > 1) throw new AggregateError(failures, "Scheduler task failures");
+	}
+	runWithSyncProgress(fn) {
+		this.scopes.adjustProgress(1);
+		const startVersion = this.flushVersion;
+		try {
+			const res = fn();
+			if (!this.running && this.hasPendingTasks()) this.flush();
+			if (isDevelopmentEnvironment()) {
+				if (!this.running && this.hasPendingTasks()) throw new Error("[Scheduler] tasks remain after runWithSyncProgress flush");
+			}
+			return res;
+		} finally {
+			this.scopes.adjustProgress(-1);
+			if (this.flushVersion === startVersion) this.completeIdleEpoch();
+			this.scheduleFlushKick();
+		}
+	}
+	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 waiter = {
+				target,
+				resolve,
+				reject
+			};
+			waiter.timer = setTimeout(() => {
+				const index = this.waiters.indexOf(waiter);
+				if (index >= 0) this.waiters.splice(index, 1);
+				if (waiter.timer !== void 0) clearTimeout(waiter.timer);
+				const diag = {
+					flushVersion: this.flushVersion,
+					queueLen: this.getPendingTaskCount(),
+					running: this.running,
+					inHandler: this.scopes.inHandler,
+					bulk: this.isBulkCommitActive()
+				};
+				reject(/* @__PURE__ */ new Error(`waitForFlush timeout ${timeoutMs}ms: ${JSON.stringify(diag)}`));
+			}, timeoutMs);
+			this.waiters.push(waiter);
+		});
+	}
+	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.scopes.inHandler,
+			allowSyncProgress: this.scopes.allowSyncProgress
+		};
+	}
+	getFlushVersion() {
+		return this.flushVersion;
+	}
+	flushIfQueued() {
+		if (!this.running && this.hasPendingTasks()) this.flush();
+	}
+	runInHandlerScope(fn, flushMode = "defer") {
+		this.scopes.adjustHandler(1);
+		try {
+			return fn();
+		} finally {
+			this.scopes.adjustHandler(-1);
+			if (!this.scopes.inHandler) {
+				if (flushMode === "sync") this.flushIfQueued();
+				else this.scheduleFlushKick();
+			}
+		}
+	}
+	setInHandler(v) {
+		this.scopes.setHandlerFlag(v);
+		if (!v) this.scheduleFlushKick();
+	}
+	isInHandler() {
+		return this.scopes.inHandler;
+	}
+	isExecuting() {
+		return this.running || this.executionDepth > 0;
+	}
+	clearPendingSyncTasks() {
+		const remaining = this.getPendingTaskCount();
+		if (remaining <= 0) return 0;
+		for (const lane of SCHEDULER_LANES) {
+			const queue = this.lanes[lane];
+			for (let index = queue.head; index < queue.tasks.length; index++) ScheduledWork.release(queue.tasks[index]);
+			queue.tasks.length = this.running ? queue.head : 0;
+			if (!this.running) queue.head = 0;
+		}
+		this.taskCount = Math.max(0, this.taskCount - remaining);
+		this.completeIdleEpoch();
+		return remaining;
+	}
+	completeIdleEpoch() {
+		if (!this.running && !this.scopes.allowSyncProgress && !this.hasPendingTasks()) this.completeEpoch();
+	}
+	completeEpoch() {
+		this.flushVersion++;
+		this.resolveWaiters();
+	}
+	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 !== void 0) clearTimeout(w.timer);
+			ready.push(w.resolve);
+		} else remaining.push(w);
+		this.waiters = remaining;
+		for (const r of ready) r();
+	}
+};
+const globalScheduler = new Scheduler();
+//#endregion
+//#region src/runtime/transactions/coordinator.ts
+const transactionCreation = Symbol("transaction creation");
+let transactionState;
+/** Read-only transaction identity with explicit resource and notification operations. */
+var CommitTransaction = class {
+	#state;
+	static {
+		transactionState = (transaction) => transaction.#state;
+	}
+	constructor(coordinator, parent, token) {
+		if (token !== transactionCreation) throw new Error("[Askr] Transactions must be created by their coordinator.");
+		this.#state = {
+			phase: "preparing",
+			parent,
+			coordinator,
+			participants: [],
+			seen: void 0,
+			index: void 0,
+			resources: void 0,
+			errors: void 0,
+			completions: void 0,
+			deferNotifications: false
+		};
+		Object.freeze(this);
+	}
+	get phase() {
+		return this.#state.phase;
+	}
+	get parent() {
+		return this.#state.parent;
+	}
+	get coordinator() {
+		return this.#state.coordinator;
+	}
+	get participants() {
+		return Object.freeze(this.#state.participants.slice());
+	}
+	get errors() {
+		return Object.freeze(this.#state.errors?.slice() ?? []);
+	}
+	get resourceCount() {
+		return this.#state.resources?.size ?? 0;
+	}
+	/** Detached diagnostic collections cannot mutate coordinator bookkeeping. */
+	inspect() {
+		return {
+			index: new Map(Array.from(this.#state.index ?? [], ([kind, entries]) => [kind, new Map(entries)])),
+			resources: new Map(this.#state.resources),
+			seen: new Set(this.#state.seen),
+			completions: new Map(this.#state.completions)
+		};
+	}
+	get active() {
+		const phase = this.#state.phase;
+		return phase === "preparing" || phase === "applying" || phase === "publishing";
+	}
+	hasResource(key) {
+		return this.#state.resources?.has(key) ?? false;
+	}
+	resource(key) {
+		return this.#state.resources?.get(key);
+	}
+	captureResource(key, resource) {
+		if (!this.active) throw new Error("[Askr] Cannot capture a resource on a settled transaction.");
+		const resources = this.#state.resources ??= /* @__PURE__ */ new Map();
+		if (resources.has(key)) return resources.get(key);
+		resources.set(key, resource);
+		return resource;
+	}
+	setDeferredNotifications(enabled) {
+		if (!this.active) throw new Error("[Askr] Cannot configure a settled transaction.");
+		this.#state.deferNotifications = enabled;
+	}
+	participant(key, kind) {
+		return this.#state.index?.get(kind)?.get(key);
+	}
+};
+/** Reuse the larger map while preserving earlier values, including undefined. */
+function mergeEarlierEntries(earlier, later, reuseLater = true) {
+	if (reuseLater && (!earlier || earlier.size < later.size)) {
+		for (const [key, value] of earlier ?? []) later.set(key, value);
+		return later;
+	}
+	earlier ??= /* @__PURE__ */ new Map();
+	for (const [key, value] of later) if (!earlier.has(key)) earlier.set(key, value);
+	return earlier;
+}
+/** One synchronous stack per runtime. This coordinator has no component,
+* subscription, renderer, scheduler, or browser dependencies. */
+var CommitCoordinator = class {
+	constructor(options = {}) {
+		this.frame = null;
+		this.options = options;
+	}
+	get current() {
+		return this.frame;
+	}
+	begin() {
+		const transaction = new CommitTransaction(this, this.frame?.active ? this.frame : null, transactionCreation);
+		this.frame = transaction;
+		return transaction;
+	}
+	register(participant) {
+		if (!this.frame?.active) return false;
+		this.add(this.frame, participant);
+		return true;
+	}
+	add(transaction, participant) {
+		const state = transactionState(transaction);
+		if (state.seen?.has(participant)) return;
+		if (participant.key) {
+			const kinds = state.index ??= /* @__PURE__ */ new Map();
+			let index = kinds.get(participant.kind);
+			if (!index) kinds.set(participant.kind, index = /* @__PURE__ */ new Map());
+			const previous = index.get(participant.key);
+			if (previous) {
+				this.validateCollision(previous, participant);
+				if (previous === participant) return;
+				if (participant.collision === "keep-first") {
+					(state.seen ??= /* @__PURE__ */ new Set()).add(participant);
+					return;
+				}
+				try {
+					participant.merge(previous);
+					(state.seen ??= /* @__PURE__ */ new Set()).add(participant);
+				} catch (error) {
+					state.participants.push(participant);
+					this.discardMergedTransactions(transaction);
+					throw error;
+				}
+				return;
+			}
+			index.set(participant.key, participant);
+		} else (state.seen ??= /* @__PURE__ */ new Set()).add(participant);
+		state.participants.push(participant);
+	}
+	validateCollision(previous, participant) {
+		if (previous !== participant && participant.collision !== "keep-first" && !participant.merge) throw new Error("[Askr] Participant collision requires merge or keep-first.");
+	}
+	discardMergedTransactions(transaction, mergedParent) {
+		const state = transactionState(transaction);
+		const affected = /* @__PURE__ */ new Set([transaction]);
+		const participants = new Set(state.participants);
+		const ancestors = [];
+		for (let ancestor = state.parent; ancestor; ancestor = transactionState(ancestor).parent) if (ancestor.active) ancestors.push(ancestor);
+		let changed;
+		do {
+			changed = false;
+			for (const ancestor of ancestors) if (!affected.has(ancestor) && (ancestor === mergedParent || transactionState(ancestor).participants.some((participant) => participants.has(participant)))) {
+				affected.add(ancestor);
+				changed = true;
+				for (const participant of transactionState(ancestor).participants) participants.add(participant);
+			}
+		} while (changed);
+		const frames = [transaction, ...ancestors.filter((ancestor) => affected.has(ancestor))];
+		const owners = /* @__PURE__ */ new Set();
+		for (let index = frames.length - 1; index >= 0; index--) {
+			const frame = frames[index];
+			const frameState = transactionState(frame);
+			frameState.phase = "discarding";
+			for (let member = frameState.participants.length - 1; member >= 0; member--) {
+				const participant = frameState.participants[member];
+				if (owners.has(participant)) frameState.participants.splice(member, 1);
+				else owners.add(participant);
+			}
+		}
+		for (const frame of frames) this.drainRollback(frame);
+	}
+	suspend(transaction) {
+		const state = transactionState(transaction);
+		this.assertOwned(transaction);
+		if (this.frame === transaction) this.frame = this.liveFrame(state.parent);
+	}
+	apply(transaction, operation) {
+		const state = transactionState(transaction);
+		this.assertOwned(transaction);
+		if (!transaction.active) throw new Error("[Askr] Cannot apply a settled transaction.");
+		const previous = this.frame;
+		const previousPhase = state.phase;
+		if (previous && previous !== transaction && previous.active) {
+			let ancestor = previous;
+			while (ancestor && ancestor !== transaction) ancestor = transactionState(ancestor).parent;
+			if (!ancestor) state.parent = previous;
+		}
+		this.frame = transaction;
+		state.phase = "applying";
+		try {
+			return operation();
+		} finally {
+			if (transaction.active) state.phase = previousPhase;
+			this.frame = this.liveFrame(previous);
+		}
+	}
+	/** State writes survive rollback. Their notifications wait until all
+	* framework restoration or post-commit work has finished. */
+	deferCompletion(key, complete) {
+		const transaction = this.frame;
+		if (!transaction || !this.notificationsDeferred()) return false;
+		const state = transactionState(transaction);
+		(state.completions ??= /* @__PURE__ */ new Map()).set(key, complete);
+		return true;
+	}
+	notificationsDeferred() {
+		let transaction = this.frame;
+		while (transaction) {
+			const state = transactionState(transaction);
+			if (state.deferNotifications && (transaction.active || state.phase === "discarding")) return true;
+			transaction = state.parent;
+		}
+		return false;
+	}
+	commit(transaction) {
+		const state = transactionState(transaction);
+		this.assertOwned(transaction);
+		if (!transaction.active || state.committing) return;
+		state.committing = true;
+		try {
+			const parent = state.parent;
+			if (parent?.active) {
+				this.joinParentTransaction(transaction, state, parent);
+				return;
+			}
+			this.applyAndSettle(transaction, state);
+		} finally {
+			state.committing = false;
+		}
+	}
+	/**
+	* Fold a nested transaction into its still-open parent.
+	*
+	* Nothing is applied here: the child's participants, index, resources and
+	* identity set move to the parent, which will run them when it commits. The
+	* work is in reconciling identity — a participant may already exist in the
+	* parent under the same key, in which case the two have to be merged, and a
+	* merge can register further participants of its own, so it runs with its own
+	* failure ownership.
+	*/
+	joinParentTransaction(transaction, state, parent) {
+		const parentState = transactionState(parent);
+		let needsMerge = false;
+		let changedIdentity = false;
+		for (const participant of state.participants) {
+			if (participant.key && state.seen?.has(participant)) changedIdentity = true;
+			if (parentState.seen?.has(participant)) continue;
+			const previous = participant.key ? parent.participant(participant.key, participant.kind) : void 0;
+			if (previous) {
+				this.validateCollision(previous, participant);
+				if (previous !== participant && participant.collision !== "keep-first") needsMerge = true;
+			}
+		}
+		for (const [kind, index] of state.index?.entries() ?? []) {
+			index.forEach((participant, key) => {
+				if (participant.key !== key || participant.kind !== kind) changedIdentity = true;
+			});
+			if (changedIdentity) break;
+		}
+		if (needsMerge || changedIdentity) {
+			try {
+				for (const participant of state.participants) {
+					if (parentState.seen?.has(participant)) continue;
+					const previous = participant.key ? parent.participant(participant.key, participant.kind) : void 0;
+					if (previous && previous !== participant) {
+						if (participant.collision !== "keep-first") participant.merge(previous);
+						if (!parent.active) this.discard(transaction);
+						if (!transaction.active) return;
+						(parentState.seen ??= /* @__PURE__ */ new Set()).add(participant);
+					}
+				}
+			} catch (error) {
+				this.discardMergedTransactions(transaction, parent);
+				throw error;
+			}
+			for (const participant of state.participants) if (!participant.key || !parent.participant(participant.key, participant.kind)) this.add(parent, participant);
+		} else {
+			for (const participant of state.participants) {
+				if (parentState.seen?.has(participant)) {
+					if (participant.key) state.index.get(participant.kind).delete(participant.key);
+					continue;
+				}
+				if (participant.key) {
+					const previous = parent.participant(participant.key, participant.kind);
+					if (previous) {
+						if (previous !== participant) (state.seen ??= /* @__PURE__ */ new Set()).add(participant);
+						continue;
+					}
+				}
+				parentState.participants.push(participant);
+			}
+			for (const [kind, index] of state.index?.entries() ?? []) {
+				if (!index.size) continue;
+				const kinds = parentState.index ??= /* @__PURE__ */ new Map();
+				kinds.set(kind, mergeEarlierEntries(kinds.get(kind), index));
+			}
+		}
+		if (state.resources) parentState.resources = mergeEarlierEntries(parentState.resources, state.resources, !needsMerge && !changedIdentity);
+		if (state.seen) {
+			if (!parentState.seen) parentState.seen = state.seen;
+			else if (parentState.seen.size < state.seen.size) {
+				for (const participant of parentState.seen) state.seen.add(participant);
+				parentState.seen = state.seen;
+			} else for (const participant of state.seen) parentState.seen.add(participant);
+		}
+		this.mergeCompletions(transaction, parent);
+		state.phase = "joined";
+		this.suspend(transaction);
+		this.release(transaction);
+	}
+	/**
+	* Run a root transaction to completion.
+	*
+	* Apply and publish interleave because an application hook can render during
+	* either, appending participants that must themselves be applied before
+	* anything else publishes. Settlement then runs each remaining phase over
+	* every participant, collecting failures rather than stopping, so one broken
+	* cleanup cannot strand the rest.
+	*
+	* A participant that deactivates the transaction returns early from here,
+	* which deliberately skips settlement — the `finally` blocks still restore
+	* the frame and release.
+	*/
+	applyAndSettle(transaction, state) {
+		const previous = this.frame;
+		this.frame = transaction;
+		let applied = 0;
+		let published = 0;
+		try {
+			while (applied < state.participants.length || published < state.participants.length) {
+				state.phase = "applying";
+				while (applied < state.participants.length) {
+					state.participants[applied++].apply?.();
+					if (!transaction.active) return;
+				}
+				state.phase = "publishing";
+				if (published < state.participants.length) state.participants[published++].publish?.();
+				if (!transaction.active) return;
+			}
+		} catch (error) {
+			this.discard(transaction);
+			throw error;
+		} finally {
+			this.frame = this.liveFrame(previous === transaction ? state.parent : previous);
+		}
+		state.phase = "settling";
+		try {
+			for (const phase of [
+				"settle",
+				"activate",
+				"complete"
+			]) for (const participant of state.participants) try {
+				participant[phase]?.();
+			} catch (error) {
+				(state.errors ??= []).push(error);
+			}
+			this.complete(transaction, (error) => (state.errors ??= []).push(error));
+			state.phase = "committed";
+			if (state.errors?.length) this.options.settlementErrors?.(state.errors, transaction);
+		} finally {
+			state.phase = "committed";
+			this.release(transaction);
+		}
+	}
+	discard(transaction) {
+		this.assertOwned(transaction);
+		if (!transaction.active) return;
+		this.drainRollback(transaction);
+	}
+	drainRollback(transaction) {
+		const state = transactionState(transaction);
+		const previous = this.frame;
+		this.frame = transaction;
+		state.phase = "discarding";
+		const report = (error) => {
+			try {
+				this.options.rollbackError?.(error);
+			} catch {}
+		};
+		try {
+			for (let index = state.participants.length - 1; index >= 0; index--) try {
+				state.participants[index].rollback?.();
+			} catch (error) {
+				report(error);
+			}
+		} finally {
+			state.phase = "discarded";
+			this.frame = this.liveFrame(previous === transaction ? state.parent : previous);
+			if (state.parent?.active || state.parent?.phase === "discarding") this.mergeCompletions(transaction, state.parent);
+			else this.complete(transaction, report);
+			this.release(transaction);
+		}
+	}
+	mergeCompletions(transaction, parent) {
+		const state = transactionState(transaction);
+		if (!state.completions) return;
+		const parentState = transactionState(parent);
+		const completions = parentState.completions ??= /* @__PURE__ */ new Map();
+		for (const [key, complete] of state.completions) completions.set(key, complete);
+	}
+	complete(transaction, report) {
+		const state = transactionState(transaction);
+		for (const complete of state.completions?.values() ?? []) try {
+			complete();
+		} catch (error) {
+			report(error);
+		}
+	}
+	release(transaction) {
+		const state = transactionState(transaction);
+		state.participants.length = 0;
+		state.seen = void 0;
+		state.index = void 0;
+		state.resources = void 0;
+		state.completions?.clear();
+		state.completions = void 0;
+	}
+	liveFrame(transaction) {
+		while (transaction && !transaction.active) transaction = transactionState(transaction).parent;
+		return transaction;
+	}
+	assertOwned(transaction) {
+		if (transactionState(transaction).coordinator !== this) throw new Error("[Askr] Transaction belongs to another runtime.");
+	}
+};
+//#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/runtime/runtime-state.ts
+/**
+* The renderer host for an environment that has no DOM renderer.
+*
+* This is not only a pre-boot placeholder: SSR and SSG never install a renderer,
+* so it is the live host for the whole life of every server render. It
+* therefore has to be usable, not merely loud, and it follows one rule:
+*
+* - Bookkeeping degrades. Capturing, releasing and inspecting hosts, scopes and
+*   key maps answer as though nothing is mounted, because during a server
+*   render nothing is.
+* - Anything that would produce or destroy DOM throws. Reaching `evaluate`,
+*   `replaceComponentRange` or a teardown without a renderer means execution
+*   believed it had one, which is a bug worth surfacing rather than silently
+*   dropping the output.
+*
+* Browser composition replaces this through `installRuntimeRenderer`.
+*/
+function createMissingRendererHost() {
+	const noop = () => void 0;
+	const missing = (method) => {
+		throw new Error(`[Askr] renderer host is not configured; cannot call ${method}().`);
+	};
+	return {
+		captureComponentHost: noop,
+		releaseComponentHost: noop,
+		detachPortalHostOutput: noop,
+		isComponentHostDetached() {
+			return false;
+		},
+		clearChildScopeHost(scope) {
+			scope.dom = void 0;
+			scope.range = void 0;
+		},
+		captureChildScopeHost: noop,
+		resolveScopeBoundary() {
+			return {
+				dom: void 0,
+				range: void 0
+			};
+		},
+		prepareScopeRemoval() {
+			return {
+				dom: void 0,
+				range: void 0
+			};
+		},
+		recordRemovedScopeBoundary: noop,
+		teardownScopeHost() {
+			return 0;
+		},
+		hasUnmountedComponentHost() {
+			return false;
+		},
+		recordInlineComponentHost(instance, target) {
+			instance.target = target;
+		},
+		applyComponentResult(instance) {
+			if (instance.target || instance._placeholder) return missing("applyComponentResult");
+			return false;
+		},
+		classifyComponentUpdate() {
+			return {
+				useFastPath: false,
+				reason: "no-root"
+			};
+		},
+		evaluate() {
+			missing("evaluate");
+		},
+		cleanupInstancesUnder() {
+			missing("cleanupInstancesUnder");
+		},
+		replaceComponentRange() {
+			return missing("replaceComponentRange");
+		},
+		teardownNodeSubtree() {
+			missing("teardownNodeSubtree");
+		},
+		populateKeyMapForElement: noop,
+		getKeyMapForElement: noop,
+		isKeyedReorderFastPathEligible() {
+			return {
+				useFastPath: false,
+				totalKeyed: 0,
+				totalChildren: 0,
+				currentKeyCount: 0,
+				moveCount: 0,
+				lisLen: 0,
+				hasPropChanges: false,
+				isWholeKeyedList: false
+			};
+		},
+		markReactivePropsDirtySource: noop
+	};
+}
+function createRuntimeState(scheduler = globalScheduler) {
+	return {
+		scheduler,
+		renderer: createMissingRendererHost(),
+		commits: new CommitCoordinator({
+			rollbackError(error) {
+				logger.error("[Askr] transaction rollback failed:", error);
+			},
+			settlementErrors(errors) {
+				logger.error("[Askr] committed lifecycle work failed:", new AggregateError(errors, "Committed lifecycle work failed"));
+			}
+		})
+	};
+}
+const defaultRuntimeState = createRuntimeState();
+//#endregion
+//#region src/runtime/access.ts
+function getRuntimeScheduler() {
+	return defaultRuntimeState.scheduler;
+}
+function getRuntimeEvaluation() {
+	return defaultRuntimeState.renderer;
+}
+function getRuntimeCleanup() {
+	return defaultRuntimeState.renderer;
+}
+function getRuntimeScopes() {
+	return defaultRuntimeState.renderer;
+}
+function getRuntimeKeys() {
+	return defaultRuntimeState.renderer;
+}
+/** Not exported: `markRuntimeReactivePropsDirtySource` is its only caller. */
+function getRuntimeReactivity() {
+	return defaultRuntimeState.renderer;
+}
+/** Native boot composition does not require a published extension view. */
+function installRuntimeRenderer(renderer) {
+	defaultRuntimeState.renderer = renderer;
+}
+function enqueueRuntimeTask(task) {
+	getRuntimeScheduler().enqueue(task);
+}
+function enqueueRuntimeLane(lane, task) {
+	getRuntimeScheduler().enqueueInLane(lane, task);
+}
+function requestRuntimeWork(lane, work) {
+	work.request(getRuntimeScheduler(), lane);
+}
+function runRuntimeHandlerScope(fn, flushMode = "defer") {
+	const savedScope = clearCurrentComponentScope();
+	try {
+		return getRuntimeScheduler().runInHandlerScope(fn, flushMode);
+	} finally {
+		endComponentScope(savedScope);
+	}
+}
+function runRuntimeWithSyncProgress(fn) {
+	return getRuntimeScheduler().runWithSyncProgress(fn);
+}
+function isRuntimeSchedulerExecuting() {
+	return getRuntimeScheduler().isExecuting();
+}
+function getRuntimeFlushVersion() {
+	return getRuntimeScheduler().getFlushVersion();
+}
+function flushRuntimeScheduler() {
+	getRuntimeScheduler().flush();
+}
+function markRuntimeReactivePropsDirtySource(source) {
+	getRuntimeReactivity().markReactivePropsDirtySource(source);
+}
+/**
+* Wrap an event listener so its work runs inside a scheduler handler scope.
+*
+* Resolves the active scheduler per call rather than closing over the module
+* singleton, so a runtime constructed with its own scheduler schedules its own
+* handlers.
+*/
+function scheduleEventHandler(handler) {
+	return (event) => {
+		try {
+			getRuntimeScheduler().runInHandlerScope(() => {
+				handler.call(null, event);
+			});
+		} catch (error) {
+			logger.error("[Askr] Event handler error:", error);
+		}
+	};
+}
+//#endregion
+export { getRuntimeEnv as C, incrementPerfMetric as S, isProductionEnvironment as T, defaultRuntimeState as _, getRuntimeEvaluation as a, ScheduledWork as b, getRuntimeScopes as c, markRuntimeReactivePropsDirtySource as d, requestRuntimeWork as f, createRuntimeState as g, scheduleEventHandler as h, getRuntimeCleanup as i, installRuntimeRenderer as l, runRuntimeWithSyncProgress as m, enqueueRuntimeTask as n, getRuntimeFlushVersion as o, runRuntimeHandlerScope as p, flushRuntimeScheduler as r, getRuntimeKeys as s, enqueueRuntimeLane as t, isRuntimeSchedulerExecuting as u, logger as v, isDevelopmentEnvironment as w, addPerfDuration as x, SCHEDULER_LANES as y };