@finesoft/front 0.2.0 → 0.3.0

package/dist/{server-data-DQzknR97.d.mts → server-data-HVSgxEac.d.mts}

@@ -621,6 +621,16 @@ declare class Router {
   private parseUrl;
 }
 //#endregion
+//#region ../core/src/router/types.d.ts
+/**
+ * Router 共享类型
+ *
+ * `RouteParams` 是路由参数（path + query 经 codec 转换后）的统一形状，
+ * 同时也是 Intent.params、NavigationContext.params 与 LeafNode.params 的共同类型。
+ */
+/** 路由参数：键为参数名，值为 codec 转换后的任意类型（string / number / boolean …）。 */
+type RouteParams = Record<string, unknown>;
+//#endregion
 //#region ../core/src/router/params/primitives.d.ts
 interface StrOptions {
   minLength?: number;
@@ -1117,6 +1127,585 @@ declare function pipeAsync<A, B, C, D>(m1: AsyncMapper<A, B>, m2: AsyncMapper<B,
  */
 declare function mapEach<TInput, TOutput>(mapper: Mapper<TInput, TOutput>): Mapper<TInput[], TOutput[]>;
 //#endregion
+//#region ../core/src/navigation/types.d.ts
+/**
+ * 导航树里 `Page` 的别名 —— 运行期 dispatch 始终产出 `BasePage`，
+ * 但导航层对内容无关，字段语义由应用决定。
+ */
+type Page = BasePage;
+/** 导航节点 Kind 常量 */
+declare const NAVIGATION_NODE_KINDS: {
+  readonly LEAF: "leaf";
+  readonly STACK: "stack";
+  readonly TABS: "tabs";
+  readonly SPLIT: "split";
+};
+/** 所有导航节点 Kind 的联合类型 */
+type NavigationNodeKind = (typeof NAVIGATION_NODE_KINDS)[keyof typeof NAVIGATION_NODE_KINDS];
+/** 叶子：一个具体导航目标 */
+interface LeafNode {
+  readonly kind: typeof NAVIGATION_NODE_KINDS.LEAF;
+  readonly intent: string;
+  readonly params: RouteParams;
+}
+/** 栈：有序路径，entries[0]=根，末尾=栈顶（可见） */
+interface StackNode {
+  readonly kind: typeof NAVIGATION_NODE_KINDS.STACK;
+  readonly entries: readonly NavigationNode[];
+}
+/** Tabs：并列分支 + 当前激活键 + 稳定顺序；仅激活分支可见 */
+interface TabsNode {
+  readonly kind: typeof NAVIGATION_NODE_KINDS.TABS;
+  readonly active: string;
+  readonly order: readonly string[];
+  readonly branches: Readonly<Record<string, NavigationNode>>;
+}
+/** Split 列：列 id + 该列内容（undefined = 尚未选择） */
+interface SplitColumn {
+  readonly id: string;
+  readonly content: NavigationNode | undefined;
+}
+/**
+ * Split 列可见性，对标 SwiftUI `NavigationSplitViewVisibility`。
+ *
+ * 这是**可绑定 / 可序列化 / 可恢复的导航状态**（不是渲染样式）：它决定哪些列算「可见」，
+ * 进而影响 `collectVisibleDestinations` 与 SSR 预取——例如深链到 `detailOnly` 时服务端只预取 detail 列。
+ *
+ * - `automatic`（缺省）：框架不裁剪，所有有内容的列都可见（SSR 端无视口信息时的安全默认；客户端再按视口自适应）。
+ * - `all`：显式所有列可见（语义同 automatic 的全列）。
+ * - `doubleColumn`：仅首列 + 末列可见（三列时隐藏中间 content 列）。
+ * - `detailOnly`：仅末列（detail）可见。
+ *
+ * 注意：compact 视口塌缩成单栈（SwiftUI 的 `preferredCompactColumn`）是视口反应式的纯渲染决策，
+ * 框架不建模，交给应用按 `getPlatform()` / 视口自行处理。
+ */
+declare const SPLIT_VISIBILITIES: {
+  readonly AUTOMATIC: "automatic";
+  readonly ALL: "all";
+  readonly DOUBLE_COLUMN: "doubleColumn";
+  readonly DETAIL_ONLY: "detailOnly";
+};
+/** Split 列可见性的联合类型 */
+type SplitVisibility = (typeof SPLIT_VISIBILITIES)[keyof typeof SPLIT_VISIBILITIES];
+/**
+ * Split：多列并存，列间通过 selectColumn 设置后续列内容。
+ * `visibility` 决定哪些列算可见（缺省 `automatic` = 全列），是可序列化的导航状态。
+ */
+interface SplitNode {
+  readonly kind: typeof NAVIGATION_NODE_KINDS.SPLIT;
+  readonly columns: readonly SplitColumn[];
+  readonly visibility?: SplitVisibility;
+}
+/** 所有导航节点的联合类型 */
+type NavigationNode = LeafNode | StackNode | TabsNode | SplitNode;
+/** 指向树中某节点的路径（从根到目标）的一步 */
+type NavigationPathStep = {
+  readonly kind: "stack-entry";
+  readonly index: number;
+} | {
+  readonly kind: "tab";
+  readonly key: string;
+} | {
+  readonly kind: "column";
+  readonly id: string;
+};
+/** 指向树中某节点的完整路径（从根到目标） */
+type NavigationPath = readonly NavigationPathStep[];
+/** 单个可见目标的解析结果 */
+interface ResolvedDestination {
+  readonly intent: string;
+  readonly params: RouteParams;
+  readonly page: Page;
+  readonly status?: number;
+}
+/** 导航快照：当前树 + 所有可见目标解析结果（顺序与 collectVisibleDestinations 一致） */
+interface NavigationSnapshot {
+  readonly tree: NavigationNode;
+  readonly destinations: readonly ResolvedDestination[];
+}
+/** 错误类型：序列化 / 路径 / 操作非法时抛出 */
+declare class NavigationError extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region ../core/src/navigation/nodes.d.ts
+/** 构造叶子节点（一个具体导航目标）。 */
+declare function leaf(intent: string, params?: RouteParams): LeafNode;
+/**
+ * 构造栈节点。
+ * 接受单个根节点（栈仅含根）或一个 entries 数组（entries[0]=根，末尾=栈顶）。
+ *
+ * @example
+ * stack(leaf("home"))                       // 单根栈
+ * stack([leaf("home"), leaf("detail")])     // 根 + 栈顶
+ */
+declare function stack(rootOrEntries: NavigationNode | readonly NavigationNode[]): StackNode;
+/** tabs 构造选项 */
+interface TabsInit {
+  /** 当前激活分支键 */
+  readonly active: string;
+  /** 分支映射（键 → 子节点） */
+  readonly branches: Readonly<Record<string, NavigationNode>>;
+  /** 稳定顺序；缺省时按 branches 的插入顺序推导 */
+  readonly order?: readonly string[];
+}
+/**
+ * 构造 Tabs 节点。
+ * 缺省 `order` 时按 `branches` 的插入顺序（`Object.keys`）推导稳定顺序。
+ */
+declare function tabs(init: TabsInit): TabsNode;
+/** split 列初始化（content 可缺省 = 尚未选择） */
+interface SplitColumnInit {
+  readonly id: string;
+  readonly content?: NavigationNode;
+}
+/**
+ * 构造 Split 节点（多列并存）。
+ * `visibility` 缺省（不写字段）等价 `automatic` = 全列可见；
+ * 显式传入时纳入节点状态，影响 `collectVisibleDestinations` 与 SSR 预取。
+ *
+ * @example
+ * split([{ id: "sidebar", content: leaf("folders") }, { id: "detail" }])
+ * split([...], "detailOnly")   // 深链：仅 detail 列可见
+ */
+declare function split(columns: readonly SplitColumnInit[], visibility?: SplitVisibility): SplitNode;
+declare function isLeafNode(node: NavigationNode): node is LeafNode;
+declare function isStackNode(node: NavigationNode): node is StackNode;
+declare function isTabsNode(node: NavigationNode): node is TabsNode;
+declare function isSplitNode(node: NavigationNode): node is SplitNode;
+//#endregion
+//#region ../core/src/navigation/operations.d.ts
+/**
+ * 解析「激活路径」：从根沿可见分支一路向下，直到叶子或无法继续。
+ * - leaf：路径在此结束
+ * - stack：进入栈顶 entry
+ * - tabs：进入 active 分支
+ * - split：进入最后一个有内容的列（无任何内容则结束）
+ */
+declare function resolveActivePath(tree: NavigationNode): NavigationPath;
+/**
+ * 按路径定位节点；任一步无效（索引越界 / 键不存在 / 列为空 / kind 不匹配）返回 undefined。
+ */
+declare function findNode(tree: NavigationNode, path: NavigationPath): NavigationNode | undefined;
+/**
+ * 找到 target 处（默认激活路径）「at/under」最近的 StackNode 路径。
+ * 从 target 节点沿激活分支向下，返回第一个遇到的 StackNode 的完整路径；
+ * 找不到则返回 undefined。
+ */
+declare function findNearestStack(tree: NavigationNode, path: NavigationPath): NavigationPath | undefined;
+/**
+ * 收集所有可见的叶子目标（顺序即渲染/解析顺序）。
+ * - leaf → [leaf]
+ * - stack → 栈顶 entry 的可见目标
+ * - tabs → active 分支的可见目标
+ * - split → 每个有内容的列的可见目标，按列序拼接
+ */
+declare function collectVisibleDestinations(tree: NavigationNode): readonly LeafNode[];
+/**
+ * 按 `visibility` 求出一个 split 节点当前**可见**的列（不裁剪空内容列——空 content 由调用方处理）。
+ *
+ * - `automatic`（缺省）/ `all`：全部列。
+ * - `doubleColumn`：首列 + 末列（三列时隐藏中间 content 列；列数 ≤ 2 时等价全部）。
+ * - `detailOnly`：仅末列（detail）。
+ *
+ * 应用渲染时也可用它决定该画哪几列，无需自行重实现可见性映射。
+ */
+declare function visibleSplitColumns(node: SplitNode): readonly SplitColumn[];
+/** 在目标栈（默认激活栈，或 target「at/under」最近的 stack）顶部 push 一个节点。 */
+declare function push(tree: NavigationNode, node: NavigationNode, target?: NavigationPath): NavigationNode;
+/** 从 target 处最近的 stack 弹出 count 个 entry（默认 1）；绝不弹到根 entry 之下。 */
+declare function pop(tree: NavigationNode, count?: number, target?: NavigationPath): NavigationNode;
+/** 把 target 处最近的 stack 弹回到根 entry。 */
+declare function popToRoot(tree: NavigationNode, target?: NavigationPath): NavigationNode;
+/** 把 target 处最近的 stack 弹回到指定 index（保留 [0..index]）。 */
+declare function popTo(tree: NavigationNode, index: number, target?: NavigationPath): NavigationNode;
+/** 替换 target 处最近 stack 的栈顶 entry（栈为空时抛错）。 */
+declare function replaceTop(tree: NavigationNode, node: NavigationNode, target?: NavigationPath): NavigationNode;
+/**
+ * 切换 tabs 节点的激活分支。
+ * target 默认为「最近的激活 tabs 节点」；target 必须指向 TabsNode，且 key 必须是已知分支。
+ */
+declare function selectTab(tree: NavigationNode, key: string, target?: NavigationPath): NavigationNode;
+/**
+ * 设置 split 某列内容，并清空它之后的所有列（content 置 undefined）。
+ * target 默认为「最近的激活 split 节点」；columnId 必须是已知列。
+ */
+declare function selectColumn(tree: NavigationNode, columnId: string, content: NavigationNode | undefined, target?: NavigationPath): NavigationNode;
+/**
+ * 设置 split 节点的列可见性（对标 SwiftUI `NavigationSplitViewVisibility`）。
+ * target 默认为「最近的激活 split 节点」。改变 visibility 会影响 `collectVisibleDestinations`，
+ * 进而触发 controller 对「新变可见」的列做 dispatch / SSR 预取（如 detailOnly → all 时补预取 sidebar/content）。
+ */
+declare function setVisibility(tree: NavigationNode, visibility: SplitVisibility, target?: NavigationPath): NavigationNode;
+//#endregion
+//#region ../core/src/navigation/serialization.d.ts
+/** 序列化叶子 */
+interface SerializedLeaf {
+  readonly kind: typeof NAVIGATION_NODE_KINDS.LEAF;
+  readonly intent: string;
+  readonly params: RouteParams;
+}
+/** 序列化栈 */
+interface SerializedStack {
+  readonly kind: typeof NAVIGATION_NODE_KINDS.STACK;
+  readonly entries: readonly SerializedNavigation[];
+}
+/** 序列化 Tabs */
+interface SerializedTabs {
+  readonly kind: typeof NAVIGATION_NODE_KINDS.TABS;
+  readonly active: string;
+  readonly order: readonly string[];
+  readonly branches: Readonly<Record<string, SerializedNavigation>>;
+}
+/** 序列化 Split 列（空内容用 null 表示，JSON 安全） */
+interface SerializedSplitColumn {
+  readonly id: string;
+  readonly content: SerializedNavigation | null;
+}
+/** 序列化 Split（visibility 缺省时不写该字段，保持紧凑） */
+interface SerializedSplit {
+  readonly kind: typeof NAVIGATION_NODE_KINDS.SPLIT;
+  readonly columns: readonly SerializedSplitColumn[];
+  readonly visibility?: SplitVisibility;
+}
+/** 序列化后的导航树（JSON 安全的可辨识联合） */
+type SerializedNavigation = SerializedLeaf | SerializedStack | SerializedTabs | SerializedSplit;
+/** 把导航树序列化为 JSON 安全的纯对象。 */
+declare function serializeNavigation(tree: NavigationNode): SerializedNavigation;
+/** 导航树的确定性字符串形式（keys 排序）；用于稳定缓存键 / 紧凑编码。 */
+declare function serializeNavigationStable(tree: NavigationNode): string;
+/** 从 JSON 安全数据还原导航树；结构畸形抛 NavigationError。 */
+declare function deserializeNavigation(data: unknown): NavigationNode;
+//#endregion
+//#region ../core/src/navigation/codec.d.ts
+/**
+ * Router 的最小读取面 —— codec 只依赖这两个公共方法，避免与 Router 实现耦合。
+ * （`reverse` 为可选：若 Router 将来提供则优先使用。）
+ */
+interface NavigationRouterLike {
+  /** 所有已注册路由的 `"pattern → intentId"` 摘要 */
+  getRoutes(): string[];
+  /** 可选：把 intentId + 参数反查为 URL（若实现则 encode 优先使用） */
+  reverse?(intentId: string, params: RouteParams): string | undefined;
+}
+/**
+ * 导航 URL 编解码器。
+ * - `encode`：把导航树映射为 URL。
+ * - `decode`：把 URL 还原为导航树；无法（或无需）从 URL 同步还原时返回 `undefined`。
+ */
+interface NavigationCodec {
+  encode(tree: NavigationNode, router: NavigationRouterLike): string;
+  decode(url: string, router: NavigationRouterLike): NavigationNode | undefined;
+}
+/** 默认结构化覆盖参数名（full-state 编码所用的保留 query key）。 */
+declare const DEFAULT_NAV_PARAM = "__nav";
+/**
+ * 把整棵树编码为紧凑、URL 安全、确定性的字符串。
+ * 用 `serializeNavigationStable`（keys 排序）保证相同树产出相同串，再做 base64url。
+ */
+declare function encodeNavigationTreeParam(tree: NavigationNode): string;
+/**
+ * 还原 `encodeNavigationTreeParam` 的输出为导航树；畸形输入抛 NavigationError。
+ */
+declare function decodeNavigationTreeParam(encoded: string): NavigationNode;
+/**
+ * 默认 codec：
+ * - `encode`：把激活叶子反查为 URL（`Router.reverse` 或路由摘要反查）；激活叶子无对应路由时回退 `"/"`。
+ * - `decode`：仅在 URL 带 `__nav` 结构化覆盖时同步还原整棵树；否则返回 `undefined`，
+ *   交由调用方走 `await router.resolve(url)` 异步重建单个 LeafNode（今天的行为）。
+ */
+declare function createActiveLeafCodec(): NavigationCodec;
+/** full-state codec 选项 */
+interface FullStateCodecOptions {
+  /** 保留 query 参数名（整树编码所用）；默认 `__nav`。 */
+  readonly param?: string;
+}
+/**
+ * 整树 codec：把整棵树编码进保留 query 参数（默认 `__nav`），支持完整深链。
+ * - `encode`：以激活叶子的 URL 作为基底路径（保留 app 可能依赖的 path/query），
+ *   再写入保留参数承载整棵树。激活叶子无对应路由时基底退化为 `"/"`。
+ * - `decode`：读取保留参数无损还原整棵树；缺失该参数时返回 `undefined`（交由调用方走默认路径）。
+ */
+declare function createFullStateCodec(options?: FullStateCodecOptions): NavigationCodec;
+//#endregion
+//#region ../core/src/navigation/controller.d.ts
+/** 导航操作 Kind 常量 */
+declare const NAVIGATION_OP_KINDS: {
+  readonly PUSH: "push";
+  readonly POP: "pop";
+  readonly POP_TO_ROOT: "popToRoot";
+  readonly POP_TO: "popTo";
+  readonly REPLACE_TOP: "replaceTop";
+  readonly SELECT_TAB: "selectTab";
+  readonly SELECT_COLUMN: "selectColumn";
+  readonly SET_VISIBILITY: "setVisibility";
+  readonly HYDRATE: "hydrate";
+};
+/** 所有导航操作 Kind 的联合类型 */
+type NavigationOpKind = (typeof NAVIGATION_OP_KINDS)[keyof typeof NAVIGATION_OP_KINDS];
+/** push：在目标栈顶压入一个新 leaf（intent + params）。 */
+interface PushOperation {
+  readonly kind: typeof NAVIGATION_OP_KINDS.PUSH;
+  readonly intent: string;
+  readonly params?: RouteParams;
+  readonly target?: NavigationPath;
+}
+/** pop：从目标栈弹出 count 个 entry（默认 1）。 */
+interface PopOperation {
+  readonly kind: typeof NAVIGATION_OP_KINDS.POP;
+  readonly count?: number;
+  readonly target?: NavigationPath;
+}
+/** popToRoot：把目标栈弹回根 entry。 */
+interface PopToRootOperation {
+  readonly kind: typeof NAVIGATION_OP_KINDS.POP_TO_ROOT;
+  readonly target?: NavigationPath;
+}
+/** popTo：把目标栈弹回指定 index。 */
+interface PopToOperation {
+  readonly kind: typeof NAVIGATION_OP_KINDS.POP_TO;
+  readonly index: number;
+  readonly target?: NavigationPath;
+}
+/** replaceTop：替换目标栈的栈顶为新 leaf。 */
+interface ReplaceTopOperation {
+  readonly kind: typeof NAVIGATION_OP_KINDS.REPLACE_TOP;
+  readonly intent: string;
+  readonly params?: RouteParams;
+  readonly target?: NavigationPath;
+}
+/** selectTab：切换 tabs 节点的激活分支。 */
+interface SelectTabOperation {
+  readonly kind: typeof NAVIGATION_OP_KINDS.SELECT_TAB;
+  readonly key: string;
+  readonly target?: NavigationPath;
+}
+/** selectColumn：设置 split 某列内容（intent 为 undefined 表示清空该列）。 */
+interface SelectColumnOperation {
+  readonly kind: typeof NAVIGATION_OP_KINDS.SELECT_COLUMN;
+  readonly columnId: string;
+  readonly intent: string | undefined;
+  readonly params?: RouteParams;
+  readonly target?: NavigationPath;
+}
+/** setVisibility：设置 split 节点的列可见性（对标 NavigationSplitViewVisibility）。 */
+interface SetVisibilityOperation {
+  readonly kind: typeof NAVIGATION_OP_KINDS.SET_VISIBILITY;
+  readonly visibility: SplitVisibility;
+  readonly target?: NavigationPath;
+}
+/** hydrate：用外部给定的整棵树替换当前树（来自 history/URL 还原）。 */
+interface HydrateOperation {
+  readonly kind: typeof NAVIGATION_OP_KINDS.HYDRATE;
+  readonly tree: NavigationNode;
+}
+/** 所有导航操作的可辨识联合。 */
+type NavigationOperation = PushOperation | PopOperation | PopToRootOperation | PopToOperation | ReplaceTopOperation | SelectTabOperation | SelectColumnOperation | SetVisibilityOperation | HydrateOperation;
+/**
+ * 控制器解析单个目标时需要的「环境」——由应用提供。
+ *
+ * 仓库里没有契约所说的 `IntentContext`：dispatch 需要 `Container`，守卫需要
+ * `NavigationContext`（含 url/cookie/header）。所以 `createContext` 在此被建模为
+ * 「给定目标 intent/params，返回构建守卫上下文 + 派发所需的零件」：
+ * - `container`：派发 intent 用（`intentDispatcher.dispatch(intent, container)`）。
+ * - `navigation`：完整的 `NavigationContext`（应用按 SSR/CSR 用
+ *   `createServerContext`/`createBrowserContext` 造好传入）；缺省时控制器用一个不含
+ *   cookie/header 的最小上下文兜底（含 url/path/params/intent/container/isServer，
+ *   其中 isServer 取 `NavigationControllerOptions.isServer`，缺省按运行环境推断）。
+ *
+ * `signal` 暂无消费方（现有 runner 也没有 AbortSignal 管线），仅透传保留。
+ */
+interface NavigationContextInput {
+  readonly intent: string;
+  readonly params: RouteParams;
+  readonly signal?: AbortSignal;
+}
+/** `createContext` 的返回：派发用的 Container + 守卫用的 NavigationContext（可选）。 */
+interface NavigationDispatchContext {
+  /** DI 容器 —— intent 派发的必备参数。 */
+  readonly container: Container;
+  /** 守卫上下文；缺省时控制器用最小上下文兜底。 */
+  readonly navigation?: NavigationContext;
+  /** 该目标对应的完整 URL（用于最小兜底上下文的 url/path）。 */
+  readonly url?: string;
+}
+/** NavigationController 构造选项。 */
+interface NavigationControllerOptions {
+  /** Intent 派发器（派发可见目标的 intent → page）。 */
+  readonly intentDispatcher: IntentDispatcher;
+  /** 路由器（beforeLoad rewrite/redirect 时把 URL 重解析为 leaf）。 */
+  readonly router: Router;
+  /** 初始导航树（单 LeafNode = 今天的扁平单页）。 */
+  readonly initial: NavigationNode;
+  /** 应用提供的「目标 → 派发上下文」构建回调。 */
+  readonly createContext: (input: NavigationContextInput) => NavigationDispatchContext;
+  /**
+   * 是否运行在服务端——仅用于 `createContext` 未返回 `navigation` 时的最小兜底上下文，
+   * 决定该上下文的 `isServer` 字段。缺省时按运行环境推断（`typeof window === "undefined"`）。
+   * 应用若已通过 `createContext` 提供完整 `navigation`，此项不生效。
+   */
+  readonly isServer?: boolean;
+  /** 目标级 beforeLoad 守卫（在全局/路由守卫之外，由控制器对主目标执行）。 */
+  readonly beforeLoad?: readonly BeforeLoadGuard[];
+  /** 目标级 afterLoad 守卫。 */
+  readonly afterLoad?: readonly AfterLoadGuard[];
+  /** SSR 预取缓存（浏览器 hydration 时复用服务端解析结果）。 */
+  readonly prefetched?: PrefetchedIntents;
+  /**
+   * 兜底错误页工厂——dispatch 失败 / deny 时，用它产出该目标的 page。
+   * 缺省用一个最小的 BasePage（pageType="error"）。复刻 runner 的 fallback 语义。
+   */
+  readonly getErrorPage?: (status: number, message: string) => Page;
+  /**
+   * redirect 处理器——beforeLoad/afterLoad 返回 redirect 时调用（SPA 内跳 / 外链）。
+   * 控制器不持有 history，把「怎么跳」交给应用（浏览器侧 → `framework.perform`）。
+   * 缺省为 no-op（该目标不 dispatch、不再跳，仅保留当前页/兜底页）。
+   */
+  readonly onRedirect?: (redirect: {
+    url: string;
+    status: number;
+  }) => void;
+}
+/** 导航控制器对外接口。 */
+interface NavigationController {
+  /** 当前导航树。 */
+  getTree(): NavigationNode;
+  /** 当前快照（树 + 已解析的可见目标）。 */
+  getSnapshot(): NavigationSnapshot;
+  /** 应用一个声明式操作，重解析并提交，返回新快照。 */
+  apply(op: NavigationOperation): Promise<NavigationSnapshot>;
+  /** 便捷：在激活栈压入新目标。 */
+  push(intent: string, params?: RouteParams, options?: PushOptions): Promise<NavigationSnapshot>;
+  /** 便捷：从激活栈弹出。 */
+  pop(count?: number): Promise<NavigationSnapshot>;
+  /** 便捷：激活栈弹回根。 */
+  popToRoot(): Promise<NavigationSnapshot>;
+  /** 便捷：替换激活栈栈顶。 */
+  replaceTop(intent: string, params?: RouteParams): Promise<NavigationSnapshot>;
+  /** 便捷：切换 tabs 激活分支。 */
+  selectTab(key: string, target?: NavigationPath): Promise<NavigationSnapshot>;
+  /** 便捷：设置 split 列内容（intent=undefined 清空）。 */
+  selectColumn(columnId: string, intent: string | undefined, params?: RouteParams, target?: NavigationPath): Promise<NavigationSnapshot>;
+  /** 便捷：设置 split 列可见性（对标 NavigationSplitViewVisibility）；改变可见集会触发新可见列的派发。 */
+  setVisibility(visibility: SplitVisibility, target?: NavigationPath): Promise<NavigationSnapshot>;
+  /** 用外部树替换当前树并重解析（history/URL 还原）。 */
+  hydrate(tree: NavigationNode): Promise<NavigationSnapshot>;
+  /** 订阅快照变更；返回取消订阅函数。 */
+  subscribe(listener: (snapshot: NavigationSnapshot) => void): () => void;
+  /** 解析当前树（首屏 SSR/CSR），提交并返回快照。 */
+  resolve(): Promise<NavigationSnapshot>;
+}
+/** `push` 便捷方法的可选项。 */
+interface PushOptions {
+  readonly target?: NavigationPath;
+}
+declare function createNavigationController(options: NavigationControllerOptions): NavigationController;
+//#endregion
+//#region ../core/src/bootstrap/define-navigation.d.ts
+/**
+ * `initial` 既可是一棵静态初始树，也可是按 URL 产出树骨架的工厂。
+ *
+ * - 静态树：所有请求（CSR 首屏 / SSR 无深链回退）都以这棵树为初始结构。
+ * - 工厂 `(url) => NavigationNode | undefined`：按请求 URL 动态决定骨架；返回 `undefined`
+ *   表示「此 URL 无结构化骨架」，SSR 侧据此回退到「`Router.resolve` → 单 LeafNode」
+ *   （今天的单页行为）。CSR 侧首屏对工厂传入当前 `window.location` 的 path+query。
+ */
+type NavigationInitial = NavigationNode | ((url: string) => NavigationNode | undefined);
+/**
+ * 浏览器 runner（`startBrowserApp`）期望的导航配置形态。
+ *
+ * 与 `@finesoft/browser` 的 `BrowserNavigationConfig` 结构等价（`initial` 为具体树）；
+ * 在 core 中以结构化形状声明，避免 core → browser 的反向依赖。
+ */
+interface NavigationBrowserConfig {
+  readonly initial: NavigationNode;
+  readonly codec?: NavigationCodec;
+  readonly beforeLoad?: readonly BeforeLoadGuard[];
+  readonly afterLoad?: readonly AfterLoadGuard[];
+  readonly getErrorPage?: (status: number, message: string) => BasePage;
+}
+/**
+ * SSR runner（`createSSRNavigationRender` / `ssrRenderNavigation`）期望的导航定义形态。
+ *
+ * 与 `@finesoft/ssr` 的 `SSRNavigationDefinition` 结构等价（`codec` 必填、`initial`
+ * 为骨架工厂）；在 core 中以结构化形状声明，避免 core → ssr 的反向依赖。
+ */
+interface NavigationSSRDefinition {
+  readonly codec: NavigationCodec;
+  readonly initial?: (url: string) => NavigationNode | undefined;
+  readonly beforeLoad?: readonly BeforeLoadGuard[];
+  readonly afterLoad?: readonly AfterLoadGuard[];
+}
+/** `defineNavigation` 的输入声明。 */
+interface DefineNavigationOptions {
+  /**
+   * 初始导航结构：静态树或按 URL 产出树骨架的工厂。
+   * 单个 `leaf(...)` 树即为今天的扁平单页（向后兼容）。
+   */
+  readonly initial: NavigationInitial;
+  /**
+   * URL ⇄ 树 编解码器；缺省 `createActiveLeafCodec()`
+   * （URL 只反映激活叶子，整树通过 history/hydration 旁路）。
+   */
+  readonly codec?: NavigationCodec;
+  /** 导航级 beforeLoad 守卫（控制器对主目标执行，叠加在全局/路由守卫之外）。 */
+  readonly beforeLoad?: readonly BeforeLoadGuard[];
+  /** 导航级 afterLoad 守卫。 */
+  readonly afterLoad?: readonly AfterLoadGuard[];
+  /** dispatch 失败 / deny 时的兜底错误页工厂（仅 CSR runner 直接消费；SSR runner 用其自带的 getErrorPage）。 */
+  readonly getErrorPage?: (status: number, message: string) => BasePage;
+}
+/**
+ * `defineNavigation` 的产物：规范化后的导航定义。
+ *
+ * 既暴露规范化字段（应用可自取），也提供两个适配器把定义转成各 runner 需要的精确形态。
+ * 字段全部 `readonly`、不可变。
+ */
+interface NavigationDefinition {
+  /** 规范化的初始结构（静态树或工厂）。 */
+  readonly initial: NavigationInitial;
+  /** 最终生效的 codec（已套用默认值）。 */
+  readonly codec: NavigationCodec;
+  /** 导航级 beforeLoad 守卫。 */
+  readonly beforeLoad?: readonly BeforeLoadGuard[];
+  /** 导航级 afterLoad 守卫。 */
+  readonly afterLoad?: readonly AfterLoadGuard[];
+  /** 兜底错误页工厂。 */
+  readonly getErrorPage?: (status: number, message: string) => BasePage;
+  /**
+   * 适配为浏览器 runner 配置（`initial` 收敛为具体树）。
+   * `initial` 是工厂时，对 `url`（缺省当前 `window.location`）求值；返回 `undefined`
+   * 时回退到一个最小的占位 leaf（`@finesoft/navigation-root`），保证 bridge 能挂载——
+   * 浏览器首屏随后会用 SSR 注入的真实树 hydrate（见 navigation-bridge）。
+   */
+  toBrowserConfig(url?: string): NavigationBrowserConfig;
+  /** 适配为 SSR runner 定义（`initial` 收敛为骨架工厂、`codec` 必填）。 */
+  toSSRDefinition(): NavigationSSRDefinition;
+}
+/**
+ * 声明结构化导航。
+ *
+ * 在 `bootstrap(framework)` 里与 `defineRoutes` 并列调用，返回一个 `NavigationDefinition`，
+ * 由应用分别交给 CSR / SSR runner：
+ *
+ * @example
+ * ```ts
+ * const nav = defineNavigation({
+ *   initial: tabs({
+ *     active: "home",
+ *     branches: { home: stack(leaf("home")), me: stack(leaf("me")) },
+ *   }),
+ *   beforeLoad: [authGuard],
+ * });
+ *
+ * // CSR
+ * startBrowserApp({ bootstrap, mount, callbacks, navigation: nav.toBrowserConfig() });
+ * // SSR
+ * createSSRNavigationRender({ bootstrap, getErrorPage, renderApp, navigation: nav.toSSRDefinition() });
+ * ```
+ */
+declare function defineNavigation(options: DefineNavigationOptions): NavigationDefinition;
+//#endregion
 //#region ../core/src/bootstrap/define-routes.d.ts
 /** 渲染模式 */
 type RenderMode = "ssr" | "csr" | "prerender";
@@ -1456,6 +2045,14 @@ interface FlowActionDependencies {
   }) => void;
   /** 获取可滚动页面元素，用于滚动位置保存/恢复 */
   getScrollablePageElement?: () => HTMLElement | null;
+  /**
+   * 是否由本 handler 管理浏览器 history（pushState / popstate）。缺省 `true`。
+   * 结构化导航（`startBrowserApp({ navigation })`）下应传 `false`：history 由
+   * NavigationBridge 独占，否则两套 `History` 实例会争抢同一个 `window.history.state`、
+   * 各自注册 popstate 互相 clobber，导致 back/forward 行为错乱。传 `false` 时本 handler
+   * 仍负责 dispatch + updateApp（初始渲染 / redirect / modal），只是不碰 history。
+   */
+  manageHistory?: boolean;
 }
 declare function registerFlowActionHandler(deps: FlowActionDependencies): void;
 //#endregion
