@finesoft/front 0.1.2 → 0.1.11

package/dist/index.js

@@ -1,1040 +1,53 @@
-// ../core/dist/index.js
-var ACTION_KINDS = {
-  FLOW: "flow",
-  EXTERNAL_URL: "externalUrl",
-  COMPOUND: "compound"
-};
-function isFlowAction(action) {
-  return action.kind === ACTION_KINDS.FLOW;
-}
-function isExternalUrlAction(action) {
-  return action.kind === ACTION_KINDS.EXTERNAL_URL;
-}
-function isCompoundAction(action) {
-  return action.kind === ACTION_KINDS.COMPOUND;
-}
-function makeFlowAction(url, presentationContext) {
-  return { kind: ACTION_KINDS.FLOW, url, presentationContext };
-}
-function makeExternalUrlAction(url) {
-  return { kind: ACTION_KINDS.EXTERNAL_URL, url };
-}
-var ActionDispatcher = class {
-  handlers = /* @__PURE__ */ new Map();
-  wiredActions = /* @__PURE__ */ new Set();
-  /** 注册指定 kind 的 handler（防止重复注册） */
-  onAction(kind, handler) {
-    if (this.wiredActions.has(kind)) {
-      console.warn(
-        `[ActionDispatcher] kind="${kind}" already registered, skipping`
-      );
-      return;
-    }
-    this.wiredActions.add(kind);
-    this.handlers.set(kind, handler);
-  }
-  /** 执行一个 Action（CompoundAction 递归展开） */
-  async perform(action) {
-    if (isCompoundAction(action)) {
-      for (const subAction of action.actions) {
-        await this.perform(subAction);
-      }
-      return;
-    }
-    const handler = this.handlers.get(action.kind);
-    if (!handler) {
-      console.warn(
-        `[ActionDispatcher] No handler for kind="${action.kind}"`
-      );
-      return;
-    }
-    await handler(action);
-  }
-};
-var IntentDispatcher = class {
-  controllers = /* @__PURE__ */ new Map();
-  /** 注册一个 IntentController */
-  register(controller) {
-    this.controllers.set(controller.intentId, controller);
-  }
-  /** 分发 Intent 到对应 Controller */
-  async dispatch(intent, container) {
-    const controller = this.controllers.get(intent.id);
-    if (!controller) {
-      throw new Error(
-        `[IntentDispatcher] No controller for "${intent.id}". Registered: [${Array.from(this.controllers.keys()).join(", ")}]`
-      );
-    }
-    return controller.perform(intent, container);
-  }
-  /** 检查是否已注册某个 Intent */
-  has(intentId) {
-    return this.controllers.has(intentId);
-  }
-};
-var Container = class {
-  registrations = /* @__PURE__ */ new Map();
-  /** 注册依赖（默认单例） */
-  register(key, factory, singleton = true) {
-    this.registrations.set(key, { factory, singleton });
-    return this;
-  }
-  /** 解析依赖 */
-  resolve(key) {
-    const reg = this.registrations.get(key);
-    if (!reg) {
-      throw new Error(`[Container] No registration for key: "${key}"`);
-    }
-    if (reg.singleton) {
-      if (reg.instance === void 0) {
-        reg.instance = reg.factory();
-      }
-      return reg.instance;
-    }
-    return reg.factory();
-  }
-  /** 检查是否已注册 */
-  has(key) {
-    return this.registrations.has(key);
-  }
-  /** 销毁容器，清除所有缓存 */
-  dispose() {
-    for (const reg of this.registrations.values()) {
-      reg.instance = void 0;
-    }
-    this.registrations.clear();
-  }
-};
-var BaseLogger = class {
-  category;
-  constructor(category) {
-    this.category = category;
-  }
-};
-var LEVEL_TO_NUM = {
-  "*": 4,
-  debug: 4,
-  info: 3,
-  warn: 2,
-  error: 1,
-  off: 0,
-  "": 0
-};
-var cachedRules;
-var cachedRaw;
-function parseRules() {
-  if (typeof globalThis.localStorage === "undefined") {
-    return {};
-  }
-  let raw;
-  try {
-    raw = globalThis.localStorage.getItem("onyxLog");
-  } catch {
-    return {};
-  }
-  if (!raw) return {};
-  if (raw === cachedRaw && cachedRules) return cachedRules;
-  cachedRaw = raw;
-  const rules = {};
-  const parts = raw.split(",");
-  for (const part of parts) {
-    const [name, level] = part.trim().split("=");
-    if (!name || level === void 0) continue;
-    const num = LEVEL_TO_NUM[level.toLowerCase()] ?? void 0;
-    if (num === void 0) continue;
-    if (name === "*") {
-      rules.defaultLevel = num;
-    } else {
-      rules.named ??= {};
-      rules.named[name] = num;
-    }
-  }
-  cachedRules = rules;
-  return rules;
-}
-function shouldLog(name, level) {
-  const rules = parseRules();
-  if (rules.defaultLevel === void 0 && !rules.named) {
-    return true;
-  }
-  const currentNum = LEVEL_TO_NUM[level] ?? 4;
-  if (rules.named?.[name] !== void 0) {
-    return currentNum <= rules.named[name];
-  }
-  if (rules.defaultLevel !== void 0) {
-    return currentNum <= rules.defaultLevel;
-  }
-  return true;
-}
-function resetFilterCache() {
-  cachedRules = void 0;
-  cachedRaw = void 0;
-}
-var ConsoleLogger = class extends BaseLogger {
-  debug(...args) {
-    if (shouldLog(this.category, "debug")) {
-      console.debug(`[${this.category}]`, ...args);
-    }
-    return "";
-  }
-  info(...args) {
-    if (shouldLog(this.category, "info")) {
-      console.info(`[${this.category}]`, ...args);
-    }
-    return "";
-  }
-  warn(...args) {
-    if (shouldLog(this.category, "warn")) {
-      console.warn(`[${this.category}]`, ...args);
-    }
-    return "";
-  }
-  error(...args) {
-    console.error(`[${this.category}]`, ...args);
-    return "";
-  }
-};
-var ConsoleLoggerFactory = class {
-  loggerFor(category) {
-    return new ConsoleLogger(category);
-  }
-};
-var DEP_KEYS = {
-  LOGGER: "logger",
-  LOGGER_FACTORY: "loggerFactory",
-  NET: "net",
-  LOCALE: "locale",
-  STORAGE: "storage",
-  FEATURE_FLAGS: "featureFlags",
-  METRICS: "metrics",
-  FETCH: "fetch"
-};
-var DefaultLocale = class {
-  language = "en";
-  storefront = "us";
-  setActiveLocale(language, storefront) {
-    this.language = language;
-    this.storefront = storefront;
-  }
-};
-var MemoryStorage = class {
-  store = /* @__PURE__ */ new Map();
-  get(key) {
-    return this.store.get(key);
-  }
-  set(key, value) {
-    this.store.set(key, value);
-  }
-  delete(key) {
-    this.store.delete(key);
-  }
-};
-var DefaultFeatureFlags = class {
-  flags;
-  constructor(flags = {}) {
-    this.flags = flags;
-  }
-  isEnabled(key) {
-    return this.flags[key] === true;
-  }
-  getString(key) {
-    const v = this.flags[key];
-    return typeof v === "string" ? v : void 0;
-  }
-  getNumber(key) {
-    const v = this.flags[key];
-    return typeof v === "number" ? v : void 0;
-  }
-};
-var ConsoleMetrics = class {
-  recordPageView(page, fields) {
-    console.info(`[Metrics:PageView] ${page}`, fields ?? "");
-  }
-  recordEvent(name, fields) {
-    console.info(`[Metrics:Event] ${name}`, fields ?? "");
-  }
-};
-function makeDependencies(container, options = {}) {
-  const {
-    fetch: fetchFn = globalThis.fetch?.bind(globalThis),
-    language = "en",
-    storefront = "us",
-    featureFlags = {}
-  } = options;
-  const loggerFactory = new ConsoleLoggerFactory();
-  container.register(
-    DEP_KEYS.LOGGER_FACTORY,
-    () => loggerFactory
-  );
-  container.register(
-    DEP_KEYS.LOGGER,
-    () => loggerFactory.loggerFor("framework")
-  );
-  container.register(DEP_KEYS.NET, () => ({
-    fetch: (url, opts) => fetchFn(url, opts)
-  }));
-  container.register(DEP_KEYS.LOCALE, () => {
-    const locale = new DefaultLocale();
-    locale.setActiveLocale(language, storefront);
-    return locale;
-  });
-  container.register(DEP_KEYS.STORAGE, () => new MemoryStorage());
-  container.register(
-    DEP_KEYS.FEATURE_FLAGS,
-    () => new DefaultFeatureFlags(featureFlags)
-  );
-  container.register(
-    DEP_KEYS.METRICS,
-    () => new ConsoleMetrics()
-  );
-  container.register(DEP_KEYS.FETCH, () => fetchFn);
-}
-var Router = class {
-  routes = [];
-  /** 添加路由规则 */
-  add(pattern, intentId) {
-    const paramNames = [];
-    const regexStr = pattern.replace(
-      /\/:(\w+)(\?)?/g,
-      (_, name, optional) => {
-        paramNames.push(name);
-        return optional ? "(?:/([^/]+))?" : "/([^/]+)";
-      }
-    );
-    this.routes.push({
-      pattern,
-      intentId,
-      regex: new RegExp(`^${regexStr}/?$`),
-      paramNames
-    });
-    return this;
-  }
-  /** 解析 URL → RouteMatch */
-  resolve(urlOrPath) {
-    const path = this.extractPath(urlOrPath);
-    const queryParams = this.extractQueryParams(urlOrPath);
-    for (const route of this.routes) {
-      const match = path.match(route.regex);
-      if (match) {
-        const params = {};
-        route.paramNames.forEach((name, index) => {
-          const value = match[index + 1];
-          if (value) params[name] = value;
-        });
-        for (const [k, v] of Object.entries(queryParams)) {
-          if (!(k in params)) params[k] = v;
-        }
-        return {
-          intent: { id: route.intentId, params },
-          action: makeFlowAction(urlOrPath)
-        };
-      }
-    }
-    return null;
-  }
-  /** 获取所有已注册的路由 */
-  getRoutes() {
-    return this.routes.map((r) => `${r.pattern} \u2192 ${r.intentId}`);
-  }
-  extractPath(url) {
-    try {
-      const parsed = new URL(url, "http://localhost");
-      return parsed.pathname;
-    } catch {
-      return url.split("?")[0].split("#")[0];
-    }
-  }
-  extractQueryParams(url) {
-    try {
-      const parsed = new URL(url, "http://localhost");
-      const params = {};
-      parsed.searchParams.forEach((v, k) => {
-        params[k] = v;
-      });
-      return params;
-    } catch {
-      return {};
-    }
-  }
-};
-var CompositeLoggerFactory = class {
-  constructor(factories) {
-    this.factories = factories;
-  }
-  loggerFor(name) {
-    return new CompositeLogger(
-      this.factories.map((f) => f.loggerFor(name))
-    );
-  }
-};
-var CompositeLogger = class {
-  constructor(loggers) {
-    this.loggers = loggers;
-  }
-  debug(...args) {
-    return this.callAll("debug", args);
-  }
-  info(...args) {
-    return this.callAll("info", args);
-  }
-  warn(...args) {
-    return this.callAll("warn", args);
-  }
-  error(...args) {
-    return this.callAll("error", args);
-  }
-  callAll(method, args) {
-    for (const logger of this.loggers) {
-      logger[method](...args);
-    }
-    return "";
-  }
-};
-function stableStringify(obj) {
-  if (obj === null || obj === void 0) return String(obj);
-  if (typeof obj !== "object") return JSON.stringify(obj);
-  if (Array.isArray(obj)) {
-    return "[" + obj.map(stableStringify).join(",") + "]";
-  }
-  const keys = Object.keys(obj).sort();
-  const parts = keys.filter((k) => obj[k] !== void 0).map(
-    (k) => JSON.stringify(k) + ":" + stableStringify(obj[k])
-  );
-  return "{" + parts.join(",") + "}";
-}
-var PrefetchedIntents = class _PrefetchedIntents {
-  intents;
-  constructor(intents) {
-    this.intents = intents;
-  }
-  /** 从 PrefetchedIntent 数组创建缓存实例 */
-  static fromArray(items) {
-    const map = /* @__PURE__ */ new Map();
-    for (const item of items) {
-      if (item.intent && item.data !== void 0) {
-        const key = stableStringify(item.intent);
-        map.set(key, item.data);
-      }
-    }
-    return new _PrefetchedIntents(map);
-  }
-  /** 创建空缓存实例 */
-  static empty() {
-    return new _PrefetchedIntents(/* @__PURE__ */ new Map());
-  }
-  /**
-   * 获取缓存的 Intent 结果（一次性使用）。
-   * 命中后从缓存中删除。
-   */
-  get(intent) {
-    const key = stableStringify(intent);
-    const data = this.intents.get(key);
-    if (data !== void 0) {
-      this.intents.delete(key);
-      return data;
-    }
-    return void 0;
-  }
-  /** 检查缓存中是否有某个 Intent 的数据 */
-  has(intent) {
-    return this.intents.has(stableStringify(intent));
-  }
-  /** 缓存中的条目数 */
-  get size() {
-    return this.intents.size;
-  }
-};
-var Framework = class _Framework {
-  container;
-  intentDispatcher;
-  actionDispatcher;
-  router;
-  prefetchedIntents;
-  constructor(container, prefetchedIntents) {
-    this.container = container;
-    this.intentDispatcher = new IntentDispatcher();
-    this.actionDispatcher = new ActionDispatcher();
-    this.router = new Router();
-    this.prefetchedIntents = prefetchedIntents;
-  }
-  /** 创建并初始化 Framework 实例 */
-  static create(config = {}) {
-    const container = new Container();
-    makeDependencies(container, config);
-    const fw = new _Framework(
-      container,
-      config.prefetchedIntents ?? PrefetchedIntents.empty()
-    );
-    config.setupRoutes?.(fw.router);
-    return fw;
-  }
-  /** 分发 Intent — 获取页面数据 */
-  async dispatch(intent) {
-    const logger = this.container.resolve(DEP_KEYS.LOGGER);
-    const cached = this.prefetchedIntents.get(intent);
-    if (cached !== void 0) {
-      logger.debug(
-        `[Framework] re-using prefetched intent response for: ${intent.id}`,
-        intent.params
-      );
-      return cached;
-    }
-    logger.debug(
-      `[Framework] dispatch intent: ${intent.id}`,
-      intent.params
-    );
-    return this.intentDispatcher.dispatch(intent, this.container);
-  }
-  /** 执行 Action — 处理用户交互 */
-  async perform(action) {
-    const logger = this.container.resolve(DEP_KEYS.LOGGER);
-    logger.debug(`[Framework] perform action: ${action.kind}`);
-    return this.actionDispatcher.perform(action);
-  }
-  /** 路由 URL — 将 URL 解析为 Intent + Action */
-  routeUrl(url) {
-    return this.router.resolve(url);
-  }
-  /** 记录页面访问事件 */
-  didEnterPage(page) {
-    const metrics = this.container.resolve(
-      DEP_KEYS.METRICS
-    );
-    metrics.recordPageView(page.pageType, {
-      pageId: page.id,
-      title: page.title
-    });
-  }
-  /** 注册 Action 处理器 */
-  onAction(kind, handler) {
-    this.actionDispatcher.onAction(kind, handler);
-  }
-  /** 注册 Intent Controller */
-  registerIntent(controller) {
-    this.intentDispatcher.register(controller);
-  }
-  /** 销毁 Framework 实例 */
-  dispose() {
-    this.container.dispose();
-  }
-};
-var HttpError = class extends Error {
-  constructor(status, statusText, body) {
-    super(`HTTP ${status}: ${statusText}`);
-    this.status = status;
-    this.statusText = statusText;
-    this.body = body;
-    this.name = "HttpError";
-  }
-};
-var HttpClient = class {
-  baseUrl;
-  defaultHeaders;
-  fetchFn;
-  constructor(config) {
-    this.baseUrl = config.baseUrl;
-    this.defaultHeaders = config.defaultHeaders ?? {};
-    this.fetchFn = config.fetch ?? globalThis.fetch.bind(globalThis);
-  }
-  /** GET 请求，返回解析后的 JSON */
-  async get(path, params) {
-    return this.request("GET", path, { params });
-  }
-  /** POST 请求，自动序列化 body 为 JSON */
-  async post(path, body, params) {
-    return this.request("POST", path, { body, params });
-  }
-  /** PUT 请求 */
-  async put(path, body, params) {
-    return this.request("PUT", path, { body, params });
-  }
-  /** DELETE 请求 */
-  async del(path, params) {
-    return this.request("DELETE", path, { params });
-  }
-  /**
-   * 底层请求方法 — 子类可覆写以自定义行为
-   *
-   * 自动处理:
-   * - URL 拼接 (baseUrl + path + params)
-   * - 默认 headers 合并
-   * - JSON body 序列化
-   * - 响应 JSON 解析
-   * - 非 2xx 状态码抛出 HttpError
-   */
-  async request(method, path, options) {
-    const url = this.buildUrl(path, options?.params);
-    const headers = {
-      ...this.defaultHeaders,
-      ...options?.headers
-    };
-    const init = { method, headers };
-    if (options?.body !== void 0) {
-      headers["Content-Type"] = headers["Content-Type"] ?? "application/json";
-      init.body = JSON.stringify(options.body);
-    }
-    const response = await this.fetchFn(url, init);
-    if (!response.ok) {
-      const body = await response.text().catch(() => void 0);
-      throw new HttpError(response.status, response.statusText, body);
-    }
-    return response.json();
-  }
-  /** 构建完整 URL — 子类可覆写以自定义 URL 拼接逻辑 */
-  buildUrl(path, params) {
-    const base = this.baseUrl.endsWith("/") ? this.baseUrl.slice(0, -1) : this.baseUrl;
-    const normalizedPath = path.startsWith("/") ? path : `/${path}`;
-    const url = new URL(`${base}${normalizedPath}`, "http://placeholder");
-    if (params) {
-      for (const [k, v] of Object.entries(params)) {
-        url.searchParams.set(k, v);
-      }
-    }
-    if (this.baseUrl.startsWith("http")) {
-      return url.toString();
-    }
-    return `${url.pathname}${url.search}`;
-  }
-};
-var BaseController = class {
-  /**
-   * 错误回退 — 子类可选覆写
-   *
-   * 当 execute() 抛出异常时调用。
-   * 默认行为: 重新抛出原始错误。
-   *
-   * @param params - Intent 参数
-   * @param error - execute() 抛出的错误
-   * @returns 回退数据
-   */
-  fallback(params, error) {
-    throw error;
-  }
-  /**
-   * IntentController.perform() 实现
-   *
-   * 自动 try/catch → fallback 模式。
-   */
-  async perform(intent, container) {
-    const params = intent.params ?? {};
-    try {
-      return await this.execute(params, container);
-    } catch (e) {
-      return this.fallback(
-        params,
-        e instanceof Error ? e : new Error(String(e))
-      );
-    }
-  }
-};
-function pipe(...mappers) {
-  return (input) => mappers.reduce((acc, mapper) => mapper(acc), input);
-}
-function pipeAsync(...mappers) {
-  return async (input) => {
-    let acc = input;
-    for (const mapper of mappers) {
-      acc = await mapper(acc);
-    }
-    return acc;
-  };
-}
-function mapEach(mapper) {
-  return (items) => items.map(mapper);
-}
-function defineRoutes(framework, definitions) {
-  const registeredIntents = /* @__PURE__ */ new Set();
-  for (const def of definitions) {
-    if (def.controller && !registeredIntents.has(def.intentId)) {
-      framework.registerIntent(def.controller);
-      registeredIntents.add(def.intentId);
-    }
-    framework.router.add(def.path, def.intentId);
-  }
-}
-var LruMap = class {
-  map = /* @__PURE__ */ new Map();
-  capacity;
-  constructor(capacity) {
-    this.capacity = capacity;
-  }
-  get(key) {
-    const value = this.map.get(key);
-    if (value !== void 0) {
-      this.map.delete(key);
-      this.map.set(key, value);
-    }
-    return value;
-  }
-  set(key, value) {
-    if (this.map.has(key)) {
-      this.map.delete(key);
-    } else if (this.map.size >= this.capacity) {
-      const oldest = this.map.keys().next().value;
-      if (oldest !== void 0) {
-        this.map.delete(oldest);
-      }
-    }
-    this.map.set(key, value);
-  }
-  has(key) {
-    return this.map.has(key);
-  }
-  delete(key) {
-    return this.map.delete(key);
-  }
-  get size() {
-    return this.map.size;
-  }
-  clear() {
-    this.map.clear();
-  }
-};
-function isSome(value) {
-  return value !== null && value !== void 0;
-}
-function isNone(value) {
-  return value === null || value === void 0;
-}
-function removeScheme(url) {
-  return url.replace(/^https?:\/\//, "");
-}
-function removeHost(url) {
-  try {
-    const parsed = new URL(url);
-    return parsed.pathname + parsed.search + parsed.hash;
-  } catch {
-    return url;
-  }
-}
-function removeQueryParams(url) {
-  return url.split("?")[0];
-}
-function getBaseUrl(url) {
-  return url.split("?")[0].split("#")[0];
-}
-function buildUrl(path, params) {
-  if (!params) return path;
-  const searchParams = new URLSearchParams();
-  for (const [key, value] of Object.entries(params)) {
-    if (value !== void 0) {
-      searchParams.set(key, value);
-    }
-  }
-  const qs = searchParams.toString();
-  return qs ? `${path}?${qs}` : path;
-}
-function generateUuid() {
-  if (typeof crypto !== "undefined" && crypto.randomUUID) {
-    return crypto.randomUUID();
-  }
-  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-    const r = Math.random() * 16 | 0;
-    const v = c === "x" ? r : r & 3 | 8;
-    return v.toString(16);
-  });
-}
-
-// ../browser/dist/index.js
-function registerExternalUrlHandler(deps) {
-  const { framework, log } = deps;
-  framework.onAction(
-    ACTION_KINDS.EXTERNAL_URL,
-    (action) => {
-      log.debug(`ExternalUrlAction \u2192 ${action.url}`);
-      window.open(action.url, "_blank", "noopener,noreferrer");
-    }
-  );
-}
-var MAX_TRIES = 100;
-var FUDGE = 16;
-var pendingFrame = null;
-function tryScroll(log, getScrollableElement, scrollY) {
-  if (pendingFrame !== null) {
-    cancelAnimationFrame(pendingFrame);
-    pendingFrame = null;
-  }
-  let tries = 0;
-  pendingFrame = requestAnimationFrame(function attempt() {
-    if (++tries >= MAX_TRIES) {
-      log.warn(
-        `tryScroll: gave up after ${MAX_TRIES} frames, target=${scrollY}`
-      );
-      pendingFrame = null;
-      return;
-    }
-    const el = getScrollableElement();
-    if (!el) {
-      log.warn(
-        "could not restore scroll: the scrollable element is missing"
-      );
-      return;
-    }
-    const { scrollHeight, offsetHeight } = el;
-    const canScroll = scrollY + offsetHeight <= scrollHeight + FUDGE;
-    if (!canScroll) {
-      log.info("page is not tall enough for scroll yet", {
-        scrollHeight,
-        offsetHeight
-      });
-      pendingFrame = requestAnimationFrame(attempt);
-      return;
-    }
-    el.scrollTop = scrollY;
-    log.info("scroll restored to", scrollY);
-    pendingFrame = null;
-  });
-}
-var HISTORY_SIZE_LIMIT = 10;
-var History = class {
-  entries;
-  log;
-  getScrollablePageElement;
-  currentStateId;
-  constructor(log, options, sizeLimit = HISTORY_SIZE_LIMIT) {
-    this.entries = new LruMap(sizeLimit);
-    this.log = log;
-    this.getScrollablePageElement = options.getScrollablePageElement;
-  }
-  replaceState(state, url) {
-    const id = generateUuid();
-    window.history.replaceState({ id }, "", url);
-    this.currentStateId = id;
-    this.entries.set(id, { state, scrollY: 0 });
-    this.scrollTop = 0;
-    this.log.info("replaceState", state, url, id);
-  }
-  pushState(state, url) {
-    const id = generateUuid();
-    window.history.pushState({ id }, "", url);
-    this.currentStateId = id;
-    this.entries.set(id, { state, scrollY: 0 });
-    this.scrollTop = 0;
-    this.log.info("pushState", state, url, id);
-  }
-  beforeTransition() {
-    const { state } = window.history;
-    if (!state) return;
-    const oldEntry = this.entries.get(state.id);
-    if (!oldEntry) {
-      this.log.info(
-        "current history state evicted from LRU, not saving scroll position"
-      );
-      return;
-    }
-    const { scrollTop } = this;
-    this.entries.set(state.id, { ...oldEntry, scrollY: scrollTop });
-    this.log.info("saving scroll position", scrollTop);
-  }
-  onPopState(listener) {
-    window.addEventListener("popstate", (event) => {
-      this.currentStateId = event.state?.id;
-      if (!this.currentStateId) {
-        this.log.warn(
-          "encountered a null event.state.id in onPopState event:",
-          window.location.href
-        );
-      }
-      this.log.info("popstate", this.entries, this.currentStateId);
-      const entry = this.currentStateId ? this.entries.get(this.currentStateId) : void 0;
-      listener(window.location.href, entry?.state);
-      if (!entry) {
-        return;
-      }
-      const { scrollY } = entry;
-      this.log.info("restoring scroll to", scrollY);
-      tryScroll(this.log, () => this.getScrollablePageElement(), scrollY);
-    });
-  }
-  updateState(update) {
-    if (!this.currentStateId) {
-      this.log.warn(
-        "failed: encountered a null currentStateId inside updateState"
-      );
-      return;
-    }
-    const currentState = this.entries.get(this.currentStateId);
-    const newState = update(currentState?.state);
-    this.log.info("updateState", newState, this.currentStateId);
-    this.entries.set(this.currentStateId, {
-      ...currentState,
-      state: newState
-    });
-  }
-  get scrollTop() {
-    return this.getScrollablePageElement()?.scrollTop || 0;
-  }
-  set scrollTop(scrollTop) {
-    const element = this.getScrollablePageElement();
-    if (element) {
-      element.scrollTop = scrollTop;
-    }
-  }
-};
-function registerFlowActionHandler(deps) {
-  const { framework, log, callbacks, updateApp } = deps;
-  let isFirstPage = true;
-  const history = new History(log, {
-    getScrollablePageElement: () => document.getElementById("scrollable-page-override") || document.getElementById("scrollable-page") || document.documentElement
-  });
-  framework.onAction(ACTION_KINDS.FLOW, async (action) => {
-    const flowAction = action;
-    const url = flowAction.url;
-    log.debug(`FlowAction \u2192 ${url}`);
-    if (flowAction.presentationContext === "modal") {
-      const match2 = framework.routeUrl(url);
-      if (match2) {
-        const page = await framework.dispatch(
-          match2.intent
-        );
-        callbacks.onModal(page);
-      }
-      return;
-    }
-    const shouldReplace = isFirstPage;
-    const match = framework.routeUrl(url);
-    if (!match) {
-      log.warn(`FlowAction: no route for ${url}`);
-      return;
-    }
-    const pagePromise = framework.dispatch(
-      match.intent
-    );
-    await Promise.race([
-      pagePromise,
-      new Promise((r) => setTimeout(r, 500))
-    ]).catch(() => {
-    });
-    history.beforeTransition();
-    updateApp({
-      page: pagePromise.then((page) => {
-        const canonicalURL = url;
-        if (shouldReplace) {
-          history.replaceState({ page }, canonicalURL);
-        } else {
-          history.pushState({ page }, canonicalURL);
-        }
-        callbacks.onNavigate(
-          new URL(canonicalURL, window.location.origin).pathname
-        );
-        didEnterPage(page);
-        return page;
-      }),
-      isFirstPage
-    });
-    isFirstPage = false;
-  });
-  history.onPopState(async (url, cachedState) => {
-    log.debug(`popstate \u2192 ${url}, cached=${!!cachedState}`);
-    callbacks.onNavigate(new URL(url).pathname);
-    if (cachedState) {
-      const { page } = cachedState;
-      didEnterPage(page);
-      updateApp({ page, isFirstPage });
-      return;
-    }
-    const parsed = new URL(url);
-    const routeMatch = framework.routeUrl(parsed.pathname + parsed.search);
-    if (!routeMatch) {
-      log.error(
-        "received popstate without data, but URL was unroutable:",
-        url
-      );
-      didEnterPage(null);
-      updateApp({
-        page: Promise.reject(new Error("404")),
-        isFirstPage
-      });
-      return;
-    }
-    const pagePromise = framework.dispatch(
-      routeMatch.intent
-    );
-    await Promise.race([
-      pagePromise,
-      new Promise((r) => setTimeout(r, 500))
-    ]).catch(() => {
-    });
-    updateApp({
-      page: pagePromise.then((page) => {
-        didEnterPage(page);
-        return page;
-      }),
-      isFirstPage
-    });
-  });
-  function didEnterPage(page) {
-    (async () => {
-      try {
-        if (page) {
-          await framework.didEnterPage(page);
-        }
-      } catch (e) {
-        log.error("didEnterPage error:", e);
-      }
-    })();
-  }
-}
-function registerActionHandlers(deps) {
-  const { framework, log, callbacks, updateApp } = deps;
-  registerFlowActionHandler({
-    framework,
-    log,
-    callbacks,
-    updateApp
-  });
-  registerExternalUrlHandler({ framework, log });
-}
-var SERVER_DATA_ID = "serialized-server-data";
-function deserializeServerData() {
-  const script = document.getElementById(SERVER_DATA_ID);
-  if (!script?.textContent) return void 0;
-  script.parentNode?.removeChild(script);
-  try {
-    return JSON.parse(script.textContent);
-  } catch {
-    return void 0;
-  }
-}
-function createPrefetchedIntentsFromDom() {
-  const data = deserializeServerData();
-  if (!data || !Array.isArray(data)) {
-    return PrefetchedIntents.empty();
-  }
-  return PrefetchedIntents.fromArray(data);
-}
-async function startBrowserApp(config) {
-  const { bootstrap, defaultLocale = "en", mount, callbacks } = config;
-  const prefetchedIntents = createPrefetchedIntentsFromDom();
-  const framework = Framework.create({ prefetchedIntents });
-  bootstrap(framework);
-  const loggerFactory = framework.container.resolve(
-    DEP_KEYS.LOGGER_FACTORY
-  );
-  const log = loggerFactory.loggerFor("browser");
-  const initialAction = framework.routeUrl(
-    window.location.pathname + window.location.search
-  );
-  const locale = document.documentElement.lang || defaultLocale;
-  const target = document.getElementById("app");
-  const updateApp = mount(target, { framework, locale });
-  registerActionHandlers({
-    framework,
-    log,
-    callbacks,
-    updateApp
-  });
-  if (initialAction) {
-    await framework.perform(initialAction.action);
-  } else {
-    updateApp({
-      page: Promise.reject(new Error("404")),
-      isFirstPage: true
-    });
-  }
-}
+import {
+  ACTION_KINDS,
+  ActionDispatcher,
+  BaseController,
+  BaseLogger,
+  CompositeLogger,
+  CompositeLoggerFactory,
+  ConsoleLogger,
+  ConsoleLoggerFactory,
+  Container,
+  DEP_KEYS,
+  Framework,
+  History,
+  HttpClient,
+  HttpError,
+  IntentDispatcher,
+  LruMap,
+  PrefetchedIntents,
+  Router,
+  buildUrl,
+  createPrefetchedIntentsFromDom,
+  defineRoutes,
+  deserializeServerData,
+  generateUuid,
+  getBaseUrl,
+  isCompoundAction,
+  isExternalUrlAction,
+  isFlowAction,
+  isNone,
+  isSome,
+  makeDependencies,
+  makeExternalUrlAction,
+  makeFlowAction,
+  mapEach,
+  pipe,
+  pipeAsync,
+  registerActionHandlers,
+  registerExternalUrlHandler,
+  registerFlowActionHandler,
+  removeHost,
+  removeQueryParams,
+  removeScheme,
+  resetFilterCache,
+  shouldLog,
+  stableStringify,
+  startBrowserApp,
+  tryScroll
+} from "./chunk-OVGQ4NUA.js";
 
