@finesoft/front 0.1.12 → 0.1.14

package/dist/index.cjs

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,75 +30,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  ACTION_KINDS: () => ACTION_KINDS,
-  ActionDispatcher: () => ActionDispatcher,
-  BaseController: () => BaseController,
-  BaseLogger: () => BaseLogger,
-  CompositeLogger: () => CompositeLogger,
-  CompositeLoggerFactory: () => CompositeLoggerFactory,
-  ConsoleLogger: () => ConsoleLogger,
-  ConsoleLoggerFactory: () => ConsoleLoggerFactory,
-  Container: () => Container,
-  DEP_KEYS: () => DEP_KEYS,
-  Framework: () => Framework,
-  History: () => History,
-  HttpClient: () => HttpClient,
-  HttpError: () => HttpError,
-  IntentDispatcher: () => IntentDispatcher,
-  LruMap: () => LruMap,
-  PrefetchedIntents: () => PrefetchedIntents,
-  Router: () => Router,
-  SSR_PLACEHOLDERS: () => SSR_PLACEHOLDERS,
-  buildUrl: () => buildUrl,
-  createPrefetchedIntentsFromDom: () => createPrefetchedIntentsFromDom,
-  createSSRApp: () => createSSRApp,
-  createSSRRender: () => createSSRRender,
-  createServer: () => createServer,
-  defineRoutes: () => defineRoutes,
-  deserializeServerData: () => deserializeServerData,
-  detectRuntime: () => detectRuntime,
-  generateUuid: () => generateUuid,
-  getBaseUrl: () => getBaseUrl,
-  injectSSRContent: () => injectSSRContent,
-  isCompoundAction: () => isCompoundAction,
-  isExternalUrlAction: () => isExternalUrlAction,
-  isFlowAction: () => isFlowAction,
-  isNone: () => isNone,
-  isSome: () => isSome,
-  makeDependencies: () => makeDependencies,
-  makeExternalUrlAction: () => makeExternalUrlAction,
-  makeFlowAction: () => makeFlowAction,
-  mapEach: () => mapEach,
-  parseAcceptLanguage: () => parseAcceptLanguage,
-  pipe: () => pipe,
-  pipeAsync: () => pipeAsync,
-  registerActionHandlers: () => registerActionHandlers,
-  registerExternalUrlHandler: () => registerExternalUrlHandler,
-  registerFlowActionHandler: () => registerFlowActionHandler,
-  removeHost: () => removeHost,
-  removeQueryParams: () => removeQueryParams,
-  removeScheme: () => removeScheme,
-  resetFilterCache: () => resetFilterCache,
-  resolveRoot: () => resolveRoot,
-  serializeServerData: () => serializeServerData,
-  shouldLog: () => shouldLog,
-  ssrRender: () => ssrRender,
-  stableStringify: () => stableStringify,
-  startBrowserApp: () => startBrowserApp,
-  startServer: () => startServer,
-  tryScroll: () => tryScroll
-});
-module.exports = __toCommonJS(index_exports);
-
 // ../core/src/actions/types.ts
-var ACTION_KINDS = {
-  FLOW: "flow",
-  EXTERNAL_URL: "externalUrl",
-  COMPOUND: "compound"
-};
 function isFlowAction(action) {
   return action.kind === ACTION_KINDS.FLOW;
 }
@@ -111,119 +46,144 @@ function makeFlowAction(url, presentationContext) {
 function makeExternalUrlAction(url) {
   return { kind: ACTION_KINDS.EXTERNAL_URL, url };
 }
+var ACTION_KINDS;
+var init_types = __esm({
+  "../core/src/actions/types.ts"() {
+    "use strict";
+    ACTION_KINDS = {
+      FLOW: "flow",
+      EXTERNAL_URL: "externalUrl",
+      COMPOUND: "compound"
+    };
+  }
+});
 
 // ../core/src/actions/dispatcher.ts
-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);
+var ActionDispatcher;
+var init_dispatcher = __esm({
+  "../core/src/actions/dispatcher.ts"() {
+    "use strict";
+    init_types();
+    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);
       }
-      return;
-    }
-    const handler = this.handlers.get(action.kind);
-    if (!handler) {
-      console.warn(
-        `[ActionDispatcher] No handler for kind="${action.kind}"`
-      );
-      return;
-    }
-    await handler(action);
+      /** 执行一个 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);
+      }
+    };
   }
-};
+});
 
 // ../core/src/intents/dispatcher.ts
-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 IntentDispatcher;
+var init_dispatcher2 = __esm({
+  "../core/src/intents/dispatcher.ts"() {
+    "use strict";
+    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);
+      }
+    };
   }
-};
+});
 
 // ../core/src/dependencies/container.ts
-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();
+var Container;
+var init_container = __esm({
+  "../core/src/dependencies/container.ts"() {
+    "use strict";
+    Container = class {
+      registrations = /* @__PURE__ */ new Map();
+      /** 注册依赖（默认单例） */
+      register(key, factory, singleton = true) {
+        this.registrations.set(key, { factory, singleton });
+        return this;
       }
-      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();
+      /** 解析依赖 */
+      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();
+      }
+    };
   }
-};
+});
 
 // ../core/src/logger/base.ts
-var BaseLogger = class {
-  category;
-  constructor(category) {
-    this.category = category;
+var BaseLogger;
+var init_base = __esm({
+  "../core/src/logger/base.ts"() {
+    "use strict";
+    BaseLogger = class {
+      category;
+      constructor(category) {
+        this.category = category;
+      }
+    };
   }
-};
+});
 
 // ../core/src/logger/local-storage-filter.ts
-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 {};
@@ -272,94 +232,62 @@ function resetFilterCache() {
   cachedRules = void 0;
   cachedRaw = void 0;
 }
+var LEVEL_TO_NUM, cachedRules, cachedRaw;
+var init_local_storage_filter = __esm({
+  "../core/src/logger/local-storage-filter.ts"() {
+    "use strict";
+    LEVEL_TO_NUM = {
+      "*": 4,
+      debug: 4,
+      info: 3,
+      warn: 2,
+      error: 1,
+      off: 0,
+      "": 0
+    };
+  }
+});
 
 // ../core/src/logger/console.ts
-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 ConsoleLogger, ConsoleLoggerFactory;
+var init_console = __esm({
+  "../core/src/logger/console.ts"() {
+    "use strict";
+    init_base();
+    init_local_storage_filter();
+    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 "";
+      }
+    };
+    ConsoleLoggerFactory = class {
+      loggerFor(category) {
+        return new ConsoleLogger(category);
+      }
+    };
   }
-};
+});
 
 // ../core/src/dependencies/make-dependencies.ts
-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),
@@ -395,479 +323,983 @@ function makeDependencies(container, options = {}) {
   );
   container.register(DEP_KEYS.FETCH, () => fetchFn);
 }