@@ -1470,10 +2067,85 @@ interface ActionHandlerDependencies {
   }) => void;
   /** 获取可滚动页面元素，用于滚动位置保存/恢复 */
   getScrollablePageElement?: () => HTMLElement | null;
+  /** 是否由 FlowAction handler 管理 history；结构化导航下传 `false`（见 registerFlowActionHandler）。 */
+  manageHistory?: boolean;
 }
 declare function registerActionHandlers(deps: ActionHandlerDependencies): void;
 //#endregion
+//#region ../browser/src/navigation-bridge.d.ts
+/** NavigationBridge 构造依赖。 */
+interface NavigationBridgeDependencies {
+  /** 已构建好的导航控制器（持有 initial 树、intentDispatcher、router 等）。 */
+  readonly controller: NavigationController;
+  /** URL 编解码器（默认 `createActiveLeafCodec`）。 */
+  readonly codec: NavigationCodec;
+  /** Router 的最小读取面（encode 反查 / decode 用）。 */
+  readonly router: NavigationRouterLike;
+  /** 日志器。 */
+  readonly log: Logger;
+  /** 获取可滚动页面元素，用于滚动位置保存/恢复（透传给 History）。 */
+  readonly getScrollablePageElement?: () => HTMLElement | null;
+}
+/**
+ * 导航操作句柄 —— 向应用暴露的对外面。
+ *
+ * 所有写操作返回提交后的 `NavigationSnapshot`；写操作会同步把新树落到 history/URL。
+ * `subscribe` 与 controller 的订阅一致（每次提交都回调，含来自 popstate 的 hydrate）。
+ */
+interface NavigationHandle {
+  /** 当前快照（树 + 已解析的可见目标）。 */
+  getSnapshot(): NavigationSnapshot;
+  /** 在激活栈压入新目标。 */
+  push(intent: string, params?: RouteParams, options?: {
+    target?: NavigationPath;
+  }): Promise<NavigationSnapshot>;
+  /** 从激活栈弹出 count 个（默认 1）。 */
+  pop(count?: number): Promise<NavigationSnapshot>;
+  /** 激活栈弹回根。 */
+  popToRoot(): Promise<NavigationSnapshot>;
+  /** 替换激活栈栈顶。 */
+  replaceTop(intent: string, params?: RouteParams): Promise<NavigationSnapshot>;
+  /** 切换 tabs 激活分支。 */
+  selectTab(key: string, target?: NavigationPath): Promise<NavigationSnapshot>;
+  /** 设置 split 列内容（intent=undefined 清空该列）。 */
+  selectColumn(columnId: string, intent: string | undefined, params?: RouteParams, target?: NavigationPath): Promise<NavigationSnapshot>;
+  /** 用外部树替换当前树并重解析（一般由桥内部 popstate 调用，亦对外暴露）。 */
+  hydrate(tree: NavigationNode): Promise<NavigationSnapshot>;
+  /** 订阅快照变更；返回取消订阅函数。 */
+  subscribe(listener: (snapshot: NavigationSnapshot) => void): () => void;
+}
+/**
+ * 创建 NavigationBridge：订阅 controller、装配 popstate、返回 navigation handle。
+ *
+ * 调用后 bridge 已激活（已订阅 controller + 已注册 popstate listener）。应用应在调用前/后
+ * 调一次 `controller.resolve()` 完成首屏解析；首屏的快照提交会被 bridge 用 `replaceState`
+ * 写入 history（first-page 语义），不会污染历史栈。
+ */
+declare function createNavigationBridge(deps: NavigationBridgeDependencies): NavigationHandle;
+//#endregion
 //#region ../browser/src/start-app.d.ts
