@octane-xplat/ui 0.6.0 → 0.7.0

package/dist/native/ios/UITableView.ios.tsrx.js

@@ -1,6 +1,7 @@
 import { cx } from "../cx.js";
-import { ActivityIndicator } from "../ActivityIndicator.native.tsrx.js";
-import { createPullToRefresh } from "../refresh.native.js";
+import { applyEscapeProps } from "../escape-props.js";
+import { ActivityIndicator } from "../ActivityIndicator.tsrx.js";
+import { createPullToRefresh } from "../refresh.js";
 import { defineUniversalComponent, hookSlots, memo, universalComponent, universalIf, universalPlan, universalProps, universalValue, useEffect, useRef } from "@nativescript-community/octane";
 import { ScrollView } from "@nativescript/core";
 //#region src/ios/UITableView.ios.tsrx
@@ -102,6 +103,7 @@ var UITableViewInner = defineUniversalComponent("nativescript", function UITable
 			"ref",
 			(v) => {
 				lv.current = v;
+				applyEscapeProps(v, props);
 			}
 		],
 		[
@@ -147,7 +149,7 @@ var UITableViewInner = defineUniversalComponent("nativescript", function UITable
 		["spread", props.ios]
 	])]);
 }, { "module": "@nativescript-community/octane" });
-var MemoListView = memo(UITableViewInner, (a, b) => a.items === b.items && a.className === b.className && a.style === b.style && a.id === b.id && a.estimatedItemHeight === b.estimatedItemHeight && a.onEndReached === b.onEndReached && a.ios === b.ios && a.refresh === b.refresh);
+var MemoListView = memo(UITableViewInner, (a, b) => a.items === b.items && a.className === b.className && a.style === b.style && a.id === b.id && a.estimatedItemHeight === b.estimatedItemHeight && a.onEndReached === b.onEndReached && a.ios === b.ios && a.modifiers === b.modifiers && a.refresh === b.refresh);
 var UITableView = defineUniversalComponent("nativescript", function UITableView(props) {
 	const refreshCapable = props.onRefresh != null || props.refreshing != null;
 	const cfg = useRef({}, _h$2);
@@ -205,6 +207,11 @@ var UITableView = defineUniversalComponent("nativescript", function UITableView(
 						"ios",
 						props.ios
 					],
+					[
+						"set",
+						"modifiers",
+						props.modifiers
+					],
 					[
 						"set",
 						"refresh",
@@ -259,6 +266,11 @@ var UITableView = defineUniversalComponent("nativescript", function UITableView(
 					"set",
 					"ios",
 					props.ios
+				],
+				[
+					"set",
+					"modifiers",
+					props.modifiers
 				]
 			]))]);
 		})]);

package/dist/native/ios/icon.ios.js

@@ -0,0 +1,7 @@
+//#region src/ios/icon.ios.ts
+/** Selector for glyphs used by iOS-authentic widgets; the shared root Icon is unchanged. */
+var Icon = { select(choice) {
+	return choice.ios.startsWith("sys://") ? choice.ios : `sys://${choice.ios}`;
+} };
+//#endregion
+export { Icon };

package/dist/native/ios/index.js

@@ -8,4 +8,6 @@ import { openModal } from "./openModal.ios.js";
 import { SideDrawer } from "./SideDrawer.ios.tsrx.js";
 import { LiquidGlass } from "./LiquidGlass.ios.tsrx.js";
 import { LiquidGlassContainer } from "./LiquidGlassContainer.ios.tsrx.js";
-export { LiquidGlass, LiquidGlassContainer, SideDrawer, UIActivityIndicatorView, UIModal, UISlider, UISwitch, UITabBar, UITableView, openModal };
+import { Icon } from "./icon.ios.js";
+import { modifier } from "../modifier-factories.js";
+export { Icon, LiquidGlass, LiquidGlassContainer, SideDrawer, UIActivityIndicatorView, UIModal, UISlider, UISwitch, UITabBar, UITableView, modifier, openModal };