+var DEP_KEYS, DefaultLocale, MemoryStorage, DefaultFeatureFlags, ConsoleMetrics;
+var init_make_dependencies = __esm({
+  "../core/src/dependencies/make-dependencies.ts"() {
+    "use strict";
+    init_console();
+    DEP_KEYS = {
+      LOGGER: "logger",
+      LOGGER_FACTORY: "loggerFactory",
+      NET: "net",
+      LOCALE: "locale",
+      STORAGE: "storage",
+      FEATURE_FLAGS: "featureFlags",
+      METRICS: "metrics",
+      FETCH: "fetch"
+    };
+    DefaultLocale = class {
+      language = "en";
+      storefront = "us";
+      setActiveLocale(language, storefront) {
+        this.language = language;
+        this.storefront = storefront;
+      }
+    };
+    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);
+      }
+    };
+    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;
+      }
+    };
+    ConsoleMetrics = class {
+      recordPageView(page, fields) {
+        console.info(`[Metrics:PageView] ${page}`, fields ?? "");
+      }
+      recordEvent(name, fields) {
+        console.info(`[Metrics:Event] ${name}`, fields ?? "");
+      }
+    };
+  }
+});
 
 // ../core/src/router/router.ts
-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;
+var Router;
+var init_router = __esm({
+  "../core/src/router/router.ts"() {
+    "use strict";
+    init_types();
+    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
         });
-        for (const [k, v] of Object.entries(queryParams)) {
-          if (!(k in params)) params[k] = v;
+        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 {};
+        }
+      }
+    };
+  }
+});
+
+// ../core/src/logger/composite.ts
+var CompositeLoggerFactory, CompositeLogger;
+var init_composite = __esm({
+  "../core/src/logger/composite.ts"() {
+    "use strict";
+    CompositeLoggerFactory = class {
+      constructor(factories) {
+        this.factories = factories;
+      }
+      loggerFor(name) {
+        return new CompositeLogger(
+          this.factories.map((f) => f.loggerFor(name))
+        );
+      }
+    };
+    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 "";
+      }
+    };
+  }
+});
+
+// ../core/src/prefetched-intents/stable-stringify.ts
+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 init_stable_stringify = __esm({
+  "../core/src/prefetched-intents/stable-stringify.ts"() {
+    "use strict";
+  }
+});
+
+// ../core/src/prefetched-intents/prefetched-intents.ts
+var PrefetchedIntents;
+var init_prefetched_intents = __esm({
+  "../core/src/prefetched-intents/prefetched-intents.ts"() {
+    "use strict";
+    init_stable_stringify();
+    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;
+      }
+    };
+  }
+});
+
+// ../core/src/framework.ts
+var Framework;
+var init_framework = __esm({
+  "../core/src/framework.ts"() {
+    "use strict";
+    init_dispatcher();
+    init_container();
+    init_make_dependencies();
+    init_dispatcher2();
+    init_prefetched_intents();
+    init_router();
+    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;
         }
-        return {
-          intent: { id: route.intentId, params },
-          action: makeFlowAction(urlOrPath)
+        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();
+      }
+    };
+  }
+});
+
+// ../core/src/http/client.ts
+var HttpError, HttpClient;
+var init_client = __esm({
+  "../core/src/http/client.ts"() {
+    "use strict";
+    HttpError = class extends Error {
+      constructor(status, statusText, body) {
+        super(`HTTP ${status}: ${statusText}`);
+        this.status = status;
+        this.statusText = statusText;
+        this.body = body;
+        this.name = "HttpError";
+      }
+    };
+    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();
       }
-    }
-    return null;
+      /** 构建完整 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}`;
+      }
+    };
   }
-  /** 获取所有已注册的路由 */
-  getRoutes() {
-    return this.routes.map((r) => `${r.pattern} \u2192 ${r.intentId}`);
+});
+
+// ../core/src/intents/base-controller.ts
+var BaseController;
+var init_base_controller = __esm({
+  "../core/src/intents/base-controller.ts"() {
+    "use strict";
+    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))
+          );
+        }
+      }
+    };
   }
