akanjs 2.3.6-rc.1 → 2.3.6-rc.3

package/client/capacitor.ts

@@ -15,6 +15,7 @@ export type CapacitorAppModule = {
   App: {
     addListener: (eventName: string, listenerFunc: (...args: unknown[]) => void) => Promise<unknown> | unknown;
     removeAllListeners: () => Promise<void> | void;
+    exitApp?: () => Promise<void> | void;
     getInfo: () => Promise<{ id: string; version: string; build: string; [key: string]: unknown }>;
   };
 };
@@ -86,6 +87,7 @@ export type CapacitorKeyboardModule = {
   Keyboard: {
     show: () => Promise<void> | void;
     hide: () => Promise<void> | void;
+    setResizeMode?: (options: { mode: "body" | "ionic" | "native" | "none" }) => Promise<void> | void;
     addListener: (eventName: string, listenerFunc: (info: CapacitorKeyboardInfo) => void) => Promise<unknown> | unknown;
     removeAllListeners: () => Promise<void> | void;
   };

package/client/csrTypes.ts

@@ -7,15 +7,23 @@ import type { RouterInstance } from "./router";
 import type { ReactFont } from "./types";
 
 export type TransitionType = "none" | "fade" | "bottomUp" | "stack" | "scaleOut";
+export type PageSafeAreaConfig =
+  | boolean
+  | "top"
+  | "bottom"
+  | {
+      top?: boolean;
+      bottom?: boolean;
+      android?: "auto" | "edge-to-edge" | "none";
+    };
 /** Per-page CSR configuration for transition, safe-area, and gesture behavior. */
 export interface PageConfig {
   transition?: TransitionType;
-  safeArea?: boolean | "top" | "bottom";
-  topInset?: boolean | number;
-  /**
-   * @default 48px
-   */
-  bottomInset?: boolean | number;
+  safeArea?: PageSafeAreaConfig;
+  /** Top chrome reservation in px. Use 0 or omit for no reservation. */
+  topInset?: number;
+  /** Bottom chrome reservation in px. Use 0 or omit for no reservation. */
+  bottomInset?: number;
   gesture?: boolean;
   cache?: boolean;
   /**
@@ -97,6 +105,7 @@ export interface RouteRender {
   resolveError?: () => PromiseOrObject<LayoutErrorRender | undefined>;
   resolveHead?: ResolveHead;
   getPageConfig?: () => PromiseOrObject<PageConfig | undefined>;
+  getLayoutPageConfig?: () => PromiseOrObject<PageConfig | undefined>;
 }
 export interface WebAppManifestIcon {
   src: string;
@@ -158,6 +167,7 @@ export interface PageModule {
 }
 export interface LayoutModule {
   default?: LayoutRender;
+  pageConfig?: PageConfig;
   head?: Head;
   metadata?: AkanMetadata;
   generateHead?: GenerateHead;
@@ -176,6 +186,8 @@ export interface LayoutModule {
 export type RouteModule = PageModule | LayoutModule;
 export interface Route {
   PageConfig?: PageConfig;
+  pageConfig?: PageConfig;
+  layoutPageConfig?: PageConfig;
   path: string;
   renderPage?: RouteRender;
   renderLayout?: RouteRender;
@@ -184,6 +196,8 @@ export interface Route {
 
   loader?: () => unknown;
   pageState?: PageState;
+  pageConfigChain?: PageConfig[];
+  explicitPageConfigKeys?: Partial<Record<keyof PageConfig, boolean>>;
 
   children: Map<string, Route>;
 }
@@ -226,8 +240,8 @@ export const defaultPageState: PageState = {
   bottomInset: 0,
   gesture: true,
   cache: false,
-  topSafeAreaColor: "transparent",
-  bottomSafeAreaColor: "transparent",
+  topSafeAreaColor: "var(--color-base-100, Canvas)",
+  bottomSafeAreaColor: "var(--color-base-100, Canvas)",
 };
 
 export interface Location {
@@ -239,9 +253,23 @@ export interface Location {
   pathRoute: PathRoute;
   hash: string;
 }
+export type CsrNavigationPhase = "idle" | "preparing" | "transitioning";
+export type CsrNavigationKind = "push" | "replace" | "back" | "popForward" | "popBack";
+export interface NavigationIntent {
+  id: number;
+  kind: CsrNavigationKind;
+  from: Location;
+  to: Location;
+  scrollTop: number;
+  scrollToTop?: boolean;
+  createdAt: number;
+}
 export interface LocationState {
   location: Location;
   prevLocation: Location | null;
+  pendingLocation?: Location | null;
+  navigationIntent?: NavigationIntent | null;
+  phase: CsrNavigationPhase;
 }
 export interface History {
   type: "initial" | "forward" | "back";
@@ -264,6 +292,9 @@ export interface RouteState {
   clientHeight: number;
   location: Location;
   prevLocation: Location | null;
+  pendingLocation: Location | null;
+  navigationIntent: NavigationIntent | null;
+  phase: CsrNavigationPhase;
   history: RefObject<History>;
   topSafeAreaRef: RefObject<HTMLDivElement | null>;
   bottomSafeAreaRef: RefObject<HTMLDivElement | null>;
@@ -273,6 +304,8 @@ export interface RouteState {
   onBack: RefObject<{ [K in TransitionType]?: () => Promise<void> }>;
   router: RouterInstance;
   pathRoutes: PathRoute[];
+  registerFrameSlot: (path: string, slot: FrameSlotRegistration, bucket?: FrameSlotBucket) => () => void;
+  frameLayout: FrameLayoutState;
 }
 
 export type UseCsrTransition = CsrTransitionStyles & {
@@ -293,11 +326,12 @@ export const useCsr = () => {
 };
 
 export interface PathContextType {
-  pageType: "current" | "prev" | "cached";
+  pageType: "current" | "prev" | "cached" | "pending";
   location: Location;
   prefix?: string;
   gestureEnabled: boolean;
   setGestureEnabled: (enabled: boolean) => void;
+  registerFrameSlot: (slot: FrameSlotRegistration) => () => void;
 }
 export const pathContext = createContext<PathContextType>({} as unknown as PathContextType);
 export const usePathCtx = () => {
@@ -310,12 +344,101 @@ export interface PathRoute {
   pathSegments: string[];
   renderPage: RouteRender;
   pageState: PageState;
+  pageConfigChain?: PageConfig[];
+  explicitPageConfigKeys?: Partial<Record<keyof PageConfig, boolean>>;
   renderRootLayouts: RouteRender[];
   renderLayouts: RouteRender[];
   resolveHead?: ResolveHead;
   isSpecialRoute?: boolean;
 }
 
+export type FrameSlotScope = "page" | "layout";
+export type FrameSlotType = "topInset" | "bottomInset";
+export type FrameSlotBucket = "active" | "pending";
+export type FrameLayer = "page" | "topChrome" | "bottomChrome" | "keyboard" | "overlay";
+export type FrameSlotRole = "topChrome" | "bottomChrome" | "keyboardAccessory";
+export type FramePlatformProfile = "ios" | "android" | "web" | "mobileWeb";
+export interface FrameViewportState {
+  width: number;
+  height: number;
+  visualWidth: number;
+  visualHeight: number;
+  visualOffsetTop: number;
+}
+export interface KeyboardFrameState {
+  height: number;
+  offset: number;
+  visible: boolean;
+  sticky: boolean;
+  frozen?: boolean;
+  source?: "native" | "visualViewport" | "fallback";
+  animationDuration?: number;
+  animationEasing?: string;
+}
+export interface FrameContentViewportState {
+  top: number;
+  bottom: number;
+  height: number;
+}
+export interface KeyboardAccessoryFrameState {
+  top: number;
+  bottom: number;
+  height: number;
+  visible: boolean;
+  slotHeight: number;
+}
+export interface FrameSnapshot {
+  location: Location;
+  pageState: PageState;
+  viewport: FrameViewportState;
+  frameSlots: FrameSlotRegistration[];
+  measuredAt: number;
+}
+export interface TransitionActionContext {
+  plan: TransitionPlan;
+}
+export interface TransitionAction {
+  type: "page" | "topChrome" | "bottomChrome" | "keyboard" | "safeArea" | (string & {});
+  run: (ctx: TransitionActionContext) => Promise<void> | void;
+}
+export interface TransitionPlan {
+  id: number;
+  intent: NavigationIntent;
+  type: TransitionType;
+  direction: "forward" | "back";
+  fromFrame: FrameSnapshot;
+  toFrame: FrameSnapshot;
+  actions: TransitionAction[];
+  duration: number;
+}
+export interface FrameLayerZIndex {
+  page: number;
+  previousPage: number;
+  cachedPage: number;
+  topChrome: number;
+  bottomChrome: number;
+  keyboard: number;
+  overlay: number;
+}
+export interface FrameLayoutState {
+  viewport: FrameViewportState;
+  keyboard: KeyboardFrameState;
+  contentViewport: FrameContentViewportState;
+  keyboardAccessory: KeyboardAccessoryFrameState;
+  platformProfile: FramePlatformProfile;
+  zIndex: FrameLayerZIndex;
+  pageStateByPath: Map<string, PageState>;
+}
+export interface FrameSlotRegistration {
+  scope?: FrameSlotScope;
+  type: FrameSlotType;
+  role?: FrameSlotRole;
+  height?: number;
+  estimatedHeight?: number;
+  source?: "navbar" | "topInset" | "bottomInset" | "bottomTab" | (string & {});
+  cache?: boolean;
+}
+
 export interface LayoutFallbackRoute {
   path: string;
   pathSegments: string[];

package/client/device.ts

@@ -1,5 +1,6 @@
 "use client";
 import type { RefObject } from "react";
+import { debugFrame } from "./frameDebug";
 import type {
   CapacitorDeviceInfo,
   CapacitorHapticsModule,
@@ -114,6 +115,7 @@ export class Device {
         insets: { top: topSafeArea, bottom: bottomSafeArea },
       },
     ] = await Promise.all([CapacitorDevice.getInfo(), CapacitorDevice.getLanguageCode(), SafeArea.getSafeAreaInsets()]);
+    if (info.platform === "ios") await Keyboard.setResizeMode?.({ mode: "none" });
     const predefinedLangPath = window.location.pathname.split("/")[1]?.split("?")[0];
     const predefinedLang = supportLanguages.find((language) => language === predefinedLangPath);
     const device = new Device({
@@ -165,17 +167,24 @@ export class Device {
   }
   listenKeyboardChanged(onKeyboardChanged: (height: number) => void) {
     if (this.info.platform === "web") return;
+    let currentHeight = 0;
+    const emitKeyboardHeight = (event: string, height: number) => {
+      debugFrame("keyboard.event", { event, height, previousHeight: currentHeight });
+      if (currentHeight === height) return;
+      currentHeight = height;
+      onKeyboardChanged(height);
+    };
     void this.#keyboard.addListener("keyboardWillShow", (keyboard: CapacitorKeyboardInfo) => {
-      onKeyboardChanged(keyboard.keyboardHeight);
+      emitKeyboardHeight("keyboardWillShow", keyboard.keyboardHeight);
     });
     void this.#keyboard.addListener("keyboardDidShow", (keyboard: CapacitorKeyboardInfo) => {
-      onKeyboardChanged(keyboard.keyboardHeight);
+      emitKeyboardHeight("keyboardDidShow", keyboard.keyboardHeight);
     });
     void this.#keyboard.addListener("keyboardWillHide", () => {
-      onKeyboardChanged(0);
+      emitKeyboardHeight("keyboardWillHide", 0);
     });
     void this.#keyboard.addListener("keyboardDidHide", () => {
-      onKeyboardChanged(0);
+      emitKeyboardHeight("keyboardDidHide", 0);
     });
   }
   unlistenKeyboardChanged() {

package/client/frameConfig.ts

@@ -0,0 +1,239 @@
+import type { PageConfig, PageSafeAreaConfig, PageState, TransitionType } from "./csrTypes";
+
+export type DevicePlatform = "ios" | "android" | "web" | (string & {});
+export type SafeAreaInsets = { top: number; bottom: number };
+
+export interface ResolvePageStateOptions {
+  configChain?: PageConfig[];
+  path: string;
+  basePath?: string;
+  platform: DevicePlatform;
+  deviceSafeArea: SafeAreaInsets;
+  cssSafeArea?: SafeAreaInsets;
+}
+
+const pageConfigKeys = new Set<keyof PageConfig>([
+  "transition",
+  "safeArea",
+  "topInset",
+  "bottomInset",
+  "gesture",
+  "cache",
+  "rscPatchHeadSafe",
+  "topSafeAreaColor",
+  "bottomSafeAreaColor",
+]);
+const transitionTypes = new Set<TransitionType>(["none", "fade", "bottomUp", "stack", "scaleOut"]);
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+const hasOwn = <Key extends PropertyKey>(value: object, key: Key) => Object.hasOwn(value, key);
+
+export function validatePageConfig(routeKey: string, config?: PageConfig) {
+  if (config === undefined) return;
+  if (!isRecord(config)) throw new Error(`[route-convention] pageConfig in ${routeKey} must be an object.`);
+  const pageConfig = config as PageConfig;
+  for (const key of Object.keys(pageConfig)) {
+    if (!pageConfigKeys.has(key as keyof PageConfig)) {
+      throw new Error(`[route-convention] unsupported pageConfig option "${key}" in ${routeKey}`);
+    }
+  }
+  if (pageConfig.transition !== undefined && !transitionTypes.has(pageConfig.transition)) {
+    throw new Error(`[route-convention] unsupported pageConfig.transition "${pageConfig.transition}" in ${routeKey}`);
+  }
+  if (pageConfig.topInset !== undefined && !isValidInsetValue(pageConfig.topInset)) {
+    throw new Error(`[route-convention] pageConfig.topInset in ${routeKey} must be a non-negative px number.`);
+  }
+  if (pageConfig.bottomInset !== undefined && !isValidInsetValue(pageConfig.bottomInset)) {
+    throw new Error(`[route-convention] pageConfig.bottomInset in ${routeKey} must be a non-negative px number.`);
+  }
+  validateSafeAreaConfig(routeKey, pageConfig.safeArea);
+}
+
+function isValidInsetValue(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+
+function validateSafeAreaConfig(routeKey: string, safeArea?: PageSafeAreaConfig) {
+  if (
+    safeArea === undefined ||
+    typeof safeArea === "boolean" ||
+    safeArea === "top" ||
+    safeArea === "bottom"
+  )
+    return;
+  if (!isRecord(safeArea)) throw new Error(`[route-convention] pageConfig.safeArea in ${routeKey} is invalid.`);
+  for (const key of Object.keys(safeArea)) {
+    if (key !== "top" && key !== "bottom" && key !== "android") {
+      throw new Error(`[route-convention] unsupported pageConfig.safeArea option "${key}" in ${routeKey}`);
+    }
+  }
+  if (safeArea.top !== undefined && typeof safeArea.top !== "boolean") {
+    throw new Error(`[route-convention] pageConfig.safeArea.top in ${routeKey} must be a boolean.`);
+  }
+  if (safeArea.bottom !== undefined && typeof safeArea.bottom !== "boolean") {
+    throw new Error(`[route-convention] pageConfig.safeArea.bottom in ${routeKey} must be a boolean.`);
+  }
+  if (
+    safeArea.android !== undefined &&
+    safeArea.android !== "auto" &&
+    safeArea.android !== "edge-to-edge" &&
+    safeArea.android !== "none"
+  ) {
+    throw new Error(`[route-convention] pageConfig.safeArea.android in ${routeKey} is invalid.`);
+  }
+}
+
+export function mergePageConfigs(configChain: PageConfig[] = []): PageConfig {
+  const merged: PageConfig = {};
+  for (const config of configChain) {
+    for (const key of pageConfigKeys) {
+      const value = config[key];
+      if (value === undefined) continue;
+      if (key === "safeArea" && isRecord(merged.safeArea) && isRecord(value)) {
+        merged.safeArea = { ...merged.safeArea, ...value };
+      } else {
+        (merged as Record<keyof PageConfig, unknown>)[key] = value;
+      }
+    }
+  }
+  return merged;
+}
+
+export function getExplicitPageConfigKeys(configChain: PageConfig[] = []): Partial<Record<keyof PageConfig, boolean>> {
+  const explicitKeys: Partial<Record<keyof PageConfig, boolean>> = {};
+  for (const config of configChain) {
+    for (const key of pageConfigKeys) {
+      if (hasOwn(config, key)) explicitKeys[key] = true;
+    }
+  }
+  return explicitKeys;
+}
+
+export function resolvePageState({
+  configChain = [],
+  path,
+  basePath,
+  platform,
+  deviceSafeArea,
+  cssSafeArea,
+}: ResolvePageStateOptions): PageState {
+  const profile = getPlatformFrameProfile(platform);
+  const routeRole = getRouteRoleFrameDefaults(path, platform, basePath);
+  const config = mergePageConfigs([profile, routeRole, ...configChain]);
+  const explicitKeys = getExplicitPageConfigKeys(configChain);
+  const safeArea = resolveSafeArea({
+    safeArea: config.safeArea,
+    platform,
+    deviceSafeArea,
+    cssSafeArea,
+  });
+  const transition = config.transition ?? "none";
+  return {
+    transition,
+    topSafeArea: safeArea.top,
+    bottomSafeArea: safeArea.bottom,
+    topInset: config.topInset ?? 0,
+    bottomInset: config.bottomInset ?? 0,
+    gesture: explicitKeys.gesture ? (config.gesture ?? false) : transition === "none" ? false : (config.gesture ?? false),
+    cache: config.cache ?? false,
+    topSafeAreaColor: config.topSafeAreaColor ?? "var(--color-base-100, Canvas)",
+    bottomSafeAreaColor: config.bottomSafeAreaColor ?? "var(--color-base-100, Canvas)",
+  };
+}
+
+function getPlatformFrameProfile(platform: DevicePlatform): PageConfig {
+  if (platform === "ios") return { safeArea: true, transition: "stack" };
+  if (platform === "android") return { safeArea: { android: "auto" }, transition: "scaleOut", gesture: false };
+  return { safeArea: false, transition: "none", gesture: false };
+}
+
+function getRouteRoleFrameDefaults(path: string, platform: DevicePlatform, basePath?: string): PageConfig {
+  const normalizedBasePath = basePath?.replace(/^\/+|\/+$/g, "");
+  const depth = path
+    .split("/")
+    .filter(Boolean)
+    .filter((segment) => segment !== "[lang]" && segment !== ":lang")
+    .filter((segment) => (normalizedBasePath ? segment !== normalizedBasePath : true)).length;
+  if (depth <= 1) return { transition: "none", gesture: false, cache: true };
+  return {
+    transition: platform === "ios" ? "stack" : platform === "android" ? "scaleOut" : "none",
+    gesture: platform === "ios",
+  };
+}
+
+function resolveSafeArea({
+  safeArea,
+  platform,
+  deviceSafeArea,
+  cssSafeArea,
+}: {
+  safeArea?: PageSafeAreaConfig;
+  platform: DevicePlatform;
+  deviceSafeArea: SafeAreaInsets;
+  cssSafeArea?: SafeAreaInsets;
+}): SafeAreaInsets {
+  if (safeArea === false) return { top: 0, bottom: 0 };
+  const topEnabled =
+    safeArea === true ||
+    safeArea === "top" ||
+    (isRecord(safeArea) ? safeArea.top !== false : safeArea === undefined && platform !== "web");
+  const bottomEnabled =
+    safeArea === true ||
+    safeArea === "bottom" ||
+    (isRecord(safeArea) ? safeArea.bottom !== false : safeArea === undefined && platform !== "web");
+  if (platform === "android") {
+    const androidMode = isRecord(safeArea) ? (safeArea.android as "auto" | "edge-to-edge" | "none" | undefined) : "auto";
+    if (androidMode === "none") return { top: 0, bottom: 0 };
+    const source =
+      androidMode === "edge-to-edge"
+        ? maxInsets(deviceSafeArea, cssSafeArea)
+        : cssSafeArea && hasInset(cssSafeArea)
+          ? cssSafeArea
+          : null;
+    return {
+      top: topEnabled && source ? source.top : 0,
+      bottom: bottomEnabled && source ? source.bottom : 0,
+    };
+  }
+  return {
+    top: topEnabled ? deviceSafeArea.top : 0,
+    bottom: bottomEnabled ? deviceSafeArea.bottom : 0,
+  };
+}
+
+const hasInset = (insets: SafeAreaInsets) => insets.top > 0 || insets.bottom > 0;
+
+const maxInsets = (a: SafeAreaInsets, b?: SafeAreaInsets): SafeAreaInsets => ({
+  top: Math.max(a.top, b?.top ?? 0),
+  bottom: Math.max(a.bottom, b?.bottom ?? 0),
+});
+
+export function readCssSafeAreaInsets(): SafeAreaInsets {
+  if (typeof window === "undefined") return { top: 0, bottom: 0 };
+  const style = window.getComputedStyle?.(document.documentElement);
+  return {
+    top: readCssPixel(style?.getPropertyValue("--safe-area-inset-top")) || readCssEnvProbe("top"),
+    bottom: readCssPixel(style?.getPropertyValue("--safe-area-inset-bottom")) || readCssEnvProbe("bottom"),
+  };
+}
+
+function readCssEnvProbe(side: "top" | "bottom") {
+  if (typeof document === "undefined") return 0;
+  const probe = document.createElement("div");
+  probe.style.position = "fixed";
+  probe.style.visibility = "hidden";
+  probe.style.pointerEvents = "none";
+  probe.style[side] = `env(safe-area-inset-${side})`;
+  document.documentElement.appendChild(probe);
+  const value = readCssPixel(window.getComputedStyle(probe)[side]);
+  probe.remove();
+  return value;
+}
+
+function readCssPixel(value?: string) {
+  if (!value) return 0;
+  const parsed = Number.parseFloat(value);
+  return Number.isFinite(parsed) ? parsed : 0;
+}

package/client/frameDebug.ts

@@ -0,0 +1,28 @@
+"use client";
+
+type DebugPayload = Record<string, unknown>;
+
+const debugSessionId = Math.random().toString(36).slice(2, 8);
+let debugSeq = 0;
+
+const isFrameDebugEnabled = () => {
+  if (typeof window === "undefined") return false;
+  const windowWithTarget = window as typeof window & { __AKAN_MOBILE_TARGET__?: unknown };
+  const search = new URLSearchParams(window.location.search);
+  return (
+    Boolean(windowWithTarget.__AKAN_MOBILE_TARGET__) ||
+    search.has("akanMobileTarget") ||
+    search.get("akanFrameDebug") === "1" ||
+    window.localStorage.getItem("akan:debug:frame") === "1"
+  );
+};
+
+export function debugFrame(event: string, payload: DebugPayload = {}) {
+  if (!isFrameDebugEnabled()) return;
+  debugSeq += 1;
+  console.info(`[akan:frame:${debugSessionId}:${debugSeq}] ${event}`, {
+    href: window.location.href,
+    now: Math.round(performance.now()),
+    ...payload,
+  });
+}

package/client/index.ts

@@ -4,6 +4,8 @@ export * from "./createFont";
 export * from "./csrTypes";
 export * from "./decorators";
 export * from "./device";
+export * from "./frameConfig";
+export * from "./frameDebug";
 export * from "./locale";
 export * from "./makePageProto";
 export * from "./router";

package/client/router.ts

@@ -91,6 +91,8 @@ const getServerBasePath = (reqPathname: string, lang: string, headerBasePath: st
 
 declare global {
   var __AKAN_ROUTER__: Router | undefined;
+  var __AKAN_DEV_SYNC_NAVIGATION__: ((href: string, kind: "push" | "replace" | "back" | "pop") => void) | undefined;
+  var __AKAN_DEV_SYNC_NAVIGATION_APPLYING__: boolean | undefined;
 }
 
 export const getPathInfo = (requestUrl: string, lang: string, prefix: string) => {
@@ -232,14 +234,21 @@ class Router {
     Logger.log(`pathChange-start:${path}${hash ? `#${hash}` : ""}`);
     window.parent.postMessage({ type: "pathChange", path, pathname, hash }, "*");
   }
+  #postDevSyncNavigation(kind: "push" | "replace", href: string) {
+    if (globalThis.__AKAN_DEV_SYNC_NAVIGATION_APPLYING__) return;
+    const { path, search, hash } = this.#getPathInfo(href);
+    globalThis.__AKAN_DEV_SYNC_NAVIGATION__?.(`${path}${search ? `?${search}` : ""}${hash ? `#${hash}` : ""}`, kind);
+  }
   push(href: string, routeOptions?: RouteOptions) {
     this.#checkInitialized();
     this.#instance.push(href, routeOptions);
+    this.#postDevSyncNavigation("push", href);
     return undefined as never;
   }
   replace(href: string, routeOptions?: RouteOptions) {
     this.#checkInitialized();
     this.#instance.replace(href, routeOptions);
+    this.#postDevSyncNavigation("replace", href);
     return undefined as never;
   }
   back(routeOptions?: RouteOptions) {

package/fetch/requestStorage.ts

@@ -15,6 +15,7 @@ export interface AkanDynamicUsage {
 export interface AkanRequestStore {
   request: Request;
   theme?: AkanTheme;
+  frameState?: unknown;
   queryCache: Map<string, Promise<unknown>>;
   policy: AkanRequestPolicy;
   dynamicUsage: AkanDynamicUsage;
@@ -91,6 +92,16 @@ export function getRequestTheme(): AkanTheme | undefined {
   return getRequestStore()?.theme;
 }
 
+export function setRequestFrameState(frameState: unknown): void {
+  const store = getRequestStore();
+  if (!store) return;
+  store.frameState = frameState;
+}
+
+export function getRequestFrameState<FrameState = unknown>(): FrameState | undefined {
+  return getRequestStore()?.frameState as FrameState | undefined;
+}
+
 export function pushRequestFallback(storeOrRequest: Request | AkanRequestStore): () => void {
   globalThis.__AKAN_REQUEST_FALLBACK_STACK__ ??= [];
   const stack = globalThis.__AKAN_REQUEST_FALLBACK_STACK__;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "2.3.6-rc.1",
+  "version": "2.3.6-rc.3",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {
@@ -197,7 +197,7 @@
     "chance": "^1.1.13",
     "cordova-plugin-purchase": "^13.16.0",
     "croner": "^10.0.1",
-    "daisyui": "^5.5.20",
+    "daisyui": "5.5.23",
     "ioredis": "^5.10.1",
     "mermaid": "^11.15.0",
     "postgres": "^3.4.9",