package/dist/native/ios/openModal.ios.js

@@ -1,5 +1,5 @@
 import { applyThemeClasses } from "../theme/theme-scheme.js";
-import { modalPresenter } from "../modal-presenter.native.js";
+import { modalPresenter } from "../modal-presenter.mobile.js";
 import { createNativeScriptRoot } from "@nativescript-community/octane";
 import { Frame, GridLayout } from "@nativescript/core";
 //#region src/ios/openModal.ios.ts

package/dist/native/keyboard-inset.mobile.js

@@ -0,0 +1,66 @@
+import { Application } from "@nativescript/core";
+//#region src/keyboard-inset.mobile.ts
+var bound = /* @__PURE__ */ new Set();
+var inset = 0;
+var wired = false;
+var apply = () => {
+	bound.forEach((host) => {
+		host.translateY = -inset;
+	});
+};
+var wireIos = () => {
+	if (wired) return;
+	wired = true;
+	NSNotificationCenter.defaultCenter.addObserverForNameObjectQueueUsingBlock(UIKeyboardWillChangeFrameNotification, null, NSOperationQueue.mainQueue, (note) => {
+		const raw = note.userInfo.objectForKey(UIKeyboardFrameEndUserInfoKey);
+		const boxed = raw?.CGRectValue;
+		const frame = typeof boxed === "function" ? raw.CGRectValue() : boxed ?? raw;
+		inset = Math.max(0, UIScreen.mainScreen.bounds.size.height - (frame?.origin?.y ?? UIScreen.mainScreen.bounds.size.height));
+		apply();
+	});
+};
+/** Lift a bottom-anchored overlay host above the software keyboard.
+*  iOS: a shared UIKeyboardWillChangeFrame observer tracks the inset and
+*  translateY shifts the host — reliable on popup views regardless of how
+*  the RootLayout passes margins through. The current inset is applied at
+*  bind time so hosts opened over an already-visible keyboard still lift.
+*  Android: when the window runs `adjustResize` (KeyboardAvoiding sets it)
+*  the RootLayout resizes and the host follows on its own; otherwise the
+*  decor view's IME inset supplies the lift. Returns an unbind that
+*  restores the transform — call it when the host detaches. */
+function bindBottomInsetToKeyboard(host) {
+	if (Application.ios) {
+		wireIos();
+		bound.add(host);
+		host.translateY = -inset;
+		return () => {
+			bound.delete(host);
+			host.translateY = 0;
+		};
+	}
+	if (Application.android) {
+		const nativeWindow = Application.android.foregroundActivity?.window;
+		if (!nativeWindow) return () => {};
+		const params = globalThis.android?.view?.WindowManager?.LayoutParams;
+		if (!params) return () => {};
+		if ((nativeWindow.attributes.softInputMode & params.SOFT_INPUT_MASK_ADJUST) === params.SOFT_INPUT_ADJUST_RESIZE) return () => {};
+		const ViewCompat = globalThis.androidx?.core?.view?.ViewCompat;
+		const WindowInsetsCompat = globalThis.androidx?.core?.view?.WindowInsetsCompat;
+		if (!ViewCompat || !WindowInsetsCompat) return () => {};
+		const decorView = nativeWindow.decorView;
+		const listener = new ViewCompat.OnApplyWindowInsetsListener({ onApplyWindowInsets: (v, insets) => {
+			const ime = insets.getInsets(WindowInsetsCompat.Type.ime()).bottom;
+			const nav = insets.getInsets(WindowInsetsCompat.Type.systemBars()).bottom;
+			host.translateY = -Math.max(0, ime - nav);
+			return insets;
+		} });
+		ViewCompat.setOnApplyWindowInsetsListener(decorView, listener);
+		return () => {
+			host.translateY = 0;
+			ViewCompat.setOnApplyWindowInsetsListener(decorView, null);
+		};
+	}
+	return () => {};
+}
+//#endregion
+export { bindBottomInsetToKeyboard };

