@askrjs/askr 0.2.4 → 0.3.1

package/dist/index.d.ts

@@ -1,4 +1,121 @@
-import { A as cspNonce, B as selector, F as Show, H as configureRenderDiagnostics, I as ShowProps, L as For, M as CaseProps, Mn as StateSetter, N as Match, Nn as StateTuple, O as registerSSRStyle, P as MatchProps, Pn as state, R as ForProps, S as createQuery, T as createRef, V as RenderDiagnosticsOptions, at as derive, bn as defineScope, cn as QueryCollection, ct as RuntimeKeyedReorderDecision, d as defineServerQueries, dn as QueryCollectionOptions, dt as getDefaultRuntime, f as dehydrateDataRuntime, g as createQueryCollection, h as serveQuery, hn as QueryPrefetchContext, it as Derived, j as Case, jn as State, k as CspNonceScope, ln as QueryCollectionEntry, lt as RuntimeRendererHost, m as prefetchQuery, ot as AskrRuntime, p as hydrateDataRuntime, pn as QueryDefinition, pt as getSignal, st as AskrRuntimeOptions, tn as DataRuntime, u as defineQuery, un as QueryCollectionKey, ut as createRuntime, vn as ServerQueryHandler, w as Ref, xn as readScope, yn as Scope, z as Selector } from "./index-Dgjbo2gU.js";
-import { s as Props, t as Fragment } from "./types-DWVrKn9N.js";
-import { i as jsxs, n as jsx } from "./jsx-runtime-gVIaTPw0.js";
-export { AskrRuntime, type AskrRuntimeOptions, Case, type CaseProps, CspNonceScope, type DataRuntime, type Derived, For, type ForProps, Fragment, Match, type MatchProps, type Props, type QueryCollection, type QueryCollectionEntry, type QueryCollectionKey, type QueryCollectionOptions, type QueryDefinition, type QueryPrefetchContext, type Ref, type RenderDiagnosticsOptions, type RuntimeKeyedReorderDecision, type RuntimeRendererHost, type Scope, type Selector, type ServerQueryHandler, Show, type ShowProps, type State, type StateSetter, type StateTuple, configureRenderDiagnostics, createQuery, createQueryCollection, createRef, createRuntime, cspNonce, defineQuery, defineScope, defineServerQueries, dehydrateDataRuntime, derive, getDefaultRuntime, getSignal, hydrateDataRuntime, jsx, jsxs, prefetchQuery, readScope, registerSSRStyle, selector, serveQuery, state };
+export {
+  createDOMRendererHost,
+  DOMComponentOwner,
+  DOMChildScope,
+  DOMReactiveSource,
+  DOMRendererRange,
+  DOMRendererEvaluation,
+  DOMRendererCleanup,
+  DOMRendererScopes,
+  DOMRendererKeys,
+  DOMRendererReactivity,
+  DOMRendererHost,
+} from './dom-renderer.js';
+import {
+  cspNonce,
+  selector,
+  Show,
+  configureRenderDiagnostics,
+  ShowProps,
+  For,
+  CaseProps,
+  StateSetter,
+  Match,
+  StateTuple,
+  registerSSRStyle,
+  MatchProps,
+  state,
+  ForProps,
+  createQuery,
+  createRef,
+  RenderDiagnosticsOptions,
+  derive,
+  defineScope,
+  QueryCollection,
+  RuntimeKeyedReorderDecision,
+  defineServerQueries,
+  QueryCollectionOptions,
+  getDefaultRuntime,
+  dehydrateDataRuntime,
+  createQueryCollection,
+  serveQuery,
+  QueryPrefetchContext,
+  Derived,
+  Case,
+  State,
+  CspNonceScope,
+  QueryCollectionEntry,
+  RuntimeRendererHost,
+  prefetchQuery,
+  AskrRuntime,
+  hydrateDataRuntime,
+  QueryDefinition,
+  getSignal,
+  AskrRuntimeOptions,
+  DataRuntime,
+  defineQuery,
+  QueryCollectionKey,
+  createRuntime,
+  ServerQueryHandler,
+  Ref,
+  readScope,
+  Scope,
+  Selector,
+} from './core.js';
+import { Props, Fragment } from './elements.js';
+import { jsxs, jsx } from './jsx.js';
+export {
+  AskrRuntime,
+  type AskrRuntimeOptions,
+  Case,
+  type CaseProps,
+  CspNonceScope,
+  type DataRuntime,
+  type Derived,
+  For,
+  type ForProps,
+  Fragment,
+  Match,
+  type MatchProps,
+  type Props,
+  type QueryCollection,
+  type QueryCollectionEntry,
+  type QueryCollectionKey,
+  type QueryCollectionOptions,
+  type QueryDefinition,
+  type QueryPrefetchContext,
+  type Ref,
+  type RenderDiagnosticsOptions,
+  type RuntimeKeyedReorderDecision,
+  type RuntimeRendererHost,
+  type Scope,
+  type Selector,
+  type ServerQueryHandler,
+  Show,
+  type ShowProps,
+  type State,
+  type StateSetter,
+  type StateTuple,
+  configureRenderDiagnostics,
+  createQuery,
+  createQueryCollection,
+  createRef,
+  createRuntime,
+  cspNonce,
+  defineQuery,
+  defineScope,
+  defineServerQueries,
+  dehydrateDataRuntime,
+  derive,
+  getDefaultRuntime,
+  getSignal,
+  hydrateDataRuntime,
+  jsx,
+  jsxs,
+  prefetchQuery,
+  readScope,
+  registerSSRStyle,
+  selector,
+  serveQuery,
+  state,
+};

