@octane-xplat/ui 0.7.3 → 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,7 +2,52 @@
 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)$/;
 var PRESENT = /\+(modal|fade|push)$/;
+/** Loader for a `dataMode: 'baked'` route — resolves the name out of its
+*  owning manifest's `baked` map at push time. The map is assigned after
+*  the manifest is built (generated glue) or passed in (RouteSpecSet), so
+*  the lookup reads it lazily. A missing entry throws, landing as the
+*  screen's `error` prop like a live loader rejection. */
+function bakedLookup(manifest, name) {
+	return () => {
+		const baked = manifest()?.baked;
+		if (baked && Object.prototype.hasOwnProperty.call(baked, name)) return baked[name];
+		throw new Error(`[octane-xplat] baked route '${name}' has no baked data — run \`xplat routes\` to regenerate`);
+	};
+}
 /** Internal error carrier used by the public `redirect()` helper. Keeping
 * this in the shared route table gives both platform leaves the same guard
 * behavior without importing a platform runtime. */
@@ -23,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");
@@ -35,7 +81,9 @@ function deriveRouteManifest(files, prefer, dir = "app") {
 	const layouts = {};
 	const loaders = {};
 	const warned = /* @__PURE__ */ new Set();
+	const self = {};
 	for (const key of Object.keys(files).sort()) {
+		if (LOADER_FILE.test(key)) continue;
 		let rel = key.replace(/^\.?\//, "");
 		if (rel.startsWith(prefix)) rel = rel.slice(prefix.length);
 		rel = rel.replace(EXT, "");
@@ -62,22 +110,27 @@ 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;
-		if (typeof loader === "function") meta.loader = loader;
+		if (meta.dataMode === "baked") {
+			meta.loader = bakedLookup(() => self.m, name);
+			if (typeof loader === "function") console.warn(`[octane-xplat] baked route '${name}' also exports a loader — move it to a .loader.ts sibling so its imports stay out of the bundle`);
+		} 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) {
@@ -102,26 +155,30 @@ function deriveRouteManifest(files, prefer, dir = "app") {
 		if (meta.loader) loaders[meta.name] = meta.loader;
 	}
 	routes.sort(bySpecificity);
-	return {
+	const manifest = {
 		screens,
 		routes,
 		layouts,
 		loaders
 	};
+	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;
 }
@@ -131,7 +188,12 @@ var mergeWarned = /* @__PURE__ */ new Set();
 *  from their own sources, e.g. `readdirSync` over a content dir). Each
 *  spec's `path` uses the route-dir vocabulary; `layouts` keys are path
 *  prefixes playing the `_layout` role. Same-name duplicates inside the
-*  set keep the later entry with a warn, matching merge precedence. */
+*  set keep the later entry with a warn, matching merge precedence.
+*
+*  The return is branded with the spec-derived route types — read them
+*  with `ManifestRouteParams`/`ManifestRouteNames`/
+*  `ManifestRoutePresentations` to merge programmatic names into the
+*  app's typed navigation surface (`RouteName | …`, `RouteParams & …`). */
 function defineRoutes(input) {
 	const set = Array.isArray(input) ? { routes: input } : input;
 	const specs = set.routes;
@@ -140,6 +202,7 @@ function defineRoutes(input) {
 	const layouts = {};
 	const metas = /* @__PURE__ */ new Map();
 	const warned = /* @__PURE__ */ new Set();
+	const self = {};
 	for (const [key, layout] of Object.entries(extra ?? {})) {
 		const dir = key.replace(/^\/+|\/+$/g, "");
 		if (dir !== key) console.warn(`[octane-xplat] layout key '${key}' normalized to '${dir}'`);
@@ -151,12 +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
 		};
-		if (spec.loader) meta.loader = spec.loader;
+		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);
@@ -172,12 +241,15 @@ function defineRoutes(input) {
 	const routes = [...metas.values()].sort(bySpecificity);
 	const loaders = {};
 	for (const meta of routes) if (meta.loader) loaders[meta.name] = meta.loader;
-	return {
+	const manifest = {
 		screens,
 		routes,
 		layouts,
-		loaders
+		loaders,
+		baked: set.baked
 	};
+	self.m = manifest;
+	return manifest;
 }
 /** Compose manifests into one — file-derived base plus any number of
 *  programmatic sets (`registerRoutes(mergeRouteManifests(fromDir, dynamic))`).
@@ -188,9 +260,11 @@ function defineRoutes(input) {
 function mergeRouteManifests(...manifests) {
 	const screens = {};
 	const layouts = {};
+	const baked = {};
 	const winners = /* @__PURE__ */ new Map();
 	for (const m of manifests) {
 		Object.assign(layouts, m.layouts);
+		Object.assign(baked, m.baked);
 		Object.assign(screens, m.screens);
 		for (const meta of m.routes) {
 			const prev = winners.get(meta.name);
@@ -208,50 +282,116 @@ function mergeRouteManifests(...manifests) {
 		screens,
 		routes,
 		layouts,
-		loaders
+		loaders,
+		baked
+	};
+}
+/** Serialize a manifest to the normalized `RouteManifestJson` shape — the
+*  same list `xplat routes` emits for file routes, produced here for
+*  programmatic/merged manifests so hosts consume one schema. */
+function manifestToJson(manifest) {
+	return {
+		version: 1,
+		layouts: Object.keys(manifest.layouts).sort(),
+		screens: Object.keys(manifest.screens).sort(),
+		routes: manifest.routes.map((meta) => {
+			const segs = meta.name.split("/");
+			const layoutDirs = manifest.layouts[""] ? [""] : [];
+			for (let i = 1; i < segs.length; i++) {
+				const d = segs.slice(0, i).join("/");
+				if (manifest.layouts[d]) layoutDirs.push(d);
+			}
+			return {
+				name: meta.name,
+				path: meta.name === "index" ? "" : meta.segments.join("/"),
+				params: [...meta.params],
+				...meta.presentation ? { presentation: meta.presentation } : {},
+				...meta.dataMode ? { dataMode: meta.dataMode } : {},
+				layouts: layoutDirs,
+				source: meta.file,
+				loader: !!meta.loader,
+				guard: !!meta.beforeLoad,
+				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
@@ -306,12 +446,27 @@ 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) {
-	const [p, qs] = url.split("?");
+	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);
 	const segs = p.split("/").filter(Boolean);
-	const query = parseQueryString(qs);
+	let query;
+	try {
+		if (!decodeURIComponent(p)) return null;
+		query = parseQueryString(qs);
+	} catch (error) {
+		if (error instanceof URIError) return null;
+		throw error;
+	}
 	if (!segs.length) return null;
 	const finish = (stack, m, fallbackName) => ({
 		stack,
@@ -320,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("/"));
@@ -347,4 +503,4 @@ function layoutChain(layouts, name) {
 	return chain;
 }
 //#endregion
-export { RouteRedirect, buildRoutePath, defineRoutes, deriveRouteManifest, layoutChain, linkPath, matchRoute, matchUrl, mergeRouteManifests, parseQueryString };
+export { RouteRedirect, buildRoutePath, defineRoutes, deriveRouteManifest, layoutChain, linkPath, manifestToJson, matchRoute, matchUrl, mergeRouteManifests, parseQueryString };