silvery 0.19.2 → 0.21.1

package/dist/reconciler-NBDSEm8k.mjs

@@ -0,0 +1,2178 @@
+import { m as syncTextContentSignal } from "./layout-signals-Dch2EiCy.mjs";
+import { $ as isSoftBreakPoint, W as getActiveLineHeight, _t as wrapText, z as displayWidth } from "./ansi-OYRLxxZQ.mjs";
+import { O as warnOnce } from "./src-Oe6x5PrS.mjs";
+import { a as requireCapability, n as getConstants, r as getLayoutEngine } from "./layout-engine-Ca_nbtfL.mjs";
+import { createContext } from "react";
+import { createLogger } from "loggily";
+import Reconciler from "react-reconciler";
+import { DefaultEventPriority, DiscreteEventPriority, NoEventPriority } from "react-reconciler/constants.js";
+//#region packages/ag/src/dirty-tracking.ts
+/**
+* Nodes with any content/style dirty flag. Written by reconciler,
+* read by render phase for targeted subtree entry.
+*/
+const contentDirtyNodes = /* @__PURE__ */ new Set();
+/**
+* Nodes where ONLY style props changed (no content, layout, or children changes).
+* These are eligible for the style-only fast path in the render phase, which
+* updates cell styles without re-collecting text or re-computing layout.
+*
+* A node is style-only when commitUpdate classifies contentChanged="style"
+* AND layoutChanged=false. The render phase checks this set to decide whether
+* to use restyleRegion() instead of full renderText()/renderBox().
+*/
+const styleOnlyDirtyNodes = /* @__PURE__ */ new Set();
+/**
+* Nodes where scrollTo/scrollOffset changed. These don't affect Flexily layout
+* dimensions, but the scroll, sticky, scrollRect, and notify phases must still
+* run to update visible children positions.
+*
+* Written by reconciler (host-config.ts commitUpdate), read by ag.ts
+* layout-on-demand gate.
+*/
+const scrollDirtyNodes = /* @__PURE__ */ new Set();
+/** Mark a node as content-dirty. Called when content/style flags are set. */
+function trackContentDirty(node) {
+	contentDirtyNodes.add(node);
+}
+/**
+* Mark a node as style-only dirty. Called when commitUpdate sees
+* contentChanged="style" AND layoutChanged=false.
+* If a node is later marked with contentDirty, the render phase ignores
+* the style-only flag (full path takes precedence).
+*/
+function trackStyleOnlyDirty(node) {
+	styleOnlyDirtyNodes.add(node);
+}
+/** Mark a node as scroll-dirty. Called when scrollTo/scrollOffset props change. */
+function trackScrollDirty(node) {
+	scrollDirtyNodes.add(node);
+}
+/** O(1) check: are there any scroll-dirty nodes? */
+function hasScrollDirty() {
+	return scrollDirtyNodes.size > 0;
+}
+/** Clear all dirty tracking. Called after each render pass completes. */
+function clearDirtyTracking() {
+	contentDirtyNodes.clear();
+	styleOnlyDirtyNodes.clear();
+	scrollDirtyNodes.clear();
+}
+//#endregion
+//#region packages/ag/src/epoch.ts
+/**
+* The current render epoch. Incremented after each render pass.
+* Reconciler stamps dirty nodes with this value; render phase checks equality.
+*/
+let renderEpoch = 0;
+/** Get the current render epoch value. */
+function getRenderEpoch() {
+	return renderEpoch;
+}
+/**
+* Advance the render epoch. Called once at the end of each render pass.
+* All nodes stamped with the old epoch instantly become "not dirty".
+*/
+function advanceRenderEpoch() {
+	renderEpoch++;
+}
+/**
+* Check if an epoch stamp matches the current render epoch (i.e., "is dirty").
+*/
+function isCurrentEpoch(epoch) {
+	return epoch === renderEpoch;
+}
+/**
+* Check if a specific dirty bit is set for the current epoch.
+* Returns true if dirtyEpoch matches the current render epoch AND the bit is set.
+*/
+function isDirty(dirtyBits, dirtyEpoch, bit) {
+	return dirtyEpoch === renderEpoch && (dirtyBits & bit) !== 0;
+}
+/**
+* Check if ANY dirty bit is set for the current epoch.
+*/
+function isAnyDirty(dirtyBits, dirtyEpoch) {
+	return dirtyEpoch === renderEpoch && dirtyBits !== 0;
+}
+//#endregion
+//#region packages/scope/src/trace.ts
+/**
+* @silvery/scope/trace — opt-in leak detector for scopes and disposables.
+*
+* Gated by `SILVERY_SCOPE_TRACE=1`. When enabled, every `createScope()`
+* and `disposable()` call is recorded with its creation stack; dispose
+* unregisters; at process exit any remaining entries are logged.
+*
+* Zero overhead when disabled — the public functions are no-ops behind
+* an early-return guard. The trace registry isn't even allocated.
+*
+* Why: silvery's `Scope` (Phase 0/1/2 of `km-silvery.lifecycle-scope`)
+* makes resource ownership explicit, but adoption is opt-in. This is the
+* runtime backstop for what the ESLint `no-raw-lifecycle` rule can't see
+* (dynamic call sites, third-party paths). Together they make
+* convention-driven leaks structurally impossible.
+*
+* Usage in tests / CI:
+* ```bash
+* SILVERY_SCOPE_TRACE=1 bun run test
+* ```
+*
+* The detector logs to stderr at process exit (or `getTraceSnapshot()`
+* is callable any time for in-test assertions). Production builds — no
+* env var set — skip every code path.
+*
+* @packageDocumentation
+*/
+const TRACE_ENV = "SILVERY_SCOPE_TRACE";
+function envEnabled() {
+	try {
+		return !!globalThis.process?.env?.[TRACE_ENV];
+	} catch {
+		return false;
+	}
+}
+const traceEnabled = envEnabled();
+const live = traceEnabled ? /* @__PURE__ */ new Map() : null;
+/** Internal — register a handle on creation. No-op when tracing is off. */
+function _trackCreate(handle, kind, name) {
+	if (!live) return;
+	const stack = (/* @__PURE__ */ new Error("(creation stack)")).stack ?? "";
+	live.set(handle, {
+		kind,
+		name,
+		createdAt: stack
+	});
+}
+/** Internal — unregister a handle on dispose. No-op when tracing is off. */
+function _trackDispose(handle) {
+	if (!live) return;
+	live.delete(handle);
+}
+/** Force the at-exit report to fire now (for tests / manual diagnostics).
+*  Always logs the count, even if zero. No-op when tracing is off. */
+function reportTraceLeaks() {
+	if (!live) return 0;
+	const count = live.size;
+	if (count === 0) {
+		console.error("[silvery:scope:trace] no undisposed handles");
+		return 0;
+	}
+	console.error(`[silvery:scope:trace] ${count} undisposed handle(s):`);
+	for (const entry of live.values()) {
+		const label = entry.kind + (entry.name ? `(${entry.name})` : "");
+		console.error(`  - ${label}`);
+		console.error(entry.createdAt);
+	}
+	return count;
+}
+/**
+* Print a per-scope handle-delta diagnostic at scope close. Called from
+* `Scope[Symbol.asyncDispose]()` AFTER the inherited stack drains. Per
+* km-silvery.lifecycle-leak-detection Phase 2: previously the trace only
+* fired at process exit, which left in-test scope-close leaks invisible
+* until the worker terminated.
+*
+* `pre` and `post` are snapshot counts of `getAdoptedHandles(scope).length`
+* before and after scope-close. The delta is reported to stderr when
+* tracing is enabled and the scope did NOT balance.
+*/
+function reportScopeDelta(scopeName, pre, post) {
+	if (!traceEnabled) return;
+	if (post === 0) return;
+	const label = scopeName ? `Scope(${scopeName})` : "Scope";
+	console.error(`[silvery:scope:trace] ${label} close-delta: ${pre} adopted → ${post} undisposed (${pre - post} disposed cleanly)`);
+}
+if (traceEnabled) {
+	const proc = globalThis.process;
+	if (proc?.on) proc.on("exit", () => {
+		reportTraceLeaks();
+	});
+}
+//#endregion
+//#region packages/scope/src/handle.ts
+/**
+* Module-private set of every legitimate handle the factory has produced.
+* `WeakSet` keys by reference, so disposed-and-GC'd handles drop out
+* automatically; this is the canonical source of truth for "is this a real
+* silvery handle?" Forged values (created via `as TickHandle` or by hand)
+* are NOT in this set, so `adoptHandle()` and `Scope.use()` reject them.
+*/
+const branded = /* @__PURE__ */ new WeakSet();
+const metadata = /* @__PURE__ */ new WeakMap();
+/**
+* Global count of handles currently alive (created but not yet disposed).
+* Incremented in `defineHandle().create()`, decremented once on first
+* dispose (idempotent). WeakSet alone cannot give a count; this integer
+* counter is the parallel deterministic accounting layer.
+*
+* Used by tests to assert structural lifecycle invariants without GC:
+*   - After dispose-all: `getActiveHandleCount() === 0`
+*   - During N creates: `getActiveHandleCount() === N`
+*
+* Not per-scope (use `getAdoptedHandles(scope)` for per-scope accounting).
+*/
+let _activeHandleCount = 0;
+/** True iff `value` was minted by `defineHandle(...).create(...)`. */
+function isBrandedHandle(value) {
+	return typeof value === "object" && value !== null && branded.has(value);
+}
+function defineHandle(kind) {
+	Symbol(`silvery.handle:${kind}`);
+	return {
+		/** Diagnostic label for this handle kind. */
+		kind,
+		/**
+		* Create an opaque, frozen handle that wraps `value` with `dispose`
+		* cleanup. The returned value is registered in the module-private
+		* `branded` WeakSet so the library can authenticate it later.
+		*
+		* The handle is `Object.freeze`d before return so callers cannot
+		* overwrite `[Symbol.asyncDispose]`, `[Symbol.dispose]`, or any
+		* surface property the consuming factory adds via `Object.assign`.
+		* Add public surface BEFORE returning from your factory.
+		*/
+		create(_value, dispose) {
+			const handle = Object.create(null);
+			let _disposed = false;
+			Object.defineProperty(handle, Symbol.asyncDispose, {
+				value: async () => {
+					if (!_disposed) {
+						_disposed = true;
+						_activeHandleCount--;
+					}
+					await dispose();
+				},
+				enumerable: false,
+				writable: false,
+				configurable: false
+			});
+			Object.defineProperty(handle, Symbol.dispose, {
+				value: () => {
+					if (!_disposed) {
+						_disposed = true;
+						_activeHandleCount--;
+					}
+					dispose();
+				},
+				enumerable: false,
+				writable: false,
+				configurable: false
+			});
+			branded.add(handle);
+			metadata.set(handle, { kind });
+			_activeHandleCount++;
+			return handle;
+		}
+	};
+}
+/**
+* Finalise a handle's public surface and freeze it. Call this from the
+* resource factory AFTER attaching all public properties (e.g. `iterable`,
+* `emitted`) and BEFORE returning to the consumer.
+*
+* @param handle The branded handle returned by `<defineHandle().create>`.
+* @param surface Public properties to attach (each becomes non-enumerable,
+*                non-writable, non-configurable so the freeze is real).
+*
+* @example
+* ```ts
+* const handle = Tick.create(internal, stop)
+* finaliseHandle(handle, { iterable, emitted: () => count })
+* return handle as TickHandle
+* ```
+*/
+function finaliseHandle(handle, surface) {
+	if (!branded.has(handle)) throw new TypeError("finaliseHandle: not a branded handle (call defineHandle().create first)");
+	for (const key of Object.keys(surface)) Object.defineProperty(handle, key, {
+		value: surface[key],
+		enumerable: true,
+		writable: false,
+		configurable: false
+	});
+	for (const sym of Object.getOwnPropertySymbols(surface)) Object.defineProperty(handle, sym, {
+		value: surface[sym],
+		enumerable: false,
+		writable: false,
+		configurable: false
+	});
+	Object.freeze(handle);
+	return handle;
+}
+/**
+* Per-scope handle accounting. Keyed by `Scope` instance via WeakMap so we
+* don't have to modify the Scope class signature for the minimum-invasive
+* Phase 1 prototype.
+*/
+const ownedHandles = /* @__PURE__ */ new WeakMap();
+const handleOrigins = /* @__PURE__ */ new WeakMap();
+/**
+* Adopt a `Handle` into the given scope's ownership registry. The handle:
+*
+*  - is rejected if it isn't in the module-private `branded` WeakSet
+*    (forged values fail here)
+*  - is rejected if already owned by a different scope
+*  - is registered with `scope.use(...)` for LIFO disposal
+*  - subscribes to early manual disposal so the registry stays accurate
+*    if the consumer calls `handle[Symbol.asyncDispose]()` directly
+*
+* Idempotent: adopting the same handle twice into the same scope is a no-op.
+*/
+function adoptHandle(scope, handle) {
+	if (scope.disposed) throw new ReferenceError("Cannot adopt handle into a disposed scope");
+	if (!branded.has(handle)) throw new TypeError("adoptHandle: value is not a silvery handle (forged via 'as' or wrong factory). Use the resource's createX(scope, ...) factory.");
+	let owned = ownedHandles.get(scope);
+	if (!owned) {
+		owned = /* @__PURE__ */ new Set();
+		ownedHandles.set(scope, owned);
+	}
+	const existingOwner = handleOrigins.get(handle);
+	if (existingOwner && existingOwner !== scope) throw new TypeError("Handle already owned by another scope; create a new handle for this scope instead");
+	if (owned.has(handle)) return;
+	owned.add(handle);
+	handleOrigins.set(handle, scope);
+	const existing = metadata.get(handle);
+	if (existing && !existing.createdAt) metadata.set(handle, {
+		...existing,
+		createdAt: captureCreationStack()
+	});
+	let disposedFlag = false;
+	const removeFromRegistry = () => {
+		if (disposedFlag) return;
+		disposedFlag = true;
+		owned.delete(handle);
+		handleOrigins.delete(handle);
+	};
+	scope.use({ [Symbol.asyncDispose]: async () => {
+		try {
+			if (!disposedFlag) await handle[Symbol.asyncDispose]();
+		} finally {
+			removeFromRegistry();
+		}
+	} });
+}
+/**
+* Snapshot the current set of handles still adopted into this scope.
+* Empty when the scope was never used or all handles are disposed.
+*/
+function getAdoptedHandles(scope) {
+	const owned = ownedHandles.get(scope);
+	if (!owned || owned.size === 0) return [];
+	const result = [];
+	for (const h of owned) {
+		const meta = metadata.get(h);
+		result.push({
+			kind: meta?.kind ?? "unknown",
+			createdAt: meta?.createdAt
+		});
+	}
+	return result;
+}
+function captureCreationStack() {
+	return ((/* @__PURE__ */ new Error("(handle adoption)")).stack ?? "").split("\n").slice(3).join("\n");
+}
+//#endregion
+//#region packages/scope/src/index.ts
+/**
+* @silvery/scope — Structured concurrency scopes for silvery apps.
+*
+* `Scope` is a subclass of TC39's `AsyncDisposableStack` that adds:
+* - an `AbortSignal` that aborts on disposal (and links to a parent's signal)
+* - a `child(name?)` method that creates child scopes with cascade disposal
+* - an overridden `[Symbol.asyncDispose]()` that disposes children before the
+*   inherited user disposer stack
+*
+* All disposer-stack semantics (LIFO, async-await, idempotent dispose,
+* `SuppressedError` on multi-throw, post-dispose `ReferenceError`) come
+* from `AsyncDisposableStack` directly.
+*
+* @example
+* ```ts
+* using scope = createScope("app")
+* const proc = scope.use(disposable(
+*   child_process.spawn("claude"),
+*   p => p.kill("SIGTERM"),
+* ))
+* ```
+*
+* @packageDocumentation
+*/
+var Scope = class Scope extends AsyncDisposableStack {
+	signal;
+	name;
+	#children = /* @__PURE__ */ new Set();
+	#parent;
+	constructor(parent, name) {
+		super();
+		this.name = name;
+		this.#parent = parent;
+		_trackCreate(this, "scope", name);
+		const controller = new AbortController();
+		this.signal = controller.signal;
+		this.defer(() => controller.abort());
+		if (parent) {
+			if (parent.disposed) throw new ReferenceError("Cannot create child of disposed scope");
+			if (parent.signal.aborted) controller.abort();
+			else {
+				const onAbort = () => controller.abort();
+				parent.signal.addEventListener("abort", onAbort, { once: true });
+				this.defer(() => parent.signal.removeEventListener("abort", onAbort));
+			}
+			parent.#children.add(this);
+		}
+	}
+	/** Create a child scope. Child's signal aborts when this scope's signal does. */
+	child(name) {
+		return new Scope(this, name);
+	}
+	/**
+	* Schedule a one-shot callback owned by this scope. Disposing the scope
+	* clears the timer if it has not fired yet. The returned function cancels
+	* the timer early and is idempotent.
+	*/
+	timeout(callback, ms, opts) {
+		let active = true;
+		const timer = setTimeout(() => {
+			if (!active) return;
+			active = false;
+			callback();
+		}, ms);
+		if (opts?.unref === true) timer.unref?.();
+		const cancel = () => {
+			if (!active) return;
+			active = false;
+			clearTimeout(timer);
+		};
+		this.defer(cancel);
+		return cancel;
+	}
+	/**
+	* Schedule a repeating callback owned by this scope. Disposing the scope
+	* clears the interval. The returned function cancels the interval early
+	* and is idempotent.
+	*/
+	interval(callback, ms, opts) {
+		let active = true;
+		const timer = setInterval(() => {
+			if (active) callback();
+		}, ms);
+		if (opts?.unref === true) timer.unref?.();
+		const cancel = () => {
+			if (!active) return;
+			active = false;
+			clearInterval(timer);
+		};
+		this.defer(cancel);
+		return cancel;
+	}
+	/**
+	* Cancellation-aware sleep. Resolves when the timer fires, when the scope
+	* is disposed, or immediately if the scope is already aborted.
+	*/
+	sleep(ms, opts) {
+		return new Promise((resolve) => {
+			if (this.signal.aborted) {
+				resolve();
+				return;
+			}
+			let done = false;
+			let cancelTimer = null;
+			const finish = () => {
+				if (done) return;
+				done = true;
+				cancelTimer?.();
+				this.signal.removeEventListener("abort", finish);
+				resolve();
+			};
+			this.signal.addEventListener("abort", finish, { once: true });
+			cancelTimer = this.timeout(finish, ms, opts);
+			this.defer(finish);
+		});
+	}
+	/**
+	* A debounced wrapper around `fn`, owned by this scope. Each call cancels the
+	* pending invocation and reschedules `ms` out, so only the last call in a
+	* burst fires. Uses a SINGLE timer slot — no per-call defer accumulation
+	* (unlike repeatedly calling {@link timeout}), which is what makes it the
+	* right primitive for keystroke/hover debounces. Disposing the scope cancels
+	* any pending call; the returned function exposes `.cancel()` to drop a
+	* pending call early. Resolves the structured-concurrency adoption need for
+	* cancel-and-reschedule timers (@km/all/structured-concurrency).
+	*/
+	debounce(fn, ms, opts) {
+		let timer;
+		const cancel = () => {
+			if (timer !== void 0) {
+				clearTimeout(timer);
+				timer = void 0;
+			}
+		};
+		this.defer(cancel);
+		const debounced = (...args) => {
+			if (this.signal.aborted) return;
+			cancel();
+			timer = setTimeout(() => {
+				timer = void 0;
+				fn(...args);
+			}, ms);
+			if (opts?.unref === true) timer.unref?.();
+		};
+		debounced.cancel = cancel;
+		return debounced;
+	}
+	/**
+	* Adopt an opaque {@link Handle} (from `defineHandle()`) into this scope's
+	* ownership registry. The handle is added to the inherited disposer stack
+	* (LIFO disposal) and tracked separately so {@link assertScopeBalance}
+	* can detect leaked handles per-scope without depending on global GC.
+	*
+	* See `./handle.ts` for the brand-+-registry pattern.
+	*/
+	adoptHandle(handle) {
+		adoptHandle(this, handle);
+	}
+	/**
+	* Adopt an `AsyncDisposable` for LIFO teardown.
+	*
+	* Branded handles (from `defineHandle()`) are routed through
+	* {@link adoptHandle} so per-scope accounting catches them.
+	* Non-branded `AsyncDisposable` values use the inherited stack directly.
+	*
+	* This closes the pro/Kimi-flagged "scope.use(handle) bypasses ownership"
+	* hole — a forged or hand-rolled `AsyncDisposable` claiming to be a
+	* branded handle still goes through the runtime authenticity gate in
+	* `adoptHandle`.
+	*/
+	use(value) {
+		if (value !== null && value !== void 0 && typeof value === "object" && isBrandedHandle(value)) {
+			adoptHandle(this, value);
+			return value;
+		}
+		return super.use(value);
+	}
+	/**
+	* Dispose children first, then the inherited user disposer stack.
+	* Collects errors across the tree and surfaces them as `SuppressedError`.
+	*
+	* When `SILVERY_SCOPE_TRACE=1`, prints a per-scope handle-delta to
+	* stderr if any adopted handles remained undisposed after the inherited
+	* stack ran (km-silvery.lifecycle-leak-detection Phase 2).
+	*/
+	async [Symbol.asyncDispose]() {
+		if (this.disposed) return;
+		const errors = [];
+		const preCount = getAdoptedHandles(this).length;
+		const children = [...this.#children].reverse();
+		this.#children.clear();
+		for (const c of children) try {
+			await c[Symbol.asyncDispose]();
+		} catch (e) {
+			errors.push(e);
+		}
+		try {
+			await super[Symbol.asyncDispose]();
+		} catch (e) {
+			errors.push(e);
+		}
+		const postCount = getAdoptedHandles(this).length;
+		reportScopeDelta(this.name, preCount, postCount);
+		if (this.#parent) this.#parent.#children.delete(this);
+		_trackDispose(this);
+		if (errors.length === 1) throw errors[0];
+		if (errors.length > 1) throw errors.reduce((suppressed, e) => new SuppressedError(e, suppressed, "multiple dispose errors"));
+	}
+	/**
+	* `AsyncDisposableStack.move()` returns a plain stack that loses Scope's
+	* `signal`, `name`, and child registry. Throw rather than silently
+	* corrupting invariants. Create a new scope and re-register resources
+	* explicitly if you need to relocate ownership.
+	*/
+	move() {
+		throw new TypeError("Scope.move() is not supported — create a new scope and re-register resources explicitly");
+	}
+};
+/** Create a root scope. Use `scope.child(name?)` for descendants. */
+function createScope(name) {
+	return new Scope(void 0, name);
+}
+const SINK_KEY = Symbol.for("@silvery/scope/disposeErrorSink");
+const defaultSink = (error, context) => {
+	const name = context.scope?.name ?? "?";
+	console.error(`[scope dispose error] phase=${context.phase} scope=${name}`, error);
+};
+const sinkHost = globalThis;
+if (!sinkHost[SINK_KEY]) sinkHost[SINK_KEY] = { sink: defaultSink };
+/**
+* Report a disposal failure from a fire-and-forget context (React unmount,
+* signal handler, app-exit hook). Best-effort; never throws.
+*/
+function reportDisposeError(error, context) {
+	try {
+		sinkHost[SINK_KEY].sink(error, context);
+	} catch {}
+}
+//#endregion
+//#region packages/ag-term/src/pipeline/collect-text.ts
+/**
+* Collect plain text from a node tree, applying internal_transform.
+*
+* This is the base traversal used by:
+* - measure-phase.ts (fit-content measurement)
+* - render-text.ts (DOM-level truncation budget)
+*
+* Does NOT filter hidden or display:none nodes — those are handled by
+* the layout engine (display:none gets 0x0 size) or by other phases.
+*/
+function collectPlainText(node) {
+	if (node.textContent !== void 0) return node.textContent;
+	let result = "";
+	for (let i = 0; i < node.children.length; i++) {
+		const child = node.children[i];
+		let childText = collectPlainText(child);
+		if (childText.length > 0 && child.props.internal_transform) childText = child.props.internal_transform(childText, i);
+		result += childText;
+	}
+	return result;
+}
+/**
+* Collect plain text from a node tree, skipping hidden children.
+*
+* Used by the reconciler's Yoga measure function where hidden nodes
+* (from Suspense) must not contribute to measured size.
+*
+* Identical to collectPlainText except for the hidden check.
+*/
+function collectPlainTextSkipHidden(node) {
+	if (node.textContent !== void 0) return node.textContent;
+	let result = "";
+	for (let i = 0; i < node.children.length; i++) {
+		const child = node.children[i];
+		if (child.hidden) continue;
+		let childText = collectPlainTextSkipHidden(child);
+		if (childText.length > 0 && child.props.internal_transform) childText = child.props.internal_transform(childText, i);
+		result += childText;
+	}
+	return result;
+}
+//#endregion
+//#region packages/ag-term/src/pipeline/measure-stats.ts
+/**
+* Profiling counters for measure function performance analysis (dev only).
+*
+* Shared between @silvery/ag-react/reconciler/nodes (where measure happens)
+* and @silvery/ag-term/pipeline/layout-phase (where stats are logged).
+*
+* Lives in @silvery/ag-term to keep the @silvery/ag-term barrel React-free.
+*/
+const measureStats = {
+	calls: 0,
+	cacheHits: 0,
+	textCollects: 0,
+	displayWidthCalls: 0,
+	reset() {
+		this.calls = 0;
+		this.cacheHits = 0;
+		this.textCollects = 0;
+		this.displayWidthCalls = 0;
+	}
+};
+//#endregion
+//#region packages/ag-react/src/reconciler/helpers.ts
+/**
+* Reconciler Helper Functions
+*
+* Utility functions for props comparison and change detection
+* used by the React reconciler during updates.
+*/
+/**
+* Set of layout-affecting props.
+*/
+const LAYOUT_PROPS = new Set([
+	"width",
+	"height",
+	"minWidth",
+	"minHeight",
+	"maxWidth",
+	"maxHeight",
+	"flexDirection",
+	"flexWrap",
+	"justifyContent",
+	"alignItems",
+	"alignContent",
+	"alignSelf",
+	"flexGrow",
+	"flexShrink",
+	"flexBasis",
+	"padding",
+	"paddingX",
+	"paddingY",
+	"paddingTop",
+	"paddingBottom",
+	"paddingLeft",
+	"paddingRight",
+	"margin",
+	"marginX",
+	"marginY",
+	"marginTop",
+	"marginBottom",
+	"marginLeft",
+	"marginRight",
+	"gap",
+	"columnGap",
+	"rowGap",
+	"borderStyle",
+	"borderTop",
+	"borderBottom",
+	"borderLeft",
+	"borderRight",
+	"display",
+	"position",
+	"top",
+	"left",
+	"bottom",
+	"right",
+	"aspectRatio",
+	"overflow",
+	"overflowX",
+	"overflowY",
+	"cols",
+	"rows"
+]);
+/**
+* Set of content props that affect layout dimensions (trigger contentDirty + Flexily markDirty()).
+* wrap changes text line count; internal_transform changes text width; truncate
+* is a per-line elision hook whose output changes the painted line, so a change
+* to it must force a content re-render (its identity is unstable across renders,
+* which is also why render-text.ts bypasses the format cache when it is present).
+*/
+const TEXT_CONTENT_PROPS = new Set([
+	"wrap",
+	"internal_transform",
+	"truncate"
+]);
+/**
+* Set of style props that affect content (paint) but NOT layout dimensions.
+* borderColor, color, bold, etc. don't change how much space a node takes.
+* borderStyle is also a layout prop (affects border widths), but it's included
+* here so stylePropsDirty is set — otherwise border add/remove doesn't trigger
+* renderBox to draw/clear border characters.
+*/
+const STYLE_PROPS = new Set([
+	"color",
+	"truncateMarkerColor",
+	"backgroundColor",
+	"bold",
+	"italic",
+	"underline",
+	"underlineStyle",
+	"underlineColor",
+	"overline",
+	"strikethrough",
+	"inverse",
+	"borderColor",
+	"borderBackgroundColor",
+	"borderTopBackgroundColor",
+	"borderBottomBackgroundColor",
+	"borderLeftBackgroundColor",
+	"borderRightBackgroundColor",
+	"borderStyle",
+	"outlineStyle",
+	"outlineColor",
+	"outlineDimColor",
+	"outlineTop",
+	"outlineBottom",
+	"outlineLeft",
+	"outlineRight",
+	"data-subtree-fade",
+	"userSelect",
+	"theme"
+]);
+/** Shared singleton for the no-changes fast path (identity check). */
+const NO_CHANGES = {
+	anyChanged: false,
+	layoutChanged: false,
+	contentChanged: false
+};
+/**
+* Classify all prop changes in a single pass over the union of old and new keys.
+*
+* Replaces the previous 3-pass approach (propsEqual + layoutPropsChanged +
+* contentPropsChanged) with one iteration. Includes an identity fast path
+* and early exit when both layout and content flags are fully determined.
+*/
+function classifyPropChanges(oldProps, newProps) {
+	if (oldProps === newProps) return NO_CHANGES;
+	const keysA = Object.keys(oldProps);
+	const keysB = Object.keys(newProps);
+	const sameKeyCount = keysA.length === keysB.length;
+	let layoutChanged = false;
+	let contentChanged = false;
+	let anyChanged = false;
+	for (const key of keysA) if (oldProps[key] !== newProps[key]) {
+		anyChanged = true;
+		if (LAYOUT_PROPS.has(key)) layoutChanged = true;
+		if (contentChanged !== "text") {
+			if (key === "children") {
+				const oldIsPrimitive = typeof oldProps[key] === "string" || typeof oldProps[key] === "number";
+				const newIsPrimitive = typeof newProps[key] === "string" || typeof newProps[key] === "number";
+				if (oldIsPrimitive || newIsPrimitive) contentChanged = "text";
+			} else if (TEXT_CONTENT_PROPS.has(key)) contentChanged = "text";
+			else if (contentChanged !== "style" && STYLE_PROPS.has(key)) contentChanged = "style";
+		}
+		if (layoutChanged && contentChanged === "text") break;
+	}
+	if (!sameKeyCount) {
+		for (const key of keysB) if (!(key in oldProps)) {
+			anyChanged = true;
+			if (LAYOUT_PROPS.has(key)) layoutChanged = true;
+			if (contentChanged !== "text") {
+				if (key === "children") {
+					if (typeof newProps[key] === "string" || typeof newProps[key] === "number") contentChanged = "text";
+				} else if (TEXT_CONTENT_PROPS.has(key)) contentChanged = "text";
+				else if (contentChanged !== "style" && STYLE_PROPS.has(key)) contentChanged = "style";
+			}
+			if (layoutChanged && contentChanged === "text") break;
+		}
+	}
+	if (!anyChanged && !sameKeyCount) anyChanged = true;
+	if (!anyChanged) return NO_CHANGES;
+	return {
+		anyChanged,
+		layoutChanged,
+		contentChanged
+	};
+}
+//#endregion
+//#region packages/ag-react/src/reconciler/nodes.ts
+/**
+* Node Creation and Layout Application
+*
+* Functions for creating SilveryNodes and applying layout properties.
+*/
+const measureLog = createLogger("silvery:measure");
+/**
+* Create a new SilveryNode with a fresh layout node.
+*/
+function createNode(type, props, measurer) {
+	const layoutNode = getLayoutEngine().createNode();
+	const epoch = getRenderEpoch();
+	const node = {
+		type,
+		props,
+		children: [],
+		parent: null,
+		layoutNode,
+		boxRect: null,
+		scrollRect: null,
+		screenRect: null,
+		prevLayout: null,
+		prevScrollRect: null,
+		prevScreenRect: null,
+		layoutChangedThisFrame: epoch,
+		dirtyBits: 31,
+		dirtyEpoch: epoch
+	};
+	if (type === "silvery-box") applyBoxProps(layoutNode, props);
+	else if (type === "silvery-text") applyTextFlexItemProps(layoutNode, props);
+	else if (type === "silvery-viewport") applyViewportProps(layoutNode, props);
+	else if (type === "silvery-island") applyIslandProps(layoutNode, props);
+	if (type === "silvery-text") {
+		let cachedText = null;
+		const measureCache = /* @__PURE__ */ new Map();
+		layoutNode.setMeasureFunc((width, widthMode, height, heightMode) => {
+			measureStats.calls++;
+			measureLog.debug?.(`measure "${collectPlainTextSkipHidden(node).slice(0, 40)}" width=${width} widthMode=${widthMode} height=${height} heightMode=${heightMode}`);
+			const cacheKey = `${width}|${widthMode}|${height}|${heightMode}`;
+			const cached = measureCache.get(cacheKey);
+			if (cached && cachedText !== null && !isDirty(node.dirtyBits, node.dirtyEpoch, 1)) {
+				measureStats.cacheHits++;
+				return cached;
+			}
+			let text;
+			if (cachedText !== null && !isDirty(node.dirtyBits, node.dirtyEpoch, 1)) text = cachedText;
+			else {
+				measureStats.textCollects++;
+				const newText = collectPlainTextSkipHidden(node);
+				if (newText !== cachedText) measureCache.clear();
+				text = newText;
+				cachedText = text;
+				node.dirtyBits &= -2;
+			}
+			if (!text) return {
+				width: 0,
+				height: 0
+			};
+			const cachedAfterCollect = measureCache.get(cacheKey);
+			if (cachedAfterCollect) {
+				measureStats.cacheHits++;
+				return cachedAfterCollect;
+			}
+			const lines = text.split("\n");
+			const isMinContentQuery = widthMode === "min-content";
+			const maxWidth = widthMode === "undefined" || Number.isNaN(width) ? Number.POSITIVE_INFINITY : isMinContentQuery ? 0 : width;
+			const { wrap } = node.props;
+			const isTruncate = wrap === "truncate" || wrap === "truncate-start" || wrap === "truncate-middle" || wrap === "truncate-end" || wrap === "clip" || wrap === false;
+			const isHardWrap = wrap === "hard";
+			const isWrapTruncate = wrap === "wrap-truncate";
+			const internalTransform = node.props.internal_transform;
+			let totalHeight = 0;
+			let actualWidth = 0;
+			const dw = measurer ? measurer.displayWidth.bind(measurer) : displayWidth;
+			const wt = measurer ? measurer.wrapText.bind(measurer) : wrapText;
+			const lh = getActiveLineHeight();
+			let renderedLineIndex = 0;
+			const widthFor = (line) => {
+				if (!internalTransform) return dw(line);
+				return dw(internalTransform(line, renderedLineIndex));
+			};
+			for (const line of lines) {
+				measureStats.displayWidthCalls++;
+				const lineWidth = dw(line);
+				if (isTruncate) {
+					totalHeight += lh;
+					if (isMinContentQuery) actualWidth = Math.max(actualWidth, lineWidth > 0 ? 1 : 0);
+					else actualWidth = Math.max(actualWidth, widthFor(line));
+					renderedLineIndex++;
+				} else if (isHardWrap) if (isMinContentQuery) {
+					totalHeight += lh;
+					actualWidth = Math.max(actualWidth, lineWidth > 0 ? 1 : 0);
+					renderedLineIndex++;
+				} else if (lineWidth <= maxWidth) {
+					totalHeight += lh;
+					actualWidth = Math.max(actualWidth, widthFor(line));
+					renderedLineIndex++;
+				} else if (Number.isFinite(maxWidth) && maxWidth > 0) {
+					const wrappedCount = Math.ceil(lineWidth / maxWidth);
+					totalHeight += wrappedCount * lh;
+					actualWidth = Math.max(actualWidth, maxWidth);
+					renderedLineIndex += wrappedCount;
+				} else {
+					totalHeight += lh;
+					actualWidth = Math.max(actualWidth, widthFor(line));
+					renderedLineIndex++;
+				}
+				else if (isMinContentQuery) {
+					let longestSegment = 0;
+					let segmentWidth = 0;
+					for (let pos = 0; pos < line.length; pos++) {
+						const ch = line[pos];
+						if (ch === " " || ch === "	" || ch === "-") {
+							if (segmentWidth > longestSegment) longestSegment = segmentWidth;
+							segmentWidth = 0;
+							continue;
+						}
+						segmentWidth += dw(ch);
+						if (isSoftBreakPoint(ch)) {
+							if (segmentWidth > longestSegment) longestSegment = segmentWidth;
+							segmentWidth = 0;
+						}
+					}
+					if (segmentWidth > longestSegment) longestSegment = segmentWidth;
+					totalHeight += lh;
+					actualWidth = Math.max(actualWidth, longestSegment);
+					renderedLineIndex++;
+				} else if (lineWidth <= maxWidth) {
+					totalHeight += lh;
+					actualWidth = Math.max(actualWidth, widthFor(line));
+					renderedLineIndex++;
+				} else {
+					const wrapped = wt(line, maxWidth, false, true, isWrapTruncate);
+					totalHeight += wrapped.length * lh;
+					for (const wl of wrapped) {
+						actualWidth = Math.max(actualWidth, widthFor(wl));
+						renderedLineIndex++;
+					}
+				}
+			}
+			let resultHeight = Math.max(lh, totalHeight);
+			if (heightMode === "exactly" && Number.isFinite(height)) resultHeight = height;
+			else if (heightMode === "at-most" && Number.isFinite(height)) resultHeight = Math.min(resultHeight, height);
+			const result = {
+				width: isMinContentQuery ? actualWidth : isTruncate && true ? actualWidth : Math.min(actualWidth, maxWidth),
+				height: resultHeight
+			};
+			measureCache.set(cacheKey, result);
+			return result;
+		});
+	}
+	return node;
+}
+/**
+* Create the root node for the Silvery tree.
+* Root is always column (document flow is top-to-bottom), regardless of
+* flexily's default flexDirection.
+*/
+function createRootNode() {
+	const node = createNode("silvery-root", {});
+	const c = getConstants();
+	node.layoutNode.setFlexDirection(c.FLEX_DIRECTION_COLUMN);
+	return node;
+}
+/**
+* Create a virtual text node (for nested text elements).
+* Virtual text nodes don't have layout nodes and don't participate in layout.
+* They're used when Text is nested inside another Text.
+*/
+function createVirtualTextNode(props) {
+	return {
+		type: "silvery-text",
+		props,
+		children: [],
+		parent: null,
+		layoutNode: null,
+		boxRect: null,
+		scrollRect: null,
+		screenRect: null,
+		prevLayout: null,
+		prevScrollRect: null,
+		prevScreenRect: null,
+		layoutChangedThisFrame: -1,
+		dirtyBits: 23,
+		dirtyEpoch: getRenderEpoch(),
+		isRawText: false,
+		inlineRects: null
+	};
+}
+/**
+* Apply ViewportProps to a viewport node's layout node.
+*
+* A `<Viewport>` is a leaf with fixed `cols`×`rows` — no flex children, no
+* measure function. We pin width/height from the props so the parent layout
+* positions the viewport rect deterministically; if the parent rect is
+* narrower, flexbox + parent overflow="hidden" clips at paint time.
+*
+* See bead `@km/silvery/15513-surface-nested-composition-primitive`.
+*/
+function applyViewportProps(layoutNode, props, oldProps) {
+	if (props.cols !== void 0) layoutNode.setWidth(props.cols);
+	else if (oldProps?.cols !== void 0) layoutNode.setWidthAuto();
+	if (props.rows !== void 0) layoutNode.setHeight(props.rows);
+	else if (oldProps?.rows !== void 0) layoutNode.setHeightAuto();
+}
+/**
+* Apply IslandProps to an island node's layout node.
+*
+* `<Island>` is a leaf — guest content lives off the AgNode's `islandState`
+* slot, blitted by the render phase at boxRect. Layout-dim resolution:
+* explicit `width` / `height` wins; otherwise fall back to `cols` / `rows`.
+*
+* See bead `@km/silvery/15646-islands` for the two-phase resize protocol
+* (guest acks via `IslandSizeOwner` after host writes new dims).
+*/
+function applyIslandProps(layoutNode, props, oldProps) {
+	const c = getConstants();
+	const wasRemoved = (prop) => oldProps?.[prop] !== void 0 && props[prop] === void 0;
+	if (props.width !== void 0) {
+		if (typeof props.width === "string" && props.width.endsWith("%")) layoutNode.setWidthPercent(Number.parseFloat(props.width));
+		else if (typeof props.width === "number") layoutNode.setWidth(props.width);
+	} else if (props.cols !== void 0) layoutNode.setWidth(props.cols);
+	else if (wasRemoved("width") || wasRemoved("cols")) layoutNode.setWidthAuto();
+	if (props.height !== void 0) {
+		if (typeof props.height === "string" && props.height.endsWith("%")) layoutNode.setHeightPercent(Number.parseFloat(props.height));
+		else if (typeof props.height === "number") layoutNode.setHeight(props.height);
+	} else if (props.rows !== void 0) layoutNode.setHeight(props.rows);
+	else if (wasRemoved("height") || wasRemoved("rows")) layoutNode.setHeightAuto();
+	if (props.flexGrow !== void 0) layoutNode.setFlexGrow(props.flexGrow);
+	else if (wasRemoved("flexGrow")) layoutNode.setFlexGrow(0);
+	if (props.flexShrink !== void 0) layoutNode.setFlexShrink(props.flexShrink);
+	else if (wasRemoved("flexShrink")) layoutNode.setFlexShrink(1);
+	if (props.flexBasis !== void 0) {
+		if (typeof props.flexBasis === "string" && props.flexBasis.endsWith("%")) layoutNode.setFlexBasisPercent(Number.parseFloat(props.flexBasis));
+		else if (props.flexBasis === "auto") layoutNode.setFlexBasisAuto();
+		else if (typeof props.flexBasis === "number") layoutNode.setFlexBasis(props.flexBasis);
+	} else if (wasRemoved("flexBasis")) layoutNode.setFlexBasisAuto();
+	if (props.alignSelf !== void 0) if (props.alignSelf === "auto") layoutNode.setAlignSelf(c.ALIGN_AUTO);
+	else layoutNode.setAlignSelf(alignToConstant(props.alignSelf));
+	else if (wasRemoved("alignSelf")) layoutNode.setAlignSelf(c.ALIGN_AUTO);
+	if (props.minWidth !== void 0) {
+		if (typeof props.minWidth === "string" && props.minWidth.endsWith("%")) layoutNode.setMinWidthPercent(Number.parseFloat(props.minWidth));
+		else if (typeof props.minWidth === "number") layoutNode.setMinWidth(props.minWidth);
+	} else if (wasRemoved("minWidth")) layoutNode.setMinWidth(0);
+	if (props.minHeight !== void 0) {
+		if (typeof props.minHeight === "string" && props.minHeight.endsWith("%")) layoutNode.setMinHeightPercent(Number.parseFloat(props.minHeight));
+		else if (typeof props.minHeight === "number") layoutNode.setMinHeight(props.minHeight);
+	} else if (wasRemoved("minHeight")) layoutNode.setMinHeight(0);
+	if (props.maxWidth !== void 0) {
+		if (typeof props.maxWidth === "string" && props.maxWidth.endsWith("%")) layoutNode.setMaxWidthPercent(Number.parseFloat(props.maxWidth));
+		else if (typeof props.maxWidth === "number") layoutNode.setMaxWidth(props.maxWidth);
+	} else if (wasRemoved("maxWidth")) layoutNode.setMaxWidth(Number.POSITIVE_INFINITY);
+	if (props.maxHeight !== void 0) {
+		if (typeof props.maxHeight === "string" && props.maxHeight.endsWith("%")) layoutNode.setMaxHeightPercent(Number.parseFloat(props.maxHeight));
+		else if (typeof props.maxHeight === "number") layoutNode.setMaxHeight(props.maxHeight);
+	} else if (wasRemoved("maxHeight")) layoutNode.setMaxHeight(Number.POSITIVE_INFINITY);
+}
+/**
+* Apply TextFlexItemProps to a Text node's layout node.
+*
+* Text is a leaf flex item — it accepts the subset of FlexboxProps that
+* affect how it participates as a flex item (sizing, growth, shrink),
+* not the props that affect how it lays out children. This is the
+* canonical CSS escape hatch: use `flexShrink={0}` to keep a Text rigid,
+* or `minWidth={0}` to let it shrink fully under a tight parent.
+*
+* See `TextFlexItemProps` in @silvery/ag/types.
+*/
+function applyTextFlexItemProps(layoutNode, props, oldProps) {
+	const c = getConstants();
+	const wasRemoved = (prop) => oldProps?.[prop] !== void 0 && props[prop] === void 0;
+	if (props.flexGrow !== void 0) layoutNode.setFlexGrow(props.flexGrow);
+	else if (wasRemoved("flexGrow")) layoutNode.setFlexGrow(0);
+	if (props.flexShrink !== void 0) layoutNode.setFlexShrink(props.flexShrink);
+	else if (wasRemoved("flexShrink")) layoutNode.setFlexShrink(1);
+	if (props.flexBasis !== void 0) {
+		if (typeof props.flexBasis === "string" && props.flexBasis.endsWith("%")) layoutNode.setFlexBasisPercent(Number.parseFloat(props.flexBasis));
+		else if (props.flexBasis === "auto") layoutNode.setFlexBasisAuto();
+		else if (typeof props.flexBasis === "number") layoutNode.setFlexBasis(props.flexBasis);
+	} else if (wasRemoved("flexBasis")) layoutNode.setFlexBasisAuto();
+	if (props.alignSelf !== void 0) if (props.alignSelf === "auto") layoutNode.setAlignSelf(c.ALIGN_AUTO);
+	else layoutNode.setAlignSelf(alignToConstant(props.alignSelf));
+	else if (wasRemoved("alignSelf")) layoutNode.setAlignSelf(c.ALIGN_AUTO);
+	if (props.minWidth !== void 0) {
+		if (typeof props.minWidth === "string" && props.minWidth.endsWith("%")) layoutNode.setMinWidthPercent(Number.parseFloat(props.minWidth));
+		else if (typeof props.minWidth === "number") layoutNode.setMinWidth(props.minWidth);
+	} else if (wasRemoved("minWidth")) layoutNode.setMinWidth(0);
+	if (props.minHeight !== void 0) {
+		if (typeof props.minHeight === "string" && props.minHeight.endsWith("%")) layoutNode.setMinHeightPercent(Number.parseFloat(props.minHeight));
+		else if (typeof props.minHeight === "number") layoutNode.setMinHeight(props.minHeight);
+	} else if (wasRemoved("minHeight")) layoutNode.setMinHeight(0);
+	if (props.maxWidth !== void 0) {
+		if (typeof props.maxWidth === "string" && props.maxWidth.endsWith("%")) layoutNode.setMaxWidthPercent(Number.parseFloat(props.maxWidth));
+		else if (typeof props.maxWidth === "number") layoutNode.setMaxWidth(props.maxWidth);
+	} else if (wasRemoved("maxWidth")) layoutNode.setMaxWidth(Number.POSITIVE_INFINITY);
+	if (props.maxHeight !== void 0) {
+		if (typeof props.maxHeight === "string" && props.maxHeight.endsWith("%")) layoutNode.setMaxHeightPercent(Number.parseFloat(props.maxHeight));
+		else if (typeof props.maxHeight === "number") layoutNode.setMaxHeight(props.maxHeight);
+	} else if (wasRemoved("maxHeight")) layoutNode.setMaxHeight(Number.POSITIVE_INFINITY);
+}
+/**
+* Parse a `fitWidth` entry from user-facing form (number | string) to the
+* engine's FitWidthLane shape (number | { value, unit: "cqi" | "cqmin" }).
+*
+* Accepted strings: `"100cqi"`, `"50cqmin"` — decimal and integer values both
+* fine. Numbers pass through unchanged. Invalid strings throw with a clear
+* pointer to the bug — the layout engine consumes only the parsed form, so
+* parse-fail at the React seam is the right place.
+*/
+function parseFitWidthEntry(entry) {
+	if (typeof entry === "number") return entry;
+	const cqiMatch = entry.match(/^(\d+(?:\.\d+)?)cqi$/);
+	if (cqiMatch) return {
+		value: Number.parseFloat(cqiMatch[1]),
+		unit: "cqi"
+	};
+	const cqminMatch = entry.match(/^(\d+(?:\.\d+)?)cqmin$/);
+	if (cqminMatch) return {
+		value: Number.parseFloat(cqminMatch[1]),
+		unit: "cqmin"
+	};
+	throw new Error(`<Box fitWidth>: invalid lane entry ${JSON.stringify(entry)}. Expected a number (cells) or a string like "100cqi" / "50cqmin".`);
+}
+/**
+* Apply BoxProps to a layout node.
+* This maps Ink/Silvery props to the layout engine API.
+*/
+function applyBoxProps(layoutNode, props, oldProps) {
+	const c = getConstants();
+	const wasRemoved = (prop) => oldProps?.[prop] !== void 0 && props[prop] === void 0;
+	if (props.width !== void 0) {
+		if (typeof props.width === "string" && props.width.endsWith("%")) layoutNode.setWidthPercent(Number.parseFloat(props.width));
+		else if (typeof props.width === "number") layoutNode.setWidth(props.width);
+		else if (props.width === "auto") layoutNode.setWidthAuto();
+		else if (props.width === "fit-content") layoutNode.setWidthFitContent();
+		else if (props.width === "snug-content") layoutNode.setWidthSnugContent();
+	} else if (wasRemoved("width")) layoutNode.setWidthAuto();
+	if (props.height !== void 0) {
+		if (typeof props.height === "string" && props.height.endsWith("%")) layoutNode.setHeightPercent(Number.parseFloat(props.height));
+		else if (typeof props.height === "number") layoutNode.setHeight(props.height);
+		else if (props.height === "auto") layoutNode.setHeightAuto();
+	} else if (wasRemoved("height")) layoutNode.setHeightAuto();
+	if (props.minWidth !== void 0) {
+		if (typeof props.minWidth === "string" && props.minWidth.endsWith("%")) layoutNode.setMinWidthPercent(Number.parseFloat(props.minWidth));
+		else if (typeof props.minWidth === "number") layoutNode.setMinWidth(props.minWidth);
+	} else if (wasRemoved("minWidth")) layoutNode.setMinWidth(0);
+	if (props.minHeight !== void 0) {
+		if (typeof props.minHeight === "string" && props.minHeight.endsWith("%")) layoutNode.setMinHeightPercent(Number.parseFloat(props.minHeight));
+		else if (typeof props.minHeight === "number") layoutNode.setMinHeight(props.minHeight);
+	} else if (wasRemoved("minHeight")) layoutNode.setMinHeight(0);
+	if (props.maxWidth !== void 0) {
+		if (typeof props.maxWidth === "string" && props.maxWidth.endsWith("%")) layoutNode.setMaxWidthPercent(Number.parseFloat(props.maxWidth));
+		else if (typeof props.maxWidth === "number") layoutNode.setMaxWidth(props.maxWidth);
+	} else if (wasRemoved("maxWidth")) layoutNode.setMaxWidth(Number.POSITIVE_INFINITY);
+	if (props.maxHeight !== void 0) {
+		if (typeof props.maxHeight === "string" && props.maxHeight.endsWith("%")) layoutNode.setMaxHeightPercent(Number.parseFloat(props.maxHeight));
+		else if (typeof props.maxHeight === "number") layoutNode.setMaxHeight(props.maxHeight);
+	} else if (wasRemoved("maxHeight")) layoutNode.setMaxHeight(Number.POSITIVE_INFINITY);
+	if (props.flexGrow !== void 0) layoutNode.setFlexGrow(props.flexGrow);
+	else if (wasRemoved("flexGrow")) layoutNode.setFlexGrow(0);
+	if (props.flexShrink !== void 0) layoutNode.setFlexShrink(props.flexShrink);
+	else if (wasRemoved("flexShrink")) layoutNode.setFlexShrink(1);
+	if (props.flexBasis !== void 0) {
+		if (typeof props.flexBasis === "string" && props.flexBasis.endsWith("%")) layoutNode.setFlexBasisPercent(Number.parseFloat(props.flexBasis));
+		else if (props.flexBasis === "auto") layoutNode.setFlexBasisAuto();
+		else if (typeof props.flexBasis === "number") layoutNode.setFlexBasis(props.flexBasis);
+	} else if (wasRemoved("flexBasis")) layoutNode.setFlexBasisAuto();
+	if (props.flexDirection !== void 0) {
+		const directionMap = {
+			row: c.FLEX_DIRECTION_ROW,
+			column: c.FLEX_DIRECTION_COLUMN,
+			"row-reverse": c.FLEX_DIRECTION_ROW_REVERSE,
+			"column-reverse": c.FLEX_DIRECTION_COLUMN_REVERSE
+		};
+		layoutNode.setFlexDirection(directionMap[props.flexDirection] ?? c.FLEX_DIRECTION_ROW);
+	} else if (wasRemoved("flexDirection")) layoutNode.setFlexDirection(c.FLEX_DIRECTION_ROW);
+	if (props.flexWrap !== void 0) {
+		const wrapMap = {
+			nowrap: c.WRAP_NO_WRAP,
+			wrap: c.WRAP_WRAP,
+			"wrap-reverse": c.WRAP_WRAP_REVERSE
+		};
+		layoutNode.setFlexWrap(wrapMap[props.flexWrap] ?? c.WRAP_NO_WRAP);
+	} else if (wasRemoved("flexWrap")) layoutNode.setFlexWrap(c.WRAP_NO_WRAP);
+	if (props.alignItems !== void 0) layoutNode.setAlignItems(alignToConstant(props.alignItems));
+	else if (wasRemoved("alignItems")) layoutNode.setAlignItems(c.ALIGN_STRETCH);
+	if (props.alignSelf !== void 0) if (props.alignSelf === "auto") layoutNode.setAlignSelf(c.ALIGN_AUTO);
+	else layoutNode.setAlignSelf(alignToConstant(props.alignSelf));
+	else if (wasRemoved("alignSelf")) layoutNode.setAlignSelf(c.ALIGN_AUTO);
+	if (props.alignContent !== void 0) layoutNode.setAlignContent(alignToConstant(props.alignContent));
+	else if (wasRemoved("alignContent")) layoutNode.setAlignContent(c.ALIGN_FLEX_START);
+	if (props.justifyContent !== void 0) layoutNode.setJustifyContent(justifyToConstant(props.justifyContent));
+	else if (wasRemoved("justifyContent")) layoutNode.setJustifyContent(c.JUSTIFY_FLEX_START);
+	applySpacing(layoutNode, "padding", props);
+	applySpacing(layoutNode, "margin", props);
+	if (props.gap !== void 0) layoutNode.setGap(c.GUTTER_ALL, props.gap);
+	else if (wasRemoved("gap")) layoutNode.setGap(c.GUTTER_ALL, 0);
+	if (props.columnGap !== void 0) layoutNode.setGap(c.GUTTER_COLUMN, props.columnGap);
+	else if (wasRemoved("columnGap")) layoutNode.setGap(c.GUTTER_COLUMN, 0);
+	if (props.rowGap !== void 0) layoutNode.setGap(c.GUTTER_ROW, props.rowGap);
+	else if (wasRemoved("rowGap")) layoutNode.setGap(c.GUTTER_ROW, 0);
+	if (props.display !== void 0) layoutNode.setDisplay(props.display === "none" ? c.DISPLAY_NONE : c.DISPLAY_FLEX);
+	else if (wasRemoved("display")) layoutNode.setDisplay(c.DISPLAY_FLEX);
+	if (props.position !== void 0) if (props.position === "absolute") layoutNode.setPositionType(c.POSITION_TYPE_ABSOLUTE);
+	else if (props.position === "static") layoutNode.setPositionType(c.POSITION_TYPE_STATIC);
+	else layoutNode.setPositionType(c.POSITION_TYPE_RELATIVE);
+	else if (wasRemoved("position")) layoutNode.setPositionType(c.POSITION_TYPE_RELATIVE);
+	if (props.position !== "static") {
+		applyPositionOffset(layoutNode, c.EDGE_TOP, props.top);
+		applyPositionOffset(layoutNode, c.EDGE_LEFT, props.left);
+		applyPositionOffset(layoutNode, c.EDGE_BOTTOM, props.bottom);
+		applyPositionOffset(layoutNode, c.EDGE_RIGHT, props.right);
+	}
+	if (props.aspectRatio !== void 0) layoutNode.setAspectRatio(props.aspectRatio);
+	else if (wasRemoved("aspectRatio")) layoutNode.setAspectRatio(NaN);
+	const effectiveOverflow = props.overflow ?? (props.overflowX === "hidden" || props.overflowY === "hidden" ? "hidden" : void 0);
+	if (effectiveOverflow !== void 0) if (effectiveOverflow === "hidden") layoutNode.setOverflow(c.OVERFLOW_HIDDEN);
+	else if (effectiveOverflow === "scroll") layoutNode.setOverflow(c.OVERFLOW_HIDDEN);
+	else layoutNode.setOverflow(c.OVERFLOW_VISIBLE);
+	else if (wasRemoved("overflow") || wasRemoved("overflowX") || wasRemoved("overflowY")) layoutNode.setOverflow(c.OVERFLOW_VISIBLE);
+	if (props.containerType !== void 0) {
+		requireCapability("containerQueries", "<Box containerType>");
+		layoutNode.setContainerType(props.containerType === "inline-size" ? 1 : 0);
+	} else if (wasRemoved("containerType")) layoutNode.setContainerType(0);
+	if (props.containSize !== void 0) {
+		requireCapability("containSize", "<Box containSize>");
+		layoutNode.setContainSize(props.containSize);
+	} else if (wasRemoved("containSize")) layoutNode.setContainSize(false);
+	if (props.containerQueries !== void 0) requireCapability("containerQueries", "<Box containerQueries>");
+	if (props.fitWidth !== void 0) {
+		requireCapability("fitWidth", "<Box fitWidth>");
+		layoutNode.setFitWidth(props.fitWidth.map(parseFitWidthEntry));
+	} else if (wasRemoved("fitWidth")) layoutNode.setFitWidth(void 0);
+	if (props.borderStyle) {
+		const borderWidth = getActiveLineHeight() > 1 ? 0 : 1;
+		if (props.borderTop !== false) layoutNode.setBorder(c.EDGE_TOP, borderWidth);
+		else layoutNode.setBorder(c.EDGE_TOP, 0);
+		if (props.borderBottom !== false) layoutNode.setBorder(c.EDGE_BOTTOM, borderWidth);
+		else layoutNode.setBorder(c.EDGE_BOTTOM, 0);
+		if (props.borderLeft !== false) layoutNode.setBorder(c.EDGE_LEFT, borderWidth);
+		else layoutNode.setBorder(c.EDGE_LEFT, 0);
+		if (props.borderRight !== false) layoutNode.setBorder(c.EDGE_RIGHT, borderWidth);
+		else layoutNode.setBorder(c.EDGE_RIGHT, 0);
+	} else {
+		layoutNode.setBorder(c.EDGE_TOP, 0);
+		layoutNode.setBorder(c.EDGE_BOTTOM, 0);
+		layoutNode.setBorder(c.EDGE_LEFT, 0);
+		layoutNode.setBorder(c.EDGE_RIGHT, 0);
+	}
+}
+/**
+* Apply padding or margin to a layout node.
+*/
+function applySpacing(layoutNode, type, props) {
+	const c = getConstants();
+	const set = type === "padding" ? layoutNode.setPadding.bind(layoutNode) : layoutNode.setMargin.bind(layoutNode);
+	const all = props[type];
+	const x = props[`${type}X`];
+	const yy = props[`${type}Y`];
+	const top = props[`${type}Top`];
+	const bottom = props[`${type}Bottom`];
+	const left = props[`${type}Left`];
+	const right = props[`${type}Right`];
+	set(c.EDGE_TOP, top ?? yy ?? all ?? 0);
+	set(c.EDGE_BOTTOM, bottom ?? yy ?? all ?? 0);
+	set(c.EDGE_LEFT, left ?? x ?? all ?? 0);
+	set(c.EDGE_RIGHT, right ?? x ?? all ?? 0);
+}
+/**
+* Apply a position offset (top/left/bottom/right) to a layout node.
+* Supports both numeric (absolute) and percentage string values.
+*/
+function applyPositionOffset(layoutNode, edge, value) {
+	if (value === void 0) {
+		layoutNode.setPosition(edge, NaN);
+		return;
+	}
+	if (typeof value === "string" && value.endsWith("%")) layoutNode.setPositionPercent(edge, Number.parseFloat(value));
+	else if (typeof value === "number") layoutNode.setPosition(edge, value);
+}
+/**
+* Convert align value to layout constant.
+*/
+function alignToConstant(align) {
+	const c = getConstants();
+	return {
+		"flex-start": c.ALIGN_FLEX_START,
+		"flex-end": c.ALIGN_FLEX_END,
+		center: c.ALIGN_CENTER,
+		stretch: c.ALIGN_STRETCH,
+		baseline: c.ALIGN_BASELINE,
+		"space-between": c.ALIGN_SPACE_BETWEEN,
+		"space-around": c.ALIGN_SPACE_AROUND,
+		"space-evenly": c.ALIGN_SPACE_EVENLY
+	}[align] ?? c.ALIGN_STRETCH;
+}
+/**
+* Convert justify value to layout constant.
+*/
+function justifyToConstant(justify) {
+	const c = getConstants();
+	return {
+		"flex-start": c.JUSTIFY_FLEX_START,
+		"flex-end": c.JUSTIFY_FLEX_END,
+		center: c.JUSTIFY_CENTER,
+		"space-between": c.JUSTIFY_SPACE_BETWEEN,
+		"space-around": c.JUSTIFY_SPACE_AROUND,
+		"space-evenly": c.JUSTIFY_SPACE_EVENLY
+	}[justify] ?? c.JUSTIFY_FLEX_START;
+}
+//#endregion
+//#region packages/ag-react/src/reconciler/host-config.ts
+/**
+* React Reconciler Host Config
+*
+* Defines how React creates, updates, and manages SilveryNodes.
+* This is the bridge between React's reconciliation algorithm
+* and our custom terminal node tree.
+*/
+const log = createLogger("silvery:reconciler");
+const mountLog = createLogger("silvery:mount");
+const DEBUG_PROP_NAMES = [
+	"id",
+	"testID",
+	"data-component",
+	"display",
+	"position",
+	"flexDirection",
+	"width",
+	"height",
+	"minWidth",
+	"minHeight",
+	"flexGrow",
+	"flexShrink",
+	"overflow",
+	"overflowX",
+	"overflowY",
+	"overflowIndicator",
+	"scrollTo",
+	"scrollOffset",
+	"scrollbar",
+	"scrollbarVisibility",
+	"follow",
+	"onWheel",
+	"onClick",
+	"onMouseDown",
+	"onMouseUp",
+	"onMouseMove"
+];
+function hostTypeLabel(type) {
+	if (type === "silvery-box") return "Box";
+	if (type === "silvery-text") return "Text";
+	if (type === "silvery-viewport") return "Viewport";
+	if (type === "silvery-island") return "Island";
+	return type;
+}
+function getDebugComponentName(node) {
+	const props = node.props;
+	const explicitName = props["data-component"];
+	if (typeof explicitName === "string" && explicitName.length > 0) return explicitName;
+	const base = hostTypeLabel(node.type);
+	const testID = props.testID;
+	if (typeof testID === "string" && testID.length > 0) return `${base}#${testID}`;
+	const id = props.id;
+	if (typeof id === "string" && id.length > 0) return `${base}#${id}`;
+	return base;
+}
+function summarizeDebugProp(value) {
+	if (typeof value === "function") return true;
+	if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value;
+}
+function summarizeDebugProps(props) {
+	const summary = {};
+	for (const key of DEBUG_PROP_NAMES) {
+		const value = summarizeDebugProp(props[key]);
+		if (value !== void 0) summary[key] = value;
+	}
+	for (const key of Object.keys(props)) {
+		if (!key.startsWith("data-") || key === "data-component") continue;
+		const value = summarizeDebugProp(props[key]);
+		if (value !== void 0) summary[key] = value;
+	}
+	return summary;
+}
+function logNodeLifecycle(event, node) {
+	const props = node.props;
+	const component = getDebugComponentName(node);
+	const text = node.textContent;
+	mountLog.debug?.(`${event} ${component}`, {
+		event,
+		component,
+		type: node.type,
+		props: summarizeDebugProps(props),
+		propKeys: Object.keys(props).filter((key) => key !== "children").sort(),
+		...text ? { text: text.length > 80 ? `${text.slice(0, 77)}...` : text } : {}
+	});
+}
+function logUnmountSubtree(node) {
+	logNodeLifecycle("unmount", node);
+	for (const child of node.children) logUnmountSubtree(child);
+}
+/**
+* Normalize Ink intrinsic element types to Silvery equivalents.
+* Ink uses `ink-box` / `ink-text` as intrinsic element names;
+* Silvery uses `silvery-box` / `silvery-text`.
+*/
+function normalizeNodeType(type) {
+	if (type === "ink-box") return "silvery-box";
+	if (type === "ink-text") return "silvery-text";
+	return type;
+}
+const NODE_CONTAINERS_KEY = Symbol.for("@silvery/ag-react/reconciler/nodeContainers");
+const nodeContainers = globalThis[NODE_CONTAINERS_KEY] ?? (globalThis[NODE_CONTAINERS_KEY] = /* @__PURE__ */ new WeakMap());
+function bindSubtreeToContainer(node, container) {
+	nodeContainers.set(node, container);
+	for (const child of node.children) bindSubtreeToContainer(child, container);
+}
+function unbindSubtreeFromContainer(node) {
+	nodeContainers.delete(node);
+	for (const child of node.children) unbindSubtreeFromContainer(child);
+}
+function getOwningContainer(node) {
+	let current = node;
+	while (current) {
+		const container = nodeContainers.get(current);
+		if (container) return container;
+		current = current.parent;
+	}
+}
+function registerContainer(container) {
+	bindSubtreeToContainer(container.root, container);
+}
+function releaseContainerLifecycle(container) {
+	container.nodeLifecycle = null;
+	unbindSubtreeFromContainer(container.root);
+}
+function setContainerNodeLifecycle(container, observer) {
+	container.nodeLifecycle = observer;
+}
+function notifyNodeRemoved(container, removedNode) {
+	container?.nodeLifecycle?.onNodeRemoved?.(removedNode);
+}
+function notifyNodeUpdated(updatedNode) {
+	getOwningContainer(updatedNode)?.nodeLifecycle?.onNodeUpdated?.(updatedNode);
+}
+function notifySubtreeAttached(container, attachedRoot) {
+	container?.nodeLifecycle?.onSubtreeAttached?.(attachedRoot);
+}
+const NODE_SCOPES_KEY = Symbol.for("@silvery/ag-react/reconciler/nodeScopes");
+const nodeScopes = globalThis[NODE_SCOPES_KEY] ?? (globalThis[NODE_SCOPES_KEY] = /* @__PURE__ */ new WeakMap());
+/**
+* Dispose any scope attached to `node` and to every descendant. Called
+* from the reconciler's unmount paths. Fire-and-forget per the design
+* contract: react commit is synchronous, scope dispose is async, so we
+* kick off the promise and route rejections through `reportDisposeError`.
+*
+* Walks the subtree synchronously so all slots are detached *before* any
+* dispose promise resolves — this prevents a re-entrant render from
+* observing a partially torn-down tree with live scope slots.
+*/
+function disposeSubtreeScopes(node) {
+	const scope = nodeScopes.get(node);
+	if (scope) {
+		nodeScopes.delete(node);
+		scope[Symbol.asyncDispose]().catch((error) => reportDisposeError(error, {
+			phase: "react-unmount",
+			scope
+		}));
+	}
+	for (const child of node.children) disposeSubtreeScopes(child);
+}
+/**
+* Mark this node and all ancestors as having dirty content/layout.
+* Used to enable fast-path subtree skipping in renderPhase.
+*/
+function markSubtreeDirty(node) {
+	const epoch = getRenderEpoch();
+	while (node && !isDirty(node.dirtyBits, node.dirtyEpoch, 16)) {
+		if (node.dirtyEpoch !== epoch) {
+			node.dirtyBits = 16;
+			node.dirtyEpoch = epoch;
+		} else node.dirtyBits |= 16;
+		node = node.parent;
+	}
+}
+/**
+* When a child change (append/remove/insert/text-update) occurs inside a
+* virtual text subtree (no layoutNode), the nearest layout ancestor must be
+* notified so its measure function re-collects descendant text and the layout
+* engine recalculates dimensions. Without this, the measure cache stays stale
+* and renderPhase renders at the wrong size / doesn't clear old content.
+*
+* No-op when the node already has a layoutNode (normal path handles it).
+*/
+function markLayoutAncestorDirty(node) {
+	if (node.layoutNode) return;
+	let ancestor = node.parent;
+	while (ancestor && !ancestor.layoutNode) ancestor = ancestor.parent;
+	if (ancestor?.layoutNode) {
+		const epoch = getRenderEpoch();
+		if (ancestor.dirtyEpoch !== epoch) {
+			ancestor.dirtyBits = 3;
+			ancestor.dirtyEpoch = epoch;
+		} else ancestor.dirtyBits |= 3;
+		ancestor.layoutNode.markDirty();
+		trackContentDirty(ancestor);
+	}
+}
+const BOX_INSIDE_TEXT_WARNING_ID = "silvery/ag-react:box-in-text";
+let currentUpdatePriority = NoEventPriority;
+/**
+* Run a callback with DiscreteEventPriority so React treats state
+* updates inside it as user-interaction priority (synchronous commit).
+* Use this for keyboard input handling to prevent React's concurrent
+* scheduler from deferring the commit.
+*/
+function runWithDiscreteEvent(fn) {
+	const prev = currentUpdatePriority;
+	currentUpdatePriority = DiscreteEventPriority;
+	try {
+		fn();
+	} finally {
+		currentUpdatePriority = prev;
+	}
+}
+/**
+* The React Reconciler host config.
+* This defines how React creates, updates, and manages our custom SilveryNodes.
+*/
+const hostConfig = {
+	rendererPackageName: "@silvery/ag-react",
+	rendererVersion: "0.0.1",
+	supportsMutation: true,
+	supportsPersistence: false,
+	supportsHydration: false,
+	isPrimaryRenderer: true,
+	scheduleTimeout: setTimeout,
+	cancelTimeout: clearTimeout,
+	noTimeout: -1,
+	supportsMicrotasks: true,
+	scheduleMicrotask: queueMicrotask,
+	getRootHostContext() {
+		return { isInsideText: false };
+	},
+	getChildHostContext(parentHostContext, type) {
+		const normalizedType = normalizeNodeType(type);
+		const isInsideText = parentHostContext.isInsideText || normalizedType === "silvery-text";
+		if (isInsideText === parentHostContext.isInsideText) return parentHostContext;
+		return { isInsideText };
+	},
+	createInstance(type, props, _rootContainer, hostContext) {
+		type = normalizeNodeType(type);
+		if ("style" in props && props.style && typeof props.style === "object") props = {
+			...props.style,
+			...props
+		};
+		if (type === "silvery-box" && hostContext.isInsideText) {
+			if (process.env.NODE_ENV !== "production") warnOnce(BOX_INSIDE_TEXT_WARNING_ID, () => log.warn?.("<Box> cannot be nested inside <Text>. This produces undefined layout behavior."));
+		}
+		if (type === "silvery-text" && hostContext.isInsideText) {
+			const node = createVirtualTextNode(props);
+			logNodeLifecycle("mount", node);
+			return node;
+		}
+		const node = createNode(type, props);
+		logNodeLifecycle("mount", node);
+		return node;
+	},
+	createTextInstance(text, _rootContainer, hostContext) {
+		const epoch = getRenderEpoch();
+		const node = {
+			type: "silvery-text",
+			props: { children: text },
+			children: [],
+			parent: null,
+			layoutNode: null,
+			boxRect: null,
+			scrollRect: null,
+			screenRect: null,
+			prevLayout: null,
+			prevScrollRect: null,
+			prevScreenRect: null,
+			layoutChangedThisFrame: -1,
+			dirtyBits: 23,
+			dirtyEpoch: epoch,
+			textContent: text,
+			isRawText: true
+		};
+		logNodeLifecycle("mount", node);
+		return node;
+	},
+	appendChild(parentInstance, child) {
+		const existingIndex = parentInstance.children.indexOf(child);
+		if (existingIndex !== -1) {
+			parentInstance.children.splice(existingIndex, 1);
+			if (parentInstance.layoutNode && child.layoutNode) parentInstance.layoutNode.removeChild(child.layoutNode);
+		}
+		child.parent = parentInstance;
+		parentInstance.children.push(child);
+		const container = getOwningContainer(parentInstance);
+		if (container) bindSubtreeToContainer(child, container);
+		if (parentInstance.layoutNode && child.layoutNode) {
+			const layoutIndex = parentInstance.children.filter((c) => c.layoutNode !== null).length - 1;
+			parentInstance.layoutNode.insertChild(child.layoutNode, layoutIndex);
+		}
+		{
+			const epoch = getRenderEpoch();
+			const bits = 9;
+			parentInstance.dirtyBits = parentInstance.dirtyEpoch !== epoch ? bits : parentInstance.dirtyBits | bits;
+			parentInstance.dirtyEpoch = epoch;
+		}
+		parentInstance.layoutNode?.markDirty();
+		trackContentDirty(parentInstance);
+		markLayoutAncestorDirty(parentInstance);
+		markSubtreeDirty(parentInstance);
+		notifySubtreeAttached(container, child);
+	},
+	appendInitialChild(parentInstance, child) {
+		child.parent = parentInstance;
+		parentInstance.children.push(child);
+		const container = getOwningContainer(parentInstance);
+		if (container) bindSubtreeToContainer(child, container);
+		if (parentInstance.layoutNode && child.layoutNode) {
+			const layoutIndex = parentInstance.children.filter((c) => c.layoutNode !== null).length - 1;
+			parentInstance.layoutNode.insertChild(child.layoutNode, layoutIndex);
+		}
+	},
+	appendChildToContainer(container, child) {
+		const existingIndex = container.root.children.indexOf(child);
+		if (existingIndex !== -1) {
+			container.root.children.splice(existingIndex, 1);
+			if (container.root.layoutNode && child.layoutNode) container.root.layoutNode.removeChild(child.layoutNode);
+		}
+		child.parent = container.root;
+		container.root.children.push(child);
+		bindSubtreeToContainer(child, container);
+		if (container.root.layoutNode && child.layoutNode) {
+			const layoutIndex = container.root.children.filter((c) => c.layoutNode !== null).length - 1;
+			container.root.layoutNode.insertChild(child.layoutNode, layoutIndex);
+		}
+		{
+			const epoch = getRenderEpoch();
+			const bits = 9;
+			container.root.dirtyBits = container.root.dirtyEpoch !== epoch ? bits : container.root.dirtyBits | bits;
+			container.root.dirtyEpoch = epoch;
+		}
+		container.root.layoutNode?.markDirty();
+		trackContentDirty(container.root);
+		markSubtreeDirty(container.root);
+		notifySubtreeAttached(container, child);
+	},
+	removeChild(parentInstance, child) {
+		const index = parentInstance.children.indexOf(child);
+		if (index !== -1) {
+			notifyNodeRemoved(getOwningContainer(parentInstance) ?? getOwningContainer(child), child);
+			logUnmountSubtree(child);
+			disposeSubtreeScopes(child);
+			parentInstance.children.splice(index, 1);
+			if (parentInstance.layoutNode && child.layoutNode) {
+				parentInstance.layoutNode.removeChild(child.layoutNode);
+				child.layoutNode.free();
+			}
+			unbindSubtreeFromContainer(child);
+			child.parent = null;
+			{
+				const epoch = getRenderEpoch();
+				const bits = 9;
+				parentInstance.dirtyBits = parentInstance.dirtyEpoch !== epoch ? bits : parentInstance.dirtyBits | bits;
+				parentInstance.dirtyEpoch = epoch;
+			}
+			parentInstance.layoutNode?.markDirty();
+			trackContentDirty(parentInstance);
+			markLayoutAncestorDirty(parentInstance);
+			markSubtreeDirty(parentInstance);
+		}
+	},
+	removeChildFromContainer(container, child) {
+		const index = container.root.children.indexOf(child);
+		if (index !== -1) {
+			notifyNodeRemoved(container, child);
+			logUnmountSubtree(child);
+			disposeSubtreeScopes(child);
+			container.root.children.splice(index, 1);
+			if (container.root.layoutNode && child.layoutNode) {
+				container.root.layoutNode.removeChild(child.layoutNode);
+				child.layoutNode.free();
+			}
+			unbindSubtreeFromContainer(child);
+			child.parent = null;
+			{
+				const epoch = getRenderEpoch();
+				const bits = 9;
+				container.root.dirtyBits = container.root.dirtyEpoch !== epoch ? bits : container.root.dirtyBits | bits;
+				container.root.dirtyEpoch = epoch;
+			}
+			container.root.layoutNode?.markDirty();
+			trackContentDirty(container.root);
+			markSubtreeDirty(container.root);
+		}
+	},
+	insertBefore(parentInstance, child, beforeChild) {
+		const existingIndex = parentInstance.children.indexOf(child);
+		if (existingIndex !== -1) {
+			parentInstance.children.splice(existingIndex, 1);
+			if (parentInstance.layoutNode && child.layoutNode) parentInstance.layoutNode.removeChild(child.layoutNode);
+		}
+		const beforeIndex = parentInstance.children.indexOf(beforeChild);
+		if (beforeIndex !== -1) {
+			child.parent = parentInstance;
+			parentInstance.children.splice(beforeIndex, 0, child);
+			const container = getOwningContainer(parentInstance);
+			if (container) bindSubtreeToContainer(child, container);
+			if (parentInstance.layoutNode && child.layoutNode) {
+				const layoutIndex = parentInstance.children.slice(0, beforeIndex).filter((c) => c.layoutNode !== null).length;
+				parentInstance.layoutNode.insertChild(child.layoutNode, layoutIndex);
+			}
+			{
+				const epoch = getRenderEpoch();
+				const bits = 9;
+				parentInstance.dirtyBits = parentInstance.dirtyEpoch !== epoch ? bits : parentInstance.dirtyBits | bits;
+				parentInstance.dirtyEpoch = epoch;
+			}
+			parentInstance.layoutNode?.markDirty();
+			trackContentDirty(parentInstance);
+			markLayoutAncestorDirty(parentInstance);
+			markSubtreeDirty(parentInstance);
+			notifySubtreeAttached(container, child);
+		}
+	},
+	insertInContainerBefore(container, child, beforeChild) {
+		const existingIndex = container.root.children.indexOf(child);
+		if (existingIndex !== -1) {
+			container.root.children.splice(existingIndex, 1);
+			if (container.root.layoutNode && child.layoutNode) container.root.layoutNode.removeChild(child.layoutNode);
+		}
+		const beforeIndex = container.root.children.indexOf(beforeChild);
+		if (beforeIndex !== -1) {
+			child.parent = container.root;
+			container.root.children.splice(beforeIndex, 0, child);
+			bindSubtreeToContainer(child, container);
+			if (container.root.layoutNode && child.layoutNode) {
+				const layoutIndex = container.root.children.slice(0, beforeIndex).filter((c) => c.layoutNode !== null).length;
+				container.root.layoutNode.insertChild(child.layoutNode, layoutIndex);
+			}
+			{
+				const epoch = getRenderEpoch();
+				const bits = 9;
+				container.root.dirtyBits = container.root.dirtyEpoch !== epoch ? bits : container.root.dirtyBits | bits;
+				container.root.dirtyEpoch = epoch;
+			}
+			container.root.layoutNode?.markDirty();
+			trackContentDirty(container.root);
+			markSubtreeDirty(container.root);
+			notifySubtreeAttached(container, child);
+		}
+	},
+	prepareUpdate(_instance, _type, oldProps, newProps) {
+		return classifyPropChanges(oldProps, newProps).anyChanged;
+	},
+	commitUpdate(instance, _type, oldProps, newProps, _finishedWork) {
+		if ("style" in oldProps && oldProps.style && typeof oldProps.style === "object") oldProps = {
+			...oldProps.style,
+			...oldProps
+		};
+		if ("style" in newProps && newProps.style && typeof newProps.style === "object") newProps = {
+			...newProps.style,
+			...newProps
+		};
+		const { anyChanged, layoutChanged, contentChanged } = classifyPropChanges(oldProps, newProps);
+		if (!anyChanged) {
+			instance.props = newProps;
+			return;
+		}
+		if (layoutChanged) {
+			if (instance.layoutNode) {
+				if (instance.type === "silvery-text") applyTextFlexItemProps(instance.layoutNode, newProps, oldProps);
+				else if (instance.type === "silvery-viewport") applyViewportProps(instance.layoutNode, newProps, oldProps);
+				else if (instance.type === "silvery-island") applyIslandProps(instance.layoutNode, newProps, oldProps);
+				else applyBoxProps(instance.layoutNode, newProps, oldProps);
+				instance.layoutNode.markDirty();
+			}
+		}
+		if (contentChanged) {
+			const epoch = getRenderEpoch();
+			let bits = 2;
+			if (contentChanged === "text") {
+				bits |= 1;
+				if (instance.layoutNode) instance.layoutNode.markDirty();
+			}
+			if (oldProps.backgroundColor !== newProps.backgroundColor) bits |= 4;
+			if (oldProps.borderStyle && !newProps.borderStyle) bits |= 4;
+			if (oldProps.theme !== newProps.theme) bits |= 5;
+			instance.dirtyBits = instance.dirtyEpoch !== epoch ? bits : instance.dirtyBits | bits;
+			instance.dirtyEpoch = epoch;
+		}
+		if (contentChanged) trackContentDirty(instance);
+		if (contentChanged === "style" && !layoutChanged && !isDirty(instance.dirtyBits, instance.dirtyEpoch, 4) && !isDirty(instance.dirtyBits, instance.dirtyEpoch, 1) && !isDirty(instance.dirtyBits, instance.dirtyEpoch, 8)) trackStyleOnlyDirty(instance);
+		instance.props = newProps;
+		logNodeLifecycle("update", instance);
+		notifyNodeUpdated(instance);
+		const scrollToChanged = oldProps.scrollTo !== newProps.scrollTo;
+		const scrollOffsetChanged = oldProps.scrollOffset !== newProps.scrollOffset;
+		if (scrollToChanged || scrollOffsetChanged) trackScrollDirty(instance);
+		if (layoutChanged || contentChanged || scrollToChanged || scrollOffsetChanged) {
+			markLayoutAncestorDirty(instance);
+			markSubtreeDirty(instance);
+		}
+	},
+	commitTextUpdate(textInstance, _oldText, newText) {
+		textInstance.textContent = newText;
+		syncTextContentSignal(textInstance);
+		textInstance.props = { children: newText };
+		const epoch = getRenderEpoch();
+		const bits = 3;
+		textInstance.dirtyBits = textInstance.dirtyEpoch !== epoch ? bits : textInstance.dirtyBits | bits;
+		textInstance.dirtyEpoch = epoch;
+		trackContentDirty(textInstance);
+		markLayoutAncestorDirty(textInstance);
+		markSubtreeDirty(textInstance);
+	},
+	finalizeInitialChildren() {
+		return false;
+	},
+	prepareForCommit() {
+		return null;
+	},
+	resetAfterCommit(container) {
+		const budgetEnv = typeof process !== "undefined" ? process.env.SILVERY_RENDER_BUDGET_MS : void 0;
+		const budget = budgetEnv !== void 0 ? Number(budgetEnv) : 0;
+		if (budget > 0 && Number.isFinite(budget)) {
+			const start = performance.now();
+			container.onRender();
+			const elapsed = performance.now() - start;
+			if (elapsed > budget) console.warn(`[silvery] render commit exceeded budget: ${elapsed.toFixed(0)}ms > ${budget}ms — see @km/board/projection-stability-improvements for cascade-prevention guidance`);
+		} else container.onRender();
+	},
+	getPublicInstance(instance) {
+		return instance;
+	},
+	shouldSetTextContent() {
+		return false;
+	},
+	clearContainer(container) {
+		for (const child of container.root.children) {
+			notifyNodeRemoved(container, child);
+			logUnmountSubtree(child);
+		}
+		disposeSubtreeScopes(container.root);
+		for (const child of container.root.children) {
+			if (container.root.layoutNode && child.layoutNode) {
+				container.root.layoutNode.removeChild(child.layoutNode);
+				child.layoutNode.free();
+			}
+			unbindSubtreeFromContainer(child);
+		}
+		container.root.children = [];
+		{
+			const epoch = getRenderEpoch();
+			const bits = 9;
+			container.root.dirtyBits = container.root.dirtyEpoch !== epoch ? bits : container.root.dirtyBits | bits;
+			container.root.dirtyEpoch = epoch;
+		}
+		container.root.layoutNode?.markDirty();
+		trackContentDirty(container.root);
+		markSubtreeDirty(container.root);
+	},
+	preparePortalMount() {},
+	getCurrentEventPriority() {
+		if (currentUpdatePriority !== NoEventPriority) return currentUpdatePriority;
+		return DefaultEventPriority;
+	},
+	getInstanceFromNode() {
+		return null;
+	},
+	beforeActiveInstanceBlur() {},
+	afterActiveInstanceBlur() {},
+	prepareScopeUpdate() {},
+	getInstanceFromScope() {
+		return null;
+	},
+	detachDeletedInstance(node) {
+		disposeSubtreeScopes(node);
+		unbindSubtreeFromContainer(node);
+	},
+	setCurrentUpdatePriority(newPriority) {
+		currentUpdatePriority = newPriority;
+	},
+	getCurrentUpdatePriority() {
+		return currentUpdatePriority;
+	},
+	resolveUpdatePriority() {
+		if (currentUpdatePriority !== NoEventPriority) return currentUpdatePriority;
+		return DefaultEventPriority;
+	},
+	maySuspendCommit() {
+		return false;
+	},
+	NotPendingTransition: null,
+	HostTransitionContext: createContext(null),
+	resetFormInstance() {},
+	requestPostPaintCallback() {},
+	shouldAttemptEagerTransition() {
+		return false;
+	},
+	trackSchedulerEvent() {},
+	resolveEventType() {
+		return null;
+	},
+	resolveEventTimeStamp() {
+		return -1.1;
+	},
+	preloadInstance() {
+		return true;
+	},
+	startSuspendingCommit() {},
+	suspendInstance() {},
+	waitForCommitToBeReady() {
+		return null;
+	},
+	/**
+	* Hide an instance during Suspense.
+	* Called when React needs to hide content while showing a fallback.
+	*
+	* Must set stylePropsDirty (render phase fast-path skip includes stylePropsDirty check),
+	* layoutNode.markDirty() (hiding changes measured content — the layout engine
+	* must recalculate dimensions), and markLayoutAncestorDirty (virtual text nodes
+	* without layoutNode need the nearest layout ancestor dirty).
+	*/
+	hideInstance(instance) {
+		instance.hidden = true;
+		const epoch = getRenderEpoch();
+		const bits = 3;
+		instance.dirtyBits = instance.dirtyEpoch !== epoch ? bits : instance.dirtyBits | bits;
+		instance.dirtyEpoch = epoch;
+		if (instance.layoutNode) instance.layoutNode.markDirty();
+		trackContentDirty(instance);
+		if (instance.parent) {
+			if (instance.parent.dirtyEpoch !== epoch) {
+				instance.parent.dirtyBits = 1;
+				instance.parent.dirtyEpoch = epoch;
+			} else instance.parent.dirtyBits |= 1;
+			trackContentDirty(instance.parent);
+		}
+		markLayoutAncestorDirty(instance);
+		markSubtreeDirty(instance);
+	},
+	/**
+	* Unhide an instance after Suspense resolves.
+	* Called when the suspended content is ready to show.
+	*
+	* Same invalidation as hideInstance — the node's visibility change affects
+	* layout (measured content changes) and paint (content must be re-rendered).
+	*/
+	unhideInstance(instance, _props) {
+		instance.hidden = false;
+		const epoch = getRenderEpoch();
+		const bits = 3;
+		instance.dirtyBits = instance.dirtyEpoch !== epoch ? bits : instance.dirtyBits | bits;
+		instance.dirtyEpoch = epoch;
+		if (instance.layoutNode) instance.layoutNode.markDirty();
+		trackContentDirty(instance);
+		if (instance.parent) {
+			if (instance.parent.dirtyEpoch !== epoch) {
+				instance.parent.dirtyBits = 1;
+				instance.parent.dirtyEpoch = epoch;
+			} else instance.parent.dirtyBits |= 1;
+			trackContentDirty(instance.parent);
+		}
+		markLayoutAncestorDirty(instance);
+		markSubtreeDirty(instance);
+	},
+	/**
+	* Hide a text instance during Suspense.
+	*
+	* Text instances don't have layout nodes. markLayoutAncestorDirty walks up
+	* to the nearest layout ancestor and marks it dirty so the measure function
+	* re-collects descendant text (collectNodeTextContent skips hidden children).
+	*/
+	hideTextInstance(textInstance) {
+		textInstance.hidden = true;
+		const epoch = getRenderEpoch();
+		const bits = 3;
+		textInstance.dirtyBits = textInstance.dirtyEpoch !== epoch ? bits : textInstance.dirtyBits | bits;
+		textInstance.dirtyEpoch = epoch;
+		trackContentDirty(textInstance);
+		if (textInstance.parent) {
+			if (textInstance.parent.dirtyEpoch !== epoch) {
+				textInstance.parent.dirtyBits = 1;
+				textInstance.parent.dirtyEpoch = epoch;
+			} else textInstance.parent.dirtyBits |= 1;
+			trackContentDirty(textInstance.parent);
+		}
+		markLayoutAncestorDirty(textInstance);
+		markSubtreeDirty(textInstance);
+	},
+	/**
+	* Unhide a text instance after Suspense resolves.
+	*
+	* Same invalidation as hideTextInstance — the text content changes when
+	* hidden children become visible again.
+	*/
+	unhideTextInstance(textInstance, _text) {
+		textInstance.hidden = false;
+		const epoch = getRenderEpoch();
+		const bits = 3;
+		textInstance.dirtyBits = textInstance.dirtyEpoch !== epoch ? bits : textInstance.dirtyBits | bits;
+		textInstance.dirtyEpoch = epoch;
+		trackContentDirty(textInstance);
+		if (textInstance.parent) {
+			if (textInstance.parent.dirtyEpoch !== epoch) {
+				textInstance.parent.dirtyBits = 1;
+				textInstance.parent.dirtyEpoch = epoch;
+			} else textInstance.parent.dirtyBits |= 1;
+			trackContentDirty(textInstance.parent);
+		}
+		markLayoutAncestorDirty(textInstance);
+		markSubtreeDirty(textInstance);
+	}
+};
+//#endregion
+//#region packages/ag-react/src/reconciler/index.ts
+/**
+* Silvery React Reconciler
+*
+* Custom React reconciler that builds a tree of SilveryNodes, each with a Yoga layout node.
+* This is the core of Silvery's architecture - separating structure (React reconciliation)
+* from content (terminal rendering).
+*
+* The reconciler creates SilveryNodes during React's reconciliation phase,
+* but actual terminal content is rendered later after Yoga computes layout.
+*/
+/**
+* Create the React reconciler instance.
+*/
+const reconciler = Reconciler(hostConfig);
+/**
+* Create a container for rendering.
+*/
+function createContainer(onRender) {
+	const container = {
+		root: createRootNode(),
+		onRender,
+		nodeLifecycle: null
+	};
+	registerContainer(container);
+	return container;
+}
+/**
+* Create a React fiber root for a container (wraps the 10-argument reconciler call).
+*
+* Pass `options.onUncaughtError` to route React-thrown render errors back to
+* the host's panic path. Without it, render errors are silently swallowed
+* (the default `() => {}` callback) and the only surface for them is whatever
+* the host's `console.error` capture decides to do — typically an altscreen
+* overlay the user can't copy-paste or screenshot reliably.
+*/
+function createFiberRoot(container, options = {}) {
+	return reconciler.createContainer(container, 1, null, false, null, "", options.onUncaughtError ?? (() => {}), options.onCaughtError ?? (() => {}), options.onRecoverableError ?? (() => {}), null);
+}
+/**
+* Get the root SilveryNode from a container.
+*/
+function getContainerRoot(container) {
+	return container.root;
+}
+/**
+* Synchronously unmount a fiber root and scrub the container so it can't
+* keep its closure-captured RenderInstance alive afterward.
+*
+* Why both steps are needed:
+*
+* 1. `createFiberRoot` uses `ConcurrentRoot` (mode 1). React's async
+*    `updateContainer(null, fiberRoot, ...)` does NOT run layout-effect
+*    cleanups before returning — useLayoutEffect / useBoxRect /
+*    useBoxMetrics / signal-effect disposers are scheduled but may not
+*    fire promptly. That keeps signal subscriptions alive past unmount,
+*    which keeps the React tree reachable, which keeps the host
+*    `RenderInstance` reachable. `updateContainerSync` + `flushSyncWork`
+*    forces all cleanups to run inline.
+*
+* 2. Even after the React tree is detached, the `FiberRoot` keeps a
+*    pointer to its `containerInfo` (our `Container`) for some time, and
+*    `Container.onRender` typically closes over the entire enclosing
+*    `RenderInstance`. Without nulling `onRender` and scrubbing the root
+*    AgNode, the instance graph is still reachable through the FiberRoot's
+*    container pointer.
+*
+* Call this in every unmount path that uses ConcurrentRoot. The previous
+* (async) pattern leaked across mount/unmount cycles in tests and likely
+* in production long-lived host applications too.
+*
+* Safe to call multiple times — `releaseContainer` is idempotent (the
+* scrub fields are nulled and `layoutNode.free()` is best-effort).
+*
+* @param fiberRoot — opaque React FiberRoot returned by `createFiberRoot`
+* @param container — the `Container` paired with that fiberRoot
+*/
+function unmountFiberRoot(fiberRoot, container) {
+	reconciler.updateContainerSync(null, fiberRoot, null, null);
+	reconciler.flushSyncWork();
+	releaseContainer(container);
+}
+/**
+* Scrub a Container so it can't retain its enclosing render state after
+* the React tree has been unmounted. See {@link unmountFiberRoot} for the
+* full rationale; call this directly only if you've already run a sync
+* unmount through the reconciler and just need the post-commit scrub.
+*/
+function releaseContainer(container) {
+	disposeSubtreeScopes(container.root);
+	releaseContainerLifecycle(container);
+	container.onRender = () => {};
+	const root = container.root;
+	root.children = [];
+	root.parent = null;
+	root.boxRect = null;
+	root.scrollRect = null;
+	root.screenRect = null;
+	root.prevLayout = null;
+	root.prevScrollRect = null;
+	root.prevScreenRect = null;
+	if (root.layoutNode) {
+		try {
+			root.layoutNode.free();
+		} catch {}
+		root.layoutNode = null;
+	}
+}
+//#endregion
+export { trackContentDirty as S, isAnyDirty as _, unmountFiberRoot as a, clearDirtyTracking as b, setContainerNodeLifecycle as c, createScope as d, reportDisposeError as f, getRenderEpoch as g, advanceRenderEpoch as h, reconciler as i, measureStats as l, finaliseHandle as m, createFiberRoot as n, hostConfig as o, defineHandle as p, getContainerRoot as r, runWithDiscreteEvent as s, createContainer as t, collectPlainText as u, isCurrentEpoch as v, hasScrollDirty as x, isDirty as y };
+
+//# sourceMappingURL=reconciler-NBDSEm8k.mjs.map