package/dist/index.js

@@ -1,24 +1,24 @@
-import { a as getRuntimeFlushVersion, f as AskrRuntime, h as getDefaultRuntime, m as createRuntime, t as enqueueRuntimeLane } from "./access-BucjYZcX.js";
-import { g as getSignal, i as claimHookIndex, p as getCurrentInstance } from "./component-scope-4I3yEMkb.js";
+import { _ as defaultRuntimeState, b as ScheduledWork, f as requestRuntimeWork, g as createRuntimeState, o as getRuntimeFlushVersion } from "./access-CEA2pOry.js";
+import { f as configureRenderDiagnostics, m as defineScope, v as readScope, w as bindComponentOwnership } from "./instance-VAFYVJOa.js";
+import { C as teardownScopeHost, D as captureOwnerRange, E as recordInlineComponentHost, O as releaseOwnerRange, S as resolveScopeBoundary, T as isComponentHostDetached, _ as captureChildScopeHost, b as prepareScopeRemoval, m as applyComponentResult, p as classifyUpdate, r as ensureNativeDOMHost, t as createRendererCapabilities, v as clearChildScopeHost, w as detachPortalHostOutput, x as recordRemovedScopeBoundary, y as hasUnmountedComponentHost } from "./renderer-CT0HeY58.js";
+import { O as ownCleanup, T as getOwnedChildScopes, f as getCurrentComponentInstance, h as getSignal, i as claimHookIndex, j as setOwnedChildScopes, x as componentRecordPrototype, y as OwnershipRecord } from "./scope-Cq_iYbTR.js";
+import { b as syncDerivedDependencySubscriptions, h as clearDerivedDependencySubscriptions, t as notifyReadableSource, v as recordReadableRead, x as withDerivedReadTracking } from "./notify-DxxuDPeY.js";
 import { n as Fragment } from "./jsx-DRS-qjiN.js";
-import { b as readScope, f as configureRenderDiagnostics, m as defineScope } from "./component-internal-C4hKKQBF.js";
-import { f as syncDerivedDependencySubscriptions, l as notifyReadableReaders, o as markReactivePropsDirtySource, p as withDerivedReadTracking, r as clearDerivedDependencySubscriptions, s as markReadableDerivedSubscribersDirty, u as recordReadableRead } from "./readable-Di1fzSwm.js";
-import { n as isSnapshotSource } from "./snapshot-source-BB42xgwb.js";
+import { n as isSnapshotSource } from "./snapshot-source-An4iKajG.js";
 import { c as registerSSRStyle } from "./render-context-B7ohlh6t.js";
