@finesoft/front 0.1.1 → 0.1.3

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,45 +17,1522 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  History: () => import_browser.History,
-  createPrefetchedIntentsFromDom: () => import_browser.createPrefetchedIntentsFromDom,
-  createSSRRender: () => import_ssr.createSSRRender,
-  deserializeServerData: () => import_browser.deserializeServerData,
-  injectSSRContent: () => import_ssr.injectSSRContent,
-  registerActionHandlers: () => import_browser.registerActionHandlers,
-  registerExternalUrlHandler: () => import_browser.registerExternalUrlHandler,
-  registerFlowActionHandler: () => import_browser.registerFlowActionHandler,
-  serializeServerData: () => import_ssr.serializeServerData,
-  ssrRender: () => import_ssr.ssrRender,
-  startBrowserApp: () => import_browser.startBrowserApp,
-  tryScroll: () => import_browser.tryScroll
+  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,
+  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);
-__reExport(index_exports, require("@finesoft/core"), module.exports);
-var import_browser = require("@finesoft/browser");
-var import_ssr = require("@finesoft/ssr");
-__reExport(index_exports, require("@finesoft/server"), module.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;
+}
+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 };
+}
+
+// ../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);
+      }
+      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);
+  }
+};
+
+// ../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();
+      }
+      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;
+  }
+};
+
+// ../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 {};
+  }
+  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;
+}
+
+// ../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);
+  }
+};
+
+// ../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),
+    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);
+}
+
+// ../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;
+        });
+        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 = 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 "";
+  }
+};
+
+// ../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(",") + "}";
+}
+
+// ../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);
+      }
+    }
+    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 = 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();
+  }
+};
+
+// ../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();
+  }
+  /** 构建完整 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}`;
+  }
+};
+
+// ../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 ?? {};
+    try {
+      return await this.execute(params, container);
+    } catch (e) {
+      return this.fallback(
+        params,
+        e instanceof Error ? e : new Error(String(e))
+      );
+    }
+  }
+};
+
+// ../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);
+      }
+    }
+    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];
+}
+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;
+}
+
+// ../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);
+  });
+}
+
+// ../browser/src/action-handlers/external-url-action.ts
+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");
+    }
+  );
+}
+
+// ../browser/src/utils/try-scroll.ts
+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;
+  });
+}
+
+// ../browser/src/utils/history.ts
+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;
+    }
+  }
+};
+
+// ../browser/src/action-handlers/flow-action.ts
+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);
+      }
+    })();
+  }
+}
+
+// ../browser/src/action-handlers/register.ts
+function registerActionHandlers(deps) {
+  const { framework, log, callbacks, updateApp } = deps;
+  registerFlowActionHandler({
+    framework,
+    log,
+    callbacks,
+    updateApp
+  });
+  registerExternalUrlHandler({ framework, log });
+}
+
+// ../browser/src/server-data.ts
+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);
+}
+
+// ../browser/src/start-app.ts
+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
+    });
+  }
+}
+
+// ../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
+  };
+}
+
+// ../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)
+  });
+}
+
+// ../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-lang-->", locale).replace("<!--ssr-head-->", `${head}
+${cssTag}`).replace("<!--ssr-body-->", html).replace("<!--ssr-data-->", serializedData);
+}
+
+// ../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/app.ts
+var import_hono = require("hono");
+
+// ../server/src/locale.ts
+var DEFAULT_SUPPORTED = ["zh", "en"];
+var DEFAULT_LOCALE = "en";
+function parseAcceptLanguage(header, supported = DEFAULT_SUPPORTED, fallback = DEFAULT_LOCALE) {
+  if (!header) return fallback;
+  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 (supported.includes(prefix)) {
+      return prefix;
+    }
+  }
+  return fallback;
+}
+
+// ../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("fs");
+      const { resolve: resolve2 } = await import("path");
+      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 { readFileSync } = await import("fs");
+    const { resolve } = await import("path");
+    return readFileSync(resolve(root, "dist/client/index.html"), "utf-8");
+  }
+  async function loadSSRModule() {
+    if (!isProduction && vite) {
+      return await vite.ssrLoadModule(ssrEntryPath);
+    }
+    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
+      });
+      return c.html(finalHtml);
+    } catch (e) {
+      if (!isProduction && vite) {
+        vite.ssrFixStacktrace(e);
+      }
+      console.error("[SSR Error]", e);
+      return c.text("Internal Server Error", 500);
+    }
+  });
+  return app;
+}
+
+// ../server/src/create-server.ts
+var import_hono3 = require("hono");
+
+// ../server/src/runtime.ts
+function detectRuntime() {
+  return {
+    isDeno: typeof globalThis.Deno !== "undefined",
+    isBun: typeof globalThis.Bun !== "undefined",
+    isVercel: !!process.env.VERCEL,
+    isProduction: process.env.NODE_ENV === "production"
+  };
+}
+async function resolveRoot(importMetaUrl, levelsUp = 0) {
+  const isDeno = typeof globalThis.Deno !== "undefined";
+  if (isDeno) {
+    let url = new URL(importMetaUrl);
+    for (let i = 0; i < levelsUp; i++) {
+      url = new URL("..", url);
+    }
+    return url.pathname;
+  }
+  const { dirname, resolve, normalize } = await import("path");
+  const { fileURLToPath } = await import("url");
+  let dir = normalize(dirname(fileURLToPath(importMetaUrl)));
+  for (let i = 0; i < levelsUp; i++) {
+    dir = resolve(dir, "..");
+  }
+  return dir;
+}
+
+// ../server/src/start.ts
+var import_hono2 = require("hono");
+async function startServer(options) {
+  const { app, root, port = 3e3, isProduction, vite } = options;
+  const { isDeno, isBun, isVercel } = options.runtime ?? detectRuntime();
+  if (isVercel) {
+    return { vite };
+  }
+  if (!isProduction) {
+    let devVite = vite;
+    if (!devVite) {
+      const { createServer: createViteServer } = await import("vite");
+      devVite = await createViteServer({
+        root,
+        server: { middlewareMode: true },
+        appType: "custom"
+      });
+    }
+    const { getRequestListener } = await import("@hono/node-server");
+    const { createServer: createServer2 } = await import("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}
+`);
+    });
+    return { vite: devVite };
+  }
+  if (isDeno) {
+    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 prodApp = new import_hono2.Hono();
+    prodApp.use("/*", serveStatic({ root: resolve(root, "dist/client") }));
+    prodApp.route("/", app);
+    const { serve } = await import("@hono/node-server");
+    serve({ fetch: prodApp.fetch, port }, () => {
+      console.log(`
+  Server running at http://localhost:${port}
+`);
+    });
+  }
+  return { vite };
+}
+
+// ../server/src/create-server.ts
+async function createServer(config = {}) {
+  const {
+    root: rootOverride,
+    locales,
+    defaultLocale,
+    port = Number(process.env.PORT) || 3e3,
+    setup,
+    ssr
+  } = config;
+  const root = rootOverride ?? process.cwd();
+  const { existsSync } = await import("fs");
+  const { resolve } = await import("path");
+  const envPath = resolve(root, ".env");
+  if (existsSync(envPath)) {
+    try {
+      const { config: dotenvConfig } = await import("dotenv");
+      dotenvConfig({ path: envPath });
+    } catch {
+    }
+  }
+  const runtime = detectRuntime();
+  let vite;
+  if (!runtime.isProduction && !runtime.isVercel) {
+    const { createServer: createViteServer } = await import("vite");
+    vite = await createViteServer({
+      root,
+      server: { middlewareMode: true },
+      appType: "custom"
+    });
+  }
+  const app = new import_hono3.Hono();
+  if (setup) {
+    await setup(app);
+  }
+  const ssrApp = createSSRApp({
+    root,
+    vite,
+    isProduction: runtime.isProduction,
+    supportedLocales: locales,
+    defaultLocale,
+    ...ssr
+  });
+  app.route("/", ssrApp);
+  await startServer({
+    app,
+    root,
+    port,
+    isProduction: runtime.isProduction,
+    vite,
+    runtime
+  });
+  return { app, vite, runtime };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ACTION_KINDS,
+  ActionDispatcher,
+  BaseController,
+  BaseLogger,
+  CompositeLogger,
+  CompositeLoggerFactory,
+  ConsoleLogger,
+  ConsoleLoggerFactory,
+  Container,
+  DEP_KEYS,
+  Framework,
   History,
+  HttpClient,
+  HttpError,
+  IntentDispatcher,
+  LruMap,
+  PrefetchedIntents,
+  Router,
+  buildUrl,
   createPrefetchedIntentsFromDom,
+  createSSRApp,
   createSSRRender,
+  createServer,
+  defineRoutes,
   deserializeServerData,
+  detectRuntime,
+  generateUuid,
+  getBaseUrl,
   injectSSRContent,
+  isCompoundAction,
+  isExternalUrlAction,
+  isFlowAction,
+  isNone,
+  isSome,
+  makeDependencies,
+  makeExternalUrlAction,
+  makeFlowAction,
+  mapEach,
+  parseAcceptLanguage,
+  pipe,
+  pipeAsync,
   registerActionHandlers,
   registerExternalUrlHandler,
   registerFlowActionHandler,
+  removeHost,
+  removeQueryParams,
+  removeScheme,
+  resetFilterCache,
+  resolveRoot,
   serializeServerData,
+  shouldLog,
   ssrRender,
+  stableStringify,
   startBrowserApp,
-  tryScroll,
-  ...require("@finesoft/core"),
-  ...require("@finesoft/server")
+  startServer,
+  tryScroll
 });
 //# sourceMappingURL=index.cjs.map