@octane-xplat/ui 0.9.0 → 0.10.0

package/dist/native/resize-state.js

@@ -0,0 +1,208 @@
+import { clampSize, toPixels } from "./resize-math.js";
+import { loadResizableState, persistResizableState } from "./resize-persist.js";
+var warned = /* @__PURE__ */ new Set();
+function devWarn(what, msg) {
+	const k = what + ":" + msg;
+	if (warned.has(k)) return;
+	warned.add(k);
+	console.warn(`[octane-xplat] ${what}: ${msg}`);
+}
+/** Build a single resizable region. `storageKey` defaults to autoSaveId;
+*  multi-region callers pass `${autoSaveId}:${key}`. */
+function createResizableRegion(config, basis, storageKey) {
+	const direction = config.direction ?? "horizontal";
+	const containerRef = config.containerRef;
+	const persistKey = storageKey ?? config.autoSaveId;
+	const persisted = persistKey ? loadResizableState(persistKey.startsWith(basis.storagePrefix) ? persistKey : basis.storagePrefix + persistKey) : null;
+	let listeners = /* @__PURE__ */ new Set();
+	let gestureBasis = null;
+	let dragStartSize = 0;
+	let didWarnInverted = false;
+	let snapshot = {
+		size: 0,
+		isCollapsed: false
+	};
+	const emit = () => {
+		listeners.forEach((cb) => cb());
+	};
+	let cfg = config;
+	let basisValue = basis.measure(containerRef, direction);
+	const isBasisMeasured = () => basisValue != null;
+	const resolvedMin = () => {
+		return toPixels(cfg.minSize, basisValue ?? 0) ?? 0;
+	};
+	const resolvedMax = () => {
+		return toPixels(cfg.maxSize, basisValue ?? Infinity) ?? Infinity;
+	};
+	const snaps = () => cfg.snaps ?? [];
+	const initialSize = () => {
+		if (persisted?.size != null) return persisted.size;
+		return toPixels(cfg.defaultSize, basisValue ?? 0) ?? 0;
+	};
+	let chosenSize = initialSize();
+	let uncontrolledCollapsed = persisted?.isCollapsed ?? cfg.defaultIsCollapsed ?? false;
+	const isControlled = () => cfg.isCollapsed !== void 0;
+	const isCollapsed = () => cfg.collapsible ? isControlled() ? cfg.isCollapsed : uncontrolledCollapsed : false;
+	const recomputeSnapshot = () => {
+		const size = isCollapsed() ? 0 : chosenSize;
+		if (snapshot.size !== size || snapshot.isCollapsed !== isCollapsed()) snapshot = {
+			size,
+			isCollapsed: isCollapsed()
+		};
+	};
+	recomputeSnapshot();
+	const setCollapsed = (value) => {
+		if (!isControlled()) uncontrolledCollapsed = value;
+	};
+	const notify = () => {
+		if (resolvedMin() > resolvedMax() && !didWarnInverted) {
+			didWarnInverted = true;
+			devWarn("useResizable", `the resolved minimum (${resolvedMin()}px) is above the resolved maximum (${resolvedMax()}px). The maximum wins.`);
+		}
+		if (persistKey && isBasisMeasured()) persistResizableState(persistKey.startsWith(basis.storagePrefix) ? persistKey : basis.storagePrefix + persistKey, {
+			size: chosenSize,
+			isCollapsed: isCollapsed()
+		});
+		recomputeSnapshot();
+		emit();
+	};
+	const collapse = () => {
+		if (!cfg.collapsible || isCollapsed()) return;
+		setCollapsed(true);
+		cfg.onCollapseChange?.(true);
+		cfg.onSizeChange?.(0);
+		notify();
+	};
+	const expand = () => {
+		const wasCollapsed = isCollapsed();
+		setCollapsed(false);
+		if (wasCollapsed) cfg.onCollapseChange?.(false);
+		cfg.onSizeChange?.(chosenSize);
+		notify();
+	};
+	const resize = (newSize) => {
+		if (!Number.isFinite(newSize) || newSize < 0) {
+			devWarn("useResizable", `resize(${String(newSize)}) is not a pixel size. Keeping the current size. Percentages configure the hook; they are not a programmatic input.`);
+			return;
+		}
+		const clamped = clampSize(newSize, resolvedMin(), resolvedMax(), snaps());
+		const wasCollapsed = isCollapsed();
+		chosenSize = clamped;
+		setCollapsed(false);
+		if (wasCollapsed) cfg.onCollapseChange?.(false);
+		cfg.onSizeChange?.(clamped);
+		notify();
+	};
+	const onResizeStart = () => {
+		gestureBasis = basisValue;
+		dragStartSize = isCollapsed() ? 0 : chosenSize;
+	};
+	const onResizeMove = (delta) => {
+		const raw = dragStartSize + delta;
+		const collapsedSize = cfg.collapsedSize ?? 40;
+		if (cfg.collapsible && raw < collapsedSize) {
+			if (!isCollapsed()) {
+				setCollapsed(true);
+				cfg.onCollapseChange?.(true);
+				cfg.onSizeChange?.(0);
+				notify();
+			}
+			return;
+		}
+		if (isCollapsed() && raw >= collapsedSize) {
+			setCollapsed(false);
+			cfg.onCollapseChange?.(false);
+		}
+		const clamped = clampSize(raw, resolvedMin(), resolvedMax(), snaps());
+		chosenSize = clamped;
+		cfg.onSizeChange?.(clamped);
+		notify();
+	};
+	const releaseGestureBasis = () => {
+		gestureBasis = null;
+	};
+	const onResizeEnd = () => {
+		releaseGestureBasis();
+	};
+	const props = {
+		_size: 0,
+		_isCollapsed: false,
+		_onResizeStart: onResizeStart,
+		_onResizeMove: onResizeMove,
+		_onResizeEnd: onResizeEnd,
+		_onResizeCancel: releaseGestureBasis,
+		_minSizePx: 0,
+		_maxSizePx: 0,
+		_snaps: [],
+		_collapsedSize: 0,
+		_collapsible: false,
+		_direction: direction,
+		_isResizableProps: true
+	};
+	const syncProps = () => {
+		props._size = isCollapsed() ? 0 : chosenSize;
+		props._isCollapsed = isCollapsed();
+		props._minSizePx = resolvedMin();
+		props._maxSizePx = resolvedMax();
+		props._snaps = snaps();
+		props._collapsedSize = cfg.collapsedSize ?? 40;
+		props._collapsible = cfg.collapsible ?? false;
+	};
+	syncProps();
+	const machine = {
+		region: {
+			size: snapshot.size,
+			isCollapsed: snapshot.isCollapsed,
+			collapse,
+			expand,
+			resize,
+			props
+		},
+		subscribe: (cb) => {
+			listeners.add(cb);
+			return () => listeners.delete(cb);
+		},
+		getSnapshot: () => {
+			recomputeSnapshot();
+			syncProps();
+			machine.region.size = snapshot.size;
+			machine.region.isCollapsed = snapshot.isCollapsed;
+			return snapshot;
+		},
+		remeasure: () => {
+			if (gestureBasis != null) return;
+			const next = basis.measure(containerRef, direction);
+			if (next == null || next === basisValue) return;
+			basisValue = next;
+			chosenSize = clampSize(chosenSize, resolvedMin(), resolvedMax(), snaps());
+			notify();
+		},
+		update: (next) => {
+			cfg = next;
+		}
+	};
+	if (!isBasisMeasured()) {} else notify();
+	return machine;
+}
+/** Map a component's simplified `resizable` config (e.g. SideNav) to the
+*  full single-region config. */
+function regionConfigFrom(resizable) {
+	if (!resizable) return null;
+	if (resizable === true) return {
+		defaultSize: 260,
+		minSize: 180,
+		maxSize: 480
+	};
+	return {
+		defaultSize: resizable.defaultWidth ?? 260,
+		minSize: resizable.minWidth ?? 180,
+		maxSize: resizable.maxWidth ?? 480,
+		autoSaveId: resizable.autoSaveId,
+		defaultIsCollapsed: resizable.defaultIsCollapsed,
+		isCollapsed: resizable.isCollapsed,
+		onSizeChange: resizable.onWidthChange,
+		onCollapseChange: resizable.onCollapseChange
+	};
+}
+//#endregion
+export { createResizableRegion, regionConfigFrom };