-  extractPath(url) {
-    try {
-      const parsed = new URL(url, "http://localhost");
-      return parsed.pathname;
-    } catch {
-      return url.split("?")[0].split("#")[0];
+});
+
+// ../core/src/data/mapper.ts
+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);
+}
+var init_mapper = __esm({
+  "../core/src/data/mapper.ts"() {
+    "use strict";
   }
-  extractQueryParams(url) {
-    try {
-      const parsed = new URL(url, "http://localhost");
-      const params = {};
-      parsed.searchParams.forEach((v, k) => {
-        params[k] = v;
-      });
-      return params;
-    } catch {
-      return {};
+});
+
+// ../core/src/bootstrap/define-routes.ts
+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 init_define_routes = __esm({
+  "../core/src/bootstrap/define-routes.ts"() {
+    "use strict";
+  }
+});
 
-// ../core/src/logger/composite.ts
-var CompositeLoggerFactory = class {
-  constructor(factories) {
-    this.factories = factories;
+// ../core/src/utils/lru-map.ts
+var LruMap;
+var init_lru_map = __esm({
+  "../core/src/utils/lru-map.ts"() {
+    "use strict";
+    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();
+      }
+    };
   }
-  loggerFor(name) {
-    return new CompositeLogger(
-      this.factories.map((f) => f.loggerFor(name))
-    );
+});
+
+// ../core/src/utils/optional.ts
+function isSome(value) {
+  return value !== null && value !== void 0;
+}
+function isNone(value) {
+  return value === null || value === void 0;
+}
+var init_optional = __esm({
+  "../core/src/utils/optional.ts"() {
+    "use strict";
   }
-};
-var CompositeLogger = class {
-  constructor(loggers) {
-    this.loggers = loggers;
+});
+
+// ../core/src/utils/url.ts
+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);
+    }
   }
-  debug(...args) {
-    return this.callAll("debug", args);
+  const qs = searchParams.toString();
+  return qs ? `${path}?${qs}` : path;
+}
+var init_url = __esm({
+  "../core/src/utils/url.ts"() {
+    "use strict";
   }
-  info(...args) {
-    return this.callAll("info", args);
+});
+
+// ../core/src/utils/uuid.ts
+function generateUuid() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
   }
-  warn(...args) {
-    return this.callAll("warn", args);
+  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);
+  });
+}
+var init_uuid = __esm({
+  "../core/src/utils/uuid.ts"() {
+    "use strict";
   }
-  error(...args) {
-    return this.callAll("error", args);
+});
+
+// ../core/src/index.ts
+var init_src = __esm({
+  "../core/src/index.ts"() {
+    "use strict";
+    init_dispatcher();
+    init_types();
+    init_dispatcher2();
+    init_container();
+    init_make_dependencies();
+    init_router();
+    init_base();
+    init_composite();
+    init_console();
+    init_local_storage_filter();
+    init_framework();
+    init_prefetched_intents();
+    init_stable_stringify();
+    init_client();
+    init_base_controller();
+    init_mapper();
+    init_define_routes();
+    init_lru_map();
+    init_optional();
+    init_url();
+    init_uuid();
   }
-  callAll(method, args) {
-    for (const logger of this.loggers) {
-      logger[method](...args);
+});
+
+// ../ssr/src/render.ts
+async function ssrRender(options) {
+  const { url, frameworkConfig, bootstrap, getErrorPage, renderApp } = options;
+  const framework = Framework.create(frameworkConfig);
+  bootstrap(framework);
+  const parsed = new URL(url, "http://localhost");
+  const fullPath = parsed.pathname + parsed.search;
+  const match = framework.routeUrl(fullPath);
+  let page;
+  let serverData = [];
+  if (match) {
+    try {
+      page = await framework.dispatch(match.intent);
+      serverData = [{ intent: match.intent, data: page }];
+    } catch {
+      page = getErrorPage(500, "Internal error");
     }
-    return "";
+  } else {
+    page = getErrorPage(404, "Page not found");
   }
-};
+  const result = renderApp(page, framework);
+  framework.dispose();
+  return {
+    html: result.html,
+    head: result.head,
+    css: result.css,
+    serverData
+  };
+}
+var init_render = __esm({
+  "../ssr/src/render.ts"() {
+    "use strict";
+    init_src();
+  }
+});
 
-// ../core/src/prefetched-intents/stable-stringify.ts
-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(",") + "]";
+// ../ssr/src/create-render.ts
+function createSSRRender(config) {
+  const { bootstrap, getErrorPage, renderApp, frameworkConfig } = config;
+  return (url, locale) => ssrRender({
+    url,
+    frameworkConfig: frameworkConfig ?? {},
+    bootstrap,
+    getErrorPage,
+    renderApp: (page) => renderApp(page, locale)
+  });
+}
+var init_create_render = __esm({
+  "../ssr/src/create-render.ts"() {
+    "use strict";
+    init_render();
   }
-  const keys = Object.keys(obj).sort();
-  const parts = keys.filter((k) => obj[k] !== void 0).map(
-    (k) => JSON.stringify(k) + ":" + stableStringify(obj[k])
+});
+
+// ../ssr/src/inject.ts
+function injectSSRContent(options) {
+  const { template, locale, head, css, html, serializedData } = options;
+  const cssTag = css ? `<style>${css}</style>` : "";
+  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>`
   );
-  return "{" + parts.join(",") + "}";
 }
+var SSR_PLACEHOLDERS;
+var init_inject = __esm({
+  "../ssr/src/inject.ts"() {
+    "use strict";
+    SSR_PLACEHOLDERS = {
+      LANG: "<!--ssr-lang-->",
+      HEAD: "<!--ssr-head-->",
+      BODY: "<!--ssr-body-->",
+      DATA: "<!--ssr-data-->"
+    };
+  }
+});
 
-// ../core/src/prefetched-intents/prefetched-intents.ts
-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);
-      }
+// ../ssr/src/server-data.ts
+function serializeServerData(data) {
+  const json = JSON.stringify(data);
+  return json.replace(
+    HTML_ESCAPE_PATTERN,
+    (match) => HTML_REPLACEMENTS[match] ?? match
+  );
+}
+var HTML_REPLACEMENTS, HTML_ESCAPE_PATTERN;
+var init_server_data = __esm({
+  "../ssr/src/server-data.ts"() {
+    "use strict";
+    HTML_REPLACEMENTS = {
+      "<": "\\u003C",
+      ">": "\\u003E",
+      "/": "\\u002F",
+      "\u2028": "\\u2028",
+      "\u2029": "\\u2029"
+    };
+    HTML_ESCAPE_PATTERN = /[<>/\u2028\u2029]/g;
+  }
+});
+
+// ../ssr/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Framework: () => Framework,
+  SSR_PLACEHOLDERS: () => SSR_PLACEHOLDERS,
+  createSSRRender: () => createSSRRender,
+  injectSSRContent: () => injectSSRContent,
+  serializeServerData: () => serializeServerData,
+  ssrRender: () => ssrRender
+});
+var init_src2 = __esm({
+  "../ssr/src/index.ts"() {
+    "use strict";
+    init_create_render();
+    init_inject();
+    init_render();
+    init_server_data();
+    init_src();
+  }
+});
+
+// ../server/src/locale.ts
+var locale_exports = {};
+__export(locale_exports, {
+  parseAcceptLanguage: () => parseAcceptLanguage
+});
+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 {
+      lang: lang.trim().toLowerCase(),
+      q: q ? parseFloat(q) : 1
+    };
+  }).sort((a, b) => b.q - a.q);
+  for (const { lang } of langs) {
+    const prefix = lang.split("-")[0];
+    if (effectiveSupported.includes(prefix)) {
+      return prefix;
     }
-    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 effectiveFallback;
+}
+var init_locale = __esm({
+  "../server/src/locale.ts"() {
+    "use strict";
+  }
+});
+
+// ../server/src/app.ts
+var app_exports = {};
+__export(app_exports, {
+  createSSRApp: () => createSSRApp
+});
+function createSSRApp(options) {
+  const {
+    root,
+    vite,
+    isProduction,
+    ssrEntryPath = "/src/ssr.ts",
+    ssrProductionModule,
+    supportedLocales,
+    defaultLocale
+  } = options;
+  const app = new import_hono.Hono();
+  async function readTemplate(url) {
+    if (!isProduction && vite) {
+      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);
     }
-    return void 0;
-  }
-  /** 检查缓存中是否有某个 Intent 的数据 */
-  has(intent) {
-    return this.intents.has(stableStringify(intent));
-  }
-  /** 缓存中的条目数 */
-  get size() {
-    return this.intents.size;
-  }
-};
-
-// ../core/src/framework.ts
-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
+    const isDeno = typeof globalThis.Deno !== "undefined";
+    if (isDeno) {
+      return globalThis.Deno.readTextFileSync(
+        new URL("../dist/client/index.html", import_meta.url)
       );
-      return cached;
     }
-    logger.debug(
-      `[Framework] dispatch intent: ${intent.id}`,
-      intent.params
+    const { readFileSync } = await import(
+      /* @vite-ignore */
+      "fs"
     );
-    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
+    const { resolve } = await import(
+      /* @vite-ignore */
+      "path"
     );
-    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();
-  }
-};
-
-// ../core/src/http/client.ts
-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();
+    return readFileSync(resolve(root, "dist/client/index.html"), "utf-8");
   }
-  /** 构建完整 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);
-      }
+  async function loadSSRModule() {
+    if (!isProduction && vite) {
+      return await vite.ssrLoadModule(ssrEntryPath);
     }
-    if (this.baseUrl.startsWith("http")) {
-      return url.toString();
+    if (ssrProductionModule) {
+      return import(ssrProductionModule);
     }
-    return `${url.pathname}${url.search}`;
+    const { resolve } = await import(
+      /* @vite-ignore */
+      "path"
+    );
+    const { pathToFileURL } = await import(
+      /* @vite-ignore */
+      "url"
+    );
+    const absPath = pathToFileURL(resolve(root, "dist/server/ssr.js")).href;
+    return import(absPath);
   }
-};
-
-// ../core/src/intents/base-controller.ts
-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 ?? {};
+  app.get("*", async (c) => {
+    const url = c.req.path + (c.req.url.includes("?") ? "?" + c.req.url.split("?")[1] : "");
     try {
-      return await this.execute(params, container);
-    } catch (e) {
-      return this.fallback(
-        params,
-        e instanceof Error ? e : new Error(String(e))
+      const template = await readTemplate(url);
+      const { render, serializeServerData: serializeServerData2 } = await loadSSRModule();
+      const locale = parseAcceptLanguage(
+        c.req.header("accept-language"),
+        supportedLocales,
+        defaultLocale
       );
-    }
-  }
-};
-
-// ../core/src/data/mapper.ts
-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);
-}
-
-// ../core/src/bootstrap/define-routes.ts
-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);
-  }
-}
-
-// ../core/src/utils/lru-map.ts
-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);
+      const {
+        html: appHtml,
+        head,
+        css,
+        serverData
+      } = await render(url, locale);
+      const serializedData = serializeServerData2(serverData);
+      const finalHtml = injectSSRContent({
+        template,
+        locale,
+        head,
+        css,
+        html: appHtml,
+        serializedData
+      });
+      return c.html(finalHtml);
+    } catch (e) {
+      if (!isProduction && vite) {
+        vite.ssrFixStacktrace(e);
       }
+      console.error("[SSR Error]", e);
+      return c.text("Internal Server Error", 500);
     }
-    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();
-  }
-};
-
-// ../core/src/utils/optional.ts
-function isSome(value) {
-  return value !== null && value !== void 0;
-}
-function isNone(value) {
-  return value === null || value === void 0;
-}
-
-// ../core/src/utils/url.ts
-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];
+  });
+  return app;
 }
-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);
-    }
+var import_hono, import_meta;
+var init_app = __esm({
+  "../server/src/app.ts"() {
+    "use strict";
+    init_src2();
+    import_hono = require("hono");
+    init_locale();
+    import_meta = {};
   }
-  const qs = searchParams.toString();
-  return qs ? `${path}?${qs}` : path;
-}
+});
 
-// ../core/src/utils/uuid.ts
-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);
-  });
-}
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ACTION_KINDS: () => ACTION_KINDS,
+  ActionDispatcher: () => ActionDispatcher,
+  BaseController: () => BaseController,
+  BaseLogger: () => BaseLogger,
+  CompositeLogger: () => CompositeLogger,
+  CompositeLoggerFactory: () => CompositeLoggerFactory,
+  ConsoleLogger: () => ConsoleLogger,
+  ConsoleLoggerFactory: () => ConsoleLoggerFactory,
+  Container: () => Container,
+  DEP_KEYS: () => DEP_KEYS,
+  Framework: () => Framework,
+  History: () => History,
+  HttpClient: () => HttpClient,
+  HttpError: () => HttpError,
+  IntentDispatcher: () => IntentDispatcher,
+  LruMap: () => LruMap,
+  PrefetchedIntents: () => PrefetchedIntents,
+  Router: () => Router,
+  SSR_PLACEHOLDERS: () => SSR_PLACEHOLDERS,
+  autoAdapter: () => autoAdapter,
+  buildUrl: () => buildUrl,
+  cloudflareAdapter: () => cloudflareAdapter,
+  createPrefetchedIntentsFromDom: () => createPrefetchedIntentsFromDom,
+  createSSRApp: () => createSSRApp,
+  createSSRRender: () => createSSRRender,
+  createServer: () => createServer,
+  defineRoutes: () => defineRoutes,
+  deserializeServerData: () => deserializeServerData,
+  detectRuntime: () => detectRuntime,
+  finesoftFrontViteConfig: () => finesoftFrontViteConfig,
+  generateUuid: () => generateUuid,
+  getBaseUrl: () => getBaseUrl,
+  injectSSRContent: () => injectSSRContent,
+  isCompoundAction: () => isCompoundAction,
+  isExternalUrlAction: () => isExternalUrlAction,
+  isFlowAction: () => isFlowAction,
+  isNone: () => isNone,
+  isSome: () => isSome,
+  makeDependencies: () => makeDependencies,
+  makeExternalUrlAction: () => makeExternalUrlAction,
+  makeFlowAction: () => makeFlowAction,
+  mapEach: () => mapEach,
+  netlifyAdapter: () => netlifyAdapter,
+  nodeAdapter: () => nodeAdapter,
+  parseAcceptLanguage: () => parseAcceptLanguage,
+  pipe: () => pipe,
+  pipeAsync: () => pipeAsync,
+  registerActionHandlers: () => registerActionHandlers,
+  registerExternalUrlHandler: () => registerExternalUrlHandler,
+  registerFlowActionHandler: () => registerFlowActionHandler,
+  removeHost: () => removeHost,
+  removeQueryParams: () => removeQueryParams,
+  removeScheme: () => removeScheme,
+  resetFilterCache: () => resetFilterCache,
+  resolveAdapter: () => resolveAdapter,
+  resolveRoot: () => resolveRoot,
+  serializeServerData: () => serializeServerData,
+  shouldLog: () => shouldLog,
+  ssrRender: () => ssrRender,
+  stableStringify: () => stableStringify,
+  startBrowserApp: () => startBrowserApp,
+  startServer: () => startServer,
+  staticAdapter: () => staticAdapter,
+  tryScroll: () => tryScroll,
+  vercelAdapter: () => vercelAdapter
+});
+module.exports = __toCommonJS(index_exports);
+init_src();
 
 // ../browser/src/action-handlers/external-url-action.ts
+init_src();
 function registerExternalUrlHandler(deps) {
   const { framework, log } = deps;
   framework.onAction(
@@ -879,6 +1311,12 @@ function registerExternalUrlHandler(deps) {
   );
 }
 
+// ../browser/src/action-handlers/flow-action.ts
+init_src();
+
+// ../browser/src/utils/history.ts
+init_src();
+
 // ../browser/src/utils/try-scroll.ts
 var MAX_TRIES = 100;
 var FUDGE = 16;
@@ -1126,7 +1564,11 @@ function registerActionHandlers(deps) {
   registerExternalUrlHandler({ framework, log });
 }
 
+// ../browser/src/start-app.ts
+init_src();
+
 // ../browser/src/server-data.ts
+init_src();
 var SERVER_DATA_ID = "serialized-server-data";
 function deserializeServerData() {
   const script = document.getElementById(SERVER_DATA_ID);
@@ -1184,194 +1626,459 @@ async function startBrowserApp(config) {
   }
 }
 
-// ../ssr/src/render.ts
-async function ssrRender(options) {
-  const { url, frameworkConfig, bootstrap, getErrorPage, renderApp } = options;
-  const framework = Framework.create(frameworkConfig);
-  bootstrap(framework);
-  const parsed = new URL(url, "http://localhost");
-  const fullPath = parsed.pathname + parsed.search;
-  const match = framework.routeUrl(fullPath);
-  let page;
-  let serverData = [];
-  if (match) {
-    try {
-      page = await framework.dispatch(match.intent);
-      serverData = [{ intent: match.intent, data: page }];
-    } catch {
-      page = getErrorPage(500, "Internal error");
-    }
-  } else {
-    page = getErrorPage(404, "Page not found");
-  }
-  const result = renderApp(page, framework);
-  framework.dispose();
-  return {
-    html: result.html,
-    head: result.head,
-    css: result.css,
-    serverData
-  };
+// ../browser/src/index.ts
+init_src();
+
+// src/index.ts
+init_src2();
+
+// ../server/src/adapters/shared.ts
+var BUILD_TOOL_EXTERNALS = [
+  "vite",
+  "esbuild",
+  "rollup",
+  "fsevents",
+  "lightningcss"
+];
+function generateSSREntry(ctx, opts) {
+  const setupImport = ctx.setupPath ? `import _setupDefault from "./${ctx.setupPath}";` : ``;
+  const setupCall = ctx.setupPath ? `if (typeof _setupDefault === "function") await _setupDefault(app);` : ``;
+  const locales = JSON.stringify(ctx.locales);
+  const defaultLocale = JSON.stringify(ctx.defaultLocale);
+  return `
+import { Hono } from "hono";
+${opts.platformImport}
+import { render, serializeServerData } from "./${ctx.ssrEntry}";
+${setupImport}
+
+const TEMPLATE = ${JSON.stringify(ctx.templateHtml)};
+const LOCALES = ${locales};
+const DEFAULT_LOCALE = ${defaultLocale};
+
+function parseAcceptLanguage(header) {
+  if (!header) return DEFAULT_LOCALE;
+  const langs = header.split(",").map(p => {
+    const [l, q] = p.trim().split(";q=");
+    return { l: l.trim().toLowerCase(), q: q ? +q : 1 };
+  }).sort((a, b) => b.q - a.q);
+  for (const { l } of langs) {
+    const prefix = l.split("-")[0];
+    if (LOCALES.includes(prefix)) return prefix;
+  }
+  return DEFAULT_LOCALE;
+}
+
+function injectSSR(t, locale, head, css, html, data) {
+  return t
+    .replace("<!--ssr-lang-->", locale)
+    .replace("<!--ssr-head-->", head + "\\n<style>" + css + "</style>")
+    .replace("<!--ssr-body-->", html)
+    .replace("<!--ssr-data-->", '<script id="serialized-server-data" type="application/json">' + data + "</script>");
 }
 
-// ../ssr/src/create-render.ts
-function createSSRRender(config) {
-  const { bootstrap, getErrorPage, renderApp, frameworkConfig } = config;
-  return (url, locale) => ssrRender({
-    url,
-    frameworkConfig: frameworkConfig ?? {},
-    bootstrap,
-    getErrorPage,
-    renderApp: (page) => renderApp(page, locale)
+const app = new Hono();
+${setupCall}
+
+app.get("*", async (c) => {
+  const url = c.req.path + (c.req.url.includes("?") ? "?" + c.req.url.split("?")[1] : "");
+  try {
+    const locale = parseAcceptLanguage(c.req.header("accept-language"));
+    const { html: appHtml, head, css, serverData } = await render(url, locale);
+    const serializedData = serializeServerData(serverData);
+    return c.html(injectSSR(TEMPLATE, locale, head, css, appHtml, serializedData));
+  } catch (e) {
+    console.error("[SSR Error]", e);
+    return c.text("Internal Server Error", 500);
+  }
+});
+
+${opts.platformExport}
+`;
+}
+async function buildBundle(ctx, opts) {
+  await ctx.vite.build({
+    root: ctx.root,
+    build: {
+      ssr: opts.entry,
+      outDir: opts.outDir,
+      emptyOutDir: true,
+      target: opts.target ?? "node18",
+      rollupOptions: {
+        output: { entryFileNames: opts.fileName ?? "index.mjs" }
+      }
+    },
+    ssr: {
+      noExternal: opts.noExternal !== false,
+      external: opts.external ?? BUILD_TOOL_EXTERNALS
+    },
+    resolve: ctx.resolvedResolve,
+    css: ctx.resolvedCss
   });
 }
-
-// ../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_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>`
-  );
+function copyStaticAssets(ctx, destDir, opts) {
+  const { fs, path } = ctx;
+  fs.cpSync(path.resolve(ctx.root, "dist/client"), destDir, {
+    recursive: true
+  });
+  if (opts?.excludeHtml !== false) {
+    fs.rmSync(path.join(destDir, "index.html"), { force: true });
+  }
 }
 
-// ../ssr/src/server-data.ts
-var HTML_REPLACEMENTS = {
-  "<": "\\u003C",
-  ">": "\\u003E",
-  "/": "\\u002F",
-  "\u2028": "\\u2028",
-  "\u2029": "\\u2029"
-};
-var HTML_ESCAPE_PATTERN = /[<>/\u2028\u2029]/g;
-function serializeServerData(data) {
-  const json = JSON.stringify(data);
-  return json.replace(
-    HTML_ESCAPE_PATTERN,
-    (match) => HTML_REPLACEMENTS[match] ?? match
-  );
+// ../server/src/adapters/cloudflare.ts
+function cloudflareAdapter() {
+  return {
+    name: "cloudflare",
+    async build(ctx) {
+      const { fs, path, root } = ctx;
+      const outputDir = path.resolve(root, "dist/cloudflare");
+      fs.rmSync(outputDir, { recursive: true, force: true });
+      const entrySource = generateSSREntry(ctx, {
+        platformImport: ``,
+        platformExport: `export default app;`
+      });
+      const tempEntry = path.resolve(root, ".cf-entry.tmp.mjs");
+      fs.writeFileSync(tempEntry, entrySource);
+      try {
+        await buildBundle(ctx, {
+          entry: ".cf-entry.tmp.mjs",
+          outDir: outputDir,
+          target: "es2022",
+          fileName: "_worker.js",
+          external: []
+          // CF Workers 需全部打包
+        });
+        copyStaticAssets(ctx, path.resolve(outputDir, "assets"));
+      } finally {
+        fs.rmSync(tempEntry, { force: true });
+      }
+      console.log("  Cloudflare output \u2192 dist/cloudflare/\n");
+    }
+  };
 }
 
-// ../server/src/app.ts
-var import_hono = require("hono");
+// ../server/src/adapters/netlify.ts
+function netlifyAdapter() {
+  return {
+    name: "netlify",
+    async build(ctx) {
+      const { fs, path, root } = ctx;
+      const funcDir = path.resolve(
+        root,
+        ".netlify/functions-internal/ssr"
+      );
+      fs.rmSync(path.resolve(root, ".netlify"), {
+        recursive: true,
+        force: true
+      });
+      const entrySource = generateSSREntry(ctx, {
+        platformImport: `import { handle } from "hono/netlify";`,
+        platformExport: `export default handle(app);`
+      });
+      const tempEntry = path.resolve(root, ".netlify-entry.tmp.mjs");
+      fs.writeFileSync(tempEntry, entrySource);
+      try {
+        await buildBundle(ctx, {
+          entry: ".netlify-entry.tmp.mjs",
+          outDir: funcDir,
+          target: "node18"
+        });
+      } finally {
+        fs.rmSync(tempEntry, { force: true });
+      }
+      const redirects = `/* /.netlify/functions/ssr 200
+`;
+      fs.writeFileSync(
+        path.resolve(root, "dist/client/_redirects"),
+        redirects
+      );
+      console.log(
+        "  Netlify output \u2192 .netlify/functions-internal/ssr/\n  Publish dir: dist/client/\n"
+      );
+    }
+  };
+}
 
-// ../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 {
-      lang: lang.trim().toLowerCase(),
-      q: q ? parseFloat(q) : 1
-    };
-  }).sort((a, b) => b.q - a.q);
-  for (const { lang } of langs) {
-    const prefix = lang.split("-")[0];
-    if (effectiveSupported.includes(prefix)) {
-      return prefix;
+// ../server/src/adapters/node.ts
+function nodeAdapter() {
+  return {
+    name: "node",
+    async build(ctx) {
+      const { fs, path, root } = ctx;
+      const entrySource = generateSSREntry(ctx, {
+        platformImport: `import { serve } from "@hono/node-server";`,
+        platformExport: `
+const port = +(process.env.PORT || 3000);
+serve({ fetch: app.fetch, port }, (info) => {
+  console.log(\`Server running at http://localhost:\${info.port}\`);
+});
+`
+      });
+      const tempEntry = path.resolve(root, ".node-entry.tmp.mjs");
+      fs.writeFileSync(tempEntry, entrySource);
+      try {
+        await buildBundle(ctx, {
+          entry: ".node-entry.tmp.mjs",
+          outDir: path.resolve(root, "dist/server"),
+          target: "node18"
+        });
+      } finally {
+        fs.rmSync(tempEntry, { force: true });
+      }
+      console.log(
+        "  Node output \u2192 dist/server/index.mjs\n  Run: node dist/server/index.mjs\n"
+      );
     }
-  }
-  return effectiveFallback;
+  };
 }
 
-// ../server/src/app.ts
-var import_meta = {};
-function createSSRApp(options) {
-  const {
-    root,
-    vite,
-    isProduction,
-    ssrEntryPath = "/src/ssr.ts",
-    ssrProductionModule,
-    supportedLocales,
-    defaultLocale
-  } = options;
-  const app = new import_hono.Hono();
-  async function readTemplate(url) {
-    if (!isProduction && vite) {
-      const { readFileSync: readFileSync2 } = await import(
+// ../server/src/adapters/static.ts
+function staticAdapter(opts = {}) {
+  return {
+    name: "static",
+    async build(ctx) {
+      const { fs, path, root, vite } = ctx;
+      const outputDir = path.resolve(root, "dist/static");
+      fs.rmSync(outputDir, { recursive: true, force: true });
+      fs.mkdirSync(outputDir, { recursive: true });
+      const { pathToFileURL } = await import(
         /* @vite-ignore */
-        "fs"
+        "url"
       );
-      const { resolve: resolve2 } = await import(
+      const ssrPath = pathToFileURL(
+        path.resolve(root, "dist/server/ssr.js")
+      ).href;
+      const ssrModule = await import(
         /* @vite-ignore */
-        "path"
+        ssrPath
       );
-      const raw = readFileSync2(resolve2(root, "index.html"), "utf-8");
-      return vite.transformIndexHtml(url, raw);
-    }
-    const isDeno = typeof globalThis.Deno !== "undefined";
-    if (isDeno) {
-      return globalThis.Deno.readTextFileSync(
-        new URL("../dist/client/index.html", import_meta.url)
+      const routePaths = await extractRoutes(ctx, opts);
+      const allUrls = [];
+      for (const routePath of routePaths) {
+        for (const locale of ctx.locales) {
+          const url = locale === ctx.defaultLocale ? routePath : `/${locale}${routePath === "/" ? "" : routePath}`;
+          allUrls.push(url);
+        }
+      }
+      console.log(
+        `  Pre-rendering ${allUrls.length} pages (${routePaths.length} routes \xD7 ${ctx.locales.length} locales)...
+`
       );
+      for (const url of allUrls) {
+        try {
+          const locale = inferLocale(
+            url,
+            ctx.locales,
+            ctx.defaultLocale
+          );
+          const {
+            html: appHtml,
+            head,
+            css,
+            serverData
+          } = await ssrModule.render(url, locale);
+          const serializedData = ssrModule.serializeServerData(serverData);
+          const finalHtml = injectSSRForStatic(
+            ctx.templateHtml,
+            locale,
+            head,
+            css,
+            appHtml,
+            serializedData
+          );
+          const filePath = url === "/" ? path.join(outputDir, "index.html") : path.join(outputDir, url, "index.html");
+          fs.mkdirSync(path.resolve(filePath, ".."), {
+            recursive: true
+          });
+          fs.writeFileSync(filePath, finalHtml);
+        } catch (e) {
+          console.warn(`  [static] Failed to render ${url}:`, e);
+        }
+      }
+      ctx.copyStaticAssets(outputDir, { excludeHtml: true });
+      console.log(`  Static output \u2192 dist/static/
+`);
     }
-    const { readFileSync } = await import(
+  };
+}
+async function extractRoutes(ctx, opts) {
+  const routesFile = opts.routesExport ?? "src/lib/bootstrap.ts";
+  const paths = [];
+  try {
+    const { pathToFileURL } = await import(
       /* @vite-ignore */
-      "fs"
+      "url"
     );
-    const { resolve } = await import(
+    await ctx.vite.build({
+      root: ctx.root,
+      build: {
+        ssr: routesFile,
+        outDir: ctx.path.resolve(ctx.root, "dist/server"),
+        emptyOutDir: false,
+        rollupOptions: {
+          output: { entryFileNames: "_routes.mjs" }
+        }
+      },
+      resolve: ctx.resolvedResolve
+    });
+    const routesPath = pathToFileURL(
+      ctx.path.resolve(ctx.root, "dist/server/_routes.mjs")
+    ).href;
+    const routesMod = await import(
       /* @vite-ignore */
-      "path"
+      routesPath
     );
-    return readFileSync(resolve(root, "dist/client/index.html"), "utf-8");
+    const routes = routesMod.routes ?? routesMod.default;
+    if (Array.isArray(routes)) {
+      for (const r of routes) {
+        if (r.path && !r.path.includes(":")) {
+          paths.push(r.path);
+        }
+      }
+    }
+    ctx.fs.rmSync(ctx.path.resolve(ctx.root, "dist/server/_routes.mjs"), {
+      force: true
+    });
+  } catch (e) {
+    console.warn(
+      `  [static] Could not load routes from "${routesFile}". Using "/" only.`,
+      e
+    );
+    if (paths.length === 0) paths.push("/");
   }
-  async function loadSSRModule() {
-    if (!isProduction && vite) {
-      return await vite.ssrLoadModule(ssrEntryPath);
+  if (opts.dynamicRoutes) {
+    for (const r of opts.dynamicRoutes) {
+      if (!paths.includes(r)) paths.push(r);
     }
-    const modulePath = ssrProductionModule ?? "../dist/server/ssr.js";
-    return import(modulePath);
   }
-  app.get("*", async (c) => {
-    const url = c.req.path + (c.req.url.includes("?") ? "?" + c.req.url.split("?")[1] : "");
-    try {
-      const template = await readTemplate(url);
-      const { render, serializeServerData: serializeServerData2 } = await loadSSRModule();
-      const locale = parseAcceptLanguage(
-        c.req.header("accept-language"),
-        supportedLocales,
-        defaultLocale
-      );
-      const {
-        html: appHtml,
-        head,
-        css,
-        serverData
-      } = await render(url, locale);
-      const serializedData = serializeServerData2(serverData);
-      const finalHtml = injectSSRContent({
-        template,
-        locale,
-        head,
-        css,
-        html: appHtml,
-        serializedData
+  if (paths.length === 0) paths.push("/");
+  return paths;
+}
+function inferLocale(url, locales, defaultLocale) {
+  const segments = url.split("/").filter(Boolean);
+  if (segments.length > 0 && locales.includes(segments[0])) {
+    return segments[0];
+  }
+  return defaultLocale;
+}
+function injectSSRForStatic(template, locale, head, css, html, serializedData) {
+  return template.replace("<!--ssr-lang-->", locale).replace("<!--ssr-head-->", head + "\n<style>" + css + "</style>").replace("<!--ssr-body-->", html).replace(
+    "<!--ssr-data-->",
+    '<script id="serialized-server-data" type="application/json">' + serializedData + "</script>"
+  );
+}
+
+// ../server/src/adapters/vercel.ts
+function vercelAdapter() {
+  return {
+    name: "vercel",
+    async build(ctx) {
+      const { fs, path, root } = ctx;
+      const outputDir = path.resolve(root, ".vercel/output");
+      fs.rmSync(outputDir, { recursive: true, force: true });
+      const entrySource = generateSSREntry(ctx, {
+        platformImport: `import { handle } from "hono/vercel";`,
+        platformExport: `export default handle(app);`
       });
-      return c.html(finalHtml);
-    } catch (e) {
-      if (!isProduction && vite) {
-        vite.ssrFixStacktrace(e);
+      const tempEntry = path.resolve(root, ".vercel-entry.tmp.mjs");
+      fs.writeFileSync(tempEntry, entrySource);
+      try {
+        const funcDir = path.resolve(
+          root,
+          ".vercel/output/functions/ssr.func"
+        );
+        await buildBundle(ctx, {
+          entry: ".vercel-entry.tmp.mjs",
+          outDir: funcDir,
+          target: "node18"
+        });
+        fs.writeFileSync(
+          path.resolve(funcDir, ".vc-config.json"),
+          JSON.stringify(
+            {
+              runtime: "nodejs20.x",
+              handler: "index.mjs",
+              launcherType: "Nodejs"
+            },
+            null,
+            2
+          )
+        );
+        copyStaticAssets(
+          ctx,
+          path.resolve(root, ".vercel/output/static")
+        );
+        fs.writeFileSync(
+          path.resolve(root, ".vercel/output/config.json"),
+          JSON.stringify(
+            {
+              version: 3,
+              routes: [
+                { handle: "filesystem" },
+                { src: "/(.*)", dest: "/ssr" }
+              ]
+            },
+            null,
+            2
+          )
+        );
+      } finally {
+        fs.rmSync(tempEntry, { force: true });
       }
-      console.error("[SSR Error]", e);
-      return c.text("Internal Server Error", 500);
+      console.log("  Vercel output \u2192 .vercel/output/\n");
     }
-  });
-  return app;
+  };
+}
+
+// ../server/src/adapters/resolve.ts
+function resolveAdapter(value) {
+  if (typeof value !== "string") return value;
+  switch (value) {
+    case "vercel":
+      return vercelAdapter();
+    case "cloudflare":
+      return cloudflareAdapter();
+    case "netlify":
+      return netlifyAdapter();
+    case "node":
+      return nodeAdapter();
+    case "static":
+      return staticAdapter();
+    case "auto":
+      return autoAdapter();
+    default:
+      throw new Error(
+        `[finesoft] Unknown adapter: "${value}". Available: vercel, cloudflare, netlify, node, static, auto`
+      );
+  }
 }
 
+// ../server/src/adapters/auto.ts
+function autoAdapter() {
+  return {
+    name: "auto",
+    async build(ctx) {
+      const detected = detectPlatform();
+      console.log(`  [auto] Detected platform: ${detected}
+`);
+      const adapter = resolveAdapter(detected);
+      return adapter.build(ctx);
+    }
+  };
+}
+function detectPlatform() {
+  if (process.env.VERCEL) return "vercel";
+  if (process.env.CF_PAGES) return "cloudflare";
+  if (process.env.NETLIFY) return "netlify";
+  return "node";
+}
+
+// ../server/src/index.ts
+init_app();
+
 // ../server/src/create-server.ts
 var import_hono3 = require("hono");
+init_app();
 
 // ../server/src/runtime.ts
 function detectRuntime() {
@@ -1490,7 +2197,15 @@ async function startServer(options) {
       "path"
     );
     const prodApp = new import_hono2.Hono();
-    prodApp.use("/*", serveStatic({ root: resolve(root, "dist/client") }));
+    const clientDir = resolve(root, "dist/client");
+    prodApp.use(
+      "/*",
+      serveStatic({
+        root: clientDir,
+        // 禁止目录路径自动提供 index.html，让其 fall through 到 SSR
+        rewriteRequestPath: (path) => path.endsWith("/") ? "/__nosuchfile__" : path
+      })
+    );
     prodApp.route("/", app);
     const { serve } = await import(
       /* @vite-ignore */
@@ -1571,6 +2286,251 @@ async function createServer(config = {}) {
   });
   return { app, vite, runtime };
 }
+
+// ../server/src/index.ts
+init_locale();
+
+// ../server/src/vite-plugin.ts
+function resolveSetupFn(mod) {
+  if (typeof mod.default === "function") return mod.default;
+  if (typeof mod.setup === "function") return mod.setup;
+  const first = Object.values(mod).find((v) => typeof v === "function");
+  return first ?? null;
+}
+function finesoftFrontViteConfig(options = {}) {
+  const ssrEntry = options.ssr?.entry ?? "src/ssr.ts";
+  let root = process.cwd();
+  let resolvedCommand;
+  let resolvedResolve;
+  let resolvedCss;
+  return {
+    name: "finesoft-front",
+    config(userConfig, env) {
+      const overrides = {
+        appType: "custom"
+      };
+      if (env.command === "build" && !process.env.__FINESOFT_SUB_BUILD__) {
+        overrides.build = {
+          outDir: userConfig.build?.outDir ?? "dist/client"
+        };
+      }
+      return overrides;
+    },
+    configResolved(config) {
+      resolvedCommand = config.command;
+      resolvedResolve = config.resolve;
+      resolvedCss = config.css;
+      root = config.root;
+    },
+    // ─── Dev ───────────────────────────────────────────────
+    configureServer(server) {
+      return async () => {
+        const { Hono: HonoClass } = await import(
+          /* @vite-ignore */
+          "hono"
+        );
+        const { createSSRApp: createSSRApp2 } = await Promise.resolve().then(() => (init_app(), app_exports));
+        const { getRequestListener } = await import(
+          /* @vite-ignore */
+          "@hono/node-server"
+        );
+        const app = new HonoClass();
+        if (typeof options.setup === "function") {
+          await options.setup(app);
+        } else if (typeof options.setup === "string") {
+          const mod = await server.ssrLoadModule("/" + options.setup);
+          const fn = resolveSetupFn(mod);
+          if (fn) await fn(app);
+        }
+        const ssrApp = createSSRApp2({
+          root,
+          vite: server,
+          isProduction: false,
+          ssrEntryPath: "/" + ssrEntry,
+          supportedLocales: options.locales,
+          defaultLocale: options.defaultLocale
+        });
+        app.route("/", ssrApp);
+        const listener = getRequestListener(app.fetch);
+        server.middlewares.use((req, res) => {
+          listener(req, res);
+        });
+      };
+    },
+    // ─── Preview ───────────────────────────────────────────
+    configurePreviewServer(server) {
+      return async () => {
+        const { readFileSync } = await import(
+          /* @vite-ignore */
+          "fs"
+        );
+        const { resolve } = await import(
+          /* @vite-ignore */
+          "path"
+        );
+        const { pathToFileURL } = await import(
+          /* @vite-ignore */
+          "url"
+        );
+        const { Hono: HonoClass } = await import(
+          /* @vite-ignore */
+          "hono"
+        );
+        const { injectSSRContent: injectSSRContent2 } = await Promise.resolve().then(() => (init_src2(), src_exports));
+        const { parseAcceptLanguage: parseAcceptLanguage2 } = await Promise.resolve().then(() => (init_locale(), locale_exports));
+        const { getRequestListener } = await import(
+          /* @vite-ignore */
+          "@hono/node-server"
+        );
+        const app = new HonoClass();
+        if (typeof options.setup === "function") {
+          await options.setup(app);
+        } else if (typeof options.setup === "string") {
+          try {
+            const setupPath = pathToFileURL(
+              resolve(root, "dist/server/setup.mjs")
+            ).href;
+            const mod = await import(
+              /* @vite-ignore */
+              setupPath
+            );
+            const fn = resolveSetupFn(
+              mod
+            );
+            if (fn) await fn(app);
+          } catch {
+            console.warn(
+              "[finesoft] Could not load setup module for preview. API routes disabled."
+            );
+          }
+        }
+        const templatePath = resolve(root, "dist/client/index.html");
+        const template = readFileSync(templatePath, "utf-8");
+        const ssrPath = pathToFileURL(
+          resolve(root, "dist/server/ssr.js")
+        ).href;
+        const ssrModule = await import(
+          /* @vite-ignore */
+          ssrPath
+        );
+        app.get("*", async (c) => {
+          const url = c.req.path + (c.req.url.includes("?") ? "?" + c.req.url.split("?")[1] : "");
+          try {
+            const locale = parseAcceptLanguage2(
+              c.req.header("accept-language"),
+              options.locales,
+              options.defaultLocale
+            );
+            const {
+              html: appHtml,
+              head,
+              css,
+              serverData
+            } = await ssrModule.render(url, locale);
+            const serializedData = ssrModule.serializeServerData(serverData);
+            const finalHtml = injectSSRContent2({
+              template,
+              locale,
+              head,
+              css,
+              html: appHtml,
+              serializedData
+            });
+            return c.html(finalHtml);
+          } catch (e) {
+            console.error("[SSR Preview Error]", e);
+            return c.text("Internal Server Error", 500);
+          }
+        });
+        const listener = getRequestListener(app.fetch);
+        server.middlewares.use((req, res) => {
+          listener(req, res);
+        });
+      };
+    },
+    // ─── Build ─────────────────────────────────────────────
+    async closeBundle() {
+      if (process.env.__FINESOFT_SUB_BUILD__) return;
+      if (resolvedCommand !== "build") return;
+      process.env.__FINESOFT_SUB_BUILD__ = "1";
+      try {
+        const vite = await import(
+          /* @vite-ignore */
+          "vite"
+        );
+        const fs = await import(
+          /* @vite-ignore */
+          "fs"
+        );
+        const path = await import(
+          /* @vite-ignore */
+          "path"
+        );
+        console.log("\n  Building SSR bundle...\n");
+        await vite.build({
+          root,
+          build: {
+            ssr: ssrEntry,
+            outDir: "dist/server"
+          },
+          resolve: resolvedResolve,
+          css: resolvedCss
+        });
+        if (typeof options.setup === "string") {
+          console.log("  Building setup module...\n");
+          await vite.build({
+            root,
+            build: {
+              ssr: options.setup,
+              outDir: "dist/server",
+              emptyOutDir: false,
+              rollupOptions: {
+                output: { entryFileNames: "setup.mjs" }
+              }
+            },
+            resolve: resolvedResolve
+          });
+        }
+        if (options.adapter) {
+          const adapter = resolveAdapter(options.adapter);
+          const locales = options.locales ?? ["zh", "en"];
+          const defaultLocale = options.defaultLocale ?? locales[0] ?? "en";
+          const templateHtml = fs.readFileSync(
+            path.resolve(root, "dist/client/index.html"),
+            "utf-8"
+          );
+          const ctx = {
+            root,
+            ssrEntry,
+            setupPath: typeof options.setup === "string" ? options.setup : void 0,
+            locales,
+            defaultLocale,
+            templateHtml,
+            resolvedResolve,
+            resolvedCss,
+            vite,
+            fs,
+            path,
+            generateSSREntry(opts) {
+              return generateSSREntry(ctx, opts);
+            },
+            buildBundle(opts) {
+              return buildBundle(ctx, opts);
+            },
+            copyStaticAssets(destDir, opts) {
+              return copyStaticAssets(ctx, destDir, opts);
+            }
+          };
+          console.log(`  Running adapter: ${adapter.name}...
+`);
+          await adapter.build(ctx);
+        }
+      } finally {
+        delete process.env.__FINESOFT_SUB_BUILD__;
+      }
+    }
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ACTION_KINDS,
@@ -1592,7 +2552,9 @@ async function createServer(config = {}) {
   PrefetchedIntents,
   Router,
   SSR_PLACEHOLDERS,
+  autoAdapter,
   buildUrl,
+  cloudflareAdapter,
   createPrefetchedIntentsFromDom,
   createSSRApp,
   createSSRRender,
@@ -1600,6 +2562,7 @@ async function createServer(config = {}) {
   defineRoutes,
   deserializeServerData,
   detectRuntime,
+  finesoftFrontViteConfig,
   generateUuid,
   getBaseUrl,
   injectSSRContent,
@@ -1612,6 +2575,8 @@ async function createServer(config = {}) {
   makeExternalUrlAction,
   makeFlowAction,
   mapEach,
+  netlifyAdapter,
+  nodeAdapter,
   parseAcceptLanguage,
   pipe,
   pipeAsync,
@@ -1622,6 +2587,7 @@ async function createServer(config = {}) {
   removeQueryParams,
   removeScheme,
   resetFilterCache,
+  resolveAdapter,
   resolveRoot,
   serializeServerData,
   shouldLog,
@@ -1629,6 +2595,8 @@ async function createServer(config = {}) {
   stableStringify,
   startBrowserApp,
   startServer,
-  tryScroll
+  staticAdapter,
+  tryScroll,
+  vercelAdapter
 });
 //# sourceMappingURL=index.cjs.map