-import { t as state } from "./state-BGJgYSyQ.js";
-import { t as selector } from "./selector-CsKuomw0.js";
-import { t as installRendererBridge } from "./renderer-Cl23O0hV.js";
-import { n as cspNonce, t as CspNonceScope } from "./csp-nonce-9NFUb7hJ.js";
-import { i as For, n as Match, r as Show, t as Case } from "./control-C-wSaq9V.js";
-import { jsx, jsxs } from "./jsx-runtime.js";
-import { n as createQuery, t as createQueryCollection } from "./data-ghKopAbp.js";
-import { a as hydrateDataRuntime, i as dehydrateDataRuntime, n as defineQuery, o as prefetchQuery, r as defineServerQueries, s as serveQuery } from "./query-registry-Bua3cDyb.js";
-//#region src/runtime/derive.ts
+import { t as state } from "./state-BXJfudq1.js";
+import { t as selector } from "./selector-BSPVkjKP.js";
+import { n as cspNonce, t as CspNonceScope } from "./csp-nonce-BfFWcd0w.js";
+import { i as For, n as Match, r as Show, t as Case } from "./control-BR_mrX__.js";
+import { r as jsxs, t as jsx } from "./jsx-runtime-CPJXAOBF.js";
+import { n as createQuery, t as createQueryCollection } from "./data-2edW0jhF.js";
+import { a as hydrateDataRuntime, i as dehydrateDataRuntime, n as defineQuery, o as prefetchQuery, r as defineServerQueries, s as serveQuery } from "./query-registry-LrYpQsDJ.js";
+//#region src/runtime/reactivity/derive.ts
 const deriveCells = /* @__PURE__ */ new WeakMap();
 const dirtyDerivedCells = /* @__PURE__ */ new Set();