package/dist/native/{layout-child.native.js → layout-child.js}

@@ -1,4 +1,4 @@
-//#region src/layout-child.native.ts
+//#region src/layout-child.ts
 var FLEX_JUSTIFY = {
 	start: "flex-start",
 	end: "flex-end"

package/dist/native/{modal-presenter.native.js → modal-presenter.mobile.js}

@@ -1,4 +1,4 @@
-//#region src/modal-presenter.native.ts
+//#region src/modal-presenter.mobile.ts
 /** Resolve the view `showModal` should present from: the frame's current
 *  page while it's live, else the frame itself. During push/pop churn
 *  `currentPage` can still point at a page that already left the window —

package/dist/native/modifier-factories.js

@@ -0,0 +1,24 @@
+//#region src/modifier-factories.ts
+var style = (values) => ({
+	type: "style",
+	values
+});
+/** Serializable modifier factories for the platform-authentic UI subpaths. */
+var modifier = {
+	background: (color) => style({ backgroundColor: color }),
+	cornerRadius: (radius) => style({ borderRadius: radius }),
+	opacity: (value) => style({ opacity: value }),
+	padding: (value) => style({ padding: value }),
+	frame: (width, height) => style({
+		width,
+		height
+	}),
+	style,
+	nativeProperty: (name, value) => ({
+		type: "property",
+		name,
+		value
+	})
+};
+//#endregion
+export { modifier };

package/dist/native/native/index.js

@@ -1,4 +1,4 @@
-import { findInRootLayouts, rootLayoutFor, topRootLayout } from "../root-layout.native.js";
-import { layoutsForRoute } from "../route.native.js";
-import { sheetHost } from "../sheet-service.native.js";
+import { findInRootLayouts, rootLayoutFor, topRootLayout } from "../root-layout.mobile.js";
+import { layoutsForRoute } from "../route.js";
+import { sheetHost } from "../sheet-service.js";
 export { findInRootLayouts, layoutsForRoute, rootLayoutFor, sheetHost, topRootLayout };

package/dist/native/octane-client-build.json

@@ -1,6 +1,6 @@
 {
   "version": 1,
-  "buildId": "29582229-3893-4486-bd72-49102bb0634c",
+  "buildId": "b28db075-a347-4f50-bc15-416a0351d4e3",
   "mode": "production",
   "capabilities": {
     "independentHydration": false

package/dist/native/{pan.native.tsrx.js → pan.tsrx.js}

@@ -1,6 +1,6 @@
 import { hookSlots, useCallback, useRef } from "@nativescript-community/octane";
 import { Utils } from "@nativescript/core";
-//#region src/pan.native.tsrx
+//#region src/pan.tsrx
 var _hs$ = /* @__PURE__ */ hookSlots(2);
 var _h$0 = /* @__PURE__ */ Symbol(_hs$);
 var _h$1 = /* @__PURE__ */ Symbol(_hs$ + 1);

package/dist/native/{platform.native.js → platform.js}

@@ -1,10 +1,10 @@
-//#region src/platform.native.ts
+//#region src/platform.ts
 /** Compile-time platform flag — `true` in every NativeScript build.
-*  Prefer `.web`/`.native` leaves for real divergence; `isNative` covers
+*  Prefer `.web`/unsuffixed native defaults leaves for real divergence; `isNative` covers
 *  the render-time cases (conditional JSX, prop selection) where a whole
 *  leaf file is heavier than the difference. For OS-level splits use
 *  `.ios`/`.android` leaves or `isIOS`/`isAndroid` from @nativescript/core
-*  inside `.native` code. */
+*  inside native-default code. */
 var isNative = true;
 //#endregion
 export { isNative };

package/dist/native/{platformProps.native.js → platformProps.js}

@@ -1,10 +1,12 @@
+import { applyNativeModifiers } from "./apply-native-modifiers.native.js";
 import { isAndroid, isIOS } from "@nativescript/core";
-//#region src/platformProps.native.ts
+//#region src/platformProps.ts
 /** Apply the matching native escape-hatch bag after the primitive's props. */
 function applyNativeProps(el, props) {
 	if (!el) return;
 	const bag = isIOS ? props.ios : isAndroid ? props.android : void 0;
 	if (bag) Object.assign(el, bag);
+	applyNativeModifiers(el, props.modifiers);
 }
 //#endregion
 export { applyNativeProps };

package/dist/native/{refresh.native.js → refresh.js}

@@ -1,6 +1,6 @@
 import { dampenPull } from "./refresh-metrics.js";
 import { isIOS } from "@nativescript/core";
-//#region src/refresh.native.ts
+//#region src/refresh.ts
 var PAN_ENDED = /* @__PURE__ */ new Set([0, 3]);
 var DOCK_ANIM_MS = 180;
 function makeInsets(top, left, bottom, right) {

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

@@ -1,5 +1,5 @@
 import { RootLayout, getRootLayout } from "@nativescript/core";
-//#region src/root-layout.native.ts
+//#region src/root-layout.mobile.ts
 var registry = [];
 /** Called by the Screen leaf's <rootlayout> onLoaded/onUnloaded. */
 function registerRootLayout(rl) {
@@ -17,7 +17,7 @@ function topRootLayout() {
 	return registry[registry.length - 1] ?? getRootLayout();
 }
 /** Resolve the RootLayout enclosing `view` by walking the native parent
-*  chain — the screen shell is a RootLayout (Screen.native), so the first
+*  chain — the screen shell is a RootLayout (Screen), so the first
 *  RootLayout ancestor IS the current page's overlay host. Falls back to
 *  the top registry entry when the component renders outside any Screen. */
 function rootLayoutFor(view) {

package/dist/native/route-host.mobile.js

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

package/dist/native/route-table.js

@@ -1,13 +1,12 @@
 //#region src/route-table.ts
 var EXT = /\.(tsrx|tsx|ts|mts|cts|js|mjs|cjs|jsx)$/;
-var SUFFIX = /\.(web|native|ios|android)$/;
+var SUFFIX = /\.(web|mobile|ios|android|macos|windows|linux)$/;
 var PARAM = /^\[(.+)\]$/;
 var PRESENT = /\+(modal|fade|push)$/;
 /** 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. */
 var RouteRedirect = class extends Error {
-	route;
 	constructor(route) {
 		super("route redirect");
 		this.route = route;
@@ -102,7 +101,109 @@ function deriveRouteManifest(files, prefer, dir = "app") {
 		routes.push(meta);
 		if (meta.loader) loaders[meta.name] = meta.loader;
 	}
-	routes.sort((a, b) => 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));
+	routes.sort(bySpecificity);
+	return {
+		screens,
+		routes,
+		layouts,
+		loaders
+	};
+}
+/** Match-order comparator: static segments (2) outrank params (1), 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);
+}
+/** 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. */
+function specSegments(path) {
+	const segs = path.split("/").filter(Boolean).map((s) => {
+		const p = PARAM.exec(s);
+		return p ? ":" + p[1] : s;
+	});
+	if (segs[segs.length - 1] === "index") segs.pop();
+	return segs;
+}
+var mergeWarned = /* @__PURE__ */ new Set();
+/** Build a manifest from app data rather than the route dir — the
+*  programmatic half of the route contract (host frameworks derive specs
+*  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. */
+function defineRoutes(input) {
+	const set = Array.isArray(input) ? { routes: input } : input;
+	const specs = set.routes;
+	const extra = set.layouts;
+	const screens = {};
+	const layouts = {};
+	const metas = /* @__PURE__ */ new Map();
+	const warned = /* @__PURE__ */ new Set();
+	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}'`);
+		layouts[dir] = layout;
+	}
+	for (const spec of specs) {
+		const segments = specSegments(spec.path);
+		const name = segments.join("/") || "index";
+		const meta = {
+			name,
+			segments,
+			params: segments.filter((s) => s.startsWith(":")).map((s) => s.slice(1)),
+			file: spec.source ?? `programmatic:${spec.path}`,
+			presentation: spec.presentation
+		};
+		if (spec.loader) meta.loader = spec.loader;
+		if (spec.beforeLoad) meta.beforeLoad = spec.beforeLoad;
+		if (spec.head) meta.head = spec.head;
+		if (metas.has(name) && !warned.has(name)) {
+			warned.add(name);
+			console.warn(`[octane-xplat] route '${name}' is defined twice — keeping the later spec (${meta.file})`);
+		}
+		if (typeof spec.screen !== "function") {
+			console.warn(`[octane-xplat] route '${name}' has no component — 'screen' must be a component function, not a module`);
+			continue;
+		}
+		metas.set(name, meta);
+		screens[name] = spec.screen;
+	}
+	const routes = [...metas.values()].sort(bySpecificity);
+	const loaders = {};
+	for (const meta of routes) if (meta.loader) loaders[meta.name] = meta.loader;
+	return {
+		screens,
+		routes,
+		layouts,
+		loaders
+	};
+}
+/** Compose manifests into one — file-derived base plus any number of
+*  programmatic sets (`registerRoutes(mergeRouteManifests(fromDir, dynamic))`).
+*  Registration order is precedence: on a same-name collision the later
+*  manifest's route wins and the loser's loader/beforeLoad/head go with it —
+*  a warn fires once per colliding name. `layouts` merge key-wise the same
+*  way. `matchRoute` order is rebuilt by specificity after the merge. */
+function mergeRouteManifests(...manifests) {
+	const screens = {};
+	const layouts = {};
+	const winners = /* @__PURE__ */ new Map();
+	for (const m of manifests) {
+		Object.assign(layouts, m.layouts);
+		Object.assign(screens, m.screens);
+		for (const meta of m.routes) {
+			const prev = winners.get(meta.name);
+			if (prev && !mergeWarned.has(meta.name)) {
+				mergeWarned.add(meta.name);
+				console.warn(`[octane-xplat] route '${meta.name}' is defined by both ${prev.file} and ${meta.file} — keeping ${meta.file}`);
+			}
+			winners.set(meta.name, meta);
+		}
+	}
+	const routes = [...winners.values()].sort(bySpecificity);
+	const loaders = {};
+	for (const meta of routes) if (meta.loader) loaders[meta.name] = meta.loader;
 	return {
 		screens,
 		routes,
@@ -246,4 +347,4 @@ function layoutChain(layouts, name) {
 	return chain;
 }
 //#endregion
-export { RouteRedirect, buildRoutePath, deriveRouteManifest, layoutChain, linkPath, matchRoute, matchUrl, parseQueryString };
+export { RouteRedirect, buildRoutePath, defineRoutes, deriveRouteManifest, layoutChain, linkPath, matchRoute, matchUrl, mergeRouteManifests, parseQueryString };

package/dist/native/{route.native.js → route.js}

@@ -1,11 +1,12 @@
-import { getStack, onStackRegistered, stackEntries } from "./stacks.native.js";
-import { RouteRedirect, buildRoutePath, layoutChain, linkPath, matchUrl } from "./route-table.js";
-import { RouteHost } from "./RouteHost.native.tsrx.js";
-import { modalPresenter } from "./modal-presenter.native.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 { createNativeScriptRoot } from "@nativescript-community/octane";
 import { Application, GridLayout, Page } from "@nativescript/core";
-import { hookSlots as hookSlots$1, useSyncExternalStore as useSyncExternalStore$1 } from "octane";
-//#region src/route.native.ts
+import { hookSlots as hookSlots$1, useSyncExternalStore as useSyncExternalStore$1 } from "octane/universal/native";
+//#region src/route.ts
 /** Native twin of route.web — same Route contract over Frame/Page stacks.
 *  `pushRoute` resolves a stack ('root' = the app's root Frame — an
 *  explicit registerStack('root') or, by default, the Frame returned by
@@ -22,10 +23,24 @@ import { hookSlots as hookSlots$1, useSyncExternalStore as useSyncExternalStore$
 *  - named stacks register via `TabSpec.stack` or `registerStack`.
 *  Every drop path warns loudly — silent no-ops are how apps ship a
 *  default route on native while working fine on web. */
+var baseManifest = {
+	screens: {},
+	routes: [],
+	layouts: {}
+};
+var dynamicManifests = [];
 var screens = {};
 var routes = [];
 var routeLayouts = {};
 var routeLoaders = {};
+function rebuildRegistry() {
+	const merged = mergeRouteManifests(baseManifest, ...dynamicManifests);
+	screens = merged.screens;
+	routes = merged.routes;
+	routeLayouts = merged.layouts;
+	routeLoaders = merged.loaders ?? {};
+	emit();
+}
 /** Register the app's name → screen table (call once, from the shared
 *  routes module). Native `pushRoute` resolves `route.name` through it;
 *  on web the table feeds `screenFor` for outlets without a
@@ -33,16 +48,28 @@ var routeLoaders = {};
 *  for parity — the web leaf matches URLs through it; native navigation
 *  is name+params and only needs the table. */
 function registerScreens(table, manifest) {
-	screens = table;
-	routes = manifest ?? [];
+	baseManifest = {
+		...baseManifest,
+		screens: table,
+		routes: manifest ?? []
+	};
+	rebuildRegistry();
 	ensureBackWired();
 }
 /** One-call registration for route-dir apps — screens + URL patterns +
 *  layouts all come from deriveRouteManifest. */
 function registerRoutes(manifest) {
-	registerScreens(manifest.screens, manifest.routes);
-	routeLayouts = manifest.layouts ?? {};
-	routeLoaders = manifest.loaders ?? {};
+	baseManifest = manifest;
+	rebuildRegistry();
+	ensureBackWired();
+}
+/** Layer a programmatic manifest (from `defineRoutes`) over the registered
+*  routes — same-name entries win over the base with a warn, so a host
+*  framework can override a file route deliberately. Registered layers
+*  survive later registerRoutes re-registration (e.g. routes.gen HMR). */
+function addRoutes(manifest) {
+	dynamicManifests.push(manifest);
+	rebuildRegistry();
 }
 function layoutsForRoute(name) {
 	return layoutChain(routeLayouts, name);
@@ -82,6 +109,14 @@ function resolveStack(stack) {
 	if (frame) trackFrame(frame);
 	return frame;
 }
+/** TabViewItem-hosted frames report isLoaded=false after tab-selection
+*  lifecycle churn; without re-arming, the nav queue defers pushes AND pops
+*  forever (iOS strand of #11444 — goBack also gates on isLoaded via
+*  _processNextNavigationEntry). callLoaded is idempotent once the flag
+*  holds, so run it before every navigate/goBack on a registered frame. */
+function rearmFrameLoaded(frame) {
+	if (!frame.isLoaded) frame.callLoaded?.();
+}
 onStackRegistered((_name, frame) => {
 	trackFrame(frame);
 	ensureBackWired();
@@ -263,7 +298,7 @@ function commitRoute(r) {
 		warnOnce("stack:" + r.stack, r.stack === "root" ? `pushRoute('${r.name}') dropped — no root Frame. Boot with a Frame as the app root (Application.run create() returning new Frame) or call registerStack('root', frame).` : `pushRoute('${r.name}') dropped — no stack '${r.stack}' is registered. Named stacks come from TabSpec.stack on <Tabs> or registerStack('${r.stack}', frame).`);
 		return;
 	}
-	if (!frame.isLoaded) frame.callLoaded?.();
+	rearmFrameLoaded(frame);
 	const props = {
 		...r.params,
 		...contextFor(r),
@@ -378,6 +413,7 @@ function popRoute(stack = "root") {
 		warnOnce("pop:" + stack, `popRoute('${stack}') dropped — no such stack is registered.`);
 		return;
 	}
+	rearmFrameLoaded(frame);
 	frame.goBack();
 }
 /** Route stamped on a stack's current page, or null at its base page. */
@@ -464,4 +500,4 @@ var _h$0 = /* @__PURE__ */ Symbol(_hs$);
 var _h$1 = /* @__PURE__ */ Symbol(_hs$ + 1);
 var _h$2 = /* @__PURE__ */ Symbol(_hs$ + 2);
 //#endregion
-export { addBackInterceptor, canGoBack, currentModalRoute, currentRoute, hrefFor, layoutsForRoute, popRoute, pushDeepLink, pushRoute, redirect, registerRoutes, registerScreens, routeFor, routeStacks, screenFor, useCanGoBack, useModalRoute, useRoute };
+export { addBackInterceptor, addRoutes, canGoBack, currentModalRoute, currentRoute, hrefFor, layoutsForRoute, popRoute, pushDeepLink, pushRoute, redirect, registerRoutes, registerScreens, routeFor, routeStacks, screenFor, useCanGoBack, useModalRoute, useRoute };

package/dist/native/safeAreaInsets.tsrx.js

@@ -0,0 +1,67 @@
+import { hookSlots, useEffect, useState } from "@nativescript-community/octane";
+import { Application, Screen } from "@nativescript/core";
+//#region src/safeAreaInsets.tsrx
+var _hs$ = /* @__PURE__ */ hookSlots(2);
+var _h$0 = /* @__PURE__ */ Symbol(_hs$);
+var _h$1 = /* @__PURE__ */ Symbol(_hs$ + 1);
+function androidActivity() {
+	return Application.android?.foregroundActivity ?? Application.android?.startActivity;
+}
+function readAndroidInsets() {
+	const insets = (androidActivity()?.getWindow?.()?.getDecorView?.())?.getRootWindowInsets?.();
+	if (!insets) return {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0
+	};
+	const scale = Screen.mainScreen.scale || 1;
+	if (android.os.Build.VERSION.SDK_INT >= 30) {
+		const systemBars = android.view.WindowInsets.Type.systemBars() | android.view.WindowInsets.Type.displayCutout();
+		const i = insets.getInsets(systemBars);
+		return {
+			top: i.top / scale,
+			right: i.right / scale,
+			bottom: i.bottom / scale,
+			left: i.left / scale
+		};
+	}
+	return {
+		top: insets.getSystemWindowInsetTop() / scale,
+		right: insets.getSystemWindowInsetRight() / scale,
+		bottom: insets.getSystemWindowInsetBottom() / scale,
+		left: insets.getSystemWindowInsetLeft() / scale
+	};
+}
+function measure() {
+	const insets = (Application.ios?.rootController?.view)?.safeAreaInsets;
+	if (insets) return {
+		top: insets.top,
+		right: insets.right,
+		bottom: insets.bottom,
+		left: insets.left
+	};
+	if (Application.android) return readAndroidInsets();
+	return {
+		top: 0,
+		right: 0,
+		bottom: 0,
+		left: 0
+	};
+}
+function useSafeAreaInsets() {
+	const [insets, setInsets] = useState(measure, _h$0);
+	useEffect(() => {
+		const update = () => setInsets(measure());
+		Application.on(Application.orientationChangedEvent, update);
+		Application.on(Application.resumeEvent, update);
+		update();
+		return () => {
+			Application.off(Application.orientationChangedEvent, update);
+			Application.off(Application.resumeEvent, update);
+		};
+	}, [], _h$1);
+	return insets;
+}
+//#endregion
+export { useSafeAreaInsets };