package/dist/native/{root-layout.mobile.js → root-layout.js}

@@ -1,5 +1,5 @@
 import { RootLayout, getRootLayout } from "@nativescript/core";
-//#region src/root-layout.mobile.ts
+//#region src/root-layout.ts
 var registry = [];
 /** Called by the Screen leaf's <rootlayout> onLoaded/onUnloaded. */
 function registerRootLayout(rl) {

package/dist/native/route-host.js

@@ -0,0 +1,2 @@
+import { RouteHost, screenParamsFor } from "./RouteHost.tsrx.js";
+export { RouteHost, screenParamsFor };

package/dist/native/route-table.js

@@ -2,6 +2,36 @@
 var EXT = /\.(tsrx|tsx|ts|mts|cts|js|mjs|cjs|jsx)$/;
 var SUFFIX = /\.(web|mobile|ios|android|macos|windows|linux)$/;
 var PARAM = /^\[(.+)\]$/;
+/** One route-dir/spec path segment → normalized pattern segment:
+*  `[x]`→`:x` · `[[x]]`/`[x?]`→`:x?` (optional param) · `[...x]`→`*x`
+*  (terminal catch-all). Spec paths may write the normalized forms
+*  directly (`:x`, `:x?`, `*`, `*x`); a bare `*` captures into
+*  `params['*']`, a named `*x`/`[...x]` into `params.x`. */
+function normSegment(s) {
+	const b = PARAM.exec(s);
+	if (!b) return s;
+	const inner = b[1];
+	if (inner.startsWith("[") && inner.endsWith("]")) {
+		const core = inner.slice(1, -1);
+		return core.startsWith("...") ? "*" + core.slice(3) : ":" + core + "?";
+	}
+	return inner.startsWith("...") ? "*" + inner.slice(3) : ":" + inner;
+}
+/** Normalized pattern segment → param name: ':x'/':x?' → 'x',
+*  '*'/'*x' → '*'/'x', static segments → undefined. */
+function segmentParam(s) {
+	if (s.startsWith(":")) return s.endsWith("?") ? s.slice(1, -1) : s.slice(1);
+	if (s.startsWith("*")) return s.slice(1) || "*";
+}
+function segmentParams(segments) {
+	return segments.flatMap((s) => segmentParam(s) ?? []);
+}
+/** A catch-all only matches at the end of a pattern — warn that a
+*  mid-path '*' is a literal segment, not a remainder capture. */
+function warnOnStraySplat(segments, file) {
+	const at = segments.findIndex((s) => s.startsWith("*"));
+	if (at !== -1 && at !== segments.length - 1) console.warn(`[octane-xplat] route '${segments.join("/")}' (${file}) has a catch-all segment mid-path — '*' only captures at the end of a pattern and is a literal here`);
+}
 /** Build-time loader modules — `docs.loader.ts` pairs with route `docs`
 *  for `dataMode: 'baked'`. Never a route itself, never in a runtime glob. */
 var LOADER_FILE = /\.loader\.(ts|mts|cts|js|mjs|cjs|jsx)$/;
@@ -38,7 +68,8 @@ function pick(mod, file) {
 	const fns = Object.keys(mod ?? {}).filter((k) => typeof mod[k] === "function" && ![
 		"loader",
 		"beforeLoad",
-		"head"
+		"head",
+		"ErrorBoundary"
 	].includes(k));
 	if (fns.length === 1) return mod[fns[0]];
 	console.warn("[octane-xplat] route file " + file + (fns.length ? ` has ${fns.length} component-shaped exports (${fns.join(", ")}) — add a default or 'screen' export` : " has no component export") + " — skipped");
@@ -79,18 +110,16 @@ function deriveRouteManifest(files, prefer, dir = "app") {
 		}
 		const segs = parts.slice(0, -1).concat(base);
 		if (segs[segs.length - 1] === "index") segs.pop();
-		const segments = segs.map((s) => {
-			const p = PARAM.exec(s);
-			return p ? ":" + p[1] : s;
-		});
+		const segments = segs.map(normSegment);
 		const name = segments.join("/") || "index";
 		const meta = {
 			name,
 			segments,
-			params: segments.filter((s) => s.startsWith(":")).map((s) => s.slice(1)),
+			params: segmentParams(segments),
 			file: key,
 			presentation
 		};
+		warnOnStraySplat(segments, key);
 		const dataMode = files[key]?.dataMode;
 		if (dataMode === "baked" || dataMode === "live") meta.dataMode = dataMode;
 		const loader = files[key]?.loader;
@@ -100,6 +129,8 @@ function deriveRouteManifest(files, prefer, dir = "app") {
 		} else if (typeof loader === "function") meta.loader = loader;
 		const beforeLoad = files[key]?.beforeLoad;
 		if (typeof beforeLoad === "function") meta.beforeLoad = beforeLoad;
+		const errorBoundary = files[key]?.ErrorBoundary;
+		if (typeof errorBoundary === "function") meta.errorBoundary = errorBoundary;
 		if (files[key]?.head && (typeof files[key].head === "object" || typeof files[key].head === "function")) meta.head = files[key].head;
 		const prev = seen.get(name);
 		if (prev && prev.rank <= rank) {
@@ -133,19 +164,21 @@ function deriveRouteManifest(files, prefer, dir = "app") {
 	self.m = manifest;
 	return manifest;
 }
-/** Match-order comparator: static segments (2) outrank params (1), ties
-*  break alphabetically so ordering is total and stable across merges. */
+/** Match-order comparator: static (3) outranks a required param (2),
+*  which outranks an optional param (1), which outranks a catch-all (0).
+*  Ties break alphabetically so ordering is total and stable across
+*  merges. */
 function bySpecificity(a, b) {
-	return b.segments.reduce((n, s) => n + (s.startsWith(":") ? 1 : 2), 0) - a.segments.reduce((n, s) => n + (s.startsWith(":") ? 1 : 2), 0) || a.name.localeCompare(b.name);
+	const weight = (s) => s.startsWith("*") ? 0 : s.startsWith(":") ? s.endsWith("?") ? 1 : 2 : 3;
+	return b.segments.reduce((n, s) => n + weight(s), 0) - a.segments.reduce((n, s) => n + weight(s), 0) || a.name.localeCompare(b.name);
 }
 /** Normalize a programmatic `path` into manifest segments using the
 *  route-dir vocabulary: `'docs/[slug]'` and `'docs/:slug'` are the same
-*  pattern, a trailing `index` drops, `''`/`'index'` name the root route. */
+*  pattern, `':slug?'`/`'[slug?]'`/`'[[slug]]'` mark an optional segment,
+*  a terminal `'*'`/`'[...rest]'` is a catch-all, a trailing `index`
+*  drops, `''`/`'index'` name the root route. */
 function specSegments(path) {
-	const segs = path.split("/").filter(Boolean).map((s) => {
-		const p = PARAM.exec(s);
-		return p ? ":" + p[1] : s;
-	});
+	const segs = path.split("/").filter(Boolean).map(normSegment);
 	if (segs[segs.length - 1] === "index") segs.pop();
 	return segs;
 }
@@ -181,16 +214,18 @@ function defineRoutes(input) {
 		const meta = {
 			name,
 			segments,
-			params: segments.filter((s) => s.startsWith(":")).map((s) => s.slice(1)),
+			params: segmentParams(segments),
 			file: spec.source ?? `programmatic:${spec.path}`,
 			presentation: spec.presentation
 		};
+		warnOnStraySplat(segments, meta.file);
 		if (spec.dataMode) meta.dataMode = spec.dataMode;
 		if (spec.dataMode === "baked") {
 			meta.loader = bakedLookup(() => self.m, name);
 			if (spec.loader) console.warn(`[octane-xplat] baked route '${name}' also carries a loader — bake it in the host and pass the result via 'baked' so its code stays out of the bundle`);
 		} else if (spec.loader) meta.loader = spec.loader;
 		if (spec.beforeLoad) meta.beforeLoad = spec.beforeLoad;
+		if (spec.errorBoundary) meta.errorBoundary = spec.errorBoundary;
 		if (spec.head) meta.head = spec.head;
 		if (metas.has(name) && !warned.has(name)) {
 			warned.add(name);
@@ -276,52 +311,87 @@ function manifestToJson(manifest) {
 				source: meta.file,
 				loader: !!meta.loader,
 				guard: !!meta.beforeLoad,
-				head: !!meta.head
+				head: !!meta.head,
+				errorBoundary: !!meta.errorBoundary
 			};
 		})
 	};
 }
 /** Match URL path segments against a manifest — returns the winning meta
 *  plus extracted params, or null. First hit wins (routes are pre-sorted
-*  by specificity). */
+*  by specificity). A `:param?` segment matches zero or one segment —
+*  the matcher consumes greedily and backtracks to the absent case so a
+*  later static can still align; a terminal `*` captures the remaining
+*  segments `/`-joined into `params['*']` (a named `*rest` into 'rest'). */
 function matchRoute(routes, segs) {
 	for (const meta of routes) {
-		if (meta.segments.length !== segs.length) continue;
-		const params = {};
-		let ok = true;
-		for (let i = 0; i < segs.length; i++) {
-			const p = meta.segments[i];
-			if (p.startsWith(":")) params[p.slice(1)] = decodeRouteParam(decodeURIComponent(segs[i]));
-			else if (p !== segs[i]) {
-				ok = false;
-				break;
-			}
-		}
-		if (ok) return {
+		const params = matchSegments(meta.segments, segs);
+		if (params) return {
 			meta,
 			params
 		};
 	}
 	return null;
 }
+/** Variable-length pattern match — optional segments try consuming a
+*  segment first and fall back to absent, so the more specific reading
+*  wins; a backtracking miss deletes the tentative param before the
+*  absent retry. */
+function matchSegments(pattern, segs) {
+	const params = {};
+	const walk = (pi, si) => {
+		if (pi === pattern.length) return si === segs.length;
+		const p = pattern[pi];
+		if (p.startsWith("*")) {
+			if (pi !== pattern.length - 1) return p === segs[si] && walk(pi + 1, si + 1);
+			params[segmentParam(p)] = segs.slice(si).map((s) => decodeURIComponent(s)).join("/");
+			return true;
+		}
+		if (p.startsWith(":") && p.endsWith("?")) {
+			const name = p.slice(1, -1);
+			if (si < segs.length) {
+				params[name] = decodeRouteParam(decodeURIComponent(segs[si]));
+				if (walk(pi + 1, si + 1)) return true;
+				delete params[name];
+			}
+			return walk(pi + 1, si);
+		}
+		if (si >= segs.length) return false;
+		if (p.startsWith(":")) {
+			params[p.slice(1)] = decodeRouteParam(decodeURIComponent(segs[si]));
+			return walk(pi + 1, si + 1);
+		}
+		return p === segs[si] && walk(pi + 1, si + 1);
+	};
+	return walk(0, 0) ? params : null;
+}
 /** Serialize a Route to a URL path (no origin): manifest routes substitute
-*  `:param` segments from params (leftover params → query string);
+*  `:param` segments from params (leftover params → query string); a
+*  `:param?` segment with no value drops out of the path entirely, and a
+*  terminal `*`/`*rest` splices in its `/`-joined param value.
 *  non-manifest names keep the legacy `/<stack>/<name>?params` shape. */
 function buildRoutePath(routes, r) {
 	const meta = routes.find((m) => m.name === r.name);
 	let segs;
 	let rest = r.params;
 	if (meta) {
-		segs = meta.segments.map((s) => {
-			if (!s.startsWith(":")) return s;
-			const v = r.params[s.slice(1)];
+		segs = meta.segments.flatMap((s, i) => {
+			const p = s.startsWith("*") && i !== meta.segments.length - 1 ? void 0 : segmentParam(s);
+			if (p === void 0) return [s];
+			const v = r.params[p];
+			if (s.startsWith("*")) {
+				if (v === void 0 || v === null || v === "") return [];
+				const enc = encodeRouteParam(v, r.name, p);
+				return enc.startsWith(JSON_PARAM_PREFIX) ? [encodeURIComponent(enc)] : enc.split("/").map(encodeURIComponent);
+			}
+			if (s.endsWith("?") && (v === void 0 || v === null || v === "")) return [];
 			if (v === void 0) console.warn(`[octane-xplat] route '${r.name}' pushed without path param ${s}`);
-			return encodeURIComponent(encodeRouteParam(v, r.name, s.slice(1)));
+			return [encodeURIComponent(encodeRouteParam(v, r.name, p))];
 		});
 		rest = Object.fromEntries(Object.entries(r.params).filter(([k]) => !meta.params.includes(k)));
 	} else segs = [r.name];
 	const q = Object.entries(rest).map(([k, v]) => encodeURIComponent(k) + "=" + encodeURIComponent(encodeRouteParam(v, r.name, k))).join("&");
-	return (((r.stack === "root" ? "" : "/" + r.stack) + "/" + segs.join("/")).replace(/\/+$/, "") || "/") + (q ? "?" + q : "");
+	return (((r.stack === "root" ? "" : "/" + r.stack) + "/" + segs.join("/")).replace(/\/+$/, "") || "/") + (q ? "?" + q : "") + (r.hash ? "#" + r.hash : "");
 }
 var JSON_PARAM_PREFIX = "json:";
 /** Route codegen exposes string params, but the low-level Route shape remains
@@ -376,10 +446,15 @@ function linkPath(url) {
 /** Match a URL path+query against the manifest into a Route — the shared
 *  half of web's URL parse and native's deep-link handling. Whole-path
 *  match wins ('/demo/x' → root 'demo/:id'); a non-matching first segment
-*  is the stack prefix ('/demos/demo/x' → stack 'demos'). Unmatched names
-*  fall through as literal routes for pre-manifest callers. */
+*  is the stack prefix ('/demos/demo/x' → stack 'demos'). Whole-path
+*  includes catch-alls: a root `*` claims every URL, including
+*  stack-prefixed ones — apps needing named-stack links scope their
+*  splats under a prefix. Unmatched names fall through as literal
+*  routes for pre-manifest callers. */
 function matchUrl(routes, url) {
-	url = url.split("#", 1)[0];
+	const hashAt = url.indexOf("#");
+	const hash = hashAt === -1 ? void 0 : url.slice(hashAt + 1);
+	url = hashAt === -1 ? url : url.slice(0, hashAt);
 	const at = url.indexOf("?");
 	const p = at === -1 ? url : url.slice(0, at);
 	const qs = at === -1 ? void 0 : url.slice(at + 1);
@@ -400,7 +475,8 @@ function matchUrl(routes, url) {
 			...query,
 			...m?.params
 		},
-		presentation: m?.meta.presentation
+		presentation: m?.meta.presentation,
+		hash
 	});
 	const root = matchRoute(routes, segs);
 	if (root) return finish("root", root, segs.join("/"));

package/dist/native/route.js

@@ -1,9 +1,9 @@
 import { createNavigationRequests } from "./navigation-request.js";
 import { getStack, onStackRegistered, stackEntries } from "./stacks.js";
 import { RouteRedirect, buildRoutePath, layoutChain, linkPath, matchUrl, mergeRouteManifests } from "./route-table.js";
-import { RouteHost } from "./RouteHost.mobile.tsrx.js";
-import "./route-host.mobile.js";
-import { modalPresenter } from "./modal-presenter.mobile.js";
+import { RouteHost } from "./RouteHost.tsrx.js";
+import "./route-host.js";
+import { modalPresenter } from "./modal-presenter.js";
 import { createNativeScriptRoot } from "@nativescript-community/octane";
 import { Application, GridLayout, Page } from "@nativescript/core";
 import { hookSlots as hookSlots$1, useSyncExternalStore as useSyncExternalStore$1 } from "octane/universal/native";
@@ -79,6 +79,11 @@ function layoutsForRoute(name) {
 function screenFor(name) {
 	return screens[name];
 }
+/** The route's declared `ErrorBoundary` export, if any — outlets wrap the
+*  resolved screen in `RouteBoundary` with it. */
+function errorBoundaryFor(name) {
+	return metaFor(name)?.errorBoundary;
+}
 /** Wrap a screen in its directory `_layout` chain (outermost →
 *  innermost) as a single root component — pushed Pages and modal roots
 *  render this, matching web's outlet wrapping. */
@@ -329,7 +334,9 @@ function commitRoute(r, request) {
 				createNativeScriptRoot(host).render(RouteHost, {
 					screen: C,
 					layouts: layoutsForRoute(r.name),
-					params: props
+					params: props,
+					boundary: errorBoundaryFor(r.name),
+					route: r
 				});
 				return page;
 			},
@@ -378,7 +385,9 @@ function pushModal(frame, r, C) {
 		root.render(RouteHost, {
 			screen: C,
 			layouts: layoutsForRoute(r.name),
-			params
+			params,
+			boundary: errorBoundaryFor(r.name),
+			route: r
 		});
 		presenter.showModal(host, {
 			context: {},
@@ -510,4 +519,4 @@ var _h$0 = /* @__PURE__ */ Symbol(_hs$);
 var _h$1 = /* @__PURE__ */ Symbol(_hs$ + 1);
 var _h$2 = /* @__PURE__ */ Symbol(_hs$ + 2);
 //#endregion
-export { addBackInterceptor, addRoutes, canGoBack, currentModalRoute, currentRoute, hrefFor, layoutsForRoute, popRoute, pushDeepLink, pushRoute, redirect, registerRoutes, registerScreens, routeFor, routeStacks, screenFor, useCanGoBack, useModalRoute, useRoute };
+export { addBackInterceptor, addRoutes, canGoBack, currentModalRoute, currentRoute, errorBoundaryFor, hrefFor, layoutsForRoute, popRoute, pushDeepLink, pushRoute, redirect, registerRoutes, registerScreens, routeFor, routeStacks, screenFor, useCanGoBack, useModalRoute, useRoute };

package/dist/native/safe-url.js

@@ -0,0 +1,13 @@
+//#region src/safe-url.ts
+function normalizeUrl(url) {
+	return url.replace(/[\x00-\x1f\x7f]/g, "").trim();
+}
+/** Return the normalized URL, or null for a blocked scheme. */
+function sanitizeUrl(url) {
+	const normalized = normalizeUrl(url);
+	const lower = normalized.toLowerCase();
+	if (lower.startsWith("javascript:") || lower.startsWith("vbscript:") || lower.startsWith("data:text/html")) return null;
+	return normalized;
+}
+//#endregion
+export { sanitizeUrl };

package/dist/native/scheme-colors.js

@@ -0,0 +1,41 @@
+//#region src/scheme-colors.ts
+var TEXT_SECONDARY = {
+	light: "#666666",
+	dark: "#a1a1a1"
+};
+var TEXT_PRIMARY = {
+	light: "#0a0a0a",
+	dark: "#ededed"
+};
+var PRIMARY = {
+	light: "#171717",
+	dark: "#ededed"
+};
+var SUCCESS = "#15803d";
+var WARNING = "#b45309";
+var DANGER = "#dc2626";
+var mutedColor = (scheme) => TEXT_SECONDARY[scheme];
+var textColor = (scheme) => TEXT_PRIMARY[scheme];
+var accentColor = (scheme) => PRIMARY[scheme];
+/** StatusDot variant → ink color painted on the dot on native. */
+function statusDotColor(variant, scheme) {
+	switch (variant) {
+		case "success": return SUCCESS;
+		case "warning": return WARNING;
+		case "error": return DANGER;
+		case "accent": return PRIMARY[scheme];
+		default: return TEXT_SECONDARY[scheme];
+	}
+}
+/** ProgressBar variant → fill color on native. */
+function progressFillColor(variant, scheme) {
+	switch (variant) {
+		case "success": return SUCCESS;
+		case "warning": return WARNING;
+		case "error": return DANGER;
+		case "neutral": return TEXT_SECONDARY[scheme];
+		default: return PRIMARY[scheme];
+	}
+}
+//#endregion
+export { accentColor, mutedColor, progressFillColor, statusDotColor, textColor };

package/dist/native/select-options.js

@@ -0,0 +1,31 @@
+//#region src/select-options.ts
+function selectValues(value) {
+	return value == null ? [] : Array.isArray(value) ? [...new Set(value)] : [value];
+}
+function sameSelection(a, b) {
+	return a.length === b.length && a.every((value, index) => value === b[index]);
+}
+function filterSelectOptions(options, query) {
+	const lower = query.toLowerCase();
+	return options.filter((option) => (option.label ?? option.value).toLowerCase().includes(lower));
+}
+function groupSelectOptions(options) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const option of options) {
+		const rows = groups.get(option.group);
+		if (rows) rows.push(option);
+		else groups.set(option.group, [option]);
+	}
+	return [...groups].map(([heading, rows]) => ({
+		heading,
+		options: rows
+	}));
+}
+/** Bulk toggles affect only the visible enabled set, retaining hidden/disabled values. */
+function toggleVisibleSelection(selected, options) {
+	const enabled = options.filter((option) => !option.isDisabled).map((option) => option.value);
+	if (!enabled.length) return selected;
+	return enabled.every((value) => selected.includes(value)) ? selected.filter((value) => !enabled.includes(value)) : [.../* @__PURE__ */ new Set([...selected, ...enabled])];
+}
+//#endregion
+export { filterSelectOptions, groupSelectOptions, sameSelection, selectValues, toggleVisibleSelection };