-let hasPendingDerivedFlush = false;
+const derivedWork = new ScheduledWork(flushDirtyDerivedCells);
 function getDeriveStore(instance) {
-	const generation = instance._ownershipGeneration;
+	const generation = instance.owner.identity;
 	let store = deriveCells.get(generation);
 	if (!store) {
 		store = /* @__PURE__ */ new Map();
@@ -28,16 +28,13 @@ function getDeriveStore(instance) {
 }
 function markDerivedCellDirty(cell) {
 	cell._dirty = true;
-	if (cell._scheduled) return;
-	cell._scheduled = true;
-	dirtyDerivedCells.add(cell);
-	if (!hasPendingDerivedFlush) {
-		hasPendingDerivedFlush = true;
-		enqueueRuntimeLane("derived", flushDirtyDerivedCells);
+	if (!cell._pending) {
+		cell._pending = true;
+		dirtyDerivedCells.add(cell);
 	}
+	requestRuntimeWork("derived", derivedWork);
 }
 function flushDirtyDerivedCells() {
-	hasPendingDerivedFlush = false;
 	if (dirtyDerivedCells.size === 0) return;
 	const pending = dirtyDerivedCells.values();
 	let failures = null;
@@ -45,7 +42,7 @@ function flushDirtyDerivedCells() {
 	while (!next.done) {
 		const cell = next.value;
 		dirtyDerivedCells.delete(cell);
-		cell._scheduled = false;
+		cell._pending = false;
 		if (!cell._dirty) {
 			next = pending.next();
 			continue;
@@ -85,11 +82,7 @@ function recomputeDerivedCell(cell, notifyDownstream) {
 	cell._hasValue = true;
 	cell._value = nextValue;
 	cell._lastRecomputeFlushVersion = getRuntimeFlushVersion();
-	if (valueChanged && notifyDownstream) {
-		markReadableDerivedSubscribersDirty(cell, true);
-		markReactivePropsDirtySource(cell);
-		notifyReadableReaders(cell);
-	}
+	if (valueChanged && notifyDownstream) notifyReadableSource(cell, { skipCurrentDerivedSubscriber: true });
 	return cell._value;
 }
 function createDerivedCell(instance, generation, store, hookIndex, compute) {
@@ -100,7 +93,7 @@ function createDerivedCell(instance, generation, store, hookIndex, compute) {
 			return derivedCell._value;
 		}
 		recordReadableRead(derivedCell);
-		return recomputeDerivedCell(derivedCell, derivedCell._scheduled);
+		return recomputeDerivedCell(derivedCell, derivedCell._pending);
 	};
 	cell._owner = instance;
 	cell._hookIndex = hookIndex;
@@ -108,7 +101,7 @@ function createDerivedCell(instance, generation, store, hookIndex, compute) {
 	cell._value = void 0;
 	cell._hasValue = false;
 	cell._dirty = true;
-	cell._scheduled = false;
+	cell._pending = false;
 	cell._evaluating = false;
 	cell._active = true;
 	cell._lastRecomputeFlushVersion = -1;
@@ -119,7 +112,7 @@ function createDerivedCell(instance, generation, store, hookIndex, compute) {
 	cell._cleanup = () => {
 		if (!cell._active) return;
 		cell._active = false;
-		cell._scheduled = false;
+		cell._pending = false;
 		cell._dirty = false;
 		cell._pendingDependencySources = void 0;
 		dirtyDerivedCells.delete(cell);
@@ -128,10 +121,13 @@ function createDerivedCell(instance, generation, store, hookIndex, compute) {
 		cell._readers?.size;
 		cell._readers?.clear();
 	};
-	(instance.cleanupFns ??= []).push(() => {
-		cell._cleanup();
-		store.delete(hookIndex);
-		if (store.size === 0 && deriveCells.get(generation) === store) deriveCells.delete(generation);
+	ownCleanup(instance.owner, () => {
+		try {
+			cell._cleanup();
+		} finally {
+			store.delete(hookIndex);
+			if (store.size === 0 && deriveCells.get(generation) === store) deriveCells.delete(generation);
+		}
 	});
 	return cell;
 }
@@ -143,7 +139,7 @@ function getOrCreateDerivedCell(instance, hookIndex, compute) {
 		if (existing._lastRecomputeFlushVersion !== getRuntimeFlushVersion()) existing._dirty = true;
 		return existing;
 	}
-	const created = createDerivedCell(instance, instance._ownershipGeneration, store, hookIndex, compute);
+	const created = createDerivedCell(instance, instance.owner.identity, store, hookIndex, compute);
 	store.set(hookIndex, created);
 	return created;
 }
@@ -161,25 +157,298 @@ function createMappedSelector(source, map) {
 	};
 }
 function derive(source, map) {
-	const instance = getCurrentInstance();
+	const instance = getCurrentComponentInstance();
 	if (!instance) throw new Error("derive() can only be called during component render execution. Move derive() calls to the top level of your component function.");
 	const cell = getOrCreateDerivedCell(instance, claimHookIndex(instance, "derive"), map === void 0 ? () => source() : createMappedSelector(source, map));
 	recomputeDerivedCell(cell, false);
 	return cell;
 }
 //#endregion
+//#region src/runtime/public-ownership.ts
+const fields = {
+	mounted: "mounted",
+	abortController: "controller",
+	cleanupFns: "cleanups",
+	_lastReadSources: "reads",
+	_ownershipGeneration: "identity"
+};
+const descriptors = {};
+for (const [field, member] of Object.entries(fields)) descriptors[field] = {
+	enumerable: true,
+	configurable: true,
+	get() {
+		return this.owner[member];
+	},
+	set(value) {
+		this.owner[member] = value;
+	}
+};
+descriptors._ownedChildScopes = {
+	enumerable: true,
+	configurable: true,
+	get() {
+		return getOwnedChildScopes(this.owner);
+	},
+	set(scopes) {
+		setOwnedChildScopes(this.owner, scopes);
+	}
+};
+let ownershipViewsInstalled = false;
+/**
+* Publish the legacy ownership property views onto the execution record.
+*
+* Called at module scope from the published entry barrels: an entry barrel
+* exists to compose the surface a consumer imports, so wiring there is the
+* composition root rather than accidental import-order coupling. It latches so
+* that importing several entries, or adapting a renderer host afterwards,
+* redefines nothing.
+*/
+function installOwnershipViews() {
+	if (ownershipViewsInstalled) return;
+	ownershipViewsInstalled = true;
+	Object.defineProperties(componentRecordPrototype, descriptors);
+}
+const exposed = /* @__PURE__ */ new WeakSet();
+/** Preserve the object identity used by host callbacks and readable maps.
+* Legacy properties are views of the same record, never copied lifetime state. */
+function componentView(instance) {
+	if (!exposed.has(instance)) {
+		Object.defineProperties(instance, descriptors);
+		exposed.add(instance);
+	}
+	return instance;
+}
+/** Adopt a consumer-created extension record in place, preserving identity. */
+function executionRecord(instance) {
+	const record = instance;
+	if (!record.owner) {
+		const owner = new OwnershipRecord();
+		owner.mounted = instance.mounted;
+		owner.controller = instance.abortController;
+		owner.cleanups = instance.cleanupFns;
+		setOwnedChildScopes(owner, instance._ownedChildScopes);
+		owner.reads = instance._lastReadSources;
+		owner.identity = instance._ownershipGeneration;
+		record.owner = owner;
+		bindComponentOwnership(record);
+		componentView(record);
+	}
+	return record;
+}
+//#endregion
+//#region src/renderer/host-adapter.ts
+const nativeHosts = /* @__PURE__ */ new WeakMap();
+/** Only extension hosts pay for callback translation. Keep their receiver and
+* look up methods at invocation time so later host mutation stays observable. */
+function adaptRendererHost(host) {
+	installOwnershipViews();
+	const native = nativeHosts.get(host);
+	if (native) return native;
+	return {
+		captureComponentHost: captureOwnerRange,
+		releaseComponentHost: releaseOwnerRange,
+		detachPortalHostOutput,
+		isComponentHostDetached,
+		clearChildScopeHost,
+		captureChildScopeHost,
+		resolveScopeBoundary,
+		prepareScopeRemoval,
+		recordRemovedScopeBoundary,
+		teardownScopeHost,
+		hasUnmountedComponentHost,
+		recordInlineComponentHost,
+		applyComponentResult,
+		classifyComponentUpdate: classifyUpdate,
+		evaluate: (...args) => {
+			if (args[3]) componentView(args[3]);
+			return host.evaluate(...args);
+		},
+		cleanupInstancesUnder: (...args) => host.cleanupInstancesUnder(...args),
+		replaceComponentRange: (...args) => {
+			componentView(args[0]);
+			return host.replaceComponentRange(...args);
+		},
+		get resolveChildScopeRange() {
+			return host.resolveChildScopeRange ? (...args) => {
+				componentView(args[0].componentInstance);
+				return host.resolveChildScopeRange(...args);
+			} : void 0;
+		},
+		teardownNodeSubtree: (...args) => host.teardownNodeSubtree(...args),
+		populateKeyMapForElement: (...args) => host.populateKeyMapForElement(...args),
+		getKeyMapForElement: (...args) => host.getKeyMapForElement(...args),
+		isKeyedReorderFastPathEligible: (...args) => host.isKeyedReorderFastPathEligible(...args),
+		markReactivePropsDirtySource: (...args) => host.markReactivePropsDirtySource(...args)
+	};
+}
+/** Keep the native host's identity and writable properties. Only inbound
+* extension records require adoption; ordinary owners are already authoritative. */
+function rendererHostView(capabilities) {
+	installOwnershipViews();
+	const host = capabilities;
+	if (nativeHosts.has(host)) return host;
+	const evaluate = capabilities.evaluate;
+	capabilities.evaluate = function(...args) {
+		if (args[3] && !args[3].owner) executionRecord(args[3]);
+		return evaluate.apply(this, args);
+	};
+	const replace = capabilities.replaceComponentRange;
+	capabilities.replaceComponentRange = function(...args) {
+		if (!args[0].owner) executionRecord(args[0]);
+		return replace.apply(this, args);
+	};
+	const resolve = capabilities.resolveChildScopeRange;
+	if (resolve) capabilities.resolveChildScopeRange = function(...args) {
+		if (!args[0].componentInstance.owner) executionRecord(args[0].componentInstance);
+		return resolve.apply(this, args);
+	};
+	nativeHosts.set(host, capabilities);
+	return host;
+}
+//#endregion
+//#region src/runtime/public-runtime.ts
+const defaultRuntimeOptions = {};
+/** Construction-only scheduler and renderer wiring. Mounting uses the default runtime. */
+var AskrRuntime = class {
+	#rendererCapabilities;
+	#state;
+	constructor(options = {}) {
+		this.#state = options === defaultRuntimeOptions ? defaultRuntimeState : createRuntimeState(options.scheduler);
+		this.scheduler = this.#state.scheduler;
+		this.rendererHost = options.renderer ?? rendererHostView(this.#state.renderer);
+		this.#state.renderer = adaptRendererHost(this.rendererHost);
+		this.#rendererCapabilities = this.#state.renderer;
+	}
+	get renderer() {
+		if (this.#rendererCapabilities !== this.#state.renderer) {
+			this.#rendererCapabilities = this.#state.renderer;
+			this.rendererHost = rendererHostView(this.#rendererCapabilities);
+		}
+		return this.rendererHost;
+	}
+	configureRenderer(renderer) {
+		this.#state.renderer = adaptRendererHost(renderer);
+		this.#rendererCapabilities = this.#state.renderer;
+		this.rendererHost = renderer;
+	}
+};
+/** Create construction-only runtime wiring. Omitted schedulers share the default scheduler; mounting uses the default runtime. */
+function createRuntime(options = {}) {
+	return new AskrRuntime(options);
+}
+const defaultRuntime = /* @__PURE__ */ new AskrRuntime(defaultRuntimeOptions);
+/** Get the process-wide default {@link AskrRuntime}. */
+function getDefaultRuntime() {
+	return defaultRuntime;
+}
+//#endregion
+//#region src/renderer/public-dom-host.ts
+function handles() {
+	const outward = /* @__PURE__ */ new WeakMap();
+	const inward = /* @__PURE__ */ new WeakMap();
+	return {
+		wrap(record) {
+			let handle = outward.get(record);
+			if (!handle) {
+				handle = Object.freeze({});
+				outward.set(record, handle);
+				inward.set(handle, record);
+			}
+			return handle;
+		},
+		unwrap(handle) {
+			const record = inward.get(handle);
+			if (!record) throw new TypeError("[Askr] Invalid DOM renderer handle.");
+			return record;
+		}
+	};
+}
+/** Construct a complete DOM adapter without installing it. Handles belong only
+* to this factory; native delegates validate them before accessing the DOM. */
+function createDOMRendererHost(configure) {
+	ensureNativeDOMHost();
+	const renderer = rendererHostView(createRendererCapabilities());
+	const owners = handles();
+	const scopes = handles();
+	const sources = handles();
+	const native = {
+		evaluation: {
+			evaluate(node, target, context, owner) {
+				renderer.evaluate(node, target, context, owner === void 0 ? void 0 : owners.unwrap(owner));
+			},
+			replaceComponentRange(owner, result, host) {
+				return renderer.replaceComponentRange(owners.unwrap(owner), result, host);
+			}
+		},
+		cleanup: {
+			cleanupInstancesUnder(node) {
+				renderer.cleanupInstancesUnder(node);
+			},
+			teardownNodeSubtree(node) {
+				renderer.teardownNodeSubtree(node);
+			}
+		},
+		scopes: { resolveChildScopeRange(scope) {
+			const range = renderer.resolveChildScopeRange(scopes.unwrap(scope));
+			return range ? Object.freeze({
+				start: range.start,
+				end: range.end,
+				single: range.single
+			}) : null;
+		} },
+		keys: {
+			populateKeyMapForElement(parent) {
+				renderer.populateKeyMapForElement(parent);
+			},
+			getKeyMapForElement(parent) {
+				return renderer.getKeyMapForElement(parent);
+			},
+			isKeyedReorderFastPathEligible(parent, children, oldKeyMap) {
+				return renderer.isKeyedReorderFastPathEligible(parent, children, oldKeyMap);
+			}
+		},
+		reactivity: { markReactivePropsDirtySource(source) {
+			renderer.markReactivePropsDirtySource(sources.unwrap(source));
+		} }
+	};
+	const required = Object.fromEntries(Object.entries(native).map(([role, methods]) => [role, Object.keys(methods)]));
+	const host = configure(native);
+	for (const role of Object.keys(required)) for (const method of required[role]) if (typeof (host?.[role])?.[method] !== "function") throw new TypeError(`[Askr] DOM renderer requires ${role}.${method}.`);
+	return {
+		evaluate(node, target, context, owner) {
+			host.evaluation.evaluate(node, target, context, owner === void 0 ? void 0 : owners.wrap(owner));
+		},
+		replaceComponentRange(owner, result, target) {
+			return host.evaluation.replaceComponentRange(owners.wrap(owner), result, target);
+		},
+		cleanupInstancesUnder(node) {
+			host.cleanup.cleanupInstancesUnder(node);
+		},
+		teardownNodeSubtree(node) {
+			host.cleanup.teardownNodeSubtree(node);
+		},
+		resolveChildScopeRange(scope) {
+			return host.scopes.resolveChildScopeRange(scopes.wrap(scope));
+		},
+		populateKeyMapForElement(parent) {
+			host.keys.populateKeyMapForElement(parent);
+		},
+		getKeyMapForElement(parent) {
+			return host.keys.getKeyMapForElement(parent);
+		},
+		isKeyedReorderFastPathEligible(parent, children, oldKeyMap) {
+			return host.keys.isKeyedReorderFastPathEligible(parent, children, oldKeyMap);
+		},
+		markReactivePropsDirtySource(source) {
+			host.reactivity.markReactivePropsDirtySource(sources.wrap(source));
+		}
+	};
+}
+//#endregion
 //#region src/ref.ts
 /** Create a new, empty {@link Ref} holder. */
 function createRef() {
 	return { current: null };
 }
 //#endregion
-//#region src/index.ts
-/**
-* Askr: Lane-scheduled deterministic UI framework
-*
-* Public API surface — only users should import from here
-*/
-installRendererBridge();
-//#endregion
-export { AskrRuntime, Case, CspNonceScope, For, Fragment, Match, Show, configureRenderDiagnostics, createQuery, createQueryCollection, createRef, createRuntime, cspNonce, defineQuery, defineScope, defineServerQueries, dehydrateDataRuntime, derive, getDefaultRuntime, getSignal, hydrateDataRuntime, jsx, jsxs, prefetchQuery, readScope, registerSSRStyle, selector, serveQuery, state };
+export { AskrRuntime, Case, CspNonceScope, For, Fragment, Match, Show, configureRenderDiagnostics, createDOMRendererHost, createQuery, createQueryCollection, createRef, createRuntime, cspNonce, defineQuery, defineScope, defineServerQueries, dehydrateDataRuntime, derive, getDefaultRuntime, getSignal, hydrateDataRuntime, jsx, jsxs, prefetchQuery, readScope, registerSSRStyle, selector, serveQuery, state };