-// ../ssr/dist/index.js
+// ../ssr/src/render.ts
 async function ssrRender(options) {
   const { url, frameworkConfig, bootstrap, getErrorPage, renderApp } = options;
   const framework = Framework.create(frameworkConfig);
@@ -1063,6 +76,8 @@ async function ssrRender(options) {
     serverData
   };
 }
+
+// ../ssr/src/create-render.ts
 function createSSRRender(config) {
   const { bootstrap, getErrorPage, renderApp, frameworkConfig } = config;
   return (url, locale) => ssrRender({
@@ -1073,12 +88,25 @@ function createSSRRender(config) {
     renderApp: (page) => renderApp(page, locale)
   });
 }
+
+// ../ssr/src/inject.ts
+var SSR_PLACEHOLDERS = {
+  LANG: "<!--ssr-lang-->",
+  HEAD: "<!--ssr-head-->",
+  BODY: "<!--ssr-body-->",
+  DATA: "<!--ssr-data-->"
+};
 function injectSSRContent(options) {
   const { template, locale, head, css, html, serializedData } = options;
   const cssTag = css ? `<style>${css}</style>` : "";
-  return template.replace("<!--ssr-lang-->", locale).replace("<!--ssr-head-->", `${head}
-${cssTag}`).replace("<!--ssr-body-->", html).replace("<!--ssr-data-->", serializedData);
+  return template.replace(SSR_PLACEHOLDERS.LANG, locale).replace(SSR_PLACEHOLDERS.HEAD, `${head}
+${cssTag}`).replace(SSR_PLACEHOLDERS.BODY, html).replace(
+    SSR_PLACEHOLDERS.DATA,
+    `<script id="serialized-server-data" type="application/json">${serializedData}</script>`
+  );
 }
+
+// ../ssr/src/server-data.ts
 var HTML_REPLACEMENTS = {
   "<": "\\u003C",
   ">": "\\u003E",
@@ -1095,14 +123,14 @@ function serializeServerData(data) {
   );
 }
 
-// ../server/dist/index.js
+// ../server/src/app.ts
 import { Hono } from "hono";
-import { Hono as Hono3 } from "hono";
-import { Hono as Hono2 } from "hono";
-var DEFAULT_SUPPORTED = ["zh", "en"];
-var DEFAULT_LOCALE = "en";
-function parseAcceptLanguage(header, supported = DEFAULT_SUPPORTED, fallback = DEFAULT_LOCALE) {
-  if (!header) return fallback;
+
+// ../server/src/locale.ts
+function parseAcceptLanguage(header, supported, fallback) {
+  const effectiveSupported = supported ?? ["zh", "en"];
+  const effectiveFallback = fallback ?? effectiveSupported[0] ?? "en";
+  if (!header) return effectiveFallback;
   const langs = header.split(",").map((part) => {
     const [lang, q] = part.trim().split(";q=");
     return {
@@ -1112,12 +140,14 @@ function parseAcceptLanguage(header, supported = DEFAULT_SUPPORTED, fallback = D
   }).sort((a, b) => b.q - a.q);
   for (const { lang } of langs) {
     const prefix = lang.split("-")[0];
-    if (supported.includes(prefix)) {
+    if (effectiveSupported.includes(prefix)) {
       return prefix;
     }
   }
-  return fallback;
+  return effectiveFallback;
 }
+
+// ../server/src/app.ts
 function createSSRApp(options) {
   const {
     root,
@@ -1131,8 +161,14 @@ function createSSRApp(options) {
   const app = new Hono();
   async function readTemplate(url) {
     if (!isProduction && vite) {
-      const { readFileSync: readFileSync2 } = await import("fs");
-      const { resolve: resolve2 } = await import("path");
+      const { readFileSync: readFileSync2 } = await import(
+        /* @vite-ignore */
+        "fs"
+      );
+      const { resolve: resolve2 } = await import(
+        /* @vite-ignore */
+        "path"
+      );
       const raw = readFileSync2(resolve2(root, "index.html"), "utf-8");
       return vite.transformIndexHtml(url, raw);
     }
@@ -1142,8 +178,14 @@ function createSSRApp(options) {
         new URL("../dist/client/index.html", import.meta.url)
       );
     }
-    const { readFileSync } = await import("fs");
-    const { resolve } = await import("path");
+    const { readFileSync } = await import(
+      /* @vite-ignore */
+      "fs"
+    );
+    const { resolve } = await import(
+      /* @vite-ignore */
+      "path"
+    );
     return readFileSync(resolve(root, "dist/client/index.html"), "utf-8");
   }
   async function loadSSRModule() {
@@ -1189,6 +231,11 @@ function createSSRApp(options) {
   });
   return app;
 }
+
+// ../server/src/create-server.ts
+import { Hono as Hono3 } from "hono";
+
+// ../server/src/runtime.ts
 function detectRuntime() {
   return {
     isDeno: typeof globalThis.Deno !== "undefined",
@@ -1206,40 +253,89 @@ async function resolveRoot(importMetaUrl, levelsUp = 0) {
     }
     return url.pathname;
   }
-  const { dirname, resolve, normalize } = await import("path");
-  const { fileURLToPath } = await import("url");
+  const { dirname, resolve, normalize } = await import(
+    /* @vite-ignore */
+    "path"
+  );
+  const { fileURLToPath } = await import(
+    /* @vite-ignore */
+    "url"
+  );
   let dir = normalize(dirname(fileURLToPath(importMetaUrl)));
   for (let i = 0; i < levelsUp; i++) {
     dir = resolve(dir, "..");
   }
   return dir;
 }
+
+// ../server/src/start.ts
+import { Hono as Hono2 } from "hono";
 async function startServer(options) {
-  const { app, root, port = 3e3, isProduction, vite } = options;
+  const {
+    app,
+    root,
+    port = 3e3,
+    isProduction,
+    vite,
+    routes,
+    locales,
+    ssrEntryPath
+  } = options;
   const { isDeno, isBun, isVercel } = options.runtime ?? detectRuntime();
+  function printStartupBanner() {
+    const lines = [
+      `
+  Server running at http://localhost:${port}
+`
+    ];
+    if (routes && routes.length > 0) {
+      lines.push("  Routes:");
+      for (const r of routes) {
+        lines.push(`    ${r}`);
+      }
+      lines.push("");
+    }
+    if (locales && locales.length > 0) {
+      lines.push(`  Locales: ${locales.join(", ")}`);
+    }
+    if (ssrEntryPath) {
+      lines.push(`  SSR Entry: ${ssrEntryPath}`);
+    }
+    if (locales?.length || ssrEntryPath) {
+      lines.push("");
+    }
+    console.log(lines.join("\n"));
+  }
   if (isVercel) {
     return { vite };
   }
   if (!isProduction) {
     let devVite = vite;
     if (!devVite) {
-      const { createServer: createViteServer } = await import("vite");
+      const { createServer: createViteServer } = await import(
+        /* @vite-ignore */
+        "vite"
+      );
       devVite = await createViteServer({
         root,
         server: { middlewareMode: true },
         appType: "custom"
       });
     }
-    const { getRequestListener } = await import("@hono/node-server");
-    const { createServer: createServer2 } = await import("http");
+    const { getRequestListener } = await import(
+      /* @vite-ignore */
+      "@hono/node-server"
+    );
+    const { createServer: createServer2 } = await import(
+      /* @vite-ignore */
+      "http"
+    );
     const listener = getRequestListener(app.fetch);
     const server = createServer2((req, res) => {
       devVite.middlewares(req, res, () => listener(req, res));
     });
     server.listen(port, () => {
-      console.log(`
-  Server running at http://localhost:${port}
-`);
+      printStartupBanner();
     });
     return { vite: devVite };
   }
@@ -1247,20 +343,29 @@ async function startServer(options) {
     globalThis.Deno.serve({ port }, app.fetch);
   } else if (isBun) {
   } else {
-    const { serveStatic } = await import("@hono/node-server/serve-static");
-    const { resolve } = await import("path");
+    const { serveStatic } = await import(
+      /* @vite-ignore */
+      "@hono/node-server/serve-static"
+    );
+    const { resolve } = await import(
+      /* @vite-ignore */
+      "path"
+    );
     const prodApp = new Hono2();
     prodApp.use("/*", serveStatic({ root: resolve(root, "dist/client") }));
     prodApp.route("/", app);
-    const { serve } = await import("@hono/node-server");
+    const { serve } = await import(
+      /* @vite-ignore */
+      "@hono/node-server"
+    );
     serve({ fetch: prodApp.fetch, port }, () => {
-      console.log(`
-  Server running at http://localhost:${port}
-`);
+      printStartupBanner();
     });
   }
   return { vite };
 }
+
+// ../server/src/create-server.ts
 async function createServer(config = {}) {
   const {
     root: rootOverride,
@@ -1271,12 +376,21 @@ async function createServer(config = {}) {
     ssr
   } = config;
   const root = rootOverride ?? process.cwd();
-  const { existsSync } = await import("fs");
-  const { resolve } = await import("path");
+  const { existsSync } = await import(
+    /* @vite-ignore */
+    "fs"
+  );
+  const { resolve } = await import(
+    /* @vite-ignore */
+    "path"
+  );
   const envPath = resolve(root, ".env");
   if (existsSync(envPath)) {
     try {
-      const { config: dotenvConfig } = await import("dotenv");
+      const { config: dotenvConfig } = await import(
+        /* @vite-ignore */
+        "dotenv"
+      );
       dotenvConfig({ path: envPath });
     } catch {
     }
@@ -1284,7 +398,10 @@ async function createServer(config = {}) {
   const runtime = detectRuntime();
   let vite;
   if (!runtime.isProduction && !runtime.isVercel) {
-    const { createServer: createViteServer } = await import("vite");
+    const { createServer: createViteServer } = await import(
+      /* @vite-ignore */
+      "vite"
+    );
     vite = await createViteServer({
       root,
       server: { middlewareMode: true },
@@ -1310,7 +427,9 @@ async function createServer(config = {}) {
     port,
     isProduction: runtime.isProduction,
     vite,
-    runtime
+    runtime,
+    locales,
+    ssrEntryPath: ssr?.ssrEntryPath
   });
   return { app, vite, runtime };
 }
@@ -1333,6 +452,7 @@ export {
   LruMap,
   PrefetchedIntents,
   Router,
+  SSR_PLACEHOLDERS,
   buildUrl,
   createPrefetchedIntentsFromDom,
   createSSRApp,