+/**
+ * 结构化导航定义 —— 由应用通过 `defineNavigation(...)` 或手写提供。
+ *
+ * 仅当该字段出现时 bridge 才激活；缺省时 `startBrowserApp` 走原有扁平单页路径，行为不变。
+ * 提供后：
+ * - 用 `initial` 树构建 `NavigationController`（守卫上下文走 `createBrowserContext`，
+ *   预取缓存复用 `framework.prefetchedIntents`）；
+ * - 装配 `NavigationBridge`（snapshot → history/URL，popstate → hydrate）；
+ * - 解析首屏树（一次 `resolve()`），通过 `onNavigationReady` 把 handle 交给应用。
+ */
+interface BrowserNavigationConfig {
+  /** 初始导航树（单 LeafNode = 今天的扁平单页）。 */
+  readonly initial: NavigationNode;
+  /** URL 编解码器；缺省 `createActiveLeafCodec()`。 */
+  readonly codec?: NavigationCodec;
+  /** 导航级 beforeLoad 守卫（对主目标执行）。 */
+  readonly beforeLoad?: readonly BeforeLoadGuard[];
+  /** 导航级 afterLoad 守卫。 */
+  readonly afterLoad?: readonly AfterLoadGuard[];
+  /** dispatch 失败 / deny 时的兜底错误页工厂。 */
+  readonly getErrorPage?: (status: number, message: string) => BasePage;
+}
 interface BrowserAppConfig {
   /** 注册 controllers 和路由的引导函数 */
   bootstrap: (framework: Framework) => void;
@@ -1523,6 +2195,21 @@ interface BrowserAppConfig {
    * 显式传入时会覆盖 bootstrap / Vite 自动生成的 loader。
    */
   loadMessages?: MessagesLoader;
+  /**
+   * 结构化导航定义（可选）。
+   *
+   * 提供后，`startBrowserApp` 在挂载后构建 NavigationController + NavigationBridge，
+   * 解析首屏树，并通过 `onNavigationReady` 把导航 handle 交给应用。缺省时走原有
+   * 扁平单页路径（FlowAction handler），行为完全不变。
+   */
+  navigation?: BrowserNavigationConfig;
+  /**
+   * 导航就绪回调 —— bridge 装配并完成首屏 `resolve()` 后调用。
+   *
+   * 仅当提供了 `navigation` 时触发。应用拿到 handle 后用它驱动导航
+   * （push/pop/selectTab…）并订阅快照渲染 UI。
+   */
+  onNavigationReady?: (handle: NavigationHandle) => void | Promise<void>;
 }
 /**
  * 启动客户端应用
@@ -1534,13 +2221,25 @@ declare function startBrowserApp(config: BrowserAppConfig): Promise<void>;
 //#region ../browser/src/utils/history.d.ts
 interface HistoryOptions {
   getScrollablePageElement: () => HTMLElement | null;
+  /**
+   * 是否把 `state` 一并写入 `window.history.state`（而非仅 `{ id }` + 内存 LruMap）。缺省 `false`。
+   *
+   * 内存 LruMap 在整页刷新后丢失；若 state 小且可结构化克隆（如导航树 `{ tree }`），开启此项
+   * 可让 state 随 `window.history.state` **跨刷新按 entry 保留**，刷新后 back/forward 仍能从
+   * history.state 还原（onPopState 在 LruMap 未命中时回退到 `event.state.state`）。
+   * 大状态（如整页 `{ page }`）不应开启，避免撑爆 history.state。
+   */
+  persistInHistoryState?: boolean;
 }
 declare class History<State> {
   private readonly entries;
   private readonly log;
   private readonly getScrollablePageElement;
+  private readonly persistInHistoryState;
   private currentStateId;
   constructor(log: Logger, options: HistoryOptions, sizeLimit?: number);
+  /** 写入 window.history.state 的载荷：persist 时连 state 一起带（跨刷新保留）。 */
+  private historyState;
   replaceState(state: State, url: string): void;
   pushState(state: State, url: string): void;
   beforeTransition(): void;
@@ -1569,5 +2268,5 @@ declare function deserializeServerData(): PrefetchedIntent[] | undefined;
  */
 declare function createPrefetchedIntentsFromDom(): PrefetchedIntents;
 //#endregion
-export { RenderMode as $, BaseLogger as $n, RouteAddOptions as $t, IntersectionImpressionObserver as A, DEP_KEYS as An, Translator as At, buildUrl as B, TranslationMessages as Bn, ParamsFor as Bt, PluralRuleProvider as C, BasePage as Cn, Framework as Ct, WithFieldsRecorder as D, markPublic as Dn, LocaleAttributes as Dt, resolvePluralKey as E, isPublicMarked as En, PrefetchedIntents as Et, BrowserContextOptions as F, Net as Fn, CompositeLogger as Ft, PWADisplayMode as G, EventRecorder as Gn, NumOptions as Gt, removeHost as H, resolveMessages as Hn, StripOptional as Ht, ServerContextOptions as I, Storage as In, CompositeLoggerFactory as It, Optional as J, MetricsFieldsProvider as Jn, int as Jt, getPWADisplayMode as K, ImpressionEntry as Kn, StrOptions as Kt, createBrowserContext as L, makeDependencies as Ln, ExtractParamNames as Lt, CompositeEventRecorder as M, FeatureFlagsProvider as Mn, shouldLog as Mt, runAfterLoadGuards as N, MakeDependenciesOptions as Nn, ConsoleLogger as Nt, VoidEventRecorder as O, RequestScopedKey as On, LocaleInfo as Ot, runBeforeLoadGuards as P, MetricsRecorder as Pn, ConsoleLoggerFactory as Pt, DefineRoutesOptions as Q, ReportingLoggerOptions as Qn, uuid as Qt, createServerContext as R, MessagesLoader as Rn, InferParams as Rt, PluralCategory as S, BASE_PAGE_FIELDS as Sn, safeErrorPage as St, interpolate as T, getPublicFields as Tn, PrefetchedIntent as Tt, removeQueryParams as U, PlatformInfo as Un, optional as Ut, getBaseUrl as V, resolveConfiguredMessages as Vn, QuerySchemaMap as Vt, removeScheme as W, detectPlatform as Wn, withDefault as Wt, isSome as X, ReportingLogger as Xn, oneOf as Xt, isNone as Y, ReportCallback as Yn, num as Yt, LruMap as Z, ReportingLoggerFactory as Zn, str as Zt, getTextDirection as _, RewriteResult as _n, isFlowAction as _r, ResponseInterceptor as _t, BrowserAppConfig as a, StandardResult as an, Intent as ar, mapEach as at, resolveLocaleFromUrl as b, redirect as bn, BaseShelf as bt, registerActionHandlers as c, runStandard as cn, ActionDispatcher as cr, BaseController as ct, registerFlowActionHandler as d, DenyResult as dn, Action as dr, classifyUrl as dt, RouteMatch as en, Logger as er, RouteDefinition as et, ExternalUrlDependencies as f, MiddlewareResult as fn, CompoundAction as fr, HostGuardError as ft, getLocaleAttributes as g, RedirectResult as gn, isExternalUrlAction as gr, RequestInterceptor as gt, SimpleTranslatorOptions as h, PostLoadContext as hn, isCompoundAction as hr, HttpError as ht, History as i, StandardIssue as in, IntentDispatcher as ir, Mapper as it, ConsoleEventRecorder as j, FeatureFlags as jn, resetFilterCache as jt, ImpressionObserverOptions as k, defineRequestScopedKey as kn, TextDirection as kt, FlowActionCallbacks as l, AfterLoadGuard as ln, ActionHandler as lr, HostCheckResult as lt, SimpleTranslator as m, NextResult as mn, FlowAction as mr, HttpClientConfig as mt, deserializeServerData as n, InferOutput as nn, SecureFetchOptions as nr, route as nt, startBrowserApp as o, StandardSchemaV1 as on, IntentController as or, pipe as ot, registerExternalUrlHandler as p, NavigationContext as pn, ExternalUrlAction as pr, HttpClient as pt, None as q, ImpressionObserver as qn, bool as qt, tryScroll as r, ParamSchema as rn, secureFetch as rr, AsyncMapper as rt, ActionHandlerDependencies as s, makeSchema as sn, Container as sr, pipeAsync as st, createPrefetchedIntentsFromDom as t, Router as tn, LoggerFactory as tr, defineRoutes as tt, FlowActionDependencies as u, BeforeLoadGuard as un, ACTION_KINDS as ur, classifyHost as ut, isRtl as v, deny as vn, makeExternalUrlAction as vr, stableStringify as vt, englishPlural as w, FINESOFT_PUBLIC as wn, FrameworkConfig as wt, setHtmlLocaleAttributes as x, rewrite as xn, SafeErrorPageOptions as xt, makeLocaleInfo as y, next as yn, makeFlowAction as yr, BaseItem as yt, generateUuid as z, MessagesLoaderContext as zn, InferQuery as zt };
-//# sourceMappingURL=server-data-DQzknR97.d.mts.map
+export { isNone as $, Framework as $n, BASE_PAGE_FIELDS as $r, popToRoot as $t, resolvePluralKey as A, BaseLogger as Ai, SplitVisibility as An, RouteAddOptions as Ar, createNavigationController as At, ServerContextOptions as B, ActionHandler as Bi, classifyHost as Bn, AfterLoadGuard as Br, SerializedNavigation as Bt, makeLocaleInfo as C, ImpressionEntry as Ci, NavigationPathStep as Cn, bool as Cr, PopToRootOperation as Ct, PluralRuleProvider as D, ReportingLogger as Di, SPLIT_VISIBILITIES as Dn, str as Dr, SelectColumnOperation as Dt, PluralCategory as E, ReportCallback as Ei, ResolvedDestination as En, oneOf as Er, ReplaceTopOperation as Et, ConsoleEventRecorder as F, IntentDispatcher as Fi, mapEach as Fn, StandardIssue as Fr, createActiveLeafCodec as Ft, getBaseUrl as G, FlowAction as Gi, HttpError as Gn, NextResult as Gr, deserializeNavigation as Gt, createServerContext as H, Action as Hi, HostGuardError as Hn, DenyResult as Hr, SerializedSplitColumn as Ht, CompositeEventRecorder as I, Intent as Ii, pipe as In, StandardResult as Ir, createFullStateCodec as It, removeScheme as J, isFlowAction as Ji, stableStringify as Jn, RewriteResult as Jr, collectVisibleDestinations as Jt, removeHost as K, isCompoundAction as Ki, RequestInterceptor as Kn, PostLoadContext as Kr, serializeNavigation as Kt, runAfterLoadGuards as L, IntentController as Li, pipeAsync as Ln, StandardSchemaV1 as Lr, decodeNavigationTreeParam as Lt, VoidEventRecorder as M, LoggerFactory as Mi, TabsNode as Mn, Router as Mr, FullStateCodecOptions as Mt, ImpressionObserverOptions as N, SecureFetchOptions as Ni, AsyncMapper as Nn, InferOutput as Nr, NavigationCodec as Nt, englishPlural as O, ReportingLoggerFactory as Oi, SplitColumn as On, uuid as Or, SelectTabOperation as Ot, IntersectionImpressionObserver as P, secureFetch as Pi, Mapper as Pn, ParamSchema as Pr, NavigationRouterLike as Pt, Optional as Q, safeErrorPage as Qn, rewrite as Qr, popTo as Qt, runBeforeLoadGuards as R, Container as Ri, BaseController as Rn, makeSchema as Rr, encodeNavigationTreeParam as Rt, isRtl as S, EventRecorder as Si, NavigationPath as Sn, StrOptions as Sr, PopToOperation as St, setHtmlLocaleAttributes as T, MetricsFieldsProvider as Ti, Page as Tn, num as Tr, PushOptions as Tt, generateUuid as U, CompoundAction as Ui, HttpClient as Un, MiddlewareResult as Ur, SerializedStack as Ut, createBrowserContext as V, ACTION_KINDS as Vi, classifyUrl as Vn, BeforeLoadGuard as Vr, SerializedSplit as Vt, buildUrl as W, ExternalUrlAction as Wi, HttpClientConfig as Wn, NavigationContext as Wr, SerializedTabs as Wt, getPWADisplayMode as X, makeFlowAction as Xi, BaseShelf as Xn, next as Xr, findNode as Xt, PWADisplayMode as Y, makeExternalUrlAction as Yi, BaseItem as Yn, deny as Yr, findNearestStack as Yt, None as Z, SafeErrorPageOptions as Zn, redirect as Zr, pop as Zt, registerExternalUrlHandler as _, TranslationMessages as _i, LeafNode as _n, QuerySchemaMap as _r, NavigationControllerOptions as _t, BrowserAppConfig as a, RequestScopedKey as ai, setVisibility as an, TextDirection as ar, defineRoutes as at, getLocaleAttributes as b, PlatformInfo as bi, NavigationNode as bn, withDefault as br, NavigationOperation as bt, NavigationBridgeDependencies as c, FeatureFlags as ci, TabsInit as cn, shouldLog as cr, NavigationBrowserConfig as ct, ActionHandlerDependencies as d, MetricsRecorder as di, isStackNode as dn, CompositeLogger as dr, NavigationSSRDefinition as dt, BasePage as ei, push as en, FrameworkConfig as er, isSome as et, registerActionHandlers as f, Net as fi, isTabsNode as fn, CompositeLoggerFactory as fr, defineNavigation as ft, ExternalUrlDependencies as g, MessagesLoaderContext as gi, tabs as gn, ParamsFor as gr, NavigationController as gt, registerFlowActionHandler as h, MessagesLoader as hi, stack as hn, InferQuery as hr, NavigationContextInput as ht, History as i, markPublic as ii, selectTab as in, LocaleInfo as ir, RouteDefinition as it, WithFieldsRecorder as j, Logger as ji, StackNode as jn, RouteMatch as jr, DEFAULT_NAV_PARAM as jt, interpolate as k, ReportingLoggerOptions as ki, SplitNode as kn, RouteParams as kr, SetVisibilityOperation as kt, NavigationHandle as l, FeatureFlagsProvider as li, isLeafNode as ln, ConsoleLogger as lr, NavigationDefinition as lt, FlowActionDependencies as m, makeDependencies as mi, split as mn, InferParams as mr, NAVIGATION_OP_KINDS as mt, deserializeServerData as n, getPublicFields as ni, resolveActivePath as nn, PrefetchedIntents as nr, DefineRoutesOptions as nt, BrowserNavigationConfig as o, defineRequestScopedKey as oi, visibleSplitColumns as on, Translator as or, route as ot, FlowActionCallbacks as p, Storage as pi, leaf as pn, ExtractParamNames as pr, HydrateOperation as pt, removeQueryParams as q, isExternalUrlAction as qi, ResponseInterceptor as qn, RedirectResult as qr, serializeNavigationStable as qt, tryScroll as r, isPublicMarked as ri, selectColumn as rn, LocaleAttributes as rr, RenderMode as rt, startBrowserApp as s, DEP_KEYS as si, SplitColumnInit as sn, resetFilterCache as sr, DefineNavigationOptions as st, createPrefetchedIntentsFromDom as t, FINESOFT_PUBLIC as ti, replaceTop as tn, PrefetchedIntent as tr, LruMap as tt, createNavigationBridge as u, MakeDependenciesOptions as ui, isSplitNode as un, ConsoleLoggerFactory as ur, NavigationInitial as ut, SimpleTranslator as v, resolveConfiguredMessages as vi, NAVIGATION_NODE_KINDS as vn, StripOptional as vr, NavigationDispatchContext as vt, resolveLocaleFromUrl as w, ImpressionObserver as wi, NavigationSnapshot as wn, int as wr, PushOperation as wt, getTextDirection as x, detectPlatform as xi, NavigationNodeKind as xn, NumOptions as xr, PopOperation as xt, SimpleTranslatorOptions as y, resolveMessages as yi, NavigationError as yn, optional as yr, NavigationOpKind as yt, BrowserContextOptions as z, ActionDispatcher as zi, HostCheckResult as zn, runStandard as zr, SerializedLeaf as zt };
+//# sourceMappingURL=server-data-HVSgxEac.d.mts.map