@finesoft/front 0.5.1 → 0.5.2

package/dist/cookies-Bpf9VayB.d.mts

@@ -0,0 +1,779 @@
+import { E as ParamSchema, S as EventRecorder, _ as OperationPolicy, b as RuntimeOptions, c as ExecutionContext, d as ExecutionHandle, f as Implementation, g as OperationHandler, h as Operation, m as ModuleDefinition, s as AppDefinition, w as MetricsFieldsProvider, y as RuntimeHandle } from "./path-CXT6xGPO.mjs";
+import { $t as MiddlewareResult, A as SessionStore, B as ControllerContext, Bt as NavigationPath, Dn as LocaleInfo, En as LocaleAttributes, F as WebRuntime, Ft as LeafNode, Gn as InferParams, Gt as SplitColumn, Hn as Logger, Jn as QuerySchemaMap, Jt as StackNode, Kn as InferQuery, Kt as SplitNode, Mn as BaseController, O as SessionSnapshot, On as TextDirection, Pn as ControllerInput, R as PageControllerDefinition, Rt as NavigationNode, Un as LoggerFactory, Wn as ExtractParamNames, Xt as AfterLoadGuard, Yt as TabsNode, Z as NavigationCodec, Zn as MultiValueSchema, Zt as BeforeLoadGuard, _n as RouteInput$1, bt as Router, en as NavigationContext, ft as PageRoute, j as SessionStoreOptions, kn as Translator, mt as RouteDefinition, nn as PostLoadContext, qt as SplitVisibility, un as BasePage, v as NavigationScopedState, vn as RouteIntent, yn as RouteParams, yt as RouteMatch, z as WebAppDefinition } from "./session-DnB4ZC3x.mjs";
+import { t as SecureFetchOptions } from "./secure-fetch-Xlht2jd7.mjs";
+//#region ../core/src/schema/primitives.d.ts
+interface StrOptions {
+  minLength?: number;
+  maxLength?: number;
+  pattern?: RegExp;
+}
+declare function str(opts?: StrOptions): ParamSchema<string>;
+interface NumOptions {
+  min?: number;
+  max?: number;
+}
+declare function int(opts?: NumOptions): ParamSchema<number>;
+declare function num(opts?: NumOptions): ParamSchema<number>;
+declare function bool(): ParamSchema<boolean>;
+declare function oneOf<const T extends readonly string[]>(values: T): ParamSchema<T[number]>;
+declare function uuid(): ParamSchema<string>;
+//#endregion
+//#region ../core/src/schema/modifiers.d.ts
+/** 输入缺失（undefined）时跳过校验、产出 undefined；否则委托内部 codec（同步或异步均可）。 */
+declare function optional<T>(codec: MultiValueSchema<T>): MultiValueSchema<T | undefined>;
+declare function optional<T>(codec: ParamSchema<T>): ParamSchema<T | undefined>;
+/** 输入缺失时用 fallback；否则委托内部 codec。 */
+declare function withDefault<T>(codec: MultiValueSchema<T>, fallback: T): MultiValueSchema<T>;
+declare function withDefault<T>(codec: ParamSchema<T>, fallback: T): ParamSchema<T>;
+//#endregion
+//#region ../core/src/logger/composite.d.ts
+declare class CompositeLoggerFactory implements LoggerFactory {
+  private readonly factories;
+  constructor(factories: LoggerFactory[]);
+  loggerFor(name: string): Logger;
+}
+declare class CompositeLogger implements Logger {
+  private readonly loggers;
+  constructor(loggers: Logger[]);
+  debug(...args: unknown[]): void;
+  info(...args: unknown[]): void;
+  warn(...args: unknown[]): void;
+  error(...args: unknown[]): void;
+  private callAll;
+}
+//#endregion
+//#region ../core/src/utils/stable-stringify.d.ts
+/**
+ * stableStringify — 确定性 JSON 序列化（keys 按字母排序）
+ *
+ * 用作缓存 key：相同内容的对象始终产生相同字符串。
+ */
+declare function stableStringify(obj: unknown): string;
+//#endregion
+//#region ../core/src/http/errors.d.ts
+/** HTTP 请求错误 */
+declare class HttpError extends Error {
+  readonly status: number;
+  readonly statusText: string;
+  readonly body?: string | undefined;
+  constructor(status: number, statusText: string, body?: string | undefined);
+}
+/**
+ * SSRF 防护拦截到不安全的目标地址时抛出。应用层可以 catch 它来给出业务友好的错误，
+ * 不需要靠 message 字符串匹配。
+ */
+declare class HostGuardError extends Error {
+  readonly url: string;
+  readonly reason: string;
+  constructor(url: string, reason: string);
+}
+//#endregion
+//#region ../core/src/http/client.d.ts
+/** 请求拦截器 — 在发送前修改请求 */
+interface RequestInterceptor {
+  (url: string, init: RequestInit): RequestInit | Promise<RequestInit>;
+}
+/** 响应拦截器 — 在解析前修改响应 */
+interface ResponseInterceptor {
+  (response: Response, url: string): Response | Promise<Response>;
+}
+interface HttpRequestOptions {
+  signal?: AbortSignal;
+  headers?: Record<string, string>;
+}
+/** HttpClient 构造配置 */
+interface HttpClientConfig extends SecureFetchOptions {
+  /** API base URL（如 "/api" 或 "https://example.com/api"） */
+  baseUrl: string;
+  /** 默认请求头 */
+  defaultHeaders?: Record<string, string>;
+  /** 自定义 fetch 实现（便于测试或 SSR）。可由 execution context 提供。 */
+  fetch?: typeof globalThis.fetch;
+  /** Binds this client to an execution's portable fetch and cancellation signal. */
+  context?: Pick<ExecutionContext, "fetch" | "signal">;
+  /** 请求拦截器（按注册顺序执行） */
+  requestInterceptors?: RequestInterceptor[];
+  /** 响应拦截器（按注册顺序执行） */
+  responseInterceptors?: ResponseInterceptor[];
+}
+/**
+ * 通用 HTTP 客户端基类
+ *
+ * 使用方式: 创建子类继承 HttpClient，定义业务方法调用 this.get() / this.post() 等。
+ *
+ * @example
+ * ```ts
+ * class MyApiClient extends HttpClient {
+ *   async getUser(id: string) {
+ *     return this.get<User>(`/users/${id}`);
+ *   }
+ * }
+ * ```
+ */
+declare abstract class HttpClient {
+  protected readonly baseUrl: string;
+  protected readonly defaultHeaders: Record<string, string>;
+  protected readonly fetchFn: typeof globalThis.fetch;
+  private readonly requestInterceptors;
+  private readonly responseInterceptors;
+  private readonly contextSignal?;
+  constructor(config: HttpClientConfig);
+  /** 动态添加请求拦截器 */
+  useRequestInterceptor(interceptor: RequestInterceptor): this;
+  /** 动态添加响应拦截器 */
+  useResponseInterceptor(interceptor: ResponseInterceptor): this;
+  /** GET 请求，返回解析后的 JSON */
+  protected get<T>(path: string, params?: Record<string, string>, options?: HttpRequestOptions): Promise<T>;
+  /** POST 请求，自动序列化 body 为 JSON */
+  protected post<T>(path: string, body?: unknown, params?: Record<string, string>, options?: HttpRequestOptions): Promise<T>;
+  /** PUT 请求 */
+  protected put<T>(path: string, body?: unknown, params?: Record<string, string>, options?: HttpRequestOptions): Promise<T>;
+  /** DELETE 请求 */
+  protected del<T>(path: string, params?: Record<string, string>, options?: HttpRequestOptions): Promise<T>;
+  /**
+   * 底层请求方法 — 子类可覆写以自定义行为
+   *
+   * 自动处理:
+   * - URL 拼接 (baseUrl + path + params)
+   * - SSRF 防护（IP 字面量同步校验 + 可选 DNS 解析校验）
+   * - 默认 headers 合并
+   * - JSON body 序列化
+   * - 响应 JSON 解析
+   * - 非 2xx 状态码抛出 HttpError
+   */
+  protected request<T>(method: string, path: string, options?: {
+    params?: Record<string, string>;
+    body?: unknown;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+  }): Promise<T>;
+  /** 构建完整 URL — 子类可覆写以自定义 URL 拼接逻辑 */
+  protected buildUrl(path: string, params?: Record<string, string>): string;
+}
+//#endregion
+//#region ../core/src/http/host-guard.d.ts
+/**
+ * host-guard — refuse outbound requests to private / loopback / reserved hosts.
+ *
+ * Why this exists: `HttpClient` and the raw `fetch` injected via DI both used
+ * to accept any URL the application built. SSR controllers that take a
+ * user-controlled URL (image proxy, link preview, OAuth callback) could be
+ * tricked into fetching `http://127.0.0.1/admin` and embedding the response in
+ * the SSR HTML. Round 1 of the adversarial drill walked straight through this;
+ * round 2's hand-rolled IPv4 regex was bypassed in five minutes with
+ * `[::ffff:7f00:1]`. This module centralises the check so applications can stop
+ * re-implementing it (badly).
+ *
+ * Coverage (synchronous, IP-literal forms):
+ * - IPv4 dotted-decimal: `127.0.0.1`, `10.0.0.5`, `192.168.1.1`, `172.16.0.1`
+ * - IPv4 zero / link-local / multicast / reserved: `0.0.0.0`, `169.254.0.1`,
+ *   `224.0.0.1`, `240.0.0.0/4`
+ * - IPv4 non-dotted forms accepted by some parsers: decimal `2130706433`,
+ *   hex `0x7f000001`, octal `0177.0.0.1`
+ * - IPv6 loopback `::1`, link-local `fe80::/10`, ULA `fc00::/7`, unspecified `::`
+ * - IPv4-mapped IPv6: `::ffff:7f00:1`, `::ffff:127.0.0.1`
+ * - Names: `localhost`, `*.localhost`
+ *
+ * NOT covered here (callers can layer on top):
+ * - DNS resolution of arbitrary hostnames — `enforceHostGuard` can preflight
+ *   answers, but connection-time enforcement requires a host transport such
+ *   as Node's `nodeSafeFetchOptions`, preserving hostname and TLS SNI.
+ * - IDN / homograph attacks — Node's URL parser punycode-encodes hostnames
+ *   already, so the hostname this code sees is the ASCII form.
+ */
+type HostCheckResult = {
+  ok: true;
+} | {
+  ok: false;
+  reason: string;
+};
+/**
+ * Inspect a hostname string (the `URL.hostname` value, without brackets, port,
+ * or userinfo). Returns `{ok: false}` for anything in a private/loopback/
+ * reserved range; `{ok: true}` if the literal looks like a public address or a
+ * non-IP name (the caller may then DNS-resolve and re-check).
+ */
+declare function classifyHost(rawHost: string): HostCheckResult;
+/**
+ * Convenience wrapper for callers holding a full URL string. Also rejects
+ * non-http(s) schemes (gopher, file, data, …).
+ */
+declare function classifyUrl(rawUrl: string): HostCheckResult;
+//#endregion
+//#region ../core/src/http/redirect-fetch.d.ts
+/** One redirect owner for protected clients and fixed-origin proxies. */
+declare function fetchWithRedirects(fetch: typeof globalThis.fetch, input: string | URL | Request, init: RequestInit | undefined, validate: (url: string) => void | Promise<void>): Promise<Response>;
+//#endregion
+//#region ../core/src/data/mapper.d.ts
+/**
+ * Mapper 类型工具 — 标准化数据转换管线
+ *
+ * 提供类型约定和组合函数，让 API 响应 → 页面模型 的转换有统一的签名模式。
+ */
+/** 同步映射函数 */
+type Mapper<TInput, TOutput> = (input: TInput) => TOutput;
+/** 异步映射函数 */
+type AsyncMapper<TInput, TOutput> = (input: TInput) => TOutput | Promise<TOutput>;
+/**
+ * 组合两个同步 Mapper: A → B → C
+ */
+declare function pipe<A, B, C>(m1: Mapper<A, B>, m2: Mapper<B, C>): Mapper<A, C>;
+/**
+ * 组合三个同步 Mapper: A → B → C → D
+ */
+declare function pipe<A, B, C, D>(m1: Mapper<A, B>, m2: Mapper<B, C>, m3: Mapper<C, D>): Mapper<A, D>;
+/**
+ * 组合四个同步 Mapper: A → B → C → D → E
+ */
+declare function pipe<A, B, C, D, E>(m1: Mapper<A, B>, m2: Mapper<B, C>, m3: Mapper<C, D>, m4: Mapper<D, E>): Mapper<A, E>;
+/**
+ * 组合任意数量的同步 Mapper
+ */
+declare function pipe(...mappers: Mapper<unknown, unknown>[]): Mapper<unknown, unknown>;
+/**
+ * 组合两个可能异步的 Mapper: A → B → C
+ */
+declare function pipeAsync<A, B, C>(m1: AsyncMapper<A, B>, m2: AsyncMapper<B, C>): AsyncMapper<A, C>;
+/**
+ * 组合三个可能异步的 Mapper
+ */
+declare function pipeAsync<A, B, C, D>(m1: AsyncMapper<A, B>, m2: AsyncMapper<B, C>, m3: AsyncMapper<C, D>): AsyncMapper<A, D>;
+/**
+ * 将一个 Mapper 应用到数组的每个元素
+ */
+declare function mapEach<TInput, TOutput>(mapper: Mapper<TInput, TOutput>): Mapper<TInput[], TOutput[]>;
+//#endregion
+//#region ../core/src/utils/lru-map.d.ts
+/**
+ * LruMap — 固定容量的 LRU 缓存
+ */
+declare class LruMap<K, V> {
+  private map;
+  private readonly capacity;
+  constructor(capacity: number);
+  get(key: K): V | undefined;
+  set(key: K, value: V): void;
+  has(key: K): boolean;
+  delete(key: K): boolean;
+  get size(): number;
+  clear(): void;
+  /** Iterate in eviction order: least recently used first. */
+  entries(): IterableIterator<[K, V]>;
+  [Symbol.iterator](): IterableIterator<[K, V]>;
+}
+//#endregion
+//#region ../core/src/utils/optional.d.ts
+/**
+ * Optional 类型工具
+ */
+type None = null | undefined;
+type Optional<T> = T | None;
+declare function isSome<T>(value: Optional<T>): value is T;
+declare function isNone<T>(value: Optional<T>): value is None;
+//#endregion
+//#region ../core/src/utils/url.d.ts
+/**
+ * URL 工具函数
+ */
+/** 移除 URL scheme (https://, http://) */
+declare function removeScheme(url: string): string;
+/** 移除 URL host 部分，保留路径 */
+declare function removeHost(url: string): string;
+/** 移除 query 参数 */
+declare function removeQueryParams(url: string): string;
+/** 获取 URL 的基础路径（无 query、hash） */
+declare function getBaseUrl(url: string): string;
+/** 构建 URL（路径 + query 参数） */
+declare function buildUrl(path: string, params?: Record<string, string | undefined>): string;
+//#endregion
+//#region ../core/src/utils/uuid.d.ts
+/**
+ * UUID v4 生成器
+ */
+declare function generateUuid(): string;
+//#endregion
+//#region ../core/src/metrics/composite-recorder.d.ts
+declare class CompositeEventRecorder implements EventRecorder {
+  private readonly recorders;
+  constructor(recorders: EventRecorder[]);
+  record(type: string, fields?: Record<string, unknown>): void;
+  flush(): Promise<void>;
+  destroy(): void;
+}
+//#endregion
+//#region ../core/src/metrics/console-recorder.d.ts
+declare class ConsoleEventRecorder implements EventRecorder {
+  private readonly prefix;
+  constructor(prefix?: string);
+  record(type: string, fields?: Record<string, unknown>): void;
+  flush(): Promise<void>;
+  destroy(): void;
+}
+//#endregion
+//#region ../core/src/metrics/void-recorder.d.ts
+declare class VoidEventRecorder implements EventRecorder {
+  record(): void;
+  flush(): Promise<void>;
+  destroy(): void;
+}
+//#endregion
+//#region ../core/src/metrics/with-fields-recorder.d.ts
+declare class WithFieldsRecorder implements EventRecorder {
+  private readonly inner;
+  private readonly providers;
+  constructor(inner: EventRecorder, providers: MetricsFieldsProvider[]);
+  record(type: string, fields?: Record<string, unknown>): void;
+  flush(): Promise<void>;
+  destroy(): void;
+}
+//#endregion
+//#region ../core/src/i18n/interpolate.d.ts
+/**
+ * ICU 消息格式插值
+ *
+ * 支持 `{name}` 占位符替换和基础复数规则。
+ */
+/** 将 `{key}` 占位符替换为 values 中的对应值 */
+declare function interpolate(template: string, values?: Record<string, string | number>): string;
+/**
+ * CLDR 复数类别
+ *
+ * 简化版：覆盖 zero / one / two / few / many / other。
+ * 完整 CLDR 规则可通过 PluralRuleProvider 注入。
+ */
+type PluralCategory = "zero" | "one" | "two" | "few" | "many" | "other";
+/** 复数规则函数 — 给定数量返回复数类别 */
+type PluralRuleProvider = (count: number) => PluralCategory;
+/**
+ * 英语复数规则（默认）
+ * 0 → other, 1 → one, 2+ → other
+ */
+declare function englishPlural(count: number): PluralCategory;
+/**
+ * 解析带复数后缀的翻译 key
+ *
+ * 约定: `key.one`, `key.other`, `key.zero`, etc.
+ */
+declare function resolvePluralKey(key: string, category: PluralCategory): string;
+//#endregion
+//#region ../core/src/i18n/locale.d.ts
+/** 检测语言是否为 RTL */
+declare function isRtl(language: string): boolean;
+/** 获取文本方向 */
+declare function getTextDirection(language: string): TextDirection;
+/**
+ * 从语言代码生成 HTML lang/dir 属性
+ *
+ * @example
+ * ```ts
+ * getLocaleAttributes("ar-SA") // { lang: "ar-SA", dir: "rtl" }
+ * getLocaleAttributes("en-US") // { lang: "en-US", dir: "ltr" }
+ * ```
+ */
+declare function getLocaleAttributes(language: string): LocaleAttributes;
+/**
+ * 构建 LocaleInfo
+ *
+ * @param language - 语言代码（如 "zh-Hans"）
+ * @param region - 地区代码（如 "CN"），可选
+ */
+declare function makeLocaleInfo(language: string, region?: string): LocaleInfo;
+/**
+ * 从 URL 前缀中提取 locale
+ *
+ * @param url - 请求 URL（如 "/zh/about"）
+ * @param supportedLocales - 支持的 locale 列表（如 ["zh", "en", "ja"]）
+ * @returns 匹配时返回 `{ locale, strippedUrl }`，不匹配返回 null
+ *
+ * @example
+ * ```ts
+ * resolveLocaleFromUrl("/zh/about", ["zh", "en"])
+ * // → { locale: "zh", strippedUrl: "/about" }
+ *
+ * resolveLocaleFromUrl("/about", ["zh", "en"])
+ * // → null
+ * ```
+ */
+declare function resolveLocaleFromUrl(url: string, supportedLocales: string[]): {
+  locale: string;
+  strippedUrl: string;
+} | null;
+//#endregion
+//#region ../core/src/i18n/translator.d.ts
+interface SimpleTranslatorOptions {
+  /** 翻译映射 */
+  messages: Record<string, string>;
+  /** 当前 locale */
+  locale: string;
+  /** 复数规则函数（默认英语规则） */
+  pluralRule?: PluralRuleProvider;
+  /** 找不到翻译时的回退行为（默认返回 key） */
+  fallback?: (key: string) => string;
+}
+declare class SimpleTranslator implements Translator {
+  readonly locale: string;
+  private readonly messages;
+  private readonly pluralRule;
+  private readonly fallback;
+  constructor(options: SimpleTranslatorOptions);
+  t(key: string, values?: Record<string, string | number>): string;
+  plural(key: string, count: number, values?: Record<string, string | number>): string;
+}
+//#endregion
+//#region ../core/src/application/operation.d.ts
+declare function defineOperation<I = undefined, O = unknown>(operation: Operation<I, O>): Operation<I, O>;
+declare function implementOperation<I, O>(operation: Operation<I, O>, handler: OperationHandler<I, O>): Implementation<I, O>;
+/** A fresh controller owns each call; reusable definitions never retain request state. */
+declare function implementController<I extends Record<string, unknown>, O>(operation: Operation<I, O>, create: () => BaseController<ControllerInput<I>, O>): Implementation<I, O>;
+//#endregion
+//#region ../core/src/application/definition.d.ts
+declare function defineModule(module: ModuleDefinition): ModuleDefinition;
+declare function defineApp(app: AppDefinition): AppDefinition;
+//#endregion
+//#region ../core/src/application/runtime.d.ts
+declare function createRuntime(options: RuntimeOptions): RuntimeHandle;
+//#endregion
+//#region ../web/src/models/safe-error-page.d.ts
+interface SafeErrorPageOptions {
+  /** HTTP-style status code used in the page title (e.g. 404, 500). */
+  status: number;
+  /**
+   * The message users / client code may safely see in production. Should
+   * contain no stack, file paths, hostnames, or secrets.
+   */
+  publicMessage: string;
+  /**
+   * Optional error / debug payload to surface only in non-production. In
+   * production this is dropped entirely; only `publicMessage` is exposed.
+   */
+  devError?: unknown;
+  /**
+   * Override the production detection. Pass `true` to force the prod-safe
+   * variant (drops devError). Defaults to true.
+   */
+  isProduction?: boolean;
+}
+/**
+ * Build a BasePage for an error condition. In production, only `publicMessage`
+ * makes it into the page. In dev, `devError` (if provided) is appended.
+ */
+declare function safeErrorPage(options: SafeErrorPageOptions): BasePage;
+//#endregion
+//#region ../web/src/application/route-input.d.ts
+type Simplify<T> = { [K in keyof T]: T[K]; };
+type OptionalKeys<Path extends string> = { [K in ExtractParamNames<Path>]: Path extends `${string}:${K}?` | `${string}:${K}?/${string}` ? K : never; }[ExtractParamNames<Path>];
+type PathInput<Path extends string> = string extends Path ? RouteParams : { [K in Exclude<ExtractParamNames<Path>, OptionalKeys<Path>>]: string; } & { [K in OptionalKeys<Path>]?: string; };
+type Params<R> = R extends {
+  params?: infer P extends Record<string, ParamSchema>;
+} ? R extends {
+  params: unknown;
+} ? InferParams<P> : {} | InferParams<P> : {};
+type Query<R> = R extends {
+  query?: infer Q extends QuerySchemaMap;
+} ? R extends {
+  query: unknown;
+} ? InferQuery<Q> : {} | InferQuery<Q> : {};
+type WithCodecs<Path extends string, P> = P extends unknown ? Simplify<Omit<PathInput<Path>, keyof P> & P> : never;
+type RouteInput<R> = R extends string ? {
+  params: Simplify<PathInput<R>>;
+  query: {};
+} : R extends {
+  path: infer Path extends string;
+} ? {
+  params: WithCodecs<Path, Params<R>>;
+  query: Query<R>;
+} : never;
+/** All accepted routes remain a union: a controller must handle every alias. */
+type RouteInputFor<Routes extends readonly (string | PageRoute)[]> = Routes extends readonly [] ? {
+  params: RouteParams;
+  query: RouteParams;
+} : RouteInput<Routes[number]>;
+/** Reject codec keys that cannot be captured by the corresponding path. */
+type ValidRoutes<Routes extends readonly (string | PageRoute)[]> = { [I in keyof Routes]: Routes[I] extends {
+  path: infer Path extends string;
+  params: infer P;
+} ? string extends Path ? Routes[I] : Exclude<keyof P, ExtractParamNames<Path>> extends never ? Routes[I] : never : Routes[I]; };
+//#endregion
+//#region ../web/src/navigation/nodes.d.ts
+/** 构造叶子节点（一个具体导航目标）。 */
+declare function leaf(intent: string, params?: RouteParams, options?: {
+  entryId?: string;
+  url?: string;
+  query?: 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 ../web/src/navigation/keys.d.ts
+/** Resource identity never identifies a page instance. */
+declare function resourceKey(intent: string, params: RouteParams, partition?: {
+  identity?: string;
+  locale?: string;
+}, query?: RouteParams): string;
+//#endregion
+//#region ../web/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[];
+/**
+ * 收集树中**全部存在**的叶子（含不可见：栈非顶 entry、未激活 tab 分支、所有非空 split 列）。
+ * 区别于 `collectVisibleDestinations`（只沿可见分支）—— 保活 / 缓存 prune / 作用域保留需要
+ * 全部 present 条目。顺序：栈按序、tabs 按 `Object.values(branches)` 序、split 按列序。
+ */
+declare function collectAllLeaves(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;
+/** Apply resolved route metadata to leaves without changing their instance identities. */
+declare function mapNavigationLeaves(tree: NavigationNode, transform: (leaf: LeafNode) => LeafNode): NavigationNode;
+//#endregion
+//#region ../web/src/session/snapshot.d.ts
+/** 把快照编码为确定性字符串（keys 排序），用作 `storage.set` 的值。 */
+declare function encodeSnapshot(snapshot: SessionSnapshot): string;
+/**
+ * 解码并校验快照。
+ *
+ * 校验：`version === expectedVersion`、`slices`/`scoped` 为对象、`capturedAt` 为数值；
+ * `navigation` 可缺省。任一不符或解析失败 → `undefined`（永不抛）。
+ */
+declare function decodeSnapshot(raw: string | undefined, expectedVersion: number): SessionSnapshot | undefined;
+//#endregion
+//#region ../web/src/session/scoped-state.d.ts
+/**
+ * 收集导航树中**全部 leaf** 的身份键（含不可见 / 未激活分支 / 各 split 列）。
+ * 委派给 `collectAllLeaves`（同一「全部存在」遍历），映射成 entryKey。
+ * 「全部存在」而非「可见」，用于 scoped 状态保留。
+ */
+declare function collectLeafKeys(tree: NavigationNode): string[];
+/**
+ * 创建导航作用域状态容器。
+ *
+ * 内部持一个 `Map`；`prune` 由 `presentKeys` 构造 `Set`，删除不在其中的全部键。
+ * `initial` 在构造时浅拷贝进 `Map`，构造后改动源对象不会泄漏进容器。
+ */
+declare function createNavigationScopedState(initial?: Record<string, unknown>): NavigationScopedState;
+//#endregion
+//#region ../web/src/session/session-store.d.ts
+/** One ordered persistence owner; implicit saves capture when their queue slot starts. */
+declare function createSessionStore(options: SessionStoreOptions): SessionStore;
+//#endregion
+//#region ../web/src/middleware/pipeline.d.ts
+/** 执行 beforeLoad 守卫链 */
+declare const runBeforeLoadGuards: (guards: ((ctx: NavigationContext) => MiddlewareResult | Promise<MiddlewareResult>)[], ctx: NavigationContext) => Promise<MiddlewareResult>;
+/** 执行 afterLoad 守卫链 */
+declare const runAfterLoadGuards: (guards: ((ctx: PostLoadContext) => MiddlewareResult | Promise<MiddlewareResult>)[], ctx: PostLoadContext) => Promise<MiddlewareResult>;
+//#endregion
+//#region ../web/src/application/definition.d.ts
+interface WebPlan {
+  readonly app: AppDefinition;
+  readonly router: Router;
+  readonly routes: readonly RouteDefinition[];
+  readonly operations: ReadonlyMap<string, Operation<RouteInput$1, BasePage>>;
+}
+declare function getWebPlan(definition: WebAppDefinition): WebPlan;
+declare function defineWebApp<const Pages extends readonly PageControllerDefinition[]>(input: WebAppDefinition<Pages>): WebAppDefinition<Pages>;
+//#endregion
+//#region ../web/src/application/load-page.d.ts
+interface LoadPageOptions {
+  readonly web: WebRuntime;
+  readonly target: string | LeafNode;
+  readonly execution?: ExecutionHandle;
+  readonly signal?: AbortSignal;
+  readonly retained?: BasePage;
+  readonly entryId?: string;
+  readonly createContext?: (input: {
+    url: string;
+    intent: RouteIntent;
+    execution: ExecutionHandle;
+  }) => NavigationContext;
+  readonly beforeLoad?: readonly BeforeLoadGuard[];
+  readonly afterLoad?: readonly AfterLoadGuard[];
+}
+type PageLoadResult = {
+  readonly kind: "page";
+  readonly page: BasePage;
+  readonly target: LeafNode;
+  readonly match?: RouteMatch;
+  readonly rewriteUrl?: string;
+} | {
+  readonly kind: "redirect";
+  readonly url: string;
+  readonly status: number;
+} | {
+  readonly kind: "deny";
+  readonly status: number;
+  readonly message: string;
+};
+/** One page pipeline, shared by URL, SSR and every visible tree destination. */
+declare function loadPage(options: LoadPageOptions): Promise<PageLoadResult>;
+//#endregion
+//#region ../web/src/application/initial-navigation.d.ts
+/** Resolve and validate once, then let an application arrange typed targets. */
+declare function resolveInitialNavigation(web: WebRuntime, url: string, options?: {
+  codec?: NavigationCodec;
+  initial?: WebAppDefinition["navigation"];
+}): Promise<{
+  tree: NavigationNode;
+  renderMode: string | undefined;
+} | undefined>;
+//#endregion
+//#region ../web/src/application/page.d.ts
+type ControllerParams<C> = C extends {
+  execute(input: {
+    params: infer P;
+  }): unknown;
+} ? P extends RouteParams ? P : RouteParams : RouteParams;
+/** Reference helpers emit existing declarations. Page type, operation id and entry id stay distinct. */
+interface PageReference<P extends RouteParams, R extends BasePage, Id extends string = string, Q extends RouteParams = RouteParams> extends PageControllerDefinition {
+  readonly id: Id;
+  route<const Path extends string>(path: Path): Readonly<{
+    path: Path;
+    intentId: Id;
+  }>;
+  route<const Path extends string, const Options extends Omit<PageRoute<Path>, "path">>(path: Path, options: Options & NoInfer<Record<Exclude<keyof Options, keyof Omit<PageRoute<Path>, "path">>, never>>): Readonly<{
+    path: Path;
+    intentId: Id;
+  } & Options>;
+  leaf(...args: {} extends Q ? {} extends P ? [params?: P, options?: {
+    url?: string;
+    query?: Q;
+  }] : [params: P, options?: {
+    url?: string;
+    query?: Q;
+  }] : [params: P, options: {
+    url?: string;
+    query: Q;
+  }]): LeafNode;
+  /** Explicit result pageType association; native component prop validation belongs to the UI adapter. */
+  bindView<const Type extends R["pageType"], View>(pageType: Type, view: View): Readonly<Record<Type, View>>;
+}
+declare function definePage<const Id extends string, const Routes extends readonly (string | PageRoute)[], R extends BasePage>(input: {
+  readonly id: Id;
+  readonly routes: Routes & NoInfer<ValidRoutes<Routes>>;
+  readonly handler: (params: NoInfer<RouteInputFor<Routes>["params"]>, context: ControllerContext, query: NoInfer<RouteInputFor<Routes>["query"]>) => R | Promise<R>;
+  readonly policies?: readonly OperationPolicy<NoInfer<RouteInputFor<Routes>["params"]>>[];
+}): PageReference<RouteInputFor<Routes>["params"], R, Id, RouteInputFor<Routes>["query"]>;
+declare function definePage<const Id extends string, const Routes extends readonly (string | PageRoute)[], R extends BasePage>(input: {
+  readonly id: Id;
+  readonly routes: Routes & NoInfer<ValidRoutes<Routes>>;
+  readonly create: () => {
+    perform: (params: NoInfer<RouteInputFor<Routes>["params"]>, context: ExecutionContext, query: NoInfer<RouteInputFor<Routes>["query"]>) => R | Promise<R>;
+  };
+  readonly policies?: readonly OperationPolicy<NoInfer<RouteInputFor<Routes>["params"]>>[];
+}): PageReference<RouteInputFor<Routes>["params"], R, Id, RouteInputFor<Routes>["query"]>;
+declare function definePage<const Id extends string, C extends {
+  perform(input: any, context: ExecutionContext): Promise<BasePage>;
+}>(input: {
+  readonly id: Id;
+  readonly routes?: undefined;
+  readonly create: () => C;
+  readonly policies?: readonly OperationPolicy<RouteParams>[];
+}): PageReference<ControllerParams<C>, Awaited<ReturnType<C["perform"]>>, Id>;
+declare function definePage<const Id extends string, P extends RouteParams, R extends BasePage>(input: {
+  readonly id: Id;
+  readonly routes?: undefined;
+  readonly handler: (params: P, context: ControllerContext) => R | Promise<R>;
+  readonly policies?: readonly OperationPolicy<RouteParams>[];
+}): PageReference<P, R, Id>;
+//#endregion
+//#region ../web/src/middleware/cookies.d.ts
+declare function parseCookieString(str: string): Map<string, string>;
+//#endregion
+export { SimpleTranslatorOptions as $, uuid as $t, setVisibility as A, fetchWithRedirects as At, split as B, HttpError as Bt, popTo as C, isSome as Ct, resolveActivePath as D, mapEach as Dt, replaceTop as E, Mapper as Et, isLeafNode as F, HttpClientConfig as Ft, safeErrorPage as G, withDefault as Gt, tabs as H, CompositeLogger as Ht, isSplitNode as I, HttpRequestOptions as It, defineModule as J, bool as Jt, createRuntime as K, NumOptions as Kt, isStackNode as L, RequestInterceptor as Lt, resourceKey as M, classifyHost as Mt, SplitColumnInit as N, classifyUrl as Nt, selectColumn as O, pipe as Ot, TabsInit as P, HttpClient as Pt, SimpleTranslator as Q, str as Qt, isTabsNode as R, ResponseInterceptor as Rt, pop as S, isNone as St, push as T, AsyncMapper as Tt, RouteInputFor as U, CompositeLoggerFactory as Ut, stack as V, stableStringify as Vt, SafeErrorPageOptions as W, optional as Wt, implementController as X, num as Xt, defineOperation as Y, int as Yt, implementOperation as Z, oneOf as Zt, collectAllLeaves as _, removeHost as _t, LoadPageOptions as a, PluralCategory as at, findNode as b, None as bt, defineWebApp as c, interpolate as ct, runBeforeLoadGuards as d, VoidEventRecorder as dt, getLocaleAttributes as et, createSessionStore as f, ConsoleEventRecorder as ft, encodeSnapshot as g, getBaseUrl as gt, decodeSnapshot as h, buildUrl as ht, resolveInitialNavigation as i, resolveLocaleFromUrl as it, visibleSplitColumns as j, HostCheckResult as jt, selectTab as k, pipeAsync as kt, getWebPlan as l, resolvePluralKey as lt, createNavigationScopedState as m, generateUuid as mt, PageReference as n, isRtl as nt, PageLoadResult as o, PluralRuleProvider as ot, collectLeafKeys as p, CompositeEventRecorder as pt, defineApp as q, StrOptions as qt, definePage as r, makeLocaleInfo as rt, loadPage as s, englishPlural as st, parseCookieString as t, getTextDirection as tt, runAfterLoadGuards as u, WithFieldsRecorder as ut, collectVisibleDestinations as v, removeQueryParams as vt, popToRoot as w, LruMap as wt, mapNavigationLeaves as x, Optional as xt, findNearestStack as y, removeScheme as yt, leaf as z, HostGuardError as zt };
+//# sourceMappingURL=cookies-Bpf9VayB.d.mts.map